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

package/dist/observe/boundaries.js

@@ -1,4 +1,4 @@
-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 { STATUS_PENDING, STATUS_ERROR, CONFIG_REDERIVE, STATUS_UNINITIALIZED, CONFIG_HELD, EFFECT_RENDER, CONFIG_VERDICT, REACTIVE_DISPOSED, REACTIVE_LANE_READ, CONFIG_OVERRIDE, EFFECT_USER, EFFECT_TRACKED, REACTIVE_ZOMBIE, CAUGHT_REARMED } from "./core/constants.js";
 
 import { signal, runWithOwner, computed, read, setSignal, recompute } from "./core/core.js";
 
@@ -14,7 +14,7 @@ import { enqueueSub } from "./core/heap.js";
 
 import { createOwner, getOwner, cleanup, dispose } from "./core/owner.js";
 
-import { globalQueue, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, schedule, setPassLane, passTx, resolveTx, txOf } from "./core/scheduler.js";
+import { globalQueue, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, passTx, resolveTx, schedule, txOf, unhold, laneStageHook, installBoundaryHooks } from "./core/scheduler.js";
 
 import { attrHooks } from "./core/attribution-hooks.js";
 
@@ -44,7 +44,7 @@ import { accessor } from "./signals.js";
  * the root holds the frame as for any reader. The tree's own status takes
  * the same route from the output's pass (`read(tree)` throws it).
  *
- * The hold (`blocked`, scheduler.ts) asks `hidden`: a reader behind a
+ * The hold (`blocked`, scheduler.ts) asks `hiddenBy`: a reader behind a
  * fallback — any boundary on its chain whose last pass chose the fallback —
  * is not on screen and holds nothing. An error boundary flipping to its
  * fallback is the same as a loading one resetting: every reader under it
