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

package/dist/prod/map.js

@@ -25,23 +25,23 @@ function mapArray(t, s, i) {
     const r = s.length > 1;
     const n = s;
     const o = {
-        ts: createOwner(),
-        ss: 0,
-        es: t,
-        rs: [],
-        ns: n,
+        se: createOwner(),
+        ts: 0,
+        ss: t,
+        es: [],
+        rs: n,
+        ns: [],
         hs: [],
-        fs: [],
-        xt: e,
-        cs: e || i?.keyed === false ? [] : undefined,
-        ls: r && i?.keyed !== false ? [] : undefined,
-        us: i?.keyed === false,
-        ps: i?.fallback
+        qt: e,
+        fs: e || i?.keyed === false ? [] : undefined,
+        cs: r && i?.keyed !== false ? [] : undefined,
+        ls: i?.keyed === false,
+        us: i?.fallback
     };
     const h = computed(updateKeyedMap.bind(o), undefined);
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        o.ts.bt = h;
+        o.se.Qt = h;
     h.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(h);
 }
@@ -51,8 +51,8 @@ const pureOptions = {
 };
 
 function trySmallMove(t, s, i, e) {
-    const r = t.rs;
-    const n = t.ss - 1;
+    const r = t.es;
+    const n = t.ts - 1;
     const o = [];
     const h = [];
     const f = [];
@@ -124,7 +124,7 @@ function trySmallMove(t, s, i, e) {
  * body. Pairs displaced sources with destinations (an unmatched destination
  * is a replacement/insertion → general path), then commits: slice() the live
  * arrays, copy shifted runs, patch displaced pairs, dispose leftovers. */ function commitSmallMove(t, s, i, e, r, n) {
-    const o = t.rs;
+    const o = t.es;
     let h;
     let f;
     let c;
@@ -159,8 +159,8 @@ function trySmallMove(t, s, i, e) {
             for (let e = 0, r = n[s + 2]; e < r; e++) if (t.has(o[i + e])) return false;
         }
     }
-    const a = t.hs;
-    const l = t.fs;
+    const a = t.ns;
+    const l = t.hs;
     const u = a.slice(0, i);
     const p = l.slice(0, i);
     for (let t = 0; t < n.length; t += 3) {
@@ -179,10 +179,10 @@ function trySmallMove(t, s, i, e) {
         u[t] = a[s];
         p[t] = l[s];
     }
-    t.hs = u;
-    t.fs = p;
-    t.ss = i;
-    t.rs = s.slice(0);
+    t.ns = u;
+    t.hs = p;
+    t.ts = i;
+    t.es = s.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
         for (h = 0; h < e.length; h++) {
         if (c === undefined || !c[h]) l[e[h]].dispose();
@@ -191,52 +191,52 @@ function trySmallMove(t, s, i, e) {
 }
 
 function updateKeyedMap() {
-    const t = this.es() || [], s = t.length;
+    const t = this.ss() || [], s = t.length;
     t[$TRACK];
  // top level tracking
-        runWithOwner(this.ts, () => {
+        runWithOwner(this.se, () => {
         let i, e, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        o = this.cs ? this.us ? () => {
+        o = this.fs ? this.ls ? () => {
             r[e] = signal(t[e], pureOptions);
-            return this.ns(accessor(r[e]), e);
+            return this.rs(accessor(r[e]), e);
         } : () => {
             r[e] = signal(t[e], pureOptions);
             n && (n[e] = signal(e, pureOptions));
-            return this.ns(accessor(r[e]), n ? accessor(n[e]) : undefined);
-        } : this.ls ? () => {
+            return this.rs(accessor(r[e]), n ? accessor(n[e]) : undefined);
+        } : this.cs ? () => {
             const s = t[e];
             n[e] = signal(e, pureOptions);
-            return this.ns(s, accessor(n[e]));
+            return this.rs(s, accessor(n[e]));
         } : () => {
             const s = t[e];
-            return this.ns(s);
+            return this.rs(s);
         };
         // fast path for empty arrays
                 if (s === 0) {
-            if (this.ss !== 0) {
-                this.ts.dispose(false);
-                this.fs = [];
-                this.rs = [];
+            if (this.ts !== 0) {
+                this.se.dispose(false);
                 this.hs = [];
-                this.ss = 0;
+                this.es = [];
+                this.ns = [];
+                this.ts = 0;
+                this.fs && (this.fs = []);
                 this.cs && (this.cs = []);
-                this.ls && (this.ls = []);
             }
-            if (this.ps && !this.hs[0]) {
+            if (this.us && !this.ns[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.fs[0]?.dispose();
-                this.hs[0] = runWithOwner(this.fs[0] = createOwner(), this.ps);
+                this.hs[0]?.dispose();
+                this.ns[0] = runWithOwner(this.hs[0] = createOwner(), this.us);
             }
         }
         // fast path for new create
-         else if (this.ss === 0) {
+         else if (this.ts === 0) {
             const h = new Array(s);
             const f = new Array(s);
-            r = this.cs && new Array(s);
-            n = this.ls && new Array(s);
+            r = this.fs && new Array(s);
+            n = this.cs && new Array(s);
             try {
                 for (e = 0; e < s; e++) h[e] = runWithOwner(f[e] = createOwner(), o);
             } catch (t) {
@@ -244,32 +244,32 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.fs[0]) this.fs[0].dispose();
+                        if (this.hs[0]) this.hs[0].dispose();
  // previous fallback
-                        this.hs = h;
-            this.fs = f;
-            r && (this.cs = r);
-            n && (this.ls = n);
-            this.rs = t.slice(0);
-            this.ss = s;
+                        this.ns = h;
+            this.hs = f;
+            r && (this.fs = r);
+            n && (this.cs = n);
+            this.es = t.slice(0);
+            this.ts = s;
         } else {
             let h, f, c, a, l, u, p, d, w, 
             // Dev (attribution engine installed): the items behind the exited and
             // entered rows, for the list-identity census.
             m, O;
             // skip common prefix
-                        for (h = 0, f = Math.min(this.ss, s); h < f && (this.rs[h] === t[h] || this.cs && compare(this.xt, this.rs[h], t[h])); h++) {
-                if (this.cs) setSignal(this.cs[h], t[h]);
+                        for (h = 0, f = Math.min(this.ts, s); h < f && (this.es[h] === t[h] || this.fs && compare(this.qt, this.es[h], t[h])); h++) {
+                if (this.fs) setSignal(this.fs[h], t[h]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (f = this.ss - 1, c = s - 1; f >= h && c >= h && (this.rs[f] === t[c] || this.cs && compare(this.xt, this.rs[f], t[c])); f--, 
+                        for (f = this.ts - 1, c = s - 1; f >= h && c >= h && (this.es[f] === t[c] || this.fs && compare(this.qt, this.es[f], t[c])); f--, 
             c--) ;
             // 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 (h === s && this.ss === s) {
-                this.rs = t.slice(0);
+                        if (h === s && this.ts === s) {
+                this.es = t.slice(0);
                 return;
             }
             // SMALL-MOVE FAST PATH: extracted to its own function — inlining it
@@ -279,7 +279,7 @@ function updateKeyedMap() {
             // (plain removals, tail edits), the general path is window-
             // proportional and cheap — the fast path would only re-walk what the
             // trims proved.
-                        if (s <= this.ss && f - h > 64 && this.cs === undefined && this.ls === undefined) {
+                        if (s <= this.ts && f - h > 64 && this.fs === undefined && this.cs === undefined) {
                 // PROBE before the scan: a small move keeps a mid-window item within
                 // ±32 of its old position; a REPLACE (all fresh items — the shape
                 // every page's first structural pass usually is) has it nowhere.
@@ -289,21 +289,21 @@ function updateKeyedMap() {
                 const e = t[i];
                 const r = Math.min(f, i + 32);
                 let n = Math.max(h, i - 32);
-                while (n <= r && this.rs[n] !== e) n++;
+                while (n <= r && this.es[n] !== e) n++;
                 if (n <= r && trySmallMove(this, t, s, h)) return;
             }
-            const _ = s - this.ss;
+            const _ = s - this.ts;
             const y = new Array(s);
             const A = new Array(s);
-            r = this.cs ? new Array(s) : undefined;
-            n = this.ls ? new Array(s) : undefined;
+            r = this.fs ? new Array(s) : undefined;
+            n = this.cs ? 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
                         u = new Map;
             p = new Array(c + 1);
             for (e = c; e >= h; e--) {
                 a = t[e];
-                l = this.xt ? this.xt(a) : a;
+                l = this.qt ? this.qt(a) : a;
                 i = u.get(l);
                 p[e] = i === undefined ? -1 : i;
                 u.set(l, e);
@@ -312,18 +312,18 @@ function updateKeyedMap() {
             // in the new set; if so, stage them at their new positions; if not,
             // queue them for disposal at commit
                         for (i = h; i <= f; i++) {
-                a = this.rs[i];
-                l = this.xt ? this.xt(a) : a;
+                a = this.es[i];
+                l = this.qt ? this.qt(a) : a;
                 e = u.get(l);
                 if (e !== undefined && e !== -1) {
-                    y[e] = this.hs[i];
-                    A[e] = this.fs[i];
-                    r && (r[e] = this.cs[i]);
-                    n && (n[e] = this.ls[i]);
+                    y[e] = this.ns[i];
+                    A[e] = this.hs[i];
+                    r && (r[e] = this.fs[i]);
+                    n && (n[e] = this.cs[i]);
                     e = p[e];
                     u.set(l, e);
                 } else {
-                    (d ??= []).push(this.fs[i]);
+                    (d ??= []).push(this.hs[i]);
                     if (false && attrHooks !== null) ;
                 }
             }
@@ -343,39 +343,39 @@ function updateKeyedMap() {
             // into the fresh arrays, swap them in (new identity for downstream
             // change propagation), then dispose exited rows
                         for (i = 0; i < h; i++) {
-                y[i] = this.hs[i];
-                A[i] = this.fs[i];
-                r && (r[i] = this.cs[i]);
-                n && (n[i] = this.ls[i]);
+                y[i] = this.ns[i];
+                A[i] = this.hs[i];
+                r && (r[i] = this.fs[i]);
+                n && (n[i] = this.cs[i]);
             }
             for (e = h; e <= c; e++) {
                 if (r) setSignal(r[e], t[e]);
                 if (n) setSignal(n[e], e);
             }
             for (e = c + 1; e < s; e++) {
-                y[e] = this.hs[e - _];
-                A[e] = this.fs[e - _];
+                y[e] = this.ns[e - _];
+                A[e] = this.hs[e - _];
                 if (r) {
-                    r[e] = this.cs[e - _];
+                    r[e] = this.fs[e - _];
                     setSignal(r[e], t[e]);
                 }
                 if (n) {
-                    n[e] = this.ls[e - _];
+                    n[e] = this.cs[e - _];
                     if (_ !== 0) setSignal(n[e], e);
                 }
             }
-            this.hs = y;
-            this.fs = A;
-            r && (this.cs = r);
-            n && (this.ls = n);
-            this.ss = s;
+            this.ns = y;
+            this.hs = A;
+            r && (this.fs = r);
+            n && (this.cs = n);
+            this.ts = s;
             // save a copy of the mapped items for the next update
-                        this.rs = t.slice(0);
+                        this.es = t.slice(0);
             if (d) for (i = 0; i < d.length; i++) d[i].dispose();
             if (false && attrHooks !== null && m !== undefined && O !== undefined) ;
         }
     });
-    return this.hs;
+    return this.ns;
 }
 
 /**
@@ -395,21 +395,21 @@ function updateKeyedMap() {
  */ function repeat(t, s, i) {
     const e = s;
     const r = {
-        ts: createOwner(),
-        ss: 0,
-        ds: 0,
-        ws: t,
-        ns: e,
-        fs: [],
+        se: createOwner(),
+        ts: 0,
+        ps: 0,
+        ds: t,
+        rs: e,
         hs: [],
-        Os: i?.from,
-        ps: i?.fallback
+        ns: [],
+        ws: i?.from,
+        us: 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.ts.bt = n;
+        r.se.Qt = n;
     n.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
@@ -422,55 +422,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.ws();
-    const s = this.Os?.() || 0;
-    runWithOwner(this.ts, () => {
+    const t = this.ds();
+    const s = this.ws?.() || 0;
+    runWithOwner(this.se, () => {
         if (t === 0) {
-            if (this.ss !== 0) {
-                this.ts.dispose(false);
-                this.fs = [];
+            if (this.ts !== 0) {
+                this.se.dispose(false);
                 this.hs = [];
-                this.ss = 0;
+                this.ns = [];
+                this.ts = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.ds = 0;
+                                this.ps = 0;
             }
-            if (this.ps && !this.hs[0]) {
+            if (this.us && !this.ns[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.fs[0]?.dispose();
-                this.hs[0] = runWithOwner(this.fs[0] = createOwner(), this.ps);
+                this.hs[0]?.dispose();
+                this.ns[0] = runWithOwner(this.hs[0] = createOwner(), this.us);
             }
             return;
         }
         const i = s + t;
-        const e = this.ds + this.ss;
+        const e = this.ps + this.ts;
         // 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.ds);
+                const r = Math.max(s, this.ps);
         const n = Math.min(i, e);
         const o = new Array(t);
         const h = new Array(t);
         for (let t = r; t < n; t++) {
-            h[t - s] = this.fs[t - this.ds];
-            o[t - s] = this.hs[t - this.ds];
+            h[t - s] = this.hs[t - this.ps];
+            o[t - s] = this.ns[t - this.ps];
         }
         try {
             for (let t = s; t < i; t++) {
                 if (t >= r && t < n) continue;
-                o[t - s] = runWithOwner(h[t - s] = createOwner(), () => this.ns(t));
+                o[t - s] = runWithOwner(h[t - s] = createOwner(), () => this.rs(t));
             }
         } catch (t) {
             for (let t = s; t < i; t++) if ((t < r || t >= n) && h[t - s]) h[t - s].dispose();
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.ss === 0) this.fs[0]?.dispose(); else for (let t = this.ds; t < e; t++) if (t < s || t >= i) this.fs[t - this.ds].dispose();
-        this.hs = o;
-        this.fs = h;
-        this.ds = s;
-        this.ss = t;
+                if (this.ts === 0) this.hs[0]?.dispose(); else for (let t = this.ps; t < e; t++) if (t < s || t >= i) this.hs[t - this.ps].dispose();
+        this.ns = o;
+        this.hs = h;
+        this.ps = s;
+        this.ts = t;
     });
-    return this.hs;
+    return this.ns;
 }
 
 function compare(t, s, i) {

package/dist/prod/signals.js

@@ -4,7 +4,7 @@ import { computed, optimisticComputed, setSignal, optimisticSignal, runWithOwner
 
 import { cleanup, createRoot, getOwner, dispose, getObserver } from "./core/owner.js";
 
-import { globalQueue, Queue, entangleConfirmingTransitions, activeTransition } from "./core/scheduler.js";
+import { globalQueue, dirtyQueue, Queue, entangleConfirmingTransitions, activeTransition } from "./core/scheduler.js";
 
 import { CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_DIRECT_COMMIT, CONFIG_AUTHORITATIVE_READ, CONFIG_FRESH_READ } from "./core/constants.js";
 
@@ -327,7 +327,7 @@ function createMemo(e, t) {
             // route through the inherited queue.
             const i = getOwner();
             const o = new MicrotaskQueue;
-            o.qe = i.C;
+            o._parent = i.C;
  // notify() forwards up the normal chain
                         i.C = o;
             // A user effect rather than a bare computed: computeds are pull-based and
@@ -349,7 +349,7 @@ function createMemo(e, t) {
             // stale mainline value and resolves with old data.
             {
                 user: true,
-                Pt: CONFIG_DIRECT_COMMIT
+                kt: CONFIG_DIRECT_COMMIT
             });
         });
     });
@@ -442,7 +442,7 @@ function createMemo(e, t) {
                 if (i === null) {
                     i = getOwner();
                     const e = new MicrotaskQueue;
-                    e.qe = i.C;
+                    e._parent = i.C;
                     i.C = e;
                 }
                 return read(t);
@@ -454,7 +454,7 @@ function createMemo(e, t) {
                 dispose(i);
             }, {
                 user: true,
-                Pt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
+                kt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
             });
             make();
         });
@@ -505,12 +505,20 @@ function createMemo(e, t) {
  *
  * Must be called *outside* a tracking scope.
  *
+ * Inside an action, call it from a step: after an `await`, put a bare `yield`
+ * before `yield until(...)`. The runtime cannot hook an async generator's
+ * `await` continuation, so the `until(...)` expression — which CREATES the
+ * predicate's reader — would otherwise run outside the transaction; created
+ * there it is born held (A29) and replays only at the commit its own promise
+ * holds open (#3482). See {@link action}.
+ *
  * @example
  * ```ts
  * const send = action(async function* (text: string) {
  *   const clientId = crypto.randomUUID();
  *   setMessages(m => { m.push({ clientId, text, pending: true }); }); // optimistic
  *   await socket.send({ clientId, text }); // fire-and-forget transport
+ *   yield; // re-enter the transaction after the await
  *   // Hold until the live source echoes the write (authoritative view —
  *   // the optimistic row above cannot satisfy this):
  *   yield until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });
@@ -537,10 +545,10 @@ function createMemo(e, t) {
             // microtask so the promise can settle while the transaction the caller
             // yielded it into is still open — that transaction being open is the
             // entire point of the hold.
-            const s = getOwner();
-            const u = new MicrotaskQueue;
-            u.qe = s.C;
-            s.C = u;
+            const u = getOwner();
+            const s = new MicrotaskQueue;
+            s._parent = u.C;
+            u.C = s;
             let f;
             let a;
             const settle = e => {
@@ -569,7 +577,7 @@ function createMemo(e, t) {
             // the hold itself is keeping uncommitted.
             {
                 user: true,
-                Pt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
+                kt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
             });
             if (t?.timeout !== undefined) f = setTimeout(() => settle(() => i(new TimeoutError)), t.timeout);
             if (o !== undefined) {
@@ -691,12 +699,20 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.T & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
+    t && !(t.T & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, function fire() {
+        // Settled means derived. A settle that reverts optimism (or replays
+        // gated reads) only enqueues the affected subscribers; the pass after
+        // the commit re-derives them. Fired in the commit pass, the callback
+        // read the optimistic source already reverted beside a sync memo of it
+        // still holding the optimistic value — reads do not pull (#3411). Fall
+        // to the next pass while the heap has work; `run` swapped the queue,
+        // so this lands there, and `enqueue` keeps the drain alive.
+        if (dirtyQueue.EE >= dirtyQueue.et) return globalQueue.enqueue(EFFECT_USER, fire);
         // Unowned, out-of-band fire (no owner, or a children-forbidden one this
         // one-shot must not bind to): a returned cleanup has no lifecycle to
         // attach to. Reject it in dev; in production the return is simply
         // dropped — never bound to an unrelated owner or run eagerly.
-        e();
+                e();
     });
 }