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

package/dist/prod/boundaries.js

@@ -1,7 +1,9 @@
-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 { STATUS_PENDING, STATUS_ERROR, CONFIG_REDERIVE, CONFIG_HELD, CONFIG_FRAME, STATUS_UNINITIALIZED, EFFECT_RENDER, CONFIG_VERDICT, REACTIVE_DISPOSED, REACTIVE_LANE_READ, REACTIVE_PROBED, CONFIG_STAGED_ERROR, 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";
 
+import { reportDiagnostic, emitDiagnostic } from "./core/dev.js";
+
 import { NotReadyError, unwrapStatusError } from "./core/error.js";
 
 import { reportClientError } from "./core/error-hooks.js";
@@ -81,27 +83,37 @@ const boundaryOf = e => e.A[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.D || e.h;
 
-/** A reader `b` waits on: recorded for its `on`, and `b` visited at the seam. */ function record(e, r) {
-    e.F.add(r);
+/** A reader `b` waits on: recorded for its `on`, and `b` visited at the seam. */ function record(e, n, r = n) {
+    e.F.set(n, r);
     collecting.add(e);
 }
 
 /** 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, r, n) {
+ * decides). */ function caught(e, n, r, o = n) {
     if (e.i === 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.
-        n ??= r.T?.U;
-        r = n?.source ?? r;
-        const o = unwrapStatusError(n);
-        setSignal(e.U, o);
-        reportClientError(o, e.H, r);
+        // the reader that saw it, while the error is settled only when its
+        // source is neither errored nor in flight and the reader is not pending
+        // on the answer that replaces it (`prune`) — or when the
+        // reader is disposed: a source no live reader holds holds nothing
+        // (#4373). A source that died (a memo its reader owned, kept past the
+        // pass that disposed it) settles nothing: the reader is waited on.
+        // `reset` re-runs the source.
+        r ??= n.T?.U;
+        o = r?.source ?? n;
+        if (o.R & REACTIVE_DISPOSED) o = n;
+        const t = unwrapStatusError(r);
+        setSignal(e.U, t);
+        reportClientError(t, e.H, o);
     }
-    record(e, r);
+    record(e, n, o);
+    // A loading fallback behind an error fallback is hidden: the error stays
+    // the display until what the fallback waits on answers (D-39) — the
+    // error boundary waits on it too.
+    // (`_type`: STATUS_PENDING 1 < STATUS_ERROR 2 — an error boundary above a
+    // loading one.)
+        for (let r = e; r = r._parent; ) if (r.L && r.i > e.i) record(r, n);
     if (e.h) 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
@@ -117,8 +129,8 @@ const boundaryOf = e => e.A[BOUNDARY];
  * transaction with the arming frame's (#3540 `on: () => latest(dep)`). */ function flip(e) {
     e.D = false;
     e.P = e.B;
-    const r = e.j;
-    if (!e.P && r.l & CONFIG_HELD && txOf(r) !== flushTransaction) unhold(r);
+    const n = e.j;
+    if (!e.P && n.l & CONFIG_HELD && txOf(n) !== flushTransaction) unhold(n);
     if (laneStageHook && e.P !== null && e.j !== null) laneStageHook(e.j, e.P, true, false);
 }
 
@@ -131,25 +143,29 @@ function redraw(e) {
 
 /** `catchHook` (scheduler.ts): status from a frame reader, nearest boundary first.
  * A loading boundary on the way records a pending reader whether or not it
- * catches it (its `on` may collect it later). */ function catchStatus(e, r, n) {
-    if (r === 0) {
+ * catches it (its `on` may collect it later). */ function catchStatus(e, n, r) {
+    if (n === 0) {
         // A status cleared. Judged by the node's status now, against each
-        // boundary's own rule (`unsettled`) — the error path clears pending
+        // boundary's own rule (`prune`'s mask) — the error path clears pending
         // first and the node is still errored then. The last reader a fallback
         // waited on settling re-derives the output now, in the same heap (a
         // 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 r = boundaryOf(e); r; r = r._parent) if (!(e.m & unsettled(r)) && r.F.delete(e) && r.F.size === 0) {
-            if (r.L) redraw(r);
-            if (revealHooks && r.v !== null) revealHooks.V(r.v);
+        // on screen changes, the fallback stays as it is. `node` here is an
+        // effect reporting its own status. An error boundary records an effect
+        // only while it is errored, and a staged error keeps STATUS_ERROR on a
+        // node that had it (`stageError`), so `prune`'s CONFIG_STAGED_ERROR case
+        // cannot reach this path (#4364).
+        if (collecting.size !== 0) for (let n = boundaryOf(e); n; n = n._parent) if (!(n.F.get(e)?.m & (n.i | STATUS_PENDING)) && n.F.delete(e) && n.F.size === 0) {
+            if (n.L) redraw(n);
+            if (revealHooks && n.v !== null) revealHooks.V(n.v);
         }
         return false;
     }
     for (let o = boundaryOf(e); o; o = o._parent) {
-        if (!(o.i & r)) continue;
+        if (!(o.i & n)) continue;
         if (isCollecting(o)) {
-            caught(o, e, n);
+            caught(o, e, r);
             return o.h ? CAUGHT_REARMED : true;
         }
         record(o, e);
@@ -159,12 +175,12 @@ function redraw(e) {
 
 /** The nearest loading boundary that would catch `node` was re-armed this
  * flush. */ function armedOver(e) {
-    for (let r = boundaryOf(e); r; r = r._parent) if (r.i & STATUS_PENDING && isCollecting(r)) return r.h;
+    for (let n = boundaryOf(e); n; n = n._parent) if (n.i & STATUS_PENDING && isCollecting(n)) return n.h;
 }
 
 /** The nearest boundary on `r`'s chain showing its fallback, if any
  * (`hiddenHook`: `r` is behind a fallback). */ function hiddenBy(e) {
-    for (let r = boundaryOf(e); r; r = r._parent) if (r.L) return r;
+    for (let n = boundaryOf(e); n; n = n._parent) if (n.L) return n;
     return undefined;
 }
 
@@ -179,9 +195,9 @@ function redraw(e) {
  * synchronous on creation and never comes here. The run's `_modified` stays
  * set; the reveal re-queues it by type (`release`), and a boundary above
  * still showing its fallback holds it again then. */ function heldRun(e) {
-    const r = hiddenBy(e);
-    if (r === undefined) return false;
-    (r.M ??= new Set).add(e);
+    const n = hiddenBy(e);
+    if (n === undefined) return false;
+    (n.M ??= new Set).add(e);
     return true;
 }
 
@@ -189,9 +205,9 @@ function redraw(e) {
  * its own phase — render updates with the frame that attaches the content,
  * user effects after it. */ function release(e) {
     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.Z : r.W ??= GlobalQueue.K.bind(null, r));
+    for (const n of e.M) {
+        const e = n.i;
+        globalQueue.enqueue(e === EFFECT_TRACKED ? EFFECT_USER : e, e === EFFECT_TRACKED ? n.Z : n.W ??= GlobalQueue.q.bind(null, n));
     }
     e.M = null;
 }
@@ -201,13 +217,21 @@ 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;
-
-function prune(e, r) {
-    const n = unsettled(e);
-    for (const o of e.F) {
-        if (o.R & REACTIVE_DISPOSED) e.F.delete(o); else if (!(o.m & n)) {
-            if ((o !== e.Y || e.h) && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) {
+ * landing). The statuses that keep a reader: pending — and its error, for an
+ * error boundary (`_type` is the status it catches) — on the reader or its
+ * source. A reader pending again after the source that threw answered (it
+ * re-asks through a memo that carried the error) has no new answer yet: the
+ * error stays the display (D-39: a pending is not a value; async-gen 91501
+ * #1831). */ function prune(e, n) {
+    const r = e.i | STATUS_PENDING;
+    for (const [o, t] of e.F) {
+        if (!((o.R | t.R) & REACTIVE_DISPOSED)) {
+            // An error staged on its source (D-41, `stageError`) is not settled:
+            // it publishes with the commit. A reader that threw it now (a lane
+            // pass, a reader of a node born staged) reached the boundary first
+            // (#4364).
+            if ((o.m | t.m) & r || r & STATUS_ERROR && t.l & CONFIG_STAGED_ERROR) continue;
+            if ((t !== e.K || e.h) && (t.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
@@ -215,11 +239,11 @@ function prune(e, r) {
                 // 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 (!r || !e.D) continue;
-                joinFuture(txOf(o));
+                if (!n || !e.D) continue;
+                joinFuture(txOf(t));
             }
-            e.F.delete(o);
         }
+        e.F.delete(o);
     }
     return e.F.size;
 }
@@ -227,23 +251,28 @@ function prune(e, r) {
 /** 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.D || !(e.Y.m & STATUS_PENDING) && !(e.Y.l & CONFIG_HELD && (e.j === null || e.j.m & STATUS_UNINITIALIZED)) && prune(e, false) === 0;
+    return e.D || !(e.K.m & STATUS_PENDING) && !(e.K.l & CONFIG_HELD && (e.j === null || e.j.m & STATUS_UNINITIALIZED)) && prune(e, false) === 0;
 }
 
 /** `boundarySeamHook` (scheduler.ts), 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 r = e.j.R;
-        if (r & REACTIVE_DISPOSED) {
+        const n = e.j.R;
+        if (n & REACTIVE_DISPOSED) {
             collecting.delete(e);
             continue;
         }
         // A parked frame's boundary (zombie) keeps its state for its revival.
-                if (r & REACTIVE_ZOMBIE) continue;
+                if (n & REACTIVE_ZOMBIE) continue;
         prune(e, false);
-        const n = e.j;
-        if (e.h && !e.D && n.l & CONFIG_HELD && [ ...e.F ].every(e => !(e.m & STATUS_PENDING) && e.l & CONFIG_HELD && txOf(e) === txOf(n))) {
+        const r = e.j;
+        // A fallback staged into the very hold its readers landed in folds back
+        // (D-16, U-9): the content is ready when that hold commits (D-15). Not
+        // only at the re-arm's own seam: readers pending then land, held, a
+        // flush later (#4379 — the staged fallback otherwise commits with the
+        // hold, and a quiet refresh then caught keeps it up, F-9).
+                if (!e.D && r.l & CONFIG_HELD && [ ...e.F ].every(([, e]) => !(e.m & STATUS_PENDING) && e.l & CONFIG_HELD && txOf(e) === txOf(r))) {
             e.F.clear();
             e.D = true;
         }
@@ -284,22 +313,25 @@ function prune(e, r) {
     // 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 r = passLane;
-    if (r === null && globalQueue.q && getOwner().l & CONFIG_VERDICT) {
+        let n = passLane;
+    if (n === null && globalQueue.Y && getOwner().l & CONFIG_VERDICT) {
         joinFuture(null);
-        r = GlobalQueue.J(flushTransaction);
+        n = GlobalQueue.J(flushTransaction);
     }
-    e.B = r;
+    e.B = n;
     collecting.add(e);
-    const n = e.F.size;
-    heldUnder(e.H, flushTransaction, r => record(e, r));
-    for (const r of e.F) {
-        if (e.F.size !== n || r.m & STATUS_PENDING && !(r.R & REACTIVE_DISPOSED)) {
+    const r = e.F.size;
+    heldUnder(e.H, flushTransaction, n => record(e, n));
+    for (const [n] of e.F) {
+        if (e.F.size !== r || n.m & STATUS_PENDING && !(n.R & REACTIVE_DISPOSED)) {
             // What it collects was forwarded through it to the boundaries above
             // too (`catchStatus` records a reader in every boundary on the way).
             // It is this boundary's alone now (B5, the nearest catcher): an outer
             // re-armed by the same tick does not wait for it (D-14, U-4).
-            for (let r = e._parent; r !== null; r = r._parent) for (const n of e.F) r.F.delete(n);
+            for (let n = e._parent; n !== null; n = n._parent) 
+            // An outer error boundary keys its readers too, but waits on their
+            // sources: a re-armed Loading taking the pending does not settle it.
+            if (n.i & STATUS_PENDING) for (const [r] of e.F) n.F.delete(r);
             flip(e);
             redraw(e);
             return;
@@ -310,19 +342,33 @@ function prune(e, r) {
 /** 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 r of [ ...e.F ]) if (r.X !== undefined && !(r.R & REACTIVE_DISPOSED)) recompute(r);
+    for (const n of new Set(e.F.values())) if (n.X !== undefined && !(n.R & REACTIVE_DISPOSED)) recompute(n);
     schedule();
 }
 
-function createBoundary(e, r, n, o) {
+/**
+ * Dev CHECK: the `on` dependencies evaluated to a function — `<Loading
+ * on={route}>` or `on={() => route()}` passes the accessor itself, a stable
+ * value that is never called, so nothing is read and the boundary never
+ * re-arms. Checked on the first run only: the shape is static.
+ */ function reportOnAccessor(e) {
+    reportDiagnostic(emitDiagnostic({
+        code: "LOADING_ON_ACCESSOR",
+        kind: "async",
+        severity: "warn",
+        message: "[LOADING_ON_ACCESSOR] A Loading boundary's `on` received a function. `on` takes the " + "dependency's value — `on={route()}`, or `on={[query(), page()]}` for several — and an " + "accessor passed instead is never called, so nothing is read and the boundary never re-arms."
+    }, e.H));
+}
+
+function createBoundary(e, n, r, o) {
     const t = createOwner();
     const l = {
         i: e,
         _parent: boundaryOf(t) ?? null,
         H: t,
-        Y: null,
+        K: null,
         j: null,
-        F: new Set,
+        F: new Map,
         D: false,
         h: false,
         B: null,
@@ -333,13 +379,13 @@ function createBoundary(e, r, n, o) {
         $: false,
         ee: false,
         U: e === STATUS_ERROR ? signal(undefined, ERROR_SIGNAL) : null,
-        re: n,
-        ne: null
+        ne: r,
+        re: null
     };
-    const u = e === STATUS_PENDING ? t.A[REVEAL] : null;
+    const a = e === STATUS_PENDING ? t.A[REVEAL] : null;
     if (getOwner()) cleanup(() => {
         collecting.delete(l);
-        if (revealHooks && u) revealHooks.oe(u, l);
+        if (revealHooks && a) revealHooks.oe(a, 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.
@@ -350,7 +396,8 @@ function createBoundary(e, r, n, o) {
         let e = false;
         runWithOwner(t, () => computed(() => {
             try {
-                o();
+                const n = o();
+                if (false && !e && typeof n === "function") ;
             } catch (e) {
                 if (!(e instanceof NotReadyError)) {
                     if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
@@ -363,32 +410,32 @@ function createBoundary(e, r, n, o) {
             if (e) arm(l); else e = true;
         })).l |= CONFIG_REDERIVE;
     }
-    const a = {
+    const u = {
         ...t.A,
         [BOUNDARY]: l
     };
-    if (revealHooks !== null) a[REVEAL] = null;
-    t.A = a;
+    if (revealHooks !== null) u[REVEAL] = null;
+    t.A = u;
     const i = runWithOwner(t, () => {
-        const e = false ? computed(r, {
+        const e = false ? computed(n, {
             name: "children"
-        }) : computed(r);
+        }) : computed(n);
         return false ? computed(() => flatten(read(e)), {
             name: "boundary"
         }) : computed(() => flatten(read(e)));
     });
-    l.Y = i;
+    l.K = 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 (revealHooks && u) revealHooks.te(u, l);
-    const f = computed(() => {
+        if (revealHooks && a) revealHooks.te(a, l);
+    const s = 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;
+        const n = getOwner();
+        if (!l.h && !(n.l & CONFIG_HELD)) n.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
@@ -399,7 +446,7 @@ function createBoundary(e, r, n, o) {
             // 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, r);
+            link(i, n);
             if (revealHooks && l.v !== null) revealHooks.V(l.v);
             if (l.$) {
                 if (l.ee) {
@@ -416,10 +463,10 @@ function createBoundary(e, r, n, o) {
         // 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.m & (STATUS_PENDING | STATUS_ERROR);
-        if (n !== 0) {
-            link(i, r);
-            if (n & e) {
+                const r = i.m & (STATUS_PENDING | STATUS_ERROR);
+        if (r !== 0) {
+            link(i, n);
+            if (r & e) {
                 if (isCollecting(l)) {
                     caught(l, i, undefined);
                     return fallback(l);
@@ -444,7 +491,7 @@ function createBoundary(e, r, n, o) {
             // 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.
-            if (l.F.size !== 0 && r.m & STATUS_UNINITIALIZED && !(r.l & CONFIG_HELD)) return fallback(l);
+            if (l.F.size !== 0 && n.m & STATUS_UNINITIALIZED && !(n.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);
@@ -452,10 +499,10 @@ function createBoundary(e, r, n, o) {
         let o;
         try {
             o = read(i);
-        } catch (r) {
-            if (r instanceof NotReadyError ? e === STATUS_PENDING : e === STATUS_ERROR) {
+        } catch (n) {
+            if (n instanceof NotReadyError ? e === STATUS_PENDING : e === STATUS_ERROR) {
                 if (isCollecting(l)) {
-                    caught(l, i, r);
+                    caught(l, i, n);
                     return fallback(l);
                 }
                 // Forwarded: a loading boundary showing content keeps it and
@@ -463,7 +510,7 @@ function createBoundary(e, r, n, o) {
                                 record(l, i);
             }
             // A pending passes an error boundary by (A6).
-                        throw r;
+                        throw n;
         }
         // Readers under it still unready (caught before, or while the read
         // ran the content at a mount): the fallback.
@@ -479,15 +526,15 @@ function createBoundary(e, r, n, o) {
         // 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;
+                const t = l.re;
         const drop = () => {
-            if (!l.L && l.ne === t) {
+            if (!l.L && l.re === 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;
+                l.re = null;
             }
         };
         if (t !== null) l.j.le !== t.le ? drop() : globalQueue.enqueue(EFFECT_RENDER, drop);
@@ -505,22 +552,24 @@ function createBoundary(e, r, n, o) {
     // and legitimately swaps mid-hydration (resume), so it must never be
     // frozen by snapshot capture.
     {
-        ue: true
+        ae: true
     });
-    f.l |= CONFIG_REDERIVE;
+    s.l |= CONFIG_REDERIVE;
     // The tree is structure too (the output's pass marks the output).
         i.l |= CONFIG_FRAME;
-    l.j = f;
-    return accessor(f);
+    l.j = s;
+    return accessor(s);
 }
 
 function fallback(e) {
+    // (The output's pass.)
+    const n = getOwner();
     // 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.P !== null) {
+        if (e.P !== null) {
         setPassLane(e.P);
-        e.j.R |= REACTIVE_LANE_READ;
+        n.R |= REACTIVE_LANE_READ;
         e.P = null;
     }
     e.L = true;
@@ -535,18 +584,24 @@ function fallback(e) {
     // 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.ne === null) {
-        const r = getOwner();
-        e.ne = runWithOwner(r._parent, () => computed(() => e.re(e), {
-            id: r.id
-        }));
-    }
-    return read(e.ne);
+        if (e.re === null) e.re = runWithOwner(n._parent, () => computed(() => e.ne(e), {
+        id: n.id
+    }));
+    // The swap is structure (#3540): what the fallback reads ahead — a
+    // verdict (`latest()`), a lane — is the fallback's display-ahead, not the
+    // swap's: the output's pass stays where it was (F-6 stays inside the
+    // fallback, #4337).
+        const r = passLane;
+    const o = n.R;
+    const t = read(e.re);
+    setPassLane(r);
+    n.R ^= (n.R ^ o) & (REACTIVE_PROBED | REACTIVE_LANE_READ);
+    return t;
 }
 
 const ERROR_SIGNAL = {
     ownedWrite: true,
-    ue: true
+    ae: true
 };
 
 /**
@@ -590,8 +645,8 @@ const ERROR_SIGNAL = {
  *   ) as unknown as JSX.Element;
  * }
  * ```
- */ function createLoadingBoundary(e, r, n) {
-    return createBoundary(STATUS_PENDING, e, () => r(), n?.on);
+ */ function createLoadingBoundary(e, n, r) {
+    return createBoundary(STATUS_PENDING, e, () => n(), r?.on);
 }
 
 /**
@@ -616,12 +671,12 @@ const ERROR_SIGNAL = {
  *   ) as unknown as JSX.Element;
  * }
  * ```
- */ function createErrorBoundary(e, r) {
-    return createBoundary(STATUS_ERROR, e, e => r(accessor(e.U), () => reset(e)));
+ */ function createErrorBoundary(e, n) {
+    return createBoundary(STATUS_ERROR, e, e => n(accessor(e.U), () => 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.
-installBoundaryHooks(catchStatus, (e, r) => !r && (e.m & STATUS_UNINITIALIZED ? catchStatus(e, STATUS_PENDING) : armedOver(e)), hiddenBy, boundarySeam, heldRun);
+installBoundaryHooks(catchStatus, (e, n) => !n && (e.m & STATUS_UNINITIALIZED ? catchStatus(e, STATUS_PENDING) : armedOver(e)), hiddenBy, boundarySeam, heldRun);
 
 export { REVEAL, createErrorBoundary, createLoadingBoundary, prune, ready, redraw, revealHooks, setRevealHooks };