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

package/dist/observe/boundaries.js

@@ -1,578 +1,505 @@
-import { runWithOwner, signal, spectate, computed, read, untrack, setSignal, notifyOnLane, recompute, currentOptimisticLane, ext } from "./core/core.js";
+import { STATUS_PENDING, STATUS_ERROR, CONFIG_REDERIVE, REACTIVE_DISPOSED, STATUS_UNINITIALIZED, CONFIG_HELD, REACTIVE_ZOMBIE, CONFIG_VERDICT, REACTIVE_LANE_READ, CONFIG_OVERRIDE, EFFECT_USER, EFFECT_TRACKED } from "./core/constants.js";
 
-import { NotReadyError, unwrapStatusError } from "./core/error.js";
-
-import { createOwner, cleanup } from "./core/owner.js";
-
-import { Queue, transitions, reporterBlocksSource, wakeParked, activeTransition, schedule, queueRearm, haltReactivity } from "./core/scheduler.js";
+import { signal, runWithOwner, computed, read, setSignal, recompute } from "./core/core.js";
 
-import { getContext, setContext, createContext } from "./core/context.js";
-
-import { STATUS_PENDING, STATUS_ERROR, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, STATUS_UNINITIALIZED, NOT_PENDING, CONFIG_AUTO_DISPOSE } from "./core/constants.js";
+import "./core/dev.js";
 
-import { attrHooks } from "./core/attribution-hooks.js";
+import { NotReadyError, unwrapStatusError } from "./core/error.js";
 
-import "./core/invariants.js";
+import { reportClientError } from "./core/error-hooks.js";
 
-import "./core/dev.js";
+import { link } from "./core/graph.js";
 
 import { enqueueSub } from "./core/heap.js";
 
-import "./core/verdict.js";
+import { createOwner, getOwner, cleanup } from "./core/owner.js";
 
-import "./core/effect.js";
+import { globalQueue, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, schedule, setPassLane, passTx, resolveTx, txOf } from "./core/scheduler.js";
 
-import { reportClientError } from "./core/error-hooks.js";
+import { attrHooks } from "./core/attribution-hooks.js";
 
-import { accessor } from "./signals.js";
+import { flatten } from "./flatten.js";
 
