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

package/dist/prod/boundaries.js

@@ -1,379 +1,609 @@
-import { runWithOwner, signal, untrack, read, computed, setSignal, ext, recompute } from "./core/core.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 { NotReadyError, unwrapStatusError } from "./core/error.js";
+import { signal, runWithOwner, computed, read, setSignal, recompute } from "./core/core.js";
+
+import { reportDiagnostic, emitDiagnostic } from "./core/dev.js";
 
-import { createOwner, cleanup } from "./core/owner.js";
+import { NotReadyError, unwrapStatusError } from "./core/error.js";
 
-import { Queue, haltReactivity, schedule } from "./core/scheduler.js";
+import { reportClientError } from "./core/error-hooks.js";
 
-import { getContext, setContext, createContext } from "./core/context.js";
+import { link } from "./core/graph.js";
 
-import { STATUS_PENDING, STATUS_ERROR, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE } from "./core/constants.js";
+import { enqueueSub } from "./core/heap.js";
 
-import "./core/invariants.js";
+import { createOwner, getOwner, cleanup, dispose } from "./core/owner.js";
 
-import "./core/verdict.js";
+import { globalQueue, haltReactivityAt, haltReactivity, schedule, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, txOf, unhold, laneStageHook, installBoundaryHooks } from "./core/scheduler.js";
 
-import "./core/effect.js";
+import { flatten } from "./flatten.js";
 
 import { accessor } from "./signals.js";
 
-function boundaryComputed(e, t) {
-    const r = computed(e, {
-        lazy: true
-    });
-    ext(r).A = (e, t) => {
-        // Use passed values if provided, otherwise read from node
-        const n = e !== undefined ? e : r.S;
-        const s = t !== undefined ? t : r.o?._;
-        // Notify both status dimensions like a render effect does; the queue chain
-        // consumes this boundary's own type and forwards the remainder upward until
-        // a boundary that handles it is found.
-                r.S &= ~r.R;
-        const i = r.C.notify(r, STATUS_PENDING | STATUS_ERROR, n, s);
-        // The queue is the only propagation channel: a foreign status must not stay
-        // reader-visible on the tree, or reads re-throw it across the boundary and
-        // link unrelated ambient contexts (the #2809 nested-boundary loop). Deps are
-        // untouched, so the tree still recomputes when the foreign source settles.
-                const o = n & ~r.R & (STATUS_PENDING | STATUS_ERROR);
-        if (o) {
-            r.S &= ~o;
-            if (r.o?._ === s && !(r.S & (STATUS_PENDING | STATUS_ERROR))) if (r.o !== null) r.o._ = undefined;
-        }
-        // An ERROR the chain could not deliver to any boundary is uncaught. The
-        // scrub above already removed it from reader-visible state, so without
-        // escalation here it would vanish entirely (#2884) — halt-and-throw,
-        // exactly like an unhandled effect error.
-                if (!i && n & STATUS_ERROR) {
-            haltReactivity(unwrapStatusError(s));
-            throw s;
-        }
-    };
-    r.R = t;
-    r.T &= ~CONFIG_AUTO_DISPOSE;
-    recompute(r, true);
-    return r;
-}
+/**
+ * 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("");
 
-function createBoundChildren(e, t, r, n) {
-    const s = e.C;
-    s.addChild(e.C = r);
-    cleanup(() => s.removeChild(e.C));
-    return runWithOwner(e, () => {
-        const e = computed(t);
-        return boundaryComputed(() => flatten(read(e)), n);
-    });
-}
+/** 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("");
 
-const ON_INIT = 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;
 
-const RevealControllerContext = /* @__PURE__ */ createContext(null);
+function setRevealHooks(e) {
+    revealHooks = e;
+}
 
-let _revealUsed = false;
+/** Boundaries with readers to sweep (or an arm to resolve) at the seam. */ const collecting = new Set;
 
-const FALSE_ACCESSOR = () => false;
+const boundaryOf = e => e.A[BOUNDARY];
 
-const SEQUENTIAL_ACCESSOR = () => "sequential";
+/** 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;
 
-function isRevealController(e) {
-    return e instanceof RevealController;
+/** 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);
 }
 
-function isSlotReady(e) {
-    return isRevealController(e) ? e.O() : e.v.size === 0 && !e.N;
+/** 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.V(e.v);
 }
 
-function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.U() : isSlotReady(e);
+/** 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.P = e.B;
+    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);
 }
 
-function setSlotState(e, t, r, n) {
-    setSignal(e.I, r);
-    setSignal(e.D, n);
-    if (isRevealController(e)) {
-        if (!r && e.P === t) e.P = undefined;
-        return e.B(r, n);
+function redraw(e) {
+    if (e.j !== null && !(e.j.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        enqueueSub(e.j);
+        schedule();
     }
-    if (!r && e.W === t && e.L) e.W = undefined;
 }
 
-class RevealController {
-    F;
-    q;
-    V=[];
-    P;
-    I=signal(false, {
-        ownedWrite: true,
-        H: true
-    });
-    D=signal(false, {
-        ownedWrite: true,
-        H: true
-    });
-    J=true;
-    K=true;
-    X=false;
-    constructor(e, t) {
-        this.F = e;
-        this.q = t;
+/** `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.V(n.v);
+        }
+        return false;
     }
-    Y(e) {
-        for (let t = 0; t < this.V.length; t++) {
-            const r = this.V[t];
-            if ((isRevealController(r) ? r.P : r.W) !== this) continue;
-            if (e(r) === false) 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;
         }
-        return 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));
     }
-    O() {
-        return this.Y(isSlotReady);
+    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);
     }
-    /**
-     * "Minimally ready" = this group has something visible to show under its own policy.
-     * Used by an enclosing `together` group to decide when it can release.
-     * - `together`: every direct slot is minimally ready.
-     * - `sequential`: the first owned slot is minimally ready (frontier can advance).
-     * - `natural`: any owned slot is minimally ready.
-     */    U() {
-        const e = untrack(this.F);
-        if (e === "together") return this.Y(isSlotMinimallyReady);
-        if (e === "natural") {
-            let e = false;
-            let t = false;
-            this.Y(r => {
-                e = true;
-                if (isSlotMinimallyReady(r)) {
-                    t = true;
-                    return false;
-                }
-            });
-            return !e || t;
+    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.V(e.v);
         }
-        // sequential: only the first owned slot matters.
-                let t = true;
-        this.Y(e => {
-            t = isSlotMinimallyReady(e);
-            return false;
-        });
-        return t;
     }
