@solidjs/signals 2.0.0-rc.8 → 2.0.0-rc.9

package/dist/observe/affects.js

@@ -4,6 +4,8 @@ import { ext, statusNotifierOf } from "./core/core.js";
 
 import { $REFRESH, STATUS_PENDING } from "./core/constants.js";
 
+import "./core/dev.js";
+
 import { NotReadyError } from "./core/error.js";
 
 import { GlobalQueue, globalQueue, schedule, shiftAffectsMarks } from "./core/scheduler.js";
@@ -108,7 +110,7 @@ GlobalQueue.G = releaseAffectsMarks;
 
 GlobalQueue.M = markAffects;
 
-GlobalQueue.N = releaseAffectsMark;
+GlobalQueue.j = releaseAffectsMark;
 
 function affects(e, r) {
     const t = e?.[$TARGET];

package/dist/observe/attribution.js

@@ -1 +1,7 @@
-export { attribution } from "./core/attribution.js";
+export { attribution, formatOrigin, formatRerun } from "./core/attribution.js";
+
+export { costs } from "./core/attribution-costs.js";
+
+export { feedback } from "./core/attribution-feedback.js";
+
+export { subscriptions, why } from "./core/attribution-queries.js";

package/dist/observe/boundaries.js

@@ -1,23 +1,27 @@
-import { runWithOwner, signal, untrack, read, computed, setSignal, ext, recompute } from "./core/core.js";
+import { runWithOwner, signal, untrack, read, computed, spectate, setSignal, ext, recompute } from "./core/core.js";
 
 import { NotReadyError, unwrapStatusError } from "./core/error.js";
 
 import { createOwner, cleanup } from "./core/owner.js";
 
-import { Queue, haltReactivity, schedule } from "./core/scheduler.js";
+import { Queue, transitions, wakeParked, haltReactivity, schedule } from "./core/scheduler.js";
 
 import { getContext, setContext, createContext } from "./core/context.js";
 
-import { STATUS_PENDING, STATUS_ERROR, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE } from "./core/constants.js";
+import { STATUS_PENDING, STATUS_ERROR, REACTIVE_ZOMBIE, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE } from "./core/constants.js";
 
 import { attrHooks } from "./core/attribution-hooks.js";
 
 import "./core/invariants.js";
 
+import "./core/dev.js";
+
 import "./core/verdict.js";
 
 import "./core/effect.js";
 
+import { reportClientError } from "./core/error-hooks.js";
+
 import { accessor } from "./signals.js";
 
 function boundaryComputed(t, e) {
@@ -26,44 +30,44 @@ function boundaryComputed(t, e) {
     });
     ext(r).h = (t, e) => {
         // Use passed values if provided, otherwise read from node
-        const n = t !== undefined ? t : r.S;
-        const s = e !== undefined ? e : r.o?._;
+        const s = t !== undefined ? t : r.S;
+        const n = e !== undefined ? e : 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);
+        const i = r.T.notify(r, STATUS_PENDING | STATUS_ERROR, s, n);
         // 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);
+                const o = s & ~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;
+            if (r.o?._ === n && !(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;
+                if (!i && s & STATUS_ERROR) {
+            haltReactivity(unwrapStatusError(n));
+            throw n;
         }
     };
     r.R = e;
-    r.T &= ~CONFIG_AUTO_DISPOSE;
+    r.C &= ~CONFIG_AUTO_DISPOSE;
     recompute(r, true);
     return r;
 }
 
-function createBoundChildren(t, e, r, n) {
-    const s = t.C;
-    s.addChild(t.C = r);
-    cleanup(() => s.removeChild(t.C));
+function createBoundChildren(t, e, r, s) {
+    const n = t.T;
+    n.addChild(t.T = r);
+    cleanup(() => n.removeChild(t.T));
     return runWithOwner(t, () => {
         const t = computed(e);
-        return boundaryComputed(() => flatten(read(t)), n);
+        return boundaryComputed(() => flatten(read(t)), s);
     });
 }
 
@@ -82,53 +86,53 @@ function isRevealController(t) {
 }
 
 function isSlotReady(t) {
-    return isRevealController(t) ? t.O() : t.v.size === 0 && !t.U;
+    return isRevealController(t) ? t.N() : t.O.size === 0 && !t.I;
 }
 
 function isSlotMinimallyReady(t) {
-    return isRevealController(t) ? t.I() : isSlotReady(t);
+    return isRevealController(t) ? t.U() : isSlotReady(t);
 }
 
-function setSlotState(t, e, r, n) {
-    setSignal(t.D, r);
-    setSignal(t.P, n);
+function setSlotState(t, e, r, s) {
+    setSignal(t.v, r);
+    setSignal(t.D, s);
     if (isRevealController(t)) {
-        if (!r && t.j === e) t.j = undefined;
-        return t.B(r, n);
+        if (!r && t.P === e) t.P = undefined;
+        return t.B(r, s);
     }
-    if (!r && t.W === e && t.L) t.W = undefined;
+    if (!r && t.W === e && t.H) t.W = undefined;
 }
 
 class RevealController {
+    L;
     F;
-    H;
-    q=[];
-    j;
-    D=signal(false, {
+    V=[];
+    P;
+    v=signal(false, {
         ownedWrite: true,
-        V: true
+        q: true
     });
-    P=signal(false, {
+    D=signal(false, {
         ownedWrite: true,
-        V: true
+        q: true
     });
+    Z=true;
     J=true;
-    K=true;
-    X=false;
+    K=false;
     constructor(t, e) {
-        this.F = t;
-        this.H = e;
+        this.L = t;
+        this.F = e;
     }
-    Y(t) {
-        for (let e = 0; e < this.q.length; e++) {
-            const r = this.q[e];
-            if ((isRevealController(r) ? r.j : r.W) !== this) continue;
+    X(t) {
+        for (let e = 0; e < this.V.length; e++) {
+            const r = this.V[e];
+            if ((isRevealController(r) ? r.P : r.W) !== this) continue;
             if (t(r) === false) return false;
         }
         return true;
     }
-    O() {
-        return this.Y(isSlotReady);
+    N() {
+        return this.X(isSlotReady);
     }
     /**
      * "Minimally ready" = this group has something visible to show under its own policy.
@@ -136,13 +140,13 @@ class RevealController {
      * - `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.
-     */    I() {
-        const t = untrack(this.F);
-        if (t === "together") return this.Y(isSlotMinimallyReady);
+     */    U() {
+        const t = untrack(this.L);
+        if (t === "together") return this.X(isSlotMinimallyReady);
         if (t === "natural") {
             let t = false;
             let e = false;
-            this.Y(r => {
+            this.X(r => {
                 t = true;
                 if (isSlotMinimallyReady(r)) {
                     e = true;
@@ -153,61 +157,61 @@ class RevealController {
         }
         // sequential: only the first owned slot matters.
                 let e = true;
-        this.Y(t => {
+        this.X(t => {
             e = isSlotMinimallyReady(t);
             return false;
         });
         return e;
     }
-    Z(t) {
-        if (this.q.includes(t)) return;
-        this.q.push(t);
-        const e = untrack(this.F);
-        setSignal(t.D, true), setSignal(t.P, e === "sequential" ? !!untrack(this.H) : false);
+    Y(t) {
+        if (this.V.includes(t)) return;
+        this.V.push(t);
+        const e = untrack(this.L);
+        setSignal(t.v, true), setSignal(t.D, e === "sequential" ? !!untrack(this.F) : false);
         untrack(() => this.B());
     }
     $(t) {
-        const e = this.q.indexOf(t);
-        if (e >= 0) this.q.splice(e, 1);
+        const e = this.V.indexOf(t);
+        if (e >= 0) this.V.splice(e, 1);
         untrack(() => this.B());
     }
     B(t, e) {
-        if (this.X) return;
-        this.X = true;
-        const r = this.J;
-        const n = this.K;
+        if (this.K) return;
+        this.K = true;
+        const r = this.Z;
+        const s = this.J;
         try {
-            const r = t ?? read(this.D), n = untrack(this.F), s = n === "sequential" && !!untrack(this.H), i = e ?? s;
+            const r = t ?? read(this.v), s = untrack(this.L), n = s === "sequential" && !!untrack(this.F), i = e ?? n;
             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(t => setSlotState(t, this, true, i));
-            } else if (n === "natural") {
+                this.X(t => setSlotState(t, this, true, i));
+            } else if (s === "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(t => {
+                this.X(t => {
                     if (isRevealController(t)) {
-                        setSignal(t.P, false);
                         setSignal(t.D, false);
+                        setSignal(t.v, false);
                         t.B(false, false);
                     } else {
                         setSlotState(t, this, !isSlotReady(t), false);
                     }
                 });
-            } else if (n === "together") {
+            } else if (s === "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 t = this.Y(isSlotMinimallyReady);
-                this.Y(e => setSlotState(e, this, !t, false));
+                const t = this.X(isSlotMinimallyReady);
+                this.X(e => setSlotState(e, this, !t, false));
             } else {
                 let t = false;
-                this.Y(e => {
-                    if (t) return setSlotState(e, this, true, s);
+                this.X(e => {
+                    if (t) return setSlotState(e, this, true, n);
                     if (isSlotReady(e)) return setSlotState(e, this, false, false);
                     t = true;
                     // Frontier slot. For a leaf, holding `_disabled=true` is what keeps its
@@ -217,8 +221,8 @@ class RevealController {
                     // advancing past this slot, and we bypass setSlotState so the parent
                     // backpointer survives for upward readiness notifications.
                                         if (isRevealController(e)) {
-                        setSignal(e.P, false);
                         setSignal(e.D, false);
+                        setSignal(e.v, false);
                         e.B(false, false);
                     } else {
                         setSlotState(e, this, true, false);
@@ -226,54 +230,78 @@ class RevealController {
                 });
             }
         } finally {
-            this.J = this.O();
-            this.K = this.I();
-            this.X = false;
+            this.Z = this.N();
+            this.J = this.U();
+            this.K = false;
         }
-        if (this.j && (r !== this.J || n !== this.K)) this.j.B();
+        if (this.P && (r !== this.Z || s !== this.J)) this.P.B();
     }
 }
 
 class CollectionQueue extends Queue {
     tt;
-    v=new Set;
+    O=new Set;
     et;
-    U=true;
-    D=signal(false, {
+    I=true;
+    v=signal(false, {
         ownedWrite: true,
-        V: true
+        q: true
     });
     _;
-    P=signal(false, {
+    D=signal(false, {
         ownedWrite: true,
-        V: true
+        q: true
     });
     W;
-    L=false;
+    H=false;
     rt;
-    nt=ON_INIT;
+    st=ON_INIT;
+    /** The boundary's owner — where a `caught` report locates itself, set before the children are built (a creation-time throw arrives before `_tree`). */
+    nt;
     constructor(t) {
         super();
         this.tt = t;
     }
     run(t) {
-        if (!t || read(this.D) && (!_revealUsed || read(this.P))) return;
+        if (!t || read(this.v) && (!_revealUsed || read(this.D))) return;
         return super.run(t);
     }
-    notify(t, e, r, n) {
-        if (!(e & this.tt)) return super.notify(t, e, r, n);
-        if (this.L && this.rt) {
-            const t = untrack(() => {
-                try {
-                    return this.rt();
-                } catch {
-                    return ON_INIT;
+    /** The `on` key, or ON_INIT when it throws. Evaluated mid-propagation,
+     * inside the pending node's own pass: read as a spectator so the key's
+     * sources never become that node's dependencies (#3528). */    it() {
+        return spectate(() => {
+            try {
+                return this.rt();
+            } catch {
+                return ON_INIT;
+            }
+        });
+    }
+    notify(t, e, r, s) {
+        if (!(e & this.tt)) return super.notify(t, e, r, s);
+        if (this.H && this.rt) {
+            const t = this.it();
+            if (t !== this.st) {
+                this.st = t;
+                this.H = false;
+                this.O.clear();
+                // Readers forwarded while this boundary showed content are behind the
+                // fallback now: they stop blocking (`reporterBlocksSource`), and the
+                // transactions they were holding must be re-judged for it (A33, #3375).
+                // What those readers still wait on is this boundary's to wait on now:
+                // they never re-notify (status propagation dedupes on the reader's
+                // `_pendingSources`), so the reset 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).
+                                for (const t of transitions) for (const [e, r] of t.ot) for (const t of r) if (this.lt(t)) {
+                    this.O.add(e);
+                    t.o?.ut?.forEach(t => this.O.add(t));
                 }
-            });
-            if (t !== this.nt) {
-                this.nt = t;
-                this.L = false;
-                this.v.clear();
+                if (this.O.size) {
+                    setSignal(this.v, true);
+                    if (attrHooks !== null && this.tt & STATUS_PENDING) attrHooks.boundaryFallback(this, this.et, true);
+                }
+                wakeParked();
             }
         }
         // Routing is dimension-independent: each boundary consumes only its own
@@ -286,47 +314,73 @@ class CollectionQueue extends Queue {
         // 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.tt & STATUS_PENDING && this.L) return super.notify(t, e, r, n);
+                if (this.tt & STATUS_PENDING && this.H) return super.notify(t, e, r, s);
         if (r & this.tt) {
-            this.U = true;
-            const e = n?.source || t.o?._?.source;
+            this.I = true;
+            const e = s?.source || t.o?._?.source;
             if (e) {
-                const t = this.v.size === 0;
-                this.v.add(e);
-                if (t) {
-                    setSignal(this.D, true);
+                const r = this.O.size === 0;
+                this.O.add(e);
+                // 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.tt & STATUS_PENDING) t.o?.ut?.forEach(t => this.O.add(t));
+                if (r) {
+                    setSignal(this.v, true);
                     if (attrHooks !== null && this.tt & STATUS_PENDING) attrHooks.boundaryFallback(this, this.et, true);
                 }
                 if (this.tt & STATUS_ERROR) {
-                    setSignal(this._, unwrapStatusError(e.o?._));
+                    const t = unwrapStatusError(e.o?._);
+                    setSignal(this._, t);
+                    // 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(t, this.nt, e);
                 }
             }
         }
         e &= ~this.tt;
-        return e ? super.notify(t, e, r, n) : true;
+        return e ? super.notify(t, e, r, s) : true;
+    }
+    /** Is `reporter` live and routed to this boundary — under it, with no
+     * collecting pending-type boundary in between (`reporterBlocksSource`'s test)? */    lt(t) {
+        if (t.ft & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+        for (let e = t.T; e; e = e._parent) {
+            if (e === this) return true;
+            if (e.tt & STATUS_PENDING && !e.H) return false;
+        }
+        return false;
     }
-    st() {
-        for (const t of this.v) {
+    ct() {
+        for (const t of this.O) {
             // 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 (t.it & REACTIVE_DISPOSED || !t.o?.t && !(t.S & this.tt) && !(this.tt & STATUS_ERROR && t.S & STATUS_PENDING)) this.v.delete(t);
+            if (t.ft & REACTIVE_DISPOSED || !t.o?.t && !(t.S & this.tt) && !(this.tt & STATUS_ERROR && t.S & STATUS_PENDING)) this.O.delete(t);
         }
-        if (!this.v.size) {
-            if (this.tt & STATUS_PENDING && this.U && !this.L && this.et) {
-                this.U = !!(this.et.S & this.tt);
+        if (!this.O.size) {
+            if (this.tt & STATUS_PENDING && this.I && !this.H && this.et) {
+                this.I = !!(this.et.S & this.tt);
             } else {
-                this.U = false;
+                this.I = false;
             }
-            if (!this.U) {
-                setSignal(this.D, false);
+            if (!this.I) {
+                setSignal(this.v, false);
                 if (attrHooks !== null && this.tt & STATUS_PENDING) attrHooks.boundaryFallback(this, this.et, false);
                 if (this.rt) {
-                    try {
-                        this.nt = untrack(() => this.rt());
-                    } catch {
-                        /* value not yet committed — _prevOn stays stale, next notify will reset */}
+                    // A throw (value not yet committed) leaves _prevOn stale; the next
+                    // notify then resets.
+                    const t = this.it();
+                    if (t !== ON_INIT) this.st = t;
                 }
             }
         }
@@ -334,16 +388,17 @@ class CollectionQueue extends Queue {
     }
 }
 
-function createCollectionBoundary(t, e, r, n) {
-    const s = createOwner();
-    if (_revealUsed) setContext(RevealControllerContext, null, s);
+function createCollectionBoundary(t, e, r, s) {
+    const n = createOwner();
+    if (_revealUsed) setContext(RevealControllerContext, null, n);
     const i = new CollectionQueue(t);
+    i.nt = n;
     if (t === STATUS_ERROR) i._ = signal(undefined, {
         ownedWrite: true,
-        V: true
+        q: true
     });
-    if (n) i.rt = n;
-    const o = i.et = createBoundChildren(s, e, i, t);
+    if (s) i.rt = s;
+    const o = i.et = createBoundChildren(n, e, i, t);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
         let e = false;
@@ -352,23 +407,23 @@ function createCollectionBoundary(t, e, r, n) {
         } catch (t) {
             if (t instanceof NotReadyError) e = true; else throw t;
         }
-        i.U = e || !!(o.S & t) || o.o?._ instanceof NotReadyError;
+        i.I = e || !!(o.S & t) || o.o?._ instanceof NotReadyError;
     });
     const l = _revealUsed && t === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (l) {
         i.W = l;
-        l.Z(i);
+        l.Y(i);
         cleanup(() => l.$(i));
     }
     return accessor(computed(() => {
-        if (!read(i.D)) {
+        if (!read(i.v)) {
             const t = read(o);
-            if (!untrack(() => read(i.D))) return i.L = true, t;
+            if (!untrack(() => read(i.v))) return i.H = true, t;
         }
         // 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.P)) return undefined;
+                if (_revealUsed && read(i.D)) return undefined;
         return r(i);
     }, 
     // Boundary structure, not a user source: its value is fallback-or-content and
@@ -376,7 +431,7 @@ function createCollectionBoundary(t, e, r, n) {
     // 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.
     {
-        V: true
+        q: true
     }));
 }
 
@@ -430,11 +485,11 @@ function createCollectionBoundary(t, e, r, n) {
  * ```
  */ function createErrorBoundary(t, e) {
     return createCollectionBoundary(STATUS_ERROR, t, t => e(accessor(t._), () => {
-        for (const e of t.v) {
+        for (const e of t.O) {
             // 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.ot !== undefined) recompute(e);
+            if (e.ht !== undefined) recompute(e);
         }
         schedule();
     }));
@@ -483,21 +538,21 @@ function createCollectionBoundary(t, e, r, n) {
  */ function createRevealOrder(t, e) {
     _revealUsed = true;
     const r = createOwner();
-    const n = getContext(RevealControllerContext);
-    const s = e?.order || SEQUENTIAL_ACCESSOR, i = e?.collapsed || FALSE_ACCESSOR;
-    const o = new RevealController(s, i);
+    const s = getContext(RevealControllerContext);
+    const n = e?.order || SEQUENTIAL_ACCESSOR, i = e?.collapsed || FALSE_ACCESSOR;
+    const o = new RevealController(n, i);
     setContext(RevealControllerContext, o, r);
     return runWithOwner(r, () => {
         const e = t();
         computed(() => {
-            s();
+            n();
             i();
             o.B();
         });
-        if (n) {
-            o.j = n;
-            n.Z(o);
-            cleanup(() => n.$(o));
+        if (s) {
+            o.P = s;
+            s.Y(o);
+            cleanup(() => s.$(o));
         }
         return e;
     });
@@ -551,36 +606,36 @@ function createCollectionBoundary(t, e, r, n) {
 }
 
 function flattenArray(t, e = [], r) {
-    let n = null;
-    let s = false;
+    let s = null;
+    let n = false;
     for (let i = 0; i < t.length; i++) {
         try {
-            let n = t[i];
-            if (typeof n === "function" && !n.length) {
+            let s = t[i];
+            if (typeof s === "function" && !s.length) {
                 if (r?.doNotUnwrap) {
-                    e.push(n);
-                    s = true;
+                    e.push(s);
+                    n = true;
                     continue;
                 }
                 do {
-                    n = n();
-                } while (typeof n === "function" && !n.length);
+                    s = s();
+                } while (typeof s === "function" && !s.length);
             }
-            if (Array.isArray(n)) {
+            if (Array.isArray(s)) {
                 // 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).
-                s = flattenArray(n, e, r) || s;
-            } else if (r?.skipNonRendered && (n == null || n === true || n === false || n === "")) {
+                n = flattenArray(s, e, r) || n;
+            } else if (r?.skipNonRendered && (s == null || s === true || s === false || s === "")) {
                 // skip
-            } else e.push(n);
+            } else e.push(s);
         } catch (t) {
             if (!(t instanceof NotReadyError)) throw t;
-            n = t;
+            s = t;
         }
     }
-    if (n) throw n;
-    return s;
+    if (s) throw s;
+    return n;
 }
 
 export { CollectionQueue, RevealController, createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten };