@storesjs/stores 0.9.0 → 0.11.0

package/README.md

@@ -1,6 +1,6 @@
 # Stores
 
-Stores provides a minimal, reactive state layer built on top of Zustand.
+Stores provides a minimal, reactive state layer that runs with or without React.
 
 It defines three types of runtime-evaluated stores—**base**, **derived**, and **query**—each representing a distinct state type: local, computed, or asynchronously fetched. Stores track dependencies at runtime, evaluate lazily, and clean up automatically when unused.
 
@@ -10,10 +10,32 @@ All stores expose a consistent interface and can be used both inside and outside
 - **Derived stores** compute values from other stores and re-run only when inputs change.
 - **Query stores** fetch and cache async data, refetching when reactive parameters change.
 
-All store types share a common interface: a React-compatible hook, a
-stable store object with `.getState()` and `.subscribe()`, and optional
-support for persistence. They compose naturally, interoperate cleanly,
-and scale as application complexity grows.
+All store types expose a stable store object with `.getState()` and
+`.subscribe()`, plus optional support for persistence. In the React build,
+stores are also callable hooks. In the vanilla build, stores remain plain store
+objects. They compose naturally, interoperate cleanly, and scale as application
+complexity grows.
+
+## Runtime Modes
+
+The root import is mode-aware:
+
+- React web apps use `@storesjs/stores` by default.
+- React Native apps use `@storesjs/stores`; the `react-native` package condition selects the native build.
+- Vanilla apps use `@storesjs/stores` with the `vanilla` package condition enabled.
+
+For TypeScript vanilla projects, use a condition-aware resolver and add the
+same condition to `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "customConditions": ["vanilla"]
+  }
+}
+```
 
 ## Base Store
 
@@ -21,7 +43,7 @@ A base store defines local state along with an interface for reading and
 updating that state.
 
 ```ts
-export const useSettingsStore = createBaseStore<Settings>(set => ({
+export const settingsStore = createBaseStore<Settings>(set => ({
   currency: 'USD',
   setCurrency: currency => set({ currency }),
 }));
@@ -30,14 +52,14 @@ export const useSettingsStore = createBaseStore<Settings>(set => ({
 In React, subscribe to values with selectors:
 
 ```ts
-const currency = useSettingsStore(s => s.currency);
+const currency = settingsStore(s => s.currency);
 ```
 
 Outside React:
 
 ```ts
-useSettingsStore.getState().currency;
-useSettingsStore.subscribe(selector, listener, options);
+settingsStore.getState().currency;
+settingsStore.subscribe(selector, listener, options);
 ```
 
 Enable persistence per store:
@@ -52,7 +74,7 @@ createBaseStore<Settings>(set => ({ ... }), {
 You can also export actions as a stable object:
 
 ```ts
-export const settingsActions = createStoreActions(useSettingsStore);
+export const settingsActions = createStoreActions(settingsStore);
 ```
 
 ## Derived Store
@@ -61,9 +83,9 @@ Derived stores compute values from other stores. The `$` accessor tracks
 dependencies at runtime:
 
 ```ts
