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

package/dist/types/core/types.d.ts

@@ -1,6 +1,5 @@
 import type { NOT_PENDING } from "./constants.js";
-import type { OptimisticLane } from "./lanes.js";
-import type { IQueue, Transition } from "./scheduler.js";
+import type { Transaction } from "./scheduler.js";
 export interface Disposable {
     (): void;
 }
@@ -17,16 +16,38 @@ export interface Link {
      * scanning the dep list to answer membership (see `link()`).
      */
     _gen: number;
-    _pendingObserver?: boolean;
 }
 export interface NodeOptions<T> {
     id?: string;
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind; dev and observe builds keep it
+     * for console reports and diagnostic events, production ignores it. Not
+     * meant to be written by hand.
+     */
+    loc?: string;
     transparent?: boolean;
     equals?: ((prev: T, next: T) => boolean) | false;
     ownedWrite?: boolean;
     /** Exclude this signal from snapshot capture (internal — not part of public API) */
     _noSnapshot?: boolean;
+    /** Extra CONFIG_* bits OR'd into the node's config at creation (internal —
+     * not part of public API). Used by refresh() for CONFIG_FRESH_READ,
+     * keeping the per-flag option arms out of the core creation path. */
+    _extraConfig?: number;
+    /** Observe tiers: framework plumbing — no name, no owner-path segment, no
+     * attribution records of its own; its children stay observed (internal —
+     * not part of public API; see CONFIG_PLUMBING). */
+    _plumbing?: boolean;
+    /** Observe tiers: a framework scope wide by construction — exempt from
+     * WIDE_SCOPE_DEPS, never from HUGE_FAN_IN (internal — not part of public
+     * API; see CONFIG_WIDE). */
+    _wide?: boolean;
+    /** Observe tiers: a framework async node that supersedes its own flights by
+     * design — exempt from ABANDONED_FLIGHTS (internal — not part of public
+     * API; see CONFIG_SUPERSEDES). */
+    _supersedes?: boolean;
     unobserved?: () => void;
     lazy?: boolean;
     sync?: boolean;
@@ -53,67 +74,78 @@ export interface NodeOptions<T> {
  * hot-path gates — a bit says "consult _x", never the reverse.
  */
 export interface NodeExtension {
-    _overrideValue: unknown | typeof NOT_PENDING;
-    /**
-     * The transaction that owns the active override (stamped at optimistic
-     * write, cleared at settle). Ownership must live on the node: a lane's
-     * _transition is a scheduling affinity that a shared subscriber can merge
-     * across transactions (#2912) — following it would let one action's settle
-     * revert another action's live override. Node-level sibling of the store
-     * layer's STORE_OPTIMISTIC_OWNERS stamps (#2899). `null` = ambient write.
-     */
-    _overrideOwner: Transition | null | undefined;
-    _optimisticLane: OptimisticLane | undefined;
-    _pendingSignal: Signal<boolean> | undefined;
-    _latestValueComputed: Computed<any> | undefined;
-    _parentSource: Signal<any> | Computed<any> | undefined;
-    /**
-     * Live `affects()` marks on this node (refcount). Non-zero is declared
-     * motion — see affects(); the count is the mark's only graph state.
-     */
-    _affectsCount: number;
     _inFlight: PromiseLike<any> | AsyncIterable<any> | null;
+    /** Cancellation for the CURRENT iterator flight (#3122): closes the
+     * iterator (`it.return()`), idempotent. Fired at the sites that release
+     * `_inFlight` so a superseded stream stops at supersede time. Null for
+     * plain promise flights (no cancellation hook exists). */
+    _flightTeardown: (() => void) | null;
     _error: unknown;
     _blocked: boolean | undefined;
     _pendingSources: Set<Computed<any>> | undefined;
-    _notifyStatus: ((status?: number, error?: any) => void) | undefined;
-    /** Question-scoped re-ask classification of the current pending window
-     * (see the former Computed._x?._reask doc): set by recompute from
-     * REACTIVE_REASK, cleared on landing; meaningless while not pending. */
-    _reask: boolean;
-    _child: FirewallSignal<any> | null;
     _unobserved: (() => void) | undefined;
     _snapshotValue: any;
-    /** Zombie staging (staged disposal): a recompute of an owner that HAS
-     * children/disposal parks them here until the flush commits (or a
-     * transition reverts). Childless nodes — the common case — never write
-     * these. */
-    _pendingDisposal: Disposable | Disposable[] | null;
+    /** L2 — the previous pass's frame, parked for this node's commit: its child
+     * chain and `_disposal` list, still reacting until the commit disposes
+     * them (or the owner's death does). */
     _pendingFirstChild: Owner | null;
-    /** #3038: the firewall children that actually carry isPending()/latest()
-     * companions. The post-recompute companion snap iterates THIS set —
-     * O(companions asked for) — never the full `_child` chain (one entry per
-     * materialized leaf). Populated at companion creation; entries live as
-     * long as their companions (which are permanent once created). */
-    _companionChildren: Set<FirewallSignal<any>> | undefined;
+    _pendingDisposal: Disposable | Disposable[] | null;
+    /** L2 — the transaction holding this node while CONFIG_HELD is set
+     * (`holdNode`); resolved through merges by `txOf`. */
+    _transaction: Transaction | null;
+    /** The node's current flight re-asks the same question (a `refresh()`,
+     * A19 exc. 2 / A24): verdict-quiet — `isPending` reads false for it —
+     * through its landing until the commit. */
+    _reask: boolean;
+    /** A28: the staging the last flush left on a held node, kept across an
+     * unflushed rewrite — what `latest()` and a tracked reader see until the
+     * flush that carries the rewrite; valid while `_flushedAt` is the current
+     * clock (that flush advances it). */
+    _flushed: unknown;
+    _flushedAt: number;
+    /** Provenance (A18, #3331): the question this node's guess or latest
+     * flight answers (`scheduler.question`); 0 when unstamped. */
+    _q: number;
+    /** Lanes (plan sec. 28) — the lane's value for this node while CONFIG_OVERRIDE is
+     * set: a written guess, or a lane pass's derivation. `NOT_PENDING` when
+     * none. The screen shows it once the lane has revealed (`_shown`); a
+     * direct read sees it throughout; the committed truth stays `_value`. */
+    _lane: unknown;
+    /** `affects()` marks live on this node (affects.ts): declared in-flight
+     * changes — `isPending` reads true for it and its derivations while any
+     * is live. A count, never a hold. */
+    _marks: number;
+    /** D-41: the error a node showed when a re-ask made it pending — still
+     * the display (D-39) until a new answer commits: an untracked read throws
+     * it, `isPending` reads a staged answer as a change over it, and a
+     * recovery equal to the last good value is still a new answer. */
+    _shownError: unknown;
+    /** R5: the frame pass's flight of a `latest()`/`isPending()` reader the
+     * seam re-derived in the verdict lane (lanes.ts `laneSeams`) — the
+     * frame's answer to the question it asked, which the transaction's
+     * landing adopts instead of asking it again (lanes.ts `adoptParked`, F-9). Cleared
+     * by any later pass. */
+    _parked?: PromiseLike<any>;
 }
 export interface RawSignal<T> {
     _subs: Link | null;
     _subsTail: Link | null;
+    _value: T;
     /**
-     * DEV-only live subscriber count. Maintained by `link`/`unlinkSubs` for
-     * graph-size diagnostics; undefined in production.
+     * Observe-tier label (`name` option, or the node kind: `signal`,
+     * `computed`, `effect`…). A slot in the observe/dev literals — never a
+     * post-construction write — and absent from the prod literals entirely.
      */
-    _subCount?: number;
-    _value: T;
     _name?: string;
+    /**
+     * Observe-tier: the owner in scope when a user-facing signal was created
+     * (`registerGraph`), so diagnostics about the signal get an owner path.
+     * A slot in the observe/dev `signal()` literal; absent from prod.
+     */
+    _owner?: Owner | null;
     _equals: false | ((a: T, b: T) => boolean);
     _config: number;
     _time: number;
-    /** IN CORE, not the extension (stage-3 §12c): consulted on EVERY write
-     * (setSignal's transition-init check) and on recompute scheduling — the
-     * per-write extension chase measurably taxed propagation chains. */
-    _transition: Transition | null;
     /** Notify-epoch stamp of the last subscriber walk (§12d). A re-write to an
      * already-staged node whose stamp still equals the global epoch skips the
      * whole walk — marking is idempotent, and the epoch bumps on every
@@ -123,14 +155,12 @@ export interface RawSignal<T> {
     /** Cold extension — see NodeExtension. */
     _x: NodeExtension | null;
 }
-export interface FirewallSignal<T> extends RawSignal<T> {
-    _firewall: Computed<any>;
-    _nextChild: FirewallSignal<unknown> | null;
-}
-export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
+export type Signal<T> = RawSignal<T>;
 export interface Owner {
     id?: string;
     _config: number;
+    /** Lifecycle flags (REACTIVE_*); roots carry only REACTIVE_DISPOSED. */
+    _flags: number;
     _snapshotScope?: boolean;
     /** Effect-returned cleanup; managed across reruns, invoked at true disposal */
     _cleanup?: () => void;
@@ -138,21 +168,28 @@ export interface Owner {
     _parent: Owner | null;
     _context: Record<symbol | string, unknown>;
     _childCount: number;
-    _queue: IQueue;
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
     _prevSibling: Owner | null;
-    /** Cold extension — see NodeExtension (owners use the zombie-pair slots). */
+    /** Cold extension — see NodeExtension. */
     _x: NodeExtension | null;
+    /**
+     * Observe-tier label: the `name` option, the node kind (`computed`,
+     * `effect`…), or the component label the rendering layer writes on a root
+     * (`<App>`). A slot in the observe/dev literals; absent from prod.
+     */
+    _name?: string;
+    /**
+     * Observe-tier source location (`file:line:col`): the `loc` option, or
+     * the JSX site the rendering layer writes on a component root. A slot
+     * beside `_name`; absent from prod. Reserved from property mangling, like
+     * `_name`, because solid-js writes it and the core's diagnostics read it.
+     */
+    _loc?: string;
 }
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
-    /**
-     * DEV-only live source count. Maintained by `link`/`unlinkSubs` for
-     * graph-size diagnostics; undefined in production.
-     */
-    _depCount?: number;
     /** Recompute-pass counter; bumped when dep revalidation starts. */
     _depGen: number;
     _flags: number;
@@ -161,22 +198,11 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _nextHeap: Computed<any> | undefined;
     _prevHeap: Computed<any>;
     _fn: (prev?: T) => T;
-    /**
-     * Clock tick at which REACTIVE_MANUAL_WRITE was last applied
-     * (`suppressComputedRecompute`). Lets `refresh()` distinguish a same-tick
-     * manual write (which wins over the refresh, #2692) from a mask carried
-     * across ticks by a transaction (which an explicit refresh lifts, #3026).
-     * Only meaningful while REACTIVE_MANUAL_WRITE is set.
-     */
-    _manualWriteTime?: number;
     /**
      * True while a `loadingValue` node's first real answer hasn't landed: the
      * node was born committed (commit #0 = the loading value) and `handleAsync`
      * serves that committed value instead of throwing NotReadyError, so first
-     * flights never suspend readers, trip boundaries, or hold transitions.
-     * The window is verdict-quiet: `isPending` stays false, because commit #0
-     * answers the question by declaration (first-load affordances belong to
-     * the value channel). Cleared by the first value landing on any path (sync
+     * flights never suspend readers or trip boundaries. Cleared by the first value landing on any path (sync
      * return, sync-resolved promise, first iterator yield, async settle); a
      * real error leaves it set — errors answer reads but don't enter the value
      * lineage, so a retry serves the loading value again. Once cleared, normal

package/dist/types/core/verdict.d.ts

@@ -1,2 +1,37 @@
+/** The windows. `read` dispatches to `verdictValue` while one is open; each
+ * restores the dispatch it found — none inside a memo's pass a window
+ * pulled (`verdictValue`). */
 export declare function latest<T>(fn: () => T): T;
+/**
+ * Reports whether what `fn` reads is still waiting on an update. Read the
+ * values in question inside `fn`: the probe answers `true` while any of
+ * them depends on a change that is in flight — a write or an async source
+ * that has started producing a new value whose result has not landed yet —
+ * and `false` once the latest value is the one on screen. The answer is
+ * tracked like any read, so a memo or effect that calls `isPending` re-runs
+ * when it flips.
+ *
+ * A read that has no value yet is loading, not pending: inside `fn` it
+ * follows the surrounding `Loading` path like any other read, and the probe
+ * reports only updates to a value that already exists. A bare `refresh()`
+ * does not flip `isPending`; pair it with `affects()` to make the re-ask
+ * visible.
+ *
+ * @param fn expression to probe; read the values in question inside it
+ *
+ * @returns `true` while a read inside `fn` depends on a change that has not committed yet
+ *
+ * @example
+ * ```ts
+ * const [query, setQuery] = createSignal("");
+ * const results = createMemo(() => searchProducts(query()));
+ * const stale = createMemo(() => isPending(results));
+ *
+ * setQuery("shoes");
+ * // stale() is true until the new results land, while results() keeps
+ * // serving the previous list — dim it instead of showing a spinner.
+ * ```
+ *
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/is-pending
+ */
 export declare function isPending(fn: () => any): boolean;

package/dist/types/deferred.d.ts

@@ -0,0 +1,28 @@
+import { type MemoOptions, type SourceAccessor } from "./signals.js";
+/**
+ * Creates an async memo that may lag, but never leads. Before its first
+ * answer it is an ordinary async memo: readers suspend to the nearest
+ * `<Loading>`. After it, a refetch holds nothing: readers keep the last
+ * committed value until the new one lands, and the rest of the screen moves
+ * on without it. `isPending` reports the refetch, on the node and on what
+ * derives from it. Use it for independent widgets (dashboards, feeds,
+ * search results) where the previous answer with a "refreshing" indicator is
+ * better than waiting with everything else.
+ *
+ * - It never shows a value ahead of a held change: a refetch that read a
+ *   held value lands with that hold.
+ * - A rejected refetch errors like any memo; the stale value never masks it.
+ * - `refresh(d)` is a quiet re-ask, and `await refresh(d)` and `until`
+ *   wait for the landing rather than the stale value.
+ * - Combine with `loadingValue` for a node that never suspends at all.
+ *
+ * @example
+ * ```tsx
+ * const rows = createDeferred(() => fetchRows(store.period));
+ *
+ * <section class={{ stale: isPending(() => rows()) }}>
+ *   <For each={rows()}>{row => <Row row={row} />}</For>
+ * </section>
+ * ```
+ */
+export declare function createDeferred<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: MemoOptions<T>): SourceAccessor<T>;

package/dist/types/flatten.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolves nested accessors and arrays in a children tree to their rendered
+ * values. See the `children()` helper in solid-js for the memoized form.
+ */
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;

package/dist/types/from.d.ts

@@ -0,0 +1,47 @@
+/** The observer a `subscribe` call receives. */
+type FromObserver<T> = {
+    next(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+};
+type Teardown = (() => void) | {
+    unsubscribe(): void;
+} | void;
+/**
+ * Anything `from` accepts: a subscribe function
+ * (`(next, error, complete) => unsubscribe`), an object with
+ * `subscribe(observer)` (RxJS and TC39 Observables, including
+ * `Symbol.observable` / `"@@observable"` interop), or an AsyncIterable.
+ */
+export type FromSource<T> = ((next: (value: T) => void, error: (err: unknown) => void, complete: () => void) => Teardown) | {
+    subscribe(observer: FromObserver<T>): Teardown;
+} | AsyncIterable<T>;
+/**
+ * Converts a callback subscription, an Observable or an AsyncIterable into an
+ * AsyncIterable for a Solid computation. A subscription keeps only the latest
+ * value, and a value the source emits during `subscribe` is served without a
+ * loading frame; an AsyncIterable streams every value through.
+ *
+ * The source closes on supersede — the owning computation re-running — and
+ * on owner disposal. Inside an async generator memo that holds for a
+ * `for await` that starts before the first `await`; one that starts after it
+ * has no owner to bind to, so its source closes only when the loop ends.
+ * Prefer returning `from(...)` from its own memo, with awaited inputs read
+ * from upstream memos and transforms done in a downstream memo.
+ *
+ * Iterate the result with `for await` or return it from a computation: its
+ * `next()` returns an already-buffered value as a bare result, not a promise.
+ *
+ * @example
+ * ```ts
+ * const position = createMemo(() =>
+ *   from<Position>((next, error) => {
+ *     const id = navigator.geolocation.watchPosition(next, error);
+ *     return () => navigator.geolocation.clearWatch(id);
+ *   })
+ * );
+ * const ticks = createMemo(() => from(interval$(rate())));
+ * ```
+ */
+export declare function from<T>(source: FromSource<T>): AsyncIterable<T>;
+export {};

package/dist/types/index.d.ts

@@ -1,10 +1,36 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.js";
-import { type Dev } from "./core/index.js";
+export { $REFRESH, action, ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt, configureClientErrors, ROOT_ERROR_HOOK } from "./core/index.js";
+/**
+ * @internal The dev console footer seam — registered by `solid-js`, which
+ * owns the repair skill the footer points at. Not part of `DEV`; a no-op
+ * outside dev builds.
+ */
+export { setConsoleFooter } from "./core/index.js";
+/** @internal The flush round counter (scheduler.ts): hydration's served pass tells its own round from a later one. */
+export { clock } from "./core/index.js";
+/** @internal Dev duplicate-copy check: solid-js marks components and context reads. */
+export { runAsSolidCopy, checkForeignOwnerless } from "./core/copies.js";
+/** @internal The pre-write hook (`setWriteHook` in core/core.ts); the server-components client's deferred hydration. */
+/** @internal Plain-signal identities and the dev read watch (dependency edges; the server-components client). */
+export { setWriteHook, setSignalIdentities, setReadWatch, signalName } from "./core/index.js";
+/** @internal Store dependency edges: the name a store proxy's writes go by (the server-components client). */
+export { storeName } from "./store/edges.js";
+import { type Dev, type Observe } from "./core/index.js";
+/**
+ * Observe tier (diagnostics channel, attribution hook slot + interaction
+ * frame): dev and observe builds. The attribution engine itself is the
+ * `@solidjs/signals/attribution` entry.
+ */
+export declare const OBSERVE: Observe | undefined;
+/** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */
 export declare const DEV: Dev | undefined;
-export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.js";
-export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled, onCleanup } from "./signals.js";
-export type { Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
-export { affects } from "./affects.js";
+export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionSlot, ClientErrorContext, ClientErrorHook, ClientErrorsConfig, InteractionRef, NavigationRef, Dev, Observe, ServerObserve, Records, RecordTypes, HostRecordTypes, RecordType, RecordEvent, RecordLive, RecordListener, RecordSubscribeOptions, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.js";
+export { createSignal, createOptimistic, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, refresh, resolve, until, onSettled, onFlush, onCleanup } from "./signals.js";
+export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
-export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.js";
+export { affects } from "./affects.js";
+export { createDeferred } from "./deferred.js";
+export { from, type FromSource } from "./from.js";
+export { flatten } from "./flatten.js";
+export { createLoadingBoundary, createErrorBoundary } from "./boundaries.js";
+export { createRevealOrder, type RevealOrder } from "./reveal.js";

package/dist/types/map.d.ts

@@ -30,7 +30,7 @@ export type Maybe<T> = T | void | null | undefined | false;
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/jsx-component-primitives/map-array
  */
 export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
     keyed?: true;
@@ -47,6 +47,8 @@ export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly
     fallback?: Accessor<any>;
     name?: string;
 }): Accessor<MappedItem[]>;
+/** @internal */
+export declare function __smallMoveHits(): number;
 /**
  * Reactively renders a callback `count` times, reusing previously-rendered
  * entries when only the count changes. Underlying helper for `<Repeat>`.
@@ -60,7 +62,7 @@ export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly
  * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/jsx-component-primitives/repeat
  */
 export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
     from?: Accessor<number | undefined>;

package/dist/types/reveal.d.ts

@@ -0,0 +1,19 @@
+export type RevealOrder = "sequential" | "together" | "natural";
+type OrderAccessor = () => RevealOrder;
+type BoolAccessor = () => boolean;
+/**
+ * Lower-level primitive behind `<Reveal>`: coordinates the order in which the
+ * Loading boundaries created directly inside `fn` reveal their content.
+ *
+ * @param fn the subtree; the Loading boundaries it creates directly are the
+ *   group's slots, a nested `createRevealOrder` a composite slot
+ * @param options `order` — `"sequential"` (default: front to back, the
+ *   first unready slot showing its fallback), `"together"` (all at once),
+ *   `"natural"` (each on its own); `collapsed` — in a sequential group, the
+ *   slots behind the frontier render nothing instead of their fallbacks
+ */
+export declare function createRevealOrder<T>(fn: () => T, options?: {
+    order?: OrderAccessor;
+    collapsed?: BoolAccessor;
+}): T;
+export {};