@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/prod/map.js

@@ -23,23 +23,23 @@ function mapArray(t, s, i) {
     const r = s.length > 1;
     const n = s;
     const h = {
-        jt: createOwner(),
-        Wt: 0,
-        xt: t,
-        Kt: [],
-        $t: n,
-        qt: [],
+        Wt: createOwner(),
+        xt: 0,
+        Kt: t,
+        $t: [],
+        qt: n,
         zt: [],
-        Jt: e,
-        Xt: e || i?.keyed === false ? [] : undefined,
-        Yt: r && i?.keyed !== false ? [] : undefined,
-        Zt: i?.keyed === false,
-        ts: i?.fallback
+        Jt: [],
+        Xt: e,
+        Yt: e || i?.keyed === false ? [] : undefined,
+        Zt: r && i?.keyed !== false ? [] : undefined,
+        ts: i?.keyed === false,
+        ss: i?.fallback
     };
     const o = computed(updateKeyedMap.bind(h));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        h.jt.Ot = o;
+        h.Wt.Ot = o;
     o.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
@@ -58,52 +58,52 @@ const pureOptions = {
 // strong-abort ordering: removed rows now dispose AFTER the pass's new rows
 // are created (you cannot destroy state before knowing the pass will land).
 function updateKeyedMap() {
-    const t = this.xt() || [], s = t.length;
+    const t = this.Kt() || [], s = t.length;
     t[$TRACK];
  // top level tracking
-        runWithOwner(this.jt, () => {
+        runWithOwner(this.Wt, () => {
         let i, e, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        h = this.Xt ? this.Zt ? () => {
+        h = this.Yt ? this.ts ? () => {
             r[e] = signal(t[e], pureOptions);
-            return this.$t(accessor(r[e]), e);
+            return this.qt(accessor(r[e]), e);
         } : () => {
             r[e] = signal(t[e], pureOptions);
             n && (n[e] = signal(e, pureOptions));
-            return this.$t(accessor(r[e]), n ? accessor(n[e]) : undefined);
-        } : this.Yt ? () => {
+            return this.qt(accessor(r[e]), n ? accessor(n[e]) : undefined);
+        } : this.Zt ? () => {
             const s = t[e];
             n[e] = signal(e, pureOptions);
-            return this.$t(s, accessor(n[e]));
+            return this.qt(s, accessor(n[e]));
         } : () => {
             const s = t[e];
-            return this.$t(s);
+            return this.qt(s);
         };
         // fast path for empty arrays
                 if (s === 0) {
-            if (this.Wt !== 0) {
-                this.jt.dispose(false);
+            if (this.xt !== 0) {
+                this.Wt.dispose(false);
+                this.Jt = [];
+                this.$t = [];
                 this.zt = [];
-                this.Kt = [];
-                this.qt = [];
-                this.Wt = 0;
-                this.Xt && (this.Xt = []);
+                this.xt = 0;
                 this.Yt && (this.Yt = []);
+                this.Zt && (this.Zt = []);
             }
-            if (this.ts && !this.qt[0]) {
+            if (this.ss && !this.zt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.zt[0]?.dispose();
-                this.qt[0] = runWithOwner(this.zt[0] = createOwner(), this.ts);
+                this.Jt[0]?.dispose();
+                this.zt[0] = runWithOwner(this.Jt[0] = createOwner(), this.ss);
             }
         }
         // fast path for new create
-         else if (this.Wt === 0) {
+         else if (this.xt === 0) {
             const o = new Array(s);
             const c = new Array(s);
-            r = this.Xt && new Array(s);
-            n = this.Yt && new Array(s);
+            r = this.Yt && new Array(s);
+            n = this.Zt && new Array(s);
             try {
                 for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
             } catch (t) {
@@ -111,43 +111,43 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.zt[0]) this.zt[0].dispose();
+                        if (this.Jt[0]) this.Jt[0].dispose();
  // previous fallback
-                        this.qt = o;
-            this.zt = c;
-            r && (this.Xt = r);
-            n && (this.Yt = n);
-            this.Kt = t.slice(0);
-            this.Wt = s;
+                        this.zt = o;
+            this.Jt = c;
+            r && (this.Yt = r);
+            n && (this.Zt = n);
+            this.$t = t.slice(0);
+            this.xt = s;
         } else {
             let o, c, a, f, u, p, w, l, d;
             // skip common prefix
-                        for (o = 0, c = Math.min(this.Wt, s); o < c && (this.Kt[o] === t[o] || this.Xt && compare(this.Jt, this.Kt[o], t[o])); o++) {
-                if (this.Xt) setSignal(this.Xt[o], t[o]);
+                        for (o = 0, c = Math.min(this.xt, s); o < c && (this.$t[o] === t[o] || this.Yt && compare(this.Xt, this.$t[o], t[o])); o++) {
+                if (this.Yt) setSignal(this.Yt[o], t[o]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (c = this.Wt - 1, a = s - 1; c >= o && a >= o && (this.Kt[c] === t[a] || this.Xt && compare(this.Jt, this.Kt[c], t[a])); c--, 
+                        for (c = this.xt - 1, a = s - 1; c >= o && a >= o && (this.$t[c] === t[a] || this.Yt && compare(this.Xt, this.$t[c], t[a])); c--, 
             a--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
             // array identity so downstream consumers don't re-run at all
-                        if (o === s && this.Wt === s) {
-                this.Kt = t.slice(0);
+                        if (o === s && this.xt === s) {
+                this.$t = t.slice(0);
                 return;
             }
-            const O = s - this.Wt;
+            const O = s - this.xt;
             const m = new Array(s);
             const _ = new Array(s);
-            r = this.Xt ? new Array(s) : undefined;
-            n = this.Yt ? new Array(s) : undefined;
+            r = this.Yt ? new Array(s) : undefined;
+            n = this.Zt ? new Array(s) : undefined;
             // 0) prepare a map of all indices in the changed window of newItems,
             // scanning backwards so we encounter them in natural order
                         p = new Map;
             w = new Array(a + 1);
             for (e = a; e >= o; e--) {
                 f = t[e];
-                u = this.Jt ? this.Jt(f) : f;
+                u = this.Xt ? this.Xt(f) : f;
                 i = p.get(u);
                 w[e] = i === undefined ? -1 : i;
                 p.set(u, e);
@@ -156,17 +156,17 @@ function updateKeyedMap() {
             // in the new set; if so, stage them at their new positions; if not,
             // queue them for disposal at commit
                         for (i = o; i <= c; i++) {
-                f = this.Kt[i];
-                u = this.Jt ? this.Jt(f) : f;
+                f = this.$t[i];
+                u = this.Xt ? this.Xt(f) : f;
                 e = p.get(u);
                 if (e !== undefined && e !== -1) {
-                    m[e] = this.qt[i];
-                    _[e] = this.zt[i];
-                    r && (r[e] = this.Xt[i]);
-                    n && (n[e] = this.Yt[i]);
+                    m[e] = this.zt[i];
+                    _[e] = this.Jt[i];
+                    r && (r[e] = this.Yt[i]);
+                    n && (n[e] = this.Zt[i]);
                     e = w[e];
                     p.set(u, e);
-                } else (l ??= []).push(this.zt[i]);
+                } else (l ??= []).push(this.Jt[i]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
@@ -183,38 +183,38 @@ function updateKeyedMap() {
             // into the fresh arrays, swap them in (new identity for downstream
             // change propagation), then dispose exited rows
                         for (i = 0; i < o; i++) {
-                m[i] = this.qt[i];
-                _[i] = this.zt[i];
-                r && (r[i] = this.Xt[i]);
-                n && (n[i] = this.Yt[i]);
+                m[i] = this.zt[i];
+                _[i] = this.Jt[i];
+                r && (r[i] = this.Yt[i]);
+                n && (n[i] = this.Zt[i]);
             }
             for (e = o; e <= a; e++) {
                 if (r) setSignal(r[e], t[e]);
                 if (n) setSignal(n[e], e);
             }
             for (e = a + 1; e < s; e++) {
-                m[e] = this.qt[e - O];
-                _[e] = this.zt[e - O];
+                m[e] = this.zt[e - O];
+                _[e] = this.Jt[e - O];
                 if (r) {
-                    r[e] = this.Xt[e - O];
+                    r[e] = this.Yt[e - O];
                     setSignal(r[e], t[e]);
                 }
                 if (n) {
-                    n[e] = this.Yt[e - O];
+                    n[e] = this.Zt[e - O];
                     if (O !== 0) setSignal(n[e], e);
                 }
             }
-            this.qt = m;
-            this.zt = _;
-            r && (this.Xt = r);
-            n && (this.Yt = n);
-            this.Wt = s;
+            this.zt = m;
+            this.Jt = _;
+            r && (this.Yt = r);
+            n && (this.Zt = n);
+            this.xt = s;
             // save a copy of the mapped items for the next update
-                        this.Kt = t.slice(0);
+                        this.$t = t.slice(0);
             if (l) for (i = 0; i < l.length; i++) l[i].dispose();
         }
     });
-    return this.qt;
+    return this.zt;
 }
 
 /**
@@ -234,21 +234,21 @@ function updateKeyedMap() {
  */ function repeat(t, s, i) {
     const e = s;
     const r = {
-        jt: createOwner(),
-        Wt: 0,
-        ss: 0,
-        es: t,
-        $t: e,
+        Wt: createOwner(),
+        xt: 0,
+        es: 0,
+        rs: t,
+        qt: e,
+        Jt: [],
         zt: [],
-        qt: [],
-        rs: i?.from,
-        ts: i?.fallback
+        ns: i?.from,
+        ss: i?.fallback
     };
     const n = computed(updateRepeat.bind(r));
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        r.jt.Ot = n;
+        r.Wt.Ot = n;
     n.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
@@ -261,55 +261,55 @@ function updateKeyedMap() {
 // for the post-settle retry. The overlap math also subsumes the previous
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
-    const t = this.es();
-    const s = this.rs?.() || 0;
-    runWithOwner(this.jt, () => {
+    const t = this.rs();
+    const s = this.ns?.() || 0;
+    runWithOwner(this.Wt, () => {
         if (t === 0) {
-            if (this.Wt !== 0) {
-                this.jt.dispose(false);
+            if (this.xt !== 0) {
+                this.Wt.dispose(false);
+                this.Jt = [];
                 this.zt = [];
-                this.qt = [];
-                this.Wt = 0;
+                this.xt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.ss = 0;
+                                this.es = 0;
             }
-            if (this.ts && !this.qt[0]) {
+            if (this.ss && !this.zt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.zt[0]?.dispose();
-                this.qt[0] = runWithOwner(this.zt[0] = createOwner(), this.ts);
+                this.Jt[0]?.dispose();
+                this.zt[0] = runWithOwner(this.Jt[0] = createOwner(), this.ss);
             }
             return;
         }
         const i = s + t;
-        const e = this.ss + this.Wt;
+        const e = this.es + this.xt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const r = Math.max(s, this.ss);
+                const r = Math.max(s, this.es);
         const n = Math.min(i, e);
         const h = new Array(t);
         const o = new Array(t);
         for (let t = r; t < n; t++) {
-            o[t - s] = this.zt[t - this.ss];
-            h[t - s] = this.qt[t - this.ss];
+            o[t - s] = this.Jt[t - this.es];
+            h[t - s] = this.zt[t - this.es];
         }
         try {
             for (let t = s; t < i; t++) {
                 if (t >= r && t < n) continue;
-                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.$t(t));
+                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.qt(t));
             }
         } catch (t) {
             for (let t = s; t < i; t++) if ((t < r || t >= n) && o[t - s]) o[t - s].dispose();
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.Wt === 0) this.zt[0]?.dispose(); else for (let t = this.ss; t < e; t++) if (t < s || t >= i) this.zt[t - this.ss].dispose();
-        this.qt = h;
-        this.zt = o;
-        this.ss = s;
-        this.Wt = t;
+                if (this.xt === 0) this.Jt[0]?.dispose(); else for (let t = this.es; t < e; t++) if (t < s || t >= i) this.Jt[t - this.es].dispose();
+        this.zt = h;
+        this.Jt = o;
+        this.es = s;
+        this.xt = t;
     });
-    return this.qt;
+    return this.zt;
 }
 
 function compare(t, s, i) {

package/dist/prod/signals.js

@@ -251,7 +251,7 @@ function createEffect(e, t, n) {
             // route through the inherited queue.
             const r = getOwner();
             const o = new MicrotaskQueue;
-            o.ve = r.C;
+            o.ke = r.C;
  // notify() forwards up the normal chain
                         r.C = o;
             // A user effect rather than a bare computed: computeds are pull-based and

package/dist/prod/store/index.js

@@ -10,6 +10,8 @@ import "../core/effect.js";
 
 import { createStoreNext, deepNext, snapshotNext } from "./next/store.js";
 
+export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./next/store.js";
+
 import { reconcileNextState } from "./next/reconcile.js";
 
 import { createStoreDerivedNext } from "./next/projection.js";

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

@@ -18,6 +18,10 @@ import { runProjectionComputedNext } from "./projection.js";
 
 import { wrapNext, runAuthoritative, storeSetterNext, hasActiveOverride, unwrapValue, getNode, getHasNode, targetsEqual, getKeySetNode, bumpDeep } from "./store.js";
 
+import { patchHooks, rowHooks } from "./patch-hooks.js";
+
+import { buildIdentityRowOps, sameKey } from "./reconcile.js";
+
 import { setOptHooks } from "./target.js";
 
 /**
@@ -51,14 +55,31 @@ function installNextBlockedHalf() {
     // Scheduler flush tails call _clearOptimisticStores whenever tracked
     // stores exist; next has no layer to clear — reverts are engine-native —
     // so the hook only empties the batch set.
-        if (!GlobalQueue.Vt) {
-        GlobalQueue.Vt = e => {
+        if (!GlobalQueue.Bt) {
+        GlobalQueue.Bt = e => {
+            // Patch channel (revert site): engine-native reverts flip node values
+            // back to committed; patched records need a forced DOM re-apply from
+            // the post-revert view. Emission only — next keeps no layer to clear.
+            for (const t of e) {
+                const e = t?.[$TARGET];
+                const n = e?.fam?.overlaid;
+                if (n !== undefined) {
+                    for (const e of n) {
+                        if (e.pc !== null && e.pc.p !== null) patchHooks.emitPatchOptimistic(e, null, null);
+                        // Row-ops resync (family increment 2): reverts flip node values
+                        // back engine-natively; a driven list must rebuild retention by
+                        // row identity against the post-revert view (resolved from the
+                        // target at drain — overrides are gone by then).
+                                                if (e.pc !== null && e.pc.ro !== null) rowHooks.emitRowOpsOptimistic(e, null, null);
+                    }
+                }
+            }
             e.clear();
         };
     }
-    const e = GlobalQueue.dn;
-    GlobalQueue.dn = t => {
-        for (const e of t.cn) {
+    const e = GlobalQueue.In;
+    GlobalQueue.In = t => {
+        for (const e of t.Tn) {
             const t = e?.[$TARGET];
             const n = t?.fam?.node;
             // The hold exists to keep optimistic state alive until the store's own
@@ -148,6 +169,21 @@ function createOptimisticStoreNext(e, t, n) {
     const n = e.fam?.node;
     if (n?._e) globalQueue.initTransition(n._e);
     const i = e.v;
+    // Patch channel (override-application site): the draft IS the intended
+    // visible state; prev is the view before these overrides apply. Bypasses
+    // the transition stash — optimism is visible in flight.
+        if (e.pc !== null && e.pc.p !== null) patchHooks.emitPatchOptimistic(e, t, optimisticView(e, i));
+    // Row-ops channel (family increment 2): optimistic STRUCTURE on an array
+    // rides node overrides — it never enters the reconcile walk — so a driven
+    // list must get its structural ops here, lane-timed. Identity diff of the
+    // pre-write optimistic view against the draft; aligned writes emit nothing.
+        if (e.pc !== null && e.pc.ro !== null && Array.isArray(t)) {
+        const n = optimisticView(e, i);
+        if (Array.isArray(n)) {
+            const i = buildIdentityRowOps(n, t);
+            if (i !== null) rowHooks.emitRowOpsOptimistic(e, t, i);
+        }
+    }
     const visible = (t, n) => {
         const i = e.n?.[t];
         return i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.De) : n;
@@ -198,7 +234,7 @@ function createOptimisticStoreNext(e, t, n) {
     // and the target for landing consumption (RUL-2).
         e.pb = null;
     (e.fam.overlaid ??= new Set).add(e);
-    GlobalQueue.Nn?.(e.fam.px ?? e.px);
+    GlobalQueue.An?.(e.fam.px ?? e.px);
 }
 
 /**
@@ -223,7 +259,7 @@ function createOptimisticStoreNext(e, t, n) {
                 e.T |= CONFIG_OPTIMISTIC;
                 const i = e.o;
                 if (i) {
-                    i.Et = null;
+                    i.Nt = null;
                     i.Be = undefined;
                 }
                 e.Pe = NOT_PENDING;
@@ -264,12 +300,16 @@ function createOptimisticStoreNext(e, t, n) {
                 e.k.T |= CONFIG_OPTIMISTIC;
                 const t = e.k.o;
                 if (t) {
-                    t.Et = null;
+                    t.Nt = null;
                     t.Be = undefined;
                 }
                 insertSubs(e.k, true);
                 schedule();
             }
+            // Patch channel (override-consumption site): visible truth flipped to
+            // committed for the consumed keys — force a re-apply from the live
+            // view so the DOM leaves the override state.
+                        if (e.pc !== null && e.pc.p !== null) patchHooks.emitPatchOptimistic(e, null, null);
         }
         t.clear();
     });
@@ -322,7 +362,9 @@ function applyTentative(e, t, n) {
         if (n) {
             const i = n(e);
             const o = n(t);
-            if (i !== undefined && o !== undefined && i !== o) return null;
+            // SameValueZero (re-audit 3, P1-3): parity with the plain reconcile
+            // channel — NaN keys are self-equal.
+                        if (i !== undefined && o !== undefined && !sameKey(i, o)) return null;
         }
         return r.get(unwrapValue(e)) ?? null;
     };
@@ -337,16 +379,28 @@ function applyTentative(e, t, n) {
                 const t = n(r);
                 if (t !== undefined) {
                     if (i === null) {
+                        // Occurrence-aware index queues (re-audit 3, P1-3): parity with
+                        // the plain adoption window — duplicate keys match per
+                        // occurrence, each view row consumed once.
                         i = new Map;
                         for (let t = 0; t < e.length; t++) {
                             const o = unwrapValue(e[t]);
                             if (isWrappable(o)) {
                                 const e = n(o);
-                                if (e !== undefined && !i.has(e)) i.set(e, o);
+                                if (e === undefined) continue;
+                                const r = i.get(e);
+                                if (r === undefined) i.set(e, t); else if (Array.isArray(r)) r.push(t); else i.set(e, [ r, t ]);
                             }
                         }
                     }
-                    s = i.get(t);
+                    const o = i.get(t);
+                    if (o === undefined) s = undefined; else if (Array.isArray(o)) {
+                        s = unwrapValue(e[o.shift()]);
+                        if (o.length === 1) i.set(t, o[0]);
+                    } else {
+                        s = unwrapValue(e[o]);
+                        i.delete(t);
+                    }
                 } else s = unwrapValue(e[o]);
             } else s = unwrapValue(e[o]);
             const c = match(s, r);

package/dist/prod/store/next/patch-hooks.js

@@ -0,0 +1,13 @@
+let patchHooks = null;
+
+let rowHooks = null;
+
+function installPatchHooks(o) {
+    patchHooks = o;
+}
+
+function installRowHooks(o) {
+    rowHooks = o;
+}
+
+export { installPatchHooks, installRowHooks, patchHooks, rowHooks };