@solidjs/signals 2.0.0-beta.7 → 2.0.0-beta.9

package/dist/types/boundaries.d.ts

@@ -5,18 +5,29 @@ export interface BoundaryComputed<T> extends Computed<T> {
 }
 type RevealSlot = CollectionQueue | RevealController;
 type BoolAccessor = () => boolean;
+export type RevealOrder = "sequential" | "together" | "natural";
+type OrderAccessor = () => RevealOrder;
 export declare class RevealController {
-    _togetherAccessor: BoolAccessor;
+    _orderAccessor: OrderAccessor;
     _collapsedAccessor: BoolAccessor;
     _slots: RevealSlot[];
     _parentController?: RevealController;
     _disabled: Signal<boolean>;
     _collapsed: Signal<boolean>;
     _ready: boolean;
+    _minimallyReady: boolean;
     _evaluating: boolean;
-    constructor(together: BoolAccessor, collapsed: BoolAccessor);
+    constructor(order: OrderAccessor, collapsed: BoolAccessor);
     _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
     isReady(): boolean;
+    /**
+     * "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`: fully ready (atomic).
+     * - `sequential`: the first owned slot is minimally ready (frontier can advance).
+     * - `natural`: any owned slot is minimally ready.
+     */
+    isMinimallyReady(): boolean;
     register(slot: RevealSlot): void;
     unregister(slot: RevealSlot): void;
     evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
@@ -37,14 +48,79 @@ export declare class CollectionQueue extends Queue {
     notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
     checkSources(): void;
 }
+/**
+ * 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
+ */
 export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
     on?: () => any;
 }): import("./signals.js").Accessor<unknown>;
+/**
+ * Lower-level primitive that backs the `<Errored>` flow control. Catches
+ * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
+ * `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.
+ */
 export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.js").Accessor<unknown>;
+/**
+ * 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 when fully ready, since natural treats composites as atomic).
+ */
 export declare function createRevealOrder<T>(fn: () => T, options?: {
-    together?: BoolAccessor;
+    order?: OrderAccessor;
     collapsed?: BoolAccessor;
 }): 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)
+ */
 export declare function flatten(children: any, options?: {
     skipNonRendered?: boolean;
     doNotUnwrap?: boolean;

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

@@ -1 +1,35 @@
+/**
+ * Wraps a generator function so each invocation runs as a single transaction
+ * (a "transition") that batches every signal/store write between yields. The
+ * surrounding UI sees one atomic update per yielded step; nothing is committed
+ * until the action either completes or the next `yield` resolves.
+ *
+ * Yield promises (or any awaitable) inside the generator — the action waits
+ * for each before continuing, but the writes you made beforehand are already
+ * visible (or held by `<Loading>` if optimistic). Yield bare values for
+ * synchronous batched steps.
+ *
+ * Each call returns a `Promise` that resolves with the generator's return
+ * value, or rejects if it throws. Pair with `createOptimistic` /
+ * `createOptimisticStore` to apply tentative writes that auto-revert if the
+ * action fails.
+ *
+ * @example
+ * ```ts
+ * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
+ *
+ * const addTodo = action(function* (text: string) {
+ *   const tempId = crypto.randomUUID();
+ *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
+ *   const saved = yield api.createTodo(text); // network round-trip
+ *   setTodos(t => {
+ *     const i = t.findIndex(x => x.id === tempId);
+ *     if (i >= 0) t[i] = saved;
+ *   });
+ *   return saved;
+ * });
+ *
+ * await addTodo("buy milk");
+ * ```
+ */
 export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => Promise<R>;

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

@@ -9,6 +9,12 @@ export declare const REACTIVE_DISPOSED: number;
 export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
 export declare const REACTIVE_SNAPSHOT_STALE: number;
 export declare const REACTIVE_LAZY: number;
+export declare const CONFIG_OWNED_WRITE: number;
+export declare const CONFIG_NO_SNAPSHOT: number;
+export declare const CONFIG_TRANSPARENT: number;
+export declare const CONFIG_IN_SNAPSHOT_SCOPE: number;
+export declare const CONFIG_CHILDREN_FORBIDDEN: number;
+export declare const CONFIG_AUTO_DISPOSE: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
@@ -23,3 +29,14 @@ export declare const STORE_SNAPSHOT_PROPS = "sp";
 export declare const SUPPORTS_PROXY: boolean;
 export declare const defaultContext: {};
 export declare const $REFRESH: unique symbol;
+/**
+ * Brand applied to derived/projected stores indicating they participate in
+ * the `refresh()` re-run protocol. Use this alias instead of inlining
+ * `T & { [$REFRESH]: any }` so that user-defined hooks that wrap
+ * `createOptimisticStore` / `createProjection` / projection-form
+ * `createStore` can have their return types inferred without leaking the
+ * internal `$REFRESH` symbol into public type signatures (TS4058).
+ */
+export type Refreshable<T> = T & {
+    readonly [$REFRESH]: any;
+};

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

@@ -1,6 +1,7 @@
-import { $REFRESH } from "./constants.js";
+import { type Refreshable } from "./constants.js";
 import { type OptimisticLane } from "./lanes.js";
 import type { Computed, FirewallSignal, NodeOptions, Owner, Signal } from "./types.js";
+export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
 export declare let tracking: boolean;
 export declare let stale: boolean;
 export declare let refreshing: boolean;
@@ -17,11 +18,11 @@ export declare function releaseSnapshotScope(owner: Owner): void;
 export declare function clearSnapshots(): void;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
 export declare function computed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>): Computed<T>;
-export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: NodeOptions<T>): Computed<T>;
+export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
 export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
