@solidjs/signals 0.13.13 → 2.0.0-beta.8

package/dist/types-cjs/core/dev.d.cts

@@ -0,0 +1,49 @@
+import type { Computed, Owner, Signal } from "./types.cjs";
+export interface DevHooks {
+    onOwner?: (owner: Owner) => void;
+    onGraph?: (value: any, owner: Owner | null) => void;
+    onUpdate?: () => void;
+    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 DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner";
+export interface DiagnosticEvent {
+    sequence: number;
+    code: DiagnosticCode;
+    kind: DiagnosticKind;
+    severity: DiagnosticSeverity;
+    message: string;
+    ownerId?: string;
+    ownerName?: string;
+    nodeName?: string;
+    data?: Record<string, unknown>;
+}
+export type DiagnosticListener = (event: DiagnosticEvent) => void;
+export interface DiagnosticCapture {
+    readonly events: readonly DiagnosticEvent[];
+    clear(): void;
+    stop(): DiagnosticEvent[];
+}
+export interface Diagnostics {
+    subscribe(listener: DiagnosticListener): () => void;
+    capture(): DiagnosticCapture;
+}
+export interface Dev {
+    hooks: DevHooks;
+    diagnostics: Diagnostics;
+    getChildren: typeof getChildren;
+    getSignals: typeof getSignals;
+    getParent: typeof getParent;
+    getSources: typeof getSources;
+    getObservers: typeof getObservers;
+}
+export declare const DEV: Dev;
+export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">): DiagnosticEvent;
+export declare function registerGraph(value: any, owner: Owner | null): void;
+export declare function clearSignals(node: Owner): void;
+export declare function getChildren(owner: Owner): Owner[];
+export declare function getSignals(owner: Owner): any[];
+export declare function getParent(owner: Owner): Owner | null;
+export declare function getSources(computation: Computed<any>): (Signal<any> | Computed<any>)[];
+export declare function getObservers(node: Signal<any> | Computed<any>): Computed<any>[];

package/dist/types-cjs/core/effect.d.cts

@@ -0,0 +1,31 @@
+import type { Computed, NodeOptions, Owner } from "./types.cjs";
+export interface Effect<T> extends Computed<T>, Owner {
+    _effectFn: (val: T, prev: T | undefined) => void | (() => void);
+    _errorFn?: (err: unknown, cleanup: () => void) => void;
+    _cleanup?: () => void;
+    _modified: boolean;
+    _prevValue: T | undefined;
+    _type: number;
+}
+/**
+ * Effects are the leaf nodes of our reactive graph. When their sources change, they are
+ * 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), options?: NodeOptions<any> & {
+    user?: boolean;
+    defer?: boolean;
+    schedule?: boolean;
+}): void;
+export interface TrackedEffect extends Computed<void> {
+    _cleanup?: () => void;
+    _modified: boolean;
+    _type: number;
+    _run: () => void;
+}
+/**
+ * Internal tracked effect - bypasses heap, goes directly to effect queue.
+ * Runs as a leaf owner: child primitives and onCleanup are forbidden (__DEV__ throws).
+ * Uses stale reads.
+ */
+export declare function trackedEffect(fn: () => void | (() => void), options?: NodeOptions<any>): void;

package/dist/types-cjs/core/error.d.cts

@@ -0,0 +1,14 @@
+export declare class NotReadyError extends Error {
+    source: any;
+    constructor(source: any);
+}
+export declare class StatusError extends Error {
+    source: any;
+    constructor(source: any, original: any);
+}
+export declare class NoOwnerError extends Error {
+    constructor();
+}
+export declare class ContextNotFoundError extends Error {
+    constructor();
+}

package/dist/types-cjs/core/external.d.cts

@@ -0,0 +1,26 @@
+export type ExternalSourceFactory = (fn: (prev: any) => any, trigger: () => void) => ExternalSource;
+export interface ExternalSource {
+    track: (prev: any) => any;
+    dispose: () => void;
+}
+export interface ExternalSourceConfig {
+    factory: ExternalSourceFactory;
+    untrack?: <T>(fn: () => T) => T;
+}
+export declare let externalSourceConfig: {
+    factory: ExternalSourceFactory;
+    untrack: <T>(fn: () => T) => T;
+} | null;
+/**
+ * Registers a factory that bridges external reactive systems (e.g. MobX, Vue refs)
+ * into Solid's tracking graph. Every computation will be wrapped so that the
+ * external library can track its own dependencies alongside Solid's.
+ *
+ * Multiple calls pipe together: each new factory wraps the previous one.
+ *
+ * @param config.factory receives `(fn, trigger)` — wrap fn execution in external tracking,
+ *   call trigger when external deps change. Return `{ track, dispose }`.
+ * @param config.untrack optional wrapper for `untrack` — disables external tracking too.
+ */
+export declare function enableExternalSource(config: ExternalSourceConfig): void;
+export declare function _resetExternalSourceConfig(): void;

package/dist/types-cjs/core/graph.d.cts

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

package/dist/types-cjs/core/heap.d.cts

@@ -0,0 +1,14 @@
+import type { Computed } from "./types.cjs";
+export interface Heap {
+    _heap: (Computed<unknown> | undefined)[];
+    _marked: boolean;
+    _min: number;
+    _max: number;
+}
+export declare function increaseHeapSize(n: number, heap: Heap): void;
+export declare function insertIntoHeap(n: Computed<any>, heap: Heap): void;
+export declare function insertIntoHeapHeight(n: Computed<unknown>, heap: Heap): void;
+export declare function deleteFromHeap(n: Computed<unknown>, heap: Heap): void;
+export declare function markHeap(heap: Heap): void;
+export declare function markNode(el: Computed<unknown>, newState?: number): void;
+export declare function runHeap(heap: Heap, recompute: (el: Computed<unknown>) => void): void;

package/dist/types-cjs/core/index.d.cts

@@ -0,0 +1,12 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.cjs";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, optimisticSignal, optimisticComputed, isPending, latest, refresh, isRefreshing, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.cjs";
+export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.cjs";
+export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.cjs";
+export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.cjs";
+export { handleAsync } from "./async.cjs";
+export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, NodeOptions } from "./types.cjs";
+export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.cjs";
+export { action } from "./action.cjs";
+export { flush, Queue, GlobalQueue, trackOptimisticStore, enforceLoadingBoundary, type IQueue, type QueueCallback } from "./scheduler.cjs";
+export { DEV, type Dev, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type Diagnostics, type DiagnosticSeverity } from "./dev.cjs";
+export * from "./constants.cjs";