-function boundaryComputed(e, t) {
-    const r = computed(e, {
-        name: "boundary",
-        lazy: true
-    });
-    ext(r).h = (e, t) => {
-        // Use passed values if provided, otherwise read from node
-        const n = e !== undefined ? e : r.S;
-        const i = 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 s = r.T.notify(r, STATUS_PENDING | STATUS_ERROR, n, i);
-        // 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?._ === i && !(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 (!s && n & STATUS_ERROR) {
-            haltReactivity(unwrapStatusError(i));
-            throw i;
-        }
-    };
-    r.R = t;
-    r.C &= ~CONFIG_AUTO_DISPOSE;
-    recompute(r, true);
-    return r;
-}
+import { accessor } from "./signals.js";
 
 /**
- * A boundary's `on` dependencies (#3540): `onFn` runs tracked, as a
- * computation whose value is discarded — what it READS is the point. Every
- * run after the first is a notification (a source it read was written, went
- * pending, or landed; an optimistic write notifies like any other) and
- * queues the boundary for re-arming once this pass's heap has run
- * (scheduler.ts `pendingRearms`: the re-arm needs what the notifying write
- * put in flight, which this pass — at the height of its reads — runs ahead
- * of). The value is never compared: a thunk that returns a fresh object per
- * run but reads nothing reactive never re-arms, and one that returns the
- * same constant re-arms whenever a read source changes. A zero-argument
- * function is an accessor, tracked like any other.
+ * Boundaries — the display consumers between a frame reader and the root:
+ * `createLoadingBoundary` (`<Loading>`) and `createErrorBoundary`
+ * (`<Errored>`).
  *
- * The pass's posture is the notification's. A plain pass derives from the
- * frame the write belongs to, and the re-arm follows that frame. A pass
- * under a lane read display-ahead state — `latest()` (its shadow is an
- * optimistic computed), an optimistic write — and the re-arm shows the
- * fallback through that lane (`_rearmLane`): now, beside whatever frame a
- * transaction still holds.
+ * 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.
  *
- * Created under `owner` while the owner's queue is still the parent's, so
- * the node belongs to the parent boundary, not to this one — as the
- * condition of a `<Show>` wrapping the boundary would. Two status rules set
- * it apart from a plain memo:
- * - Pending is not the parent's: a source of `on` that is not ready is a
- *   notification for this boundary (it re-arms: the fallback shows here, not
- *   in an outer boundary). Propagation marks the node without a pass, so the
- *   channel scrubs the mark and re-derives it; the pass reads the source
- *   (linking to its landing) and catches. The node never registers as a
- *   reporter: `on` reading a pending source holds no frame.
- * - An error IS the parent's, as a wrapping `<Show>` condition's would be:
- *   forwarded up the queue chain like a render effect's; uncaught, it halts
- *   (#2884).
- */ function onNode(e, t, r) {
-    let n = false;
-    const i = runWithOwner(e, () => computed(() => {
-        try {
-            r();
-        } catch (e) {
-            if (!(e instanceof NotReadyError)) throw e;
-        }
-        if (n) {
-            if (currentOptimisticLane !== null) t.N = currentOptimisticLane;
-            queueRearm(t);
-        } else n = true;
-    }, {
-        lazy: true
-    }));
-    ext(i).h = (e, t) => {
-        const r = e !== undefined ? e : i.S;
-        if (r & STATUS_PENDING) {
-            i.S &= ~STATUS_PENDING;
-            if (i.o?._ instanceof NotReadyError) i.o._ = undefined;
-            enqueueSub(i);
-            schedule();
-        }
-        if (r & STATUS_ERROR) {
-            const e = t !== undefined ? t : i.o?._;
-            i.S &= ~STATUS_ERROR;
-            if (i.o?._ === e && i.o !== null) i.o._ = undefined;
-            if (!i.T.notify(i, STATUS_ERROR, r, e)) {
-                haltReactivity(unwrapStatusError(e));
-                throw e;
-            }
-        }
-    };
-    i.C &= ~CONFIG_AUTO_DISPOSE;
-    recompute(i, true);
-    return i;
+ * 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 `hidden`: 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("");
+
+let revealHooks = null;
+
+function setRevealHooks(e) {
+    revealHooks = e;
 }
 
-function createBoundChildren(e, t, r, n) {
-    const i = e.T;
-    i.addChild(e.T = r);
-    cleanup(() => i.removeChild(e.T));
-    // Named for the observe tier's owner paths: user content under a boundary
-    // is owned by `children`, and the boundary's own two nodes read as
-    // structure rather than as anonymous `computed`s between `<Loading>` and
-    // the content (`<App> › <Loading> › children › <Feed>`).
-        return runWithOwner(e, () => {
-        // The call, not the argument, is gated: `computed(fn, void 0)` would keep
-        // a trailing argument in the prod artifact.
-        const e = true ? computed(t, {
-            name: "children"
-        }) : computed(t);
-        return boundaryComputed(() => flatten(read(e)), n);
-    });
+/** Boundaries with readers to sweep (or an arm to resolve) at the seam. */ const collecting = new Set;
+
+const boundaryOf = e => e.U[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.k || e.L;
+
+/** The reader goes to the fallback: recorded, and the output re-derives
+ * (a no-op while the output's own pass is running — its post-check
+ * decides). */ function caught(e, n, r) {
+    if (e.i === STATUS_ERROR) {
+        // An error boundary waits on what THREW (`StatusError.source`), not on
+        // the reader that saw it: the reader recovers the moment a refetch
+        // starts (its boundary catches the pending), while the error is settled
+        // only when its source is neither errored nor in flight. `reset` re-runs
+        // the same node.
+        r ??= n.m?.v;
+        n = r?.source ?? n;
+        const t = unwrapStatusError(r);
+        setSignal(e.v, t);
+        reportClientError(t, e.H, n);
+    }
+    e.V.add(n);
+    collecting.add(e);
+    if (e.L) flip(e);
+    // Already showing the fallback: one more reader to wait on changes
+    // nothing on screen. The fallback is instantiated once per show — a later
+    // error reaches it through the `error` accessor, which is why it is one.
+        if (!e.P) redraw(e);
+    if (e.B !== null) revealHooks.j(e.B);
 }
 
-const RevealControllerContext = /* @__PURE__ */ createContext(null);
-
-let _revealUsed = false;
+/** 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.k = false;
+    e.Z = e.W;
+    if (e.Z !== null && e.K !== null) GlobalQueue.M(e.K, e.Z, true, false);
+}
 
-const FALSE_ACCESSOR = () => false;
+function redraw(e) {
+    if (e.K !== null && !(e.K.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        enqueueSub(e.K);
+        schedule();
+    }
+}
 
-const SEQUENTIAL_ACCESSOR = () => "sequential";
+/** GlobalQueue._catch: 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 (`unsettled`) — the error path clears pending
+        // first and the node is still errored then. The last reader a fallback
+        // waited on settling re-derives the output now, in the same heap (a
+        // held reader's landing has joined its transaction, so the content
+        // lands with its run, not a round after). Others still waiting: nothing
+        // on screen changes, the fallback stays as it is.
+        if (collecting.size !== 0) for (let n = boundaryOf(e); n !== undefined; n = n._parent ?? undefined) if (!(e.G & unsettled(n)) && n.V.delete(e) && n.V.size === 0) {
+            if (n.P) redraw(n);
+            if (n.B !== null) revealHooks.j(n.B);
+        }
+        return false;
+    }
+    for (let t = boundaryOf(e); t !== undefined; t = t._parent ?? undefined) {
+        if (!(t.i & n)) continue;
+        if (isCollecting(t)) {
+            caught(t, e, r);
+            return true;
+        }
+        t.V.add(e);
+        collecting.add(t);
+    }
+    return false;
+}
 
-function isRevealController(e) {
-    return e instanceof RevealController;
+/** The nearest boundary on `r`'s chain showing its fallback, if any. */ function hiddenBy(e) {
+    for (let n = boundaryOf(e); n !== undefined; n = n._parent ?? undefined) if (n.P) return n;
+    return undefined;
 }
 
-function isSlotReady(e) {
-    return isRevealController(e) ? e.O() : e.I.size === 0 && !e.U;
+/** GlobalQueue._hidden: behind a fallback. */ function hidden(e) {
+    return hiddenBy(e) !== undefined;
 }
 
-function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.v() : isSlotReady(e);
+/** GlobalQueue._heldRun: 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.Y ??= new Set).add(e);
+    return true;
 }
 
-function setSlotState(e, t, r, n) {
-    setSignal(e.D, r);
-    setSignal(e.P, n);
-    if (isRevealController(e)) {
-        if (!r && e.L === t) e.L = undefined;
-        return e.B(r, n);
+/** The reveal: the runs held behind the fallback are this flush's, each in
+ * its own phase — render updates with the frame that attaches the content,
+ * user effects after it. */ function release(e) {
+    if (e.Y === null) return;
+    for (const n of e.Y) {
+        const e = n.i;
+        globalQueue.enqueue(e === EFFECT_TRACKED ? EFFECT_USER : e, e === EFFECT_TRACKED ? n.q : n.J ??= GlobalQueue.X.bind(null, n));
     }
-    if (!r && e.W === t && e.H) e.W = undefined;
+    e.Y = null;
 }
 
-class RevealController {
-    q;
-    V;
-    F=[];
-    L;
-    D=signal(false, {
-        ownedWrite: true,
-        Z: true
-    });
-    P=signal(false, {
-        ownedWrite: true,
-        Z: true
-    });
-    J=true;
-    K=true;
-    X=false;
-    constructor(e, t) {
-        this.q = e;
-        this.V = t;
-    }
-    Y(e) {
-        for (let t = 0; t < this.F.length; t++) {
-            const r = this.F[t];
-            if ((isRevealController(r) ? r.L : r.W) !== this) continue;
-            if (e(r) === false) return false;
+/** 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). */ 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.G & r)) {
+            if (t !== e.$ && (t.u & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) {
+                // Landed, held: the content is that transaction's — the output's
+                // pass enters it and the reveal lands with the reader's run. The
+                // seam, past its park decision, waits for the commit instead. (A
+                // lane's reader reveals with the lane, this round.)
+                if (!n) continue;
+                joinFuture(txOf(t));
+            }
+            e.V.delete(t);
         }
-        return true;
     }
-    O() {
-        return this.Y(isSlotReady);
-    }
-    /**
-     * "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.
-     */    v() {
-        const e = untrack(this.q);
-        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.V.size;
+}
+
+/** Reveal order: a slot is ready when its content can show — it has shown
+ * content, or nothing under it is unready (the tree neither pending nor
+ * born held, no reader waited on). */ function ready(e) {
+    return e.k || !(e.$.G & STATUS_PENDING) && !(e.$.u & CONFIG_HELD && (e.K === null || e.K.G & STATUS_UNINITIALIZED)) && prune(e, false) === 0;
+}
+
+/** GlobalQueue._boundarySeam, end of the seam: readers that settled, died,
+ * or landed and committed are dropped; a fallback with none left reveals
+ * next round. An arm resolves: nothing collected, nothing happened. */ function boundarySeam() {
+    for (const e of collecting) {
+        const n = e.K.R;
+        if (n & REACTIVE_DISPOSED) {
+            collecting.delete(e);
+            continue;
         }
-        // sequential: only the first owned slot matters.
-                let t = true;
-        this.Y(e => {
-            t = isSlotMinimallyReady(e);
-            return false;
-        });
-        return t;
-    }
-    $(e) {
-        if (this.F.includes(e)) return;
-        this.F.push(e);
-        const t = untrack(this.q);
-        setSignal(e.D, true), setSignal(e.P, t === "sequential" ? !!untrack(this.V) : false);
-        untrack(() => this.B());
-    }
-    ee(e) {
-        const t = this.F.indexOf(e);
-        if (t >= 0) this.F.splice(t, 1);
-        untrack(() => this.B());
-    }
-    B(e, t) {
-        if (this.X) return;
-        this.X = true;
-        const r = this.J;
-        const n = this.K;
-        try {
-            const r = e ?? read(this.D), n = untrack(this.q), i = n === "sequential" && !!untrack(this.V), s = t ?? i;
-            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, s));
-            } 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.P, false);
-                        setSignal(e.D, 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, i);
-                    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.P, false);
-                        setSignal(t.D, false);
-                        t.B(false, false);
-                    } else {
-                        setSlotState(t, this, true, false);
-                    }
-                });
-            }
-        } finally {
-            this.J = this.O();
-            this.K = this.v();
-            this.X = false;
+        // A parked frame's boundary (zombie) keeps its state for its revival.
+                if (n & REACTIVE_ZOMBIE) continue;
+        prune(e, false);
+        e.L = false;
+        if (e.V.size === 0) {
+            collecting.delete(e);
+            if (e.P) redraw(e);
+            if (e.B !== null) revealHooks.j(e.B);
         }
-        if (this.L && (r !== this.J || n !== this.K)) this.L.B();
     }
 }
 
