@solidjs/signals 2.0.0-beta.9 → 2.0.0-rc.0

package/dist/prod/affects.js

@@ -0,0 +1,126 @@
+import { forEachDependent } from "./core/async.js";
+
+import { $REFRESH, STATUS_PENDING } from "./core/constants.js";
+
+import { NotReadyError } from "./core/error.js";
+
+import "./core/core.js";
+
+import { GlobalQueue, globalQueue, schedule, shiftAffectsMarks } from "./core/scheduler.js";
+
+import "./core/verdict.js";
+
+import "./core/effect.js";
+
+import "./core/invariants.js";
+
+import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
+
+/**
+ * The counting half of a mark, shared by direct registration and store-scope
+ * inheritance (a node created inside a live keyless mark's identity scope).
+ * A mark is ONLY this count: coverage of everything derived from the node is
+ * pull-derived by the verdict layer's `markWalk` (dep-graph reachability), so
+ * nothing is stored downstream and nothing can be stranded or stripped by
+ * mid-window recomputes.
+ */ function markAffects(e) {
+    e.t = (e.t || 0) + 1;
+    shiftAffectsMarks(1);
+}
+
+/**
+ * Boundary visual channel: within a transaction, a live mark holds Loading
+ * fallbacks / reveal ordering the way real in-flight async would — but the
+ * notification is tagged visibility-only at the source (`_markVisual`), so
+ * the root queue never registers reporters from it: marks are invisible to
+ * ALL completion and settlement accounting by construction. Boundaries hold
+ * the marked node in `_sources` while `_affectsCount` is live; the release
+ * sweep (finalizePureQueue re-checks boundary children after mark release)
+ * is the display-state update point. Ambient marks release inside the same
+ * flush that would surface them, before effects run — verdict-only, netting
+ * no visual change.
+ */ function notifyMarkBoundaries(e) {
+    if (!e.o && !e.u) return;
+    const r = new NotReadyError(e);
+    r.l = true;
+    const t = new Set;
+    const visit = e => {
+        if (t.has(e)) return;
+        t.add(e);
+        // Display consumers (render effects, boundary computeds) act on the
+        // notification; descent stops there, exactly like the status rails.
+                if (e.i) {
+            e.i(STATUS_PENDING, r);
+            return;
+        }
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+}
+
+/**
+ * Registers one `affects()` mark on a node: counts it, records the
+ * registration with the current transaction (after initTransition the queue's
+ * batch IS the active transition, mirroring `_optimisticNodes`), re-derives
+ * every downstream verdict companion (the mark channel's only push — verdict
+ * pokes, not state), and notifies boundary display state. Both walks run on
+ * every registration (not just the first): subscribers gained since an
+ * earlier overlapping registration get covered, and dedup stops re-descent.
+ */ function registerAffectsMark(e) {
+    markAffects(e);
+    globalQueue.m.A.push(e);
+    // Companions only exist once the verdict layer (isPending/latest) loaded;
+    // without them there is no materialized verdict to poke.
+        GlobalQueue.k !== null && GlobalQueue.k(e);
+    notifyMarkBoundaries(e);
+    schedule();
+}
+
+/**
+ * Releases one registration. When the node's last mark drops, re-derives
+ * every downstream verdict through the settlement snap (committed, not
+ * transition-scoped — release runs inside queue finalization, where a
+ * setSignal would open a fresh override window that nothing settles).
+ */ function releaseAffectsMark(e) {
+    shiftAffectsMarks(-1);
+    e.t--;
+    if (!e.t) {
+        GlobalQueue.k !== null && GlobalQueue.k(e, true);
+        GlobalQueue.p?.(e);
+    }
+}
+
+/**
+ * Releases one batch of affects marks (a settling transaction's, or the
+ * ambient batch at a plain flush end).
+ */ function releaseAffectsMarks(e) {
+    for (let r = 0; r < e.length; r++) releaseAffectsMark(e[r]);
+    e.length = 0;
+}
+
+// Late installation (same pattern as `GlobalQueue._update`): the mark engine
+// lives with the feature so graphs that never declare a mark never ship it.
+// Each call site is gated by state only this module creates (a non-empty
+// `_affectsNodes` batch, a live scope in the store's `affectsScopes`), so the
+// hooks are installed before the first time any of them can fire.
+GlobalQueue.G = releaseAffectsMarks;
+
+GlobalQueue.M = markAffects;
+
+GlobalQueue.h = releaseAffectsMark;
+
+function affects(e, r) {
+    const t = e?.[$TARGET];
+    if (t) {
+        const e = getStoreAffectsNodes(t, r);
+        for (let r = 0; r < e.length; r++) registerAffectsMark(e[r]);
+        return;
+    }
+    const o = e?.[$REFRESH];
+    if (o) {
+        registerAffectsMark(o);
+        return;
+    }
+}
+
+export { affects };

package/dist/prod/boundaries.js

@@ -0,0 +1,572 @@
+import { runWithOwner, signal, untrack, read, computed, setSignal, 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 { getContext, setContext, createContext } from "./core/context.js";
+
+import { STATUS_PENDING, STATUS_ERROR, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE } from "./core/constants.js";
+
+import "./core/invariants.js";
+
+import "./core/verdict.js";
+
+import "./core/effect.js";
+
+import { accessor } from "./signals.js";
+
+function boundaryComputed(e, t) {
+    const r = computed(e, {
+        lazy: true
+    });
+    r.i = (e, t) => {
+        // Use passed values if provided, otherwise read from node
+        const n = e !== undefined ? e : r.S;
+        const s = t !== undefined ? t : r._;
+        // 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._ === s && !(r.S & (STATUS_PENDING | STATUS_ERROR))) r._ = 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;
+}
+
+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);
+    });
+}
+
+const ON_INIT = Symbol();
+
+const RevealControllerContext = /* @__PURE__ */ createContext(null);
+
+let _revealUsed = false;
+
+const FALSE_ACCESSOR = () => false;
+
+const SEQUENTIAL_ACCESSOR = () => "sequential";
+
+function isRevealController(e) {
+    return e instanceof RevealController;
+}
+
+function isSlotReady(e) {
+    return isRevealController(e) ? e.O() : e.v.size === 0 && !e.N;
+}
+
+function isSlotMinimallyReady(e) {
+    return isRevealController(e) ? e.U() : isSlotReady(e);
+}
+
+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.j(r, n);
+    }
+    if (!r && e.B === t && e.W) e.B = undefined;
+}
+
+class RevealController {
+    L;
+    F;
+    q=[];
+    P;
+    I=signal(false, {
+        ownedWrite: true,
+        V: true
+    });
+    D=signal(false, {
+        ownedWrite: true,
+        V: true
+    });
+    H=true;
+    J=true;
+    K=false;
+    constructor(e, t) {
+        this.L = e;
+        this.F = t;
+    }
+    X(e) {
+        for (let t = 0; t < this.q.length; t++) {
+            const r = this.q[t];
+            if ((isRevealController(r) ? r.P : r.B) !== this) continue;
+            if (e(r) === false) return false;
+        }
+        return true;
+    }
+    O() {
+        return this.X(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.
+     */    U() {
+        const e = untrack(this.L);
+        if (e === "together") return this.X(isSlotMinimallyReady);
+        if (e === "natural") {
+            let e = false;
+            let t = false;
+            this.X(r => {
+                e = true;
+                if (isSlotMinimallyReady(r)) {
+                    t = true;
+                    return false;
+                }
+            });
+            return !e || t;
+        }
+        // sequential: only the first owned slot matters.
+                let t = true;
+        this.X(e => {
+            t = isSlotMinimallyReady(e);
+            return false;
+        });
+        return t;
+    }
+    Y(e) {
+        if (this.q.includes(e)) return;
+        this.q.push(e);
+        const t = untrack(this.L);
+        setSignal(e.I, true), setSignal(e.D, t === "sequential" ? !!untrack(this.F) : false);
+        untrack(() => this.j());
+    }
+    Z(e) {
+        const t = this.q.indexOf(e);
+        if (t >= 0) this.q.splice(t, 1);
+        untrack(() => this.j());
+    }
+    j(e, t) {
+        if (this.K) return;
+        this.K = true;
+        const r = this.H;
+        const n = this.J;
+        try {
+            const r = e ?? read(this.I), n = untrack(this.L), s = n === "sequential" && !!untrack(this.F), 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.X(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.X(e => {
+                    if (isRevealController(e)) {
+                        setSignal(e.D, false);
+                        setSignal(e.I, false);
+                        e.j(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.X(isSlotMinimallyReady);
+                this.X(t => setSlotState(t, this, !e, false));
+            } else {
+                let e = false;
+                this.X(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.j(false, false);
+                    } else {
+                        setSlotState(t, this, true, false);
+                    }
+                });
+            }
+        } finally {
+            this.H = this.O();
+            this.J = this.U();
+            this.K = false;
+        }
+        if (this.P && (r !== this.H || n !== this.J)) this.P.j();
+    }
+}
+
+class CollectionQueue extends Queue {
+    $;
+    v=new Set;
+    ee;
+    N=true;
+    I=signal(false, {
+        ownedWrite: true,
+        V: true
+    });
+    _;
+    D=signal(false, {
+        ownedWrite: true,
+        V: true
+    });
+    B;
+    W=false;
+    te;
+    re=ON_INIT;
+    constructor(e) {
+        super();
+        this.$ = e;
+    }
+    run(e) {
+        if (!e || read(this.I) && (!_revealUsed || read(this.D))) return;
+        return super.run(e);
+    }
+    notify(e, t, r, n) {
+        if (!(t & this.$)) return super.notify(e, t, r, n);
+        if (this.W && this.te) {
+            const e = untrack(() => {
+                try {
+                    return this.te();
+                } catch {
+                    return ON_INIT;
+                }
+            });
+            if (e !== this.re) {
+                this.re = e;
+                this.W = false;
+                this.v.clear();
+            }
+        }
+        // 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.$ & STATUS_PENDING && this.W) return super.notify(e, t, r, n);
+        if (r & this.$) {
+            this.N = true;
+            const t = n?.source || e._?.source;
+            if (t) {
+                const e = this.v.size === 0;
+                this.v.add(t);
+                if (e) setSignal(this.I, true);
+                if (this.$ & STATUS_ERROR) {
+                    setSignal(this._, unwrapStatusError(t._));
+                }
+            }
+        }
+        t &= ~this.$;
+        return t ? super.notify(e, t, r, n) : true;
+    }
+    ne() {
+        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.se & REACTIVE_DISPOSED || !e.t && !(e.S & this.$) && !(this.$ & STATUS_ERROR && e.S & STATUS_PENDING)) this.v.delete(e);
+        }
+        if (!this.v.size) {
+            if (this.$ & STATUS_PENDING && this.N && !this.W && this.ee) {
+                this.N = !!(this.ee.S & this.$);
+            } else {
+                this.N = false;
+            }
+            if (!this.N) {
+                setSignal(this.I, false);
+                if (this.te) {
+                    try {
+                        this.re = untrack(() => this.te());
+                    } catch {
+                        /* value not yet committed — _prevOn stays stale, next notify will reset */}
+                }
+            }
+        }
+        if (_revealUsed) this.B?.j();
+    }
+}
+
+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,
+        V: true
+    });
+    if (n) i.te = n;
+    const o = i.ee = 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._ instanceof NotReadyError;
+    });
+    const l = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
+    if (l) {
+        i.B = l;
+        l.Y(i);
+        cleanup(() => l.Z(i));
+    }
+    return accessor(computed(() => {
+        if (!read(i.I)) {
+            const e = read(o);
+            if (!untrack(() => read(i.I))) return i.W = true, 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);
+    }, 
+    // 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.
+    {
+        V: true
+    }));
+}
+
+/**
+ * Lower-level primitive that backs the `<Loading>` flow control. Catches
+ * pending async reads inside `fn` and renders `fallback` until they settle.
+ *
+ * App code should use `<Loading fallback={...}>` instead — reach for this only
+ * when authoring custom boundary components.
+ *
+ * @param fn the tracked subtree
+ * @param fallback the fallback shown while async reads in `fn` are unresolved
+ * @param options `on` — accessor whose value scopes the boundary; when set,
+ *   transitions caused by writes to other reactive sources are *not* caught
+ *
+ * @example
+ * ```tsx
+ * // Custom boundary component built on top of the primitive.
+ * function MyLoading(props: { fallback: JSX.Element; children: JSX.Element }) {
+ *   return createLoadingBoundary(
+ *     () => props.children,
+ *     () => props.fallback
+ *   ) as unknown as JSX.Element;
+ * }
+ * ```
+ */ function createLoadingBoundary(e, t, r) {
+    return createCollectionBoundary(STATUS_PENDING, e, () => t(), r?.on);
+}
+
+/**
+ * Lower-level primitive that backs the `<Errored>` flow control. Catches
+ * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
+ * `error` is an accessor for the latest captured error; `reset()` recomputes
+ * the failing sources so the boundary can attempt to recover.
+ *
+ * App code should use `<Errored fallback={...}>` instead — reach for this only
+ * when authoring custom boundary components.
+ *
+ * @example
+ * ```tsx
+ * // Custom boundary that wraps the primitive and adds telemetry.
+ * function TracedErrored(props: { fallback: (e: () => unknown) => JSX.Element; children: JSX.Element }) {
+ *   return createErrorBoundary(
+ *     () => props.children,
+ *     (err, reset) => {
+ *       reportError(err());
+ *       return props.fallback(err);
+ *     }
+ *   ) as unknown as JSX.Element;
+ * }
+ * ```
+ */ function createErrorBoundary(e, 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.j();
+        });
+        if (n) {
+            o.P = n;
+            n.Y(o);
+            cleanup(() => n.Z(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 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;
+}
+
+export { CollectionQueue, RevealController, createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten };