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

package/dist/observe/index.js

@@ -14,7 +14,9 @@ import "./core/invariants.js";
 
 import { OBSERVE as OBSERVE$1 } from "./core/dev.js";
 
-export { enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
+export { ownerPath } from "./core/dev.js";
+
+export { ROOT_ERROR_HOOK, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
 
 export { isPending, latest } from "./core/verdict.js";
 
@@ -22,6 +24,8 @@ import "./core/effect.js";
 
 export { action } from "./core/action.js";
 
+export { configureClientErrors } from "./core/error-hooks.js";
+
 export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until } from "./signals.js";
 
 export { affects } from "./affects.js";
@@ -34,12 +38,12 @@ export { createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten
 
 export { $PROXY, $TARGET, $TRACK, isWrappable } from "./store/store.js";
 
+export { MergeView, OmitView, SOURCE_MEMO, SOURCE_MERGE, SOURCE_OMIT, SOURCE_PLAIN, SOURCE_PROXY, hasStaticKeys, isStatic, merge, mergeSources, mergeView, omit, omitView, resolvedTable, sourceGet, sourceHas, sourceKeys, sourceOwners, viewOf } from "./store/utils.js";
+
 export { createOptimisticStoreNext as createOptimisticStore } from "./store/next/optimistic.js";
 
 export { createProjectionNext as createProjection } from "./store/next/projection.js";
 
-export { merge, mergeSources, omit } from "./store/utils.js";
-
 export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store/next/store.js";
 
 export { storePath } from "./store/storePath.js";

package/dist/observe/map.js

@@ -10,6 +10,8 @@ import { attrHooks } from "./core/attribution-hooks.js";
 
 import "./core/invariants.js";
 
+import "./core/dev.js";
+
 import "./core/verdict.js";
 
 import "./core/effect.js";
@@ -20,31 +22,31 @@ import { $TRACK } from "./store/store.js";
 
 import "./store/next/store.js";
 
-function mapArray(t, s, i) {
-    const e = typeof i?.keyed === "function" ? i.keyed : undefined;
+function mapArray(t, s, e) {
+    const i = typeof e?.keyed === "function" ? e.keyed : undefined;
     const r = s.length > 1;
     const n = s;
     const o = {
-        an: createOwner(),
+        nt: createOwner(),
         ts: 0,
         ss: t,
         es: [],
         rs: n,
         ns: [],
         hs: [],
-        _n: e,
-        fs: e || i?.keyed === false ? [] : undefined,
-        cs: r && i?.keyed !== false ? [] : undefined,
-        us: i?.keyed === false,
-        ls: i?.fallback
+        En: i,
+        fs: i || e?.keyed === false ? [] : undefined,
+        cs: r && e?.keyed !== false ? [] : undefined,
+        us: e?.keyed === false,
+        ls: e?.fallback
     };
-    const h = computed(updateKeyedMap.bind(o), i?.name ? {
-        name: i.name
+    const h = computed(updateKeyedMap.bind(o), e?.name ? {
+        name: e.name
     } : 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.an.ln = h;
-    h.T &= ~CONFIG_AUTO_DISPOSE;
+        o.nt.fn = h;
+    h.C &= ~CONFIG_AUTO_DISPOSE;
     return accessor(h);
 }
 
@@ -52,7 +54,7 @@ const pureOptions = {
     ownedWrite: true
 };
 
-function trySmallMove(t, s, i, e) {
+function trySmallMove(t, s, e, i) {
     const r = t.es;
     const n = t.ts - 1;
     const o = [];
@@ -60,13 +62,13 @@ function trySmallMove(t, s, i, e) {
     const f = [];
  // flat triples: oldStart, newStart, length
         let c = 256;
-    let a = e;
-    let u = e;
+    let a = i;
+    let u = i;
     let l = false;
-    while (a <= n && u <= i - 1) {
+    while (a <= n && u <= e - 1) {
         const t = r[a];
-        const e = s[u];
-        if (t === e) {
+        const i = s[u];
+        if (t === i) {
             if (!l) {
                 f.push(a, u, 0);
                 l = true;
@@ -81,17 +83,17 @@ function trySmallMove(t, s, i, e) {
                 let d = -1;
         let p = Math.min(32 - o.length, n - a, c);
         for (let t = 1; t <= p; t++) {
-            if (r[a + t] === e) {
+            if (r[a + t] === i) {
                 d = t;
                 break;
             }
         }
         c -= d === -1 ? p : d;
         let w = -1;
-        p = Math.min(32 - h.length, i - 1 - u, c);
-        for (let i = 1; i <= p; i++) {
-            if (s[u + i] === t) {
-                w = i;
+        p = Math.min(32 - h.length, e - 1 - u, c);
+        for (let e = 1; e <= p; e++) {
+            if (s[u + e] === t) {
+                w = e;
                 break;
             }
         }
@@ -112,11 +114,11 @@ function trySmallMove(t, s, i, e) {
         if (o.length === 32) return false;
         o.push(a);
     }
-    for (;u <= i - 1; u++) {
+    for (;u <= e - 1; u++) {
         if (h.length === 32) return false;
         h.push(u);
     }
-    return commitSmallMove(t, s, i, o, h, f);
+    return commitSmallMove(t, s, e, o, h, f);
 }
 
 /** PHASE 2 of the small-move path, in its OWN function so that a pass which
@@ -125,17 +127,17 @@ function trySmallMove(t, s, i, e) {
  * per function, and cold `replace` measured +0.5 ms with both phases in one
  * 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) {
+ * arrays, copy shifted runs, patch displaced pairs, dispose leftovers. */ function commitSmallMove(t, s, e, i, r, n) {
     const o = t.es;
     let h;
     let f;
     let c;
     if (r.length !== 0) {
-        c = new Array(e.length);
+        c = new Array(i.length);
         for (f = 0; f < r.length; f++) {
             let t = -1;
-            for (h = 0; h < e.length; h++) {
-                if (!c[h] && o[e[h]] === s[r[f]]) {
+            for (h = 0; h < i.length; h++) {
+                if (!c[h] && o[i[h]] === s[r[f]]) {
                     t = h;
                     break;
                 }
@@ -152,42 +154,42 @@ function trySmallMove(t, s, i, e) {
     // and if a displaced identity also occurs inside a run the two algorithms
     // can hand different occurrences different owners (row-local state moves;
     // a shrink could dispose the wrong one). Decline that case — general path.
-        if (e.length !== 0 || r.length !== 0) {
+        if (i.length !== 0 || r.length !== 0) {
         const t = new Set;
-        for (h = 0; h < e.length; h++) t.add(o[e[h]]);
+        for (h = 0; h < i.length; h++) t.add(o[i[h]]);
         for (f = 0; f < r.length; f++) t.add(s[r[f] >> 6]);
         for (let s = 0; s < n.length; s += 3) {
-            const i = n[s];
-            for (let e = 0, r = n[s + 2]; e < r; e++) if (t.has(o[i + e])) return false;
+            const e = n[s];
+            for (let i = 0, r = n[s + 2]; i < r; i++) if (t.has(o[e + i])) return false;
         }
     }
     const a = t.ns;
     const u = t.hs;
-    const l = a.slice(0, i);
-    const d = u.slice(0, i);
+    const l = a.slice(0, e);
+    const d = u.slice(0, e);
     for (let t = 0; t < n.length; t += 3) {
         const s = n[t];
-        const i = n[t + 1];
-        if (s !== i) {
-            for (let e = 0; e < n[t + 2]; e++) {
-                l[i + e] = a[s + e];
-                d[i + e] = u[s + e];
+        const e = n[t + 1];
+        if (s !== e) {
+            for (let i = 0; i < n[t + 2]; i++) {
+                l[e + i] = a[s + i];
+                d[e + i] = u[s + i];
             }
         }
     }
     for (f = 0; f < r.length; f++) {
         const t = r[f] >> 6;
-        const s = e[r[f] & 63];
+        const s = i[r[f] & 63];
         l[t] = a[s];
         d[t] = u[s];
     }
     t.ns = l;
     t.hs = d;
-    t.ts = i;
+    t.ts = e;
     t.es = s.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
-        for (h = 0; h < e.length; h++) {
-        if (c === undefined || !c[h]) u[e[h]].dispose();
+        for (h = 0; h < i.length; h++) {
+        if (c === undefined || !c[h]) u[i[h]].dispose();
     }
     return true;
 }
@@ -196,29 +198,29 @@ function updateKeyedMap() {
     const t = this.ss() || [], s = t.length;
     t[$TRACK];
  // top level tracking
-        runWithOwner(this.an, () => {
-        let i, e, r, n, 
+        runWithOwner(this.nt, () => {
+        let e, i, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
         o = this.fs ? this.us ? () => {
-            r[e] = signal(t[e], pureOptions);
-            return this.rs(accessor(r[e]), e);
+            r[i] = signal(t[i], pureOptions);
+            return this.rs(accessor(r[i]), i);
         } : () => {
-            r[e] = signal(t[e], pureOptions);
-            n && (n[e] = signal(e, pureOptions));
-            return this.rs(accessor(r[e]), n ? accessor(n[e]) : undefined);
+            r[i] = signal(t[i], pureOptions);
+            n && (n[i] = signal(i, pureOptions));
+            return this.rs(accessor(r[i]), n ? accessor(n[i]) : undefined);
         } : this.cs ? () => {
-            const s = t[e];
-            n[e] = signal(e, pureOptions);
-            return this.rs(s, accessor(n[e]));
+            const s = t[i];
+            n[i] = signal(i, pureOptions);
+            return this.rs(s, accessor(n[i]));
         } : () => {
-            const s = t[e];
+            const s = t[i];
             return this.rs(s);
         };
         // fast path for empty arrays
                 if (s === 0) {
             if (this.ts !== 0) {
-                this.an.dispose(false);
+                this.nt.dispose(false);
                 this.hs = [];
                 this.es = [];
                 this.ns = [];
@@ -240,9 +242,9 @@ function updateKeyedMap() {
             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);
+                for (i = 0; i < s; i++) h[i] = runWithOwner(f[i] = createOwner(), o);
             } catch (t) {
-                for (i = 0; i <= e; i++) f[i]?.dispose();
+                for (e = 0; e <= i; e++) f[e]?.dispose();
                 throw t;
             }
             // commit
@@ -260,12 +262,12 @@ function updateKeyedMap() {
             // entered rows, for the list-identity census.
             m, O;
             // skip common prefix
-                        for (h = 0, f = Math.min(this.ts, s); h < f && (this.es[h] === t[h] || this.fs && compare(this._n, this.es[h], t[h])); h++) {
+                        for (h = 0, f = Math.min(this.ts, s); h < f && (this.es[h] === t[h] || this.fs && compare(this.En, 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.ts - 1, c = s - 1; f >= h && c >= h && (this.es[f] === t[c] || this.fs && compare(this._n, this.es[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.En, 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
@@ -287,11 +289,11 @@ function updateKeyedMap() {
                 // every page's first structural pass usually is) has it nowhere.
                 // ~65 compares, no allocation, and the scan function is never
                 // compiled for a replace (its cold first-call compile was the cost).
-                const i = h + (c - h >> 1);
-                const e = t[i];
-                const r = Math.min(f, i + 32);
-                let n = Math.max(h, i - 32);
-                while (n <= r && this.es[n] !== e) n++;
+                const e = h + (c - h >> 1);
+                const i = t[e];
+                const r = Math.min(f, e + 32);
+                let n = Math.max(h, e - 32);
+                while (n <= r && this.es[n] !== i) n++;
                 if (n <= r && trySmallMove(this, t, s, h)) return;
             }
             const _ = s - this.ts;
@@ -303,67 +305,67 @@ function updateKeyedMap() {
             // scanning backwards so we encounter them in natural order
                         l = new Map;
             d = new Array(c + 1);
-            for (e = c; e >= h; e--) {
-                a = t[e];
-                u = this._n ? this._n(a) : a;
-                i = l.get(u);
-                d[e] = i === undefined ? -1 : i;
-                l.set(u, e);
+            for (i = c; i >= h; i--) {
+                a = t[i];
+                u = this.En ? this.En(a) : a;
+                e = l.get(u);
+                d[i] = e === undefined ? -1 : e;
+                l.set(u, i);
             }
             // 1) step through the old changed window and see if items can be found
             // 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.es[i];
-                u = this._n ? this._n(a) : a;
-                e = l.get(u);
-                if (e !== undefined && e !== -1) {
-                    y[e] = this.ns[i];
-                    A[e] = this.hs[i];
-                    r && (r[e] = this.fs[i]);
-                    n && (n[e] = this.cs[i]);
-                    e = d[e];
-                    l.set(u, e);
+                        for (e = h; e <= f; e++) {
+                a = this.es[e];
+                u = this.En ? this.En(a) : a;
+                i = l.get(u);
+                if (i !== undefined && i !== -1) {
+                    y[i] = this.ns[e];
+                    A[i] = this.hs[e];
+                    r && (r[i] = this.fs[e]);
+                    n && (n[i] = this.cs[e]);
+                    i = d[i];
+                    l.set(u, i);
                 } else {
-                    (p ??= []).push(this.hs[i]);
+                    (p ??= []).push(this.hs[e]);
                     if (true && attrHooks !== null) (m ??= []).push(a);
                 }
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
-                for (e = h; e <= c; e++) {
-                    if (A[e] !== undefined) continue;
-                    (w ??= []).push(A[e] = createOwner());
-                    if (true && attrHooks !== null) (O ??= []).push(t[e]);
-                    y[e] = runWithOwner(A[e], o);
+                for (i = h; i <= c; i++) {
+                    if (A[i] !== undefined) continue;
+                    (w ??= []).push(A[i] = createOwner());
+                    if (true && attrHooks !== null) (O ??= []).push(t[i]);
+                    y[i] = runWithOwner(A[i], o);
                 }
             } catch (t) {
-                if (w) for (i = 0; i < w.length; i++) w[i].dispose();
+                if (w) for (e = 0; e < w.length; e++) w[e].dispose();
                 throw t;
             }
             // 3) commit: land the retained prefix and suffix plus the staged window
             // 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.ns[i];
-                A[i] = this.hs[i];
-                r && (r[i] = this.fs[i]);
-                n && (n[i] = this.cs[i]);
+                        for (e = 0; e < h; e++) {
+                y[e] = this.ns[e];
+                A[e] = this.hs[e];
+                r && (r[e] = this.fs[e]);
+                n && (n[e] = this.cs[e]);
             }
-            for (e = h; e <= c; e++) {
-                if (r) setSignal(r[e], t[e]);
-                if (n) setSignal(n[e], e);
+            for (i = h; i <= c; i++) {
+                if (r) setSignal(r[i], t[i]);
+                if (n) setSignal(n[i], i);
             }
-            for (e = c + 1; e < s; e++) {
-                y[e] = this.ns[e - _];
-                A[e] = this.hs[e - _];
+            for (i = c + 1; i < s; i++) {
+                y[i] = this.ns[i - _];
+                A[i] = this.hs[i - _];
                 if (r) {
-                    r[e] = this.fs[e - _];
-                    setSignal(r[e], t[e]);
+                    r[i] = this.fs[i - _];
+                    setSignal(r[i], t[i]);
                 }
                 if (n) {
-                    n[e] = this.cs[e - _];
-                    if (_ !== 0) setSignal(n[e], e);
+                    n[i] = this.cs[i - _];
+                    if (_ !== 0) setSignal(n[i], i);
                 }
             }
             this.ns = y;
@@ -373,8 +375,8 @@ function updateKeyedMap() {
             this.ts = s;
             // save a copy of the mapped items for the next update
                         this.es = t.slice(0);
-            if (p) for (i = 0; i < p.length; i++) p[i].dispose();
-            if (true && attrHooks !== null && m !== undefined && O !== undefined) attrHooks.listChurn(this.an.ln, m, O, s, this._n !== undefined);
+            if (p) for (e = 0; e < p.length; e++) p[e].dispose();
+            if (true && attrHooks !== null && m !== undefined && O !== undefined) attrHooks.listChurn(this.nt.fn, m, O, s, this.En !== undefined);
         }
     });
     return this.ns;
@@ -394,25 +396,25 @@ function updateKeyedMap() {
  * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
- */ function repeat(t, s, i) {
-    const e = s;
+ */ function repeat(t, s, e) {
+    const i = s;
     const r = {
-        an: createOwner(),
+        nt: createOwner(),
         ts: 0,
         ds: 0,
         ps: t,
-        rs: e,
+        rs: i,
         hs: [],
         ns: [],
-        ws: i?.from,
-        ls: i?.fallback
+        ws: e?.from,
+        ls: e?.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.an.ln = n;
-    n.T &= ~CONFIG_AUTO_DISPOSE;
+        r.nt.fn = n;
+    n.C &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
 
@@ -426,10 +428,10 @@ function updateKeyedMap() {
 function updateRepeat() {
     const t = this.ps();
     const s = this.ws?.() || 0;
-    runWithOwner(this.an, () => {
+    runWithOwner(this.nt, () => {
         if (t === 0) {
             if (this.ts !== 0) {
-                this.an.dispose(false);
+                this.nt.dispose(false);
                 this.hs = [];
                 this.ns = [];
                 this.ts = 0;
@@ -444,12 +446,12 @@ function updateRepeat() {
             }
             return;
         }
-        const i = s + t;
-        const e = this.ds + this.ts;
+        const e = s + t;
+        const i = this.ds + 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 n = Math.min(i, e);
+        const n = Math.min(e, i);
         const o = new Array(t);
         const h = new Array(t);
         for (let t = r; t < n; t++) {
@@ -457,16 +459,16 @@ function updateRepeat() {
             o[t - s] = this.ns[t - this.ds];
         }
         try {
-            for (let t = s; t < i; t++) {
+            for (let t = s; t < e; t++) {
                 if (t >= r && t < n) continue;
                 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();
+            for (let t = s; t < e; 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.ts === 0) this.hs[0]?.dispose(); else for (let t = this.ds; t < e; t++) if (t < s || t >= i) this.hs[t - this.ds].dispose();
+                if (this.ts === 0) this.hs[0]?.dispose(); else for (let t = this.ds; t < i; t++) if (t < s || t >= e) this.hs[t - this.ds].dispose();
         this.ns = o;
         this.hs = h;
         this.ds = s;
@@ -475,8 +477,8 @@ function updateRepeat() {
     return this.ns;
 }
 
-function compare(t, s, i) {
-    return t ? t(s) === t(i) : true;
+function compare(t, s, e) {
+    return t ? t(s) === t(e) : true;
 }
 
 export { mapArray, repeat };

package/dist/observe/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";
 
@@ -69,7 +69,7 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const r = computed(e, t);
-        r.T &= ~CONFIG_AUTO_DISPOSE;
+        r.C &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), setMemo.bind(null, r) ];
     }
     const r = signal(e, t);
@@ -330,9 +330,9 @@ function createMemo(e, t) {
             // route through the inherited queue.
             const i = getOwner();
             const o = new MicrotaskQueue;
-            o.Nt = i.C;
+            o._parent = i.T;
  // notify() forwards up the normal chain
-                        i.C = o;
+                        i.T = o;
             // A user effect rather than a bare computed: computeds are pull-based and
             // are only re-enqueued when a pending source *resolves* — a rejection just
             // marks them errored, so nothing would re-run and the promise would never
@@ -352,7 +352,7 @@ function createMemo(e, t) {
             // stale mainline value and resolves with old data.
             {
                 user: true,
-                Kt: CONFIG_DIRECT_COMMIT
+                Xt: CONFIG_DIRECT_COMMIT
             });
         });
     });
@@ -445,8 +445,8 @@ function createMemo(e, t) {
                 if (i === null) {
                     i = getOwner();
                     const e = new MicrotaskQueue;
-                    e.Nt = i.C;
-                    i.C = e;
+                    e._parent = i.T;
+                    i.T = e;
                 }
                 return read(t);
             }, t => {
@@ -457,7 +457,7 @@ function createMemo(e, t) {
                 dispose(i);
             }, {
                 user: true,
-                Kt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
+                Xt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
             });
             make();
         });
@@ -508,12 +508,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 });
@@ -540,10 +548,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.Nt = s.C;
-            s.C = u;
+            const u = getOwner();
+            const s = new MicrotaskQueue;
+            s._parent = u.T;
+            u.T = s;
             let f;
             let a;
             const settle = e => {
@@ -572,7 +580,7 @@ function createMemo(e, t) {
             // the hold itself is keeping uncommitted.
             {
                 user: true,
-                Kt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
+                Xt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
             });
             if (t?.timeout !== undefined) f = setTimeout(() => settle(() => i(new TimeoutError)), t.timeout);
             if (o !== undefined) {
@@ -592,7 +600,7 @@ function createOptimistic(e, t) {
     installOptimisticEngine();
     if (typeof e === "function") {
         const r = optimisticComputed(e, t);
-        r.T &= ~CONFIG_AUTO_DISPOSE;
+        r.C &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), setSignal.bind(null, r) ];
     }
     const r = optimisticSignal(e, t);
@@ -695,14 +703,22 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.T & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), {
+    t && !(t.C & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), {
         name: "onSettled"
-    }) : globalQueue.enqueue(EFFECT_USER, () => {
+    }) : 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.Ct) 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();
     });
 }