-class CollectionQueue extends Queue {
-    te;
-    I=new Set;
-    re;
-    /** The output pass — fallback or content (createCollectionBoundary). */
-    ne;
-    U=true;
-    D=signal(false, {
-        ownedWrite: true,
-        Z: true
-    });
-    _;
-    P=signal(false, {
-        ownedWrite: true,
-        Z: true
-    });
-    W;
-    H=false;
-    /** The boundary's owner — where a `caught` report locates itself, set before the children are built (a creation-time throw arrives before `_tree`). */
-    ie;
-    /** The lane the `on` pass that queued this re-arm ran under (onNode), if
-     * any: the fallback swap is display-ahead — shown through the lane. */
-    N=null;
-    constructor(e) {
-        super();
-        this.te = e;
-    }
-    run(e) {
-        if (!e || read(this.D) && (!_revealUsed || read(this.P))) return;
-        return super.run(e);
-    }
-    /** An `on` dependency notified (onNode → scheduler `pendingRearms`);
-     * drained after the heap, before the verdict, under the notifying write's
-     * transaction (#3540). A boundary showing content is fresh again: it
-     * releases its hold now and, if anything under it is still pending, swaps
-     * to its fallback. The swap is staged, so it lands with the write's frame
-     * — at once when nothing else holds it, with the rest of the new page
-     * when something outside the boundary does; if the pending lands first,
-     * `_checkSources` clears it and no fallback is shown. An `on` that read a
-     * lane (`latest()`, an optimistic write) asked for the change now:
-     * `_rearmLane` shows the swap through the lane, beside the held frame.
-     * Children stay alive behind the fallback. */    se() {
-        const e = this.N;
-        this.N = null;
-        if (this.re === undefined || this.re.oe & REACTIVE_DISPOSED) return;
-        if (!this.H) return;
-        // Readers forwarded while this boundary showed content are what it
-        // would wait on now. They never re-notify (status propagation dedupes on
-        // the reader's `_pendingSources`), so the re-arm collects it from their
-        // registrations — the one place a forwarded reader is recorded (INV-3)
-        // — or a sibling reader's flight that lands first reveals them stale
-        // (A33, #3459). Before the verdict, a registration may have stopped
-        // counting without being pruned yet (its flight landed this pass):
-        // `reporterBlocksSource` is the verdict's own test.
-                const t = new Set;
-        for (const e of transitions) for (const [r, n] of e.ae) {
-            for (const e of n) if (this.le(e) && reporterBlocksSource(e, r)) {
-                t.add(r);
-                e.o?.ue?.forEach(e => t.add(e));
-            }
+/** The `on` pass is a verdict's: it probed itself (CONFIG_VERDICT), or it
+ * read a memo that did (#3528's `createMemo(() => isPending(m2))`) — its
+ * swap is display-ahead either way. */ function verdictDerived(e) {
+    if (e.u & CONFIG_VERDICT) return true;
+    for (let n = e._; n !== null; n = n.p) if (n.I.u & CONFIG_VERDICT) return true;
+    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.k) {
+        // Already re-armed and on its fallback, as the frame's work — and the
+        // `on` pass arms again as lane work: its verdict was provisional (a
+        // memo of `isPending(m2)` is a watcher until the flush parks, then the
+        // holder's verdict lane's — verdict.ts), and the swap it asked for is
+        // display-ahead after all (#3528). Re-home the swap: the output re-runs
+        // as the lane's, shown now beside the held frame.
+        if (e.P && e.Z === null && e.W === null && passLane !== null) {
+            e.W = passLane;
+            // 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);
         }
-        if (!t.size) return;
-        this.H = false;
-        this.I = t;
-        this.U = true;
-        this.fe(e);
-        // Those readers are behind the fallback now: they stop blocking
-        // (`reporterBlocksSource`), and the transactions they were holding must
-        // be re-judged for it (A33, #3375) — the active one by the verdict that
-        // follows this drain, parked ones by the wake. A live action keeps its
-        // transaction parked regardless (transitionComplete): its batch commits
-        // when it settles, intact.
-                wakeParked();
+        return;
     }
-    /** Show the fallback: the swap the output pass selects on. Staged, it is
-     * the frame's and lands with its commit. Re-armed from a lane pass
-     * (`lane`), it is the current frame's — committed outright, as the lane's
-     * view already is on screen — and shown through the lane: the output pass
-     * publishes a derived override and its readers run from the lane's queue,
-     * at the park, ahead of the transaction (a lane pass reads staged plain
-     * writes committed, so a staged swap would be invisible to it). */    fe(e) {
-        if (e === null) setSignal(this.D, true); else {
-            this.D.ce = true;
-            notifyOnLane(this.D, e);
-        }
-        // Observe: the staged swap is displayed when the transaction carrying
-        // this pass commits; the lane's readers run in this drain.
-                if (attrHooks !== null) attrHooks.boundaryFallback(this, this.re, true, e === null ? activeTransition : null);
+    e.L = true;
+    // A verdict read in `on` (`isPending`) whose frame has no transaction
+    // yet: the swap is still display-ahead — the frame gets one now (it lands
+    // at this very seam if nothing holds it), and the swap is its verdict
+    // lane's work, shown ahead of the frame's own runs (#3528).
+        let n = passLane;
+    if (n === null && globalQueue.ee && verdictDerived(getOwner())) {
+        joinFuture(null);
+        n = GlobalQueue.ne(flushTransaction);
     }
-    /** Retry the collected failures of an error boundary: recompute each
-     * source that threw, so the boundary can recover. */    he() {
-        for (const e of this.I) {
-            // Non-computed sources (patch-channel registrations under plain
-            // owners) are not recomputable — their reset is the record's next
-            // transition re-applying the patch (re-audit 2, P1-4).
-            if (e.Se !== undefined) recompute(e);
+    e.W = n;
+    collecting.add(e);
+    for (const n of e.V) {
+        if (n.G & STATUS_PENDING && !(n.R & REACTIVE_DISPOSED)) {
+            flip(e);
+            redraw(e);
+            return;
         }
-        schedule();
     }
-    notify(e, t, r, n) {
-        if (!(t & this.te)) return super.notify(e, t, r, n);
-        // 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.te & STATUS_PENDING && this.H) return super.notify(e, t, r, n);
-        if (r & this.te) {
-            this.U = true;
-            const t = n?.source || e.o?._?.source;
-            if (t) {
-                const r = this.I.size === 0;
-                this.I.add(t);
-                // A collecting boundary waits on everything the effect is pending on,
-                // not only the source this notification carries. Status propagation
-                // dedupes on the effect's `_pendingSources`: a source it already
-                // carries (a flight that started before an `on` reset cleared the
-                // set) is never re-reported, and that source's later re-flight
-                // stays invisible — the boundary revealed when its one collected
-                // source settled while the effect was still pending (#3375).
-                                if (this.te & STATUS_PENDING) e.o?.ue?.forEach(e => this.I.add(e));
-                if (r) {
-                    setSignal(this.D, true);
-                    if (attrHooks !== null && this.te & STATUS_PENDING) attrHooks.boundaryFallback(this, this.re, true, activeTransition);
-                }
-                if (this.te & STATUS_ERROR) {
-                    const e = unwrapStatusError(t.o?._);
-                    setSignal(this._, e);
-                    // The client error hook: this boundary renders its fallback for
-                    // it — the one road a rendered failure took that no global handler
-                    // ever saw. `source` is the computation that threw (the status
-                    // wrapper's, made at the first landing and kept downstream), so the
-                    // hook hears where it broke as well as where it was met. Once per
-                    // error object; a `reset()` re-collecting the same failure says
-                    // nothing new.
-                                        reportClientError(e, this.ie, t);
+}
+
+/** 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.re !== undefined && !(n.R & REACTIVE_DISPOSED)) recompute(n);
+    schedule();
+}
+
+function createBoundary(e, n, r, t) {
+    const o = createOwner();
+    const l = {
+        i: e,
+        _parent: boundaryOf(o) ?? null,
+        H: o,
+        $: null,
+        K: null,
+        V: new Set,
+        k: false,
+        L: false,
+        W: null,
+        Z: null,
+        P: false,
+        Y: null,
+        B: null,
+        te: false,
+        oe: false,
+        v: e === STATUS_ERROR ? signal(undefined, ERROR_SIGNAL) : null,
+        le: r
+    };
+    const u = e === STATUS_PENDING ? o.U[REVEAL] : null;
+    if (getOwner()) cleanup(() => {
+        collecting.delete(l);
+        if (u) revealHooks.ue(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.
+    // 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 (t) {
+        let e = false;
+        runWithOwner(o, () => computed(() => {
+            try {
+                t();
+            } catch (e) {
+                if (!(e instanceof NotReadyError)) {
+                    if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
+                        haltReactivity(e);
+                        throw e;
+                    }
+                    return;
                 }
             }
-        }
-        t &= ~this.te;
-        return t ? super.notify(e, t, r, n) : true;
+            if (e) arm(l); else e = true;
+        })).u |= CONFIG_REDERIVE;
     }
-    /** Is `reporter` live and routed to this boundary — under it, with no
-     * collecting pending-type boundary in between (`reporterBlocksSource`'s test)? */    le(e) {
-        if (e.oe & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-        for (let t = e.T; t; t = t._parent) {
-            if (t === this) return true;
-            if (t.te & STATUS_PENDING && !t.H) return false;
-        }
-        return false;
-    }
-    /** Has a collected source stopped counting for this boundary? 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. A source born held under this
-     * boundary (recompute, #3540) carries no status either: it is collected
-     * while it has a staged value and no committed one, and released by the
-     * commit that initializes it. */    de(e) {
-        return !!(e.oe & REACTIVE_DISPOSED || !e.o?.t && !(e.S & this.te) && !(this.te & STATUS_ERROR && e.S & STATUS_PENDING) && !(this.te & STATUS_PENDING && e.S & STATUS_UNINITIALIZED && e._e !== NOT_PENDING));
-    }
-    /** The pre-verdict sweep (scheduler run(), #3540): a collecting boundary
-     * whose OUTPUT is pending — its fallback read something not ready — is
-     * judged here, under the transaction. That output is what an initialized
-     * parent holds the frame on, and it derives from `_disabled`, not the
-     * tree: the tree settling never re-runs it, only a sweep does, and the
-     * commit sweep runs after the verdict the output's own read keeps parking
-     * — the content waited for the fallback's flight. Judged ready here, the
-     * boundary stages `_disabled` false with the frame and the output re-runs
-     * in this heap: it reads the tree and drops the fallback's read (recompute
-     * settles a pass's outgoing pending sources), so the verdict sees the
-     * release. A boundary showing a ready fallback parks nothing and keeps the
-     * commit sweep's reveal. */    Re() {
-        if (this.H || !(this.ne.S & STATUS_PENDING)) return;
-        this.Te();
-    }
-    Te() {
-        for (const e of this.I) if (this.de(e)) this.I.delete(e);
-        if (!this.I.size) {
-            if (this.te & STATUS_PENDING && this.U && !this.H && this.re) {
-                this.U = !!(this.re.S & this.te);
-            } else {
-                this.U = false;
+    const a = {
+        ...o.U,
+        [BOUNDARY]: l
+    };
+    if (revealHooks !== null) a[REVEAL] = null;
+    o.U = a;
+    const i = runWithOwner(o, () => {
+        const e = true ? computed(n, {
+            name: "children"
+        }) : computed(n);
+        return true ? computed(() => flatten(read(e)), {
+            name: "boundary"
+        }) : computed(() => flatten(read(e)));
+    });
+    l.$ = i;
+    // A slot of the reveal order in its context (reveal.ts): gated until the
+    // controller releases it — before the output's first pass.
+        if (u) revealHooks.ae(u, l);
+    const f = computed(() => {
+        // Reveal order (reveal.ts): a gated slot shows its fallback — or, in a
+        // collapsed tail, nothing — whatever its content's state; the
+        // controller is told the pass ran (its readiness may have changed) and
+        // releases it in turn.
+        if (l.te) {
+            // 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 (l.B !== null) revealHooks.j(l.B);
+            if (l.te) {
+                if (l.oe) {
+                    l.P = true;
+                    return undefined;
+                }
+                return fallback(l);
             }
-            if (!this.U) {
-                setSignal(this.D, false);
-                if (attrHooks !== null && this.te & STATUS_PENDING) attrHooks.boundaryFallback(this, this.re, false);
+        }
+        // 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 n = i.G & (STATUS_PENDING | STATUS_ERROR);
+        if (n !== 0) {
+            link(i, getOwner());
+            if (n & 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`).
+                                l.V.add(i);
+                collecting.add(l);
             }
+            // A pending passes an error boundary by (A6); an error, a loading
+            // one; a loading boundary showing content forwards its pending.
+                        throw i.m.v;
         }
-        if (_revealUsed) this.W?.B();
-    }
-}
-
-function createCollectionBoundary(e, t, r, n) {
-    const i = createOwner();
-    if (_revealUsed) setContext(RevealControllerContext, null, i);
-    const s = new CollectionQueue(e);
-    s.ie = i;
-    if (e === STATUS_ERROR) s._ = signal(undefined, {
-        ownedWrite: true,
-        Z: true
-    });
-    // The `on` dependencies live OUTSIDE the boundary, as the condition of a
-    // `<Show>` wrapping it would: created before the owner's queue becomes
-    // this boundary's (onNode).
-        n && onNode(i, s, n);
-    const o = s.re = createBoundChildren(i, t, s, e);
-    // Prime source tracking so reveal registration sees pending sources. A
-    // bookkeeping read (`spectate`): the mounting pass derives nothing from
-    // the tree — it must not be linked to it, nor enter the transaction a
-    // tree born held (A29 under a boundary, #3540) was staged into.
-        spectate(() => {
-        let t = false;
+        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.
+            const e = getOwner();
+            if (l.V.size !== 0 && e.G & STATUS_UNINITIALIZED && !(e.u & 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 r;
         try {
-            read(o);
-        } catch (e) {
-            if (e instanceof NotReadyError) t = true; else throw e;
+            r = 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`).
+                                l.V.add(i);
+                collecting.add(l);
+            }
+            // A pending passes an error boundary by (A6).
+                        throw n;
         }
-        s.U = t || !!(o.S & e) || o.o?._ instanceof NotReadyError;
-    });
-    const a = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
-    if (a) {
-        s.W = a;
-        a.$(s);
-        cleanup(() => a.ee(s));
-    }
-    return accessor(s.ne = computed(() => {
-        // `_disabled` selects fallback or content: set by a collecting
-        // notification or a re-arm (`_rearm`), cleared by the sweep when the
-        // collected sources settle — each re-runs this pass.
-        if (!read(s.D)) {
-            const e = read(o);
-            if (!untrack(() => read(s.D))) return s.H = 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.V.size !== 0) return fallback(l);
+        l.k = 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.P && l.i & STATUS_PENDING && attrHooks !== null) attrHooks.boundaryFallback(l, l.$, false);
+        l.P = false;
+        release(l);
+        // Shown: the slot leaves its reveal order (a later re-arm gates nobody
+        // else; the frontier moves on).
+                if (l.B !== null) {
+            const e = l.B;
+            l.B = null;
+            revealHooks.j(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(s.P)) return undefined;
-        return r(s);
+        return r;
     }, 
-    // 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.
     {
         name: "value",
-        Z: true
-    }));
+        ie: true
+    });
+    f.u |= CONFIG_REDERIVE;
+    l.K = f;
+    return accessor(f);
 }
 
+function fallback(e) {
+    // The swap a display-ahead re-arm asked for: this pass is the lane's — a
+    // lane read by construction (REACTIVE_LANE_READ: `recompute`'s tail keeps
+    // the pass in the lane).
+    if (e.Z !== null) {
+        setPassLane(e.Z);
+        e.K.R |= REACTIVE_LANE_READ;
+        e.Z = null;
+    }
+    // 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.P && e.i & STATUS_PENDING && attrHooks !== null) {
+        attrHooks.boundaryFallback(e, e.$, true, passLane !== null ? null : flushTransaction !== null ? resolveTx(flushTransaction) : passTx);
+        if (!globalQueue.ee) schedule();
+    }
+    e.P = true;
+    return e.le(e);
+}
+
+const ERROR_SIGNAL = {
+    ownedWrite: true,
+    ie: true
+};
+
 /**
  * Lower-level primitive that backs the `<Loading>` flow control. Catches
  * pending async reads inside `fn` and renders `fallback` until they settle.
@@ -614,8 +541,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);
 }
 
 /**
@@ -640,154 +567,20 @@ function createCollectionBoundary(e, t, r, n) {
  *   ) as unknown as JSX.Element;
  * }
  * ```
- */ function createErrorBoundary(e, t) {
-    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e._), () => e.he()));
+ */ function createErrorBoundary(e, n) {
+    return createBoundary(STATUS_ERROR, e, e => n(accessor(e.v), () => reset(e)));
 }
 
-/**
- * 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 i = t?.order || SEQUENTIAL_ACCESSOR, s = t?.collapsed || FALSE_ACCESSOR;
-    const o = new RevealController(i, s);
-    setContext(RevealControllerContext, o, r);
-    return runWithOwner(r, () => {
-        const t = e();
-        const r = computed(() => {
-            i();
-            s();
-            o.B();
-        });
-        // Post-construction rather than an options argument, so the prod call
-        // keeps its shape; the observe node literal already carries the slot.
-                if (true) r._name = "reveal order";
-        if (n) {
-            o.L = n;
-            n.$(o);
-            cleanup(() => n.ee(o));
-        }
-        return t;
-    });
-}
+// Installed at module evaluation — present exactly when something imports a
+// boundary. An app without one pays the three null checks and nothing else.
+GlobalQueue.fe = catchStatus;
 
-/**
- * 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;
-}
+GlobalQueue.ce = e => e.G & STATUS_UNINITIALIZED && catchStatus(e, STATUS_PENDING);
 
-function flattenArray(e, t = [], r) {
-    let n = null;
-    let i = false;
-    for (let s = 0; s < e.length; s++) {
-        try {
-            let n = e[s];
-            if (typeof n === "function" && !n.length) {
-                if (r?.doNotUnwrap) {
-                    t.push(n);
-                    i = true;
-                    continue;
-                }
-                do {
-                    n = n();
-                } while (typeof n === "function" && !n.length);
-            }
-            if (Array.isArray(n)) {
-                // OR, don't overwrite: an accessor already pushed under doNotUnwrap
-                // still needs the resolving wrapper even when a later sibling
-                // fragment contains no functions (#3133).
-                i = flattenArray(n, t, r) || i;
-            } 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 i;
-}
+GlobalQueue.se = hidden;
+
+GlobalQueue.Ee = boundarySeam;
+
+GlobalQueue.de = heldRun;
 
-export { CollectionQueue, RevealController, createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten };
+export { REVEAL, createErrorBoundary, createLoadingBoundary, prune, ready, redraw, revealHooks, setRevealHooks };