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

package/dist/observe/boundaries.js

@@ -1,4 +1,4 @@
-import { STATUS_PENDING, STATUS_ERROR, CONFIG_REDERIVE, STATUS_UNINITIALIZED, CONFIG_HELD, EFFECT_RENDER, CONFIG_VERDICT, REACTIVE_DISPOSED, REACTIVE_LANE_READ, CONFIG_OVERRIDE, EFFECT_USER, EFFECT_TRACKED, REACTIVE_ZOMBIE, CAUGHT_REARMED } from "./core/constants.js";
+import { STATUS_PENDING, STATUS_ERROR, CONFIG_REDERIVE, CONFIG_HELD, CONFIG_FRAME, STATUS_UNINITIALIZED, EFFECT_RENDER, CONFIG_VERDICT, REACTIVE_DISPOSED, REACTIVE_LANE_READ, CONFIG_OVERRIDE, EFFECT_USER, EFFECT_TRACKED, REACTIVE_ZOMBIE, CAUGHT_REARMED } from "./core/constants.js";
 
 import { signal, runWithOwner, computed, read, setSignal, recompute } from "./core/core.js";
 
@@ -14,7 +14,7 @@ import { enqueueSub } from "./core/heap.js";
 
 import { createOwner, getOwner, cleanup, dispose } from "./core/owner.js";
 
-import { globalQueue, haltReactivityAt, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, passTx, resolveTx, schedule, txOf, unhold, laneStageHook, installBoundaryHooks } from "./core/scheduler.js";
+import { globalQueue, haltReactivityAt, haltReactivity, schedule, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, passTx, resolveTx, txOf, unhold, laneStageHook, installBoundaryHooks } from "./core/scheduler.js";
 
 import { attrHooks } from "./core/attribution-hooks.js";
 
@@ -69,6 +69,9 @@ import { accessor } from "./signals.js";
  * slot of (reveal.ts); a boundary clears it for its content — only direct
  * children are slots. */ const REVEAL = Symbol("");
 
+// Every call site checks the hooks themselves first (not only the slot or
+// controller, which are never set without them): a build that does not
+// import `createRevealOrder` folds the reveal-order arms away.
 let revealHooks = null;
 
 function setRevealHooks(e) {
@@ -98,9 +101,9 @@ const boundaryOf = e => e.A[BOUNDARY];
         // the same node.
         n ??= r.T?.F;
         r = n?.source ?? r;
-        const t = unwrapStatusError(n);
-        setSignal(e.F, t);
-        reportClientError(t, e.H, r);
+        const o = unwrapStatusError(n);
+        setSignal(e.F, o);
+        reportClientError(o, e.H, r);
     }
     record(e, r);
     if (e.h) flip(e);
@@ -108,7 +111,7 @@ const boundaryOf = e => e.A[BOUNDARY];
     // nothing on screen. The fallback is instantiated once per show — a later
     // error reaches it through the `error` accessor, which is why it is one.
         if (!e.L) redraw(e);
