@solidjs/signals 2.0.0-rc.18 → 2.0.0-rc.19

package/dist/observe/reveal.js

@@ -106,7 +106,7 @@ class RevealController {
         }
         return t !== "natural";
     }
-    oe(t) {
+    te(t) {
         if (this.Zt.includes(t)) return;
         this.Zt.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
@@ -124,7 +124,7 @@ class RevealController {
         }
         untrack(() => this.Bt());
     }
-    te(t) {
+    oe(t) {
         const e = this.Zt.indexOf(t);
         if (e >= 0) this.Zt.splice(e, 1);
         untrack(() => this.Bt());
@@ -194,8 +194,8 @@ class RevealController {
         });
         if (true) s._name = "reveal order";
         if (r) {
-            r.oe(i);
-            cleanup(() => r.te(i));
+            r.te(i);
+            cleanup(() => r.oe(i));
         }
         return e;
     });
@@ -204,8 +204,8 @@ class RevealController {
 // Installed at module evaluation — present exactly when something imports
 // `createRevealOrder`; a Loading boundary without one pays a null check.
 setRevealHooks({
-    oe: (t, e) => t.oe(e),
     te: (t, e) => t.te(e),
+    oe: (t, e) => t.oe(e),
     P: t => t.Bt()
 });
 

package/dist/observe/signals.js

@@ -8,7 +8,7 @@ import { computed, signal, runWithOwner, setMemo, setSignal, markRefresh, read,
 
 import { registerGraph } from "./core/dev.js";
 
-import { globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
+import { schedule, globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
 
 import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
@@ -343,14 +343,14 @@ function createMemo(e, t) {
     // or an already-displayed guess would satisfy it in a later slice. (REDERIVE
     // after: the first pass's own error is the promise's rejection.)
         computed(() => {
-        let i, u = false;
+        let u, i = false;
         try {
-            i = e();
+            u = e();
         } catch (e) {
             if (e instanceof NotReadyError) throw e;
             // An error is an answer (D-41): delivered by the same frame rule.
-                        i = unwrapStatusError(e);
-            u = true;
+                        u = unwrapStatusError(e);
+            i = true;
         }
         const s = getOwner();
         // A truth reader waits out a `createDeferred` flight its value derives
@@ -363,9 +363,9 @@ function createMemo(e, t) {
             staleReader(s, resolveTx(a));
             return;
         }
-        if (u) return void queueMicrotask(() => r(i));
-        o?.(i);
-        queueMicrotask(() => t(i));
+        if (i) return void queueMicrotask(() => r(u));
+        o?.(u);
+        queueMicrotask(() => t(u));
     }, {
         St: n
     }).l |= CONFIG_REDERIVE;
@@ -525,14 +525,14 @@ function createMemo(e, t) {
         // (`saving=true` beside the confirmed `version=1` is a tear no timeline
         // contains). Updates that do not flip the predicate reveal freely.
                 const c = flushTransaction;
-        createRoot(i => {
-            let u;
+        createRoot(u => {
+            let i;
             let s;
             const settle = e => {
-                if (u !== undefined) clearTimeout(u);
+                if (i !== undefined) clearTimeout(i);
                 if (s !== undefined) o.removeEventListener("abort", s);
                 e();
-                i();
+                u();
             };
             // Authoritative: the predicate sees the truth, never the action's own
             // optimistic guess — a guess cannot satisfy the wait for its own
@@ -547,7 +547,7 @@ function createMemo(e, t) {
                 // revealed with the action.
                 if (e && c !== null && globalQueue.q && resolveTx(c).tt !== 0) joinFuture(c);
             });
-            if (t?.timeout !== undefined) u = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
+            if (t?.timeout !== undefined) i = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
             if (o !== undefined) {
                 s = () => settle(() => n(o.reason));
                 o.addEventListener("abort", s, {
@@ -663,7 +663,7 @@ function createMemo(e, t) {
         // 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.jt >= dirtyQueue.st) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.jt >= dirtyQueue.lt) 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
@@ -672,4 +672,46 @@ function createMemo(e, t) {
     });
 }
 
-export { accessor, createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until };
+/**
+ * Schedules `callback` to run **once**, right after the pending flush
+ * finishes, in the same microtask checkpoint (before the browser paints).
+ * Unlike `onSettled`, it never waits on async work: if that flush is held by
+ * a pending transition, the callback still runs.
+ *
+ * Its main use is keeping a write out of another update's hold. Writes made
+ * in the same synchronous frame are applied together, so when one of them
+ * starts async work (a route change, a fetch), the others are held with it
+ * until it resolves. A write made in `onFlush` happens after that flush, so
+ * it is its own update: it commits on its own unless something it changes
+ * also derives from the held work (a memo or `createEffect` reading both),
+ * in which case it joins that hold as any later write would.
+ *
+ * Call it from event handlers and effect callbacks (including
+ * `createTrackedEffect` and `onSettled` bodies). In an owned scope such as a
+ * component body or a computation it warns in dev: use `onSettled` there.
+ *
+ * - A write in the callback lands after any write made inline in the same
+ *   frame. Don't write the same signal both inside and outside it; use a
+ *   functional setter if the order matters.
+ * - Several `onFlush` callbacks run in call order and batch into one flush.
+ * - `queueMicrotask` is not a substitute: called before the frame's first
+ *   write, it runs before that flush and its write joins it.
+ *
+ * @example
+ * ```tsx
+ * // A menu closes now even when the consumer's onSelect starts async work.
+ * const select = (id: string) => {
+ *   onFlush(() => setOpen(false));
+ *   props.onSelect?.(id);
+ * };
+ * ```
+ *
+ * @param callback Function to run once after the pending flush
+ */ function onFlush(e) {
+    // The frame's flush is queued (or already draining) ahead of this
+    // microtask, so the callback's writes start a flush of their own.
+    schedule();
+    queueMicrotask(e);
+}
+
+export { accessor, createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onFlush, onSettled, refresh, resolve, until };

package/dist/observe/store/affects.js

@@ -72,7 +72,7 @@ function scopeOf(e, o) {
     if (f !== undefined) {
         if (f.pb !== null) o.oo.add(f.v);
         // The writer's view: the tick's own unflushed guesses are in motion too.
-                if (f.fam?.opt === true) r = optHooks.view(f, r, true);
+                if (optHooks && f.fam?.opt === true) r = optHooks.view(f, r, true);
         const e = f.n;
         if (e !== null) for (const o of Reflect.ownKeys(e)) 
         // Another mark's carrier is its own channel: counting it here would

package/dist/observe/store/hooks.js

@@ -1,3 +1,6 @@
+// Set before any family is optimistic (`fam.opt`): a call site checks the
+// hooks first, so a build that does not import optimistic.ts folds the arm
+// away.
 let optHooks = null;
 
 function installOptHooks(o) {

package/dist/observe/store/optimistic.js

@@ -83,7 +83,7 @@ function notifyOptimisticWrites(e, n) {
     // inner store's truth for its key before guessing over it.
         const o = e.ch ? e.v : null;
     const guess = (e, n, i, r) => {
-        if (o !== null) e.Ie = i ? n in t : unwrapValue(t[n]);
+        if (o !== null) e.le = i ? n in t : unwrapValue(t[n]);
         // By value: a function leaf is a value, not an updater (#3017).
                 optimisticWrite(e, () => r);
     };
@@ -344,7 +344,7 @@ function arrangementEqual(e, n, t) {
     // keyed arrangement guess's view carries its removed-keys set.
         if (!i.It || !(t?.l & CONFIG_OVERRIDE) || !t.T.V?.removed) return false;
     const r = e.T.V;
-    if ((!e.Ye || !e.Ye(r, n)) && !GlobalQueue.sn(r, n)) {
+    if ((!e.je || !e.je(r, n)) && !GlobalQueue.sn(r, n)) {
         i.folded = foldedRead;
         insertSubs(e);
     } else GlobalQueue.tn?.(i);
@@ -365,8 +365,8 @@ function arrangementEqual(e, n, t) {
         const t = txOf(n);
         joinPassAt(e, resolveTx(t._parent ?? t));
     }
-    if (n.ue !== NOT_PENDING) return n.ue;
-    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.Ie;
+    if (n.ie !== NOT_PENDING) return n.ie;
+    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.le;
 }
 
 function sameRow(e, n, t) {
@@ -430,7 +430,7 @@ function sweepOverlaid() {
             // The container shows its backing again (a shown arrangement guess
             // that ended without a landing left its `LaneView` as the value).
                         const t = e.k;
-            if (t !== null && t.Ie instanceof LaneView) t.Ie = t.Ie.base;
+            if (t !== null && t.le instanceof LaneView) t.le = t.le.base;
         }
         if (n.size === 0) overlaidFamilies.delete(e);
     }
@@ -447,8 +447,8 @@ function sweepOverlaid() {
     if (i !== null) for (const e of Reflect.ownKeys(i)) {
         const r = i[e];
         const o = untrack(() => unwrapValue(n[e]));
-        if (r.Ye && r.Ye(r.Ie, o)) continue;
-        r.Ie = o;
+        if (r.je && r.je(r.le, o)) continue;
+        r.le = o;
         // (The lane's end notified it this epoch when the shown value and the
         // covered one differed — its readers re-derive already.)
                 if (r.o !== null && r.Ot !== notifyEpoch) {
@@ -460,8 +460,8 @@ function sweepOverlaid() {
     if (r !== null) for (const e of Reflect.ownKeys(r)) {
         const i = r[e];
         const o = untrack(() => e in n);
-        if (i.Ie === o) continue;
-        i.Ie = o;
+        if (i.le === o) continue;
+        i.le = o;
         if (i.o !== null && i.Ot !== notifyEpoch) {
             insertSubs(i);
             t = true;
@@ -470,9 +470,9 @@ function sweepOverlaid() {
     // The arrangement the readers saw (the shown guess) against the inner's
     // now: a structural reader re-derives when they differ.
         const o = e.k;
-    if (o !== null && o.o !== null && o.Ie instanceof LaneView && o.Ot !== notifyEpoch) {
+    if (o !== null && o.o !== null && o.le instanceof LaneView && o.Ot !== notifyEpoch) {
         const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
-        if (!arrangementEqual(o.Ie.rows, i, e.fam?.key ?? null)) {
+        if (!arrangementEqual(o.le.rows, i, e.fam?.key ?? null)) {
             insertSubs(o);
             t = true;
         }

package/dist/observe/store/projection.js

@@ -1,6 +1,6 @@
 import { attrHooks } from "../core/attribution-hooks.js";
 
-import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_UNINITIALIZED } from "../core/constants.js";
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_ERROR, STATUS_UNINITIALIZED } from "../core/constants.js";
 
 import { computed } from "../core/core.js";
 
@@ -80,8 +80,8 @@ import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.j
     };
     const s = {
         get(s, c) {
-            const u = read(() => e[c]);
-            return !o && typeof u === "object" && u !== null && c !== $TARGET ? wrapDraft(u, t, r, false, n, i) : u;
+            const a = read(() => e[c]);
+            return !o && typeof a === "object" && a !== null && c !== $TARGET ? wrapDraft(a, t, r, false, n, i) : a;
         },
         has: (t, r) => read(() => r in e),
         set: (t, r, o) => mutate(() => {
@@ -103,8 +103,8 @@ import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.j
     const c = new Proxy(Array.isArray(e) ? [] : {}, s);
     // The wrapper stands for its store proxy wherever the derive's result
     // carries it (`wrap`, `unwrapValue`, reconcile's slot matching).
-        const u = e[$TARGET];
-    if (u !== undefined) setLookup(c, u);
+        const a = e[$TARGET];
+    if (a !== undefined) setLookup(c, a);
     return c;
 }
 
@@ -120,8 +120,14 @@ function cloneState(e, t) {
  * (`notifyStatus`): a verdict or re-derive reader re-runs, any other is
  * pending derivatively on the derive (its readers hold; it re-runs at the
  * landing). The leaves do not subscribe to the derive, so the family does
- * the walk. */ function wakeFamily(e, t) {
-    const r = e.node;
+ * the walk. */ function wakeFamily(e) {
+    const t = e.node;
+    // Pending on the derive itself, whatever source took it there (an upstream
+    // memo's flight reaches it as a NotReady of that memo, #4271): the leaves
+    // are not that source's dependents, so only the family's settle — which
+    // retires the derive (`settleFamily`) — reaches the readers parked here. A
+    // reader the landing leaves unchanged does not re-run to clear it (#4305).
+        const r = new NotReadyError(t);
     e.woke = true;
     forEachFamilyNode(e, e => {
         if (e.o === null) return;
@@ -129,12 +135,12 @@ function cloneState(e, t) {
         // between them would: a dependent recovering one branch stays pending
         // through a leaf it still reads (core `retryReaches`), and the landing's
         // walk retires the copy first (`settleFamily` → `settlePendingSource`).
-                addPendingSource(e, r);
+                addPendingSource(e, t);
         // Its readers: core's propagation from the leaf — a verdict or re-derive
         // reader re-runs, any other is pending derivatively on the derive and
         // queued for the frame (held with it: the frame waits on the flight
         // through them, `blocked`).
-                propagateStatus(e, STATUS_PENDING, t);
+                propagateStatus(e, STATUS_PENDING, r);
     });
 }
 
@@ -160,6 +166,12 @@ function cloneState(e, t) {
     });
 }
 
+/** A source's status reached the derive by propagation (core
+ * `propagateStatus`), its pass not re-run: the family learns it as from the
+ * pass's own throw. */ function familyStatus(e) {
+    if (e & STATUS_PENDING) wakeFamily(this); else if (e & STATUS_ERROR) errorFamily(this);
+}
+
 function forEachFamilyNode(e, t) {
     for (const r of e.live) {
         const e = r.n;
@@ -179,18 +191,18 @@ function forEachFamilyNode(e, t) {
     const i = getOwner();
     const s = e[$TARGET];
     const c = s.fam;
-    const u = c.run = (c.run || 0) + 1;
+    const a = c.run = (c.run || 0) + 1;
     let l;
     // Open loading window (seedLoadingValue): the observable store IS commit #0
     // for the whole first flight — the derive works a detached shadow of the
     // seed so draft writes cannot tear through to readers (#2988). Every
     // commit point reconciles the shadow through the normal commit path.
-        const a = i.ce ? cloneState(s.v, s.s) : null;
+        const u = i.ce ? cloneState(s.v, s.s) : null;
     // The question a write of this run answers: inside a slice, the slice's
     // (the sync pass); in a continuation — the flight still registered — the
     // flight's (`handleAsync` stamped it with the action that asked).
-        const asking = () => question || (i.T !== null && i.T.Se !== null ? i.T.Ee : 0);
-    const f = wrapDraft(e, () => c.run === u && !isDisposed(i), n, s.s, 
+        const asking = () => question || (i.T !== null && i.T.Ee !== null ? i.T.de : 0);
+    const f = wrapDraft(e, () => c.run === a && !isDisposed(i), n, s.s, 
     // A write after the run returned (a continuation, a callback) arms the
     // drain itself when no landing will.
     () => {
@@ -199,14 +211,14 @@ function forEachFamilyNode(e, t) {
     // The creation run commits directly (a memo's first value is its
     // `_value`); every later run — a re-derive in a flush, an async landing
     // — stages and commits with the flush like a memo's recompute.
-        const d = u === 1;
+        const d = a === 1;
     const pass = () => storeSetter(f, n => {
-        l = t(a ?? n);
+        l = t(u ?? n);
         const commit = t => {
             // Shadow run: commit a detached snapshot, never the shadow itself
             // (adoption takes the value by identity — handing it the live
             // shadow would fuse the draft to the observable store).
-            if (a && (t === undefined || t === a)) t = cloneState(a, s.s);
+            if (u && (t === undefined || t === u)) t = cloneState(u, s.s);
             if (t !== n && t !== undefined) {
                 const write = () => {
                     const o = question;
@@ -228,7 +240,7 @@ function forEachFamilyNode(e, t) {
             // (a fallback value, not pending) re-runs too (#4070).
                         insertSubs(i);
         };
-        const u = handleAsync(i, l, commit, (e, t) => {
+        const a = handleAsync(i, l, commit, (e, t) => {
             // The flight rejected: the leaves' readers learn it from here —
             // they do not subscribe to the derive. Pending again (a NotReady
             // rejection): the wake, as for the pass. Errored: every live
@@ -236,9 +248,9 @@ function forEachFamilyNode(e, t) {
             // #2897) — and the flush that runs them advances the clock, so a
             // later tracked re-read may retry (core `read`).
             if (d && i.m & STATUS_UNINITIALIZED) return;
-            if (t) wakeFamily(c, e); else errorFamily(c);
+            if (t) wakeFamily(c); else errorFamily(c);
         });
-        if (!i.ce) commit(u);
+        if (!i.ce) commit(a);
     }, false);
     try {
         d ? runDirect(pass) : pass();
@@ -248,14 +260,14 @@ function forEachFamilyNode(e, t) {
         // they do not subscribe to the derive.
         // A synchronous error the same way (#3956: a rerun that finds the
         // entry failed throws): every live reader re-derives and meets it.
-        if (!d) e instanceof NotReadyError ? wakeFamily(c, e) : errorFamily(c);
+        if (!d) e instanceof NotReadyError ? wakeFamily(c) : errorFamily(c);
         throw e;
     }
     // A pass that returned with a flight up (an iterator's sync first yield):
     // the wake, as for the throw. Not a sync pass that superseded one — the
     // status it reads is the dead flight's, cleared when this pass settles
     // (#3181: a reader the settle walk had just released, re-parked for good).
-        if (i.m & STATUS_PENDING && i.T.Se !== null && !i.ce && !d) wakeFamily(c, i.T?.F);
+        if (i.m & STATUS_PENDING && i.T.Ee !== null && !i.ce && !d) wakeFamily(c);
     return i;
 }
 
@@ -268,6 +280,7 @@ function createProjectionInternal(e, t, r) {
         map: new WeakMap,
         node: null,
         live: new Set,
+        st: familyStatus,
         shallow: !!r?.shallow,
         // The row key, for a child paired after the adoption (store.ts
         // `adoptChild`, #3712) as the adoption pairs them.

package/dist/observe/store/reconcile.js

@@ -31,7 +31,7 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
     // truth but an optimistic edit — the keyed diff is written into the draft
     // (a matched row keeps its proxy, its changed leaves become its guesses),
     // and the setter's exit turns the draft into guesses like any.
-        if (userWriting() && f.fam?.opt === true) {
+        if (optHooks && userWriting() && f.fam?.opt === true) {
         optHooks.reconcile(n, unwrapValue(e), i);
         return;
     }
@@ -72,7 +72,7 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
     // Q-D: a landing on an optimistic family is reconciled against the VIEW
     // — key matching from the arrangement the guesses made (R28), so a row
     // the guess added keeps its proxy when the server returns it.
-        const i = e.fam?.opt === true ? optHooks.view(e, f) : f;
+        const i = optHooks && e.fam?.opt === true ? optHooks.view(e, f) : f;
     const l = Array.isArray(n);
     const r = e.s === true;
     adoptPB(e, n, false);