@storesjs/stores 0.8.6 → 0.9.0

package/dist/sync/types.d.ts

@@ -1,4 +1,4 @@
-type UnknownFunction = (...args: unknown[]) => unknown;
+import { UnknownFunction } from '../types/functions';
 /**
  * Metadata for a field's last write.
  */
@@ -9,147 +9,86 @@ export type SyncStateKey<T extends Record<string, unknown>> = Extract<{
 export type SyncValues<T extends Record<string, unknown>> = Partial<T> & {
     [K in SyncStateKey<T>]?: T[K];
 };
-export type RecordDeltaPayload<TValue = unknown> = {
-    readonly clear?: true;
-    readonly del?: readonly string[];
-    readonly set?: Record<string, TValue>;
-    readonly patch?: Record<string, RecordDeltaPayload>;
-};
-export type SyncDeltaPayload<TValue = unknown> = {
-    readonly kind: 'record';
-} & RecordDeltaPayload<TValue>;
-export type SyncDeltaDescriptor = {
-    /**
-     * Minimum fraction of the full payload the delta must save (0–1).
-     */
-    readonly minSavingsRatio?: number;
-    /**
-     * Minimum number of bytes the delta must save compared to sending the full payload.
-     */
-    readonly minSavingsBytes?: number;
-};
-/**
- * Per-field delta configuration. Use `true` to enable with defaults, or provide thresholds.
- */
-export type SyncDeltaConfig<T extends Record<string, unknown>> = Partial<Record<SyncStateKey<T>, SyncDeltaDescriptor | true>>;
-export type SyncDeltaMap<T extends Record<string, unknown>> = Partial<Record<SyncStateKey<T>, SyncDeltaPayload<T[SyncStateKey<T>]>>>;
 export type SyncUpdate<T extends Record<string, unknown>> = {
-    deltas?: SyncDeltaMap<T>;
     replace: boolean;
     sessionId: string;
     timestamp: number;
     values: SyncValues<T>;
 };
+/**
+ * Passed to `SyncEngine.register()` to connect a store to the sync system.
+ */
 export type SyncRegistration<T extends Record<string, unknown>> = {
+    /** Callback invoked by the engine to apply incoming remote updates to the store. */
     apply: (update: SyncUpdate<T>) => void;
+    /** The state keys to sync. Non-function properties only. */
     fields: ReadonlyArray<SyncStateKey<T>>;
+    /** Returns the store's current state. Used by engines that need to read state (e.g., for diffing). */
     getState: () => T;
+    /** Unique identifier for this store. Must match across clients to sync the same data. */
     key: string;
-    delta?: SyncDeltaConfig<T>;
 };
+/**
+ * Returned by `SyncEngine.register()`. Controls the lifecycle of a synced store.
+ */
 export interface SyncHandle<T extends Record<string, unknown>> {
+    /**
+     * Permanently removes this store from the sync engine. After calling, the handle
+     * is invalid and the store will no longer send or receive updates. To temporarily
+     * pause sync, use `onFirstSubscribe`/`onLastUnsubscribe` lifecycle hooks instead.
+     */
     destroy: () => void;
+    /** Returns `true` once the store has received its initial state from the engine. */
     hydrated?: () => boolean;
+    /**
+     * Called when the store's subscriber count goes from 0 to 1. The registration
+     * remains active. Use for lazy resource acquisition (e.g., opening a WebSocket).
+     */
+    onFirstSubscribe?: () => void;
+    /** Registers a one-time callback to run when hydration completes. */
     onHydrated?: (callback: () => void) => void;
+    /**
+     * Called when the store's subscriber count drops to 0. The registration remains
+     * active and `onFirstSubscribe` will fire again on the next subscription.
+     * Use for resource cleanup (e.g., closing idle connections).
+     */
+    onLastUnsubscribe?: () => void;
+    /**
+     * Broadcasts a state update to other clients. Set to `null` for engines where
+     * publishing is implicit (e.g., `chrome.storage` where the write itself triggers sync).
+     */
     publish: ((update: SyncUpdate<T>) => void) | null;
 }
+/**
+ * Interface for multi-client state synchronization. Stores register to send and receive updates.
+ */
 export interface SyncEngine {
-    register<T extends Record<string, unknown>>(registration: SyncRegistration<T>): SyncHandle<T>;
-    registerPresence?<Presence>(registration: SyncPresenceRegistration<Presence>): SyncPresenceChannel<Presence> | null;
     /**
-     * When true, injects sync metadata (`{ origin, timestamp, fields }`) into the persisted
-     * storage payload. Only takes effect when used with a persisted store.
-     *
-     * Useful for sync engines that use storage events as their transport (e.g., `chrome.storage`).
+     * When `true`, embeds sync metadata (`{ origin, timestamp, fields }`) into persisted
+     * storage values. Required for engines that use storage writes as their transport.
+     * Only effective when the store is also persisted.
      * @default false
      */
     readonly injectStorageMetadata?: boolean;
+    /** Registers a store for synchronization. Returns a handle to control the sync lifecycle. */
+    register: {
+        <T extends Record<string, unknown>>(registration: SyncRegistration<T>): SyncHandle<T>;
+        (registration: SyncRegistration<Record<string, unknown>>): SyncHandle<Record<string, unknown>>;
+    };
+    /** Unique identifier for this client session. Used for conflict resolution and filtering self-updates. */
     readonly sessionId: string;
 }
 export type SyncMergeFn<T, TState = unknown> = (incoming: T, current: T, currentState: TState, incomingValues: Partial<TState>) => T;
-export type SyncPresenceJoinHandler<Presence> = (userId: string, data: Presence) => void;
-export type SyncPresenceUpdateHandler<Presence> = (userId: string, data: Presence) => void;
-export type SyncPresenceLeaveHandler = (userId: string) => void;
-export type PresencePruneStrategy = 'updates' | 'activity';
-type PresenceActivityField<Presence> = Presence extends Record<string, unknown> ? Extract<keyof Presence, string> : string;
-export type SyncPresenceHeartbeatConfig<Presence> = {
-    /** Interval in milliseconds between heartbeat broadcasts */
-    interval: number;
-    /** Reuse the last presence payload for each heartbeat (default). */
-    behavior?: 'reuse' | undefined;
-} | {
-    /** Interval in milliseconds between heartbeat broadcasts */
-    interval: number;
-    /** Clone the payload and refresh an activity field on every heartbeat. */
-    behavior: 'refresh-activity';
-    /**
-     * Field from the presence payload to refresh. Defaults to the prune strategy's activity field or `timestamp`.
-     */
-    activityField?: PresenceActivityField<Presence>;
-} | {
-    /** Interval in milliseconds between heartbeat broadcasts */
-    interval: number;
-    /** Derive a custom payload for each heartbeat. */
-    behavior: 'transform';
-    /**
-     * Transform invoked before each heartbeat. Return a payload to broadcast, or void to reuse the current data.
-     */
-    onHeartbeat: (currentData: Presence) => Presence | void;
-};
-export type SyncPresenceRegistration<Presence> = {
-    key: string;
-    /**
-     * Optional heartbeat configuration. When enabled, presence data is re-broadcast at the
-     * specified interval. Use `'reuse'` (default) to emit the last payload unchanged, `'refresh-activity'`
-     * to automatically update a timestamp-like field on object payloads, or `'transform'` to derive a custom payload.
-     */
-    heartbeat?: SyncPresenceHeartbeatConfig<Presence>;
-    /**
-     * Optional stale presence pruning. When enabled, remote presence entries that
-     * haven't been updated within the specified threshold are automatically removed.
-     */
-    pruneStale?: {
-        /**
-         * Determines how staleness is evaluated.
-         * - `updates` (default) considers the time since the last presence message arrived.
-         * - `activity` considers a timestamp field within the presence payload (defaults to `timestamp`).
-         */
-        basedOn?: PresencePruneStrategy;
-        /**
-         * Field from the presence payload to inspect when `basedOn` is set to `activity`.
-         * Defaults to `timestamp`.
-         */
-        activityField?: PresenceActivityField<Presence>;
-        /** Time in milliseconds after which presence is considered stale */
-        after: number;
-        /** Optional callback invoked before removing stale presence */
-        onPrune?: (userId: string, data: Presence) => void;
-    };
-    onJoin?: SyncPresenceJoinHandler<Presence>;
-    onLeave?: SyncPresenceLeaveHandler;
-    onUpdate?: SyncPresenceUpdateHandler<Presence>;
-};
-export interface SyncPresenceChannel<Presence> {
-    join(userId: string, data: Presence): void;
-    leave(): void;
-    update(data: Presence): void;
-    /**
-     * Destroys the presence channel and cleans up all resources.
-     * Automatically calls leave() and clears all timers.
-     * Safe to call multiple times.
-     */
-    destroy(): void;
-}
 export type SyncConfig<T extends Record<string, unknown>> = {
-    engine?: SyncEngine;
-    fields?: ReadonlyArray<SyncStateKey<T>>;
     /**
-     * The delta configuration for the sync engine.
+     * The sync engine implementation to use.
      *
-     * Only takes effect when used with delta-enabled engines like `NetworkSyncEngine`.
-     * @default undefined
+     * Defaults to cross-tab sync in browser environments. No-op in other environments unless a
+     * custom engine is provided.
      */
-    delta?: SyncDeltaConfig<T>;
+    engine?: SyncEngine;
+    /** The state keys to sync. If unspecified, all non-function store properties are synced. */
+    fields?: ReadonlyArray<SyncStateKey<T>>;
     /**
      * When true, injects sync metadata (`{ origin, timestamp, fields }`) into the persisted
      * storage payload. Only takes effect when used with a persisted store.
@@ -160,7 +99,9 @@ export type SyncConfig<T extends Record<string, unknown>> = {
      * @default false
      */
     injectStorageMetadata?: boolean;
+    /** The key used to identify the store to the sync engine. Required if `storageKey` is absent. */
     key?: string;
+    /** Optional merge function to use for each synced state key. Use with caution. */
     merge?: {
         [K in SyncStateKey<T>]?: SyncMergeFn<T[K], T>;
     };
@@ -171,20 +112,4 @@ export type SyncConfig<T extends Record<string, unknown>> = {
 export type NormalizedSyncConfig<T extends Record<string, unknown>> = SyncConfig<T> & {
     key: string;
 };
-export type SyncAuthPhase = 'connect' | 'refresh' | 'challenge';
-export type SyncAuthPayload = {
-    readonly headers?: Record<string, string>;
-    readonly query?: Record<string, string>;
-    readonly token?: string;
-};
-export type SyncAuthFailure = {
-    readonly code: string;
-    readonly message?: string;
-    readonly retryable: boolean;
-};
-export type SyncAuthenticator = {
-    readonly getPayload: (phase: SyncAuthPhase) => Promise<SyncAuthPayload | null> | SyncAuthPayload | null;
-    readonly onFailure?: (failure: SyncAuthFailure) => void;
-};
-export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types/functions.d.ts

@@ -1,7 +1,24 @@
-/** Extract the keys of T whose values are functions. */
+/**
+ * Relaxes function parameter variance to allow subtype
+ * assignment otherwise blocked by strict contravariance.
+ */
+export type BivariantMethod<T extends Record<string, UnknownFunction>> = T[keyof T];
+/**
+ * Extract the keys of `T` whose values are functions.
+ */
 export type FunctionKeys<T> = {
     [K in keyof T]-?: T[K] extends UnknownFunction ? K : never;
 }[keyof T];
-export type OmitFunctionKeys<T> = Omit<T, FunctionKeys<T>>;
+/**
+ * A record of string keys to unknown functions.
+ */
+export type FunctionRecord = Record<string, UnknownFunction>;
+/**
+ * Return `T` if it is **not** a function, otherwise `never`.
+ */
+export type NonFunction<T> = T extends (...args: infer _) => unknown ? never : T;
+/**
+ * Unknown generic function type.
+ */
 export type UnknownFunction = (...args: never[]) => unknown;
 //# sourceMappingURL=functions.d.ts.map

package/dist/types/objects.d.ts

@@ -1,4 +1,11 @@
-import { FunctionKeys, UnknownFunction } from './functions';
-export type NoOverlap<State, Bundled extends ObjectMethods> = Extract<keyof Bundled, FunctionKeys<State>> extends never ? Bundled : never;
-export type ObjectMethods = Record<string, UnknownFunction>;
+/**
+ * Forces TypeScript to expand a type for clearer IDE display.
+ */
+export type Prettify<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+/**
+ * Enforce no overlapping keys between two objects.
+ */
+export type NoOverlap<A, B> = B & Record<Extract<keyof A, keyof B>, never>;
 //# sourceMappingURL=objects.d.ts.map

package/dist/types/utils.d.ts

@@ -1,5 +1,5 @@
 /**
- * Safe `hasOwnProperty` check. Use to guard `for..in` loops against inherited properties.
+ * Typed `hasOwnProperty` alias.
  */
 export declare function hasOwn<T extends Record<string, unknown>, K extends string>(value: T, key: K): value is T & Record<K, unknown>;
 /**

package/dist/types.d.ts

@@ -1,16 +1,17 @@
-import { Mutate, StateCreator as ZustandStateCreator, StoreApi } from 'zustand';
-import { PersistOptions } from 'zustand/middleware';
-import { UseBoundStoreWithEqualityFn } from 'zustand/traditional';
-import { StorageValue } from './storage/storageTypes';
-import { SyncConfig } from './sync/types';
+import type { Mutate, StateCreator as ZustandStateCreator, StoreApi, StoreMutatorIdentifier } from 'zustand';
+import type { PersistOptions } from 'zustand/middleware';
+import type { StorageValue } from './storage/storageTypes';
+import type { SyncConfig } from './sync/types';
 type SubscribeWithSelector = ['zustand/subscribeWithSelector', never];
+export type StoreMutators = [StoreMutatorIdentifier, unknown][];
+export type StoreMutatorsWithSelector<Mutators extends StoreMutators = StoreMutators> = [SubscribeWithSelector, ...Mutators];
 type HydrationPromise<PersistReturn> = PersistReturn extends Promise<void> ? {
     /** Invoke to get a promise that resolves once hydration completes. */
     hydrationPromise: () => Promise<void>;
 } : {
     hydrationPromise?: undefined;
 };
-export type StorePersist<Store, PersistedState, PersistReturn> = Store extends {
+type WithPersist<Store, PersistedState, PersistReturn> = Store extends {
     getState: () => infer S;
     setState: {
         (...args: infer SetPartialArgs): infer _;
@@ -30,18 +31,16 @@ export type StorePersist<Store, PersistedState, PersistReturn> = Store extends {
     } & HydrationPromise<PersistReturn>;
 } : never;
 export type StateCreator<S, U = S> = ZustandStateCreator<S, [SubscribeWithSelector], [SubscribeWithSelector], U>;
+export type UseBoundStoreWithEqualityFn<Store extends StoreApi<unknown>, State = InferStoreState<Store>> = UseStoreCallSignatures<State> & Store;
 export type BaseStore<S, ExtraSubscribeOptions extends boolean = false> = UseBoundStoreWithEqualityFn<Mutate<StoreApi<S>, [SubscribeWithSelector]>> & {
     subscribe: SubscribeOverloads<S, ExtraSubscribeOptions>;
 };
-export type PersistedStore<S, PersistedState = Partial<S>, ExtraSubscribeOptions extends boolean = false, PersistReturn = unknown> = {
-    (): S;
-    <U>(selector: (state: S) => U, equalityFn?: (a: U, b: U) => boolean): U;
-} & Omit<BaseStore<S, ExtraSubscribeOptions>, 'setState' | 'persist'> & StorePersist<BaseStore<S, ExtraSubscribeOptions>, PersistedState, PersistReturn>;
-export type Store<S, PersistedState extends Partial<S> = never, ExtraSubscribeOptions extends boolean = false, PersistReturn = unknown> = [
+export type PersistedStore<S, PersistedState = Partial<S>, PersistReturn = unknown, ExtraSubscribeOptions extends boolean = false> = UseStoreCallSignatures<S> & Omit<BaseStore<S, ExtraSubscribeOptions>, 'setState' | 'persist'> & WithPersist<BaseStore<S, ExtraSubscribeOptions>, PersistedState, PersistReturn>;
+export type Store<S, PersistedState extends Partial<S> = never, PersistReturn = unknown, ExtraSubscribeOptions extends boolean = false> = [
     PersistedState
-] extends [never] ? BaseStore<S, ExtraSubscribeOptions> : PersistedStore<S, PersistedState, ExtraSubscribeOptions, PersistReturn>;
+] extends [never] ? BaseStore<S, ExtraSubscribeOptions> : PersistedStore<S, PersistedState, PersistReturn, ExtraSubscribeOptions>;
 export type OptionallyPersistedStore<S, PersistedState, PersistReturn = void> = WithAsyncSet<Store<S>, S, PersistedState, PersistReturn> & UseStoreCallSignatures<S> & {
-    persist?: PersistedStore<S, PersistedState, false, PersistReturn>['persist'];
+    persist?: PersistedStore<S, PersistedState, PersistReturn, false>['persist'];
 };
 export type NoInfer<T> = [T][T extends unknown ? 0 : never];
 export type Timeout = ReturnType<typeof setTimeout>;
@@ -56,24 +55,18 @@ export type InferStoreState<Store extends StoreApi<unknown>> = Store extends {
     getState: () => infer T;
 } ? T : never;
 /**
- * Extracts the return type of setState from a store.
- * Returns `void` for non-persisted or sync-persisted stores.
- * Returns `Promise<void>` for async-persisted stores.
+ * Extracts a store's `setState` return type.
+ *  - `void` for non-persisted or synchronous persisted stores.
+ *  - `Promise<void>` for async persisted stores.
  */
 export type InferSetStateReturn<Store> = Store extends {
     setState(...args: SetStateArgs<infer S>): infer R;
 } ? R : void;
 /**
- * Extracts the PersistedState type from a store's persist property.
- * Returns `Partial<State>` if the store doesn't have persistence.
+ * Extracts a store's `PersistedState` type.
+ * Returns `never` if the store doesn't use persistence.
  */
-export type InferPersistedState<Store, State> = Store extends {
-    persist: {
-        getOptions: () => infer Options;
-    };
-} ? Options extends {
-    name?: string;
-} ? Partial<State> : Partial<State> : Partial<State>;
+export type InferPersistedState<PersistedStore> = PersistedStore extends Store<infer _, infer PersistedState> ? PersistedState : never;
 export type SetPartial<S> = Partial<S> | ((state: S) => Partial<S>);
 export type SetFull<S> = S | ((state: S) => S);
 export type SetStateReplaceArgs<S, ExtraArgs extends unknown[] = []> = [update: SetFull<S>, replace: true, ...extraArgs: ExtraArgs];
@@ -85,10 +78,16 @@ export type SetStateOverloads<S, PersistReturn extends Promise<void> | void = vo
     (update: SetFull<S>, replace: true): PersistReturn;
 };
 export type WithAsyncSet<Store extends StoreApi<unknown>, S, PersistedState, PersistReturn> = Omit<Store, 'persist' | 'setState'> & {
-    persist?: PersistedStore<S, PersistedState, false, PersistReturn>['persist'];
+    persist?: PersistedStore<S, PersistedState, PersistReturn, false>['persist'];
     setState(update: SetPartial<InferStoreState<Store>>, replace?: false): PersistReturn;
     setState(update: SetFull<InferStoreState<Store>>, replace: true): PersistReturn;
 };
+/**
+ * Minimum store API required for subscription.
+ */
+export type SubscribableStore = {
+    subscribe(selector: Selector<unknown, unknown>, listener: () => void, options?: SubscribeOptions<unknown>): UnsubscribeFn;
+};
 export type SubscribeOptions<Selected> = {
     equalityFn?: EqualityFn<Selected>;
     fireImmediately?: boolean;
@@ -111,6 +110,10 @@ export type DerivedStore<S> = WithFlushUpdates<ReadOnlyDerivedStore<BaseStore<S>
 export type WithFlushUpdates<Store extends StoreApi<unknown>> = Store & {
     /**
      * Destroy the derived store and its subscriptions.
+     *
+     * Derived stores automatically clean up internal resources and subscriptions
+     * when no subscribers exist. So calling `destroy()` is usually unnecessary,
+     * unless `keepAlive: true` is specified and explict teardown is desired.
      */
     destroy: () => void;
     /**
@@ -202,12 +205,12 @@ export interface SyncStorageInterface<SerializedState = unknown> {
      * Adapter-level deserializer used when a store does not supply its own.
      * Acts as the default before falling back to the framework implementation.
      */
-    readonly deserializer?: <PersistedState>(serializedState: SerializedState) => StorageValue<PersistedState>;
+    deserializer?<PersistedState>(serializedState: SerializedState): StorageValue<PersistedState>;
     /**
      * Adapter-level serializer used when a store does not supply its own.
      * Acts as the default before falling back to the framework implementation.
      */
-    readonly serializer?: <PersistedState>(storageValue: StorageValue<PersistedState>) => SerializedState;
+    serializer?<PersistedState>(storageValue: StorageValue<PersistedState>): SerializedState;
     clearAll(): void;
     contains(key: string): boolean;
     delete(key: string): void;
@@ -225,12 +228,12 @@ export type AsyncStorageInterface<SerializedState = unknown> = {
      * Adapter-level deserializer used when a store does not supply its own.
      * Acts as the default before falling back to the framework implementation.
      */
-    readonly deserializer?: <PersistedState>(serializedState: SerializedState) => StorageValue<PersistedState>;
+    deserializer?<PersistedState>(serializedState: SerializedState): StorageValue<PersistedState>;
     /**
      * Adapter-level serializer used when a store does not supply its own.
      * Acts as the default before falling back to the framework implementation.
      */
-    readonly serializer?: <PersistedState>(storageValue: StorageValue<PersistedState>) => SerializedState;
+    serializer?<PersistedState>(storageValue: StorageValue<PersistedState>): SerializedState;
     clearAll(): Promise<void>;
     contains(key: string): Promise<boolean>;
     delete(key: string): Promise<void>;
@@ -246,7 +249,7 @@ export type PersistConfig<S, PersistedState = Partial<S>, PersistReturn = void>
      * A function to convert the serialized value back into the state object.
      * If not provided, the storage adapter's `deserializer` is used before falling back to the default implementation.
      */
-    deserializer?: <SerializedState>(serializedState: SerializedState) => StorageValue<PersistedState>;
+    deserializer?: (serializedState: unknown) => StorageValue<PersistedState>;
     /**
      * A function to merge persisted state with current state during hydration.
      * By default, zustand does a shallow merge, but this allows custom logic for deep merging nested objects.
@@ -277,7 +280,7 @@ export type PersistConfig<S, PersistedState = Partial<S>, PersistReturn = void>
      * A function to serialize the state and version for storage.
      * If not provided, the storage adapter's `serializer` is used before falling back to the default implementation.
      */
-    serializer?: <SerializedState>(storageValue: StorageValue<PersistedState>) => SerializedState;
+    serializer?: (storageValue: StorageValue<PersistedState>) => string;
     /**
      * Custom storage implementation. If async, `setState` will return a Promise that resolves
      * when the state is persisted. If sync, `setState` will return void.

package/dist/utils/core.d.ts

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

package/dist/utils/createStoreActions.d.ts

@@ -1,7 +1,7 @@
 import { StoreApi } from 'zustand';
 import { InferStoreState } from '../types';
-import { NoOverlap, ObjectMethods } from '../types/objects';
-import { FunctionKeys } from '../types/functions';
+import { NoOverlap } from '../types/objects';
+import { FunctionKeys, FunctionRecord } from '../types/functions';
 export type StoreActions<Store extends StoreApi<unknown>> = Pick<InferStoreState<Store>, FunctionKeys<InferStoreState<Store>>>;
 /**
  * Given a store instance, produces a new object containing only its actions.
@@ -21,5 +21,5 @@ export type StoreActions<Store extends StoreApi<unknown>> = Pick<InferStoreState
  * exampleActions.increment();
  */
 export declare function createStoreActions<Store extends StoreApi<unknown>>(store: Store): StoreActions<Store>;
-export declare function createStoreActions<Store extends StoreApi<unknown>, Bundled extends ObjectMethods>(store: Store, bundledMethods: NoOverlap<InferStoreState<Store>, Bundled>): StoreActions<Store> & Bundled;
+export declare function createStoreActions<Store extends StoreApi<unknown>, Bundled extends FunctionRecord>(store: Store, bundledMethods: NoOverlap<InferStoreState<Store>, Bundled>): StoreActions<Store> & Bundled;
 //# sourceMappingURL=createStoreActions.d.ts.map

package/dist/utils/persistUtils.d.ts

@@ -1,9 +1,9 @@
-import { 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.
  */
-export declare function omitStoreMethods<S, PersistedState extends Partial<S>>(state: S): PersistedState;
+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/utils/storeUtils.d.ts

@@ -1,11 +1,12 @@
 import { StoreApi } from 'zustand';
-import { BaseStore, DerivedStore, PersistedStore, SetStateArgs, WithGetSnapshot } from '../types';
-import { QueryStore, QueryStoreState } from 'src/queryStore/types';
-export declare enum StoreTags {
-    QueryStore = "_queryStore",
-    VirtualStore = "_virtualStore"
-}
-export declare function assignStoreTag<S>(store: BaseStore<S>, tag: StoreTags): BaseStore<S>;
+import { QueryStore, QueryStoreState } from '../queryStore/types';
+import { BaseStore, InferStoreState, PersistedStore, SetStateArgs } from '../types';
+export declare const StoreTags: Readonly<{
+    QueryStore: symbol;
+    VirtualStore: symbol;
+}>;
+type StoreTag = (typeof StoreTags)[keyof typeof StoreTags];
+export declare function assignStoreTag<S>(store: BaseStore<S>, tag: StoreTag): BaseStore<S>;
 /**
  * Helper that applies a `setState` update to the provided state.
  * Handles the `setState` discriminated union types internally.
@@ -29,29 +30,35 @@ export declare function getStoreName(store: BaseStore<unknown>): string;
 /**
  * Checks if a store has a `destroy` method.
  */
-export declare function hasDestroy<S>(store: StoreApi<S>): store is StoreApi<S> & {
+export declare function hasDestroy<T extends StoreApi<unknown>>(store: T): store is T & {
     destroy: () => void;
 };
 /**
  * Checks if a store is a `DerivedStore` and reveals its internal `getSnapshot` method.
  */
-export declare function hasGetSnapshot<S>(store: BaseStore<S> | StoreApi<S>): store is WithGetSnapshot<DerivedStore<S>>;
+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<S>(store: StoreApi<S> | BaseStore<S> | QueryStore<S, Record<string, unknown>, S>): store is BaseStore<QueryStoreState<S, Record<string, unknown>, S>>;
+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<S>(store: BaseStore<S> | StoreApi<S>): store is DerivedStore<S>;
+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<S>(store: BaseStore<S>): store is PersistedStore<S>;
+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<S>(store: BaseStore<S> | StoreApi<S>): store is BaseStore<S> & {
-    [StoreTags.VirtualStore]: true;
-};
+export declare function isVirtualStore<T extends BaseStore<unknown> | StoreApi<unknown>>(store: T): store is T & BaseStore<InferStoreState<T>>;
+export {};
 //# sourceMappingURL=storeUtils.d.ts.map

package/dist/utils/time.d.ts

@@ -38,9 +38,6 @@ export declare const time: TimeUtils;
  * Uses setTimeout(0) to allow microtasks scheduled via queueMicrotask to execute.
  *
  * Useful in tests when waiting for async operations scheduled via microtasks.
- *
- * @example
- * await waitForMicrotask();
  */
 export declare function waitForMicrotask(): Promise<void>;
 export {};

package/dist/web/chrome.js

@@ -1 +1 @@
-var e="stores:";function t(e){if("object"!=typeof e||null===e)return!1;const t=Object.getPrototypeOf(e);return null===t||t===Object.prototype}function r(e,t){return t instanceof Map?{__type:"Map",entries:Array.from(t.entries())}:t instanceof Set?{__type:"Set",values:Array.from(t)}:t}function s(e,t){return function(e){return"object"==typeof e&&null!==e&&"__type"in e&&"Map"===e.__type}(t)?new Map(t.entries):function(e){return"object"==typeof e&&null!==e&&"__type"in e&&"Set"===e.__type}(t)?new Set(t.values):t}var n=class{constructor(t){this.async=!0,this.deserializer=i,this.serializer=o,this.area=t?.area??"local",this.storageKeyPrefix=t?.storageKeyPrefix??e}async clearAll(){const e=this.ensureStorage();if(!e)return;if(!this.storageKeyPrefix)throw new Error("Cannot clear all storage with empty storageKeyPrefix. This would delete all storage entries.");const t=await this.listPrefixedKeys(e,this.storageKeyPrefix);t.length&&await this.execute(e,r=>e.remove(t,r))}async contains(e){const t=this.ensureStorage();if(!t)return!1;const r=this.toStorageKey(e),s=await this.getFromStorage(t,r);return Object.prototype.hasOwnProperty.call(s,r)}async delete(e){const t=this.ensureStorage();if(!t)return;const r=this.toStorageKey(e);await this.execute(t,e=>t.remove(r,e))}async getAllKeys(){const e=this.ensureStorage();if(!e)return[];const t=await this.getFromStorage(e,null),r=this.storageKeyPrefix;return r?Object.keys(t).filter(e=>e.startsWith(r)).map(e=>e.slice(r.length)):Object.keys(t)}async get(e){const t=this.ensureStorage();if(!t)return;const r=this.toStorageKey(e);return a((await this.getFromStorage(t,r))[r])||void 0}async set(e,t){const r=this.ensureStorage();if(!r)return;const s=this.toStorageKey(e);await this.execute(r,e=>r.set({[s]:t},e))}ensureStorage(){return e=this.area,"undefined"!=typeof chrome&&chrome.storage?chrome.storage[e]??null:null;var e}toStorageKey(e){return this.storageKeyPrefix?`${this.storageKeyPrefix}${e}`:e}async listPrefixedKeys(e,t){const r=await this.getFromStorage(e,null);return Object.keys(r).filter(e=>e.startsWith(t))}async getFromStorage(e,t){return this.invokeWithCallbackSupport(r=>e.get(t,r))}async execute(e,t){await this.invokeWithCallbackSupport(t)}async invokeWithCallbackSupport(e){return new Promise((t,r)=>{let s=!1;const n=e=>{if(s)return;s=!0;const n="undefined"!=typeof chrome&&chrome.runtime&&chrome.runtime.lastError?new Error(chrome.runtime.lastError.message):null;n?r(n):t(e)};try{const t=e(n);(o=t)&&"object"==typeof o&&"then"in o&&"function"==typeof o.then&&t.then(n).catch(r)}catch(e){r(e)}var o})}};function o(e){return{state:h(e.state),syncMetadata:e.syncMetadata,version:e.version}}function i(e){const t=a(e);if(!t)throw new Error("[ChromeStorageAdapter] Invalid serialized state format");return{state:u(t.state),syncMetadata:t.syncMetadata,version:t.version}}function a(e){if(c(e))return e;if("string"==typeof e)try{const t=JSON.parse(e);if(c(t))return t}catch{}return null}function c(e){return!(!e||"object"!=typeof e)&&Object.prototype.hasOwnProperty.call(e,"state")}function h(e,s=r){if(e instanceof Map||e instanceof Set)return s.call(void 0,"",e);if(!t(e))return e;const n={};for(const[t,r]of Object.entries(e))n[t]=s.call(e,t,r);return n}function u(e,r=s){const n=r.call(void 0,"",e);if(!t(n))return n;const o={};for(const e of Object.entries(n)){const t=e[0],s=e[1];o[t]=r.call(n,t,s)}return o}var l=class{constructor(t){this.injectStorageMetadata=!0,this.registrations=new Map,this.isListening=!1,this.onStorageChanged=async(e,t)=>{if(t===this.area)for(const t of this.registrations){const r=t[0],s=t[1];if(s.destroyed)continue;const n=e[this.toStorageKey(r)];if(n&&void 0!==n.newValue)try{const e=this.parsePersistValue(n.newValue);if(!e||e.syncMetadata?.origin===this.sessionId)continue;const t=e?.syncMetadata,r=this.extractChangedFields(s,e.state,t,n.oldValue);if(!Object.keys(r).length)continue;s.registration.apply({replace:!1,sessionId:t?.origin??"unknown",timestamp:t?.timestamp??Date.now(),values:r})}catch(e){continue}}},t&&"storage"in t?(this.area=t.storage.area,this.storageKeyPrefix=t.storage.storageKeyPrefix):(this.area=t?.area??"local",this.storageKeyPrefix=t?.storageKeyPrefix??e),this.sessionId=this.generateSessionId(),this.attachListener()}generateSessionId(){return"undefined"!=typeof crypto&&"randomUUID"in crypto?crypto.randomUUID():`${Math.random().toString(36).slice(2)}:${Date.now().toString(36)}`}register(e){this.attachListener();const t={destroyed:!1,hydrated:!0,listeners:new Set,registration:e};return this.registrations.set(e.key,t),{destroy:()=>{t.destroyed=!0,t.listeners.clear(),this.registrations.delete(e.key),this.registrations.size||this.detachListener()},publish:null}}attachListener(){"undefined"!=typeof chrome&&chrome.storage&&!this.isListening&&(this.isListening=!0,chrome.storage.onChanged.addListener(this.onStorageChanged))}detachListener(){"undefined"!=typeof chrome&&chrome.storage&&this.isListening&&(chrome.storage.onChanged.removeListener(this.onStorageChanged),this.isListening=!1)}extractChangedFields(e,t,r,s){const n=Object.create(null),o=r?.fields;if(o&&Object.keys(o).length>0){let r=!1;for(const s of e.registration.fields){const e=String(s);Object.prototype.hasOwnProperty.call(o,e)&&(n[s]=t[s],r=!0)}if(r)return n}const i=this.parsePersistValue(s);for(const r of e.registration.fields){const e=t[r],s=i?.state[r];Object.is(e,s)||(n[r]=e)}return n}toStorageKey(e){return this.storageKeyPrefix?`${this.storageKeyPrefix}${e}`:e}parsePersistValue(e){return i(e)}};exports.ChromeExtensionSyncEngine=l,exports.ChromeStorageAdapter=n,exports.createSyncedChromeStorage=function(e){const t=new n(e);return{storage:t,syncEngine:new l({storage:t})}};
+process.env.NODE_ENV,process.env.NODE_ENV;var e=Object.prototype.hasOwnProperty;function t(t,r){return e.call(t,r)}function r(e){if("object"!=typeof e||null===e)return!1;const t=Object.getPrototypeOf(e);return null===t||t===Object.prototype}var s=Object.freeze(Object.create(null)),n="stores:";function o(e,t){return t instanceof Map?{__type:"Map",entries:Array.from(t.entries())}:t instanceof Set?{__type:"Set",values:Array.from(t)}:t}function i(e,t){return function(e){return"object"==typeof e&&null!==e&&"__type"in e&&"Map"===e.__type}(t)?new Map(t.entries):function(e){return"object"==typeof e&&null!==e&&"__type"in e&&"Set"===e.__type}(t)?new Set(t.values):t}var a=class{constructor(e){this.async=!0,this.deserializer=h,this.serializer=c,this.area=e?.area??"local",this.storageKeyPrefix=e?.storageKeyPrefix??n}async clearAll(){const e=this.ensureStorage();if(!e)return;if(!this.storageKeyPrefix)throw new Error("Cannot clear all storage with empty storageKeyPrefix. This would delete all storage entries.");const t=await this.listPrefixedKeys(e,this.storageKeyPrefix);t.length&&await this.execute(e,r=>e.remove(t,r))}async contains(e){const t=this.ensureStorage();if(!t)return!1;const r=this.toStorageKey(e),s=await this.getFromStorage(t,r);return Object.prototype.hasOwnProperty.call(s,r)}async delete(e){const t=this.ensureStorage();if(!t)return;const r=this.toStorageKey(e);await this.execute(t,e=>t.remove(r,e))}async getAllKeys(){const e=this.ensureStorage();if(!e)return[];const t=await this.getFromStorage(e,null),r=this.storageKeyPrefix;return r?Object.keys(t).filter(e=>e.startsWith(r)).map(e=>e.slice(r.length)):Object.keys(t)}async get(e){const t=this.ensureStorage();if(!t)return;const r=this.toStorageKey(e);return u((await this.getFromStorage(t,r))[r])||void 0}async set(e,t){const r=this.ensureStorage();if(!r)return;const s=this.toStorageKey(e);await this.execute(r,e=>r.set({[s]:t},e))}ensureStorage(){return e=this.area,"undefined"!=typeof chrome&&chrome.storage?chrome.storage[e]??null:null;var e}toStorageKey(e){return this.storageKeyPrefix?`${this.storageKeyPrefix}${e}`:e}async listPrefixedKeys(e,t){const r=await this.getFromStorage(e,null);return Object.keys(r).filter(e=>e.startsWith(t))}async getFromStorage(e,t){return this.invokeWithCallbackSupport(r=>e.get(t,r))}async execute(e,t){await this.invokeWithCallbackSupport(t)}async invokeWithCallbackSupport(e){return new Promise((t,r)=>{let s=!1;function n(e){if(s)return;s=!0;const n="undefined"!=typeof chrome&&chrome.runtime&&chrome.runtime.lastError?new Error(chrome.runtime.lastError.message):null;n?r(n):t(e)}try{const t=e(n);(o=t)&&"object"==typeof o&&"then"in o&&"function"==typeof o.then&&t.then(n).catch(r)}catch(e){r(e)}var o})}};function c(e){return{state:g(e.state),syncMetadata:e.syncMetadata,version:e.version}}function h(e){const t=u(e);if(!t)throw new Error("[ChromeStorageAdapter] Invalid serialized state format");return{state:f(t.state),syncMetadata:t.syncMetadata,version:t.version}}function u(e){if(l(e))return e;if("string"==typeof e)try{const t=JSON.parse(e);if(l(t))return t}catch{}return null}function l(e){return!(!e||"object"!=typeof e)&&Object.prototype.hasOwnProperty.call(e,"state")}function g(e,t=o){if(e instanceof Map||e instanceof Set)return t.call(void 0,"",e);if(!r(e))return e;const s={};for(const[r,n]of Object.entries(e))s[r]=t.call(e,r,n);return s}function f(e,t=i){const s=t.call(void 0,"",e);if(!r(s))return s;const n={};for(const e of Object.entries(s)){const r=e[0],o=e[1];n[r]=t.call(s,r,o)}return n}var y=class{constructor(e){this.injectStorageMetadata=!0,this.registrations=new Map,this.isListening=!1,this.onStorageChanged=async(e,t)=>{if(t===this.area)for(const t of this.registrations){const r=t[0],s=t[1];if(s.destroyed)continue;const n=e[this.toStorageKey(r)];if(n&&void 0!==n.newValue)try{const e=this.parsePersistValue(n.newValue);if(!e||e.syncMetadata?.origin===this.sessionId)continue;const t=e?.syncMetadata,r=this.extractChangedFields(s,e.state,t,n.oldValue);if(!Object.keys(r).length)continue;s.registration.apply({replace:!1,sessionId:t?.origin??"unknown",timestamp:t?.timestamp??Date.now(),values:r})}catch(e){continue}}},e&&"storage"in e?(this.area=e.storage.area,this.storageKeyPrefix=e.storage.storageKeyPrefix):(this.area=e?.area??"local",this.storageKeyPrefix=e?.storageKeyPrefix??n),this.sessionId=this.generateSessionId(),this.attachListener()}destroy(){for(const e of this.registrations.values())e.destroyed=!0,e.listeners.clear();this.detachListener()}register(e){this.attachListener();const t={destroyed:!1,hydrated:!0,listeners:new Set,registration:e};return this.setRegistration(e.key,t),{destroy:()=>{t.destroyed=!0,t.listeners.clear(),this.registrations.delete(e.key),this.registrations.size||this.detachListener()},publish:null}}generateSessionId(){return"undefined"!=typeof crypto&&"randomUUID"in crypto?crypto.randomUUID():`${Math.random().toString(36).slice(2)}:${Date.now().toString(36)}`}attachListener(){"undefined"!=typeof chrome&&chrome.storage&&!this.isListening&&(this.isListening=!0,chrome.storage.onChanged.addListener(this.onStorageChanged))}detachListener(){"undefined"!=typeof chrome&&chrome.storage&&this.isListening&&(chrome.storage.onChanged.removeListener(this.onStorageChanged),this.isListening=!1)}extractChangedFields(e,r,n,o){const i=Object.create(s),a=n?.fields;if(a&&Object.keys(a).length>0){let s=!1;for(const n of e.registration.fields)t(a,String(n))&&(i[n]=r[n],s=!0);if(s)return i}const c=this.parsePersistValue(o);for(const t of e.registration.fields){const e=r[t],s=c?.state[t];Object.is(e,s)||(i[t]=e)}return i}setRegistration(e,t){this.registrations.set(e,t)}toStorageKey(e){return this.storageKeyPrefix?`${this.storageKeyPrefix}${e}`:e}parsePersistValue(e){return h(e)}};exports.ChromeExtensionSyncEngine=y,exports.ChromeStorageAdapter=a,exports.createSyncedChromeStorage=function(e){const t=new a(e);return{storage:t,syncEngine:new y({storage:t})}};