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

package/dist/prod/map.js

@@ -21,7 +21,7 @@ function mapArray(t, e, i) {
     const n = e.length > 1;
     const r = e;
     const o = {
-        L: createOwner(),
+        H: createOwner(),
         it: 0,
         st: t,
         ot: [],
@@ -32,7 +32,7 @@ function mapArray(t, e, i) {
         ct: s || i?.keyed === false ? [] : undefined,
         lt: n && i?.keyed !== false ? [] : undefined,
         ut: i?.keyed === false,
-        H: i?.fallback
+        L: i?.fallback
     };
     const f = computed(updateKeyedMap.bind(o), undefined);
     f.l &= ~CONFIG_AUTO_DISPOSE;
@@ -263,11 +263,11 @@ function updateKeyedMap() {
     // the flight's reader (pending tracking + post-settle retry) instead of
     // vanishing. Set per pass: the first pass runs inside `computed()`, before
     // the node exists to the caller.
-    this.L.Ye = getOwner();
+    this.H.Ye = getOwner();
     const t = this.st() || [], e = t.length;
     t[$TRACK];
  // top level tracking (a store array's container node)
-        runWithOwner(this.L, () => {
+        runWithOwner(this.H, () => {
         let i, s, 
         // The stage slot a mapper writes its row/index signal into: `j` on the
         // create-all path, `j - start` on the general path, whose stage arrays
@@ -293,7 +293,7 @@ function updateKeyedMap() {
         // fast path for empty arrays
                 if (e === 0) {
             if (this.it !== 0) {
-                this.L.dispose(false);
+                this.H.dispose(false);
                 this.tn = [];
                 this.ot = [];
                 this.ht = [];
@@ -301,11 +301,11 @@ function updateKeyedMap() {
                 this.ct && (this.ct = []);
                 this.lt && (this.lt = []);
             }
-            if (this.H && !this.ht.length) {
+            if (this.L && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.tn[0]?.dispose();
-                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.H);
+                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.L);
             }
         }
         // fast path for new create
@@ -502,7 +502,7 @@ function updateKeyedMap() {
  */ function repeat(t, e, i) {
     const s = e;
     const n = {
-        L: createOwner(),
+        H: createOwner(),
         it: 0,
         dt: 0,
         wt: t,
@@ -510,7 +510,7 @@ function updateKeyedMap() {
         tn: [],
         ht: [],
         Ot: i?.from,
-        H: i?.fallback
+        L: i?.fallback
     };
     const r = computed(updateRepeat.bind(n));
     r.l &= ~CONFIG_AUTO_DISPOSE;
@@ -526,24 +526,24 @@ function updateKeyedMap() {
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
     // As in updateKeyedMap: the node is the row callbacks' reader, per pass.
-    this.L.Ye = getOwner();
+    this.H.Ye = getOwner();
     const t = this.wt();
     const e = this.Ot?.() || 0;
-    runWithOwner(this.L, () => {
+    runWithOwner(this.H, () => {
         if (t === 0) {
             if (this.it !== 0) {
-                this.L.dispose(false);
+                this.H.dispose(false);
                 this.tn = [];
                 this.ht = [];
                 this.it = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
                                 this.dt = 0;
             }
-            if (this.H && !this.ht.length) {
+            if (this.L && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.tn[0]?.dispose();
-                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.H);
+                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.L);
             }
             return;
         }

package/dist/prod/reveal.js

@@ -76,7 +76,7 @@ class RevealController {
     /** A slot that has left this controller's ownership: a boundary that has
      * shown content, a nested group that is ready. Shown is shown — it counts
      * as ready whatever happens to it later (a re-arm gates nobody else). */    gt(t) {
-        return (isController(t) ? t._parent : t.V) !== this;
+        return (isController(t) ? t._parent : t.v) !== this;
     }
     /** The slots this controller still owns, in registration order — the
      * ones the order's state is forced on. */    Lt(t) {
@@ -106,7 +106,7 @@ class RevealController {
         }
         return t !== "natural";
     }
-    oe(t) {
+    te(t) {
         if (this.At.includes(t)) return;
         this.At.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
@@ -118,13 +118,13 @@ class RevealController {
             t.ee = e;
             t._t();
         } else {
-            t.V = this;
+            t.v = this;
             t.$ = true;
             t.ee = e;
         }
         untrack(() => this._t());
     }
-    te(t) {
+    oe(t) {
         const e = this.At.indexOf(t);
         if (e >= 0) this.At.splice(e, 1);
         untrack(() => this._t());
@@ -194,8 +194,8 @@ class RevealController {
         });
         if (false) ;
         if (r) {
-            r.oe(i);
-            cleanup(() => r.te(i));
+            r.te(i);
+            cleanup(() => r.oe(i));
         }
         return e;
     });
@@ -204,9 +204,9 @@ 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),
-    P: t => t._t()
+    oe: (t, e) => t.oe(e),
+    V: t => t._t()
 });
 
 export { createRevealOrder };

package/dist/prod/signals.js

@@ -6,7 +6,7 @@ import { CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_AUTO_DISPOSE,
 
 import { computed, signal, runWithOwner, setMemo, setSignal, markRefresh, read, untrack } from "./core/core.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";
 
@@ -463,7 +463,7 @@ function createMemo(e, t) {
                 // guessed node's own re-ask is not answered by it (#3895): park
                 // on that flight, or reject with its error.
                                 const e = read(t);
-                if (t.l & CONFIG_GUESS && t.m & (STATUS_PENDING | STATUS_ERROR)) throw t.T?.F;
+                if (t.l & CONFIG_GUESS && t.m & (STATUS_PENDING | STATUS_ERROR)) throw t.T?.U;
                 return e;
             }, t => {
                 n(typeof e === "function" ? t : e);
@@ -657,7 +657,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.et >= dirtyQueue.Ge) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.et >= dirtyQueue.Fe) 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
@@ -666,4 +666,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/prod/store/affects.js

@@ -72,7 +72,7 @@ function scopeOf(e, o) {
     if (f !== undefined) {
         if (f.pb !== null) o.eo.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/prod/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/prod/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);
     };
@@ -274,7 +274,7 @@ function arrangementEqual(e, n, t) {
     if (!t) return fold(e, n);
     const i = e.O;
     if (i === undefined || e.ze !== $TRACK) return;
-    const r = e.T.v;
+    const r = e.T.P;
     if (!(r instanceof LaneView)) return;
     if (!Array.isArray(n) || !Array.isArray(r.rows)) {
         r.base = n;
@@ -318,7 +318,7 @@ function arrangementEqual(e, n, t) {
         // key's new object is the same row, its target adopted it).
                 if (n === undefined) {
             if (!sameRow(d[e], f[e], o)) laneSet(getNode(i, e), f[e], c);
-        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.v : d[e], f[e], o)) laneSet(n, f[e], c);
+        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.P : d[e], f[e], o)) laneSet(n, f[e], c);
     }
     if (p !== null) {
         for (let e = f.length; ;e++) {
@@ -342,8 +342,8 @@ function arrangementEqual(e, n, t) {
     const i = txOf(e);
     // A guess the screen never showed is void at the correction (D-34); a
     // keyed arrangement guess's view carries its removed-keys set.
-        if (!i.ke || !(t?.l & CONFIG_OVERRIDE) || !t.T.v?.removed) return false;
-    const r = e.T.v;
+        if (!i.ge || !(t?.l & CONFIG_OVERRIDE) || !t.T.P?.removed) return false;
+    const r = e.T.P;
     if ((!e.xe || !e.xe(r, n)) && !GlobalQueue.nn(r, n)) {
         i.folded = foldedRead;
         insertSubs(e);
@@ -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) {
@@ -383,8 +383,8 @@ function sameRow(e, n, t) {
     if (!(e.l & CONFIG_OVERRIDE)) {
         e.l |= CONFIG_OVERRIDE;
         list(e, t);
-    } else if (i.v === n) return;
-    i.v = n;
+    } else if (i.P === n) return;
+    i.P = n;
     if (e.o !== null) {
         insertSubs(e);
         laneDirty(e, 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.xe && r.xe(r.Ie, o)) continue;
-        r.Ie = o;
+        if (r.xe && r.xe(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.Me !== 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.Me !== 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.Me !== notifyEpoch) {
+    if (o !== null && o.o !== null && o.le instanceof LaneView && o.Me !== 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/prod/store/projection.js

@@ -1,4 +1,4 @@
-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";
 
@@ -118,8 +118,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;
@@ -127,12 +133,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);
     });
 }
 
@@ -158,6 +164,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;
@@ -187,7 +199,7 @@ function forEachFamilyNode(e, t) {
     // 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 asking = () => question || (i.T !== null && i.T.Ee !== null ? i.T.Te : 0);
     const f = wrapDraft(e, () => c.run === u && !isDisposed(i), o, s.s, 
     // A write after the run returned (a continuation, a callback) arms the
     // drain itself when no landing will.
@@ -234,7 +246,7 @@ 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);
     }, false);
@@ -246,14 +258,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;
 }
 
@@ -266,6 +278,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/prod/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);