-    if (e.v !== null) revealHooks.P(e.v);
+    if (revealHooks && e.v !== null) revealHooks.P(e.v);
 }
 
 /** A re-armed boundary found something pending: fresh again, and the swap
@@ -120,7 +123,7 @@ const boundaryOf = e => e.A[BOUNDARY];
     e.V = e.B;
     const r = e.j;
     if (!e.V && r.l & CONFIG_HELD && txOf(r) !== flushTransaction) unhold(r);
-    if (e.V !== null && e.j !== null) laneStageHook(e.j, e.V, true, false);
+    if (laneStageHook && e.V !== null && e.j !== null) laneStageHook(e.j, e.V, true, false);
 }
 
 function redraw(e) {
@@ -143,17 +146,17 @@ function redraw(e) {
         // on screen changes, the fallback stays as it is.
         if (collecting.size !== 0) for (let r = boundaryOf(e); r; r = r._parent) if (!(e.m & unsettled(r)) && r.U.delete(e) && r.U.size === 0) {
             if (r.L) redraw(r);
-            if (r.v !== null) revealHooks.P(r.v);
+            if (revealHooks && r.v !== null) revealHooks.P(r.v);
         }
         return false;
     }
-    for (let t = boundaryOf(e); t; t = t._parent) {
-        if (!(t.i & r)) continue;
-        if (isCollecting(t)) {
-            caught(t, e, n);
-            return t.h ? CAUGHT_REARMED : true;
+    for (let o = boundaryOf(e); o; o = o._parent) {
+        if (!(o.i & r)) continue;
+        if (isCollecting(o)) {
+            caught(o, e, n);
+            return o.h ? CAUGHT_REARMED : true;
         }
-        record(t, e);
+        record(o, e);
     }
     return false;
 }
@@ -182,19 +185,19 @@ function redraw(e) {
  * still showing its fallback holds it again then. */ function heldRun(e) {
     const r = hiddenBy(e);
     if (r === undefined) return false;
-    (r.Z ??= new Set).add(e);
+    (r.M ??= new Set).add(e);
     return true;
 }
 
 /** The reveal: the runs held behind the fallback are this flush's, each in
  * its own phase — render updates with the frame that attaches the content,
  * user effects after it. */ function release(e) {
-    if (e.Z === null) return;
-    for (const r of e.Z) {
+    if (e.M === null) return;
+    for (const r of e.M) {
         const e = r.i;
-        globalQueue.enqueue(e === EFFECT_TRACKED ? EFFECT_USER : e, e === EFFECT_TRACKED ? r.M : r.W ??= GlobalQueue.K.bind(null, r));
+        globalQueue.enqueue(e === EFFECT_TRACKED ? EFFECT_USER : e, e === EFFECT_TRACKED ? r.Z : r.W ??= GlobalQueue.K.bind(null, r));
     }
-    e.Z = null;
+    e.M = null;
 }
 
 /** Drop the readers that settled or died. Settled: a loading reader no
@@ -206,9 +209,9 @@ function redraw(e) {
 
 function prune(e, r) {
     const n = unsettled(e);
-    for (const t of e.U) {
-        if (t.R & REACTIVE_DISPOSED) e.U.delete(t); else if (!(t.m & n)) {
-            if ((t !== e.Y || e.h) && (t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) {
+    for (const o of e.U) {
+        if (o.R & REACTIVE_DISPOSED) e.U.delete(o); else if (!(o.m & n)) {
+            if ((o !== e.Y || e.h) && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) {
                 // Landed, held: the content is that transaction's — the output's
                 // pass enters it and the reveal lands with the reader's run. The
                 // seam, past its park decision, waits for the commit instead. (A
@@ -217,9 +220,9 @@ function prune(e, r) {
                 // the reader is committed (#3540: what a fresh boundary catches holds
                 // nothing outside it).
                 if (!r || !e.D) continue;
-                joinFuture(txOf(t));
+                joinFuture(txOf(o));
             }
-            e.U.delete(t);
+            e.U.delete(o);
         }
     }
     return e.U.size;
@@ -252,7 +255,7 @@ function prune(e, r) {
         if (e.U.size === 0) {
             collecting.delete(e);
             if (e.L) redraw(e);
-            if (e.v !== null) revealHooks.P(e.v);
+            if (revealHooks && e.v !== null) revealHooks.P(e.v);
         }
     }
 }
@@ -278,6 +281,8 @@ function prune(e, r) {
         return;
     }
     e.h = true;
+    // The swap is the change's work: the output joins it (D-13, #3540).
+        e.j.l &= ~CONFIG_FRAME;
     // A verdict read in `on` (`isPending`, or a memo of one — #3528's
     // `createMemo(() => isPending(m2))`: the mark carries, core.ts `read`)
     // whose frame has no transaction yet: the swap is still display-ahead — the frame gets one now (it lands
@@ -313,12 +318,12 @@ function prune(e, r) {
     schedule();
 }
 
-function createBoundary(e, r, n, t) {
-    const o = createOwner();
+function createBoundary(e, r, n, o) {
+    const t = createOwner();
     const l = {
         i: e,
-        _parent: boundaryOf(o) ?? null,
-        H: o,
+        _parent: boundaryOf(t) ?? null,
+        H: t,
         Y: null,
         j: null,
         U: new Set,
@@ -327,7 +332,7 @@ function createBoundary(e, r, n, t) {
         B: null,
         V: null,
         L: false,
-        Z: null,
+        M: null,
         v: null,
         $: false,
         ee: false,
@@ -335,21 +340,21 @@ function createBoundary(e, r, n, t) {
         re: n,
         ne: null
     };
-    const u = e === STATUS_PENDING ? o.A[REVEAL] : null;
+    const u = e === STATUS_PENDING ? t.A[REVEAL] : null;
     if (getOwner()) cleanup(() => {
         collecting.delete(l);
-        if (u) revealHooks.te(u, l);
+        if (revealHooks && u) revealHooks.oe(u, l);
     });
     // The `on` dependencies live OUTSIDE the boundary, as the condition of a
     // `<Show>` wrapping it would: created before the owner's context names it.
     // A source of it going pending re-runs it (CONFIG_REDERIVE) rather than
     // marking it: the pass catches the NotReady — it is a notification, it
     // does not suspend the parent — and re-arms.
-        if (t) {
+        if (o) {
         let e = false;
-        runWithOwner(o, () => computed(() => {
+        runWithOwner(t, () => computed(() => {
             try {
-                t();
+                o();
             } catch (e) {
                 if (!(e instanceof NotReadyError)) {
                     if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
@@ -363,12 +368,12 @@ function createBoundary(e, r, n, t) {
         })).l |= CONFIG_REDERIVE;
     }
     const a = {
-        ...o.A,
+        ...t.A,
         [BOUNDARY]: l
     };
     if (revealHooks !== null) a[REVEAL] = null;
-    o.A = a;
-    const i = runWithOwner(o, () => {
+    t.A = a;
+    const s = runWithOwner(t, () => {
         const e = true ? computed(r, {
             name: "children"
         }) : computed(r);
@@ -376,23 +381,30 @@ function createBoundary(e, r, n, t) {
             name: "boundary"
         }) : computed(() => flatten(read(e)));
     });
-    l.Y = i;
+    l.Y = s;
     // A slot of the reveal order in its context (reveal.ts): gated until the
     // controller releases it — before the output's first pass.
-        if (u) revealHooks.oe(u, l);
-    const s = computed(() => {
+        if (revealHooks && u) revealHooks.te(u, l);
+    const i = computed(() => {
+        // Structure, not a derivation of its content (CONFIG_FRAME, #4283): it
+        // reads a hold it is not part of as the screen, as the render effect
+        // flattening the same children without a boundary would. Not while a
+        // re-arm's swap is the change's work (`arm`), until that swap commits
+        // (D-13, #3540).
+        const r = getOwner();
+        if (!l.h && !(r.l & CONFIG_HELD)) r.l |= CONFIG_FRAME;
         // Reveal order (reveal.ts): a gated slot shows its fallback — or, in a
         // collapsed tail, nothing — whatever its content's state; the
         // controller is told the pass ran (its readiness may have changed) and
         // releases it in turn.
-        if (l.$) {
+                if (l.$) {
             // Linked without being read: the tree settling (or changing)
             // re-derives this pass, which is how the controller hears of it.
             // It may release this very slot (the frontier whose content just
             // settled): the pass goes on to show it — the redraw it asks for is
             // refused mid-pass and not needed.
-            link(i, getOwner());
-            if (l.v !== null) revealHooks.P(l.v);
+            link(s, r);
+            if (revealHooks && l.v !== null) revealHooks.P(l.v);
             if (l.$) {
                 if (l.ee) {
                     l.L = true;
@@ -408,21 +420,21 @@ function createBoundary(e, r, n, t) {
         // display-ahead `on` causes is the lane's, and must still be the
         // fallback. Linked, so its recovery re-derives this pass; read again
         // once clean.
-                const r = i.m & (STATUS_PENDING | STATUS_ERROR);
-        if (r !== 0) {
-            link(i, getOwner());
-            if (r & e) {
+                const n = s.m & (STATUS_PENDING | STATUS_ERROR);
+        if (n !== 0) {
+            link(s, r);
+            if (n & e) {
                 if (isCollecting(l)) {
-                    caught(l, i, undefined);
+                    caught(l, s, undefined);
                     return fallback(l);
                 }
                 // Forwarded: a loading boundary showing content keeps it and
                 // holds the frame like any reader (recorded for its `on`).
-                                record(l, i);
+                                record(l, s);
             }
             // A pending passes an error boundary by (A6); an error, a loading
             // one; a loading boundary showing content forwards its pending.
-                        throw i.T.F;
+                        throw s.T.F;
         }
         if (isCollecting(l)) {
             // A29's boundary exemption (#3540): a boundary MOUNTED over a held
@@ -436,24 +448,23 @@ function createBoundary(e, r, n, t) {
             // enters: the outside sees its committed value until the landing,
             // which reveals the content — a fallback staged earlier is replaced
             // ahead of the commit and never shown.
-            const e = getOwner();
-            if (l.U.size !== 0 && e.m & STATUS_UNINITIALIZED && !(e.l & CONFIG_HELD)) return fallback(l);
+            if (l.U.size !== 0 && r.m & STATUS_UNINITIALIZED && !(r.l & CONFIG_HELD)) return fallback(l);
             // Readers under it still unready: the fallback, the tree untouched.
             // The seam re-derives this pass when they settle.
                         if (prune(l, true) !== 0) return fallback(l);
         }
-        let n;
+        let o;
         try {
-            n = read(i);
+            o = read(s);
         } catch (r) {
             if (r instanceof NotReadyError ? e === STATUS_PENDING : e === STATUS_ERROR) {
                 if (isCollecting(l)) {
-                    caught(l, i, r);
+                    caught(l, s, r);
                     return fallback(l);
                 }
                 // Forwarded: a loading boundary showing content keeps it and
                 // holds the frame like any reader (recorded for its `on`).
-                                record(l, i);
+                                record(l, s);
             }
             // A pending passes an error boundary by (A6).
                         throw r;
@@ -471,34 +482,44 @@ function createBoundary(e, r, n, t) {
         // landing when the frame parks (the run is held with it, as the old
         // children of a held pass are) — not now: a held swap keeps the
         // fallback on screen, live, until it commits. A pass back to the
-        // fallback before then finds it still built and keeps it.
+        // fallback before then finds it still built and keeps it. A fallback
+        // the screen does not show (a swap staged with a held frame, replaced
+        // before it commits) dies now: what it reads holds nothing (S-22 row
+        // 3′, #4268).
                 const t = l.ne;
-        if (t !== null) globalQueue.enqueue(EFFECT_RENDER, () => {
+        const drop = () => {
             if (!l.L && l.ne === t) {
+                // A fallback that threw (a rethrow the boundary does not
+                // handle) is what an enclosing boundary waits on: it died, and
+                // the seam of another round drops it there (#4270).
+                if (t.m & STATUS_ERROR) schedule();
                 dispose(t);
                 l.ne = null;
             }
-        });
+        };
+        if (t !== null) l.j.le !== t.le ? drop() : globalQueue.enqueue(EFFECT_RENDER, drop);
         release(l);
         // Shown: the slot leaves its reveal order (a later re-arm gates nobody
         // else; the frontier moves on).
-                if (l.v !== null) {
+                if (revealHooks && l.v !== null) {
             const e = l.v;
             l.v = null;
             revealHooks.P(e);
         }
-        return n;
+        return o;
     }, 
     // Boundary structure, not a user source: its value is fallback-or-content
     // and legitimately swaps mid-hydration (resume), so it must never be
     // frozen by snapshot capture.
     {
         name: "value",
-        le: true
+        ue: true
     });
-    s.l |= CONFIG_REDERIVE;
-    l.j = s;
-    return accessor(s);
+    i.l |= CONFIG_REDERIVE;
+    // The tree is structure too (the output's pass marks the output).
+        s.l |= CONFIG_FRAME;
+    l.j = i;
+    return accessor(i);
 }
 
 function fallback(e) {
@@ -541,7 +562,7 @@ function fallback(e) {
 
 const ERROR_SIGNAL = {
     ownedWrite: true,
-    le: true
+    ue: true
 };
 
 /**

package/dist/observe/core/action.js

@@ -70,6 +70,14 @@ import { attrHooks } from "./attribution-hooks.js";
  * yield until(() => todos.some(t => t.id === saved.id));
  * ```
  *
+ * The same holds inside an async helper the action yields
+ * (`yield (async () => { ... })()`): everything after its first `await` runs
+ * outside the transaction. An `await refresh(x)` or `await until(...)` there
+ * waits for this action's commit, which waits on the helper, so it hangs
+ * whenever `x` re-ran during the action (#4263) and works otherwise. Call
+ * `refresh(x)` in the generator once the helper returns; `yield` it only when
+ * the action needs the fresh value.
+ *
  * (For the same reason, don't call `flush()` inside an action body — it
  * cannot reveal the held writes and is refused.)
  *