@storesjs/stores 0.9.0 → 0.10.0

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

@@ -0,0 +1,30 @@
+/**
+ * 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;
+export declare function isCascadeActive(): boolean;
+/**
+ * Rank of the currently running derive batch, or null if not in a batch.
+ */
+export declare function getCurrentDeriveRank(): Rank | null;
+/**
+ * Arms the cascade and schedules a single microtask flush.
+ */
+export declare function activateCascade(): void;
+/**
+ * Enlist one per-store component flush (idempotent per store).
+ */
+export declare function joinCascade(storeId: StoreId, task: Task): void;
+/**
+ * Enqueue (or upgrade) a derive task with the given rank.
+ * If the task is already present, we keep the maximum rank (run later).
+ */
+export declare function enqueueDerive(task: Task, rank: Rank): void;
+export {};

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/{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,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>;

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/{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,66 @@
+/**
+ * Initialization config for the SubscriptionManager.
+ */
+interface SubscriptionManagerConfig {
+    /**
+     * The store's `disableAutoRefetching` option, passed through from the query config.
+     */
+    disableAutoRefetching: boolean;
+    /**
+     * The initial enabled state for the SubscriptionManager.
+     */
+    initialEnabled: boolean;
+}
+/**
+ * Lazy initialization config for subscription handlers.
+ */
+interface SubscriptionHandlerConfig {
+    /**
+     * Callback executed when a subscription is added.
+     * @param enabled - The current enabled state
+     * @param isFirstSubscription - Whether this is the first subscription
+     * @param shouldThrottle - Whether to throttle the fetch
+     */
+    onSubscribe: (enabled: boolean, 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 enabled;
+    private lastSubscriptionTime;
+    private readonly fetchThrottleMs;
+    private onSubscribe;
+    private onLastUnsubscribe;
+    /**
+     * Creates a new SubscriptionManager instance.
+     */
+    constructor({ disableAutoRefetching, initialEnabled }: SubscriptionManagerConfig);
+    /**
+     * Initializes subscription event handlers.
+     */
+    init({ onSubscribe, onLastUnsubscribe }: SubscriptionHandlerConfig): void;
+    /**
+     * Returns the current subscription state.
+     * @returns An object containing `enabled`, `lastSubscriptionTime`, and `subscriptionCount`
+     */
+    get(): {
+        enabled: boolean;
+        lastSubscriptionTime: number | null;
+        subscriptionCount: number;
+    };
+    /**
+     * Updates the enabled state for queries.
+     * @param enabled - The new enabled state
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 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,2 @@
+export declare function getQueryKey<TParams extends Record<string, unknown>>(params: TParams): string;
+export declare function parseQueryKey<TParams extends Record<string, unknown>>(queryKey: string): TParams;

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

@@ -0,0 +1,13 @@
+import type { StoreApi } from '../store/types';
+import type { EqualityFn, Selector } from '../types/subscribe';
+type NestedAttachValue<T> = T extends object ? {
+    readonly [K in keyof T]: AttachValue<T[K]>;
+} : Record<string, never>;
+export type AttachValue<T> = {
+    readonly value: T;
+} & NestedAttachValue<T>;
+export type SignalFunction = {
+    <T>(store: StoreApi<T>): AttachValue<T>;
+    <T, S>(store: StoreApi<T>, selector: Selector<T, S>, equalityFn?: EqualityFn<S>): AttachValue<S>;
+};
+export {};