@storesjs/stores 0.9.0 → 0.11.0

package/dist/vanilla/createQueryStore.d.ts

@@ -0,0 +1,110 @@
+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).
+ *
+ * @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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;

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}process.env.NODE_ENV,process.env.NODE_ENV;var r=Object.freeze(Object.create(null));function n(e){return"object"!=typeof e||null===e?e:Object.keys(e).sort().reduce((t,r)=>{const o=e[r];return t[r]=function(e){if("object"!=typeof e||null===e)return!1;const t=Object.getPrototypeOf(e);return null===t||t===Object.prototype}(o)?n(o):o,t},Object.create(r))}var o=Symbol("stores.queryParamConfig");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(e){return JSON.stringify(n(e))},exports.parseQueryKey=function(e){return JSON.parse(e)},exports.queryParam=function(e,t){return{[o]:!0,key:t.key,value:e}};

package/dist/vanilla/index.mjs

@@ -0,0 +1 @@
+import{baseStore as t,derivedStore as e,queryStore as r,virtualStore as n}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 o(t,e,r,n){return t}function u(e,r){const n=t(e,r);return o(n,n.getState,n.getInitialState)}function i(t,r=Object.is){const n=e(t,r);return o(n,n.getSnapshot)}process.env.NODE_ENV,process.env.NODE_ENV;var s=Object.freeze(Object.create(null));function a(t){return JSON.stringify(l(t))}function c(t){return JSON.parse(t)}function l(t){return"object"!=typeof t||null===t?t:Object.keys(t).sort().reduce((e,r)=>{const n=t[r];return e[r]=function(t){if("object"!=typeof t||null===t)return!1;const e=Object.getPrototypeOf(t);return null===e||e===Object.prototype}(n)?l(n):n,e},Object.create(s))}var S=Symbol("stores.queryParamConfig");function f(t,e){return{[S]:!0,key:e.key,value:t}}function p(t,e,n){const u=r(t,e,n);return o(u,u.getState,u.getInitialState)}function y(t,e,r){const u=n(t,e,r);return o(u,u.getState,u.getInitialState)}export{u as createBaseStore,i as createDerivedStore,p as createQueryStore,y as createVirtualStore,a as getQueryKey,c as parseQueryKey,f as queryParam};

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/vanilla/internal/derivedStore/deriveProxy.d.ts

@@ -0,0 +1,14 @@
+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: StoreApi<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/queryParams.d.ts

@@ -0,0 +1,17 @@
+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>;

package/dist/{queryStore → vanilla/internal/queryStore}/queryStoreDefaults.d.ts

@@ -1,8 +1,7 @@
+import { Prettify } from '../../types/objects';
 import { QueryStoreDefaults } from '../config';
-import { Prettify } from '../types/objects';
 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/vanilla/internal/queryStore.d.ts

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

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

@@ -0,0 +1,11 @@
+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';

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

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

