@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/prod/affects.js

@@ -4,7 +4,9 @@ import { ext } from "./core/core.js";
 
 import { enqueueSub } from "./core/heap.js";
 
-import { GlobalQueue, schedule, resolveTx, flushTransaction } from "./core/scheduler.js";
+import { schedule, resolveTx, flushTransaction, GlobalQueue } from "./core/scheduler.js";
+
+import { storeMarks, installStoreAffects, releaseMarkScope } from "./store/affects.js";
 
 import { $TARGET } from "./store/types.js";
 
@@ -36,12 +38,12 @@ let active = 0;
 /** The verdict readers downstream of `node` — through derivations, stopping
  * at effects — re-derive: the mark's one notification (a probe's answer
  * changed with no value notifying anyone). */ function repoll(e, t = new Set) {
-    for (let n = e.t; n !== null; n = n.l) {
-        const e = n.o;
+    for (let r = e.t; r !== null; r = r.o) {
+        const e = r.l;
         if (t.has(e)) continue;
         t.add(e);
-        if (e.u & CONFIG_VERDICT) enqueueSub(e);
-        if (!e.i) repoll(e, t);
+        if (e.i & CONFIG_VERDICT) enqueueSub(e);
+        if (!e.u) repoll(e, t);
     }
 }
 
@@ -51,13 +53,13 @@ let active = 0;
  * (a direct mark on one still reads pending). Mid-recompute, only the
  * validated prefix of the dependency list is this pass's. */ function marked(e, t) {
     if (e.m !== null && e.m.T !== 0) return true;
-    const n = e;
-    if (n.G & STATUS_ERROR || t.has(e)) return false;
+    const r = e;
+    if (r.S & STATUS_ERROR || t.has(e)) return false;
     t.add(e);
-    const r = n.R & REACTIVE_RECOMPUTING_DEPS ? n.S : undefined;
-    if (r !== null) for (let e = n._ ?? null; e !== null; e = e.p) {
+    const n = r.R & REACTIVE_RECOMPUTING_DEPS ? r.G : undefined;
+    if (n !== null) for (let e = r.p ?? null; e !== null; e = e._) {
         if (marked(e.I, t)) return true;
-        if (e === r) break;
+        if (e === n) break;
     }
     return false;
 }
@@ -65,13 +67,13 @@ let active = 0;
 /** Releases one scope's marks (a landed transaction's, the ambient list at
  * the seam): a node whose last mark drops re-derives its verdict readers. */ function release(e) {
     for (let t = 0; t < e.length; t++) {
-        const n = e[t];
+        const r = e[t];
         active--;
-        if (--n.m.T === 0) {
-            repoll(n);
+        if (--r.m.T === 0) {
+            repoll(r);
             // A store mark's carrier: its scope (and the marks the nodes born in
             // its window inherited) goes with it.
-                        GlobalQueue.N?.(n);
+                        releaseMarkScope(r);
         }
     }
     e.length = 0;
@@ -82,8 +84,8 @@ let active = 0;
     mark(e);
     const t = flushTransaction;
     if (t === null) ambient.push(e); else {
-        const n = resolveTx(t);
-        (n.T ??= []).push(e);
+        const r = resolveTx(t);
+        (r.T ??= []).push(e);
     }
     repoll(e);
 }
@@ -96,28 +98,29 @@ function mark(e) {
 function affects(e, t) {
     // A store (the store half, store/affects.ts): the slot's leaf, or the
     // record's carrier and every live node under it.
-    const n = e?.[$TARGET];
-    if (n !== undefined) {
-        const e = GlobalQueue.O(n, t);
+    const r = e?.[$TARGET];
+    if (r !== undefined) {
+        installStoreAffects();
+        const e = storeMarks(r, t);
         for (let t = 0; t < e.length; t++) register(e[t]);
         schedule();
         return;
     }
-    const r = e?.[$REFRESH];
-    if (!r) {
+    const n = e?.[$REFRESH];
+    if (!n) {
         return;
     }
-    register(r);
+    register(n);
     schedule();
 }
 
-GlobalQueue.C = e => active !== 0 && marked(e, new Set);
+GlobalQueue.N = e => active !== 0 && marked(e, new Set);
 
-GlobalQueue.h = mark;
+GlobalQueue.O = mark;
 
-GlobalQueue.A = release;
+GlobalQueue.k = release;
 
-GlobalQueue.D = e => {
+GlobalQueue.A = e => {
     if (ambient.length === 0) return;
     // The flush parked: the declaration's window is the frame's — the marks
     // are its transaction's ("nothing async below ⇒ no window").
@@ -132,17 +135,17 @@ GlobalQueue.D = e => {
     // the window is the flight's; the mark stays to the seam after the
     // landing. The rest release: verdict-only, nothing to show.
         let t = 0;
-    const n = [];
+    const r = [];
     for (let e = 0; e < ambient.length; e++) {
-        const r = ambient[e];
-        if (inFlight(r)) ambient[t++] = r; else n.push(r);
+        const n = ambient[e];
+        if (inFlight(n)) ambient[t++] = n; else r.push(n);
     }
     ambient.length = t;
-    if (n.length !== 0) release(n);
+    if (r.length !== 0) release(r);
 };
 
 function inFlight(e) {
-    return (e.G & STATUS_PENDING) !== 0 || (e.u & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.F?.(e) === true;
+    return (e.S & STATUS_PENDING) !== 0 || (e.i & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.C?.(e) === true;
 }
 
 export { affects };

package/dist/prod/boundaries.js

@@ -1,4 +1,4 @@
-import { STATUS_PENDING, STATUS_ERROR, CONFIG_REDERIVE, REACTIVE_DISPOSED, STATUS_UNINITIALIZED, CONFIG_HELD, REACTIVE_ZOMBIE, CONFIG_VERDICT, REACTIVE_LANE_READ, CONFIG_OVERRIDE, EFFECT_USER, EFFECT_TRACKED } from "./core/constants.js";
+import { STATUS_PENDING, STATUS_ERROR, CONFIG_REDERIVE, REACTIVE_DISPOSED, STATUS_UNINITIALIZED, CONFIG_HELD, EFFECT_RENDER, REACTIVE_ZOMBIE, CONFIG_VERDICT, REACTIVE_LANE_READ, CONFIG_OVERRIDE, EFFECT_USER, EFFECT_TRACKED } from "./core/constants.js";
 
 import { signal, runWithOwner, computed, read, setSignal, recompute } from "./core/core.js";
 
@@ -10,7 +10,7 @@ import { link } from "./core/graph.js";
 
 import { enqueueSub } from "./core/heap.js";
 
-import { createOwner, getOwner, cleanup } from "./core/owner.js";
+import { createOwner, getOwner, cleanup, dispose } from "./core/owner.js";
 
 import { globalQueue, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, schedule, setPassLane, txOf } from "./core/scheduler.js";
 
@@ -73,34 +73,34 @@ function setRevealHooks(e) {
 
 /** Boundaries with readers to sweep (or an arm to resolve) at the seam. */ const collecting = new Set;
 
-const boundaryOf = e => e.U[BOUNDARY];
+const boundaryOf = e => e.D[BOUNDARY];
 
 /** Catches what reaches it: an error boundary always; a loading one until it
- * has shown content, or while re-armed. */ const isCollecting = e => e.i === STATUS_ERROR || !e.L || e.k;
+ * has shown content, or while re-armed. */ const isCollecting = e => e.u === STATUS_ERROR || !e.h || e.U;
 
 /** The reader goes to the fallback: recorded, and the output re-derives
  * (a no-op while the output's own pass is running — its post-check
  * decides). */ function caught(e, n, r) {
-    if (e.i === STATUS_ERROR) {
+    if (e.u === STATUS_ERROR) {
         // An error boundary waits on what THREW (`StatusError.source`), not on
         // the reader that saw it: the reader recovers the moment a refetch
         // starts (its boundary catches the pending), while the error is settled
         // only when its source is neither errored nor in flight. `reset` re-runs
         // the same node.
-        r ??= n.m?.V;
+        r ??= n.m?.F;
         n = r?.source ?? n;
         const t = unwrapStatusError(r);
-        setSignal(e.V, t);
-        reportClientError(t, e.v, n);
+        setSignal(e.F, t);
+        reportClientError(t, e.L, n);
     }
-    e.H.add(n);
+    e.V.add(n);
     collecting.add(e);
-    if (e.k) flip(e);
+    if (e.U) flip(e);
     // Already showing the fallback: one more reader to wait on changes
     // 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.P) redraw(e);
-    if (e.B !== null) revealHooks.j(e.B);
+        if (!e.v) redraw(e);
+    if (e.H !== null) revealHooks.P(e.H);
 }
 
 /** A re-armed boundary found something pending: fresh again, and the swap
@@ -108,14 +108,14 @@ const boundaryOf = e => e.U[BOUNDARY];
  * the lane's work from its next pass's head — not a re-pass of the
  * transaction holding its pending content, which would entangle that
  * transaction with the arming frame's (#3540 `on: () => latest(dep)`). */ function flip(e) {
-    e.L = false;
-    e.Z = e.W;
-    if (e.Z !== null && e.K !== null) GlobalQueue.M(e.K, e.Z, true, false);
+    e.h = false;
+    e.B = e.j;
+    if (e.B !== null && e.Z !== null) GlobalQueue.W(e.Z, e.B, true, false);
 }
 
 function redraw(e) {
-    if (e.K !== null && !(e.K.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
-        enqueueSub(e.K);
+    if (e.Z !== null && !(e.Z.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        enqueueSub(e.Z);
         schedule();
     }
 }
@@ -131,26 +131,26 @@ function redraw(e) {
         // held reader's landing has joined its transaction, so the content
         // lands with its run, not a round after). Others still waiting: nothing
         // on screen changes, the fallback stays as it is.
-        if (collecting.size !== 0) for (let n = boundaryOf(e); n !== undefined; n = n._parent ?? undefined) if (!(e.G & unsettled(n)) && n.H.delete(e) && n.H.size === 0) {
-            if (n.P) redraw(n);
-            if (n.B !== null) revealHooks.j(n.B);
+        if (collecting.size !== 0) for (let n = boundaryOf(e); n !== undefined; n = n._parent ?? undefined) if (!(e.S & unsettled(n)) && n.V.delete(e) && n.V.size === 0) {
+            if (n.v) redraw(n);
+            if (n.H !== null) revealHooks.P(n.H);
         }
         return false;
     }
     for (let t = boundaryOf(e); t !== undefined; t = t._parent ?? undefined) {
-        if (!(t.i & n)) continue;
+        if (!(t.u & n)) continue;
         if (isCollecting(t)) {
             caught(t, e, r);
             return true;
         }
-        t.H.add(e);
+        t.V.add(e);
         collecting.add(t);
     }
     return false;
 }
 
 /** The nearest boundary on `r`'s chain showing its fallback, if any. */ function hiddenBy(e) {
-    for (let n = boundaryOf(e); n !== undefined; n = n._parent ?? undefined) if (n.P) return n;
+    for (let n = boundaryOf(e); n !== undefined; n = n._parent ?? undefined) if (n.v) return n;
     return undefined;
 }
 
@@ -171,19 +171,19 @@ function redraw(e) {
  * still showing its fallback holds it again then. */ function heldRun(e) {
     const n = hiddenBy(e);
     if (n === undefined) return false;
-    (n.Y ??= new Set).add(e);
+    (n.K ??= 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.Y === null) return;
-    for (const n of e.Y) {
-        const e = n.i;
-        globalQueue.enqueue(e === EFFECT_TRACKED ? EFFECT_USER : e, e === EFFECT_TRACKED ? n.q : n.J ??= GlobalQueue.X.bind(null, n));
+    if (e.K === null) return;
+    for (const n of e.K) {
+        const e = n.u;
+        globalQueue.enqueue(e === EFFECT_TRACKED ? EFFECT_USER : e, e === EFFECT_TRACKED ? n.M : n.Y ??= GlobalQueue.q.bind(null, n));
     }
-    e.Y = null;
+    e.K = null;
 }
 
 /** Drop the readers that settled or died. Settled: a loading reader no
@@ -191,37 +191,40 @@ function redraw(e) {
  * that landed but is held (its value staged in a transaction) is not: the
  * content reveals at the commit, with its run. The tree is: the output reads
  * it and enters the transaction itself (its committed value shows until the
- * landing). */ const unsettled = e => e.i === STATUS_ERROR ? STATUS_ERROR | STATUS_PENDING : STATUS_PENDING;
+ * landing). */ const unsettled = e => e.u === STATUS_ERROR ? STATUS_ERROR | STATUS_PENDING : STATUS_PENDING;
 
 function prune(e, n) {
     const r = unsettled(e);
-    for (const t of e.H) {
-        if (t.R & REACTIVE_DISPOSED) e.H.delete(t); else if (!(t.G & r)) {
-            if (t !== e.$ && (t.u & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) {
+    for (const t of e.V) {
+        if (t.R & REACTIVE_DISPOSED) e.V.delete(t); else if (!(t.S & r)) {
+            if (t !== e.J && (t.i & (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
-                // lane's reader reveals with the lane, this round.)
-                if (!n) continue;
+                // lane's reader reveals with the lane, this round.) A boundary that
+                // has not shown content catches it instead: the fallback stays until
+                // the reader is committed (#3540: what a fresh boundary catches holds
+                // nothing outside it).
+                if (!n || !e.h) continue;
                 joinFuture(txOf(t));
             }
-            e.H.delete(t);
+            e.V.delete(t);
         }
     }
-    return e.H.size;
+    return e.V.size;
 }
 
 /** Reveal order: a slot is ready when its content can show — it has shown
  * content, or nothing under it is unready (the tree neither pending nor
  * born held, no reader waited on). */ function ready(e) {
-    return e.L || !(e.$.G & STATUS_PENDING) && !(e.$.u & CONFIG_HELD && (e.K === null || e.K.G & STATUS_UNINITIALIZED)) && prune(e, false) === 0;
+    return e.h || !(e.J.S & STATUS_PENDING) && !(e.J.i & CONFIG_HELD && (e.Z === null || e.Z.S & STATUS_UNINITIALIZED)) && prune(e, false) === 0;
 }
 
 /** GlobalQueue._boundarySeam, end of the seam: readers that settled, died,
  * or landed and committed are dropped; a fallback with none left reveals
  * next round. An arm resolves: nothing collected, nothing happened. */ function boundarySeam() {
     for (const e of collecting) {
-        const n = e.K.R;
+        const n = e.Z.R;
         if (n & REACTIVE_DISPOSED) {
             collecting.delete(e);
             continue;
@@ -229,11 +232,11 @@ function prune(e, n) {
         // A parked frame's boundary (zombie) keeps its state for its revival.
                 if (n & REACTIVE_ZOMBIE) continue;
         prune(e, false);
-        e.k = false;
-        if (e.H.size === 0) {
+        e.U = false;
+        if (e.V.size === 0) {
             collecting.delete(e);
-            if (e.P) redraw(e);
-            if (e.B !== null) revealHooks.j(e.B);
+            if (e.v) redraw(e);
+            if (e.H !== null) revealHooks.P(e.H);
         }
     }
 }
@@ -241,22 +244,22 @@ function prune(e, n) {
 /** The `on` pass is a verdict's: it probed itself (CONFIG_VERDICT), or it
  * read a memo that did (#3528's `createMemo(() => isPending(m2))`) — its
  * swap is display-ahead either way. */ function verdictDerived(e) {
-    if (e.u & CONFIG_VERDICT) return true;
-    for (let n = e._; n !== null; n = n.p) if (n.I.u & CONFIG_VERDICT) return true;
+    if (e.i & CONFIG_VERDICT) return true;
+    for (let n = e.p; n !== null; n = n._) if (n.I.i & CONFIG_VERDICT) return true;
     return false;
 }
 
 /** `on` changed after the mount: fresh again if anything under it is
  * pending now; collecting for the rest of the flush either way. */ function arm(e) {
-    if (!e.L) {
+    if (!e.h) {
         // Already re-armed and on its fallback, as the frame's work — and the
         // `on` pass arms again as lane work: its verdict was provisional (a
         // memo of `isPending(m2)` is a watcher until the flush parks, then the
         // holder's verdict lane's — verdict.ts), and the swap it asked for is
         // display-ahead after all (#3528). Re-home the swap: the output re-runs
         // as the lane's, shown now beside the held frame.
-        if (e.P && e.Z === null && e.W === null && passLane !== null) {
-            e.W = passLane;
+        if (e.v && e.B === null && e.j === null && passLane !== null) {
+            e.j = passLane;
             // The swap the frame's pass staged (held with the frame) is void: the
             // lane's pass stages it anew (`flip` lists the output in the lane,
             // which voids its staging), as a watcher's provisional value is
@@ -266,20 +269,20 @@ function prune(e, n) {
         }
         return;
     }
-    e.k = true;
+    e.U = true;
     // A verdict read in `on` (`isPending`) whose frame has no transaction
     // yet: the swap is still display-ahead — the frame gets one now (it lands
     // at this very seam if nothing holds it), and the swap is its verdict
     // lane's work, shown ahead of the frame's own runs (#3528).
         let n = passLane;
-    if (n === null && globalQueue.ee && verdictDerived(getOwner())) {
+    if (n === null && globalQueue.X && verdictDerived(getOwner())) {
         joinFuture(null);
-        n = GlobalQueue.ne(flushTransaction);
+        n = GlobalQueue.$(flushTransaction);
     }
-    e.W = n;
+    e.j = n;
     collecting.add(e);
-    for (const n of e.H) {
-        if (n.G & STATUS_PENDING && !(n.R & REACTIVE_DISPOSED)) {
+    for (const n of e.V) {
+        if (n.S & STATUS_PENDING && !(n.R & REACTIVE_DISPOSED)) {
             flip(e);
             redraw(e);
             return;
@@ -290,35 +293,36 @@ function prune(e, n) {
 /** The error boundary's `reset`: re-run what threw (a comparator throw
  * names a signal — nothing to re-run). */ function reset(e) {
     // A snapshot: a source failing again is caught — and re-added — mid-walk.
-    for (const n of [ ...e.H ]) if (n.re !== undefined && !(n.R & REACTIVE_DISPOSED)) recompute(n);
+    for (const n of [ ...e.V ]) if (n.ee !== undefined && !(n.R & REACTIVE_DISPOSED)) recompute(n);
     schedule();
 }
 
 function createBoundary(e, n, r, t) {
     const l = createOwner();
     const o = {
-        i: e,
+        u: e,
         _parent: boundaryOf(l) ?? null,
-        v: l,
-        $: null,
-        K: null,
-        H: new Set,
-        L: false,
-        k: false,
-        W: null,
+        L: l,
+        J: null,
         Z: null,
-        P: false,
-        Y: null,
+        V: new Set,
+        h: false,
+        U: false,
+        j: null,
         B: null,
-        te: false,
-        le: false,
-        V: e === STATUS_ERROR ? signal(undefined, ERROR_SIGNAL) : null,
-        oe: r
+        v: false,
+        K: null,
+        H: null,
+        ne: false,
+        re: false,
+        F: e === STATUS_ERROR ? signal(undefined, ERROR_SIGNAL) : null,
+        te: r,
+        le: null
     };
-    const u = e === STATUS_PENDING ? l.U[REVEAL] : null;
+    const u = e === STATUS_PENDING ? l.D[REVEAL] : null;
     if (getOwner()) cleanup(() => {
         collecting.delete(o);
-        if (u) revealHooks.ue(u, o);
+        if (u) revealHooks.oe(u, o);
     });
     // The `on` dependencies live OUTSIDE the boundary, as the condition of a
     // `<Show>` wrapping it would: created before the owner's context names it.
@@ -340,14 +344,14 @@ function createBoundary(e, n, r, t) {
                 }
             }
             if (e) arm(o); else e = true;
-        })).u |= CONFIG_REDERIVE;
+        })).i |= CONFIG_REDERIVE;
     }
     const a = {
-        ...l.U,
+        ...l.D,
         [BOUNDARY]: o
     };
     if (revealHooks !== null) a[REVEAL] = null;
-    l.U = a;
+    l.D = a;
     const i = runWithOwner(l, () => {
         const e = false ? computed(n, {
             name: "children"
@@ -356,26 +360,26 @@ function createBoundary(e, n, r, t) {
             name: "boundary"
         }) : computed(() => flatten(read(e)));
     });
-    o.$ = i;
+    o.J = i;
     // 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.ae(u, o);
+        if (u) revealHooks.ue(u, o);
     const f = computed(() => {
         // 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 (o.te) {
+        if (o.ne) {
             // 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 (o.B !== null) revealHooks.j(o.B);
-            if (o.te) {
-                if (o.le) {
-                    o.P = true;
+            if (o.H !== null) revealHooks.P(o.H);
+            if (o.ne) {
+                if (o.re) {
+                    o.v = true;
                     return undefined;
                 }
                 return fallback(o);
@@ -388,7 +392,7 @@ function createBoundary(e, n, r, 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 n = i.G & (STATUS_PENDING | STATUS_ERROR);
+                const n = i.S & (STATUS_PENDING | STATUS_ERROR);
         if (n !== 0) {
             link(i, getOwner());
             if (n & e) {
@@ -398,12 +402,12 @@ function createBoundary(e, n, r, t) {
                 }
                 // Forwarded: a loading boundary showing content keeps it and
                 // holds the frame like any reader (recorded for its `on`).
-                                o.H.add(i);
+                                o.V.add(i);
                 collecting.add(o);
             }
             // A pending passes an error boundary by (A6); an error, a loading
             // one; a loading boundary showing content forwards its pending.
-                        throw i.m.V;
+                        throw i.m.F;
         }
         if (isCollecting(o)) {
             // A29's boundary exemption (#3540): a boundary MOUNTED over a held
@@ -418,7 +422,7 @@ function createBoundary(e, n, r, t) {
             // which reveals the content — a fallback staged earlier is replaced
             // ahead of the commit and never shown.
             const e = getOwner();
-            if (o.H.size !== 0 && e.G & STATUS_UNINITIALIZED && !(e.u & CONFIG_HELD)) return fallback(o);
+            if (o.V.size !== 0 && e.S & STATUS_UNINITIALIZED && !(e.i & CONFIG_HELD)) return fallback(o);
             // Readers under it still unready: the fallback, the tree untouched.
             // The seam re-derives this pass when they settle.
                         if (prune(o, true) !== 0) return fallback(o);
@@ -434,7 +438,7 @@ function createBoundary(e, n, r, t) {
                 }
                 // Forwarded: a loading boundary showing content keeps it and
                 // holds the frame like any reader (recorded for its `on`).
-                                o.H.add(i);
+                                o.V.add(i);
                 collecting.add(o);
             }
             // A pending passes an error boundary by (A6).
@@ -442,16 +446,29 @@ function createBoundary(e, n, r, t) {
         }
         // Readers under it still unready (caught before, or while the read
         // ran the content at a mount): the fallback.
-                if (isCollecting(o) && o.H.size !== 0) return fallback(o);
-        o.L = true;
-        o.P = false;
+                if (isCollecting(o) && o.V.size !== 0) return fallback(o);
+        o.h = true;
+        o.v = false;
+        // The fallback dies when the content that replaces it is on screen —
+        // with this flush's commits when the pass is the frame's, at the
+        // 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.
+                const t = o.le;
+        if (t !== null) globalQueue.enqueue(EFFECT_RENDER, () => {
+            if (!o.v && o.le === t) {
+                dispose(t);
+                o.le = null;
+            }
+        });
         release(o);
         // Shown: the slot leaves its reveal order (a later re-arm gates nobody
         // else; the frontier moves on).
-                if (o.B !== null) {
-            const e = o.B;
-            o.B = null;
-            revealHooks.j(e);
+                if (o.H !== null) {
+            const e = o.H;
+            o.H = null;
+            revealHooks.P(e);
         }
         return r;
     }, 
@@ -459,10 +476,10 @@ function createBoundary(e, n, r, t) {
     // and legitimately swaps mid-hydration (resume), so it must never be
     // frozen by snapshot capture.
     {
-        ie: true
+        ae: true
     });
-    f.u |= CONFIG_REDERIVE;
-    o.K = f;
+    f.i |= CONFIG_REDERIVE;
+    o.Z = f;
     return accessor(f);
 }
 
@@ -470,18 +487,35 @@ function fallback(e) {
     // The swap a display-ahead re-arm asked for: this pass is the lane's — a
     // lane read by construction (REACTIVE_LANE_READ: `recompute`'s tail keeps
     // the pass in the lane).
-    if (e.Z !== null) {
-        setPassLane(e.Z);
-        e.K.R |= REACTIVE_LANE_READ;
-        e.Z = null;
+    if (e.B !== null) {
+        setPassLane(e.B);
+        e.Z.R |= REACTIVE_LANE_READ;
+        e.B = null;
+    }
+    e.v = true;
+    // Built in its own scope, like `Show`'s function child, once per show
+    // (D-39: the fallback is the display until a new answer replaces the
+    // error): a re-derive of the output while it shows — a second reader
+    // caught, the same error propagated again through a sibling's re-run, a
+    // retry pending after `reset()`, a later error — keeps the built
+    // fallback, its DOM and focus with it (#3991). A later error reaches it
+    // through the error accessor; only a fallback reading the accessor at its
+    // top level is rebuilt by it. Created beside the output — in its owner,
+    // outside the boundary, as the output is: its errors and runs are the
+    // enclosing boundary's — with the output's id, so what it builds gets the
+    // ids a build under the output would; disposed once content is on screen.
+        if (e.le === null) {
+        const n = getOwner();
+        e.le = runWithOwner(n._parent, () => computed(() => e.te(e), {
+            id: n.id
+        }));
     }
-    e.P = true;
-    return e.oe(e);
+    return read(e.le);
 }
 
 const ERROR_SIGNAL = {
     ownedWrite: true,
-    ie: true
+    ae: true
 };
 
 /**
@@ -552,19 +586,19 @@ const ERROR_SIGNAL = {
  * }
  * ```
  */ function createErrorBoundary(e, n) {
-    return createBoundary(STATUS_ERROR, e, e => n(accessor(e.V), () => reset(e)));
+    return createBoundary(STATUS_ERROR, e, e => n(accessor(e.F), () => reset(e)));
 }
 
 // Installed at module evaluation — present exactly when something imports a
 // boundary. An app without one pays the three null checks and nothing else.
-GlobalQueue.fe = catchStatus;
+GlobalQueue.ie = catchStatus;
 
-GlobalQueue.ce = e => e.G & STATUS_UNINITIALIZED && catchStatus(e, STATUS_PENDING);
+GlobalQueue.fe = e => e.S & STATUS_UNINITIALIZED && catchStatus(e, STATUS_PENDING);
 
-GlobalQueue.se = hidden;
+GlobalQueue.ce = hidden;
 
-GlobalQueue.Ee = boundarySeam;
+GlobalQueue.se = boundarySeam;
 
-GlobalQueue.de = heldRun;
+GlobalQueue.Ee = heldRun;
 
 export { REVEAL, createErrorBoundary, createLoadingBoundary, prune, ready, redraw, revealHooks, setRevealHooks };