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

package/dist/observe/boundaries.js

@@ -0,0 +1,696 @@
+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";
+
+import { link } from "./core/graph.js";
+
+import { enqueueSub } from "./core/heap.js";
+
+import { createOwner, getOwner, cleanup, dispose } from "./core/owner.js";
+
+import { globalQueue, haltReactivityAt, haltReactivity, schedule, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, passTx, resolveTx, txOf, unhold, laneStageHook, installBoundaryHooks } from "./core/scheduler.js";
+
+import { attrHooks } from "./core/attribution-hooks.js";
+
+import { flatten } from "./flatten.js";
+
+import { accessor } from "./signals.js";
+
+/**
+ * Boundaries — the display consumers between a frame reader and the root:
+ * `createLoadingBoundary` (`<Loading>`) and `createErrorBoundary`
+ * (`<Errored>`).
+ *
+ * A boundary is an owner whose context names it (`BOUNDARY`), so every node
+ * created under it finds it in O(1) and the enclosing boundaries through
+ * `_parent`; a `tree` (the content, flattened) and an `output` that shows
+ * the tree or the fallback. The output is a frame reader (CONFIG_REDERIVE):
+ * status reaching it from its content re-derives it instead of marking it,
+ * and its pass decides.
+ *
+ * Status protocol (B5). A frame reader under a boundary that goes pending or
+ * errors tells `GlobalQueue.notify`, which asks `catchStatus` before the
+ * root: the nearest boundary of that status that is collecting — an error
+ * boundary always; a loading boundary that has not shown content yet, or
+ * whose `on` just changed — records the reader and shows its fallback, and
+ * the root never hears of it (no transaction is opened: A33, a fallback-
+ * caught flight holds nothing). A loading boundary showing content forwards:
+ * 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 `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
+ * stops counting, and a flight whose only visible reader that was loses its
+ * hold (maintainer, 2026-10-01).
+ *
+ * Reveal. The seam (`boundarySeam`) drops readers that settled, died, or
+ * landed and committed; a fallback with none left re-derives its output,
+ * which reads the tree again. A reader that landed but is held (CONFIG_HELD,
+ * its value staged in a transaction) is not settled: the content reveals at
+ * the commit, with the rest of the frame (#3540).
+ *
+ * `on` (loading only): a tracked function whose reads re-arm the boundary.
+ * A pass of it after the mount arms the boundary for the flush: anything
+ * pending under it — already (its forwarded readers), or going pending later
+ * in the same heap — is collected and the fallback shows now, with the
+ * change's frame; nothing pending, and the arm is a no-op at the seam.
+ */
+/** Context key: the nearest boundary of a node, inherited at creation. */ const BOUNDARY = Symbol("");
+
+/** Context key: the reveal controller a Loading boundary created here is a
+ * slot of (reveal.ts); a boundary clears it for its content — only direct
+ * children are slots. */ const REVEAL = Symbol("");
+
+// Every call site checks the hooks themselves first (not only the slot or
+// controller, which are never set without them): a build that does not
+// import `createRevealOrder` folds the reveal-order arms away.
+let revealHooks = null;
+
+function setRevealHooks(e) {
+    revealHooks = e;
+}
+
+/** Boundaries with readers to sweep (or an arm to resolve) at the seam. */ const collecting = new Set;
+
+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, 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, 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, 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, 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
+    // error reaches it through the `error` accessor, which is why it is one.
+        if (!e.L) redraw(e);
+    if (revealHooks && e.v !== null) revealHooks.P(e.v);
+}
+
+/** A re-armed boundary found something pending: fresh again, and the swap
+ * the arming pass asked for is that pass's lane's (if any): the output is
+ * 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.D = false;
+    e.V = e.B;
+    const n = e.j;
+    if (!e.V && n.l & CONFIG_HELD && txOf(n) !== flushTransaction) unhold(n);
+    if (laneStageHook && e.V !== null && e.j !== null) laneStageHook(e.j, e.V, true, false);
+}
+
+function redraw(e) {
+    if (e.j !== null && !(e.j.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        enqueueSub(e.j);
+        schedule();
+    }
+}
+
+/** `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) {
+        // A status cleared. Judged by the node's status now, against each
+        // 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. `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.P(n.v);
+        }
+        return false;
+    }
+    for (let o = boundaryOf(e); o; o = o._parent) {
+        if (!(o.i & n)) continue;
+        if (isCollecting(o)) {
+            caught(o, e, r);
+            return o.h ? CAUGHT_REARMED : true;
+        }
+        record(o, e);
+    }
+    return false;
+}
+
+/** The nearest loading boundary that would catch `node` was re-armed this
+ * flush. */ function armedOver(e) {
+    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 n = boundaryOf(e); n; n = n._parent) if (n.L) return n;
+    return undefined;
+}
+
+/** `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
+ * off screen"); a render effect's update too — a Portal or a head-tag
+ * library writes outside the hidden subtree, and a queued render run is
+ * what mounts them. A user effect's first run is scheduled like every other,
+ * so a mount under a fallback defers it too; a render effect's first run is
+ * 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.M ??= 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.M === null) return;
+    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;
+}
+
+/** Drop the readers that settled or died. Settled: a loading reader no
+ * longer pending; an error's source neither errored nor in flight. A reader
+ * 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). 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
+                // 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.D) continue;
+                joinFuture(txOf(t));
+            }
+        }
+        e.F.delete(o);
+    }
+    return e.F.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.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 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 (n & REACTIVE_ZOMBIE) continue;
+        prune(e, false);
+        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;
+        }
+        e.h = false;
+        if (e.F.size === 0) {
+            collecting.delete(e);
+            if (e.L) redraw(e);
+            if (revealHooks && e.v !== null) revealHooks.P(e.v);
+        }
+    }
+}
+
+/** `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.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.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
+            // voided at the seam (verdict.ts `verdictSeam`).
+                        flip(e);
+            redraw(e);
+        }
+        return;
+    }
+    e.h = true;
+    // The swap is the change's work: the output joins it (D-13, #3540).
+        e.j.l &= ~CONFIG_FRAME;
+    // 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.Y && getOwner().l & CONFIG_VERDICT) {
+        joinFuture(null);
+        n = GlobalQueue.J(flushTransaction);
+    }
+    e.B = n;
+    collecting.add(e);
+    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 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;
+        }
+    }
+}
+
+/** 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 new Set(e.F.values())) if (n.X !== undefined && !(n.R & REACTIVE_DISPOSED)) recompute(n);
+    schedule();
+}
+
+/**
+ * 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,
+        K: null,
+        j: null,
+        F: new Map,
+        D: false,
+        h: false,
+        B: null,
+        V: null,
+        L: false,
+        M: null,
+        v: null,
+        $: false,
+        ee: false,
+        U: e === STATUS_ERROR ? signal(undefined, ERROR_SIGNAL) : null,
+        ne: r,
+        re: null
+    };
+    const a = e === STATUS_PENDING ? t.A[REVEAL] : null;
+    if (getOwner()) cleanup(() => {
+        collecting.delete(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.
+    // A source of it going pending re-runs it (CONFIG_REDERIVE) rather than
+    // marking it: the pass catches the NotReady — it is a notification, it
+    // does not suspend the parent — and re-arms.
+        if (o) {
+        let e = false;
+        runWithOwner(t, () => computed(() => {
+            try {
+                const n = o();
+                if (false && !e && typeof n === "function") ;
+            } catch (e) {
+                if (!(e instanceof NotReadyError)) {
+                    if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
+                        if (false) ; else haltReactivity(e);
+                        throw e;
+                    }
+                    return;
+                }
+            }
+            if (e) arm(l); else e = true;
+        })).l |= CONFIG_REDERIVE;
+    }
+    const u = {
+        ...t.A,
+        [BOUNDARY]: l
+    };
+    if (revealHooks !== null) u[REVEAL] = null;
+    t.A = u;
+    const s = runWithOwner(t, () => {
+        const e = true ? computed(n, {
+            name: "children"
+        }) : computed(n);
+        return true ? computed(() => flatten(read(e)), {
+            name: "boundary"
+        }) : computed(() => flatten(read(e)));
+    });
+    l.K = s;
+    // 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 && a) revealHooks.te(a, l);
+    const i = 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 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
+        // releases it in turn.
+                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(s, n);
+            if (revealHooks && l.v !== null) revealHooks.P(l.v);
+            if (l.$) {
+                if (l.ee) {
+                    l.L = true;
+                    return undefined;
+                }
+                return fallback(l);
+            }
+        }
+        // A tree carrying a status is not read: an errored memo's reactive
+        // re-read retries it (`read`), and neither a fallback re-rendering nor
+        // passing the error by may re-run the content; a pending one read as
+        // lane work would serve its committed value (A31) — the swap a
+        // 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 r = s.m & (STATUS_PENDING | STATUS_ERROR);
+        if (r !== 0) {
+            link(s, n);
+            if (r & e) {
+                if (isCollecting(l)) {
+                    caught(l, s, undefined);
+                    return fallback(l);
+                }
+                // Forwarded: a loading boundary showing content keeps it and
+                // holds the frame like any reader (recorded for its `on`).
+                                record(l, s);
+            }
+            // A pending passes an error boundary by (A6); an error, a loading
+            // one; a loading boundary showing content forwards its pending.
+                        throw s.T.U;
+        }
+        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
+            // binds the content) shows its fallback now and the content at the
+            // commit — entering the transaction would make the output itself
+            // born held, and nothing would show until the commit. The seam
+            // keeps a held reader until it is committed, then re-derives this
+            // pass. A boundary with a committed value reads a held tree and
+            // 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 && 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);
+        }
+        let o;
+        try {
+            o = read(s);
+        } catch (n) {
+            if (n instanceof NotReadyError ? e === STATUS_PENDING : e === STATUS_ERROR) {
+                if (isCollecting(l)) {
+                    caught(l, s, n);
+                    return fallback(l);
+                }
+                // Forwarded: a loading boundary showing content keeps it and
+                // holds the frame like any reader (recorded for its `on`).
+                                record(l, s);
+            }
+            // A pending passes an error boundary by (A6).
+                        throw n;
+        }
+        // Readers under it still unready (caught before, or while the read
+        // ran the content at a mount): the fallback.
+                if (isCollecting(l) && l.F.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 (l.L && l.i & STATUS_PENDING && attrHooks !== null) attrHooks.boundaryFallback(l, l.K, 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. A fallback
+        // 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.re;
+        const drop = () => {
+            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.re = null;
+            }
+        };
+        if (t !== null) l.j.le !== t.le ? drop() : globalQueue.enqueue(EFFECT_RENDER, drop);
+        release(l);
+        // Shown: the slot leaves its reveal order (a later re-arm gates nobody
+        // else; the frontier moves on).
+                if (revealHooks && l.v !== null) {
+            const e = l.v;
+            l.v = null;
+            revealHooks.P(e);
+        }
+        return o;
+    }, 
+    // 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
+    });
+    i.l |= CONFIG_REDERIVE;
+    // The tree is structure too (the output's pass marks the output).
+        s.l |= CONFIG_FRAME;
+    l.j = i;
+    return accessor(i);
+}
+
+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.V !== null) {
+        setPassLane(e.V);
+        n.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.L && e.i & STATUS_PENDING && attrHooks !== null) {
+        attrHooks.boundaryFallback(e, e.K, true, passLane !== null ? null : flushTransaction !== null ? resolveTx(flushTransaction) : passTx);
+        if (!globalQueue.Y) schedule();
+    }
+    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
+    // 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.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,
+    ae: true
+};
+
+/**
+ * Lower-level primitive that backs the `<Loading>` flow control. Catches
+ * pending async reads inside `fn` and renders `fallback` until they settle.
+ *
+ * App code should use `<Loading fallback={...}>` instead — reach for this only
+ * when authoring custom boundary components.
+ *
+ * @param fn the tracked subtree
+ * @param fallback the fallback shown while async reads in `fn` are unresolved
+ * @param options `on` — a dependency list: a tracked function whose reads
+ *   re-arm the boundary. Its return value is irrelevant (never compared);
+ *   what matters is what it reads. Without `on`, a boundary that has shown
+ *   content keeps it through a refetch (the pending holds with the
+ *   transaction). With `on`, a write to anything it reads makes the boundary
+ *   fresh again: it stops waiting on its current content, and if something
+ *   under it is pending it shows `fallback` until the new content is ready;
+ *   if nothing is pending, the notification is a no-op. The fallback lands
+ *   with the same frame as the change that caused it — now, when nothing
+ *   else holds that frame; together with the rest of the new page during a
+ *   held navigation, not before it. If the same data is also read outside
+ *   the boundary, the frame waits on it and the fallback can never be seen
+ *   (DEV warns `LOADING_ON_OUTSIDE_HOLD`); the fix is structural — move the
+ *   outside read under the boundary so one hold owns the data. A frame held
+ *   past the content's landing by something else (the write's action, other
+ *   pending data) also shows no fallback; that is a race the fallback may
+ *   lose, a legitimate outcome, and not reported. A display-ahead read in
+ *   `on` (`latest()`) shows the fallback now, beside the held frame; that
+ *   is a capability, not the recommended shape. Optimistic writes and a
+ *   source going pending notify like any other. The children are not
+ *   re-created — they stay alive behind the fallback.
+ *
+ * @example
+ * ```tsx
+ * // Custom boundary component built on top of the primitive.
+ * function MyLoading(props: { fallback: JSX.Element; children: JSX.Element }) {
+ *   return createLoadingBoundary(
+ *     () => props.children,
+ *     () => props.fallback
+ *   ) as unknown as JSX.Element;
+ * }
+ * ```
+ */ function createLoadingBoundary(e, n, r) {
+    return createBoundary(STATUS_PENDING, e, () => n(), r?.on);
+}
+
+/**
+ * Lower-level primitive that backs the `<Errored>` flow control. Catches
+ * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
+ * `error` is an accessor for the latest captured error; `reset()` recomputes
+ * the failing sources so the boundary can attempt to recover.
+ *
+ * App code should use `<Errored fallback={...}>` instead — reach for this only
+ * when authoring custom boundary components.
+ *
+ * @example
+ * ```tsx
+ * // Custom boundary that wraps the primitive and adds telemetry.
+ * function TracedErrored(props: { fallback: (e: () => unknown) => JSX.Element; children: JSX.Element }) {
+ *   return createErrorBoundary(
+ *     () => props.children,
+ *     (err, reset) => {
+ *       reportError(err());
+ *       return props.fallback(err);
+ *     }
+ *   ) as unknown as JSX.Element;
+ * }
+ * ```
+ */ 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, n) => !n && (e.m & STATUS_UNINITIALIZED ? catchStatus(e, STATUS_PENDING) : armedOver(e)), hiddenBy, boundarySeam, heldRun);
+
+export { REVEAL, createErrorBoundary, createLoadingBoundary, prune, ready, redraw, revealHooks, setRevealHooks };