@@ -0,0 +1,45 @@
+import type { QueryStore, QueryStoreState } from '../queryStore/types';
+import type { StoreApi } from '../store/types';
+import type { BaseStore, InferStoreState, PersistedStore } from '../types';
+/**
+ * Calls the appropriate reset or destroy method on the store, if available.
+ * Handles both `DerivedStore` and `QueryStore`.
+ */
+export declare function destroyStore(store: BaseStore<unknown> | StoreApi<unknown> | QueryStore<unknown, Record<string, unknown>, unknown>, options?: {
+    clearQueryCache?: boolean;
+}): void;
+export declare function destroyStores(stores: Partial<Record<string, BaseStore<unknown> | StoreApi<unknown>>> | (BaseStore<unknown> | StoreApi<unknown> | undefined)[], options?: {
+    clearQueryCache?: boolean;
+    skipDestroy?: (store: BaseStore<unknown> | StoreApi<unknown>) => boolean;
+}): void;
+/**
+ * Returns the name of the store, either from the `persist` options or the store itself.
+ */
+export declare function getStoreName(store: BaseStore<unknown>): string;
+/**
+ * Checks if a store is a `DerivedStore` and reveals its internal `getSnapshot` method.
+ */
+export declare function hasGetSnapshot<T extends BaseStore<unknown> | StoreApi<unknown>>(store: T): store is T & {
+    getSnapshot: () => InferStoreState<T>;
+};
+/**
+ * Checks if a store is a `QueryStore`.
+ */
+export declare function isQueryStore<T extends object>(store: T): store is Extract<T, BaseStore<QueryStoreState<unknown, Record<string, unknown>, unknown>>>;
+/**
+ * Checks if a store is a `DerivedStore`.
+ */
+export declare function isDerivedStore<T extends BaseStore<unknown> | StoreApi<unknown>>(store: T): store is T & {
+    destroy: () => void;
+    flushUpdates: () => void;
+};
+/**
+ * Checks if a store is persisted.
+ */
+export declare function isPersistedStore<T extends BaseStore<unknown> | PersistedStore<unknown>>(store: T): store is T & {
+    persist: PersistedStore<InferStoreState<T>>['persist'];
+};
+/**
+ * Checks if a store is a virtual store.
+ */
+export declare function isVirtualStore<T extends BaseStore<unknown> | StoreApi<unknown>>(store: T): store is T & BaseStore<InferStoreState<T>>;

package/dist/vanilla/internal/sync/browserSyncEngine.d.ts

@@ -0,0 +1,2 @@
+import { SyncEngine } from '../../sync/types';
+export declare function createBrowserSyncEngine(): SyncEngine;

package/dist/vanilla/internal/sync/noopSyncEngine.d.ts

@@ -0,0 +1,2 @@
+import { SyncEngine } from '../../sync/types';
+export declare function createNoopSyncEngine(): SyncEngine;

package/dist/{sync → vanilla/internal/sync}/syncEnhancer.d.ts

