@solidjs/signals 2.0.0-rc.8 → 2.0.0-rc.9

package/dist/observe/store/next/projection.js

@@ -12,6 +12,8 @@ import "../../core/effect.js";
 
 import { CONFIG_AUTO_DISPOSE } from "../../core/constants.js";
 
+import "../../core/dev.js";
+
 import { $TARGET, STORE_VALUE, markRawIngest, setWriteOverride } from "../store.js";
 
 import { reconcileNextState } from "./reconcile.js";
@@ -55,22 +57,23 @@ import { storeSetterNext, wrapNext } from "./store.js";
  * Save/restore projectionWriteActive, never hard-reset: the draft can be
  * driven from inside an enclosing authoritative-write scope (next-store
  * optimistic derives), and a hard `false` would clobber it mid-derive.
- */ function wrapDraft(e, t, r) {
+ */ function wrapDraft(e, t, r, i) {
     const write = e => r ? r(e) : e();
-    const i = {
-        get(i, o) {
-            let n;
-            const c = projectionWriteActive;
+    const o = {
+        get(o, n) {
+            let c;
+            const s = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                n = e[o];
+                c = e[n];
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(c);
+                setProjectionWriteActive(s);
             }
-            if (o === $TARGET) return n;
-            return typeof n === "object" && n !== null ? wrapDraft(n, t, r) : n;
+            // A shallow store's leaves are raw by contract (#3498): no draft proxy
+            // over them, so identity holds and a frozen leaf is never trapped.
+                        return !i && typeof c === "object" && c !== null && n !== $TARGET ? wrapDraft(c, t, r) : c;
         },
         has(t, r) {
             let i;
@@ -160,7 +163,7 @@ import { storeSetterNext, wrapNext } from "./store.js";
         }
     };
     // Matching-kind dummy so Array.isArray(draft) answers like the store.
-        return new Proxy(Array.isArray(e) ? [] : {}, i);
+        return new Proxy(Array.isArray(e) ? [] : {}, o);
 }
 
 function createProjectionNextInternal(e, t, r) {
@@ -188,7 +191,7 @@ function createProjectionNextInternal(e, t, r) {
         if (!i.node) i.node = getOwner();
         runProjectionComputedNext(o, e, r?.key === undefined ? "id" : r.key);
     }, n);
-    c.T &= ~CONFIG_AUTO_DISPOSE;
+    c.C &= ~CONFIG_AUTO_DISPOSE;
     i.node = c;
     return {
         store: o,
@@ -211,30 +214,40 @@ function createProjectionNext(e, t, r) {
     } ];
 }
 
+// A detached copy of projection state: the root container alone for a shallow
+// store — its leaves are raw references by contract and stay so (#3498) — the
+// whole tree otherwise.
+function cloneState(e, t) {
+    return t ? Array.isArray(e) ? e.slice() : {
+        ...e
+    } : JSON.parse(JSON.stringify(e));
+}
+
 function runProjectionComputedNext(e, t, r, i, o) {
     const n = getOwner();
-    let c = false;
-    let s;
+    const c = e[$TARGET];
+    let s = false;
+    let u;
     // Open loading window (seedLoadingValue): the observable store IS commit #0
     // for the whole first flight — the derive works a detached shadow of the
     // seed so draft writes cannot tear through to readers (#2988). Every commit
     // point reconciles the shadow through the normal commit path.
-        const u = n.de ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
-    const l = wrapDraft(e, () => !c || n.o?.Se === s, o);
-    storeSetterNext(l, o => {
-        s = t(u ?? o);
-        c = true;
+        const l = n.Se ? cloneState(c[STORE_VALUE], c.s) : null;
+    const a = wrapDraft(e, () => !s || n.o?.ce === u, o, c.s);
+    storeSetterNext(a, o => {
+        u = t(l ?? o);
+        s = true;
         const commit = t => {
             // Shadow run: commit a detached snapshot, never the shadow itself
             // (adoption takes the value by identity — handing it the live shadow
             // would fuse the draft to the observable store).
-            if (u && (t === undefined || t === u)) t = JSON.parse(JSON.stringify(u));
+            if (l && (t === undefined || t === l)) t = cloneState(l, c.s);
             if (t === o || t === undefined) return;
             const write = () => storeSetterNext(e, e => reconcileNextState(t, e, r, true), false);
             i ? i(write, t) : write();
         };
-        const l = handleAsync(n, s, commit);
-        if (!n.de) commit(l);
+        const a = handleAsync(n, u, commit);
+        if (!n.Se) commit(a);
     }, false);
     return n;
 }

package/dist/observe/store/next/reconcile.js

@@ -1,5 +1,7 @@
 import { isEqual } from "../../core/core.js";
 
+import "../../core/dev.js";
+
 import { projectionWriteActive } from "../../core/scheduler.js";
 
 import "../../core/invariants.js";
@@ -35,46 +37,46 @@ import { isOwned, $OWNER, storeNextLookup, optHooks, lookupTarget } from "./targ
  *   members (R11). Kind changes replace wholesale (R10).
  */ function reconcileNextState(e, t, n, o = false) {
     if (t == null) throw new Error("");
-    const f = t?.[$TARGET];
-    if (f === undefined || f.px !== t) throw new Error("");
+    const i = t?.[$TARGET];
+    if (i === undefined || i.px !== t) throw new Error("");
     // Reconcile's diff walks need a REAL pending container — a prototype
     // overlay (#3044) materializes to the clone path first (edge: reconcile
     // inside a setter that already wrote this target).
-        if (f.ovl) materializePB(f);
-    let i = n === null ? null : typeof n === "string" ? e => e?.[n] : n;
+        if (i.ovl) materializePB(i);
+    let f = n === null ? null : typeof n === "string" ? e => e?.[n] : n;
     // §7b chained backing: a projection derive returning a LIVE store proxy
     // adopts the proxy itself as the backing — reads flow through the inner
     // store's traps, so consumers subscribe to the inner graph and updates
     // flow with no re-derive (#2941). The adoption diff still notifies THIS
     // store's existing subscribers of the swap.
         if (o && e !== t && e?.[$TARGET] !== undefined) {
-        const t = f.pb ?? f.v;
+        const t = i.pb ?? i.v;
         if (t === e) return;
  // already chained to this store
-                adoptPB(f, e);
+                adoptPB(i, e);
         return;
     }
     const l = unwrapValue(e);
-    if (i) {
+    if (f) {
         // Root identity precondition — checked before ANY mutation, so a throwing
         // reconcile is atomic by construction (RUL-12 ruling). Projections
         // (replace=true) relax it: a root entity change merges in place — the
         // root proxy is stable for life (proj R5/R11) — and children are NOT
         // key-matched across the entity change (proj R7: keyFn drops to
         // positional so old-entity subtrees never merge into the new entity's).
-        const e = f.pb ?? f.v;
-        const t = i(e);
-        if (t !== undefined && !sameKey(i(l), t)) {
+        const e = i.pb ?? i.v;
+        const t = f(e);
+        if (t !== undefined && !sameKey(f(l), t)) {
             if (!o) throw new Error("");
             // Entity change: wholesale swap. The root proxy is stable for life
             // (proj R5) but NOTHING below survives — children are never matched
             // across an entity change even when their own keys align (proj R7).
             // Displaced-raw unregistration (proj R10): the outgoing raw stops
             // resolving to this proxy; re-handed later it wraps fresh.
-                        const e = f.pb ?? f.v;
+                        const e = i.pb ?? i.v;
             if (isOwned(e)) delete e[$OWNER]; // disown: wraps fresh if re-handed
-             else (f.fam?.map ?? storeNextLookup).delete(e);
-            adoptPB(f, l);
+             else (i.fam?.map ?? storeNextLookup).delete(e);
+            adoptPB(i, l);
             return;
         }
     }
@@ -83,35 +85,35 @@ import { isOwned, $OWNER, storeNextLookup, optHooks, lookupTarget } from "./targ
     // armed nodes (reverting with their transaction); committed raw is never
     // touched. Key-matched rows keep proxy identity by descending into the
     // existing child targets instead of overriding their parent slots.
-        if (f.fam?.opt === true && !projectionWriteActive && !getWriteOverride()) {
-        optHooks.applyTentative(f, l, i);
+        if (i.fam?.opt === true && !projectionWriteActive && !getWriteOverride()) {
+        optHooks.applyTentative(i, l, f);
         return;
     }
-    applyAdopt(f, l, i, o);
+    applyAdopt(i, l, f, o);
 }
 
 function applyAdopt(e, t, n, o = false) {
-    const f = e.pb ?? e.v;
+    const i = e.pb ?? e.v;
     // The sound identity skip (O7): same reference AND we never diverged it.
-        if (t === f && !isOwned(f)) return;
-    const i = e.fam;
+        if (t === i && !isOwned(i)) return;
+    const f = e.fam;
     // §6b (R28): the diff's previous-arrangement baseline is the LANE VIEW —
     // optimistic rows must be visible to key matching so a landing carrying the
     // same key recycles their proxies. Raw `prev` keeps the identity/ownership
     // roles above; only matching reads the view.
-        const l = i?.opt === true ? optHooks.optimisticView(e, f) : f;
+        const l = f?.opt === true ? optHooks.optimisticView(e, i) : i;
     const r = Array.isArray(t);
     // Plain stores notify inline AFTER the descent (child registrations feed
     // the fold diff's identity-preservation check); projections keep deferred
     // folds (downstream holds can form later in the flush).
-        const s = i === null;
+        const s = f === null;
     const u = e.s === true;
     // Node-notify base is the view the nodes were last told (#3296): a draft
     // preceding this reconcile already moved them to its pending backing at
     // setter exit (prev, materialized above), so diffing incoming against the
     // committed backing would skip a key the draft changed and the reconcile
     // restores — the node would commit the superseded draft value.
-        const a = f;
+        const a = i;
     adoptPB(e, t, s);
     // Shallow adoption: records are slot values — sticky raw-mark the incoming
     // set (R41) and never descend; slot notification is the positional diff.
@@ -121,7 +123,7 @@ function applyAdopt(e, t, n, o = false) {
         return;
     }
     if (r) {
-        const f = l;
+        const i = l;
         const r = t;
         // Fused array walk (eager mode): per-index notification rides the same
         // loop as the descent (descend first — targetsEqual needs the child's
@@ -134,13 +136,13 @@ function applyAdopt(e, t, n, o = false) {
             // rows key-match in place — the steady-state polling shape — descend
             // directly with zero staging. The prevByKey map is built only for the
             // misaligned remainder, and never at all on aligned ticks.
-            const l = f.length;
+            const l = i.length;
             const s = r.length;
             let u = false;
             let p = 0;
             for (const y = Math.min(l, s); p < y; p++) {
                 const l = r[p];
-                const s = f[p];
+                const s = i[p];
                 // Routing heuristic only (aligned vs keyed remainder) — both routes
                 // notify identically and descend() is the one authoritative
                 // validator, so bare typeof gates suffice here; full isWrappable
@@ -148,7 +150,7 @@ function applyAdopt(e, t, n, o = false) {
                                 if (s !== l && !(s !== null && typeof s === "object" && l !== null && typeof l === "object" && sameKey(n(s), n(l)))) break;
  // misaligned: fall to the keyed remainder below
                 // Identity skip inline (FINDING-1 guard), then descend the pair.
-                                if ((s !== l || l !== null && typeof l === "object" && isOwned(l)) && l !== null && typeof l === "object") descend(unwrapValue(s), l, n, i, o);
+                                if ((s !== l || l !== null && typeof l === "object" && isOwned(l)) && l !== null && typeof l === "object") descend(unwrapValue(s), l, n, f, o);
                 if (e.dk !== null && !u && !(l !== null && typeof l === "object" ? targetsEqual(s, l) : isEqual(s, l))) {
                     bumpDeep(e);
                     u = true;
@@ -185,29 +187,29 @@ function applyAdopt(e, t, n, o = false) {
                             // them here let a duplicate key adopt a prefix row AGAIN while
                             // row ops (which correctly window from structStart) retained
                             // the later occurrence's DOM row against a never-adopted target.
-                                                        for (let e = y; e < f.length; e++) {
-                                const t = unwrapValue(f[e]);
+                                                        for (let e = y; e < i.length; e++) {
+                                const t = unwrapValue(i[e]);
                                 if (t !== null && typeof t === "object") {
                                     const o = n(t);
                                     if (o === undefined) continue;
-                                    const f = w.get(o);
-                                    if (f === undefined) w.set(o, e); else if (Array.isArray(f)) f.push(e); else w.set(o, [ f, e ]);
+                                    const i = w.get(o);
+                                    if (i === undefined) w.set(o, e); else if (Array.isArray(i)) i.push(e); else w.set(o, [ i, e ]);
                                 }
                             }
                         }
                         const e = w.get(t);
                         if (e === undefined) l = undefined; else if (Array.isArray(e)) {
-                            l = unwrapValue(f[e.shift()]);
+                            l = unwrapValue(i[e.shift()]);
                             if (e.length === 1) w.set(t, e[0]);
                         } else {
-                            l = unwrapValue(f[e]);
+                            l = unwrapValue(i[e]);
                             w.delete(t);
                         }
                     } else {
-                        l = unwrapValue(f[p]);
+                        l = unwrapValue(i[p]);
  // keyless item: positional fallback
                                         }
-                    descend(l, e, n, i, o);
+                    descend(l, e, n, f, o);
                 }
                 if (c !== null) {
                     const e = c[p];
@@ -218,13 +220,13 @@ function applyAdopt(e, t, n, o = false) {
                 }
             }
         } else {
-            const l = Math.min(f.length, r.length);
+            const l = Math.min(i.length, r.length);
             const s = r.length;
             let p = false;
             for (let y = 0; y < s; y++) {
                 const s = r[y];
-                if (!u && y < l && s !== null && typeof s === "object") descend(unwrapValue(f[y]), s, n, i, o);
-                if (e.dk !== null && !p && !(s !== null && typeof s === "object" ? targetsEqual(f[y], s) : isEqual(f[y], s))) {
+                if (!u && y < l && s !== null && typeof s === "object") descend(unwrapValue(i[y]), s, n, f, o);
+                if (e.dk !== null && !p && !(s !== null && typeof s === "object" ? targetsEqual(i[y], s) : isEqual(i[y], s))) {
                     bumpDeep(e);
                     p = true;
                 }
@@ -255,7 +257,7 @@ function applyAdopt(e, t, n, o = false) {
         // slots must not notify, R9). This replaces the notifyFold re-walk that
         // doubled dbmon's diff cost. for-in covers own enumerable string keys
         // with no key-array allocation; symbols get a pass only when present.
-        const f = s ? e.n : null;
+        const i = s ? e.n : null;
         let r = 0;
         let c = false;
         // The per-key body is inlined on purpose (legacy applyStateFast parity:
@@ -267,11 +269,11 @@ function applyAdopt(e, t, n, o = false) {
             const d = t[s];
             const p = a[s];
             const y = d !== null && typeof d === "object";
-            if (p === d && (!y || !isOwned(d)) && (f === null || f[s] === undefined || !hasAccessorFlag(f[s]))) {
-                if (f !== null && f[s] !== undefined) r++;
+            if (p === d && (!y || !isOwned(d)) && (i === null || i[s] === undefined || !hasAccessorFlag(i[s]))) {
+                if (i !== null && i[s] !== undefined) r++;
                 continue;
             }
-            if (y && !u) descend(unwrapValue(l[s]), d, n, i, o);
+            if (y && !u) descend(unwrapValue(l[s]), d, n, f, o);
             // Deep-witness (dk): value changes must notify even with NO per-key
             // node — deep() subscribes one node per record. Checked after descend
             // so in-place adoptions (same logical slot) don't bump; child records
@@ -280,8 +282,8 @@ function applyAdopt(e, t, n, o = false) {
                 bumpDeep(e);
                 c = true;
             }
-            if (f !== null) {
-                const e = f[s];
+            if (i !== null) {
+                const e = i[s];
                 if (e !== undefined) {
                     r++;
                     notifyKeyValue(e, s, p, d, a, t);
@@ -293,9 +295,9 @@ function applyAdopt(e, t, n, o = false) {
             const s = d[e];
             if (s === $OWNER) continue;
             const c = t[s];
-            if (!u && c !== null && typeof c === "object") descend(unwrapValue(l[s]), c, n, i, o);
-            if (f !== null) {
-                const e = f[s];
+            if (!u && c !== null && typeof c === "object") descend(unwrapValue(l[s]), c, n, f, o);
+            if (i !== null) {
+                const e = i[s];
                 if (e !== undefined) {
                     r++;
                     notifyKeyValue(e, s, a[s], c, a, t);
@@ -305,9 +307,9 @@ function applyAdopt(e, t, n, o = false) {
         if (s) {
             // Deleted-key nodes (in the map but absent from incoming) — counted
             // fast-out: when every node was visited, skip the sweep entirely.
-            if (f !== null && r < e.nc) {
-                for (const e of Reflect.ownKeys(f)) {
-                    if (!hasOwnP.call(t, e)) notifyKeyDiff(f[e], e, a, t, false);
+            if (i !== null && r < e.nc) {
+                for (const e of Reflect.ownKeys(i)) {
+                    if (!hasOwnP.call(t, e)) notifyKeyDiff(i[e], e, a, t, false);
                 }
             }
             notifyFoldTail(e, a, t);
@@ -327,14 +329,14 @@ const hasOwnP = Object.prototype.hasOwnProperty;
     return e === t || e !== e && t !== t;
 }
 
-function descend(e, t, n, o, f = false) {
+function descend(e, t, n, o, i = false) {
     if (e === null || typeof e !== "object" || t === null || typeof t !== "object") return;
     // Lookup FIRST: a hit implies pv was wrappable and never raw-marked (only
     // wrappables acquire targets; rawValues never wrap) — one WeakMap get
     // replaces isWrappable(pv) + isRawValue(pv), and a miss prunes untracked
     // subtrees before any further checks.
-        const i = lookupTarget(e, o);
-    if (i === undefined) return;
+        const f = lookupTarget(e, o);
+    if (f === undefined) return;
  // nothing proxied below this pair
     // The NEW side still validates fully: a frozen/platform/markRaw'd incoming
     // value is a leaf for reconcile — replaced by reference, never recursed
@@ -348,13 +350,13 @@ function descend(e, t, n, o, f = false) {
         if (Array.isArray(e) !== Array.isArray(t)) return;
     if (n) {
         const o = n(e);
-        const f = n(t);
+        const i = n(t);
         // Key mismatch detaches: the slot takes the new entity; the old proxy
         // keeps its (old) backing and a fresh proxy wraps the new value on read.
         // SameValueZero (re-audit 2, P1-5): NaN keys are self-equal — strict
         // inequality detached every NaN-keyed slot on every tick while the
         // Map-based row-ops matcher retained its DOM row (stale forever).
-                if (o !== undefined && f !== undefined && !sameKey(o, f)) return;
+                if (o !== undefined && i !== undefined && !sameKey(o, i)) return;
     }
     // Reachability pruning (§6d) is MODE-dependent, both pinned:
     // - keyed matching descends only where subscriptions exist at/below (`d`) —
@@ -366,8 +368,8 @@ function descend(e, t, n, o, f = false) {
     // UNCONDITIONALLY (proj R6: the slot keeps its proxy without needing a
     // subscriber below); plain keyed reconcile detaches unobserved captures
     // (recon-snap R18 — staleness is the pinned pruning contract).
-        if (!f && n !== null && !i.d) return;
-    applyAdopt(i, t, n, f);
+        if (!i && n !== null && !f.d) return;
+    applyAdopt(f, t, n, i);
 }
 
 export { reconcileNextState, sameKey };