@storesjs/stores 0.8.7 → 0.10.0

package/dist/utils/core.d.ts

@@ -1,7 +1,26 @@
 /**
- * Returns the first argument provided to it.
- * @param value - Any value.
- * @returns `value`.
+ * Returns the argument provided.
  */
-export declare const identity: (value: any) => any;
+export declare function identity<T>(value: T): T;
+export declare function identity<T, _>(value: T): T;
+/**
+ * Creates a null-prototype object using the runtime-optimal path:
+ *  - React Native: direct literal `{ __proto__: null }`
+ *  - Web/Node: `Object.create` with a shared, frozen null prototype
+ */
+export declare function nullObject<T extends Record<string, unknown> | object = Record<string, unknown>>(): T;
+/**
+ * Builds null-prototype objects. Provided arguments are
+ * shallow-merged into a newly created null-prototype object:
+ *
+ * ```ts
+ * Object.assign(nullObject(), a, b?)
+ * ```
+ */
+export declare function buildNullObject<A extends Record<string, unknown>>(a: A): A;
+export declare function buildNullObject<A extends object, B>(a: object, b?: object): [undefined] extends B ? A : A & B;
+/**
+ * Does nothing.
+ */
+export declare function noop(): void;
 //# sourceMappingURL=core.d.ts.map

package/dist/utils/time.d.ts

@@ -33,15 +33,5 @@ type TimeUtils = {
  * time.zero // 0
  */
 export declare const time: TimeUtils;
-/**
- * Waits for microtasks to complete.
- * Uses setTimeout(0) to allow microtasks scheduled via queueMicrotask to execute.
- *
- * Useful in tests when waiting for async operations scheduled via microtasks.
- *
- * @example
- * await waitForMicrotask();
- */
-export declare function waitForMicrotask(): Promise<void>;
 export {};
 //# sourceMappingURL=time.d.ts.map

package/dist/vanilla/createBaseStore.d.ts

@@ -0,0 +1,35 @@
+import type { BaseStoreOptions, OptionallyPersistedStore, Store, StateCreator } from './types';
+/**
+ * Creates a base store without persistence.
+ * @param createState - The state creator function for the base store.
+ * @returns A store with the specified state.
+ */
+export declare function createBaseStore<S>(createState: StateCreator<S>): Store<S>;
+/**
+ * Creates a base store with persistence.
+ * @param createState - The state creator function for the base store.
+ * @param options - The configuration options for persistence and sync.
+ * @returns A store with the specified state and persistence.
+ */
+export declare function createBaseStore<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn extends void = void>(createState: StateCreator<S>, options: BaseStoreOptions<S, PersistedState, PersistReturn>): Store<S, PersistedState, PersistReturn, false>;
+/**
+ * Creates a base store with async persistence.
+ * @param createState - The state creator function for the base store.
+ * @param options - The configuration options for persistence and sync.
+ * @returns A store with the specified state and persistence.
+ */
+export declare function createBaseStore<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn extends Promise<void> = Promise<void>>(createState: StateCreator<S>, options: BaseStoreOptions<S, PersistedState, PersistReturn>): Store<S, PersistedState, PersistReturn, false>;
+/**
+ * Creates a base store with optional persistence.
+ * @param createState - The state creator function for the base store.
+ * @param options - The configuration options for persistence and sync.
+ * @returns A store with the specified state and optional persistence.
+ */
+export declare function createBaseStore<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn extends void = void>(createState: StateCreator<S>, options?: BaseStoreOptions<S, PersistedState, PersistReturn>): OptionallyPersistedStore<S, PersistedState, PersistReturn>;
+/**
+ * Creates a base store with optional async persistence.
+ * @param createState - The state creator function for the base store.
+ * @param options - The configuration options for persistence and sync.
+ * @returns A store with the specified state and optional persistence.
+ */
+export declare function createBaseStore<S, PersistedState extends Partial<S> = Partial<S>, PersistReturn extends Promise<void> = Promise<void>>(createState: StateCreator<S>, options?: BaseStoreOptions<S, PersistedState, PersistReturn>): OptionallyPersistedStore<S, PersistedState, PersistReturn>;

package/dist/vanilla/createDerivedStore.d.ts

@@ -0,0 +1,62 @@
+import type { DeriveGetter, DeriveOptions, DerivedStore } from './types';
+/**
+ * ### `createDerivedStore`
+ *
+ * Creates a **read-only** store derived from one or more source stores.
+ *
+ * ---
+ * The `deriveFunction` is called whenever its dependencies change, producing a new derived state.
+ * Dependencies are automatically tracked through a special `$` helper, which supports:
+ *
+ * 1) **Selector-based** usage:
+ *    ```ts
+ *    $ => {
+ *      const user = $(useUserStore, s => s.user, shallowEqual);
+ *      const theme = $(useSettingsStore, s => s.appearance.theme);
+ *      return { user, theme, isAdmin: user?.roles.includes('admin') };
+ *    }
+ *    ```
+ *
+ * 2) **Proxy-based** usage (auto-built selectors for nested properties):
+ *    ```ts
+ *    $ => {
+ *      const { user } = $(useUserStore); // Subscribe to `user`
+ *      const theme = $(useSettingsStore).appearance.theme; // Subscribe to `theme`
+ *      return { isAdmin: user?.roles.includes('admin'), theme, user };
+ *    }
+ *    ```
+ *
+ * ---
+ * Derived stores automatically unsubscribe from all dependencies when no consumers remain, and
+ * resubscribe when new consumers appear. The returned store exposes:
+ *
+ * - A **store object** with `getState()`, `subscribe()`, and `destroy()`
+ * - In the React build, a **React hook** (`const state = derivedStore(selector, equalityFn?)`)
+ *
+ * ---
+ * You can optionally pass a second parameter (either an equality function or a config object)
+ * to enable debouncing, customize the equality function, or set `lockDependencies: true`.
+ *
+ * (When dependencies are locked, subscriptions created via `$` are established once and are
+ * not rebuilt on subsequent re-derives, which can be a performance win for certain workloads.)
+ *
+ * ---
+ * @example
+ * ```ts
+ * // Create a derived store
+ * const searchResultsStore = createDerivedStore($ => {
+ *   const query = $(searchStore).query.trim().toLowerCase();
+ *   const items = $(itemsStore).items;
+ *   return findResults(query, items);
+ * }, shallowEqual);
+ *
+ * const results = searchResultsStore.getState();
+ * ```
+ *
+ * ---
+ * @param deriveFunction - Function that reads from other stores via `$` to produce derived state.
+ * @param optionsOrEqualityFn - Either an equality function or a config object (see `DeriveOptions`).
+ *
+ * @returns A read-only derived store. In the React build, it is also callable as a hook.
+ */
+export declare function createDerivedStore<Derived>(deriveFunction: ($: DeriveGetter) => Derived, optionsOrEqualityFn?: DeriveOptions<Derived>): DerivedStore<Derived>;

package/dist/vanilla/createQueryStore.d.ts

@@ -0,0 +1,116 @@
+import { defaultRetryDelay } from './internal/runtime';
+import type { QueryStoreConfig, QueryStoreState } from './queryStore/types';
+import type { BaseStoreOptions, OptionallyPersistedStore, PersistedStore, StateCreator, Store } from './types';
+export { defaultRetryDelay };
+/**
+ * Creates a persisted, query-enabled store with data fetching capabilities (sync storage).
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams>> = Partial<QueryStoreState<TData, TParams>>, PersistReturn extends void = void>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options: BaseStoreOptions<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>): PersistedStore<QueryStoreState<TData, TParams>, PersistedState, PersistReturn, false>;
+/**
+ * Creates a persisted, query-enabled store with data fetching capabilities (async storage).
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams>> = Partial<QueryStoreState<TData, TParams>>, PersistReturn extends Promise<void> = Promise<void>>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options: BaseStoreOptions<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>): PersistedStore<QueryStoreState<TData, TParams>, PersistedState, PersistReturn, false>;
+/**
+ * Creates a persisted, query-enabled store with data fetching capabilities (sync storage).
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template CustomState - User-defined custom store state
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams, CustomState>> = Partial<QueryStoreState<TData, TParams, CustomState>>, PersistReturn extends void = void>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>): PersistedStore<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn, false>;
+/**
+ * Creates a persisted, query-enabled store with data fetching capabilities (async storage).
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template CustomState - User-defined custom store state
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams, CustomState>> = Partial<QueryStoreState<TData, TParams, CustomState>>, PersistReturn extends Promise<void> = Promise<void>>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>): PersistedStore<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn, false>;
+/**
+ * Creates a query-enabled store with data fetching capabilities.
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template CustomState - User-defined custom store state
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options?: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>>): Store<QueryStoreState<TData, TParams, CustomState>>;
+/**
+ * Creates a query-enabled store with data fetching capabilities.
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options?: BaseStoreOptions<QueryStoreState<TData, TParams>>): Store<QueryStoreState<TData, TParams>>;
+/**
+ * Creates a conditionally persisted, query-enabled store with data-fetching capabilities
+ * and custom state (sync storage).
+ *
+ * `options.persist` may be `undefined` – the returned store exposes `persist?`.
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template CustomState - User-defined custom store state
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams, CustomState>> = Partial<QueryStoreState<TData, TParams, CustomState>>, PersistReturn extends void = void>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options?: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>): OptionallyPersistedStore<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>;
+/**
+ * Creates a conditionally persisted, query-enabled store with data-fetching capabilities
+ * and custom state (async storage).
+ *
+ * `options.persist` may be `undefined` – the returned store exposes `persist?`.
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template CustomState - User-defined custom store state
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, CustomState = unknown, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams, CustomState>> = Partial<QueryStoreState<TData, TParams, CustomState>>, PersistReturn extends Promise<void> = Promise<void>>(config: QueryStoreConfig<TQueryFnData, TParams, TData, CustomState>, stateCreator: StateCreator<QueryStoreState<TData, TParams, CustomState>, CustomState>, options?: BaseStoreOptions<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>): OptionallyPersistedStore<QueryStoreState<TData, TParams, CustomState>, PersistedState, PersistReturn>;
+/**
+ * Creates a conditionally persisted, query-enabled store with data fetching capabilities (sync storage).
+ *
+ * `options.persist` may be `undefined` – the returned store exposes `persist?`.
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams>> = Partial<QueryStoreState<TData, TParams>>, PersistReturn extends void = void>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options: BaseStoreOptions<QueryStoreState<TData, TParams>, PersistedState, PersistReturn> | undefined): OptionallyPersistedStore<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>;
+/**
+ * Creates a conditionally persisted, query-enabled store with data fetching capabilities (async storage).
+ *
+ * `options.persist` may be `undefined` – the returned store exposes `persist?`.
+ *
+ * @template TQueryFnData - The raw data type returned by the fetcher
+ * @template TParams - Parameters passed to the fetcher function
+ * @template TData - The transformed data type, if applicable (defaults to `TQueryFnData`)
+ * @template PersistedState - The persisted state type, if a stricter type than `Partial<CustomState>` is desired
+ */
+export declare function createQueryStore<TQueryFnData, TParams extends Record<string, unknown> = Record<string, never>, TData = TQueryFnData, PersistedState extends Partial<QueryStoreState<TData, TParams>> = Partial<QueryStoreState<TData, TParams>>, PersistReturn extends Promise<void> = Promise<void>>(config: QueryStoreConfig<TQueryFnData, TParams, TData>, options: BaseStoreOptions<QueryStoreState<TData, TParams>, PersistedState, PersistReturn> | undefined): OptionallyPersistedStore<QueryStoreState<TData, TParams>, PersistedState, PersistReturn>;
+/**
+ * Generates a deterministic query store `queryKey` from the given parameters,
+ * consistent with internally generated keys.
+ */
+export declare function getQueryKey<TParams extends Record<string, unknown>>(params: TParams): string;
+/**
+ * Parses a query store `queryKey` into the corresponding parameters.
+ */
+export declare function parseQueryKey<TParams extends Record<string, unknown>>(queryKey: string): TParams;

package/dist/vanilla/createVirtualStore.d.ts

@@ -0,0 +1,39 @@
+import type { BaseStore, DeriveGetter, InferPersistedState, InferSetStateReturn, InferStoreState, OptionallyPersistedStore } from './types';
+type MethodOverrides<Store extends BaseStore<unknown>> = Partial<Pick<Store, 'getState' | 'setState'>>;
+type VirtualStore<Store extends BaseStore<unknown>> = OptionallyPersistedStore<InferStoreState<Store>, InferPersistedState<Store>, InferSetStateReturn<Store>>;
+type VirtualStoreOptions = {
+    debugMode?: boolean;
+    /**
+     * Whether to lock dependencies (see: {@link DeriveOptions}) for the virtual store.
+     * @default true
+     */
+    lockDependencies?: boolean;
+};
+/**
+ * ### `createVirtualStore`
+ *
+ * Returns a stable store interface backed by different store instances over time.
+ * When dependencies change, the derive function runs and creates a new store, then
+ * all subscriptions rebind automatically. Only depend on state that should trigger
+ * new store creation.
+ *
+ * ---
+ * 💡 **Note:** `lockDependencies` (see: {@link DeriveOptions}) is enabled by default.
+ * Ensure that any `$` dependencies in your `createStore` function are called
+ * consistently. If they are not, set `lockDependencies` to `false`.
+ *
+ * ---
+ * @param createStore - Derive function that returns a store instance
+ * @param overrides - Optional method overrides (e.g., `getState(id?: string)`)
+ *
+ * @example
+ * ```ts
+ * const useUserAssetsStore = createVirtualStore($ => {
+ *   const address = $(useWalletsStore).accountAddress;
+ *   return createUserAssetsStore(address);
+ * });
+ * ```
+ */
+export declare function createVirtualStore<Store extends BaseStore<InferStoreState<Store>>>(createStore: ($: DeriveGetter) => Store, options?: VirtualStoreOptions): VirtualStore<Store>;
+export declare function createVirtualStore<Store extends BaseStore<InferStoreState<Store>>, Overrides extends MethodOverrides<Store>>(createStore: ($: DeriveGetter) => Store, overrides: (getStore: () => Store) => Overrides, options?: VirtualStoreOptions): VirtualStore<Store> & Overrides;
+export {};

package/dist/vanilla/env.web.d.ts

@@ -0,0 +1,6 @@
+export declare const IS_REACT_NATIVE = false;
+export declare const IS_BROWSER: boolean;
+export declare const IS_IOS = false;
+export declare const IS_ANDROID = false;
+export declare const IS_DEV: boolean;
+export declare const IS_TEST: boolean;

package/dist/vanilla/index.d.ts

@@ -0,0 +1 @@
+export * from './index.shared';

package/dist/vanilla/index.js

@@ -0,0 +1 @@
+var e=require("../web/internal/runtime.js");function t(e,t,r,n){return e}Object.defineProperty(exports,"QueryStatuses",{enumerable:!0,get:function(){return e.QueryStatuses}}),Object.defineProperty(exports,"StoresError",{enumerable:!0,get:function(){return e.StoresError}}),Object.defineProperty(exports,"applyStateUpdate",{enumerable:!0,get:function(){return e.applyStateUpdate}}),Object.defineProperty(exports,"configureStores",{enumerable:!0,get:function(){return e.configureStores}}),Object.defineProperty(exports,"createStoreActions",{enumerable:!0,get:function(){return e.createStoreActions}}),Object.defineProperty(exports,"deepEqual",{enumerable:!0,get:function(){return e.deepEqual}}),Object.defineProperty(exports,"defaultRetryDelay",{enumerable:!0,get:function(){return e.defaultRetryDelay}}),Object.defineProperty(exports,"destroyStore",{enumerable:!0,get:function(){return e.destroyStore}}),Object.defineProperty(exports,"destroyStores",{enumerable:!0,get:function(){return e.destroyStores}}),Object.defineProperty(exports,"getStoreName",{enumerable:!0,get:function(){return e.getStoreName}}),Object.defineProperty(exports,"hasGetSnapshot",{enumerable:!0,get:function(){return e.hasGetSnapshot}}),Object.defineProperty(exports,"identity",{enumerable:!0,get:function(){return e.identity}}),Object.defineProperty(exports,"isDerivedStore",{enumerable:!0,get:function(){return e.isDerivedStore}}),Object.defineProperty(exports,"isPersistedStore",{enumerable:!0,get:function(){return e.isPersistedStore}}),Object.defineProperty(exports,"isQueryStore",{enumerable:!0,get:function(){return e.isQueryStore}}),Object.defineProperty(exports,"isVirtualStore",{enumerable:!0,get:function(){return e.isVirtualStore}}),Object.defineProperty(exports,"nullObject",{enumerable:!0,get:function(){return e.nullObject}}),Object.defineProperty(exports,"replacer",{enumerable:!0,get:function(){return e.replacer}}),Object.defineProperty(exports,"reviver",{enumerable:!0,get:function(){return e.reviver}}),Object.defineProperty(exports,"shallowEqual",{enumerable:!0,get:function(){return e.shallowEqual}}),Object.defineProperty(exports,"time",{enumerable:!0,get:function(){return e.time}}),exports.createBaseStore=function(r,n){const o=e.baseStore(r,n);return t(o,o.getState,o.getInitialState)},exports.createDerivedStore=function(r,n=Object.is){const o=e.derivedStore(r,n);return t(o,o.getSnapshot)},exports.createQueryStore=function(r,n,o){const u=e.queryStore(r,n,o);return t(u,u.getState,u.getInitialState)},exports.createVirtualStore=function(r,n,o){const u=e.virtualStore(r,n,o);return t(u,u.getState,u.getInitialState)},exports.getQueryKey=function(t){return e.getQueryKey(t)},exports.parseQueryKey=function(t){return e.parseQueryKey(t)};

package/dist/vanilla/index.mjs

@@ -0,0 +1 @@
+import{baseStore as t,derivedStore as e,queryStore as r,getQueryKey as n,parseQueryKey as o,virtualStore as i}from"../web/internal/runtime.mjs";export{QueryStatuses,StoresError,applyStateUpdate,configureStores,createStoreActions,deepEqual,defaultRetryDelay,destroyStore,destroyStores,getStoreName,hasGetSnapshot,identity,isDerivedStore,isPersistedStore,isQueryStore,isVirtualStore,nullObject,replacer,reviver,shallowEqual,time}from"../web/internal/runtime.mjs";function a(t,e,r,n){return t}function s(e,r){const n=t(e,r);return a(n,n.getState,n.getInitialState)}function u(t,r=Object.is){const n=e(t,r);return a(n,n.getSnapshot)}function S(t,e,n){const o=r(t,e,n);return a(o,o.getState,o.getInitialState)}function c(t){return n(t)}function l(t){return o(t)}function y(t,e,r){const n=i(t,e,r);return a(n,n.getState,n.getInitialState)}export{s as createBaseStore,u as createDerivedStore,S as createQueryStore,y as createVirtualStore,c as getQueryKey,l as parseQueryKey};

package/dist/vanilla/index.shared.d.ts

@@ -0,0 +1,13 @@
+export * from './createBaseStore';
+export * from './createDerivedStore';
+export * from './createQueryStore';
+export * from './createVirtualStore';
+export { configureStores, StoresError } from './internal/runtime';
+export { applyStateUpdate, replacer, reviver } from './internal/runtime';
+export { destroyStore, destroyStores, getStoreName, hasGetSnapshot, isDerivedStore, isPersistedStore, isQueryStore, isVirtualStore, } from './internal/runtime';
+export type * from './sync/types';
+export { QueryStatuses } from './internal/runtime';
+export type * from './queryStore/types';
+export type * from './storage/storageTypes';
+export type * from './types';
+export { createStoreActions, deepEqual, identity, nullObject, shallowEqual, time } from './internal/runtime';

package/dist/vanilla/index.vanilla.d.ts

@@ -0,0 +1 @@
+export * from './index.shared';

package/dist/vanilla/internal/baseStore.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vanilla/internal/config.d.ts

@@ -0,0 +1,63 @@
+import { QueryStoreConfig } from '../queryStore/types';
+import { SyncEngine } from '../sync/types';
+import { AsyncStorageInterface, SyncStorageInterface } from '../types';
+import { NonFunction } from '../types/functions';
+import { Prettify } from '../types/objects';
+import { Logger } from './logger';
+/**
+ * Global configuration for all stores.
+ */
+export type StoresConfig = {
+    /**
+     * Custom logger for debug output. Defaults to a no-op logger in production.
+     */
+    logger: Logger;
+    /**
+     * Default options used by all query stores.
+     */
+    queryStoreDefaults: QueryStoreDefaults;
+    /**
+     * Storage backend for persisted stores. Defaults to `localStorage` in browsers,
+     * MMKV in React Native.
+     */
+    storage: AsyncStorageInterface | SyncStorageInterface;
+    /**
+     * Prefix for storage keys built by the default storage adapter.
+     * Should include a delimiter, e.g., `'myapp:'`.
+     * @default 'stores:'
+     */
+    storageKeyPrefix: string;
+    /**
+     * Sync engine for cross-client state synchronization. Defaults to cross-tab sync
+     * in browsers, no-op in other environments.
+     */
+    syncEngine: SyncEngine;
+};
+export type QueryStoreDefaults = Prettify<ConfigDefaults<QueryStoreConfig<unknown, Record<string, unknown>>, 'disableCache' | 'enabled' | 'params', 'retryDelay'>> & {
+    /**
+     * Minimum stale time for auto-refetching query stores under which to log warnings in development.
+     * `false` disables warnings.
+     * @default false
+     */
+    minStaleTime?: number | false;
+};
+type ConfigDefaults<C, Excluded extends keyof C = never, AllowedFunctions extends keyof C = never> = Omit<{
+    [K in keyof C as K extends AllowedFunctions ? K : NonFunction<C[K]> extends undefined ? never : K]?: K extends AllowedFunctions ? C[K] : NonFunction<C[K]>;
+}, Excluded>;
+/**
+ * Configures global defaults for all stores.
+ *
+ * If used, must be called before creating any stores.
+ *
+ * @see {@link StoresConfig}
+ *
+ * @example
+ * ```ts
+ * configureStores({
+ *   logger: { debug: console.debug, error: console.error },
+ *   storageKeyPrefix: 'myapp:',
+ * });
+ * ```
+ */
+export declare function configureStores(config: Partial<StoresConfig>): void;
+export {};

package/dist/vanilla/internal/createStoreActions.d.ts

@@ -0,0 +1,23 @@
+import type { StoreApi } from '../store/types';
+import type { InferStoreState, StoreActions } from '../types';
+import type { FunctionRecord } from '../types/functions';
+import type { NoOverlap } from '../types/objects';
+/**
+ * Given a store instance, produces a new object containing only its actions.
+ *
+ * Intended for export alongside the associated store.
+ *
+ * @param store - The store to create actions for.
+ * @param bundledMethods - Optional extra methods to bundle into the actions object.
+ *
+ * @example
+ * export const useCounterStore = createRainbowStore(set => ({
+ *   count: 0,
+ *   increment: () => set(state => ({ count: state.count + 1 })),
+ * }));
+ *
+ * export const exampleActions = createStoreActions(useExampleStore);
+ * exampleActions.increment();
+ */
+export declare function createStoreActions<Store extends StoreApi<unknown>>(store: Store): StoreActions<Store>;
+export declare function createStoreActions<Store extends StoreApi<unknown>, Bundled extends FunctionRecord>(store: Store, bundledMethods: NoOverlap<InferStoreState<Store>, Bundled>): StoreActions<Store> & Bundled;

package/dist/{derivedStore → vanilla/internal/derivedStore}/cascadeScheduler.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Cascade Scheduler
+ *
+ * - Coalesces derivations into a single microtask.
+ * - Tasks run once at their maximum rank via a ranked dirty queue.
+ * - Doesn't retain snapshots or dependency graphs.
+ * - Component listeners get notified after all derivations have settled.
+ */
 type Rank = number;
 type StoreId = string;
 type Task = () => void;
@@ -20,4 +28,3 @@ export declare function joinCascade(storeId: StoreId, task: Task): void;
  */
 export declare function enqueueDerive(task: Task, rank: Rank): void;
 export {};
-//# sourceMappingURL=cascadeScheduler.d.ts.map

package/dist/vanilla/internal/derivedStore/deriveProxy.d.ts

@@ -0,0 +1,14 @@
+import { BaseStore } from '../../types';
+import { TrackPathFn } from './pathFinder';
+/**
+ * Gets or creates a lightweight tracking proxy that records path access and store
+ * method invocations via proxy traps. Used to auto-generate selectors that point
+ * to either the accessed path or the value returned by an invoked store method.
+ */
+export declare function getOrCreateProxy<S>(store: BaseStore<S>, rootProxyCache: WeakMap<object, unknown>, trackPath: TrackPathFn): S;
+/**
+ * Strips tracking proxies from published values to ensure
+ * proxies remain confined to internal tracking contexts.
+ */
+export declare function stripProxies<T>(value: T): T;
+export declare function stripProxies(value: unknown, seen?: WeakSet<object>): unknown;

package/dist/vanilla/internal/derivedStore/pathFinder.d.ts

@@ -0,0 +1,25 @@
+import { Selector, SubscribableStore } from '../../types';
+type TrackedInvocation = {
+    args: unknown[] | undefined;
+};
+type PathEntry = {
+    path: string[];
+    store: SubscribableStore;
+    invocation?: TrackedInvocation;
+    isLeaf: boolean;
+};
+type SubscriptionBuilder = (store: SubscribableStore, selector: Selector<unknown, unknown>, path: string[]) => void;
+export type PathFinder = {
+    buildProxySubscriptions(createSubscription: SubscriptionBuilder, shouldLog: boolean, minConsolidationDepth?: number, shouldBuild?: (paths: Set<PathEntry>) => boolean): void;
+    reset(): void;
+    trackPath: TrackPathFn;
+};
+export type TrackPathFn = (store: SubscribableStore, path: string[], isLeaf: boolean, invocation?: TrackedInvocation) => void;
+/**
+ * A factory that returns a proxy path-tracking object with three methods:
+ *  - `buildProxySubscriptions()`: builds subscriptions to the final paths
+ *  - `reset()`: clears all tracked paths
+ *  - `trackPath()`: records usage of a store path
+ */
+export declare function createPathFinder(): PathFinder;
+export {};

package/dist/vanilla/internal/derivedStore.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vanilla/internal/errors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Error reported or thrown by the stores package itself.
+ *
+ * If an underlying thrown value caused the failure, it is available as `cause`.
+ */
+export declare class StoresError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}

package/dist/vanilla/internal/logger.d.ts

@@ -0,0 +1,9 @@
+export interface Logger {
+    debug: (message: string, context?: Record<string, unknown>) => void;
+    error: {
+        <T extends Error>(error: T, context?: Record<string, unknown>): void;
+        <T extends string>(error: T, context?: Record<string, unknown>): void;
+    };
+    info: (message: string, context?: Record<string, unknown>) => void;
+    warn: (message: string, context?: Record<string, unknown>) => void;
+}

package/dist/{middleware → vanilla/internal/middleware}/createHydrationGate.d.ts

@@ -1,5 +1,5 @@
+import { StateCreator } from '../../types';
 import { SyncContext } from '../sync/syncEnhancer';
-import { StateCreator } from '../types';
 type WrappedOnRehydrateStorage<S> = (userCallback: ((state: S) => ((finalState?: S, error?: unknown) => void) | void) | undefined, syncContext: SyncContext | undefined) => (state: S) => (finalState?: S, error?: unknown) => void;
 /**
  * Creates hydration-gating middleware that queues state updates until rehydration completes.
@@ -17,4 +17,3 @@ export declare function createHydrationGate<S>(stateCreator: StateCreator<S>): {
     wrapOnRehydrateStorage: WrappedOnRehydrateStorage<S>;
 };
 export {};
-//# sourceMappingURL=createHydrationGate.d.ts.map

package/dist/vanilla/internal/queryStore/queryStoreDefaults.d.ts

@@ -0,0 +1,7 @@
+import { Prettify } from '../../types/objects';
+import { QueryStoreDefaults } from '../config';
+export declare function getQueryStoreDefaults(): Prettify<Required<QueryStoreDefaults>>;
+/**
+ * Exponential backoff: starts at `baseDelay` (5s), doubles each retry, capped at `maxDelay` (5m).
+ */
+export declare function defaultRetryDelay(retryCount: number): number;

package/dist/vanilla/internal/queryStore.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vanilla/internal/runtime.d.ts

@@ -0,0 +1,12 @@
+export { configureStores } from './config';
+export { StoresError } from './errors';
+export { QueryStatuses } from '../queryStore/types';
+export { defaultRetryDelay } from './queryStore/queryStoreDefaults';
+export { getQueryKey, parseQueryKey } from '../queryStore/queryKey';
+export { applyStateUpdate } from '../store/stateUpdate';
+export { replacer, reviver } from '../utils/serialization';
+export { destroyStore, destroyStores, getStoreName, hasGetSnapshot, isDerivedStore, isPersistedStore, isQueryStore, isVirtualStore, } from './storeUtils';
+export { identity, nullObject } from '../utils/core';
+export { createStoreActions } from './createStoreActions';
+export { deepEqual, shallowEqual } from '../utils/equality';
+export { time } from '../utils/time';

package/dist/vanilla/internal/signal.d.ts

@@ -0,0 +1,11 @@
+import type { AttachValue } from '../queryStore/signalTypes';
+import type { StoreApi } from '../store/types';
+import type { EqualityFn, Selector, UnsubscribeFn } from '../types/subscribe';
+export declare const attachValueSubscriptionMap: WeakMap<AttachValue<unknown>, Subscribe>;
+export type Subscribe = (callback: () => void) => UnsubscribeFn;
+export type GetValue = () => unknown;
+export type SetValue = (path: unknown[], value: unknown) => void;
+export declare function $<T>(store: StoreApi<T>): AttachValue<T>;
+export declare function $<T, S>(store: StoreApi<T>, selector: Selector<T, S>, equalityFn?: EqualityFn<S>): AttachValue<S>;
+export declare const createSignal: <T, S>(store: StoreApi<T>, selector: Selector<T, S>, equalityFn: EqualityFn<S>) => [Subscribe, GetValue, SetValue];
+export declare function getAttachValueSubscribeFn<AttachVal extends AttachValue<unknown>>(attachVal: AttachVal): Subscribe | undefined;

package/dist/vanilla/internal/storage/storageCreators.d.ts

@@ -0,0 +1,11 @@
+import type { AsyncPersistStorage, PersistStorageConfig } from '../../store/types';
+import type { AsyncStorageInterface, BaseStoreOptions, EnforceStorageKey, SyncStorageInterface } from '../../types';
+import type { SyncContext } from '../sync/syncEnhancer';
+/**
+ * Creates a persist storage object for the base store.
+ */
+export declare function createPersistStorage<S, PersistedState extends Partial<S>, PersistReturn>(options: EnforceStorageKey<BaseStoreOptions<S, PersistedState, PersistReturn>>, storage: AsyncStorageInterface | SyncStorageInterface | undefined, syncContext: SyncContext | undefined): PersistStorageConfig<S, PersistedState>;
+/**
+ * Creates an asynchronous persist storage adapter.
+ */
+export declare function createAsyncPersistStorage<S, PersistedState extends Partial<S>, PersistReturn>(storage: AsyncStorageInterface, options: EnforceStorageKey<BaseStoreOptions<S, PersistedState, PersistReturn>>, persistThrottleMs: number | undefined, syncContext?: SyncContext): AsyncPersistStorage<S, PersistedState>;