@solidjs/signals 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/types/boundaries.d.ts

@@ -73,7 +73,7 @@ export declare class CollectionQueue extends Queue {
  */
 export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
     on?: () => any;
-}): import("./signals.js").Accessor<unknown>;
+}): import("./signals.js").SourceAccessor<unknown>;
 /**
  * Lower-level primitive that backs the `<Errored>` flow control. Catches
  * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
@@ -97,7 +97,7 @@ export declare function createLoadingBoundary(fn: () => any, fallback: () => any
  * }
  * ```
  */
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.js").Accessor<unknown>;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.js").SourceAccessor<unknown>;
 /**
  * Coordinate the reveal timing of sibling loading boundaries.
  *

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

@@ -9,12 +9,14 @@ 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 REACTIVE_MANUAL_WRITE: 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 CONFIG_SYNC: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
@@ -37,12 +39,12 @@ 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).
+ * Brand applied to values that participate in the `refresh()` re-run protocol.
+ * Accessors receive this handle internally; projected stores expose it through
+ * their public return type so 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

@@ -19,6 +19,13 @@ 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>, options?: NodeOptions<T>): Computed<T>;
+/**
+ * Build an Effect node with all effect-specific fields baked into a single object literal,
+ * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
+ * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
+ * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
+ */
+export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, notifyStatus: ((status?: number, error?: any) => void) | undefined, options: NodeOptions<T> | undefined): any;
 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>;
@@ -55,6 +62,21 @@ export declare function setStrictRead(v: string | false): string | false;
 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;
