@solidjs/signals 0.13.12 → 2.0.0-beta.7

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

@@ -0,0 +1,81 @@
+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 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 } 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,186 @@
+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 for effect primitives (`createEffect`, `createRenderEffect`, `createTrackedEffect`, `createReaction`). */
+export interface EffectOptions {
+    /** Debug name (dev mode only) */
+    name?: string;
+    /** When true, defers the initial effect execution until the next change */
+    defer?: 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?: EffectOptions);
+ * ```
+ * @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
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ */
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): 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;

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";

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

@@ -0,0 +1,19 @@
+import { $REFRESH } from "../core/index.cjs";
+import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "./store.cjs";
+/**
+ * Creates an optimistic store 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 store.
+ * When called with a function, creates a derived optimistic store with `ProjectionOptions` (name, key, all).
+ *
+ * @param fn a function that receives the current store and can be used to mutate it directly inside a transition
+ * @param store The plain store value, or the backing seed when using the derived-store form.
+ * @param options Optional projection options for reconciliation.
+ *
+ * @returns A tuple containing a store accessor and a setter function to apply changes.
+ */
+export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
+    [$REFRESH]: any;
+}, set: StoreSetter<T>];

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

@@ -0,0 +1,26 @@
+import { $REFRESH, type Computed } from "../core/index.cjs";
+import { type ProjectionOptions, type Store } from "./store.cjs";
+export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): {
+    store: Store<T> & {
+        [$REFRESH]: any;
+    };
+    node: Computed<void | T>;
+};
+/**
+ * Creates a mutable derived store (projection). The derive function receives a mutable
+ * draft and can mutate it directly or return a new value for reconciliation.
+ *
+ * ```typescript
+ * const store = createProjection<T>(fn, seed, options?: ProjectionOptions);
+ * ```
+ * @param fn a function that receives the current draft and mutates it or returns new data
+ * @param seed the backing store host value to wrap and reconcile into
+ * @param options `ProjectionOptions` -- name, key, all
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
+ */
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): Store<T> & {
+    [$REFRESH]: any;
+};
+export declare function createWriteTraps(isActive?: () => boolean): ProxyHandler<any>;
+export declare const writeTraps: ProxyHandler<any>;

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

@@ -0,0 +1 @@
+export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any)): (state: U) => void;

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

@@ -0,0 +1,68 @@
+import { $REFRESH, STORE_SNAPSHOT_PROPS, type Computed, type Signal } from "../core/index.cjs";
+export type Store<T> = Readonly<T>;
+export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
+/** Base options for store primitives. */
+export interface StoreOptions {
+    /** Debug name (dev mode only) */
+    name?: string;
+}
+/** Options for derived/projected stores created with `createStore(fn)`, `createProjection`, or `createOptimisticStore(fn)`. */
+export interface ProjectionOptions extends StoreOptions {
+    /** Key property name or function for reconciliation identity */
+    key?: string | ((item: NonNullable<any>) => any);
+}
+export type NoFn<T> = T extends Function ? never : T;
+type DataNode = Signal<any>;
+type DataNodes = Record<PropertyKey, DataNode>;
+export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p";
+export type StoreNode = {
+    [$PROXY]: any;
+    [STORE_VALUE]: Record<PropertyKey, any>;
+    [STORE_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_OPTIMISTIC_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_NODE]?: DataNodes;
+    [STORE_HAS]?: DataNodes;
+    [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
+    [STORE_LOOKUP]?: WeakMap<any, any>;
+    [STORE_FIREWALL]?: Computed<any>;
+    [STORE_OPTIMISTIC]?: boolean;
+    [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
+};
+export declare namespace SolidStore {
+    interface Unwrappable {
+    }
+}
+export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
+export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
+export declare const storeLookup: WeakMap<WeakKey, any>;
+export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+export declare function setWriteOverride(value: boolean): void;
+export declare function trackSelf(target: StoreNode, symbol?: symbol): void;
+export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
+export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
+export declare const storeTraps: ProxyHandler<StoreNode>;
+export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => T | void): void;
+/**
+ * Creates a deeply reactive store with proxy-based tracking.
+ *
+ * When called with a plain value, wraps it in a reactive proxy.
+ * When called with a function, creates a derived projection store with `ProjectionOptions` (name, key, all).
+ *
+ * ```typescript
+ * // Plain store
+ * const [store, setStore] = createStore<T>(initialValue);
+ * // Derived store (projection)
+ * const [store, setStore] = createStore<T>(fn, seed, options?: ProjectionOptions);
+ * ```
+ * @param store initial value to wrap in a reactive proxy, or a derive function
+ * @param options `ProjectionOptions` -- name, key, all (only for derived stores)
+ *
+ * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
+ */
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
+    [$REFRESH]: any;
+}, set: StoreSetter<T>];
+export {};

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

@@ -0,0 +1,30 @@
+import { type NotWrappable } from "./store.cjs";
+type W<T> = Exclude<T, NotWrappable>;
+type KeyOf<T> = number extends keyof T ? 0 extends 1 & T ? keyof T : [T] extends [never] ? never : [T] extends [readonly unknown[]] ? number : keyof T : keyof T;
+export type CustomPartial<T> = T extends readonly unknown[] ? "0" extends keyof T ? {
+    [K in Extract<keyof T, `${number}`>]?: T[K];
+} : {
+    [x: number]: T[number];
+} : Partial<T>;
+export type StorePathRange = {
+    from?: number;
+    to?: number;
+    by?: number;
+};
+export type ArrayFilterFn<T> = (item: T, index: number) => boolean;
+export type PathSetter<T> = T | CustomPartial<T> | ((prev: T) => T | CustomPartial<T>) | typeof DELETE;
+export type Part<T, K extends KeyOf<T> = KeyOf<T>> = K | ([K] extends [never] ? never : readonly K[]) | ([T] extends [readonly unknown[]] ? ArrayFilterFn<T[number]> | StorePathRange : never);
+declare const DELETE: unique symbol;
+export interface storePath {
+    DELETE: typeof DELETE;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends KeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, setter: PathSetter<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, setter: PathSetter<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, setter: PathSetter<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, setter: PathSetter<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, setter: PathSetter<W<W<W<T>[K1]>[K2]>[K3]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, setter: PathSetter<W<W<T>[K1]>[K2]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>>(k1: Part<W<T>, K1>, setter: PathSetter<W<T>[K1]>): (state: T) => void;
+    <T>(setter: PathSetter<T>): (state: T) => void;
+}
+export declare const storePath: storePath;
+export {};

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

@@ -0,0 +1,43 @@
+/**
+ * Returns a non reactive copy of the store object.
+ * It will attempt to preserver the original reference unless the value has been modified.
+ * @param item store proxy object
+ */
+export declare function snapshot<T>(item: T): T;
+export declare function snapshot<T>(item: T, map?: Map<unknown, unknown>, lookup?: WeakMap<any, any>): T;
+/**
+ * Returns a non-reactive snapshot of the store while subscribing to all nested changes.
+ * Subscribes to `$TRACK` at every level so that any deep change triggers recomputation,
+ * and returns plain (non-proxy) data. Works correctly with `reconcile()`.
+ * @param store store proxy object
+ */
+export declare function deep<T extends object>(store: T): T;
+type DistributeOverride<T, F> = T extends undefined ? F : T;
+type Override<T, U> = T extends any ? U extends any ? {
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
+} & {
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
+} : T & U : T & U;
+type OverrideSpread<T, U> = T extends any ? {
+    [K in keyof ({
+        [K in keyof T]: any;
+    } & {
+        [K in keyof U]?: any;
+    } & {
+        [K in U extends any ? keyof U : keyof U]?: any;
+    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
+} : T & U;
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+type _Merge<T extends unknown[], Curr = {}> = T extends [
+    infer Next | (() => infer Next),
+    ...infer Rest
+] ? _Merge<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_Merge<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
+export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
+export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
+export type Omit<T, K extends readonly (keyof T)[]> = {
+    [P in keyof T as Exclude<P, K[number]>]: T[P];
+};
+export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
+export {};