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

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

@@ -12,7 +12,7 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue, getWrit
 
 import { materializePB, adoptPB, unwrapValue, notifyFold, targetsEqual, bumpDeep, notifyKeyValue, notifyKeyDiff, notifyFoldTail, hasAccessorFlag } from "./store.js";
 
-import { storeNextLookup, optHooks, ownedRaw } from "./target.js";
+import { isOwned, $OWNER, storeNextLookup, optHooks, lookupTarget } from "./target.js";
 
 /**
  * Store rewrite — reconcile, the adoption channel (INTERNALS-STORE-STATE.md
@@ -41,7 +41,7 @@ import { storeNextLookup, optHooks, ownedRaw } from "./target.js";
     // overlay (#3044) materializes to the clone path first (edge: reconcile
     // inside a setter that already wrote this target).
         if (f.ovl) materializePB(f);
-    let l = n === null ? null : typeof n === "string" ? e => e?.[n] : n;
+    let i = 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
@@ -54,8 +54,8 @@ import { storeNextLookup, optHooks, ownedRaw } from "./target.js";
                 adoptPB(f, e);
         return;
     }
-    const i = unwrapValue(e);
-    if (l) {
+    const l = unwrapValue(e);
+    if (i) {
         // 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
@@ -63,16 +63,18 @@ import { storeNextLookup, optHooks, ownedRaw } from "./target.js";
         // 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 = l(e);
-        if (t !== undefined && !sameKey(l(i), t)) {
+        const t = i(e);
+        if (t !== undefined && !sameKey(i(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.
-                        (f.fam?.map ?? storeNextLookup).delete(f.pb ?? f.v);
-            adoptPB(f, i);
+                        const e = f.pb ?? f.v;
+            if (isOwned(e)) delete e[$OWNER]; // disown: wraps fresh if re-handed
+             else (f.fam?.map ?? storeNextLookup).delete(e);
+            adoptPB(f, l);
             return;
         }
     }
@@ -82,93 +84,93 @@ import { storeNextLookup, optHooks, ownedRaw } from "./target.js";
     // 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, i, l);
+        optHooks.applyTentative(f, l, i);
         return;
     }
-    applyAdopt(f, i, l, o);
+    applyAdopt(f, l, i, o);
 }
 
 function applyAdopt(e, t, n, o = false) {
     const f = e.pb ?? e.v;
     // The sound identity skip (O7): same reference AND we never diverged it.
-        if (t === f && !ownedRaw.has(f)) return;
-    const l = e.fam;
+        if (t === f && !isOwned(f)) return;
+    const i = 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 i = l?.opt === true ? optHooks.optimisticView(e, f) : f;
+        const l = i?.opt === true ? optHooks.optimisticView(e, f) : f;
     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 u = l === null;
-    const s = e.s === true;
+        const s = i === 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;
-    adoptPB(e, t, u);
+    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.
-        if (s) markRawIngest(t);
-    if (Array.isArray(i) !== r) {
-        if (u) notifyFold(e, a, t);
+        if (u) markRawIngest(t);
+    if (Array.isArray(l) !== r) {
+        if (s) notifyFold(e, a, t);
         return;
     }
     if (r) {
-        const f = i;
+        const f = 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
         // re-registration, R9). Length, trailing removed indexes, and any other
         // unvisited node keys land in the counted sweep below.
-                const c = u ? e.n : null;
-        let p = 0;
-        if (n && !s) {
+                const c = s ? e.n : null;
+        let d = 0;
+        if (n && !u) {
             // Positional-prefix fast path (legacy keyedMatch-walk parity): while
             // 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 i = f.length;
-            const u = r.length;
-            let s = false;
-            let d = 0;
-            for (const y = Math.min(i, u); d < y; d++) {
-                const i = r[d];
-                const u = f[d];
+            const l = f.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];
                 // 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
                 // per row was the walk's dominant residual cost.
-                                if (u !== i && !(u !== null && typeof u === "object" && i !== null && typeof i === "object" && sameKey(n(u), n(i)))) break;
+                                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 ((u !== i || i !== null && typeof i === "object" && ownedRaw.has(i)) && i !== null && typeof i === "object") descend(unwrapValue(u), i, n, l, o);
-                if (e.dk !== null && !s && !(i !== null && typeof i === "object" ? targetsEqual(u, i) : isEqual(u, i))) {
+                                if ((s !== l || l !== null && typeof l === "object" && isOwned(l)) && l !== null && typeof l === "object") descend(unwrapValue(s), l, n, i, o);
+                if (e.dk !== null && !u && !(l !== null && typeof l === "object" ? targetsEqual(s, l) : isEqual(s, l))) {
                     bumpDeep(e);
-                    s = true;
+                    u = true;
                 }
                 if (c !== null) {
-                    const e = c[d];
+                    const e = c[p];
                     if (e !== undefined) {
-                        p++;
-                        notifyKeyValue(e, d, a[d], i, a, t);
+                        d++;
+                        notifyKeyValue(e, p, a[p], l, a, t);
                     }
                 }
             }
-            if (e.dk !== null && !s && d < r.length) bumpDeep(e);
-            const y = d;
+            if (e.dk !== null && !u && p < r.length) bumpDeep(e);
+            const y = p;
  // misalignment point (== nlen on aligned ticks)
                         let w = null;
-            for (;d < r.length; d++) {
-                const e = r[d];
+            for (;p < r.length; p++) {
+                const e = r[p];
                 // typeof gates route; descend validates (same contract as the prefix).
                                 if (e !== null && typeof e === "object") {
                     const t = n(e);
-                    let i;
+                    let l;
                     if (t !== undefined) {
                         if (w === null) {
                             // Occurrence-aware (re-audit 2, P1-5): duplicate keys queue
@@ -194,49 +196,49 @@ function applyAdopt(e, t, n, o = false) {
                             }
                         }
                         const e = w.get(t);
-                        if (e === undefined) i = undefined; else if (Array.isArray(e)) {
-                            i = unwrapValue(f[e.shift()]);
+                        if (e === undefined) l = undefined; else if (Array.isArray(e)) {
+                            l = unwrapValue(f[e.shift()]);
                             if (e.length === 1) w.set(t, e[0]);
                         } else {
-                            i = unwrapValue(f[e]);
+                            l = unwrapValue(f[e]);
                             w.delete(t);
                         }
                     } else {
-                        i = unwrapValue(f[d]);
+                        l = unwrapValue(f[p]);
  // keyless item: positional fallback
                                         }
-                    descend(i, e, n, l, o);
+                    descend(l, e, n, i, o);
                 }
                 if (c !== null) {
-                    const e = c[d];
+                    const e = c[p];
                     if (e !== undefined) {
-                        p++;
-                        notifyKeyDiff(e, d, a, t, false);
+                        d++;
+                        notifyKeyDiff(e, p, a, t, false);
                     }
                 }
             }
         } else {
-            const i = Math.min(f.length, r.length);
-            const u = r.length;
-            let d = false;
-            for (let y = 0; y < u; y++) {
-                const u = r[y];
-                if (!s && y < i && u !== null && typeof u === "object") descend(unwrapValue(f[y]), u, n, l, o);
-                if (e.dk !== null && !d && !(u !== null && typeof u === "object" ? targetsEqual(f[y], u) : isEqual(f[y], u))) {
+            const l = Math.min(f.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))) {
                     bumpDeep(e);
-                    d = true;
+                    p = true;
                 }
                 if (c !== null) {
                     const e = c[y];
                     if (e !== undefined) {
-                        p++;
+                        d++;
                         notifyKeyDiff(e, y, a, t, false);
                     }
                 }
             }
         }
-        if (u) {
-            if (c !== null && p < e.nc) {
+        if (s) {
+            if (c !== null && d < e.nc) {
                 for (const e of Reflect.ownKeys(c)) {
                     // visited indexes are < nextRows.length; everything else sweeps
                     const n = typeof e === "string" ? +e : NaN;
@@ -253,7 +255,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 = u ? e.n : null;
+        const f = s ? e.n : null;
         let r = 0;
         let c = false;
         // The per-key body is inlined on purpose (legacy applyStateFast parity:
@@ -261,45 +263,46 @@ function applyAdopt(e, t, n, o = false) {
         // site). Reference-identical values early-continue BEFORE any other
         // work — sound only with the ownership guard (FINDING-1: an owned
         // backing is setter-diverged and must still diff).
-                for (const u in t) {
-            const p = t[u];
-            const d = a[u];
-            const y = p !== null && typeof p === "object";
-            if (d === p && (!y || !ownedRaw.has(p)) && (f === null || f[u] === undefined || !hasAccessorFlag(f[u]))) {
-                if (f !== null && f[u] !== undefined) r++;
+                for (const s in t) {
+            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++;
                 continue;
             }
-            if (y && !s) descend(unwrapValue(i[u]), p, n, l, o);
+            if (y && !u) descend(unwrapValue(l[s]), d, n, i, 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
             // carry their own witness. One flag + null check when unused.
-                        if (e.dk !== null && !c && !(y ? targetsEqual(d, p) : isEqual(d, p))) {
+                        if (e.dk !== null && !c && !(y ? targetsEqual(p, d) : isEqual(p, d))) {
                 bumpDeep(e);
                 c = true;
             }
             if (f !== null) {
-                const e = f[u];
+                const e = f[s];
                 if (e !== undefined) {
                     r++;
-                    notifyKeyValue(e, u, d, p, a, t);
+                    notifyKeyValue(e, s, p, d, a, t);
                 }
             }
         }
-        const p = Object.getOwnPropertySymbols(t);
-        for (let e = 0; e < p.length; e++) {
-            const u = p[e];
-            const c = t[u];
-            if (!s && c !== null && typeof c === "object") descend(unwrapValue(i[u]), c, n, l, o);
+        const d = Object.getOwnPropertySymbols(t);
+        for (let e = 0; e < d.length; e++) {
+            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[u];
+                const e = f[s];
                 if (e !== undefined) {
                     r++;
-                    notifyKeyValue(e, u, a[u], c, a, t);
+                    notifyKeyValue(e, s, a[s], c, a, t);
                 }
             }
         }
-        if (u) {
+        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) {
@@ -330,8 +333,8 @@ function descend(e, t, n, o, f = false) {
     // 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 l = (o?.map ?? storeNextLookup).get(e);
-    if (l === undefined) return;
+        const i = lookupTarget(e, o);
+    if (i === 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
@@ -363,8 +366,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 && !l.d) return;
-    applyAdopt(l, t, n, f);
+        if (!f && n !== null && !i.d) return;
+    applyAdopt(i, t, n, f);
 }
 
 export { reconcileNextState, sameKey };