-export const useTotal = createDerivedStore($ => {
-  const { currency } = $(useSettingsStore);
-  const { subtotal, tax } = $(useCartStore);
+export const totalStore = createDerivedStore($ => {
+  const { currency } = $(settingsStore);
+  const { subtotal, tax } = $(cartStore);
   return formatTotal(currency, subtotal, tax);
 });
 ```
@@ -78,10 +100,10 @@ Query stores manage remote data. They fetch, cache, and revalidate based
 on reactive parameters:
 
 ```ts
-export const useAccountStore = createQueryStore<Account, Params>({
+export const accountStore = createQueryStore<Account, Params>({
   fetcher: fetchAccount,
   params: {
-    userId: $ => $(useAuthStore).userId,
+    userId: $ => $(authStore).userId,
   },
   staleTime: time.minutes(10),
 });
@@ -93,13 +115,13 @@ idle.
 Use it in React:
 
 ```ts
-const account = useAccountStore(s => s.getData());
+const account = accountStore(s => s.getData());
 ```
 
 Or imperatively:
 
 ```ts
-useAccountStore.getState().fetch();
+accountStore.getState().fetch();
 ```
 
 Query stores support full customization: extended local state, manual cache control, configurable staleness and retry behavior, and optional persistence.
@@ -108,22 +130,26 @@ They deduplicate fetches across consumers and compute stable query keys automati
 
 ## Store Interface
 
-All stores implement the same API:
+All stores implement the same store-object API:
 
 ```ts
-useStore()
-useStore(selector, equalityFn?)
+store.getState()
+store.setState() // Except for derived stores
+store.subscribe(selector, listener, options?)
+```
 
-useStore.getState()
-useStore.setState() // Except for derived stores
-useStore.subscribe(selector, listener, options?)
+In the React build, stores are also callable hooks:
+
+```ts
+store()
+store(selector, equalityFn?)
 ```
 
 ## Composed Example
 
 ```ts
-export const useCurrencyFormatter = createDerivedStore($ => {
-  const { currency, locale } = $(useSettingsStore);
+export const currencyFormatterStore = createDerivedStore($ => {
+  const { currency, locale } = $(settingsStore);
   return new Intl.NumberFormat(locale, {
     currency,
     style: 'currency',
@@ -132,16 +158,16 @@ export const useCurrencyFormatter = createDerivedStore($ => {
 ```
 
 ```ts
-export const useAccountBalance = createDerivedStore($ => {
-  const balance = $(useAccountStore).getData()?.balance ?? 0;
-  const formatter = $(useCurrencyFormatter);
+export const accountBalanceStore = createDerivedStore($ => {
+  const balance = $(accountStore).getData()?.balance ?? 0;
+  const formatter = $(currencyFormatterStore);
   return formatter.format(balance);
 });
 ```
 
 ```ts
 function AccountSummary() {
-  const balance = useAccountBalance();
+  const balance = accountBalanceStore();
   return <Text>Balance: {balance}</Text>;
 }
 ```

package/dist/createBaseStore.d.ts

@@ -1,36 +1,36 @@
-import { BaseStoreOptions, OptionallyPersistedStore, Store, StateCreator } from './types';
+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 Zustand store with the specified state.
+ * @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 Zustand store with the specified state and persistence.
+ * @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>;
+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>;
 /**
  * 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 Zustand store with the specified state and persistence.
+ * @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>;
+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>;
 /**
  * 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 Zustand store with the specified state and optional persistence.
+ * @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 Zustand store with the specified state and optional persistence.
+ * @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>;
 //# sourceMappingURL=createBaseStore.d.ts.map

package/dist/createDerivedStore.d.ts

@@ -1,8 +1,8 @@
-import { DeriveOptions, DerivedStore, EqualityFn, Store, Selector, InferStoreState } from './types';
+import type { DeriveGetter, DeriveOptions, DerivedStore } from './types';
 /**
  * ### `createDerivedStore`
  *
- * Creates a **read-only** store derived from one or more underlying Zustand stores.
+ * 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.
@@ -28,10 +28,10 @@ import { DeriveOptions, DerivedStore, EqualityFn, Store, Selector, InferStoreSta
  *
  * ---
  * Derived stores automatically unsubscribe from all dependencies when no consumers remain, and
- * resubscribe when new consumers appear. The returned function doubles as:
+ * resubscribe when new consumers appear. The returned store exposes:
  *
- * - A **React hook** (`const state = useDerivedStore(selector, equalityFn?)`)
  * - 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)
@@ -44,28 +44,20 @@ import { DeriveOptions, DerivedStore, EqualityFn, Store, Selector, InferStoreSta
  * @example
  * ```ts
  * // Create a derived store
- * const useSearchResults = createDerivedStore($ => {
- *   const query = $(useSearchStore).query.trim().toLowerCase();
- *   const items = $(useItemsStore).items;
+ * const searchResultsStore = createDerivedStore($ => {
+ *   const query = $(searchStore).query.trim().toLowerCase();
+ *   const items = $(itemsStore).items;
  *   return findResults(query, items);
  * }, shallowEqual);
  *
- * function SearchResults() {
- *   // Consume the derived state
- *   const results = useSearchResults(); // Or (selector, equalityFn?)
- *   return <ResultsList items={results} />;
- * }
+ * 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 (usable as a hook or standard store object).
+ * @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>;
-export type DeriveGetter = {
-    <S extends Store<unknown>>(store: S): InferStoreState<S>;
-    <S extends Store<unknown>, Selected>(store: S, selector: Selector<InferStoreState<S>, Selected>, equalityFn?: EqualityFn<Selected>): Selected;
-};
 //# sourceMappingURL=createDerivedStore.d.ts.map

package/dist/createQueryStore.d.ts

@@ -1,6 +1,10 @@
-export { defaultRetryDelay } from './queryStore/queryStoreDefaults';
-import { QueryStoreConfig, QueryStoreState } from './queryStore/types';
-import { BaseStoreOptions, OptionallyPersistedStore, PersistedStore, StateCreator, Store } from './types';
+import { defaultRetryDelay } from './internal/runtime';
+import type { QueryStoreConfig, QueryStoreState } from './queryStore/types';
+import type { BaseStoreOptions, OptionallyPersistedStore, PersistedStore, StateCreator, Store } from './types';
+export { defaultRetryDelay };
+export { getQueryKey, parseQueryKey } from './queryStore/queryKey';
+export { queryParam } from './queryStore/queryParam';
+export type { QueryParam, QueryParamConfig, QueryParamKey, ReactiveParam } from './queryStore/queryParam';
 /**
  * Creates a persisted, query-enabled store with data fetching capabilities (sync storage).
  *
@@ -9,7 +13,7 @@ import { BaseStoreOptions, OptionallyPersistedStore, PersistedStore, StateCreato
  * @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>;
+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>;
 /**
  * Creates a persisted, query-enabled store with data fetching capabilities (async storage).
  *
@@ -18,7 +22,7 @@ export declare function createQueryStore<TQueryFnData, TParams extends Record<st
  * @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>;
+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>;
 /**
  * Creates a persisted, query-enabled store with data fetching capabilities (sync storage).
  *
@@ -28,7 +32,7 @@ export declare function createQueryStore<TQueryFnData, TParams extends Record<st
  * @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>;
+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>;
 /**
  * Creates a persisted, query-enabled store with data fetching capabilities (async storage).
  *
@@ -38,7 +42,7 @@ export declare function createQueryStore<TQueryFnData, TParams extends Record<st
  * @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>;
+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>;
 /**
  * Creates a query-enabled store with data fetching capabilities.
  *
@@ -104,13 +108,4 @@ export declare function createQueryStore<TQueryFnData, TParams extends Record<st
  * @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;
 //# sourceMappingURL=createQueryStore.d.ts.map

package/dist/createVirtualStore.d.ts

@@ -1,5 +1,4 @@
-import { DeriveGetter } from './createDerivedStore';
-import { BaseStore, InferPersistedState, InferSetStateReturn, InferStoreState, OptionallyPersistedStore } from './types';
+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 = {

package/dist/env.native.d.ts

@@ -1,9 +1,7 @@
-import { unstable_batchedUpdates } from 'react-native';
 export declare const IS_REACT_NATIVE = true;
 export declare const IS_BROWSER = false;
 export declare const IS_IOS: boolean;
 export declare const IS_ANDROID: boolean;
 export declare const IS_DEV: boolean;
 export declare const IS_TEST: boolean;
-export { unstable_batchedUpdates };
 //# sourceMappingURL=env.native.d.ts.map

package/dist/env.web.d.ts

@@ -4,5 +4,4 @@ export declare const IS_IOS = false;
 export declare const IS_ANDROID = false;
 export declare const IS_DEV: boolean;
 export declare const IS_TEST: boolean;
-export declare const unstable_batchedUpdates: <T>(callback: () => T) => T;
 //# sourceMappingURL=env.web.d.ts.map

package/dist/hooks/useListen.d.ts

@@ -61,7 +61,7 @@ export type UseListenOptions<Selected> = {
 /**
  * ### `useListen`
  *
- * Subscribes to a slice of a Zustand store and runs a callback whenever that slice changes,
+ * Subscribes to a slice of a store and runs a callback whenever that slice changes,
  * **without triggering re-renders**.
  *
  * Useful for forwarding updates to non-React state (e.g. Reanimated shared values), scoped side
@@ -75,7 +75,7 @@ export type UseListenOptions<Selected> = {
  * They take effect only if a resubscription occurs.
  *
  * ---
- * @param store - Zustand store to listen to. Should be a stable reference.
+ * @param store - Store to listen to. Should be a stable reference.
  * @param selector - Selects the slice of the store state to listen to.
  * @param react - Triggered when the selected slice changes. Receives `(current, previous, unsubscribe)`.
  * @param optionsOrEqualityFn - Optional `equalityFn`, `fireImmediately` settings, forwarded to `store.subscribe`.

package/dist/index.d.ts

@@ -1,19 +1,4 @@
-export { configureStores } from './config';
-export { createBaseStore } from './createBaseStore';
-export * from './createDerivedStore';
-export * from './createQueryStore';
-export * from './createVirtualStore';
-export { StoresError } from './errors';
-export { replacer, reviver } from './utils/serialization';
-export { applyStateUpdate, destroyStore, destroyStores, getStoreName, hasGetSnapshot, isDerivedStore, isPersistedStore, isQueryStore, isVirtualStore, } from './utils/storeUtils';
+export * from './index.shared';
 export * from './hooks/useListen';
 export * from './hooks/useStableValue';
-export * from './sync/types';
-export * from './queryStore/types';
-export * from './storage/storageTypes';
-export * from './types';
-export { identity, nullObject } from './utils/core';
-export * from './utils/createStoreActions';
-export { deepEqual, shallowEqual } from './utils/equality';
-export { time } from './utils/time';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.shared.d.ts

@@ -0,0 +1,14 @@
+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';
+//# sourceMappingURL=index.shared.d.ts.map

package/dist/index.vanilla.d.ts

@@ -0,0 +1,2 @@
+export * from './index.shared';
+//# sourceMappingURL=index.vanilla.d.ts.map

package/dist/internal/baseStore.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=baseStore.d.ts.map

package/dist/{config.d.ts → internal/config.d.ts}

@@ -1,9 +1,9 @@
+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';
-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';
 /**
  * Global configuration for all stores.
  */
@@ -44,9 +44,6 @@ export type QueryStoreDefaults = Prettify<ConfigDefaults<QueryStoreConfig<unknow
 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>;
-type Options = Pick<StoresConfig, 'queryStoreDefaults'>;
-type StorageConfig = Pick<StoresConfig, 'storage' | 'syncEngine'>;
-export declare const DEFAULT_STORAGE_KEY_PREFIX = "stores:";
 /**
  * Configures global defaults for all stores.
  *
@@ -63,8 +60,5 @@ export declare const DEFAULT_STORAGE_KEY_PREFIX = "stores:";
  * ```
  */
 export declare function configureStores(config: Partial<StoresConfig>): void;
-export declare function getOptions(): Options | undefined;
-export declare function getStorageConfig(): StorageConfig;
-export declare function markStoreCreated(): void;
 export {};
 //# sourceMappingURL=config.d.ts.map

package/dist/{utils → internal}/createStoreActions.d.ts

@@ -1,8 +1,7 @@
-import { StoreApi } from 'zustand';
-import { InferStoreState } from '../types';
-import { NoOverlap } from '../types/objects';
-import { FunctionKeys, FunctionRecord } from '../types/functions';
-export type StoreActions<Store extends StoreApi<unknown>> = Pick<InferStoreState<Store>, FunctionKeys<InferStoreState<Store>>>;
+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.
  *

package/dist/{derivedStore → internal/derivedStore}/deriveProxy.d.ts

@@ -1,11 +1,11 @@
-import { BaseStore } from '../types';
+import type { StoreApi } from '../../store/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<BaseStore<unknown>, unknown>, trackPath: TrackPathFn): S;
+export declare function getOrCreateProxy<S>(store: StoreApi<S>, rootProxyCache: WeakMap<object, unknown>, trackPath: TrackPathFn): S;
 /**
  * Strips tracking proxies from published values to ensure
  * proxies remain confined to internal tracking contexts.

package/dist/{derivedStore → internal/derivedStore}/pathFinder.d.ts

@@ -1,7 +1,6 @@
-import { Selector, SubscribableStore } from '../types';
+import { Selector, SubscribableStore } from '../../types';
 type TrackedInvocation = {
     args: unknown[] | undefined;
-    method: string;
 };
 type PathEntry = {
     path: string[];

package/dist/internal/derivedStore.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=derivedStore.d.ts.map

package/dist/{errors.d.ts → internal/errors.d.ts}

@@ -7,8 +7,4 @@ export declare class StoresError extends Error {
     cause?: unknown;
     constructor(message: string, cause?: unknown);
 }
-/**
- * Normalizes unknown thrown values for store state and promise rejection paths.
- */
-export declare function ensureError(error: unknown): Error;
 //# sourceMappingURL=errors.d.ts.map

package/dist/{logger.d.ts → internal/logger.d.ts}

@@ -7,6 +7,4 @@ export interface Logger {
     info: (message: string, context?: Record<string, unknown>) => void;
     warn: (message: string, context?: Record<string, unknown>) => void;
 }
-export declare let logger: Logger;
-export declare function setLogger(customLogger: Logger): void;
 //# sourceMappingURL=logger.d.ts.map

package/dist/internal/middleware/createHydrationGate.d.ts

@@ -0,0 +1,20 @@
+import { StateCreator } from '../../types';
+import { SyncContext } from '../sync/syncEnhancer';
+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.
+ *
+ * **Before hydration**: Queues all `set()` calls and flushes them sequentially after rehydration.
+ *
+ * **After hydration**: Passes `set()` calls through synchronously without batching.
+ *
+ * This ensures persistence sees a fully rehydrated base state before applying queued updates,
+ * while keeping in-memory state changes synchronous post-hydration.
+ */
+export declare function createHydrationGate<S>(stateCreator: StateCreator<S>): {
+    hydrationPromise: () => Promise<void>;
+    stateCreator: StateCreator<S>;
+    wrapOnRehydrateStorage: WrappedOnRehydrateStorage<S>;
+};
+export {};
+//# sourceMappingURL=createHydrationGate.d.ts.map

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

@@ -0,0 +1,18 @@
+import type { QueryParam, ReactiveParam } from '../../queryStore/queryParam';
+import type { StoreApi } from '../../store/types';
+import type { InternalUnsubscribeFn } from '../types/internalSubscribeTypes';
+export type TrackedValue<T> = {
+    readonly initialValue: T;
+    subscribe(listener: (value: T) => void): InternalUnsubscribeFn;
+};
+export type QueryParams<TParams extends Record<string, unknown>> = {
+    buildKey(params?: TParams): string;
+    complete(params: Partial<TParams> | undefined): TParams;
+    get(): TParams;
+    subscribe(onChange: (key: keyof TParams, oldValue: unknown, newValue: unknown) => void): InternalUnsubscribeFn;
+};
+export declare function createQueryParams<TParams extends Record<string, unknown>, State>(params: {
+    [K in keyof TParams]: QueryParam<TParams[K], State>;
+} | undefined, store: StoreApi<State>, requiredKeys: (keyof TParams)[]): QueryParams<TParams>;
+export declare function trackQueryValue<T, State>(getValue: ReactiveParam<T, State>, ownerStore: StoreApi<State>): TrackedValue<T>;
+//# sourceMappingURL=queryParams.d.ts.map

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

@@ -0,0 +1,8 @@
+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;
+//# sourceMappingURL=queryStoreDefaults.d.ts.map

package/dist/internal/queryStore.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queryStore.d.ts.map

package/dist/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 { 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';
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1,12 @@
+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>;
+//# sourceMappingURL=storageCreators.d.ts.map