package/dist/types-cjs/core/lanes.d.cts

@@ -0,0 +1,54 @@
+import { type QueueCallback, type Transition } from "./scheduler.cjs";
+import type { Computed, Signal } from "./types.cjs";
+/**
+ * OptimisticLane represents the context for a single optimistic write.
+ * Each optimistic signal creates its own lane. Lanes merge when their
+ * dependency graphs overlap.
+ */
+export interface OptimisticLane {
+    _source: Signal<any>;
+    _pendingAsync: Set<Computed<any>>;
+    _effectQueues: [QueueCallback[], QueueCallback[]];
+    _mergedInto: OptimisticLane | null;
+    _transition: Transition | null;
+    _parentLane: OptimisticLane | null;
+}
+export declare const signalLanes: WeakMap<Signal<any>, OptimisticLane>;
+export declare const activeLanes: Set<OptimisticLane>;
+/**
+ * Get an existing lane for a signal or create a new one.
+ * Reuses lane for multiple writes to the same signal.
+ */
+export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
+/**
+ * Union-find: find the root lane.
+ */
+export declare function findLane(lane: OptimisticLane): OptimisticLane;
+/**
+ * Merge two lanes when their dependency graphs overlap.
+ */
+export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane): OptimisticLane;
+/**
+ * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
+ */
+export declare function resolveLane(el: {
+    _optimisticLane?: OptimisticLane;
+}): OptimisticLane | undefined;
+export declare function resolveTransition(el: {
+    _optimisticLane?: OptimisticLane;
+    _transition?: Transition | null;
+}): Transition | null | undefined;
+/**
+ * Check if a node has an active optimistic override.
+ */
+export declare function hasActiveOverride(el: {
+    _overrideValue?: any;
+}): boolean;
+/**
+ * Assign or merge a lane onto a node. At convergence points (node already has
+ * a different active lane), merge unless the node has an active override.
+ */
+export declare function assignOrMergeLane(el: {
+    _optimisticLane?: OptimisticLane;
+    _overrideValue?: any;
+}, sourceLane: OptimisticLane): void;