@@ -1,5 +1,5 @@
-import { StateCreator } from '../types';
-import { NormalizedSyncConfig } from './types';
+import { NormalizedSyncConfig } from '../../sync/types';
+import { StateCreator } from '../../types';
 export type SyncContext = {
     isAsync: boolean;
     clearFieldTimestamps: (snapshot: Record<string, number> | undefined) => void;
@@ -23,4 +23,3 @@ export declare function createSyncedStateCreator<T extends Record<string, unknow
  * Readable indices for `FieldMetadata` tuples.
  */
 export declare const TIMESTAMP: 0, SESSION_ID: 1;
-//# sourceMappingURL=syncEnhancer.d.ts.map

package/dist/vanilla/internal/types/internalSubscribeTypes.d.ts

@@ -0,0 +1,15 @@
+import type { Listener, ListenerArgs, Selector, SubscribeOptions } from '../../types/subscribe';
+export type InternalSubscribeOptions<Selected> = SubscribeOptions<Selected> & {
+    isCascadeParticipant?: boolean;
+};
+export type InternalSelectorArgs<S, Selected> = [
+    selector: Selector<S, Selected>,
+    listener: Listener<Selected>,
+    options?: InternalSubscribeOptions<Selected>
+];
+export type InternalSubscribeArgs<S, Selected = unknown> = ListenerArgs<S> | InternalSelectorArgs<S, Selected>;
+export type InternalUnsubscribeFn = (skipAbortFetch?: boolean) => void;
+export type InternalSubscribeOverloads<S> = {
+    (...args: ListenerArgs<S>): InternalUnsubscribeFn;
+    <Selected>(...args: InternalSelectorArgs<S, Selected>): InternalUnsubscribeFn;
+};

package/dist/{utils → vanilla/internal/utils}/persistUtils.d.ts

@@ -1,4 +1,4 @@
-import type { StorageValue } from '../storage/storageTypes';
+import type { StorageValue } from '../../storage/storageTypes';
 /**
  * Default partialize function if none is provided. It omits top-level store
  * methods and keeps all other state.
@@ -6,4 +6,3 @@ import type { StorageValue } from '../storage/storageTypes';
 export declare function omitStoreMethods<S, PersistedState extends Partial<S> = Partial<S>>(state: S): PersistedState;
 export declare function defaultSerializeState<PersistedState>(storageValue: StorageValue<PersistedState>, shouldUseReplacer: boolean): string;
 export declare function defaultDeserializeState<PersistedState>(serializedState: string, shouldUseReviver: boolean): StorageValue<PersistedState>;
-//# sourceMappingURL=persistUtils.d.ts.map

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

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

package/dist/vanilla/queryStore/classes/SubscriptionManager.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Lazy initialization config for subscription handlers.
+ */
+interface SubscriptionHandlerConfig {
+    /**
+     * Callback executed when a subscription is added.
+     * @param isFirstSubscription - Whether this is the first subscription
+     * @param shouldThrottle - Whether to throttle the fetch
+     */
+    onSubscribe: (isFirstSubscription: boolean, shouldThrottle: boolean) => void;
+    /** Callback executed when the last remaining subscription is removed. */
+    onLastUnsubscribe: (willResubscribe?: boolean) => void;
+}
+/**
+ * Manages subscription state and lifecycle events for a `createQueryStore` instance.
+ */
+export declare class SubscriptionManager {
+    private count;
+    private lastSubscriptionTime;
+    private readonly fetchThrottleMs;
+    private onSubscribe;
+    private onLastUnsubscribe;
+    /**
+     * Creates a new SubscriptionManager instance.
+     */
+    constructor(disableAutoRefetching: boolean);
+    /**
+     * Initializes subscription event handlers.
+     */
+    init({ onSubscribe, onLastUnsubscribe }: SubscriptionHandlerConfig): void;
+    hasSubscribers(): boolean;
+    /**
+     * Adds a new subscription and triggers relevant lifecycle callbacks.
+     * @returns A cleanup function that removes the subscription when called
+     */
+    subscribe(): (skipAbortFetch?: boolean) => void;
+}
+export {};

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

@@ -0,0 +1,9 @@
+/**
+ * Generates a deterministic query store `queryKey` from the given
+ * key payload, consistent with internally generated keys.
+ */
+export declare function getQueryKey<TKeyPayload extends Record<string, unknown>>(keyPayload: TKeyPayload): string;
+/**
+ * Parses a query store `queryKey` into the key payload it encodes.
+ */
+export declare function parseQueryKey<TKeyPayload extends Record<string, unknown> = Record<string, unknown>>(queryKey: string): TKeyPayload;

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

@@ -0,0 +1,36 @@
+import type { StoreApi } from '../store/types';
+import type { DeriveGetter } from '../types';
+import type { NonFunction } from '../types/functions';
+declare const QUERY_PARAM_CONFIG: unique symbol;
+/**
+ * Selects how a query parameter participates in the query key.
+ */
+export type QueryParamKey<T> = false | ((value: T) => unknown);
+/**
+ * A query value derived from stores via `$`.
+ */
+export type ReactiveParam<T, State> = ($: DeriveGetter, store: StoreApi<State>) => T;
+/**
+ * Query parameter wrapper for values whose fetcher value and key value differ.
+ */
+export type QueryParamConfig<T, State> = {
+    readonly [QUERY_PARAM_CONFIG]: true;
+    readonly key: QueryParamKey<T>;
+    readonly value: NonFunction<T> | ReactiveParam<T, State>;
+};
+/**
+ * A direct, reactive, or key-configured query parameter.
+ */
+export type QueryParam<T, State> = NonFunction<T> | ReactiveParam<T, State> | QueryParamConfig<T, State>;
+/**
+ * Wraps a query parameter when its full fetcher value should be excluded
+ * from the query key or represented by a smaller key value.
+ */
+export declare function queryParam<T, State>(value: NonFunction<T> | ReactiveParam<T, State>, options: {
+    key: QueryParamKey<T>;
+}): QueryParamConfig<T, State>;
+/**
+ * Checks if a `QueryParam` value is a custom `queryParam(...)` config.
+ */
+export declare function isQueryParamConfig<T, State>(value: QueryParam<T, State>): value is QueryParamConfig<T, State>;
+export {};