+/**
+ * Suppresses automatic recomputation of `el` until the scheduler drains. Used
+ * when a manual write should win over dependency changes queued in the same
+ * tick. The MANUAL_WRITE flag is cleared by the pending-node drain; projection
+ * computeds don't commit values, but they still need the same end-of-tick
+ * cleanup point.
+ */
+export declare function suppressComputedRecompute(el: Computed<unknown>): void;
+/**
+ * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
+ * `setSignal`, but also cancels any pending recompute of the memo so the
+ * manual value wins over a value that would otherwise be produced by an
+ * upstream change in the same tick.
+ */
+export declare function setMemo<T>(el: 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`,
@@ -117,14 +139,13 @@ export declare function latest<T>(fn: () => T): T;
  */
 export declare function isPending(fn: () => any): boolean;
 /**
- * Forces a reactive source to re-execute, even if its inputs haven't changed.
+ * Invalidates one reactive source, forcing it 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.
+ * Pass either a Solid-created accessor or a projected store created from
+ * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
+ * write-like invalidation operation: it does not read the target's value, and
+ * refreshing a plain signal accessor is a no-op.
  *
  * Use it to invalidate cached async values (e.g. force a re-fetch) without
  * tearing the consumer down.
@@ -137,7 +158,7 @@ export declare function isPending(fn: () => any): boolean;
  * <button onClick={() => refresh(user)}>Reload</button>
  * ```
  */
-export declare function refresh<T>(fn: (() => T) | Refreshable<T>): T;
+export declare function refresh<T>(target: Refreshable<T>): void;
 /**
  * Returns `true` while a `refresh()` call is in progress. Useful for showing
  * a "refreshing" indicator distinct from the initial-load `<Loading>`

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" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "MISSING_EFFECT_FN";
+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" | "INVALID_REFRESH_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner";
 export interface DiagnosticEvent {
     sequence: number;

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

@@ -3,6 +3,7 @@ export interface Effect<T> extends Computed<T>, Owner {
     _effectFn: (val: T, prev: T | undefined) => void | (() => void);
     _errorFn?: (err: unknown, cleanup: () => void) => void;
     _cleanup?: () => void;
+    _cleanupRegistered?: boolean;
     _modified: boolean;
     _prevValue: T | undefined;
     _type: number;

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

@@ -1,4 +1,5 @@
 import type { Computed, Link, Signal } from "./types.js";
 export declare function unlinkSubs(link: Link): Link | null;
+export declare function trimStaleDeps(el: Computed<any>): void;
 export declare function unobserved(el: Computed<unknown>): void;
 export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;

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

@@ -1,5 +1,5 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, optimisticSignal, optimisticComputed, isPending, latest, refresh, isRefreshing, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, isPending, latest, refresh, isRefreshing, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
 export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.js";
 export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";

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

@@ -67,28 +67,33 @@ export declare class Queue implements IQueue {
 }
 export declare class GlobalQueue extends Queue {
     _running: boolean;
+    _pendingNode: Signal<any> | null;
     _pendingNodes: Signal<any>[];
     _optimisticNodes: OptimisticNode[];
     _optimisticStores: Set<any>;
     static _update: (el: Computed<unknown>) => void;
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
+    static _runEffect: (el: Computed<unknown>) => void;
     static _clearOptimisticStore: ((store: any) => void) | null;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
     initTransition(transition?: Transition | null): void;
 }
+export declare function queuePendingNode(node: Signal<any>): void;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
 export declare function trackOptimisticStore(store: any): void;
 export declare const globalQueue: GlobalQueue;
 /**
- * Synchronously processes the pending reactive queue: runs every scheduled
- * memo/effect/computation that has dirty inputs, until the graph is settled.
+ * Synchronously processes the pending reactive queue, or runs `fn` in a synchronous
+ * flush scope before draining the queue.
  *
  * 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.
+ * in tests, but also at the boundary of imperative integration code. Pass a
+ * callback when the writes themselves should bypass microtask scheduling and
+ * drain synchronously when the callback returns.
  *
  * @example
  * ```ts
@@ -98,9 +103,20 @@ export declare const globalQueue: GlobalQueue;
  * setCount(5);
  * flush();
  * expect(doubled()).toBe(10);
+ *
+ * flush(() => setCount(6));
+ * expect(doubled()).toBe(12);
+ *
+ * // Nested flushes drain at each level:
+ * flush(() => {
+ *   setCount(7);
+ *   flush(() => setCount(8)); // inner drain — effects fire here
+ *   // outer continues with up-to-date state
+ * });
  * ```
  */
 export declare function flush(): void;
+export declare function flush<T>(fn: () => T): T;
 export declare function currentTransition(transition: Transition): Transition;
 export declare function setActiveTransition(transition: Transition | null): void;
 export declare function runInTransition<T>(transition: Transition, fn: () => T): T;

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

@@ -21,6 +21,7 @@ export interface NodeOptions<T> {
     _noSnapshot?: boolean;
     unobserved?: () => void;
     lazy?: boolean;
+    sync?: boolean;
 }
 export interface RawSignal<T> {
     _subs: Link | null;
@@ -56,6 +57,7 @@ export interface Owner {
     _queue: IQueue;
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
+    _prevSibling: Owner | null;
     _pendingDisposal: Disposable | Disposable[] | null;
     _pendingFirstChild: Owner | null;
 }

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@ import { type Dev } from "./core/index.js";
 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, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
+export type { 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";

package/dist/types/map.d.ts

@@ -2,8 +2,14 @@ import { type Accessor } from "./signals.js";
 export type Maybe<T> = T | void | null | undefined | false;
 /**
  * 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.
+ * items.
+ *
+ * The callback shape follows the keying mode:
+ * - default / `keyed: true` receives `(item, index)` where `item` is the raw
+ *   row value and `index` is an accessor.
+ * - `keyed: false` receives `(item, index)` where `item` is an accessor and
+ *   `index` is a stable number.
+ * - `keyed: item => key` receives accessors for both arguments.
  *
  * This is the underlying helper that powers `<For>`. App code should use
  * `<For>` directly; reach for `mapArray` when implementing custom list
@@ -19,15 +25,25 @@ export type Maybe<T> = T | void | null | undefined | false;
  * ```ts
  * const view = mapArray(
  *   items,
- *   (item, index) => `${index()}: ${item().label}`,
+ *   (item, index) => `${index()}: ${item.label}`,
  *   { fallback: () => "no items" }
  * );
  * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
  */
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
-    keyed?: boolean | ((item: Item) => any);
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
+    keyed?: true;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: number) => MappedItem, options: {
+    keyed: false;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options: {
+    keyed: (item: Item) => any;
     fallback?: Accessor<any>;
     name?: string;
 }): Accessor<MappedItem[]>;

package/dist/types/signals.d.ts

@@ -1,4 +1,4 @@
-import type { Disposable } from "./core/index.js";
+import type { Disposable, Refreshable } from "./core/index.js";
 /**
  * Low-level reactive-cleanup primitive. Registers a callback that runs when
  * the surrounding owner is disposed.
@@ -47,7 +47,8 @@ export declare function onCleanup(fn: Disposable): Disposable;
  * creating a subscription.
  */
 export type Accessor<T> = () => T;
-export declare function accessor<T>(node: any): Accessor<T>;
+export type SourceAccessor<T> = Refreshable<Accessor<T>>;
+export declare function accessor<T>(node: any): SourceAccessor<T>;
 /**
  * A signal setter. Accepts either a new value or an updater `(prev) => next`.
  *
@@ -63,7 +64,7 @@ export type Setter<in out T> = {
     <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
 };
 /** A `[get, set]` pair returned from `createSignal` / `createOptimistic`. */
-export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
+export type Signal<T> = [get: SourceAccessor<T>, set: Setter<T>];
 export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => PromiseLike<Next> | AsyncIterable<Next> | Next;
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
 export type EffectBundle<Prev, Next extends Prev = Prev> = {
@@ -89,6 +90,16 @@ export interface EffectOptions extends BaseEffectOptions {
      * `insert()` in `render()`).
      */
     schedule?: boolean;
+    /**
+     * Advanced. When true, asserts the compute function returns synchronous
+     * values only (never `PromiseLike` / `AsyncIterable`). Skips the
+     * async-shape probe in `recompute` for a small fixed-cost win per run.
+     * Intended for compiler emissions (`_$effect`) and library code that
+     * provably returns sync values. Returning a Promise or async iterable
+     * from a `sync: true` effect is undefined behavior — the value will be
+     * stored as-is and never awaited.
+     */
+    sync?: boolean;
 }
 /** Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`. */
 export interface SignalOptions<T> {
@@ -136,6 +147,16 @@ export interface MemoOptions<T> {
      * never autodispose.
      */
     lazy?: boolean;
+    /**
+     * Advanced. When true, asserts the compute function returns synchronous
+     * values only (never `PromiseLike` / `AsyncIterable`). Skips the
+     * async-shape probe in `recompute` for a small fixed-cost win per run.
+     * Intended for compiler emissions (`_$memo`) and library code that
+     * provably returns sync values. Returning a Promise or async iterable
+     * from a `sync: true` memo is undefined behavior — the value will be
+     * stored as-is and never awaited.
+     */
+    sync?: boolean;
 }
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 /**
@@ -207,7 +228,7 @@ export declare function createSignal<T>(fn: ComputeFunction<T>, options?: Signal
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
  */
-export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<T>): Accessor<T>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<T>): SourceAccessor<T>;
 /**
  * Creates a reactive effect with **separate compute and effect phases**.
  *

package/dist/types/src/boundaries.d.ts

@@ -0,0 +1,173 @@
+import { Queue, type Computed, type Effect } from "./core/index.js";
+import type { Signal } from "./core/index.js";
+export interface BoundaryComputed<T> extends Computed<T> {
+    _propagationMask: number;
+}
+type RevealSlot = CollectionQueue | RevealController;
+type BoolAccessor = () => boolean;
+export type RevealOrder = "sequential" | "together" | "natural";
+type OrderAccessor = () => RevealOrder;
+export declare class RevealController {
+    _orderAccessor: OrderAccessor;
+    _collapsedAccessor: BoolAccessor;
+    _slots: RevealSlot[];
+    _parentController?: RevealController;
+    _disabled: Signal<boolean>;
+    _collapsed: Signal<boolean>;
+    _ready: boolean;
+    _minimallyReady: boolean;
+    _evaluating: boolean;
+    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;
+}
+export declare class CollectionQueue extends Queue {
+    _collectionType: number;
+    _sources: Set<Computed<any>>;
+    _tree?: BoundaryComputed<any>;
+    _pending: boolean;
+    _disabled: Signal<boolean>;
+    _collapsed: Signal<boolean>;
+    _revealController?: RevealController;
+    _initialized: boolean;
+    _onFn: (() => any) | undefined;
+    _prevOn: any;
+    constructor(type: number);
+    run(type: number): void;
+    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
+ *
+ * @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;
+ * }
+ * ```
+ */
+export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+    on?: () => any;
+}): import("./signals.js").SourceAccessor<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.
+ *
+ * @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;
+ * }
+ * ```
+ */
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.js").SourceAccessor<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).
+ *
+ * @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 }
+ * );
+ * ```
+ */
+export declare function createRevealOrder<T>(fn: () => T, options?: {
+    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)
+ *
+ * @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 });
+ * }
+ * ```
+ */
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;
+export {};

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

@@ -0,0 +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/src/core/async.d.ts

@@ -0,0 +1,6 @@
+import { type OptimisticLane } from "./lanes.js";
+import type { Computed } from "./types.js";
+export declare function settlePendingSource(el: Computed<any>): void;
+export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
+export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
+export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;

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

@@ -0,0 +1,51 @@
+export declare const REACTIVE_NONE = 0;
+export declare const REACTIVE_CHECK: number;
+export declare const REACTIVE_DIRTY: number;
+export declare const REACTIVE_RECOMPUTING_DEPS: number;
+export declare const REACTIVE_IN_HEAP: number;
+export declare const REACTIVE_IN_HEAP_HEIGHT: number;
+export declare const REACTIVE_ZOMBIE: number;
+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 REACTIVE_MANUAL_WRITE: 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 CONFIG_SYNC: number;
+export declare const STATUS_NONE = 0;
+export declare const STATUS_PENDING: number;
+export declare const STATUS_ERROR: number;
+export declare const STATUS_UNINITIALIZED: number;
+export declare const EFFECT_PURE = 0;
+export declare const EFFECT_RENDER = 1;
+export declare const EFFECT_USER = 2;
+export declare const EFFECT_TRACKED = 3;
+export declare const NOT_PENDING: {};
+export declare const NO_SNAPSHOT: {};
+export declare const STORE_SNAPSHOT_PROPS = "sp";
+export declare const SUPPORTS_PROXY: boolean;
+export declare const defaultContext: {};
+/**
+ * Brand symbol used by `Refreshable<T>` values (projection stores, async
+ * memos) to expose their underlying computation to `refresh()`. Not part of
+ * the user-facing API.
+ *
+ * @internal
+ */
+export declare const $REFRESH: unique symbol;
+/**
+ * Brand applied to values that participate in the `refresh()` re-run protocol.
+ * Accessors receive this handle internally; projected stores expose it through
+ * their public return type so 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;
+};