-export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: NodeOptions<T>): Computed<T>;
+export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
 /**
  * When set to a component name string, any reactive read that is not inside a nested tracking
@@ -30,14 +31,49 @@ export declare function isEqual<T>(a: T, b: T): boolean;
 export declare let strictRead: string | false;
 export declare function setStrictRead(v: string | false): string | false;
 /**
- * Executes `fn` without tracking reactive dependencies.
+ * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
+ * subscribe the current scope. Returns whatever `fn` returns.
  *
- * Pass a `strictReadLabel` string to enable strict-read warnings: any reactive read inside `fn`
- * that is not inside a nested tracking scope will log a warning in dev mode.
+ * Use `untrack` inside a memo or effect when you need to read a signal once
+ * without making the surrounding computation depend on its future changes.
+ *
+ * Pass a `strictReadLabel` string to enable a dev-mode warning: any reactive
+ * read inside `fn` that isn't inside a nested tracking scope will log a
+ * warning naming the label.
+ *
+ * @example
+ * ```ts
+ * createEffect(
+ *   () => trigger(),                 // tracks `trigger` only
+ *   () => {
+ *     const snapshot = untrack(() => state); // read once, untracked
+ *     log(snapshot);
+ *   }
+ * );
+ * ```
  */
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
+/**
+ * Executes `fn` with the given `owner` set as the current owner. Any reactive
+ * primitives (`createSignal`, `createMemo`, `createEffect`, `onCleanup`,
+ * `cleanup`, etc.) created inside `fn` are attached to that owner, so they
+ * are disposed when the owner is disposed.
+ *
+ * The classic pattern: capture the current owner with `getOwner()` inside a
+ * component, then re-enter it from a callback (event handler, async resolve,
+ * setTimeout) so disposables created in the callback get cleaned up with the
+ * component.
+ *
+ * @example
+ * ```ts
+ * function delayed<T>(ms: number, fn: () => T) {
+ *   const owner = getOwner();
+ *   setTimeout(() => runWithOwner(owner, fn), ms);
+ * }
+ * ```
+ */
 export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
 /**
  * Update _pendingSignal when pending state changes. When the override clears
@@ -46,9 +82,72 @@ export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
  */
 export declare function updatePendingSignal(el: Signal<any> | Computed<any>): void;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
+/**
+ * Reads reactive expressions while bypassing any pending async overlay — i.e.
+ * always returns the most-recently-committed value, even when newer reads
+ * inside `fn` are still in flight.
+ *
+ * Useful inside a `<Loading>` boundary's children when you want to keep
+ * showing the previous resolved data instead of the fallback while the next
+ * value loads.
+ *
+ * @example
+ * ```tsx
+ * <Loading fallback={<Skeleton />}>
+ *   {/* During a transition, render the previous user instead of skeleton: *\/}
+ *   <UserCard user={latest(() => user())} />
+ * </Loading>
+ * ```
+ */
 export declare function latest<T>(fn: () => T): T;
+/**
+ * Returns `true` if any reactive read inside `fn` is currently in a pending
+ * (async, not-yet-settled) state. Does not subscribe — pair with a tracked
+ * memo if you want to react to pending status changes.
+ *
+ * Useful for showing inline transition indicators alongside the previous
+ * value (rather than swapping to a `<Loading>` fallback).
+ *
+ * @example
+ * ```tsx
+ * const pending = createMemo(() => isPending(() => user()));
+ *
+ * <button disabled={pending()}>{pending() ? "Saving…" : "Save"}</button>
+ * ```
+ */
 export declare function isPending(fn: () => any): boolean;
