@solidjs/signals 2.0.0-rc.18 → 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.)
  *

package/dist/observe/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 { attrHooks } from "./attribution-hooks.js";
 
@@ -156,7 +156,7 @@ function releaseSettledDependents(e) {
         clearPendingSources(e);
     if (e.T) e.T.fe = false;
     if (!((e.m &= STATUS_ERROR | STATUS_UNINITIALIZED) & STATUS_ERROR)) setPendingError(e);
-    e.ue = t instanceof StatusError ? t : new StatusError(e, t);
+    e.ie = t instanceof StatusError ? t : new StatusError(e, t);
     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).
@@ -208,7 +208,7 @@ function settlePendingSource(e, t = e) {
         // is its verdict changing: it runs again.
         return s.l & CONFIG_VERDICT && enqueueSub(s);
         o.add(s);
-        s.ie = clock;
+        s.ae = clock;
         const f = s.T?.se?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
@@ -251,9 +251,9 @@ function isThenable(e) {
 }
 
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */ function releaseFlightTeardown(e) {
-    const t = e.T?.ae;
+    const t = e.T?.Se;
     if (t != null) {
-        e.T.ae = null;
+        e.T.Se = null;
         t();
     }
 }
@@ -275,9 +275,9 @@ 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 (n) r.Se = undefined;
-    const o = r.ae;
-    r.ae = o === null ? e : () => {
+        if (n) r.Ee = undefined;
+    const o = r.Se;
+    r.Se = o === null ? e : () => {
         try {
             o();
         } finally {
@@ -301,7 +301,7 @@ r) {
         });
     }
     if (!s && !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 t;
@@ -311,10 +311,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 = t;
+        ext(e).Ee = t;
     // 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.de = 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
@@ -330,7 +330,7 @@ r) {
         if (attrHooks !== null) attrHooks.flightStart(e, t);
     let f;
     const handleError = o => {
-        if (e.T?.Se !== t) return;
+        if (e.T?.Ee !== t) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let s = o instanceof NotReadyError;
         if (s && e.ce) {
@@ -338,9 +338,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.ae = clock;
             return;
         }
         // D-41: a held node's error is staged (`stageError`). A derived store's
@@ -358,7 +358,7 @@ r) {
         // rejected flight will never settle its self entry, so transfer ownership
         // after notifyStatus has propagated the replacement source.
                 if (s) settlePendingSource(e);
-        e.ie = clock;
+        e.ae = 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).
@@ -366,7 +366,7 @@ r) {
         r?.(o, s);
     };
     const asyncWrite = (r, o) => {
-        if (e.T?.Se !== t) return;
+        if (e.T?.Ee !== t) 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.
@@ -385,8 +385,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.Te = undefined;
+                e.l &= ~CONFIG_INPUTS_PUBLISHED;
+            }
             if (s) landStatus(e, true);
             // Attribution hook: this path landed through the setter (derived
             // stores, projections), which does not go through setSignal, so the
@@ -416,7 +422,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
@@ -473,7 +479,7 @@ r) {
         // `onSupersede` teardown this run registered earlier, which then falls
         // back to the owner-cleanup channel. A returned `from()` is unaffected:
         // `close` calls its `return()`, which runs its own teardown.
-                ext(e).ae = close;
+                ext(e).Se = close;
         // Release check before each next pull: an unobserved lazy node must tear
         // down (its close above runs via disposal, closing the iterator) instead
         // of pumping the stream forever with zero subscribers (#2935).
@@ -494,11 +500,11 @@ r) {
             // 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
@@ -510,7 +516,7 @@ r) {
                     n = r;
                     l = true;
                     if (r.done) u = true;
-                } else if (e.T?.Se !== t) {
+                } else if (e.T?.Ee !== t) {
                     return;
                 } else if (!r.done) {
                     s = true;
@@ -530,7 +536,7 @@ r) {
                 if (S && i) {
                     r = n;
                     a = true;
-                } else if (e.T?.Se === t) {
+                } else if (e.T?.Ee === t) {
                     u = true;
                     handleError(n);
                     settleAutodispose();
@@ -595,7 +601,7 @@ r) {
                 // compute catch above it: a protocol throw settles as this
                 // flight's error (#4112).
                 try {
-                    if (e.T?.Se === t && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, e)) return;
+                    if (e.T?.Ee === t && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, e)) return;
                     asyncWrite(r);
                 } catch (e) {
                     handleError(e);
@@ -637,7 +643,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
@@ -697,15 +703,18 @@ function notifyStatus(e, t, n) {
     // (CARVE 2: the lane assignment went with the engine.)
         if (t === 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.Te = e.T.F;
         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, n);
     } else {
         clearPendingSources(e);
-        e.m = t | (t !== STATUS_ERROR ? e.m & STATUS_UNINITIALIZED : 0);
+        // 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 = t | (t === STATUS_ERROR ? e.m & (STATUS_UNINITIALIZED | STATUS_NO_VALUE) ? STATUS_NO_VALUE : 0 : t === STATUS_PENDING && e.m & STATUS_NO_VALUE ? STATUS_UNINITIALIZED : e.m & STATUS_UNINITIALIZED);
         ext(e).F = n;
     }
     // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
@@ -733,7 +742,7 @@ function notifyStatus(e, t, n) {
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */ function propagateStatus(e, t, n) {
     const r = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
     forEachDependent(e, (o, s) => {
-        o.ie = clock;
+        o.ae = 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
@@ -753,7 +762,7 @@ function notifyStatus(e, t, n) {
         // 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) || t === STATUS_PENDING && s.Te !== o.Ne) {
+                if (o.l & (CONFIG_REDERIVE | CONFIG_VERDICT) || t === STATUS_PENDING && s.Ie !== o.Ne) {
             enqueueSub(o);
             schedule();
             return;
@@ -766,7 +775,7 @@ function notifyStatus(e, t, n) {
         // shape: the unmount it stages makes the observer a zombie whose say is
         // moot for this transaction, A15 #3463).
                 if (t === STATUS_PENDING && r && o.T?.se?.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.ae === clock)) joinFuture(txOf(o));
             return;
         }
         if (t === STATUS_PENDING && r || t !== STATUS_PENDING && (o.T?.F !== n || o.T?.se)) {
@@ -785,6 +794,9 @@ function notifyStatus(e, t, n) {
                                 if (t === STATUS_PENDING && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !o.i) joinFuture(txOf(o));
             }
             notifyStatus(o, t, n);
+            // 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(t);
         }
     });
 }