@solidjs/signals 0.13.13 → 2.0.0-beta.10

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

@@ -16,7 +16,7 @@ export interface NodeOptions<T> {
     name?: string;
     transparent?: boolean;
     equals?: ((prev: T, next: T) => boolean) | false;
-    pureWrite?: boolean;
+    ownedWrite?: boolean;
     /** Exclude this signal from snapshot capture (internal — not part of public API) */
     _noSnapshot?: boolean;
     unobserved?: () => void;
@@ -29,8 +29,7 @@ export interface RawSignal<T> {
     _snapshotValue?: any;
     _name?: string;
     _equals: false | ((a: T, b: T) => boolean);
-    _pureWrite?: 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
  */

package/dist/types/signals.d.ts

@@ -1,13 +1,68 @@
 import type { Disposable } from "./core/index.js";
+/**
+ * Low-level reactive-cleanup primitive. Registers a callback that runs when
+ * the surrounding owner is disposed.
+ *
+ * **In 2.0 user code this is rare.** The two cases where you might reach for
+ * it have better-shaped tools:
+ *
+ * - **Component lifecycle (mount/unmount, listeners, intervals):** use
+ *   {@link onSettled} and **return** a cleanup function. Setup and teardown
+ *   stay paired in one block. This replaces the 1.x `onMount` + `onCleanup`
+ *   pairing.
+ * - **Cleanup tied to an effect run:** `onCleanup` does not belong in
+ *   `createEffect`'s apply phase. If a compute phase genuinely needs per-run
+ *   teardown, that's usually a sign the work should be a memo/projection
+ *   instead, or moved to `onSettled` if it's lifecycle-shaped.
+ *
+ * Where `onCleanup` is the right tool is **library / custom-primitive
+ * internals** — coordinating disposal inside a `createRoot` body, or wiring
+ * cleanup to a captured owner via `runWithOwner` from a custom factory.
+ * Application code rarely needs to write any of those shapes directly.
+ *
+ * Must be called inside an owner. Calling outside an owner is a no-op (with a
+ * dev-mode warning).
+ *
+ * Cannot be used inside `createTrackedEffect` or `onSettled` — return a
+ * cleanup function from the callback body instead.
+ *
+ * @example
+ * ```ts
+ * // Library shape: thread a resource's disposal into a *captured* owner
+ * // from a factory that has no settle-phase setup of its own. `onSettled`
+ * // would queue a callback we don't need; `onCleanup` is the leaner
+ * // primitive when the only job is "register disposal on this owner".
+ * function bindToOwner<T extends { dispose(): void }>(owner: Owner, resource: T): T {
+ *   runWithOwner(owner, () => onCleanup(() => resource.dispose()));
+ *   return resource;
+ * }
+ * ```
+ */
 export declare function onCleanup(fn: Disposable): Disposable;
+/**
+ * A zero-arg getter for a reactive value. Calling it inside a tracking scope
+ * (memo, effect compute, JSX expression) subscribes the scope to changes.
+ *
+ * Reading outside any tracking scope simply returns the current value without
+ * creating a subscription.
+ */
 export type Accessor<T> = () => T;
 export declare function accessor<T>(node: any): Accessor<T>;
+/**
+ * A signal setter. Accepts either a new value or an updater `(prev) => next`.
+ *
+ * If the type permits `undefined`, `setState()` (no args) clears to `undefined`.
+ *
+ * To store a function as the value itself (rather than as an updater), wrap it
+ * with an updater: `setHandler(() => myHandler)`.
+ */
 export type Setter<in out T> = {
     <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
     <U extends T>(value: (prev: T) => U): U;
     <U extends T>(value: Exclude<U, Function>): U;
     <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 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;
@@ -15,21 +70,39 @@ export type EffectBundle<Prev, Next extends Prev = Prev> = {
     effect: EffectFunction<Prev, Next>;
     error: (err: unknown, cleanup: () => void) => void;
 };
-/** Options for effect primitives (`createEffect`, `createRenderEffect`, `createTrackedEffect`, `createReaction`). */
-export interface EffectOptions {
+/** Options shared by every effect primitive. */
+interface BaseEffectOptions {
     /** Debug name (dev mode only) */
     name?: string;
+}
+/** Options for effect primitives that support deferring/scheduling their initial run (`createEffect`, `createRenderEffect`, `createReaction`). */
+export interface EffectOptions extends BaseEffectOptions {
     /** When true, defers the initial effect execution until the next change */
     defer?: boolean;
+    /**
+     * When true, enqueues the initial effect callback through the effect queue instead of running
+     * it synchronously at creation. Lets the initial run participate in transitions -- if any
+     * source throws `NotReadyError` during the compute phase, the callback is held until the
+     * transition settles.
+     *
+     * Primarily for render effects that need transition-aware initial mounts (e.g. the root
+     * `insert()` in `render()`).
+     */
+    schedule?: boolean;
 }
 /** Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`. */
 export interface SignalOptions<T> {
     /** Debug name (dev mode only) */
     name?: string;
-    /** Custom equality function, or `false` to always notify subscribers */
+    /**
+     * Custom equality function, or `false` to always notify subscribers.
+     * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
+     * `(a, b) => a.id === b.id`) for value-based equality, or `false` to
+     * notify on every write regardless of equality.
+     */
     equals?: false | ((prev: T, next: T) => boolean);
     /** Suppress dev-mode warnings when writing inside an owned scope */
-    pureWrite?: boolean;
+    ownedWrite?: boolean;
     /** Callback invoked when the signal loses all subscribers */
     unobserved?: () => void;
 }
@@ -45,18 +118,30 @@ export interface MemoOptions<T> {
     name?: string;
     /** When true, the owner is invisible to the ID scheme -- inherits parent ID and doesn't consume a childCount slot */
     transparent?: boolean;
-    /** Custom equality function, or `false` to always notify subscribers */
+    /**
+     * Custom equality function, or `false` to always notify subscribers.
+     * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
+     * `(a, b) => a.id === b.id`) for value-based equality, or `false` to
+     * notify on every recompute regardless of equality.
+     */
     equals?: false | ((prev: T, next: T) => boolean);
     /** Callback invoked when the computed loses all subscribers */
     unobserved?: () => void;
-    /** When true, defers the initial computation until the value is first read */
+    /**
+     * When true, defers the initial computation until the value is first read,
+     * **and** opts the memo into autodisposal — once it has no remaining
+     * subscribers it is torn down and recomputed from scratch on the next read.
+     * Use it for compute-on-demand values that should not retain state across
+     * idle periods. Non-lazy owned memos live for their owner's lifetime and
+     * never autodispose.
+     */
     lazy?: boolean;
 }
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 /**
  * Creates a simple reactive state with a getter and setter.
  *
- * When called with a plain value, creates a signal with `SignalOptions` (name, equals, pureWrite, unobserved).
+ * When called with a plain value, creates a signal with `SignalOptions` (name, equals, ownedWrite, unobserved).
  * When called with a function, creates a writable memo with `SignalOptions & MemoOptions` (adds id, lazy).
  *
  * ```typescript
@@ -70,56 +155,152 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
  *
  * @returns `[state: Accessor<T>, setState: Setter<T>]`
  *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ *
+ * count();              // 0
+ * setCount(1);          // explicit value
+ * setCount(c => c + 1); // updater
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Writable memo: starts as `fn()`, can be locally overwritten by setter.
+ * const [user, setUser] = createSignal(() => fetchUser(userId()));
+ *
+ * setUser({ ...user(), name: "Alice" }); // optimistic local edit
+ * ```
+ *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
  */
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+export declare function createSignal<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
 /**
  * Creates a readonly derived reactive memoized signal.
  *
  * ```typescript
- * const value = createMemo<T>(compute, initialValue?, options?: MemoOptions<T>);
+ * const value = createMemo<T>(compute, options?: MemoOptions<T>);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param options `MemoOptions` -- id, name, equals, unobserved, lazy
  *
+ * @example
+ * ```ts
+ * const [first, setFirst] = createSignal("Ada");
+ * const [last, setLast] = createSignal("Lovelace");
+ *
+ * const fullName = createMemo(() => `${first()} ${last()}`);
+ *
+ * fullName(); // "Ada Lovelace"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Async memo — reads surface as pending inside <Loading>
+ * const user = createMemo(async () => {
+ *   const res = await fetch(`/users/${id()}`);
+ *   return res.json();
+ * });
+ * ```
+ *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
  */
-export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
-export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<T>): Accessor<T>;
 /**
- * Creates a reactive effect that runs after the render phase.
+ * Creates a reactive effect with **separate compute and effect phases**.
+ *
+ * - `compute(prev)` runs reactively — *put all reactive reads here*. The
+ *   returned value is passed to `effect` and is also the new "previous" value
+ *   for the next run.
+ * - `effect(next, prev?)` runs imperatively (untracked) after the queue
+ *   flushes. *Put DOM writes / fetch / logging / subscriptions here.* It may
+ *   return a cleanup function which runs before the next effect or on
+ *   disposal.
+ *
+ * Reactive reads inside `effect` will *not* re-trigger this effect — that's
+ * intentional. If you need a single-phase tracked effect, use
+ * `createTrackedEffect` (with the tradeoffs noted there).
+ *
+ * Pass an `EffectBundle` (`{ effect, error }`) instead of a plain function to
+ * intercept errors thrown from the compute or effect phases.
  *
  * ```typescript
- * createEffect<T>(compute, effectFn | { effect, error }, initialValue?, options?: EffectOptions);
+ * createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects (return a cleanup function), or an `EffectBundle` with `effect` and `error` handlers
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
- * @param options `EffectOptions` -- name, defer
+ * @param options `EffectOptions` -- name, defer, schedule
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ *
+ * createEffect(
+ *   () => count(),                  // compute: tracks `count`
+ *   value => console.log(value)     // effect: side effect
+ * );
+ *
+ * setCount(1); // logs 1 after the next flush
+ * ```
+ *
+ * @example
+ * ```ts
+ * createEffect(
+ *   () => userId(),
+ *   id => {
+ *     const ctrl = new AbortController();
+ *     fetch(`/users/${id}`, { signal: ctrl.signal });
+ *     return () => ctrl.abort(); // cleanup before next run / disposal
+ *   }
+ * );
+ * ```
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
-export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next> | EffectBundle<NoInfer<Next>, Next>): void;
-export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
+/**
+ * @deprecated `createEffect(compute)` (single argument) is no longer supported.
+ * Pass a separate effect function as the second argument:
+ * `createEffect(compute, effect)`. See [MISSING_EFFECT_FN].
+ *
+ * - For a side effect that reacts to changes, split the work:
+ *   `createEffect(() => signal(), value => doWork(value))`.
+ * - For a derived value, use `createMemo(() => signal())`.
+ * - For a one-shot side effect at construction time, just call the function.
+ */
+export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>): never;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements
  * are created and updated but not necessarily connected.
  *
+ * Same compute / effect split as `createEffect`, but scheduled inside the render
+ * queue rather than after it. Reach for this only when authoring renderer
+ * plumbing (custom DOM bindings, JSX-generated `insert()` / `spread()` calls).
+ * App code should use `createEffect`.
+ *
  * ```typescript
- * createRenderEffect<T>(compute, effectFn, initialValue?, options?: EffectOptions);
+ * createRenderEffect<T>(compute, effectFn, options?: EffectOptions);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
- * @param options `EffectOptions` -- name, defer
+ * @param options `EffectOptions` -- name, defer, schedule
+ *
+ * @example
+ * ```ts
+ * // Custom directive: bind an element's textContent to a reactive source.
+ * function bindText(el: HTMLElement, source: () => string) {
+ *   createRenderEffect(
+ *     () => source(),
+ *     value => { el.textContent = value; }
+ *   );
+ * }
+ * ```
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
  */
-export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next>): void;
-export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effectFn: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createRenderEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
@@ -129,14 +310,27 @@ export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFu
  * state). Use only when dynamic subscription patterns require same-scope tracking.
  *
  * ```typescript
- * createTrackedEffect(compute, options?: EffectOptions);
+ * createTrackedEffect(compute, options?: { name?: string });
  * ```
  * @param compute a function that contains reactive reads to track and returns an optional cleanup function to run on disposal or before next execution
- * @param options `EffectOptions` -- name, defer
+ * @param options -- name
+ *
+ * @example
+ * ```ts
+ * createTrackedEffect(() => {
+ *   const target = focusedNode();
+ *   if (!target) return;
+ *
+ *   const handler = () => log(target.value());
+ *   target.on("change", handler);
+ *
+ *   return () => target.off("change", handler);
+ * });
+ * ```
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
  */
-export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): void;
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: BaseEffectOptions): void;
 /**
  * Creates a reactive computation that runs after the render phase with flexible tracking.
  *
@@ -147,11 +341,40 @@ export declare function createTrackedEffect(compute: () => void | (() => void),
  * @param effectFn a function (or `EffectBundle`) that is called when tracked function is invalidated
  * @param options `EffectOptions` -- name, defer
  *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ *
+ * const track = createReaction(() => {
+ *   console.log("count changed once, re-arm to listen again");
+ *   track(() => count()); // re-arm
+ * });
+ *
+ * track(() => count()); // initial arm
+ *
+ * setCount(1); // logs once, reaction re-armed for next change
+ * ```
+ *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
  */
 export declare function createReaction(effectFn: EffectFunction<undefined> | EffectBundle<undefined>, options?: EffectOptions): (tracking: () => void) => void;
 /**
- * Returns a promise of the resolved value of a reactive expression
+ * Awaits a reactive expression and returns its first fully-settled value as a
+ * `Promise`. Pending async reads (`createMemo` returning a promise, etc.) are
+ * waited on; once the expression returns synchronously without `NotReadyError`
+ * the promise resolves with that value.
+ *
+ * Must be called *outside* a tracking scope — it doesn't subscribe, it just
+ * resolves the current value once.
+ *
+ * @example
+ * ```ts
+ * const user = createMemo(() => fetch(`/users/${id()}`).then(r => r.json()));
+ *
+ * // outside any reactive scope
+ * const initial = await resolve(() => user());
+ * ```
+ *
  * @param fn a reactive expression to resolve
  */
 export declare function resolve<T>(fn: () => T): Promise<T>;
@@ -159,34 +382,110 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
  * Creates an optimistic signal that can be used to optimistically update a value
  * and then revert it back to the previous value at end of transition.
  *
- * When called with a plain value, creates an optimistic signal with `SignalOptions` (name, equals, pureWrite, unobserved).
+ * When called with a plain value, creates an optimistic signal with `SignalOptions` (name, equals, ownedWrite, unobserved).
  * When called with a function, creates a writable optimistic memo with `SignalOptions & MemoOptions` (adds id, lazy).
  *
  * ```typescript
  * // Plain optimistic signal
  * const [state, setState] = createOptimistic<T>(value, options?: SignalOptions<T>);
  * // Writable optimistic memo (function overload)
- * const [state, setState] = createOptimistic<T>(fn, initialValue?, options?: SignalOptions<T> & MemoOptions<T>);
+ * const [state, setState] = createOptimistic<T>(fn, options?: SignalOptions<T> & MemoOptions<T>);
  * ```
  * @param value initial value of the signal; if empty, the signal's type will automatically extended with undefined
  * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
  *
  * @returns `[state: Accessor<T>, setState: Setter<T>]`
  *
+ * @example
+ * ```ts
+ * const [todos, setTodos] = createOptimistic(initialTodos);
+ *
+ * const addTodo = action(function* (text: string) {
+ *   const tempId = crypto.randomUUID();
+ *   setTodos(t => [...t, { id: tempId, text, pending: true }]); // optimistic
+ *   const saved = yield api.createTodo(text);
+ *   setTodos(t => t.map(x => (x.id === tempId ? saved : x)));   // reconcile
+ * });
+ * ```
+ *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-optimistic-signal
  */
 export declare function createOptimistic<T>(): Signal<T | undefined>;
 export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createOptimistic<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
 /**
- * Runs a callback after the current flush cycle completes.
+ * Schedules `callback` to run **once** after the reactive graph has fully
+ * settled — i.e. once every pending async read inside the current owner has
+ * resolved and the queue has flushed. Each call registers a single fire; it
+ * does not create an ongoing subscription.
+ *
+ * The canonical lifecycle primitive in 2.0. Three main usages:
+ *
+ * - **Component-level setup-and-teardown** *(the most common shape)*: run
+ *   setup after the component's first stable render and **return a cleanup
+ *   function** to dispose it on owner disposal. This is the replacement for
+ *   the 1.x `onMount` + `onCleanup` pairing — setup and teardown live in one
+ *   block, and `onCleanup` is no longer the right tool for component
+ *   bodies. (`onMount` no longer exists in 2.0.)
+ * - **Post-settle "ready" hook:** run once after a component's first stable
+ *   render — analytics ping, focus, scroll-into-view, etc. No cleanup needed.
+ * - **Inside an event handler:** schedule work to run after the action /
+ *   transition triggered by the event has completed.
+ *
+ * Reactive reads inside the callback are *not* tracked — to react to
+ * subsequent settles, register a new `onSettled` each time.
  *
- * When called within a reactive context (owner), uses a tracked effect with untracked
- * reads - this means normal signal reads won't create subscriptions, but uninitialized
- * async values will throw NotReadyError, causing the callback to re-run when they settle.
+ * `onCleanup` is **not** allowed inside the callback — return a cleanup
+ * function instead. The returned cleanup runs on owner disposal.
  *
- * When called without an owner, runs once and immediately calls any returned cleanup.
+ * @example
+ * ```tsx
+ * // Component-level setup + teardown — replaces onMount + onCleanup.
+ * // Subscribe to an external source on mount, unsubscribe on dispose.
+ * function useViewportWidth() {
+ *   const [width, setWidth] = createSignal(window.innerWidth);
+ *   onSettled(() => {
+ *     const onResize = () => setWidth(window.innerWidth);
+ *     window.addEventListener("resize", onResize);
+ *     return () => window.removeEventListener("resize", onResize);
+ *   });
+ *   return width;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Post-settle "ready" hook — no cleanup needed.
+ * function Dashboard() {
+ *   const data = createMemo(async () => fetchData());
+ *
+ *   onSettled(() => {
+ *     analytics.track("dashboard.ready");
+ *   });
+ *
+ *   return <Loading fallback={<Spinner />}><pre>{data()}</pre></Loading>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Event-handler — runs after the action settles.
+ * function SaveButton() {
+ *   const save = action(function* () {
+ *     yield api.save();
+ *   });
+ *
+ *   const handleClick = () => {
+ *     save();
+ *     onSettled(() => toast("Saved!"));
+ *   };
+ *
+ *   return <button onClick={handleClick}>Save</button>;
+ * }
+ * ```
  *
- * @param callback Function to run, may return a cleanup function
+ * @param callback Function to run; may return a cleanup function that fires
+ *   on owner disposal
  */
 export declare function onSettled(callback: () => void | (() => void)): void;
+export {};