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

package/dist/prod/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_HELD, REACTIVE_STAGED_READ, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, NewSet, REACTIVE_DIRTY, NOT_PENDING, REACTIVE_DISPOSED, CONFIG_REDERIVE, CONFIG_VERDICT, CONFIG_OVERRIDE } from "./constants.js";
+import { STATUS_ERROR, STATUS_PENDING, STATUS_NO_VALUE, STATUS_UNINITIALIZED, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_HELD, REACTIVE_STAGED_READ, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, NewSet, REACTIVE_DIRTY, CONFIG_INPUTS_PUBLISHED, NOT_PENDING, REACTIVE_DISPOSED, CONFIG_REDERIVE, CONFIG_VERDICT, CONFIG_OVERRIDE } from "./constants.js";
 
 import { ext, statusNotifierOf, context, untrack, setSignal } from "./core.js";
 
@@ -67,16 +67,16 @@ function retryReaches(e, n) {
 
 function setPendingError(e, n, t) {
     if (!n) {
-        if (e.T !== null) e.T.F = null;
+        if (e.T !== null) e.T.U = null;
         return;
     }
     if (t instanceof NotReadyError && t.source === n) {
-        ext(e).F = t;
+        ext(e).U = t;
         return;
     }
-    const r = e.T?.F;
+    const r = e.T?.U;
     if (!(r instanceof NotReadyError) || r.source !== n) {
-        ext(e).F = new NotReadyError(n);
+        ext(e).U = new NotReadyError(n);
     }
 }
 
@@ -152,7 +152,7 @@ function releaseSettledDependents(e) {
         clearPendingSources(e);
     if (e.T) e.T.se = false;
     if (!((e.m &= STATUS_ERROR | STATUS_UNINITIALIZED) & STATUS_ERROR)) setPendingError(e);
-    e.ue = n instanceof StatusError ? n : new StatusError(e, n);
+    e.ie = n instanceof StatusError ? n : new StatusError(e, n);
     e.l |= CONFIG_STAGED | CONFIG_STAGED_ERROR;
     // Readers parked on the flight re-run and derive from the staging; the
     // verdict readers the walk wakes need a flush (#4106).
@@ -167,7 +167,7 @@ function settleErroredDependents(e, n) {
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e.T?.F === n) {
+        if (e.T?.U === n) {
             enqueueSub(e);
             t = true;
         }
@@ -204,7 +204,7 @@ function settlePendingSource(e, n = e) {
         // is its verdict changing: it runs again.
         return f.l & CONFIG_VERDICT && enqueueSub(f);
         o.add(f);
-        f.ie = clock;
+        f.Se = clock;
         const s = f.T?.fe?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
@@ -271,7 +271,7 @@ function isThenable(e) {
     // null, which recompute would read as a flight this body registered itself.
     // Restore undefined here, so the fix costs nothing for code that never
     // calls onSupersede.
-        if (t) r.Se = undefined;
+        if (t) r.Ee = undefined;
     const o = r.ae;
     r.ae = o === null ? e : () => {
         try {
@@ -297,7 +297,7 @@ r) {
         });
     }
     if (!f && !o) {
-        if (e.T !== null) e.T.Se = null;
+        if (e.T !== null) e.T.Ee = null;
         // A sync landing is the first real answer for a loadingValue node.
                 e.ce = false;
         return n;
@@ -307,10 +307,10 @@ r) {
     // self-registration — runs during a recompute of `el`, which has already
     // fired _flightTeardown. A future non-recompute registration path must
     // release it here before overwriting _inFlight.
-        ext(e).Se = n;
+        ext(e).Ee = n;
     // The question this flight answers (A18 provenance, lanes.ts): the action
     // whose slice asked it; mainline is always the current question.
-        e.T.Ee = question || MAINLINE_QUESTION;
+        e.T.Te = question || MAINLINE_QUESTION;
     // The run that asked this flight read every input without throwing: an
     // input still in flight was masked for it (an active override, A17), so
     // pending state those inputs propagated onto the node earlier does not
@@ -320,7 +320,7 @@ r) {
         e.T.fe = undefined;
     let s;
     const handleError = o => {
-        if (e.T?.Se !== n) return;
+        if (e.T?.Ee !== n) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let f = o instanceof NotReadyError;
         if (f && e.ce) {
@@ -328,9 +328,9 @@ r) {
             // serving commit #0 — same parking as recompute's catch for sync
             // dependency throws. The dead flight is released so the clock-gated
             // error-retry pull (updateIfNecessary) can also re-ask.
-            if (e.T !== null) e.T.Se = null;
+            if (e.T !== null) e.T.Ee = null;
             parkLoadingWindow(e, o);
-            e.ie = clock;
+            e.Se = clock;
             return;
         }
         // D-41: a held node's error is staged (`stageError`). A derived store's
@@ -348,7 +348,7 @@ r) {
         // rejected flight will never settle its self entry, so transfer ownership
         // after notifyStatus has propagated the replacement source.
                 if (f) settlePendingSource(e);
-        e.ie = clock;
+        e.Se = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
         // the error twin of settlePendingSource's release (#2934).
@@ -356,7 +356,7 @@ r) {
         r?.(o, f);
     };
     const asyncWrite = (r, o) => {
-        if (e.T?.Se !== n) return;
+        if (e.T?.Ee !== n) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
@@ -371,8 +371,14 @@ r) {
                 return;
             }
             // A store derive's landing commits through its setter: unheld, the
-            // shown error leaves now; held, at the derive's commit.
-                        if (!(e.l & CONFIG_HELD)) e.T.de = undefined;
+            // shown error leaves now, and so does a commit-beneath-a-flight's
+            // CONFIG_INPUTS_PUBLISHED (its first flight's, #4269) — left standing,
+            // a verdict reader of the next flight would suspend instead of being
+            // served the screen; held, both at the derive's commit.
+                        if (!(e.l & CONFIG_HELD)) {
+                e.T.Ie = undefined;
+                e.l &= ~CONFIG_INPUTS_PUBLISHED;
+            }
             if (f) landStatus(e, true);
         } else {
             // CARVE 2: the override-covered landing (hold + A18 supersession) and the
@@ -387,7 +393,7 @@ r) {
         // (`_pendingValue` set inside setSignal) is not — commitPendingNode closes
         // the window when the flush commits it, so no one-frame pulse can leak to
         // observers between the landing and its commit (#2990).
-                if (e.ue === NOT_PENDING) {
+                if (e.ie === NOT_PENDING) {
             e.ce = false;
             // The landing published: the dependency tail the flight's pass left
             // linked goes now (A30, #3410). A staged landing has not replaced the
@@ -459,17 +465,17 @@ r) {
             }
         };
         const iterate = () => {
-            let t, r, l = false, a = false, S = true;
+            let t, r, l = false, S = false, a = true;
             // Protocol tolerance, matching `for await`: `await` unwraps whatever
             // next() returns — a thenable OR a bare IteratorResult. Real producers
             // use the bare form as a promise-free fast path when a value is already
             // buffered (seroval's deserialized streams do), so a bare result is
             // assimilated as an already-settled step instead of crashing on `.then`.
-                        const c = o.next();
-            const E = isThenable(c) ? c : {
-                then: e => void e(c)
+                        const E = o.next();
+            const c = isThenable(E) ? E : {
+                then: e => void e(E)
             };
-            E.then(r => {
+            c.then(r => {
                 // The sync stash only serves the INITIAL drain (handleAsync's caller
                 // consumes syncValue / throws NotReady from it). A sync-settled step
                 // after an async gap — seroval buffering values between pulls, a
@@ -477,11 +483,11 @@ r) {
                 // stash: it must write through the async path or the value is
                 // silently dropped. (The deferred posture never has a caller, so
                 // initialRead starts false there and everything writes through.)
-                if (S && i) {
+                if (a && i) {
                     t = r;
                     l = true;
                     if (r.done) u = true;
-                } else if (e.T?.Se !== n) {
+                } else if (e.T?.Ee !== n) {
                     return;
                 } else if (!r.done) {
                     f = true;
@@ -498,17 +504,17 @@ r) {
                     settleAutodispose();
                 }
             }, t => {
-                if (S && i) {
+                if (a && i) {
                     r = t;
-                    a = true;
-                } else if (e.T?.Se === n) {
+                    S = true;
+                } else if (e.T?.Ee === n) {
                     u = true;
                     handleError(t);
                     settleAutodispose();
                 }
             });
-            S = false;
-            if (a) {
+            a = false;
+            if (S) {
                 // Match the promise branch, but only rethrow during the initial read.
                 u = true;
                 handleError(r);
@@ -566,7 +572,7 @@ r) {
                 // compute catch above it: a protocol throw settles as this
                 // flight's error (#4112).
                 try {
-                    if (e.T?.Se === n && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, e)) return;
+                    if (e.T?.Ee === n && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, e)) return;
                     asyncWrite(r);
                 } catch (e) {
                     handleError(e);
@@ -608,7 +614,7 @@ r) {
     if (u !== null) {
         if (!u) {
             // Loading window: serve commit #0 instead of suspending.
-            if (e.ce) return e.Ie;
+            if (e.ce) return e.le;
             throw new NotReadyError(context);
         }
         // A sync first yield (or immediate empty completion) is the first real
@@ -622,7 +628,7 @@ function clearStatus(e, n = false) {
     if (e.T?.fe) clearPendingSources(e);
     if (e.T?.se) e.T.se = false;
     e.m = n ? 0 : e.m & STATUS_UNINITIALIZED;
-    if (e.T?.F) setPendingError(e);
+    if (e.T?.U) setPendingError(e);
     const t = statusNotifierOf(e);
     if (t) t.call(e);
 }
@@ -668,16 +674,19 @@ function notifyStatus(e, n, t) {
     // (CARVE 2: the lane assignment went with the engine.)
         if (n === STATUS_PENDING && r) {
         // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
-        if (e.m & STATUS_ERROR) e.T.de = e.T.F;
+        if (e.m & STATUS_ERROR) e.T.Ie = e.T.U;
         addPendingSource(e, r);
-        e.m = STATUS_PENDING | e.m & STATUS_UNINITIALIZED;
+        // A re-ask of an error that answered the first read: still no value.
+                e.m = STATUS_PENDING | (e.m & STATUS_NO_VALUE ? STATUS_UNINITIALIZED : e.m & STATUS_UNINITIALIZED);
         // Preserve the current source on this propagation so readers park on
         // the distinct pending source.
                 setPendingError(e, r, t);
     } else {
         clearPendingSources(e);
-        e.m = n | (n !== STATUS_ERROR ? e.m & STATUS_UNINITIALIZED : 0);
-        ext(e).F = t;
+        // An error answering a node with no value marks it so; a re-ask of it
+        // (pending) is uninitialized again; a write (STATUS_NONE) gives it one.
+                e.m = n | (n === STATUS_ERROR ? e.m & (STATUS_UNINITIALIZED | STATUS_NO_VALUE) ? STATUS_NO_VALUE : 0 : n === STATUS_PENDING && e.m & STATUS_NO_VALUE ? STATUS_UNINITIALIZED : e.m & STATUS_UNINITIALIZED);
+        ext(e).U = t;
     }
     // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
     // future value until we know otherwise"). Its own source in flight is its
@@ -704,7 +713,7 @@ function notifyStatus(e, n, t) {
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */ function propagateStatus(e, n, t) {
     const r = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
     forEachDependent(e, (o, f) => {
-        o.ie = clock;
+        o.Se = clock;
         // A pending mark on a kept-tail link re-derives the subscriber instead of
         // marking it (A30, #3494 review; fuzzer latest-1 #2141; #3519 review).
         // Past `_depsTail` lie the committed frame's deps, kept by A30 because
@@ -724,7 +733,7 @@ function notifyStatus(e, n, t) {
         // Inheriting the error would make a probe's reader errored. A boundary's
         // output (CONFIG_REDERIVE, boundaries.ts) the same: content or fallback
         // is its pass's call.
-                if (o.l & (CONFIG_REDERIVE | CONFIG_VERDICT) || n === STATUS_PENDING && f.Te !== o.Ne) {
+                if (o.l & (CONFIG_REDERIVE | CONFIG_VERDICT) || n === STATUS_PENDING && f.de !== o.Ne) {
             enqueueSub(o);
             schedule();
             return;
@@ -737,10 +746,10 @@ function notifyStatus(e, n, t) {
         // shape: the unmount it stages makes the observer a zombie whose say is
         // moot for this transaction, A15 #3463).
                 if (n === STATUS_PENDING && r && o.T?.fe?.has(r)) {
-            if (passLane === null && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.q && !freshHook?.(o, r.ie === clock)) joinFuture(txOf(o));
+            if (passLane === null && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.q && !freshHook?.(o, r.Se === clock)) joinFuture(txOf(o));
             return;
         }
-        if (n === STATUS_PENDING && r || n !== STATUS_PENDING && (o.T?.F !== t || o.T?.fe)) {
+        if (n === STATUS_PENDING && r || n !== STATUS_PENDING && (o.T?.U !== t || o.T?.fe)) {
             // The marked subscriber is queued for the commit sweep so its status
             // bookkeeping (loading window, uninitialized clear) runs with the flush
             // — with the lane, when the pass propagating is the lane's work and
@@ -756,6 +765,9 @@ function notifyStatus(e, n, t) {
                                 if (n === STATUS_PENDING && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !o.i) joinFuture(txOf(o));
             }
             notifyStatus(o, n, t);
+            // A derived store's derive (store/projection.ts): marked, not re-run —
+            // its leaves' readers are not its dependents, so the family walks them.
+                        o.fam?.st(n);
         }
     });
 }

package/dist/prod/core/constants.js

@@ -195,6 +195,15 @@ const CONFIG_HAS_SNAPSHOT = 1 << 9;
  * a write is promoted at that recompute's end: readers in the same block see
  * it. Cleared when the next flush begins; set only on that rare path. */ const CONFIG_PROMOTED = 1 << 22;
 
+/** The frame (rule 3, D-3): a render effect (set at creation, as
+ * `EFFECT_RENDER << 23` — keep the two in step), and a boundary's tree and
+ * output (boundaries.ts) — structure between the content and the render
+ * effect that shows it, not a user derivation of the content. Outside a
+ * hold's own flush it reads that hold's values as committed and is
+ * re-derived at its landing, and a re-pass of it publishes mainline: it
+ * joins nothing, so two mounts under one boundary made in separate flushes
+ * keep their holds apart (D-4, S-5 rows 1′–3′, #4283). */ const CONFIG_FRAME = 1 << 23;
+
 const STATUS_NONE = 0;
 
 const STATUS_PENDING = 1 << 0;
@@ -203,6 +212,10 @@ const STATUS_ERROR = 1 << 1;
 
 const STATUS_UNINITIALIZED = 1 << 2;
 
+/** An error that answered a node's first read (no value has ever landed):
+ * the error, not UNINITIALIZED, is its status while shown, but a re-ask
+ * makes it uninitialized-pending again — it still has no value (#4244). */ const STATUS_NO_VALUE = 1 << 3;
+
 /** `catchHook`'s answer when the catcher is a boundary re-armed by
  * `on` (truthy, as any catch): what it collects is its own, not the hold's. */ const CAUGHT_REARMED = 2;
 
@@ -230,4 +243,4 @@ const defaultContext = {};
 
 const NewSet = Set;
 
-export { $REFRESH, CAUGHT_REARMED, CONFIG_AUTHORITATIVE, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_GUESS, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, CONFIG_HELD_FRAME, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_LAGS, CONFIG_MANUAL_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_OVERRIDE, CONFIG_OWNED_WRITE, CONFIG_PROMOTED, CONFIG_REDERIVE, CONFIG_SLOT_NODE, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_SYNC, CONFIG_TRANSPARENT, CONFIG_VERDICT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, NewSet, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_JOINED, REACTIVE_LANE_DIRTY, REACTIVE_LANE_READ, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_PROBED, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_SNAPSHOT_STALE, REACTIVE_STAGED_READ, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_NONE, STATUS_PENDING, STATUS_UNINITIALIZED, SUPPORTS_PROXY, defaultContext };
+export { $REFRESH, CAUGHT_REARMED, CONFIG_AUTHORITATIVE, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRAME, CONFIG_FRESH_READ, CONFIG_GUESS, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, CONFIG_HELD_FRAME, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_LAGS, CONFIG_MANUAL_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_OVERRIDE, CONFIG_OWNED_WRITE, CONFIG_PROMOTED, CONFIG_REDERIVE, CONFIG_SLOT_NODE, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_SYNC, CONFIG_TRANSPARENT, CONFIG_VERDICT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, NewSet, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_JOINED, REACTIVE_LANE_DIRTY, REACTIVE_LANE_READ, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_PROBED, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_SNAPSHOT_STALE, REACTIVE_STAGED_READ, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_NONE, STATUS_NO_VALUE, STATUS_PENDING, STATUS_UNINITIALIZED, SUPPORTS_PROXY, defaultContext };