-    Z(e) {
-        if (this.V.includes(e)) return;
-        this.V.push(e);
-        const t = untrack(this.F);
-        setSignal(e.I, true), setSignal(e.D, t === "sequential" ? !!untrack(this.q) : false);
-        untrack(() => this.B());
+}
+
+/** `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.P === 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) {
-        const t = this.V.indexOf(e);
-        if (t >= 0) this.V.splice(t, 1);
-        untrack(() => this.B());
+    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);
     }
-    B(e, t) {
-        if (this.X) return;
-        this.X = true;
-        const r = this.J;
-        const n = this.K;
-        try {
-            const r = e ?? read(this.I), n = untrack(this.F), s = n === "sequential" && !!untrack(this.q), i = t ?? s;
-            if (r) {
-                // Held by an outer group. Propagate the hold (and whatever collapsed policy
-                // the outer asked for) down the whole subtree. Inner order is ignored while
-                // held; it resumes once the outer releases us.
-                this.Y(e => setSlotState(e, this, true, i));
-            } else if (n === "natural") {
-                // Each child reveals based on its own readiness. A nested controller slot
-                // is released to run its own order locally — we bypass setSlotState for it
-                // so the parent backpointer survives for upward readiness notifications.
-                this.Y(e => {
-                    if (isRevealController(e)) {
-                        setSignal(e.D, false);
-                        setSignal(e.I, false);
-                        e.B(false, false);
-                    } else {
-                        setSlotState(e, this, !isSlotReady(e), false);
-                    }
-                });
-            } else if (n === "together") {
-                // Release when every direct slot is minimally ready (has something to show
-                // under its own order). A fully-ready inner together is minimally ready;
-                // sequential's first slot being ready is minimally ready; natural having any
-                // ready child is minimally ready. This lets `together` guarantee a single
-                // cohesive reveal without waiting for every grandchild.
-                const e = this.Y(isSlotMinimallyReady);
-                this.Y(t => setSlotState(t, this, !e, false));
-            } else {
-                let e = false;
-                this.Y(t => {
-                    if (e) return setSlotState(t, this, true, s);
-                    if (isSlotReady(t)) return setSlotState(t, this, false, false);
-                    e = true;
-                    // Frontier slot. For a leaf, holding `_disabled=true` is what keeps its
-                    // fallback visible. For a composite, we instead release it so it runs
-                    // its own order locally — its leaves will each show their own fallback
-                    // until their data lands. Outer still waits on full readiness before
-                    // advancing past this slot, and we bypass setSlotState so the parent
-                    // backpointer survives for upward readiness notifications.
-                                        if (isRevealController(t)) {
-                        setSignal(t.D, false);
-                        setSignal(t.I, false);
-                        t.B(false, false);
-                    } else {
-                        setSlotState(t, this, true, false);
-                    }
-                });
-            }
-        } finally {
-            this.J = this.O();
-            this.K = this.U();
-            this.X = false;
+    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;
         }
-        if (this.P && (r !== this.J || n !== this.K)) this.P.B();
     }
 }
 
-class CollectionQueue extends Queue {
-    ee;
-    v=new Set;
-    te;
-    N=true;
-    I=signal(false, {
-        ownedWrite: true,
-        H: true
-    });
-    _;
-    D=signal(false, {
-        ownedWrite: true,
-        H: true
+/** 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,
+        P: 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);
     });
-    W;
-    L=false;
-    re;
-    ne=ON_INIT;
-    constructor(e) {
-        super();
-        this.ee = e;
-    }
-    run(e) {
-        if (!e || read(this.I) && (!_revealUsed || read(this.D))) return;
-        return super.run(e);
+    // 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;
     }
-    notify(e, t, r, n) {
-        if (!(t & this.ee)) return super.notify(e, t, r, n);
-        if (this.L && this.re) {
-            const e = untrack(() => {
-                try {
-                    return this.re();
-                } catch {
-                    return ON_INIT;
+    const u = {
+        ...t.A,
+        [BOUNDARY]: l
+    };
+    if (revealHooks !== null) u[REVEAL] = null;
+    t.A = u;
+    const i = runWithOwner(t, () => {
+        const e = false ? computed(n, {
+            name: "children"
+        }) : computed(n);
+        return false ? computed(() => flatten(read(e)), {
+            name: "boundary"
+        }) : computed(() => flatten(read(e)));
+    });
+    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 && 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 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(i, n);
+            if (revealHooks && l.v !== null) revealHooks.V(l.v);
+            if (l.$) {
+                if (l.ee) {
+                    l.L = true;
+                    return undefined;
                 }
-            });
-            if (e !== this.ne) {
-                this.ne = e;
-                this.L = false;
-                this.v.clear();
+                return fallback(l);
             }
         }
-        // Routing is dimension-independent: each boundary consumes only its own
-        // status dimension from the mask (`type &= ~collectionType` below) and
-        // forwards the remainder up the queue chain. An error inside a `Loading`
-        // needs no special rule — the ERROR dimension survives consumption here and
-        // reaches the `Errored` that catches it natively, and `flags & collectionType`
-        // keeps this boundary from collecting a node that isn't actually pending.
-        // Symmetrically, a pending inside an `Errored` forwards on the PENDING
-        // dimension, while a status already caught by an inner boundary arrives with
-        // its dimension consumed from the mask and is correctly not re-routed
-        // (the Loading > Errored > content composition escape, #2856).
-                if (this.ee & STATUS_PENDING && this.L) return super.notify(e, t, r, n);
-        if (r & this.ee) {
-            this.N = true;
-            const t = n?.source || e.o?._?.source;
-            if (t) {
-                const e = this.v.size === 0;
-                this.v.add(t);
-                if (e) setSignal(this.I, true);
-                if (this.ee & STATUS_ERROR) {
-                    setSignal(this._, unwrapStatusError(t.o?._));
+        // 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 = 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);
                 }
+                // Forwarded: a loading boundary showing content keeps it and
+                // holds the frame like any reader (recorded for its `on`).
+                                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.T.U;
         }
-        t &= ~this.ee;
-        return t ? super.notify(e, t, r, n) : true;
-    }
-    se() {
-        for (const e of this.v) {
-            // A source with a live affects() mark holds display state for the
-            // mark's lifetime (the visual channel): the marked node carries no
-            // status of its own, so the count is the liveness test. The release
-            // sweep (finalizePureQueue after mark release) re-runs this check.
-            if (e.ie & REACTIVE_DISPOSED || !e.o?.t && !(e.S & this.ee) && !(this.ee & STATUS_ERROR && e.S & STATUS_PENDING)) this.v.delete(e);
+        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);
         }
-        if (!this.v.size) {
-            if (this.ee & STATUS_PENDING && this.N && !this.L && this.te) {
-                this.N = !!(this.te.S & this.ee);
-            } else {
-                this.N = false;
-            }
-            if (!this.N) {
-                setSignal(this.I, false);
-                if (this.re) {
-                    try {
-                        this.ne = untrack(() => this.re());
-                    } catch {
-                        /* value not yet committed — _prevOn stays stale, next notify will reset */}
+        let o;
+        try {
+            o = read(i);
+        } catch (n) {
+            if (n instanceof NotReadyError ? e === STATUS_PENDING : e === STATUS_ERROR) {
+                if (isCollecting(l)) {
+                    caught(l, i, 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, i);
             }
+            // A pending passes an error boundary by (A6).
+                        throw n;
         }
-        if (_revealUsed) this.W?.B();
-    }
-}
-
-function createCollectionBoundary(e, t, r, n) {
-    const s = createOwner();
-    if (_revealUsed) setContext(RevealControllerContext, null, s);
-    const i = new CollectionQueue(e);
-    if (e === STATUS_ERROR) i._ = signal(undefined, {
-        ownedWrite: true,
-        H: true
-    });
-    if (n) i.re = n;
-    const o = i.te = createBoundChildren(s, t, i, e);
-    // Prime source tracking so reveal registration sees pending sources.
-        untrack(() => {
-        let t = false;
-        try {
-            read(o);
-        } catch (e) {
-            if (e instanceof NotReadyError) t = true; else throw e;
-        }
-        i.N = t || !!(o.S & e) || o.o?._ instanceof NotReadyError;
-    });
-    const l = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
-    if (l) {
-        i.W = l;
-        l.Z(i);
-        cleanup(() => l.$(i));
-    }
-    return accessor(computed(() => {
-        if (!read(i.I)) {
-            const e = read(o);
-            if (!untrack(() => read(i.I))) return i.L = true, e;
+        // 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;
+        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.V(e);
         }
-        // Collapsed reveal slots suppress their own output entirely; the
-        // renderer treats the hole as empty, so the cast never leaks to users
-        // outside a `createRevealOrder` scope.
-                if (_revealUsed && read(i.D)) return undefined;
-        return r(i);
+        return o;
     }, 
-    // Boundary structure, not a user source: its value is fallback-or-content and
-    // legitimately swaps mid-hydration (reveal/resume), so it must never be frozen
-    // by snapshot capture. The tree no longer carries foreign status flags, so
-    // capture can't rely on PENDING to skip this node the way it used to.
+    // 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.
     {
-        H: true
+        ae: true
+    });
+    s.l |= CONFIG_REDERIVE;
+    // The tree is structure too (the output's pass marks the output).
+        i.l |= CONFIG_FRAME;
+    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) {
+        setPassLane(e.P);
+        n.R |= REACTIVE_LANE_READ;
+        e.P = null;
+    }
+    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.
@@ -383,8 +613,27 @@ function createCollectionBoundary(e, t, r, n) {
  *
  * @param fn the tracked subtree
  * @param fallback the fallback shown while async reads in `fn` are unresolved
- * @param options `on` — accessor whose value scopes the boundary; when set,
- *   transitions caused by writes to other reactive sources are *not* caught
+ * @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
@@ -396,8 +645,8 @@ function createCollectionBoundary(e, t, r, n) {
  *   ) as unknown as JSX.Element;
  * }
  * ```
- */ function createLoadingBoundary(e, t, r) {
-    return createCollectionBoundary(STATUS_PENDING, e, () => t(), r?.on);
+ */ function createLoadingBoundary(e, n, r) {
+    return createBoundary(STATUS_PENDING, e, () => n(), r?.on);
 }
 
 /**
@@ -422,151 +671,12 @@ function createCollectionBoundary(e, t, r, n) {
  *   ) as unknown as JSX.Element;
  * }
  * ```
- */ function createErrorBoundary(e, t) {
-    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e._), () => {
-        for (const t of e.v) recompute(t);
-        schedule();
-    }));
-}
-
-/**
- * Coordinate the reveal timing of sibling loading boundaries.
- *
- * Accepts reactive accessors:
- * - `order`: `"sequential"` (default) | `"together"` | `"natural"`.
- *   - `"sequential"` — classic frontier reveal: siblings reveal in registration order
- *     as each resolves; later siblings stay hidden until earlier ones complete.
- *   - `"together"` — every direct slot stays on its fallback until the whole group
- *     is "minimally ready" (each direct slot has produced its own first visible
- *     content under its own order), then the whole group releases at once.
- *   - `"natural"` — children reveal independently (as each resolves). At the top
- *     level this is a no-op compared to not using `createRevealOrder`; the mode
- *     exists for nesting, where the group registers as a single composite slot to
- *     any enclosing `createRevealOrder`.
- * - `collapsed`: only meaningful when `order === "sequential"`. When set, tail siblings
- *   past the frontier suppress their own fallback output. Ignored under `"together"`
- *   and `"natural"` — those orders have no frontier.
- *
- * Nested `createRevealOrder` groups compose: the inner controller registers as a
- * single slot in the outer controller and is held on its fallbacks until the outer
- * releases that slot. Once released, the inner controller runs its own order locally
- * over anything still pending. There is no opt-out from an outer hold.
- *
- * "Minimally ready" is what an order considers its first visible content:
- * - `sequential` — frontier-0 is minimally ready (leaf: on resolve; nested: via its
- *   own minimal signal).
- * - `together` — every direct slot is minimally ready.
- * - `natural` — any direct slot has visible content (leaves on resolve; nested
- *   composites via their own minimal signal).
- *
- * @example
- * ```ts
- * // Primitive form of `<Reveal>` — coordinate sibling loading boundaries
- * // programmatically. App code uses the JSX `<Reveal>` component instead.
- * // Both options are accessors so they can react to state changes.
- * createRevealOrder(
- *   () => renderSiblings(),
- *   { order: () => mode(), collapsed: () => true }
- * );
- * ```
- */ function createRevealOrder(e, t) {
-    _revealUsed = true;
-    const r = createOwner();
-    const n = getContext(RevealControllerContext);
-    const s = t?.order || SEQUENTIAL_ACCESSOR, i = t?.collapsed || FALSE_ACCESSOR;
-    const o = new RevealController(s, i);
-    setContext(RevealControllerContext, o, r);
-    return runWithOwner(r, () => {
-        const t = e();
-        computed(() => {
-            s();
-            i();
-            o.B();
-        });
-        if (n) {
-            o.P = n;
-            n.Z(o);
-            cleanup(() => n.$(o));
-        }
-        return t;
-    });
-}
-
-/**
- * Resolves a children value to its renderable form: unwraps zero-arg functions
- * (accessors), recursively flattens arrays, and optionally skips
- * non-rendering values (`null`, `undefined`, `true`, `false`, `""`).
- *
- * Used internally by flow components and by the renderer to walk a children
- * tree. App code rarely needs this directly — see `children()` in `solid-js`
- * for the user-facing helper that memoizes the result.
- *
- * @param children value or array of values to flatten
- * @param options
- *   - `skipNonRendered` — drop values that won't render
- *   - `doNotUnwrap` — leave function children as-is (caller will resolve)
- *
- * @example
- * ```ts
- * // Custom renderer walking a children tree manually. Most authors should
- * // use `children()` from solid-js, which memoizes the resolved value.
- * function renderChildren(value: unknown): unknown {
- *   return flatten(value, { skipNonRendered: true });
- * }
- * ```
- */ function flatten(e, t) {
-    if (typeof e === "function" && !e.length) {
-        if (t?.doNotUnwrap) return e;
-        do {
-            e = e();
-        } while (typeof e === "function" && !e.length);
-    }
-    if (t?.skipNonRendered && (e == null || e === true || e === false || e === "")) return;
-    if (Array.isArray(e)) {
-        let r = [];
-        if (flattenArray(e, r, t)) {
-            return () => {
-                let e = [];
-                flattenArray(r, e, {
-                    ...t,
-                    doNotUnwrap: false
-                });
-                return e;
-            };
-        }
-        return r;
-    }
-    return e;
+ */ function createErrorBoundary(e, n) {
+    return createBoundary(STATUS_ERROR, e, e => n(accessor(e.U), () => reset(e)));
 }
 
-function flattenArray(e, t = [], r) {
-    let n = null;
-    let s = false;
-    for (let i = 0; i < e.length; i++) {
-        try {
-            let n = e[i];
-            if (typeof n === "function" && !n.length) {
-                if (r?.doNotUnwrap) {
-                    t.push(n);
-                    s = true;
-                    continue;
-                }
-                do {
-                    n = n();
-                } while (typeof n === "function" && !n.length);
-            }
-            if (Array.isArray(n)) {
-                s = flattenArray(n, t, r);
-            } else if (r?.skipNonRendered && (n == null || n === true || n === false || n === "")) {
-                // skip
-            } else t.push(n);
-        } catch (e) {
-            if (!(e instanceof NotReadyError)) throw e;
-            n = e;
-        }
-    }
-    if (n) throw n;
-    return s;
-}
+// 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 { CollectionQueue, RevealController, createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten };
+export { REVEAL, createErrorBoundary, createLoadingBoundary, prune, ready, redraw, revealHooks, setRevealHooks };