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

package/dist/observe/core/owner.js

@@ -69,7 +69,7 @@ function disposeChildren(e, n = false, r) {
     // cleanups never run and it stays subscribed, rerunning in a torn-down
     // tree (#3561). Death only (`self`): a re-pass leaves the frame reacting
     // until the commit.
-        if (n && !r && e.T !== null && (e.T.ft !== null || e.T.Nt !== null)) disposeChildren(e, false, true);
+        if (n && !r && e.T !== null && (e.T.ft !== null || e.T.Tt !== null)) disposeChildren(e, false, true);
     if (n) {
         e.R = t | REACTIVE_DISPOSED;
         if (e._parent === null && e.Pt) unregisterRoot(e);
@@ -116,7 +116,7 @@ function disposeChildren(e, n = false, r) {
         // would still be holding.
                 l = l.Xe;
     }
-    if (!r) e.ct = 0;
+    if (!r) e.At = 0;
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and for a zombie (it sits on the
     // parent's parked frame, drained whole by the commit). We leave
@@ -132,9 +132,9 @@ function disposeChildren(e, n = false, r) {
     runDisposal(e, r);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (n && e.kt) {
-        const n = e.kt;
-        e.kt = undefined;
+        if (n && e.Vt) {
+        const n = e.Vt;
+        e.Vt = undefined;
         runCleanup(n);
     }
 }
@@ -154,9 +154,9 @@ function runDisposal(e, n) {
     // walk ran every entry a second time. Detached, the re-entrant drain finds
     // nothing. The same shape latched a throwing cleanup: the list survived the
     // throw and every later drain re-ran and re-threw it.
-    const r = n ? e.T.Nt : e.rt;
+    const r = n ? e.T.Tt : e._t;
     if (!r) return;
-    if (n) e.T.Nt = null; else e.rt = null;
+    if (n) e.T.Tt = null; else e._t = null;
     if (Array.isArray(r)) {
         // Unwind order (#3572, restores 1.x #1562): later registrations run
         // before earlier ones. Children have already been disposed by the caller,
@@ -173,7 +173,7 @@ function runDisposal(e, n) {
 function childId(e, n) {
     let r = e;
     while (r.l & CONFIG_TRANSPARENT && r._parent) r = r._parent;
-    if (r.id != null) return formatId(r.id, n ? r.ct++ : r.ct);
+    if (r.id != null) return formatId(r.id, n ? r.At++ : r.At);
     throw new Error("");
 }
 
@@ -255,7 +255,7 @@ function formatId(e, n) {
  * one.
  */ function cleanup(e, n = context) {
     if (!n) return e;
-    if (!n.rt) n.rt = e; else if (Array.isArray(n.rt)) n.rt.push(e); else n.rt = [ n.rt, e ];
+    if (!n._t) n._t = e; else if (Array.isArray(n._t)) n._t.push(e); else n._t = [ n._t, e ];
     return e;
 }
 
@@ -282,7 +282,7 @@ function disposeRootSelf(e = true) {
     disposeChildren(this, e);
     // Outside a flush the dispose call rethrows; inside one, the flush does.
     // Kept out of `disposeChildren`, whose hot path it slows.
-        if (cleanupError && !globalQueue.q) rethrowCleanupError();
+        if (cleanupError && !globalQueue.Y) rethrowCleanupError();
 }
 
 /**
@@ -309,13 +309,13 @@ function disposeRootSelf(e = true) {
         // was 12 KB and most of disposal's time (2026-10-17).
         R: REACTIVE_NONE,
         Pt: true,
-        ht: n?.Pt ? n.ht : n,
+        Ht: n?.Pt ? n.Ht : n,
         ze: null,
         Xe: null,
         dt: null,
-        rt: null,
+        _t: null,
         A: n?.A || defaultContext,
-        ct: 0,
+        At: 0,
         T: null,
         _parent: n,
         dispose: disposeRootSelf,

package/dist/observe/core/scheduler.js

@@ -1,4 +1,4 @@
-import { EFFECT_RENDER, EFFECT_USER, CONFIG_HELD, CONFIG_OVERRIDE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, CONFIG_STAGED, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_VERDICT, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, CONFIG_HELD_FRAME, REACTIVE_LANE_DIRTY, CONFIG_STAGED_ERROR, CONFIG_INPUTS_PUBLISHED, STATUS_ERROR, EFFECT_TRACKED, REACTIVE_MANUAL_WRITE, CONFIG_GUESS, REACTIVE_FRAME_READ, CONFIG_REDERIVE } from "./constants.js";
+import { EFFECT_RENDER, EFFECT_USER, CONFIG_HELD, CONFIG_OVERRIDE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, CONFIG_STAGED, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_VERDICT, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, CONFIG_HELD_FRAME, REACTIVE_LANE_DIRTY, CONFIG_STAGED_ERROR, CONFIG_INPUTS_PUBLISHED, STATUS_ERROR, EFFECT_TRACKED, REACTIVE_MANUAL_WRITE, CONFIG_GUESS, REACTIVE_FRAME_READ, CONFIG_REDERIVE, CONFIG_FRAME } from "./constants.js";
 
 import { attrHooks } from "./attribution-hooks.js";
 
@@ -40,7 +40,21 @@ let endLanesHook = null;
 
 let lanesBlockedHook = null;
 
-function installLaneHooks(e, o, n, t, l, s, u, r, i) {
+/** R5 (lanes.ts `laneSeams` parks a frame flight): the landing's re-derive
+ * of a reader adopts the flight instead (true: adopted, nothing to queue). */ let laneAdoptHook = null;
+
+/** core.ts `frameRead` served lane work or a verdict reader a held node's
+ * committed value (lanes.ts `laneServed`). */ let laneServedHook = null;
+
+/** A guess was written (lanes.ts `optimisticWrite`): the arms only a guess
+ * reaches (CONFIG_GUESS) — a build without `createOptimistic` or
+ * `createOptimisticStore` never sets it, and its bundler folds them. */ let guessing = false;
+
+function armGuessing() {
+    guessing = true;
+}
+
+function installLaneHooks(e, o, n, t, l, s, u, r, i, a, f) {
     laneReadHook = e;
     laneStageHook = o;
     laneOutcomeHook = n;
@@ -50,6 +64,8 @@ function installLaneHooks(e, o, n, t, l, s, u, r, i) {
     laneCorrectionsHook = u;
     endLanesHook = r;
     lanesBlockedHook = i;
+    laneAdoptHook = a;
+    laneServedHook = f;
 }
 
 // Boundaries (boundaries.ts): the display consumers between an observer
@@ -109,8 +125,12 @@ function installMarkHooks(e, o) {
 
 /** Verdicts (verdict.ts). */ let observeFlightHook = null;
 
-function installVerdictHooks(e) {
+/** D-25's hold work (verdict.ts `holdWork`): on `source` going pending,
+ * whether verdict reader `n` waits on it instead of re-deriving. */ let holdWorkHook = null;
+
+function installVerdictHooks(e, o) {
     observeFlightHook = e;
+    holdWorkHook = o;
 }
 
 /** External-source bridge (wired by enableExternalSource(); undefined while
@@ -131,7 +151,7 @@ function setExternalHooks(e, o) {
 /** A transaction (listed here) or a lane (lanes.ts lists its own). */ function newTransaction(e, o = null) {
     const n = {
         Ye: [],
-        un: [ [], [] ],
+        rn: [ [], [] ],
         En: [],
         eo: null,
         _parent: o,
@@ -140,7 +160,7 @@ function setExternalHooks(e, o) {
         tt: 0,
         nt: false,
         nn: null,
-        It: false,
+        Nt: false,
         ln: false,
         I: null
     };
@@ -175,6 +195,10 @@ function setPassLane(e) {
  * schedules the seam that consumes it: membership is the tick's — the same
  * synchronous frame — and the next tick's writes are not this one's. */ let flushTransaction = null;
 
+/** The flush's transaction while only a `latest()` read of a staging opened
+ * it (verdict.ts `provisionalVerdict`): it holds nothing, and a verdict
+ * reader's plain read of a staging in it is the frame's read (D-22). */ let latestOpened = null;
+
 /** The transaction the passes running OUTSIDE a flush this tick derive from
  * (a mainline mount, a mainline re-pass): the passes' own (A29, creation-
  * time form — "the entry is the pass's alone"): their results are staged
@@ -189,7 +213,7 @@ function setPassLane(e) {
  * set it. */ let passTx = null;
 
 function joinPassTx(e, o) {
-    if (globalQueue.q && !o || flushTransaction !== null) return joinFuture(e);
+    if (globalQueue.Y && !o || flushTransaction !== null) return joinFuture(e);
     if (passTx === null) passTx = resolveTx(e); else merge(resolveTx(e), passTx);
     schedule();
 }
@@ -217,7 +241,7 @@ function resolveTx(e) {
     if (o === null) {
         flushTransaction = e === null ? newTransaction(false) : resolveTx(e);
     } else if (e !== null) merge(resolveTx(e), o);
-    if (!globalQueue.q) schedule();
+    if (!globalQueue.Y) schedule();
 }
 
 /** `t` merges into `f`: the work that touched both entangles them (A15).
@@ -233,8 +257,8 @@ function resolveTx(e) {
     o.tt += e.tt;
     o.nt ||= e.nt;
     append(o.Ye, e.Ye);
-    append(o.un[0], e.un[0]);
-    append(o.un[1], e.un[1]);
+    append(o.rn[0], e.rn[0]);
+    append(o.rn[1], e.rn[1]);
     append(o.En, e.En);
     if (e.I !== null) append(o.I ??= [], e.I);
     transactions.splice(transactions.indexOf(e), 1);
@@ -323,7 +347,7 @@ function blockedBy(e, o, n = false) {
             // lane-membership ruling, 2026-10-05). An output that never committed
             // shows nothing — a mount the frame has not revealed — and holds
             // nothing.
-                        if ((n.i === EFFECT_RENDER && n.m & STATUS_PENDING || n.R & REACTIVE_FRAME_READ || n.l & CONFIG_REDERIVE && n.m === STATUS_PENDING) && (e.Ie === n.Ne || n.T?.F != null) && !(n.R & REACTIVE_DISPOSED) && onScreen(n, judge ?? o)) return true;
+                        if ((n.i === EFFECT_RENDER && n.m & STATUS_PENDING || n.R & REACTIVE_FRAME_READ || n.l & CONFIG_REDERIVE && n.m === STATUS_PENDING) && (e.de === n.Ne || n.T?.U != null) && !(n.R & REACTIVE_DISPOSED) && onScreen(n, judge ?? o)) return true;
         }
     }
     return false;
@@ -425,10 +449,10 @@ function deferZombie(e) {
 }
 
 const dirtyQueue = {
-    gt: new Array(2e3).fill(undefined),
+    jt: new Array(2e3).fill(undefined),
     p: false,
-    lt: 0,
-    jt: 0
+    Et: 0,
+    yt: 0
 };
 
 let clock = 0;
@@ -491,7 +515,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.q) {
+    if (!syncDepth && !globalQueue.Y) {
         queueMicrotask(flush);
     }
 }
@@ -553,11 +577,11 @@ function notifyHalted() {
 }
 
 class GlobalQueue {
-    un=[ [], [] ];
-    q=false;
+    rn=[ [], [] ];
+    Y=false;
     flush() {
-        if (this.q) return;
-        this.q = true;
+        if (this.Y) return;
+        this.Y = true;
         // A28: companions of nodes written since the last flush mirror the
         // flushed world — re-synced inside the running window (the write is
         // "flushed" from here on).
@@ -575,7 +599,7 @@ class GlobalQueue {
             clock++;
             // A write the commit sweep staged with no subscriber to dirty is work
             // too — the next round commits it.
-                        scheduled = dirtyQueue.jt >= dirtyQueue.lt || pendingNodes.length !== 0;
+                        scheduled = dirtyQueue.yt >= dirtyQueue.Et || pendingNodes.length !== 0;
             this.run(EFFECT_RENDER);
             this.run(EFFECT_USER);
             if (true && holding) {
@@ -585,7 +609,7 @@ class GlobalQueue {
             if (false && !scheduled) ;
             if (false) ;
         } finally {
-            this.q = false;
+            this.Y = false;
             passTx = null;
         }
     }
@@ -600,7 +624,7 @@ class GlobalQueue {
         // pure round — the parent's flights before the parent is judged below.
         if (laneCorrectionsHook?.()) runHeap(dirtyQueue, GlobalQueue.Ze);
         const e = flushTransaction;
-        flushTransaction = null;
+        flushTransaction = latestOpened = null;
         // The frame's verdict is in: the guesses written since the last seam
         // open their lane under the frame's transaction (a lane's own flush
         // parents a nested lane to it), or are dropped — the frame commits, and
@@ -629,18 +653,18 @@ class GlobalQueue {
                     // stale stamp was the bridge that entangled unrelated updates
                     // with a never-resolving flight). Its observers are held and
                     // wait on its flight (`blocked`).
-                    if (e.ie === NOT_PENDING && e.m & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
+                    if (e.ue === NOT_PENDING && e.m & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
                     // A34 (2): a tick whose writes net to the committed value made no
                     // proposal (`setShow(false); setShow(true)` on a committed true) —
                     // not staged, not held, pends nothing; a later write to it is
                     // plain mainline. (A node already held stays held when written
                     // back: A34 (1).)
-                                        if (e.ie !== NOT_PENDING && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.T?.ft == null && e.T?.Nt == null && 
+                                        if (e.ue !== NOT_PENDING && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.T?.ft == null && e.T?.Tt == null && 
                     // The comparator last: a pass that created children (an object
                     // owning a fresh async memo, #4111) must not have it read them.
                     // A NotReady read there is a change (`isSame`).
-                    isSame(e, e.le, e.ie)) {
-                        e.ie = NOT_PENDING;
+                    isSame(e, e.le, e.ue)) {
+                        e.ue = NOT_PENDING;
                         e.l &= ~CONFIG_STAGED;
                         continue;
                     }
@@ -665,7 +689,7 @@ class GlobalQueue {
             // (Verdict readers exist only with the verdict engine installed.)
                         const n = deferredZombies.splice(0);
             if (observeFlightHook) {
-                n.sort((e, o) => e.Et - o.Et);
+                n.sort((e, o) => e.lt - o.lt);
                 for (let e = 0; e < n.length; e++) if ((n[e].R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE && n[e].l & CONFIG_VERDICT) recompute(n[e]);
             }
             // The unchanged passes' tails stay linked (A30, #3469): their inputs
@@ -679,7 +703,7 @@ class GlobalQueue {
             // `recompute`'s own gates.
                         for (let e = 0; e < heldTrims.length; e++) {
                 const o = heldTrims[e];
-                if (o.T?.F == null && !o.Qe) trimStaleDeps(o);
+                if (o.T?.U == null && !o.Qe) trimStaleDeps(o);
             }
         }
         // The list is the flush's either way. Reset only when there is something
@@ -693,17 +717,17 @@ class GlobalQueue {
         // removes its entry.
         // This flush's own runs, the lanes' reveals, and the landings' held runs
         // are collected apart and ordered below.
-                const n = this.un;
+                const n = this.rn;
         const t = [ [], [] ];
         // The passes that read this frame's stagings as the screen read held
         // writes if it parked: the lane seam re-derives them on the committed
         // world (a lane's runs wait this round).
                 if (laneSeamsHook) {
-            this.un = t;
-            laneSeamsHook(o !== null ? stagedReaders : null);
+            this.rn = t;
+            laneSeamsHook(o);
             if (stagedReaders.length) stagedReaders.length = 0;
         }
-        this.un = [ [], [] ];
+        this.rn = [ [], [] ];
         for (let e = transactions.length - 1; e >= 0; e--) {
             const o = transactions[e];
             if (blocked(o)) continue;
@@ -741,17 +765,17 @@ class GlobalQueue {
             holding = true;
         }
         for (let e = 0; e < 2; e++) {
-            if (s) append(l.un[e], n[e]);
+            if (s) append(l.rn[e], n[e]);
             // The plain flush — no reveal, no landing, not parked — has nothing to
             // order around its own runs: they are the queue as they stand (the
             // same array, not a copy; `run` takes it whole). Every other seam
             // builds the ordered queue above.
-                        this.un[e] = s || t[e].length || this.un[e].length ? t[e].concat(s ? [] : n[e], this.un[e]) : n[e];
+                        this.rn[e] = s || t[e].length || this.rn[e].length ? t[e].concat(s ? [] : n[e], this.rn[e]) : n[e];
         }
         if (deferredZombies.length !== 0) {
             // Survivors are the displayed frame of a held pass: they rerun for the
             // live write, parents before children.
-            const e = deferredZombies.splice(0).sort((e, o) => e.Et - o.Et);
+            const e = deferredZombies.splice(0).sort((e, o) => e.lt - o.lt);
             for (let o = 0; o < e.length; o++) {
                 if (!(e[o].R & REACTIVE_DISPOSED)) recompute(e[o]);
             }
@@ -761,9 +785,9 @@ class GlobalQueue {
                 boundarySeamHook?.();
     }
     run(e) {
-        const o = this.un[e - 1];
+        const o = this.rn[e - 1];
         if (o.length) {
-            this.un[e - 1] = [];
+            this.rn[e - 1] = [];
             runQueue(o, e);
         }
     }
@@ -772,7 +796,7 @@ class GlobalQueue {
         // the frame (which may park). A lane pass that read the frame's own
         // staging is the frame's (`recompute` passes null): its run waits with
         // the frame.
-        if (e) (n !== null ? n : this).un[e - 1].push(o);
+        if (e) (n !== null ? n : this).rn[e - 1].push(o);
         schedule();
     }
     /** Status reaching the root: pending is absorbed (the root mount defers —
@@ -828,17 +852,39 @@ class GlobalQueue {
         const t = e.En[n];
         // An errored reader's display is its error (D-39): the landing gives it
         // nothing to re-derive, and a re-run would be a read that retries the
-        // errored source (#3945).
-                if (t.R & REACTIVE_DISPOSED || t.m & STATUS_ERROR) continue;
-        if (t.R & REACTIVE_FRAME_READ || t.l & CONFIG_VERDICT) {
-            o ||= t.i;
-            t.R &= ~REACTIVE_FRAME_READ;
+        // errored source (#3945) — unless that source is errored no longer: the
+        // reader was served a shown error the landing replaces (`throwShown`).
+        // Nor is the reader's own error: its pass threw over the committed value
+        // of what the landing carries, served as the screen (A10; a lane's node
+        // reading its parent's hold, or a pass with no value yet reading a
+        // staging, `stagedScreen`) — the landing is the new answer, and the
+        // reader re-derives on it (A15; D-39). A first load read so has no other
+        // run: its error would stay the screen (async-gen 91501 #1158, #119).
+        // A boundary's structure (its tree, its output: CONFIG_FRAME, no effect
+        // type) re-derives all the same: what it read as the screen is the
+        // content the landing replaces, and only its pass links the new content
+        // whose recovery must reach it (D-3, D-39, #4405).
+                const l = t.T?.U?.source;
+        if (t.R & REACTIVE_DISPOSED || t.m & STATUS_ERROR && (t.i || !(t.l & CONFIG_FRAME)) && l !== t && (l?.m ?? STATUS_ERROR) & STATUS_ERROR) continue;
+        if (t.R & REACTIVE_FRAME_READ || observeFlightHook && t.l & CONFIG_VERDICT) {
+            // A memo re-deriving its own error holds the release as an effect
+            // does (`land`): run first, the held runs showed that error beside a
+            // frame about to replace it (#4407; #4284: the grouping never changes
+            // the screen).
+            o ||= t.i || l === t;
+            // A lane's reveal leaves the mark to the transaction: a reader that
+            // also read a held node as committed (`staleReader`) still observes
+            // that flight until it re-runs — cleared here, the transaction landed
+            // at this seam with the flight up and voided the reveal's run (#4397).
+                        if (!e.V) t.R &= ~REACTIVE_FRAME_READ;
             t.Qe = false;
             // Its frame is replaced by the re-derivation: a run one of its
             // children queued this flush (re-run by the same landing) is for the
             // frame being replaced — void too (#3404).
                         for (let e = t.ze; e !== null; e = e.Xe) if (e.i) e.Qe = false;
-            enqueueSub(t);
+            // A frame flight the seam parked (lanes.ts `laneSeams`, R5) asked the
+            // question this landing would: adopted, it is asked once (F-9).
+                        if (!laneAdoptHook?.(t)) enqueueSub(t);
         }
     }
     e.En.length = 0;
@@ -872,7 +918,7 @@ class GlobalQueue {
     // value. Queued last in this effect phase, the release hands them to the
     // next round's own runs, ahead of the re-derivation's: they show with it,
     // or park with it in the hold its pending opens. The commits stand.
-        if (o) globalQueue.un[1].push(() => releaseQueues(e)); else releaseQueues(e);
+        if (o) globalQueue.rn[1].push(() => releaseQueues(e)); else releaseQueues(e);
 }
 
 /** The held runs join this flush's effect phase after its own runs (the
@@ -880,8 +926,8 @@ class GlobalQueue {
  * pass would have queued them — a shell re-derived at the landing before a
  * boundary swap held since the write (#3540's log order). */ function releaseQueues(e) {
     for (let o = 0; o < 2; o++) {
-        append(globalQueue.un[o], e.un[o]);
-        e.un[o] = [];
+        append(globalQueue.rn[o], e.rn[o]);
+        e.rn[o] = [];
     }
 }
 
@@ -907,7 +953,7 @@ class GlobalQueue {
 
 function queuePendingNode(e) {
     pendingNodes.push(e);
-    if (!globalQueue.q) markUnflushedStaged();
+    if (!globalQueue.Y) markUnflushedStaged();
  // A28
 }
 
@@ -923,7 +969,7 @@ function bumpNotifyEpoch() {
 function insertSubs(e) {
     // §12d: stamp before walking — setSignal's staged-rewrite fast path skips
     // the next walk for this node while the epoch holds (marking is idempotent).
-    e.Ot = notifyEpoch;
+    e.Dt = notifyEpoch;
     // Presence bits gate the optional-slot probes (see constants.ts): one
     // masked read of the always-present _config instead of missing-property
     // lookups in the hottest notify loop.
@@ -943,7 +989,7 @@ function insertSubs(e) {
         // pass either re-reads them fresh or trims them), and neither does the
         // tail link: it is the read IN FLIGHT — read() links before it pulls, so
         // this very commit is what that read returns.
-                if (e.R & REACTIVE_RECOMPUTING_DEPS && o.Ie === e.Ne && o !== e._) e.R |= REACTIVE_MISSED_WAKE;
+                if (e.R & REACTIVE_RECOMPUTING_DEPS && o.de === e.Ne && o !== e._) e.R |= REACTIVE_MISSED_WAKE;
         if (n && e.l & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.R |= REACTIVE_SNAPSHOT_STALE;
             continue;
@@ -960,10 +1006,19 @@ function insertSubs(e) {
  * inert for its pass (`recompute` seats a lane only from its own `_x`), it
  * is a live write if the effect becomes a zombie later this flush — an
  * on-screen reader whose removal an adopted write stages follows the lane
- * (the lane-membership ruling, 2026-10-05; `_update`). */ function laneDirty(e, o) {
+ * (the lane-membership ruling, 2026-10-05; `_update`).
+ *
+ * A render effect re-run by a verdict memo's change (`createMemo(() =>
+ * latest(x))`, CONFIG_VERDICT) is the verdict reader the same read inline
+ * makes it, for that pass (F-6; D-26 `[s(), L()]`, #4284): a frame reader
+ * of its other reads — a staging's screen, a flight's committed value. One
+ * an earlier propagation this flush seated in another lane leaves that
+ * seat: its pass starts from the frame's, as the inline effect's does, and
+ * `laneRead` re-derives it on the screen if that lane holds (`entered`). */ function laneDirty(e, o) {
     for (let n = e.o; n !== null; n = n.t) {
-        const e = n.u.T?.Je;
-        if (e?.V ? sameLane(e, o) : n.u.i) n.u.R |= REACTIVE_LANE_DIRTY;
+        const t = n.u, l = t.T?.Je;
+        if (t.i === EFFECT_RENDER && e.l & CONFIG_VERDICT) t.l |= CONFIG_VERDICT, t.R &= ~REACTIVE_LANE_DIRTY;
+        if (l?.V ? sameLane(l, o) : t.i) t.R |= REACTIVE_LANE_DIRTY;
     }
 }
 
@@ -980,44 +1035,44 @@ function commitPendingNode(e) {
     // commits a value.
         if (!o.X) {
         e.l &= -385;
-        if (e.ie !== NOT_PENDING) {
-            e.le = e.ie;
-            e.ie = NOT_PENDING;
+        if (e.ue !== NOT_PENDING) {
+            e.le = e.ue;
+            e.ue = NOT_PENDING;
         }
         return;
     }
     // Computeds only from here (`_statusFlags` is not a signal field). A
     // commit beneath a flight publishes its inputs (A15 reveal corollary,
     // #3305): a reveal of it must observe, not show the pre-flight value.
-        const n = e.ie === NOT_PENDING && (o.m & STATUS_PENDING) !== 0;
+        const n = e.ue === NOT_PENDING && (o.m & STATUS_PENDING) !== 0;
     const t = e.l & CONFIG_STAGED_ERROR;
     // An answer commits: the error it replaces leaves the display (D-41).
-        if (!n && o.T) o.T.Te = undefined;
+        if (!n && o.T) o.T.Te = null;
     e.l = n ? e.l & -1048833 | CONFIG_INPUTS_PUBLISHED : e.l & -3147137;
     // D-41: the staged answer is an error — published now, when a value would
     // show, through the ordinary error path (`stageError`). Its readers first
     // see it in the cycle after this seam: a tracked re-read there is not a
     // retry (`read`), or a boundary re-derived by it would retry it forever.
         if (t) {
-        const n = e.ie;
-        e.ie = NOT_PENDING;
-        e.ae = clock + 1;
+        const n = e.ue;
+        e.ue = NOT_PENDING;
+        e.ie = clock + 1;
         notifyStatus(o, STATUS_ERROR, n);
-    } else if (e.ie !== NOT_PENDING) {
-        e.le = e.ie;
-        e.ie = NOT_PENDING;
+    } else if (e.ue !== NOT_PENDING) {
+        e.le = e.ue;
+        e.ue = NOT_PENDING;
         // A node born staged (recompute) initializes at this commit.
                 o.m &= ~STATUS_UNINITIALIZED;
         // A quiet re-ask's classification survives its landing and dies with
         // the landed value's commit (A19 exc. 2, #3178): verdict-quiet through
         // the reveal. (The sweep of a node still in flight is not a landing.)
         // The A28 stash goes with it.
-                if (o.T != null) o.T.ut = false, o.T.Gt = NOT_PENDING;
+                if (o.T != null) o.T.ut = false, o.T.Ft = NOT_PENDING;
         // An effect with a staged value was born held (L2): its first run is
         // this commit's, not its creation's (A29) — queue it now.
                 if (e.i && e.i !== EFFECT_TRACKED) {
             e.Qe = true;
-            globalQueue.enqueue(e.i, e.W ??= GlobalQueue.K.bind(null, o));
+            globalQueue.enqueue(e.i, e.W ??= GlobalQueue.q.bind(null, o));
         }
     }
     // The committed value is the first observable answer for a loading-window
@@ -1031,11 +1086,11 @@ function commitPendingNode(e) {
     // pass or by the node's own landing (whose pass was clean), so a set
     // `_error` means the last pass threw, kept its full list, and `_depsTail`
     // marks where it stopped.
-        if (o.T?.F == null) trimStaleDeps(o);
+        if (o.T?.U == null) trimStaleDeps(o);
     if (!(o.m & STATUS_PENDING)) o.m &= ~STATUS_UNINITIALIZED;
     // L2: the children this commit publishes are the frame's now — the frame
     // they replace, parked by the pass (`recompute`), goes.
-        if (!n && o.T != null && (o.T.ft !== null || o.T.Nt !== null)) GlobalQueue.et(o, false, true);
+        if (!n && o.T != null && (o.T.ft !== null || o.T.Tt !== null)) GlobalQueue.et(o, false, true);
 }
 
 function commitPendingNodes() {
@@ -1069,7 +1124,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.q) {
+    if (globalQueue.Y) {
         return;
     }
     if (halted) return;
@@ -1099,4 +1154,4 @@ function runQueue(e, o) {
     for (let n = 0; n < e.length; n++) e[n](o);
 }
 
-export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, blockersOf, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, haltReactivityAt, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneStageHook, laneWriteHook, lanesBlockedHook, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, pendingNodes, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };
+export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, armGuessing, blocked, blockersOf, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, guessing, haltReactivity, haltReactivityAt, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, holdWorkHook, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneAdoptHook, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneServedHook, laneStageHook, laneWriteHook, lanesBlockedHook, latestOpened, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, pendingNodes, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };

package/dist/observe/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.V;
-    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.je && r.je(r.T.V, r.ie);
-    if (r.ie !== NOT_PENDING) return;
+    if (r.l & CONFIG_GUESS) return r.ue !== NOT_PENDING && r.je && r.je(r.T.V, 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;
 }