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

package/dist/prod/core/truth.js

@@ -1,4 +1,4 @@
-import { CONFIG_GUESS, NOT_PENDING, CONFIG_AUTHORITATIVE, CONFIG_OVERRIDE } from "./constants.js";
+import { CONFIG_GUESS, NOT_PENDING, STATUS_UNINITIALIZED, CONFIG_AUTHORITATIVE, CONFIG_OVERRIDE } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -10,11 +10,13 @@ import { enqueueSub } from "./heap.js";
 // which exists once something installs lanes (`createOptimistic`, verdicts).
 /** A lane node's current value: its guess, or the latest it derived — the
  * staging a shown lane holds for its next reveal, else its slot; the
- * committed value while it has none (its first lane pass in flight). */
+ * committed value while it has none (its first lane pass in flight) —
+ * NOT_PENDING for a node with no committed value either (born in the lane,
+ * uninitialized: its reads throw NotReady, A7; #4363). */
 function laneValueOf(r) {
-    if (!(r.l & CONFIG_GUESS) && r.ie !== NOT_PENDING) return r.ie;
+    if (!(r.l & CONFIG_GUESS) && r.ue !== NOT_PENDING) return r.ue;
     const t = r.T.P;
-    return t !== NOT_PENDING ? t : r.le;
+    return t !== NOT_PENDING || r.m & STATUS_UNINITIALIZED ? t : r.le;
 }
 
 /** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
@@ -25,7 +27,7 @@ function laneValueOf(r) {
  * value. */ function truthRead(r) {
     if (truth(r)) return laneValueOf(r);
     if (!(r.l & CONFIG_GUESS)) throw new NotReadyError(null);
-    return r.ie !== NOT_PENDING ? r.ie : r.le;
+    return r.ue !== NOT_PENDING ? r.ue : r.le;
 }
 
 /** A guess confirmed: its lane's truth readers re-read — of the lane's
@@ -36,8 +38,8 @@ function laneValueOf(r) {
 /** A lane node's value is the truth when every guess beneath it is
  * confirmed — its source staged a value equal to the guess — and nothing
  * beneath it is held in the parent: same inputs, same value. */ function truth(r) {
-    if (r.l & CONFIG_GUESS) return r.ie !== NOT_PENDING && r.xe && r.xe(r.T.P, r.ie);
-    if (r.ie !== NOT_PENDING) return;
+    if (r.l & CONFIG_GUESS) return r.ue !== NOT_PENDING && r.ye && r.ye(r.T.P, r.ue);
+    if (r.ue !== NOT_PENDING) return;
     if (r.l & CONFIG_OVERRIDE) for (let t = r.C; t; t = t.G) if (!truth(t.S)) return;
     return 1;
 }

package/dist/prod/core/verdict.js

@@ -1,6 +1,6 @@
-import { CONFIG_VERDICT, REACTIVE_PROBED, CONFIG_CHILDREN_FORBIDDEN, CONFIG_OVERRIDE, STATUS_ERROR, CONFIG_GUESS, STATUS_PENDING, NOT_PENDING, STATUS_UNINITIALIZED, CONFIG_HELD, EFFECT_RENDER, CONFIG_STAGED_ERROR, REACTIVE_STAGED_READ, REACTIVE_PROBE_UNANSWERED, CONFIG_INPUTS_PUBLISHED, REACTIVE_JOINED, REACTIVE_LANE_READ } from "./constants.js";
+import { REACTIVE_PROBED, REACTIVE_WINDOW, CONFIG_VERDICT, CONFIG_ASYNC, CONFIG_CHILDREN_FORBIDDEN, CONFIG_OVERRIDE, STATUS_ERROR, CONFIG_GUESS, STATUS_PENDING, NOT_PENDING, STATUS_UNINITIALIZED, CONFIG_HELD, EFFECT_RENDER, CONFIG_STAGED_ERROR, REACTIVE_STAGED_READ, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, CONFIG_INPUTS_PUBLISHED, REACTIVE_JOINED, REACTIVE_LANE_READ } from "./constants.js";
 
-import { context, tracking, setVerdict, verdict, pullComputed, joinPass, markLateLinker, spectating, unflushedValue, bornInto } from "./core.js";
+import { context, creatorPass, tracking, creatorReads, setVerdict, verdict, prepareComputed, pullComputed, joinPass, markLateLinker, spectating, unflushedValue, bornInto } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -38,7 +38,7 @@ function watchVerdict(e, t = false) {
  * node's, or the staging of a write this flush may hold — and the verdict
  * does not rescue it: its result shows at the landing, re-derived). A lane
  * read, for `recompute`'s tail (REACTIVE_LANE_READ). */ function route(e, t) {
-    if (passLane === null && !(e.R & (REACTIVE_JOINED | REACTIVE_STAGED_READ))) setPassLane(verdictLane(t));
+    if (!passLane && !(e.R & (REACTIVE_JOINED | REACTIVE_STAGED_READ))) setPassLane(verdictLane(t));
     e.R |= REACTIVE_LANE_READ;
 }
 
@@ -65,7 +65,7 @@ function watchVerdict(e, t = false) {
  * transaction (`bornInto`, #4010): it has no screen — it waits on the flight
  * with the rest of its frame. */ function observeFlight(e, t) {
     if (t.l & CONFIG_INPUTS_PUBLISHED || t.l & CONFIG_HELD && bornInto(e, txOf(t))) return false;
-    if (globalQueue.q) {
+    if (globalQueue.Y) {
         joinFuture(null);
         if (!(t.l & CONFIG_HELD)) queuePendingNode(t);
         verdictRead(e, flushTransaction, true);
@@ -90,9 +90,9 @@ let probeFound = false;
  * value notifying anyone (a held write's commit; a held landing's): its
  * reader re-derives there. `latest` shows the proposal that lands — a
  * rewrite or a landing reaches its reader through the link it holds — so a
- * re-run would only repeat the frame. */ function verdictRead(e, t, n) {
+ * re-run would only repeat the frame. */ function verdictRead(e, t, r) {
     route(e, t);
-    if (n) staleReader(e, t); else if (probing && t.En[t.En.length - 1] !== e) t.En.push(e);
+    if (r) staleReader(e, t); else if (probing && t.En[t.En.length - 1] !== e) t.En.push(e);
 }
 
 /** A verdict read of a node staged or in flight but not held yet: whether it
@@ -105,40 +105,41 @@ let probeFound = false;
  * watches the seam and runs again if the flush parks (a plain sync write
  * never glitches it true).
  *
- * `latest` has its answer either way — the proposal — and only the reader's
- * membership was open, so it is settled now: the frame gets its transaction
- * (`joinFuture(null)`; nothing holds it at the seam and it lands there, the
- * lane dissolving into it — a plain commit) and the reader is its verdict
- * lane's. One pass: a provisional pass re-derived at the seam ran everything
- * downstream of it twice (#3540 web). A pass that also read the frame's own
- * stagings plainly (REACTIVE_STAGED_READ) stays the frame's (`route` does
- * not move it); a verdict reader's plain read AFTER the window sees the
- * screen (`read`: `stagedScreen`). */ function provisionalVerdict(e, t) {
-    if (!probing) {
-        joinFuture(null);
-        verdictRead(e, flushTransaction);
-        return;
-    }
-    if (flushTransaction !== null) {
-        if (t) probeFound = true;
+ * `latest` has its answer either way — the proposal — but its reader's
+ * membership is the seam's too: the frame opens no transaction for it
+ * (#4365 — one opened for the read alone made a plain read after the window
+ * take it for a hold, `stagedScreen`, and serve the screen beside the
+ * staging in a frame nothing held). The reader watches the seam like a
+ * probe before anything joined: its pass is the frame's, and runs again in
+ * the verdict lane if the flush parks. Once the flush has joined a
+ * transaction, the reader is its verdict lane's at once; a pass that also
+ * read the frame's own stagings plainly (REACTIVE_STAGED_READ) stays the
+ * frame's (`route` does not move it). */ function provisionalVerdict(e, t) {
+    if (flushTransaction) {
+        if (probing && t) probeFound = true;
         verdictRead(e, flushTransaction);
-        if (e.R & REACTIVE_STAGED_READ) watchVerdict(e);
+        if (probing && e.R & REACTIVE_STAGED_READ) watchVerdict(e);
         return;
     }
     // Before anything joined, a staging that would not be final held has no
     // answer yet: whatever the seam decides, the pass runs again — a later
     // plain read of the same pass may route it into the verdict lane
     // (`observeFlight`), which the seam must not take as this probe's answer.
-        watchVerdict(e, t);
+    // `latest` opens no transaction for its answer either (#4365): the plain
+    // read of a staging after it took one opened for it for a hold and paired
+    // the staging with the screen, in a frame nothing held. Its pass is the
+    // frame's — whole — and re-derives once if the flush parks (unanswered:
+    // its membership is the seam's, not the transaction it joins).
+        watchVerdict(e, !probing || t);
 }
 
 /** A19 exc. 2 / A24: a flight that re-asks the question already answered
  * (a `refresh()`, a poll) is quiet; a node pending through others is quiet
  * when every flight it waits on is. */ function quietPending(e) {
     const t = e.T;
-    if (t === null) return false;
-    if (t.fe !== undefined) {
-        for (const e of t.fe) if (!e.T?.Ve) return false;
+    if (!t) return false;
+    if (t.se) {
+        for (const e of t.se) if (!e.T?.Ve) return false;
         return true;
     }
     return t.Ve;
@@ -157,16 +158,24 @@ let probeFound = false;
  * flight — a staging equal to what is displayed changes nothing when it
  * lands: final now (maintainer, 2026-10-02). */ function heldNotFinal(e) {
     if ((e.m & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
-    return e.ie !== NOT_PENDING && !latestActive && !e.T.Ve && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.Ie || !e.xe || !e.xe(e.le, e.ie));
+    return e.ue !== NOT_PENDING && !latestActive && !e.T.Ve && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.Te || !e.ye || !e.ye(e.le, e.ue));
 }
 
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */ function pendingVerdict(e, t) {
     if (t.m & STATUS_UNINITIALIZED) return;
     if (probing && !quietPending(t)) probeFound = true;
-    if (e !== null && tracking) {
-        if (t.l & CONFIG_HELD) verdictRead(e, txOf(t)); else if (globalQueue.q) provisionalVerdict(e, false);
+    if (e && tracking) {
+        if (t.l & CONFIG_HELD) verdictRead(e, txOf(t)); else if (globalQueue.Y) {
+            // `latest` of a flight serves the committed value, the frame's and the
+            // lane's alike (D-22): nothing is the seam's, so the reader is the
+            // verdict lane's now, as a plain read of a flight makes it
+            // (`observeFlight`). Its frame pass re-derived in the lane (R5) asked
+            // its question again (F-9, #4397). A staging's is the seam's (#4365).
+            if (!probing) joinFuture(null);
+            provisionalVerdict(e, false);
  // decided above
-        }
+                }
+    }
 }
 
 /** The pass entering a verdict window is a verdict reader (CONFIG_VERDICT):
@@ -174,11 +183,19 @@ let probeFound = false;
  * an untracked window: that is a snapshot, like any untracked read (#3946 —
  * a router's link claim probing inside the computation that creates the
  * anchor). A throw still reaches the pass through `untrack`. */ function markVerdictReader(e) {
-    let t = context;
-    if (t?.Qe) t = t.Ye;
-    if (t !== null && tracking) {
-        t.l |= CONFIG_VERDICT;
-        t.R |= REACTIVE_PROBED;
+    const t = creatorPass(context);
+    if (t && tracking) {
+        // A pass run inside passes still running — its creator's, theirs — one
+        // of which read the future or a staging (a branch a held or staged
+        // condition opened, and whatever that branch creates) has no screen: the
+        // branch exists only in that world. It reads that world as any
+        // derivation of it does (`bornInto` once held) and stays its pass
+        // (`route`); a verdict reader from its next pass. #4341: a memo born in
+        // a newly opened <Match> read the screen, where its branch was closed.
+        // Not such a pass: a verdict reader now.
+        t.l &= ~CONFIG_ASYNC;
+        t.R |= REACTIVE_PROBED | REACTIVE_WINDOW | (creatorReads(t, 0) || (t.l |= CONFIG_VERDICT, 
+        0));
     }
 }
 
@@ -186,14 +203,14 @@ let probeFound = false;
  * restores the dispatch it found — none inside a memo's pass a window
  * pulled (`verdictValue`). */ function latest(e) {
     markVerdictReader();
-    const t = latestActive, n = verdict;
+    const t = latestActive, r = verdict;
     latestActive = true;
     setVerdict(verdictValue);
     try {
         return e();
     } finally {
         latestActive = t;
-        setVerdict(n);
+        setVerdict(r);
     }
 }
 
@@ -231,8 +248,8 @@ let probeFound = false;
  */ function isPending(e) {
     markVerdictReader();
     const t = probing;
-    const n = probeFound;
-    const r = verdict;
+    const r = probeFound;
+    const i = verdict;
     probing = true;
     probeFound = false;
     setVerdict(verdictValue);
@@ -250,23 +267,23 @@ let probeFound = false;
         return probeFound;
     } finally {
         probing = t;
-        probeFound = n;
-        setVerdict(r);
+        probeFound = r;
+        setVerdict(i);
     }
 }
 
 /** The staging, or the staged error thrown (D-41). */ function staged(e) {
-    if (e.l & CONFIG_STAGED_ERROR) throw e.ie;
-    return e.ie;
+    if (e.l & CONFIG_STAGED_ERROR) throw e.ue;
+    return e.ue;
 }
 
 /** `latest()` of a held node: the flushed staging — the proposal — and, for
  * a tracked reader of a rewrite not yet flushed, the late-linker re-run in
  * the flush that carries it. */ function heldLatest(e, t) {
-    const n = unflushedValue(e);
-    if (n === NOT_PENDING) return staged(e);
-    if (t !== null) markLateLinker(t);
-    return n;
+    const r = unflushedValue(e);
+    if (r === NOT_PENDING) return staged(e);
+    if (t) markLateLinker(t);
+    return r;
 }
 
 /** The verdict windows' read — `latest(fn)` and `isPending(fn)` — in one
@@ -279,7 +296,9 @@ let probeFound = false;
  *   differs (A24, A18 provenance). A derivation: `latest` sees the lane's
  *   latest (a landing a blocked lane holds has answered its question — the
  *   checkout's shipping text updates independently of the tax in flight),
- *   `isPending` the screen; not final while its own flight is up;
+ *   `isPending` the screen; not final while its own flight is up. A
+ *   derivation's first load in flight (nothing produced yet — an async memo
+ *   over a verdict memo, F-6) reads as the flight below: loading (D-22);
  * - a held node: the reader breaks out as the holder's verdict lane's and
  *   re-derives at the landing; `latest` serves the proposal (`heldLatest`),
  *   `isPending` answers `heldNotFinal`;
@@ -290,63 +309,76 @@ let probeFound = false;
  *   serves the committed value — below the async nothing newer exists; an
  *   uninitialized one throws NotReady: loading, not pending (A19 exc. 1);
  * - an errored derivation throws for every reader (#2897). */ function verdictValue(e, t) {
-    const n = e;
-    const r = t !== null && !(t.l & CONFIG_CHILDREN_FORBIDDEN);
-    const i = r && tracking;
-    if (t !== null && tracking) {
+    const r = e;
+    const i = !!t && !(t.l & CONFIG_CHILDREN_FORBIDDEN);
+    const n = i && tracking;
+    // A31: the pulled memo's pass is its own, not the probe's — it reads
+    // outside the window, and the probe's read below answers for what the pass
+    // produced. So is a lazy or dormant memo's wake (an unowned memo with no
+    // reader left, #4366): woken inside the window, it read its sources as the
+    // probe does, the committed value under a landing. (A signal has no
+    // `_flags`: the wake is a no-op for it.)
+        setVerdict(null);
+    prepareComputed(r);
+    if (t && tracking) {
         link(e, t);
-        if (n.X !== undefined) {
-            // A31: the pulled memo's pass is its own, not the probe's — it reads
-            // outside the window, and the probe's read below answers for what
-            // the pass produced.
-            setVerdict(null);
-            pullComputed(n, t);
-            setVerdict(verdictValue);
-        }
+        if (e.X) pullComputed(r, t);
     }
+    setVerdict(verdictValue);
     // A live `affects()` mark on the node or a dependency (affects.ts): not
     // final by declaration — the value itself is read as below. The verdict is
     // display-ahead like any: in a transaction's flush (the declaring action's
     // body) the reader is its verdict lane's, not a staging the frame parks.
-        if (probing && GlobalQueue.p !== undefined && GlobalQueue.p(n)) {
+        if (probing && GlobalQueue.p?.(r)) {
         probeFound = true;
-        if (i && flushTransaction !== null) verdictRead(t, flushTransaction);
+        if (n && flushTransaction) verdictRead(t, flushTransaction);
     }
-    if (e.l & CONFIG_OVERRIDE && !(n.m & STATUS_ERROR && !(e.l & CONFIG_GUESS))) {
-        const r = txOf(e);
-        if (i) verdictRead(t, r._parent ?? r);
-        const u = (n.m & STATUS_PENDING) !== 0 && !quietPending(n);
-        if (e.l & CONFIG_GUESS) {
-            if (probing && (u || e.ie !== NOT_PENDING && (!e.xe || !e.xe(e.T.P, e.ie)))) probeFound = true;
-            // A lane a correction folded under (D-34): `latest()` shows the hold's
-            // world whole — the truth beneath each guess, else what it covered.
-                        if (latestActive && r.folded) return r.folded(null, e);
-            return e.T.P;
+    if (e.l & CONFIG_OVERRIDE && !(r.m & STATUS_ERROR && !(e.l & CONFIG_GUESS))) {
+        const i = txOf(e), o = (r.m & STATUS_PENDING) !== 0 && !quietPending(r), a = e.l & CONFIG_GUESS, 
+        // NOT_PENDING: a node born in the lane with nothing in it yet has no
+        // value in either view — loading, not pending, and no verdict to read
+        // ahead: it is read as any uninitialized node, NotReady below (A7, A19
+        // exc. 1; #4363), its reader not moved into the verdict lane.
+        u = a ? 0 : latestActive && !o ? laneValueOf(e) : display(e);
+        if (u !== NOT_PENDING) {
+            if (n) verdictRead(t, i._parent ?? i);
+            if (a) {
+                if (probing && (o || e.ue !== NOT_PENDING && (!e.ye || !e.ye(e.T.P, e.ue)))) probeFound = true;
+                // A lane a correction folded under (D-34): `latest()` shows the hold's
+                // world whole — the truth beneath each guess, else what it covered.
+                                if (latestActive && i.folded) return i.folded(null, e);
+                return e.T.P;
+            }
+            // A first load in flight with nothing produced yet: loading, for
+            // `latest` (D-22) as for `isPending` (A19 exc. 1) — unless an error
+            // answered it first: its re-ask is pending, the error its display
+            // (D-41, #4375).
+                        if (o && u === e.le && r.m & STATUS_UNINITIALIZED && (latestActive || !r.T.Te)) throw r.T.U;
+            if (probing && o) probeFound = true;
+            return u;
         }
-        if (probing && u) probeFound = true;
-        return latestActive && !u ? laneValueOf(e) : display(e);
     }
-    const u = (n.m & STATUS_UNINITIALIZED) !== 0;
+    const o = (r.m & STATUS_UNINITIALIZED) !== 0;
     if (e.l & CONFIG_HELD) {
-        if (!u) {
-            const r = txOf(e);
+        if (!o) {
+            const i = txOf(e);
             // A render effect re-run (or mounted) outside the verdict lane's flush
             // while the lane is blocked — its display held on its own derivation
             // in flight — is a stale reader of the lane (#3460, as `laneRead`): the
             // committed value now, re-derived at the reveal. Not inside a probe:
             // `isPending` is answered below either way.
-                        if (i && !probing && t.i === EFFECT_RENDER && passLane === null && r.Pe !== null && r.Pe.ln && flushTransaction !== r) {
-                staleReader(t, r.Pe);
+                        if (n && !probing && t.i === EFFECT_RENDER && !passLane && i.Pe?.ln && flushTransaction !== i) {
+                staleReader(t, i.Pe);
                 return e.le;
             }
-            if (i) verdictRead(t, r);
-            if (probing && heldNotFinal(n)) probeFound = true;
-            if (latestActive && e.ie !== NOT_PENDING) {
+            if (n) verdictRead(t, i);
+            if (probing && heldNotFinal(r)) probeFound = true;
+            if (latestActive && e.ue !== NOT_PENDING) {
                 // An action body reading another transaction's proposal derives
                 // from it: the two settle as one (A15; posture C, 2026-09-15). An
                 // untracked read elsewhere has no transaction to entangle.
-                if (!i && flushTransaction !== null && !globalQueue.q) joinFuture(txOf(e));
-                return heldLatest(e, i ? t : null);
+                if (!n && flushTransaction && !globalQueue.Y) joinFuture(txOf(e));
+                return heldLatest(e, n ? t : null);
             }
             return e.le;
         }
@@ -354,46 +386,76 @@ let probeFound = false;
         // committed value, so no verdict: `isPending` reads it as its read does —
         // the owner joins the hold (held with it, or caught by a boundary that
         // has not shown content) and answers for the commit, where it is final.
-                if (e.ie !== NOT_PENDING && !(n.m & STATUS_PENDING)) {
-            if (probing && r) joinPass(t, e);
+                if (e.ue !== NOT_PENDING && !(r.m & STATUS_PENDING)) {
+            if (probing && i) joinPass(t, e);
             return staged(e);
         }
-    } else if (e.ie !== NOT_PENDING) {
-        if (n.m & STATUS_PENDING && !u) pendingVerdict(i ? t : null, n); else if (i && globalQueue.q) provisionalVerdict(t, !latestActive && !u);
+    } else if (e.ue !== NOT_PENDING) {
+        if (r.m & STATUS_PENDING && !o) pendingVerdict(n ? t : null, r); else if (n && globalQueue.Y) provisionalVerdict(t, !latestActive && !o);
         // Outside a flush, the staging is an unflushed write (A28): the probe
         // answers for the flushed world, and watches the seam of the flush that
         // carries the write — a memo of `isPending(x)` created after the write
         // flips if that flush parks (#3078). (The write's own fan-out ran before
         // the reader existed; nothing else would re-derive it.)
-         else if (i && probing) watchVerdict(t);
+         else if (n && probing) watchVerdict(t);
         if (latestActive) {
             // A28: an unflushed write is not what `latest` serves; a tracked
             // reader derived from the flushed world runs again in the carrying
             // flush.
-            if (globalQueue.q) return staged(e);
-            if (t !== null) markLateLinker(t);
+            if (globalQueue.Y) return staged(e);
+            if (t) markLateLinker(t);
         }
         return e.le;
     }
-    if (n.m & STATUS_PENDING) {
-        if (!u) {
-            pendingVerdict(i ? t : null, n);
+    if (r.m & STATUS_PENDING) {
+        if (!o) {
+            pendingVerdict(n ? t : null, r);
             return e.le;
         }
         // As `read()`: an untracked read of a pending node still re-runs its
         // reader when the node settles (a projection's pull reads its firewall
         // untracked, store/store.ts).
-                if (t !== null && !tracking && !spectating && e !== t) link(e, t);
-        throw n.T?.U;
+                if (t && !tracking && !spectating && e !== t) link(e, t);
+        throw r.T?.U;
     }
-    if (n.X !== undefined && n.m & STATUS_ERROR) throw n.T.U;
+    if (e.X && r.m & STATUS_ERROR) throw r.T.U;
     return e.le;
 }
 
+/** D-25: a node whose fetch a hold is waiting on is that hold's work, not a
+ * verdict reader — a pass that re-runs it reads plainly — and a memo's
+ * posture is what it reads: one that reads a verdict reader's value is a
+ * verdict reader itself (#4050). An async memo with no verdict window of its
+ * own (REACTIVE_WINDOW: it read a verdict memo, it called neither `latest`
+ * nor `isPending`) is a verdict reader between its flights, and the hold's
+ * work while one is up or its hold re-runs it.
+ *
+ * At a pass's head (core.ts `recompute`): a pending node's pass — its
+ * flight is the transition's own work (#3884) — and a held one's re-run of
+ * such a memo read plainly: the write that re-ran it is its hold's, and
+ * served the screen it re-asked a question it had answered (A10, #4397).
+ * Only a memo that never asked: D-25's "a verdict posture outlives the pass
+ * that asked" is a pass that called `latest`/`isPending`, which clears
+ * CONFIG_ASYNC and stays a verdict reader whoever dirties it.
+ *
+ * On `source` going pending (`propagateStatus`): such a memo waits on it
+ * like any derivation (F-9) instead of re-deriving — what it read changed
+ * no value, so its re-run re-asked the question it was answering. Unless
+ * its own flight is up outside a lane on a new question of the source's:
+ * its re-run supersedes a flight asked of a value the source has moved past
+ * (re-asked by a `refresh()`, the source's question is the same one). */ function holdWork(e, t) {
+    // CONFIG_ASYNC records an async memo with no window of its own: its last
+    // answering pass registered a flight (`handleAsync`) and called neither
+    // `latest` nor `isPending`. A window (`markVerdictReader`), a sync answer or
+    // an error clears it; a pass left pending keeps the last answer's.
+    const r = e.l & CONFIG_ASYNC;
+    return r && (!(e.m & STATUS_PENDING) || e.T.Re?.P || t.R & REACTIVE_REASK);
+}
+
 // Installed at module evaluation — present exactly when something imports
 // `latest` or `isPending`. (`read` dispatches to `verdictValue` through
 // `verdict`, set while a window is open.)
-installVerdictHooks(observeFlight);
+installVerdictHooks(observeFlight, holdWork);
 
 /** A store read inside an untracked `isPending` probe found a live mark on
  * a record with no node to carry it (store/affects.ts): not final. */ GlobalQueue.rt = () => {

package/dist/prod/deferred.js

@@ -121,7 +121,7 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
      * does not replace (D-40) — restaged as the committed value, the hold's
      * readers would re-derive against the old input. */    const serve = e => {
         const r = handleAsync(t, e);
-        return t.l & CONFIG_HELD && t.ie !== NOT_PENDING ? t.ie : r;
+        return t.l & CONFIG_HELD && t.ue !== NOT_PENDING ? t.ue : r;
     };
     const end = () => t.R & REACTIVE_DISPOSED && land(o);
     return accessor(computed(r => {

package/dist/prod/index.js

@@ -24,6 +24,8 @@ import "./core/effect.js";
 
 export { configureClientErrors } from "./core/error-hooks.js";
 
+export { checkForeignOwnerless, runAsSolidCopy } from "./core/copies.js";
+
 export { storeName } from "./store/edges.js";
 
 export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onFlush, onSettled, refresh, resolve, until } from "./signals.js";