@solidjs/signals 2.0.0-beta.19 → 2.0.0-beta.21

package/dist/prod/core/verdict.js

@@ -1,20 +1,20 @@
-import { STATUS_UNINITIALIZED, REACTIVE_DISPOSED, NOT_PENDING, REACTIVE_MANUAL_WRITE, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_CHECK } from "./constants.js";
+import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, REACTIVE_ZOMBIE, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_MANUAL_WRITE } from "./constants.js";
 
-import { context, setPendingCheckActive, read, optimisticSignal, setSignal, setLatestReadActive, pendingCheckActive, latestReadActive, stale, currentOptimisticLane, prepareComputed, tracking, setContextInternal, optimisticComputed } from "./core.js";
+import { setSignal, prepareComputed, read, context, stale, currentOptimisticLane, tracking, setLatestReadActive, setContextInternal, optimisticComputed, setPendingCheckActive, latestReadActive, optimisticSignal, pendingCheckActive } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
 import { link } from "./graph.js";
 
-import { insertIntoHeap, queueFor } from "./heap.js";
+import { insertIntoHeap, queueFor, markHeap } from "./heap.js";
 
 import "./invariants.js";
 
-import { hasActiveOverride, findLane } from "./lanes.js";
+import { findLane, hasActiveOverride } from "./lanes.js";
 
 import { installOptimisticEngine } from "./optimistic.js";
 