-export declare function refresh<T>(fn: (() => T) | (T & {
-    [$REFRESH]: any;
-})): T;
+/**
+ * Forces a reactive source to re-execute, even if its inputs haven't changed.
+ *
+ * Two forms:
+ * - `refresh(memo)` — pass an accessor (memo / signal getter) and its
+ *   underlying computation reruns.
+ * - `refresh(store)` — pass a *projected* store created from
+ *   `createStore(fn, ...)` or `createProjection(...)` and the projection
+ *   recomputes.
+ *
+ * Use it to invalidate cached async values (e.g. force a re-fetch) without
+ * tearing the consumer down.
+ *
+ * @example
+ * ```ts
+ * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
+ *
+ * // Re-fetch on demand
+ * <button onClick={() => refresh(user)}>Reload</button>
+ * ```
+ */
+export declare function refresh<T>(fn: (() => T) | Refreshable<T>): T;
+/**
+ * Returns `true` while a `refresh()` call is in progress. Useful for showing
+ * a "refreshing" indicator distinct from the initial-load `<Loading>`
+ * fallback.
+ *
+ * @example
+ * ```tsx
+ * <Show when={isRefreshing()}>
+ *   <span class="badge">refreshing…</span>
+ * </Show>
+ * ```
+ */
 export declare function isRefreshing(): boolean;

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