package/dist/types-cjs/core/owner.d.cts

@@ -0,0 +1,26 @@
+import type { Computed, Disposable, Owner, Root } from "./types.cjs";
+export declare function markDisposal(el: Owner): void;
+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;
+export declare function getObserver(): Owner | null;
+export declare function getOwner(): Owner | null;
+export declare function cleanup(fn: Disposable): Disposable;
+export declare function isDisposed(node: Owner): boolean;
+export declare function createOwner(options?: {
+    id?: string;
+    transparent?: boolean;
+}): Root;
+/**
+ * Creates a new non-tracked reactive context with manual disposal
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @returns the output of `fn`.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ */
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
+    id?: string;
+    transparent?: boolean;
+}): T;

package/dist/types-cjs/core/scheduler.d.cts

@@ -0,0 +1,82 @@
+import { type Heap } from "./heap.cjs";
+import { activeLanes, assignOrMergeLane, findLane } from "./lanes.cjs";
+import type { Computed, Signal } from "./types.cjs";
+export { activeLanes, assignOrMergeLane, findLane };
+export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.cjs";
+export declare const dirtyQueue: Heap;
+export declare const zombieQueue: Heap;
+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;
+export declare function setProjectionWriteActive(value: boolean): void;
+export declare function setTrackedQueueCallback(value: boolean): void;
+export type QueueCallback = (type: number) => void;
+type QueueStub = {
+    _queues: [QueueCallback[], QueueCallback[]];
+    _children: QueueStub[];
+};
+type OptimisticNode = Signal<any> | Computed<any>;
+export interface Transition {
+    _time: number;
+    _asyncReporters: Map<Computed<any>, Set<Computed<any>>>;
+    _pendingNodes: Signal<any>[];
+    _optimisticNodes: OptimisticNode[];
+    _optimisticStores: Set<any>;
+    _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
+    _queueStash: QueueStub;
+    _done: boolean | Transition;
+}
+export declare function schedule(): void;
+export interface IQueue {
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): boolean | void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    created: number;
+    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
+    stashQueues(stub: QueueStub): void;
+    restoreQueues(stub: QueueStub): void;
+    _parent: IQueue | null;
+}
+export declare class Queue implements IQueue {
+    _parent: IQueue | null;
+    _queues: [QueueCallback[], QueueCallback[]];
+    _children: IQueue[];
+    created: number;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
+    run(type: number): void;
+    enqueue(type: number, fn: QueueCallback): void;
+    stashQueues(stub: QueueStub): void;
+    restoreQueues(stub: QueueStub): void;
+}
+export declare class GlobalQueue extends Queue {
+    _running: boolean;
+    _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 _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 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;
+/**
+ * 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()`.
+ */
+export declare function flush(): void;
+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-cjs/core/types.d.cts

@@ -0,0 +1,86 @@
+import type { NOT_PENDING } from "./constants.cjs";
+import type { OptimisticLane } from "./lanes.cjs";
+import type { IQueue, Transition } from "./scheduler.cjs";
+export interface Disposable {
+    (): void;
+}
+export interface Link {
+    _dep: Signal<unknown> | Computed<unknown>;
+    _sub: Computed<unknown>;
+    _nextDep: Link | null;
+    _prevSub: Link | null;
+    _nextSub: Link | null;
+}
+export interface NodeOptions<T> {
+    id?: string;
+    name?: 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;
+    unobserved?: () => void;
+    lazy?: boolean;
+}
+export interface RawSignal<T> {
+    _subs: Link | null;
+    _subsTail: Link | null;
+    _value: T;
+    _snapshotValue?: any;
+    _name?: string;
+    _equals: false | ((a: T, b: T) => boolean);
+    _ownedWrite?: boolean;
+    _noSnapshot?: boolean;
+    _unobserved?: () => void;
+    _time: number;
+    _transition: Transition | null;
+    _pendingValue: T | typeof NOT_PENDING;
+    _overrideValue?: T | typeof NOT_PENDING;
+    _optimisticLane?: OptimisticLane;
+    _pendingSignal?: Signal<boolean>;
+    _latestValueComputed?: Computed<T>;
+    _parentSource?: Signal<any> | Computed<any>;
+}
+export interface FirewallSignal<T> extends RawSignal<T> {
+    _firewall: Computed<any>;
+    _nextChild: FirewallSignal<unknown> | null;
+}
+export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
+export interface Owner {
+    id?: string;
+    _transparent?: boolean;
+    _childrenForbidden?: boolean;
+    _snapshotScope?: boolean;
+    _disposal: Disposable | Disposable[] | null;
+    _parent: Owner | null;
+    _context: Record<symbol | string, unknown>;
+    _childCount: number;
+    _queue: IQueue;
+    _firstChild: Owner | null;
+    _nextSibling: Owner | null;
+    _pendingDisposal: Disposable | Disposable[] | null;
+    _pendingFirstChild: Owner | null;
+}
+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>>;
+    _error?: unknown;
+    _statusFlags: number;
+    _height: number;
+    _nextHeap: Computed<any> | undefined;
+    _prevHeap: Computed<any>;
+    _fn: (prev?: T) => T;
+    _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
+    _child: FirewallSignal<any> | null;
+    _notifyStatus?: (status?: number, error?: any) => void;
+}
+export interface Root extends Owner {
+    _root: true;
+    _parentComputed: Computed<any> | null;
+    dispose(self?: boolean): void;
+}