-import { GlobalQueue, clock, insertSubs, schedule } from "./scheduler.js";
+import { GlobalQueue, clock, insertSubs, schedule, activeTransition } from "./scheduler.js";
 
 /**
  * The isPending()/latest() verdict layer, moved out of core.ts. Importing this
@@ -61,11 +61,10 @@ function collectPendingSources(e) {
 }
 
 function quietPending(e) {
-    if (e.M) {
-        for (const t of e.M) if (!t.A) return false;
+    if (e.m) {
+        for (const t of e.m) if (!t.A) return false;
         return true;
     }
-    if (e.m) return e.m.A;
     return e.A;
 }
 
@@ -76,11 +75,11 @@ function newQuestionInFlight(e) {
 function computePendingState(e) {
     const t = e;
     if (t.u & REACTIVE_DISPOSED) return false;
-    if (e.P) return true;
+    if (e.M) return true;
     const n = e.rt;
     if (e.en) {
         const t = e.en;
-        if (t.P) return true;
+        if (t.M) return true;
         const n = t.rt || t;
         return newQuestionInFlight(n);
     }
@@ -88,7 +87,7 @@ function computePendingState(e) {
         return !!(n.u & REACTIVE_MANUAL_WRITE) || !n.Ae && !(n.i & STATUS_PENDING) || !!(n.i & STATUS_PENDING) && quietPending(n);
     }
     if (e.ge !== NOT_PENDING && !(t.i & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.Ge || !e.Ge(e.ge, e.be);
+        if (hasActiveOverride(e)) return !e.Ge || !e.Ge(e.ge, unwrapOverride(e.be));
         return true;
     }
     return newQuestionInFlight(t);
@@ -173,9 +172,19 @@ function getLatestValueComputed(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.be !== undefined && e.be !== NOT_PENDING ? e.be : e.Ue;
+    const i = e.be !== undefined && e.be !== NOT_PENDING ? unwrapOverride(e.be) : e.Ue;
     let r;
     try {
+        // An untracked latest() read has no reading context, so read() never
+        // performs its mid-tick pull — a plain write queued between two latest()
+        // calls left a still-subscribed shadow at its previous speculative value
+        // until the flush (#2922). Mirror the tracked-read pull here: mark the
+        // queued staleness through the graph, then bring the shadow up to date.
+        const e = queueFor(t);
+        if (t.qe >= e.Le && !(t.u & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            markHeap(e);
+            prepareComputed(t, true);
+        }
         r = read(t);
     } catch (t) {
         if (t instanceof NotReadyError && (!context || !(e.i & STATUS_UNINITIALIZED))) return i;
@@ -191,6 +200,11 @@ function getLatestValueComputed(e) {
             return i;
         }
     }
+    // A shadow recomputed by the pull above (not at creation) holds its fresh
+    // speculative value in _pendingValue; a contextless read() only surfaces
+    // _value. Overrides stay authoritative (A17), and stale readers keep the
+    // other transition's committed view, matching read()'s own selection.
+        if (t.ge !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.ve && activeTransition !== t.ve)) return t.ge;
     return r;
 }
 
@@ -272,7 +286,7 @@ function isPending(e) {
 // direct calls used, so behavior is identical once this module loads.
 GlobalQueue._e = syncCompanions;
 
-GlobalQueue._ = updatePendingSignal;
+GlobalQueue.P = updatePendingSignal;
 
 GlobalQueue.me = updateChildCompanions;
 
@@ -282,12 +296,12 @@ GlobalQueue.Gt = latestRead;
 
 GlobalQueue.Pt = pendingCheckRead;
 
-GlobalQueue.vt = recordFreshRead;
+GlobalQueue.kt = recordFreshRead;
 
 GlobalQueue.tt = applyReask;
 
 GlobalQueue.nt = repollDownstreamVerdicts;
 
-GlobalQueue.Zt = witnessAffects;
+GlobalQueue.wt = witnessAffects;
 
 export { isPending, latest };

package/dist/prod/map.js

@@ -18,26 +18,26 @@ import { $TRACK } from "./store/store.js";
 
 function mapArray(t, s, i) {
     const e = typeof i?.keyed === "function" ? i.keyed : undefined;
-    const h = s.length > 1;
-    const r = s;
-    const n = {
-        $t: createOwner(),
-        Xt: 0,
-        ts: t,
-        ss: [],
-        es: r,
-        hs: [],
-        rs: [],
-        ns: e,
-        cs: e || i?.keyed === false ? [] : undefined,
-        fs: h && i?.keyed !== false ? [] : undefined,
-        us: i?.keyed === false,
-        ps: i?.fallback
+    const r = s.length > 1;
+    const n = s;
+    const h = {
+        jt: createOwner(),
+        Wt: 0,
+        Kt: t,
+        xt: [],
+        $t: n,
+        qt: [],
+        zt: [],
+        Ht: e,
+        Jt: e || i?.keyed === false ? [] : undefined,
+        Xt: r && i?.keyed !== false ? [] : undefined,
+        Yt: i?.keyed === false,
+        Zt: i?.fallback
     };
-    const o = computed(updateKeyedMap.bind(n));
+    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).
-        n.$t.Ct = o;
+        h.jt.Ct = o;
     o.U &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
@@ -46,114 +46,149 @@ const pureOptions = {
     ownedWrite: true
 };
 
+// Exception safety (#2903): a map callback can throw NotReadyError mid-pass
+// (async read), and the computed re-runs the whole pass after settle. Every
+// pass therefore STAGES its work — new rows are created into temp arrays and
+// removals are deferred — and commits to `this` only after every mapper
+// succeeded. An aborted pass disposes just the owners it created and leaves
+// `_items`/`_mappings`/`_nodes`/`_rows`/`_indexes`/`_len` exactly as they
+// were, so the retry diffs against uncorrupted state. Consequence of the
+// 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.ts() || [], s = t.length;
+    const t = this.Kt() || [], s = t.length;
     t[$TRACK];
  // top level tracking
-        runWithOwner(this.$t, () => {
-        let i, e, h = this.cs ? this.us ? () => {
-            this.cs[e] = signal(t[e], pureOptions);
-            return this.es(accessor(this.cs[e]), e);
+        runWithOwner(this.jt, () => {
+        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.Jt ? this.Yt ? () => {
+            r[e] = signal(t[e], pureOptions);
+            return this.$t(accessor(r[e]), e);
         } : () => {
-            this.cs[e] = signal(t[e], pureOptions);
-            this.fs && (this.fs[e] = signal(e, pureOptions));
-            return this.es(accessor(this.cs[e]), this.fs ? accessor(this.fs[e]) : undefined);
-        } : this.fs ? () => {
+            r[e] = signal(t[e], pureOptions);
+            n && (n[e] = signal(e, pureOptions));
+            return this.$t(accessor(r[e]), n ? accessor(n[e]) : undefined);
+        } : this.Xt ? () => {
             const s = t[e];
-            this.fs[e] = signal(e, pureOptions);
-            return this.es(s, accessor(this.fs[e]));
+            n[e] = signal(e, pureOptions);
+            return this.$t(s, accessor(n[e]));
         } : () => {
             const s = t[e];
-            return this.es(s);
+            return this.$t(s);
         };
         // fast path for empty arrays
                 if (s === 0) {
-            if (this.Xt !== 0) {
-                this.$t.dispose(false);
-                this.rs = [];
-                this.ss = [];
-                this.hs = [];
-                this.Xt = 0;
-                this.cs && (this.cs = []);
-                this.fs && (this.fs = []);
+            if (this.Wt !== 0) {
+                this.jt.dispose(false);
+                this.zt = [];
+                this.xt = [];
+                this.qt = [];
+                this.Wt = 0;
+                this.Jt && (this.Jt = []);
+                this.Xt && (this.Xt = []);
             }
-            if (this.ps && !this.hs[0]) {
-                // create fallback
-                this.hs[0] = runWithOwner(this.rs[0] = createOwner(), this.ps);
+            if (this.Zt && !this.qt[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.Zt);
             }
         }
         // fast path for new create
-         else if (this.Xt === 0) {
-            // dispose previous fallback
-            if (this.rs[0]) this.rs[0].dispose();
-            this.hs = new Array(s);
-            for (e = 0; e < s; e++) {
-                this.ss[e] = t[e];
-                this.hs[e] = runWithOwner(this.rs[e] = createOwner(), h);
+         else if (this.Wt === 0) {
+            const o = new Array(s);
+            const c = new Array(s);
+            r = this.Jt && new Array(s);
+            n = this.Xt && new Array(s);
+            try {
+                for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
+            } catch (t) {
+                for (i = 0; i <= e; i++) c[i]?.dispose();
+                throw t;
             }
-            this.Xt = s;
+            // commit
+                        if (this.zt[0]) this.zt[0].dispose();
+ // previous fallback
+                        this.qt = o;
+            this.zt = c;
+            r && (this.Jt = r);
+            n && (this.Xt = n);
+            this.xt = t.slice(0);
+            this.Wt = s;
         } else {
-            let r, n, o, a, c, f, u, p = new Array(s), l = new Array(s), w = this.cs ? new Array(s) : undefined, O = this.fs ? new Array(s) : undefined;
+            let o, c, a, f, u, p, w, l, d, O = new Array(s), m = new Array(s);
+            r = this.Jt ? new Array(s) : undefined;
+            n = this.Xt ? new Array(s) : undefined;
             // skip common prefix
-                        for (r = 0, n = Math.min(this.Xt, s); r < n && (this.ss[r] === t[r] || this.cs && compare(this.ns, this.ss[r], t[r])); r++) {
-                if (this.cs) setSignal(this.cs[r], t[r]);
+                        for (o = 0, c = Math.min(this.Wt, s); o < c && (this.xt[o] === t[o] || this.Jt && compare(this.Ht, this.xt[o], t[o])); o++) {
+                if (this.Jt) setSignal(this.Jt[o], t[o]);
             }
             // common suffix
-                        for (n = this.Xt - 1, o = s - 1; n >= r && o >= r && (this.ss[n] === t[o] || this.cs && compare(this.ns, this.ss[n], t[o])); n--, 
-            o--) {
-                p[o] = this.hs[n];
-                l[o] = this.rs[n];
-                w && (w[o] = this.cs[n]);
-                O && (O[o] = this.fs[n]);
+                        for (c = this.Wt - 1, a = s - 1; c >= o && a >= o && (this.xt[c] === t[a] || this.Jt && compare(this.Ht, this.xt[c], t[a])); c--, 
+            a--) {
+                O[a] = this.qt[c];
+                m[a] = this.zt[c];
+                r && (r[a] = this.Jt[c]);
+                n && (n[a] = this.Xt[c]);
             }
             // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
-                        f = new Map;
-            u = new Array(o + 1);
-            for (e = o; e >= r; e--) {
-                a = t[e];
-                c = this.ns ? this.ns(a) : a;
-                i = f.get(c);
-                u[e] = i === undefined ? -1 : i;
-                f.set(c, e);
+                        p = new Map;
+            w = new Array(a + 1);
+            for (e = a; e >= o; e--) {
+                f = t[e];
+                u = this.Ht ? this.Ht(f) : f;
+                i = p.get(u);
+                w[e] = i === undefined ? -1 : i;
+                p.set(u, e);
             }
-            // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, exit them
-                        for (i = r; i <= n; i++) {
-                a = this.ss[i];
-                c = this.ns ? this.ns(a) : a;
-                e = f.get(c);
+            // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, queue them for disposal at commit
+                        for (i = o; i <= c; i++) {
+                f = this.xt[i];
+                u = this.Ht ? this.Ht(f) : f;
+                e = p.get(u);
                 if (e !== undefined && e !== -1) {
-                    p[e] = this.hs[i];
-                    l[e] = this.rs[i];
-                    w && (w[e] = this.cs[i]);
-                    O && (O[e] = this.fs[i]);
-                    e = u[e];
-                    f.set(c, e);
-                } else this.rs[i].dispose();
+                    O[e] = this.qt[i];
+                    m[e] = this.zt[i];
+                    r && (r[e] = this.Jt[i]);
+                    n && (n[e] = this.Xt[i]);
+                    e = w[e];
+                    p.set(u, e);
+                } else (l ??= []).push(this.zt[i]);
             }
-            // 2) set all the new values, pulling from the temp array if copied, otherwise entering the new value
-                        for (e = r; e < s; e++) {
-                if (e in p) {
-                    this.hs[e] = p[e];
-                    this.rs[e] = l[e];
-                    if (w) {
-                        this.cs[e] = w[e];
-                        setSignal(this.cs[e], t[e]);
-                    }
-                    if (O) {
-                        this.fs[e] = O[e];
-                        setSignal(this.fs[e], e);
-                    }
-                } else {
-                    this.hs[e] = runWithOwner(this.rs[e] = createOwner(), h);
+            // 2) create new rows into the temp arrays; an abort disposes only these
+                        try {
+                for (e = o; e < s; e++) {
+                    if (e in O) continue;
+                    (d ??= []).push(m[e] = createOwner());
+                    O[e] = runWithOwner(m[e], h);
                 }
+            } catch (t) {
+                if (d) for (i = 0; i < d.length; i++) d[i].dispose();
+                throw t;
             }
-            // 3) in case the new set is shorter than the old, set the length of the mapped array
-                        this.hs = this.hs.slice(0, this.Xt = s);
-            // 4) save a copy of the mapped items for the next update
-                        this.ss = t.slice(0);
+            // 3) commit: land positions, then dispose exited rows
+                        for (e = o; e < s; e++) {
+                this.qt[e] = O[e];
+                this.zt[e] = m[e];
+                if (r) {
+                    this.Jt[e] = r[e];
+                    setSignal(this.Jt[e], t[e]);
+                }
+                if (n) {
+                    this.Xt[e] = n[e];
+                    setSignal(this.Xt[e], e);
+                }
+            }
+            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
+            // 4) in case the new set is shorter than the old, set the length of the mapped array
+                        this.qt = this.qt.slice(0, this.Wt = s);
+            // 5) save a copy of the mapped items for the next update
+                        this.xt = t.slice(0);
         }
     });
-    return this.hs;
+    return this.qt;
 }
 
 /**
@@ -172,89 +207,83 @@ function updateKeyedMap() {
  * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
  */ function repeat(t, s, i) {
     const e = s;
-    const h = computed(updateRepeat.bind({
-        $t: createOwner(),
-        Xt: 0,
-        ls: 0,
-        ws: t,
-        es: e,
-        rs: [],
-        hs: [],
-        Os: i?.from,
-        ps: i?.fallback
-    }));
-    h.U &= ~CONFIG_AUTO_DISPOSE;
-    return accessor(h);
+    const r = {
+        jt: createOwner(),
+        Wt: 0,
+        ts: 0,
+        ss: t,
+        $t: e,
+        zt: [],
+        qt: [],
+        es: i?.from,
+        Zt: 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.Ct = n;
+    n.U &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(n);
 }
 
+// Same staged-commit discipline as `updateKeyedMap` (#2903): the retained
+// window overlap is copied into fresh arrays, missing indexes are created
+// into them, and `this` is only touched — including disposal of rows leaving
+// the window — after every `_map` call succeeded. A NotReadyError mid-pass
+// disposes only the owners this pass created and leaves prior state intact
+// 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.ws();
-    const s = this.Os?.() || 0;
-    runWithOwner(this.$t, () => {
+    const t = this.ss();
+    const s = this.es?.() || 0;
+    runWithOwner(this.jt, () => {
         if (t === 0) {
-            if (this.Xt !== 0) {
-                this.$t.dispose(false);
-                this.rs = [];
-                this.hs = [];
-                this.Xt = 0;
-                // Reset offset to match the cleared data. Without this, a subsequent
-                // nonzero render with a smaller `from` would enter the end-clear loop
-                // with `prevTo = stale_offset + 0` > `to` and dispose `_nodes[-1]`
-                // (#2767, repro 2).
-                                this.ls = 0;
+            if (this.Wt !== 0) {
+                this.jt.dispose(false);
+                this.zt = [];
+                this.qt = [];
+                this.Wt = 0;
+                // Reset offset to match the cleared data (#2767, repro 2).
+                                this.ts = 0;
             }
-            if (this.ps && !this.hs[0]) {
-                // create fallback
-                this.hs[0] = runWithOwner(this.rs[0] = createOwner(), this.ps);
+            if (this.Zt && !this.qt[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.Zt);
             }
             return;
         }
         const i = s + t;
-        const e = this.ls + this.Xt;
-        // remove fallback
-                if (this.Xt === 0 && this.rs[0]) this.rs[0].dispose();
-        // Disjoint windows have no rows to retain; replace them wholesale.
-                if (s >= e || i <= this.ls) {
-            for (let t = 0; t < this.Xt; t++) this.rs[t].dispose();
-            this.rs = new Array(t);
-            this.hs = new Array(t);
-            for (let i = 0; i < t; i++) this.hs[i] = runWithOwner(this.rs[i] = createOwner(), () => this.es(s + i));
-            this.ls = s;
-            this.Xt = t;
-            return;
+        const e = this.ts + this.Wt;
+        // 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.ts);
+        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.ts];
+            h[t - s] = this.qt[t - this.ts];
         }
-        // clear the end
-                for (let t = i; t < e; t++) this.rs[t - this.ls].dispose();
-        if (this.ls < s) {
-            // clear beginning — `_nodes` is local-indexed, so the rows leaving the
-            // front sit at local positions 0..(from - _offset), clamped to old len.
-            const t = s - this.ls;
-            for (let s = 0; s < t && s < this.Xt; s++) this.rs[s].dispose();
-            // shift indexes
-                        this.rs.splice(0, t);
-            this.hs.splice(0, t);
-        } else if (this.ls > s) {
-            // shift indexes
-            let i = e - this.ls - 1;
-            let h = this.ls - s;
-            this.rs.length = this.hs.length = t;
-            while (i >= h) {
-                this.rs[i] = this.rs[i - h];
-                this.hs[i] = this.hs[i - h];
-                i--;
-            }
-            for (let t = 0; t < h; t++) {
-                this.hs[t] = runWithOwner(this.rs[t] = createOwner(), () => this.es(t + s));
+        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));
             }
+        } catch (t) {
+            for (let t = s; t < i; t++) if ((t < r || t >= n) && o[t - s]) o[t - s].dispose();
+            throw t;
         }
-        for (let t = e; t < i; t++) {
-            this.hs[t - s] = runWithOwner(this.rs[t - s] = createOwner(), () => this.es(t));
-        }
-        this.hs = this.hs.slice(0, t);
-        this.ls = s;
-        this.Xt = 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.ts; t < e; t++) if (t < s || t >= i) this.zt[t - this.ts].dispose();
+        this.qt = h;
+        this.zt = o;
+        this.ts = s;
+        this.Wt = t;
     });
-    return this.hs;
+    return this.qt;
 }
 
 function compare(t, s, i) {

package/dist/prod/signals.js

@@ -4,7 +4,7 @@ import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
 import { globalQueue } from "./core/scheduler.js";
 
-import { CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_AUTO_DISPOSE } from "./core/constants.js";
+import { CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH } from "./core/constants.js";
 
 import "./core/invariants.js";