@@ -6,7 +6,7 @@ export interface DevHooks {
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
 export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "SIGNAL_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "SIGNAL_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "MISSING_EFFECT_FN";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner";
 export interface DiagnosticEvent {
     sequence: number;

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

@@ -12,9 +12,10 @@ export interface Effect<T> extends Computed<T>, Owner {
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
  */
-export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), initialValue?: T, options?: NodeOptions<any> & {
-    render?: boolean;
+export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), options?: NodeOptions<any> & {
+    user?: boolean;
     defer?: boolean;
+    schedule?: boolean;
 }): void;
 export interface TrackedEffect extends Computed<void> {
     _cleanup?: () => void;

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

@@ -4,19 +4,70 @@ export declare function dispose(node: Computed<unknown>): void;
 export declare function disposeChildren(node: Owner, self?: boolean, zombie?: boolean): void;
 export declare function getNextChildId(owner: Owner): string;
 export declare function peekNextChildId(owner: Owner): string;
+/**
+ * Returns the currently-tracking observer (the computation that subscribes to
+ * reactive reads at this point), or `null` if reads here would be untracked.
+ * Used by reactive primitives that need to know whether they're inside a
+ * tracking scope. App code rarely needs this — see `getOwner()` for the
+ * lifecycle owner instead.
+ */
 export declare function getObserver(): Owner | null;
+/**
+ * Returns the current reactive **owner** — the lifecycle node that the next
+ * `cleanup()` / `onCleanup()` / `createSignal()` etc. will be attached to.
+ *
+ * Returns `null` if called outside any owner. Capture the owner with
+ * `getOwner()` and re-enter it later with `runWithOwner(owner, fn)` to attach
+ * disposables created from a callback (event handler, async resolution, etc.)
+ * back to a component's lifecycle.
+ *
+ * @example
+ * ```ts
+ * function defer<T>(fn: () => T) {
+ *   const owner = getOwner();
+ *   queueMicrotask(() => runWithOwner(owner, fn));
+ * }
+ * ```
+ */
 export declare function getOwner(): Owner | null;
+/**
+ * Low-level: registers `fn` as a disposal callback on the current owner.
+ * Most code should use `onCleanup()` from `solid-js`, which adds dev-mode
+ * checks. `cleanup()` is the unchecked primitive used by internals.
+ */
 export declare function cleanup(fn: Disposable): Disposable;
+/** Returns `true` if the owner has been disposed (or marked zombie pending disposal). */
 export declare function isDisposed(node: Owner): boolean;
+/**
+ * Creates a fresh owner attached as a child of the current owner (or as a
+ * detached root if there is none). Mostly used by framework internals to
+ * group cleanups; app code should prefer `createRoot()` or `runWithOwner()`.
+ */
 export declare function createOwner(options?: {
     id?: string;
     transparent?: boolean;
 }): Root;
 /**
- * Creates a new non-tracked reactive context with manual disposal
+ * Creates a detached reactive root. The callback receives a `dispose()`
+ * function which, when called, tears down every signal, memo, effect, and
+ * `onCleanup` registered inside the root.
+ *
+ * Use this to host long-lived reactive scopes outside of a component (custom
+ * controllers, app bootstrapping, tests). Inside a component, prefer
+ * letting Solid's component lifecycle own things.
+ *
+ * @example
+ * ```ts
+ * const dispose = createRoot(dispose => {
+ *   const [n, setN] = createSignal(0);
+ *   createEffect(() => n(), value => console.log(value));
+ *   setInterval(() => setN(x => x + 1), 1000);
+ *   return dispose;
+ * });
  *
- * @param fn a function in which the reactive state is scoped
- * @returns the output of `fn`.
+ * // Later, to tear everything down:
+ * dispose();
+ * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
  */

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

@@ -9,6 +9,7 @@ export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
 export declare let _hitUnhandledAsync: boolean;
+export declare function registerTransientStoreNode(node: Signal<any>): void;
 export declare function resetUnhandledAsync(): void;
 export declare function enforceLoadingBoundary(enabled: boolean): void;
 export declare function shouldReadStashedOptimisticValue(node: Signal<any>): boolean;
@@ -29,6 +30,7 @@ export interface Transition {
     _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
     _queueStash: QueueStub;
     _done: boolean | Transition;
+    _gatedSubs: Set<Computed<any>>;
 }
 export declare function schedule(): void;
 export interface IQueue {
@@ -72,8 +74,23 @@ export declare function finalizePureQueue(completingTransition?: Transition | nu
 export declare function trackOptimisticStore(store: any): void;
 export declare const globalQueue: GlobalQueue;
 /**
- * By default, changes are batched on the microtask queue which is an async process. You can flush
- * the queue synchronously to get the latest updates by calling `flush()`.
+ * Synchronously processes the pending reactive queue: runs every scheduled
+ * memo/effect/computation that has dirty inputs, until the graph is settled.
+ *
+ * Reactive updates are normally batched onto the microtask queue, so multiple
+ * writes in a row collapse into a single update pass. Call `flush()` when you
+ * need to *observe* the result of those writes synchronously — most commonly
+ * in tests, but also at the boundary of imperative integration code.
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ * const doubled = createMemo(() => count() * 2);
+ *
+ * setCount(5);
+ * flush();
+ * expect(doubled()).toBe(10);
+ * ```
  */
 export declare function flush(): void;
 export declare function currentTransition(transition: Transition): Transition;

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

@@ -29,8 +29,7 @@ export interface RawSignal<T> {
     _snapshotValue?: any;
     _name?: string;
     _equals: false | ((a: T, b: T) => boolean);
-    _ownedWrite?: boolean;
-    _noSnapshot?: boolean;
+    _config: number;
     _unobserved?: () => void;
     _time: number;
     _transition: Transition | null;
@@ -48,8 +47,7 @@ export interface FirewallSignal<T> extends RawSignal<T> {
 export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
 export interface Owner {
     id?: string;
-    _transparent?: boolean;
-    _childrenForbidden?: boolean;
+    _config: number;
     _snapshotScope?: boolean;
     _disposal: Disposable | Disposable[] | null;
     _parent: Owner | null;
@@ -65,7 +63,6 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
     _flags: number;
-    _inSnapshotScope?: boolean;
     _blocked?: boolean;
     _pendingSource?: Computed<any>;
     _pendingSources?: Set<Computed<any>>;

package/dist/types/index.d.ts

@@ -1,9 +1,9 @@
 export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, isRefreshing, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource } from "./core/index.js";
 import { type Dev } from "./core/index.js";
 export declare const DEV: Dev | undefined;
-export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.js";
+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, 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 } from "./boundaries.js";
+export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.js";

package/dist/types/map.d.ts

@@ -1,9 +1,28 @@
 import { type Accessor } from "./signals.js";
 export type Maybe<T> = T | void | null | undefined | false;
 /**
- * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
+ * Reactively maps an array, reusing the previously-mapped value for unchanged
+ * items. The callback receives `(value, index)` as accessors so individual
+ * items and indexes can be subscribed to without re-running the mapper.
  *
- * similar to `Array.prototype.map`, but gets the value and index as accessors, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
+ * This is the underlying helper that powers `<For>`. App code should use
+ * `<For>` directly; reach for `mapArray` when implementing custom list
+ * components.
+ *
+ * - `options.keyed` — `true` (default for primitives) compares by identity;
+ *   `false` falls back to index-only mapping; pass a function `(item) => key`
+ *   for stable identity by extracted key.
+ * - `options.fallback` — accessor returning a value to show when the input is
+ *   empty.
+ *
+ * @example
+ * ```ts
+ * const view = mapArray(
+ *   items,
+ *   (item, index) => `${index()}: ${item().label}`,
+ *   { fallback: () => "no items" }
+ * );
+ * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
  */
@@ -13,7 +32,17 @@ export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly
     name?: string;
 }): Accessor<MappedItem[]>;
 /**
- * Reactively repeats a callback function the count provided - underlying helper for the `<Repeat>` control flow
+ * Reactively renders a callback `count` times, reusing previously-rendered
+ * entries when only the count changes. Underlying helper for `<Repeat>`.
+ *
+ * - `options.from` — start index (default `0`); useful for offset/windowed
+ *   rendering.
+ * - `options.fallback` — accessor returning a value to show when count is `0`.
+ *
+ * @example
+ * ```ts
+ * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
+ * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
  */