@@ -77,34 +77,38 @@ function setRevealHooks(e) {
 
 /** Boundaries with readers to sweep (or an arm to resolve) at the seam. */ const collecting = new Set;
 
-const boundaryOf = e => e.D[BOUNDARY];
+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.u === STATUS_ERROR || !e.h || e.U;
+ * 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.U.add(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, n, r) {
-    if (e.u === STATUS_ERROR) {
+ * decides). */ function caught(e, r, 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.
-        r ??= n.m?.F;
-        n = r?.source ?? n;
-        const t = unwrapStatusError(r);
+        n ??= r.T?.F;
+        r = n?.source ?? r;
+        const t = unwrapStatusError(n);
         setSignal(e.F, t);
-        reportClientError(t, e.L, n);
+        reportClientError(t, e.H, r);
     }
-    e.v.add(n);
-    collecting.add(e);
-    if (e.U) flip(e);
+    record(e, r);
+    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
     // error reaches it through the `error` accessor, which is why it is one.
-        if (!e.H) redraw(e);
-    if (e.V !== null) revealHooks.P(e.V);
+        if (!e.L) redraw(e);
+    if (e.v !== null) revealHooks.P(e.v);
 }
 
 /** A re-armed boundary found something pending: fresh again, and the swap
@@ -112,22 +116,24 @@ const boundaryOf = e => e.D[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.h = false;
-    e.B = e.j;
-    if (e.B !== null && e.Z !== null) GlobalQueue.W(e.Z, e.B, true, false);
+    e.D = false;
+    e.V = e.B;
+    const r = e.j;
+    if (!e.V && r.l & CONFIG_HELD && txOf(r) !== flushTransaction) unhold(r);
+    if (e.V !== null && e.j !== null) laneStageHook(e.j, e.V, true, false);
 }
 
 function redraw(e) {
-    if (e.Z !== null && !(e.Z.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
-        enqueueSub(e.Z);
+    if (e.j !== null && !(e.j.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        enqueueSub(e.j);
         schedule();
     }
 }
 
-/** GlobalQueue._catch: status from a frame reader, nearest boundary first.
+/** `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, n, r) {
-    if (n === 0) {
+ * catches it (its `on` may collect it later). */ function catchStatus(e, r, n) {
+    if (r === 0) {
         // A status cleared. Judged by the node's status now, against each
         // boundary's own rule (`unsettled`) — the error path clears pending
         // first and the node is still errored then. The last reader a fallback
@@ -135,34 +141,35 @@ 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.S & unsettled(n)) && n.v.delete(e) && n.v.size === 0) {
-            if (n.H) redraw(n);
-            if (n.V !== null) revealHooks.P(n.V);
+        if (collecting.size !== 0) for (let r = boundaryOf(e); r; r = r._parent) if (!(e.m & unsettled(r)) && r.U.delete(e) && r.U.size === 0) {
+            if (r.L) redraw(r);
+            if (r.v !== null) revealHooks.P(r.v);
         }
         return false;
     }
-    for (let t = boundaryOf(e); t !== undefined; t = t._parent ?? undefined) {
-        if (!(t.u & n)) continue;
+    for (let t = boundaryOf(e); t; t = t._parent) {
+        if (!(t.i & r)) continue;
         if (isCollecting(t)) {
-            caught(t, e, r);
-            return true;
+            caught(t, e, n);
+            return t.h ? CAUGHT_REARMED : true;
         }
-        t.v.add(e);
-        collecting.add(t);
+        record(t, e);
     }
     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.H) return n;
-    return undefined;
+/** 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;
 }
 
-/** GlobalQueue._hidden: behind a fallback. */ function hidden(e) {
-    return hiddenBy(e) !== undefined;
+/** 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;
+    return undefined;
 }
 
-/** GlobalQueue._heldRun: a queued run behind a fallback waits for the reveal
+/** `heldRunHook` (scheduler.ts): a queued run behind a fallback waits for the reveal
  * (maintainer, 2026-10-02: the queue is held, the synchronous first render
  * goes through). A user effect's, which would read a DOM that is not
  * attached ("many depend on reading the DOM, something that can't happen
@@ -173,21 +180,21 @@ 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 n = hiddenBy(e);
-    if (n === undefined) return false;
-    (n.K ??= new Set).add(e);
+    const r = hiddenBy(e);
+    if (r === undefined) return false;
+    (r.Z ??= 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.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));
+    if (e.Z === null) return;
+    for (const r of e.Z) {
+        const e = r.i;
+        globalQueue.enqueue(e === EFFECT_TRACKED ? EFFECT_USER : e, e === EFFECT_TRACKED ? r.M : r.W ??= GlobalQueue.K.bind(null, r));
     }
-    e.K = null;
+    e.Z = null;
 }
 
 /** Drop the readers that settled or died. Settled: a loading reader no
@@ -195,13 +202,13 @@ 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.u === STATUS_ERROR ? STATUS_ERROR | STATUS_PENDING : STATUS_PENDING;
+ * landing). */ const unsettled = e => e.i === STATUS_ERROR ? STATUS_ERROR | STATUS_PENDING : STATUS_PENDING;
 
-function prune(e, n) {
-    const r = unsettled(e);
-    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) {
+function prune(e, r) {
+    const n = unsettled(e);
+    for (const t of e.U) {
+        if (t.R & REACTIVE_DISPOSED) e.U.delete(t); else if (!(t.m & n)) {
+            if ((t !== e.Y || e.h) && (t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) {
                 // 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
@@ -209,61 +216,58 @@ function prune(e, n) {
                 // 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;
+                if (!r || !e.D) continue;
                 joinFuture(txOf(t));
             }
-            e.v.delete(t);
+            e.U.delete(t);
         }
     }
-    return e.v.size;
+    return e.U.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.h || !(e.J.S & STATUS_PENDING) && !(e.J.i & CONFIG_HELD && (e.Z === null || e.Z.S & STATUS_UNINITIALIZED)) && prune(e, false) === 0;
+    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;
 }
 
-/** GlobalQueue._boundarySeam, end of the seam: readers that settled, died,
+/** `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 n = e.Z.R;
-        if (n & REACTIVE_DISPOSED) {
+        const r = e.j.R;
+        if (r & REACTIVE_DISPOSED) {
             collecting.delete(e);
             continue;
         }
         // A parked frame's boundary (zombie) keeps its state for its revival.
-                if (n & REACTIVE_ZOMBIE) continue;
+                if (r & REACTIVE_ZOMBIE) continue;
         prune(e, false);
-        e.U = false;
-        if (e.v.size === 0) {
+        const n = e.j;
+        if (e.h && !e.D && n.l & CONFIG_HELD && [ ...e.U ].every(e => !(e.m & STATUS_PENDING) && e.l & CONFIG_HELD && txOf(e) === txOf(n))) {
+            e.U.clear();
+            e.D = true;
+        }
+        e.h = false;
+        if (e.U.size === 0) {
             collecting.delete(e);
-            if (e.H) redraw(e);
-            if (e.V !== null) revealHooks.P(e.V);
+            if (e.L) redraw(e);
+            if (e.v !== null) revealHooks.P(e.v);
         }
     }
 }
 
-/** 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.i & CONFIG_VERDICT) return true;
-    for (let n = e.G; 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.h) {
+    if (!e.D) {
         // 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.H && e.B === null && e.j === null && passLane !== null) {
-            e.j = passLane;
+        if (e.L && e.V === null && e.B === null && passLane !== null) {
+            e.B = 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
@@ -273,20 +277,28 @@ function prune(e, n) {
         }
         return;
     }
-    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
+    e.h = true;
+    // A verdict read in `on` (`isPending`, or a memo of one — #3528's
+    // `createMemo(() => isPending(m2))`: the mark carries, core.ts `read`)
+    // whose frame has no transaction yet: the swap is still display-ahead — the frame gets one now (it lands
     // 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.X && verdictDerived(getOwner())) {
+        let r = passLane;
+    if (r === null && globalQueue.q && getOwner().l & CONFIG_VERDICT) {
         joinFuture(null);
-        n = GlobalQueue.$(flushTransaction);
+        r = GlobalQueue.J(flushTransaction);
     }
-    e.j = n;
+    e.B = r;
     collecting.add(e);
-    for (const n of e.v) {
-        if (n.S & STATUS_PENDING && !(n.R & REACTIVE_DISPOSED)) {
+    const n = e.U.size;
+    heldUnder(e.H, flushTransaction, r => record(e, r));
+    for (const r of e.U) {
+        if (e.U.size !== n || r.m & STATUS_PENDING && !(r.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.U) r.U.delete(n);
             flip(e);
             redraw(e);
             return;
@@ -297,36 +309,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.v ]) if (n.ee !== undefined && !(n.R & REACTIVE_DISPOSED)) recompute(n);
+    for (const r of [ ...e.U ]) if (r.X !== undefined && !(r.R & REACTIVE_DISPOSED)) recompute(r);
     schedule();
 }
 
-function createBoundary(e, n, r, t) {
-    const l = createOwner();
-    const o = {
-        u: e,
-        _parent: boundaryOf(l) ?? null,
-        L: l,
-        J: null,
-        Z: null,
-        v: new Set,
-        h: false,
-        U: false,
+function createBoundary(e, r, n, t) {
+    const o = createOwner();
+    const l = {
+        i: e,
+        _parent: boundaryOf(o) ?? null,
+        H: o,
+        Y: null,
         j: null,
+        U: new Set,
+        D: false,
+        h: false,
         B: null,
-        H: false,
-        K: null,
         V: null,
-        ne: false,
-        re: false,
+        L: false,
+        Z: null,
+        v: null,
+        $: false,
+        ee: false,
         F: e === STATUS_ERROR ? signal(undefined, ERROR_SIGNAL) : null,
-        te: r,
-        le: null
+        re: n,
+        ne: null
     };
-    const u = e === STATUS_PENDING ? l.D[REVEAL] : null;
+    const u = e === STATUS_PENDING ? o.A[REVEAL] : null;
     if (getOwner()) cleanup(() => {
-        collecting.delete(o);
-        if (u) revealHooks.oe(u, o);
+        collecting.delete(l);
+        if (u) revealHooks.te(u, l);
     });
     // The `on` dependencies live OUTSIDE the boundary, as the condition of a
     // `<Show>` wrapping it would: created before the owner's context names it.
@@ -335,7 +347,7 @@ function createBoundary(e, n, r, t) {
     // does not suspend the parent — and re-arms.
         if (t) {
         let e = false;
-        runWithOwner(l, () => computed(() => {
+        runWithOwner(o, () => computed(() => {
             try {
                 t();
             } catch (e) {
@@ -347,46 +359,46 @@ function createBoundary(e, n, r, t) {
                     return;
                 }
             }
-            if (e) arm(o); else e = true;
-        })).i |= CONFIG_REDERIVE;
+            if (e) arm(l); else e = true;
+        })).l |= CONFIG_REDERIVE;
     }
     const a = {
-        ...l.D,
-        [BOUNDARY]: o
+        ...o.A,
+        [BOUNDARY]: l
     };
     if (revealHooks !== null) a[REVEAL] = null;
-    l.D = a;
-    const i = runWithOwner(l, () => {
-        const e = true ? computed(n, {
+    o.A = a;
+    const i = runWithOwner(o, () => {
+        const e = true ? computed(r, {
             name: "children"
-        }) : computed(n);
+        }) : computed(r);
         return true ? computed(() => flatten(read(e)), {
             name: "boundary"
         }) : computed(() => flatten(read(e)));
     });
-    o.J = i;
+    l.Y = 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.ue(u, o);
-    const f = computed(() => {
+        if (u) revealHooks.oe(u, l);
+    const s = 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.ne) {
+        if (l.$) {
             // Linked without being read: the tree settling (or changing)
             // re-derives this pass, which is how the controller hears of it.
             // It may release this very slot (the frontier whose content just
             // settled): the pass goes on to show it — the redraw it asks for is
             // refused mid-pass and not needed.
             link(i, getOwner());
-            if (o.V !== null) revealHooks.P(o.V);
-            if (o.ne) {
-                if (o.re) {
-                    o.H = true;
+            if (l.v !== null) revealHooks.P(l.v);
+            if (l.$) {
+                if (l.ee) {
+                    l.L = true;
                     return undefined;
                 }
-                return fallback(o);
+                return fallback(l);
             }
         }
         // A tree carrying a status is not read: an errored memo's reactive
@@ -396,24 +408,23 @@ 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.S & (STATUS_PENDING | STATUS_ERROR);
-        if (n !== 0) {
+                const r = i.m & (STATUS_PENDING | STATUS_ERROR);
+        if (r !== 0) {
             link(i, getOwner());
-            if (n & e) {
-                if (isCollecting(o)) {
-                    caught(o, i, undefined);
-                    return fallback(o);
+            if (r & e) {
+                if (isCollecting(l)) {
+                    caught(l, i, undefined);
+                    return fallback(l);
                 }
                 // Forwarded: a loading boundary showing content keeps it and
                 // holds the frame like any reader (recorded for its `on`).
-                                o.v.add(i);
-                collecting.add(o);
+                                record(l, i);
             }
             // A pending passes an error boundary by (A6); an error, a loading
             // one; a loading boundary showing content forwards its pending.
-                        throw i.m.F;
+                        throw i.T.F;
         }
-        if (isCollecting(o)) {
+        if (isCollecting(l)) {
             // A29's boundary exemption (#3540): a boundary MOUNTED over a held
             // value (its first pass; a first pass under it that read a hold was
             // collected, `joinPass` — the tree's own, or a render effect's that
@@ -426,89 +437,88 @@ 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.v.size !== 0 && e.S & STATUS_UNINITIALIZED && !(e.i & CONFIG_HELD)) return fallback(o);
+            if (l.U.size !== 0 && e.m & STATUS_UNINITIALIZED && !(e.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(o, true) !== 0) return fallback(o);
+                        if (prune(l, true) !== 0) return fallback(l);
         }
-        let r;
+        let n;
         try {
-            r = read(i);
-        } catch (n) {
-            if (n instanceof NotReadyError ? e === STATUS_PENDING : e === STATUS_ERROR) {
-                if (isCollecting(o)) {
-                    caught(o, i, n);
-                    return fallback(o);
+            n = read(i);
+        } catch (r) {
+            if (r instanceof NotReadyError ? e === STATUS_PENDING : e === STATUS_ERROR) {
+                if (isCollecting(l)) {
+                    caught(l, i, r);
+                    return fallback(l);
                 }
                 // Forwarded: a loading boundary showing content keeps it and
                 // holds the frame like any reader (recorded for its `on`).
-                                o.v.add(i);
-                collecting.add(o);
+                                record(l, i);
             }
             // A pending passes an error boundary by (A6).
-                        throw n;
+                        throw r;
         }
         // Readers under it still unready (caught before, or while the read
         // ran the content at a mount): the fallback.
-                if (isCollecting(o) && o.v.size !== 0) return fallback(o);
-        o.h = true;
+                if (isCollecting(l) && l.U.size !== 0) return fallback(l);
+        l.D = true;
         // Observe: the fallback stops showing (a hide before its commit means
         // it never displayed — the engine knows the swap it was staged with).
-                if (o.H && o.u & STATUS_PENDING && attrHooks !== null) attrHooks.boundaryFallback(o, o.J, false);
-        o.H = false;
+                if (l.L && l.i & STATUS_PENDING && attrHooks !== null) attrHooks.boundaryFallback(l, l.Y, false);
+        l.L = 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;
+                const t = l.ne;
         if (t !== null) globalQueue.enqueue(EFFECT_RENDER, () => {
-            if (!o.H && o.le === t) {
+            if (!l.L && l.ne === t) {
                 dispose(t);
-                o.le = null;
+                l.ne = null;
             }
         });
-        release(o);
+        release(l);
         // Shown: the slot leaves its reveal order (a later re-arm gates nobody
         // else; the frontier moves on).
-                if (o.V !== null) {
-            const e = o.V;
-            o.V = null;
+                if (l.v !== null) {
+            const e = l.v;
+            l.v = null;
             revealHooks.P(e);
         }
-        return r;
+        return n;
     }, 
     // Boundary structure, not a user source: its value is fallback-or-content
     // and legitimately swaps mid-hydration (resume), so it must never be
     // frozen by snapshot capture.
     {
         name: "value",
-        ae: true
+        le: true
     });
-    f.i |= CONFIG_REDERIVE;
-    o.Z = f;
-    return accessor(f);
+    s.l |= CONFIG_REDERIVE;
+    l.j = s;
+    return accessor(s);
 }
 
 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.B !== null) {
-        setPassLane(e.B);
-        e.Z.R |= REACTIVE_LANE_READ;
-        e.B = null;
+    if (e.V !== null) {
+        setPassLane(e.V);
+        e.j.R |= REACTIVE_LANE_READ;
+        e.V = null;
     }
     // Observe: a loading boundary starts showing its fallback — the swap lands
     // with the frame's transaction, or this drain commits it (lane work, or no
     // transaction). A mount's synchronous first show has no drain of its own:
     // one is scheduled so the engine's display instant (`flushEnd`) comes.
-        if (!e.H && e.u & STATUS_PENDING && attrHooks !== null) {
-        attrHooks.boundaryFallback(e, e.J, true, passLane !== null ? null : flushTransaction !== null ? resolveTx(flushTransaction) : passTx);
-        if (!globalQueue.X) schedule();
+        if (!e.L && e.i & STATUS_PENDING && attrHooks !== null) {
+        attrHooks.boundaryFallback(e, e.Y, true, passLane !== null ? null : flushTransaction !== null ? resolveTx(flushTransaction) : passTx);
+        if (!globalQueue.q) schedule();
     }
-    e.H = true;
+    e.L = 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
@@ -520,18 +530,18 @@ 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.le === null) {
-        const n = getOwner();
-        e.le = runWithOwner(n._parent, () => computed(() => e.te(e), {
-            id: n.id
+        if (e.ne === null) {
+        const r = getOwner();
+        e.ne = runWithOwner(r._parent, () => computed(() => e.re(e), {
+            id: r.id
         }));
     }
-    return read(e.le);
+    return read(e.ne);
 }
 
 const ERROR_SIGNAL = {
     ownedWrite: true,
-    ae: true
+    le: true
 };
 
 /**
@@ -575,8 +585,8 @@ const ERROR_SIGNAL = {
  *   ) as unknown as JSX.Element;
  * }
  * ```
- */ function createLoadingBoundary(e, n, r) {
-    return createBoundary(STATUS_PENDING, e, () => n(), r?.on);
+ */ function createLoadingBoundary(e, r, n) {
+    return createBoundary(STATUS_PENDING, e, () => r(), n?.on);
 }
 
 /**
@@ -601,20 +611,12 @@ const ERROR_SIGNAL = {
  *   ) as unknown as JSX.Element;
  * }
  * ```
- */ function createErrorBoundary(e, n) {
-    return createBoundary(STATUS_ERROR, e, e => n(accessor(e.F), () => reset(e)));
+ */ function createErrorBoundary(e, r) {
+    return createBoundary(STATUS_ERROR, e, e => r(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.ie = catchStatus;
-
-GlobalQueue.fe = e => e.S & STATUS_UNINITIALIZED && catchStatus(e, STATUS_PENDING);
-
-GlobalQueue.se = hidden;
-
-GlobalQueue.ce = boundarySeam;
-
-GlobalQueue.Ee = heldRun;
+installBoundaryHooks(catchStatus, (e, r) => !r && (e.m & STATUS_UNINITIALIZED ? catchStatus(e, STATUS_PENDING) : armedOver(e)), hiddenBy, boundarySeam, heldRun);
 
 export { REVEAL, createErrorBoundary, createLoadingBoundary, prune, ready, redraw, revealHooks, setRevealHooks };