package/dist/types-cjs/index.d.cts

@@ -0,0 +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.cjs";
+import { type Dev } from "./core/index.cjs";
+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.cjs";
+export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled, onCleanup } from "./signals.cjs";
+export type { Accessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
+export { mapArray, repeat, type Maybe } from "./map.cjs";
+export * from "./store/index.cjs";
+export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.cjs";

package/dist/types-cjs/map.d.cts

@@ -0,0 +1,24 @@
+import { type Accessor } from "./signals.cjs";
+export type Maybe<T> = T | void | null | undefined | false;
+/**
+ * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
+ *
+ * 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.
+ *
+ * @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);
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+/**
+ * Reactively repeats a callback function the count provided - underlying helper for the `<Repeat>` control flow
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ */
+export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
+    from?: Accessor<number | undefined>;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<any[]>;

package/dist/types-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/types-cjs/signals.d.cts

@@ -0,0 +1,200 @@
+import type { Disposable } from "./core/index.cjs";
+export declare function onCleanup(fn: Disposable): Disposable;
+export type Accessor<T> = () => T;
+export declare function accessor<T>(node: any): Accessor<T>;
+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;
+};
+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;
+export type EffectBundle<Prev, Next extends Prev = Prev> = {
+    effect: EffectFunction<Prev, Next>;
+    error: (err: unknown, cleanup: () => void) => void;
+};
+/** 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 */
+    equals?: false | ((prev: T, next: T) => boolean);
+    /** Suppress dev-mode warnings when writing inside an owned scope */
+    ownedWrite?: boolean;
+    /** Callback invoked when the signal loses all subscribers */
+    unobserved?: () => void;
+}
+/**
+ * Options for read-only memos created with `createMemo`.
+ * Also used in combination with `SignalOptions` for writable memos
+ * (`createSignal(fn)` / `createOptimistic(fn)`).
+ */
+export interface MemoOptions<T> {
+    /** Stable identifier for the owner hierarchy */
+    id?: string;
+    /** Debug name (dev mode only) */
+    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 */
+    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 */
+    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, ownedWrite, unobserved).
+ * When called with a function, creates a writable memo with `SignalOptions & MemoOptions` (adds id, lazy).
+ *
+ * ```typescript
+ * // Plain signal
+ * const [state, setState] = createSignal<T>(value, options?: SignalOptions<T>);
+ * // Writable memo (function overload)
+ * const [state, setState] = createSignal<T>(fn, initialValue?, options?: SignalOptions<T> & MemoOptions<T>);
+ * ```
+ * @param value initial value of the state; if empty, the state'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>]`
+ *
+ * @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>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+/**
+ * Creates a readonly derived reactive memoized signal.
+ *
+ * ```typescript
+ * const value = createMemo<T>(compute, options?: MemoOptions<T>);
+ * ```
+ * @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
+ *
+ * @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>;
+/**
+ * Creates a reactive effect that runs after the render phase.
+ *
+ * ```typescript
+ * createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
+ * ```
+ * @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 options `EffectOptions` -- name, defer
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ */
+export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
+/**
+ * Creates a reactive computation that runs during the render phase as DOM elements
+ * are created and updated but not necessarily connected.
+ *
+ * ```typescript
+ * createRenderEffect<T>(compute, effectFn, options?: EffectOptions);
+ * ```
+ * @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 options `EffectOptions` -- name, defer
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ */
+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.
+ *
+ * WARNING: Because tracking and effects happen in the same scope, this primitive
+ * may run multiple times for a single change or show tearing (reading inconsistent
+ * state). Use only when dynamic subscription patterns require same-scope tracking.
+ *
+ * ```typescript
+ * 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 -- name
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ */
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: BaseEffectOptions): void;
+/**
+ * Creates a reactive computation that runs after the render phase with flexible tracking.
+ *
+ * ```typescript
+ * const track = createReaction(effectFn, options?: EffectOptions);
+ * track(() => { // reactive reads });
+ * ```
+ * @param effectFn a function (or `EffectBundle`) that is called when tracked function is invalidated
+ * @param options `EffectOptions` -- name, defer
+ *
+ * @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
+ * @param fn a reactive expression to resolve
+ */
+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, 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, 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>]`
+ *
+ * @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>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+/**
+ * Runs a callback after the current flush cycle completes.
+ *
+ * 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.
+ *
+ * When called without an owner, runs once and immediately calls any returned cleanup.
+ *
+ * @param callback Function to run, may return a cleanup function
+ */
+export declare function onSettled(callback: () => void | (() => void)): void;
+export {};

package/dist/types-cjs/store/index.d.cts

@@ -0,0 +1,9 @@
+export type { Store, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.cjs";
+export type { Merge, Omit } from "./utils.cjs";
+export { isWrappable, createStore, $TRACK, $PROXY, $TARGET } from "./store.cjs";
+export { createProjection } from "./projection.cjs";
+export { createOptimisticStore } from "./optimistic.cjs";
+export { reconcile } from "./reconcile.cjs";
+export { storePath } from "./storePath.cjs";
+export type { PathSetter, Part, StorePathRange, ArrayFilterFn, CustomPartial } from "./storePath.cjs";
+export { snapshot, deep, merge, omit } from "./utils.cjs";