floppy-disk 3.0.0-alpha.1 → 3.0.0-alpha.3

package/esm/react/create-mutation.d.mts

@@ -1,4 +1,4 @@
-import { type InitStoreOptions, type SetState } from 'floppy-disk';
+import { type InitStoreOptions, type SetState } from 'floppy-disk/vanilla';
 /**
  * Represents the state of a mutation.
  *
@@ -90,8 +90,8 @@ export type MutationOptions<TData, TVariable> = InitStoreOptions<MutationState<T
  * const result = await useCreateUser.execute({ name: 'John' });
  */
 export declare const createMutation: <TData, TVariable = undefined>(mutationFn: (variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => Promise<TData>, options?: MutationOptions<TData, TVariable>) => (<TStateSlice = MutationState<TData, TVariable>>(selector?: (state: MutationState<TData, TVariable>) => TStateSlice) => TStateSlice) & {
-    subscribe: (subscriber: import("floppy-disk").Subscriber<MutationState<TData, TVariable>>) => () => void;
-    getSubscribers: () => Set<import("floppy-disk").Subscriber<MutationState<TData, TVariable>>>;
+    subscribe: (subscriber: import("../vanilla.d.mts").Subscriber<MutationState<TData, TVariable>>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.d.mts").Subscriber<MutationState<TData, TVariable>>>;
     getState: () => MutationState<TData, TVariable>;
     /**
      * Manually updates the mutation state.

package/esm/react/create-query.d.mts

@@ -1,4 +1,4 @@
-import { type InitStoreOptions, type SetState } from 'floppy-disk';
+import { type InitStoreOptions, type SetState } from 'floppy-disk/vanilla';
 /**
  * Represents the state of a query.
  *
@@ -202,45 +202,58 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
     /**
      * Executes the query function.
      *
-     * @param overwriteOngoingExecution - Whether to start a new execution instead of reusing an ongoing one
+     * @param options - Execution options
+     * @param options.overwriteOngoingExecution - Whether to start a new execution instead of reusing an ongoing one (default: `true`)
      *
      * @returns A promise resolving to the latest query state
      *
      * @remarks
-     * - Deduplicates concurrent executions by default.
-     * - If `overwriteOngoingExecution` is true, a new execution replaces the current one.
+     * - By default, each call starts a new execution even if one is already in progress.
+     * - Set `overwriteOngoingExecution: false` to reuse an ongoing execution (deduplication).
      * - Handles:
      *   - Pending state
      *   - Success state
      *   - Error state
      *   - Retry logic
      */
-    execute: (overwriteOngoingExecution?: boolean) => Promise<QueryState<TData>>;
+    execute: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => Promise<QueryState<TData>>;
     /**
-     * Re-executes the query if the data is stale.
+     * Re-executes the query if needed based on freshness or invalidation.
      *
-     * @param overwriteOngoingExecution - Whether to overwrite an ongoing execution
+     * @param options - Revalidation options
+     * @param options.overwriteOngoingExecution - Whether to overwrite an ongoing execution (default: `true`)
      *
      * @returns The current state if still fresh, otherwise a promise of the new state
      *
      * @remarks
-     * - Skips execution if data is still fresh (`staleTime`) and the query has not been invalidated.
-     * - Used for automatic revalidation (e.g. focus or reconnect).
+     * - Skips execution if data is still fresh (`staleTime`) **AND** the query has not been invalidated.
+     * - If execution is not skipped, by default it will start a new execution even if one is already in progress.
+     * - Set `overwriteOngoingExecution: false` to reuse an ongoing execution (deduplication).
      */
-    revalidate: (overwriteOngoingExecution?: boolean) => Promise<QueryState<TData>>;
+    revalidate: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => Promise<QueryState<TData>>;
     /**
      * Marks the query as invalidated and optionally triggers re-execution.
      *
-     * @param overwriteOngoingExecution - Whether to overwrite an ongoing execution
+     * @param options - Invalidation options
+     * @param options.overwriteOngoingExecution - Whether to overwrite an ongoing execution (default: `true`)
      *
      * @returns `true` if execution was triggered, `false` otherwise
      *
      * @remarks
      * - Invalidated queries are treated as stale regardless of `staleTime`.
      * - The next `revalidate` will always execute until a successful result clears the invalidation.
-     * - If there are active subscribers, execution will be triggered immediately.
+     * - If there are active subscribers: Execution is triggered immediately.
+     * - Otherwise: The query remains invalidated and will execute on the next revalidation.
+     * - By default, starts a new execution even if one is already in progress.
+     * - Set `overwriteOngoingExecution: false` to reuse an ongoing execution (deduplication).
      */
-    invalidate: (overwriteOngoingExecution?: boolean) => boolean;
+    invalidate: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => boolean;
     /**
      * Resets the query state to its initial state.
      *
@@ -285,8 +298,8 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * - Should be used if an optimistic update fails.
      */
     rollbackOptimisticUpdate: () => TData;
-    subscribe: (subscriber: import("floppy-disk").Subscriber<QueryState<TData>>) => () => void;
-    getSubscribers: () => Set<import("floppy-disk").Subscriber<QueryState<TData>>>;
+    subscribe: (subscriber: import("../vanilla.d.mts").Subscriber<QueryState<TData>>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.d.mts").Subscriber<QueryState<TData>>>;
     getState: () => QueryState<TData>;
     setState: (value: SetState<QueryState<TData>>) => void;
 }) & {
@@ -296,14 +309,18 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * @remarks
      * - Useful for bulk refetching.
      */
-    executeAll: (overwriteOngoingExecution?: boolean) => void;
+    executeAll: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => void;
     /**
      * Revalidates all query instances.
      *
      * @remarks
      * - Only re-fetches stale queries.
      */
-    revalidateAll: (overwriteOngoingExecution?: boolean) => void;
+    revalidateAll: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => void;
     /**
      * Invalidates all query instances.
      *
@@ -311,7 +328,9 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * - Marks all queries as invalidated and triggers revalidation if active.
      * - Invalidated queries bypass `staleTime` until successfully executed again.
      */
-    invalidateAll: (overwriteOngoingExecution?: boolean) => void;
+    invalidateAll: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => void;
     /**
      * Resets all query instances.
      */

package/esm/react/create-store.d.mts

@@ -1,4 +1,4 @@
-import { type InitStoreOptions } from 'floppy-disk';
+import { type InitStoreOptions } from 'floppy-disk/vanilla';
 /**
  * Creates a single store with a bound React hook.
  *
@@ -22,4 +22,4 @@ import { type InitStoreOptions } from 'floppy-disk';
  *
  * useCounter.setState({ count: 1 });
  */
-export declare const createStore: <TState extends Record<string, any>>(initialState: TState, options?: InitStoreOptions<TState>) => (<TStateSlice = TState>(selector?: (state: TState) => TStateSlice) => TStateSlice) & import("floppy-disk").StoreApi<TState>;
+export declare const createStore: <TState extends Record<string, any>>(initialState: TState, options?: InitStoreOptions<TState>) => (<TStateSlice = TState>(selector?: (state: TState) => TStateSlice) => TStateSlice) & import("../vanilla.d.mts").StoreApi<TState>;

package/esm/react/create-stores.d.mts

@@ -1,4 +1,4 @@
-import { type InitStoreOptions } from 'floppy-disk';
+import { type InitStoreOptions } from 'floppy-disk/vanilla';
 /**
  * Creates a factory for multiple stores identified by a key.
  *
@@ -25,8 +25,8 @@ import { type InitStoreOptions } from 'floppy-disk';
  */
 export declare const createStores: <TState extends Record<string, any>, TKey extends Record<string, any>>(initialState: TState, options?: InitStoreOptions<TState>) => (key?: TKey) => (<TStateSlice = TState>(selector?: (state: TState) => TStateSlice) => TStateSlice) & {
     delete: () => boolean;
-    setState: (value: import("floppy-disk").SetState<TState>) => void;
+    setState: (value: import("../vanilla.d.mts").SetState<TState>) => void;
     getState: () => TState;
-    subscribe: (subscriber: import("floppy-disk").Subscriber<TState>) => () => void;
-    getSubscribers: () => Set<import("floppy-disk").Subscriber<TState>>;
+    subscribe: (subscriber: import("../vanilla.d.mts").Subscriber<TState>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.d.mts").Subscriber<TState>>;
 };

package/esm/react/use-store.d.mts

@@ -1,4 +1,4 @@
-import { type StoreApi } from 'floppy-disk';
+import { type StoreApi } from 'floppy-disk/vanilla';
 export declare const useStoreUpdateNotifier: <TState extends Record<string, any>, TStateSlice = TState>(store: StoreApi<TState>, selector: (state: TState) => TStateSlice) => void;
 /**
  * React hook for subscribing to a store with optional state selection.

package/esm/react.mjs

@@ -1,5 +1,5 @@
 import { useLayoutEffect, useEffect, useState, useRef } from 'react';
-import { isClient, identity, shallow, initStore, getHash, noop } from 'floppy-disk';
+import { isClient, identity, shallow, initStore, getHash, noop } from 'floppy-disk/vanilla';
 
 const useIsomorphicLayoutEffect = isClient ? useLayoutEffect : useEffect;
 
@@ -157,17 +157,17 @@ const createQuery = (queryFn, options = {}) => {
       }
       return false;
     },
-    execute: (overwriteOngoingExecution = false) => {
+    execute: ({ overwriteOngoingExecution = true } = {}) => {
       return execute(store, variable, overwriteOngoingExecution);
     },
-    revalidate: (overwriteOngoingExecution = false) => {
+    revalidate: ({ overwriteOngoingExecution = true } = {}) => {
       return revalidate(store, variable, overwriteOngoingExecution);
     },
-    invalidate: (overwriteOngoingExecution = false) => {
+    invalidate: (options2) => {
       const { metadata } = internals.get(store);
       metadata.isInvalidated = true;
       if (store.getSubscribers().size > 0) {
-        internals.get(store).execute(overwriteOngoingExecution);
+        internals.get(store).execute(options2);
         return true;
       }
       return false;
@@ -326,7 +326,7 @@ const createQuery = (queryFn, options = {}) => {
     const useStore = (options2 = {}, selector = identity) => {
       useStoreUpdateNotifier(store, selector);
       useIsomorphicLayoutEffect(() => {
-        if (options2.enabled !== false) revalidate(store, variable);
+        if (options2.enabled !== false) revalidate(store, variable, false);
       }, [store, options2.enabled]);
       const storeState = store.getState();
       let storeStateToBeUsed = storeState;
@@ -356,8 +356,8 @@ const createQuery = (queryFn, options = {}) => {
      * @remarks
      * - Useful for bulk refetching.
      */
-    executeAll: (overwriteOngoingExecution) => {
-      stores.forEach((store) => internals.get(store).execute(overwriteOngoingExecution));
+    executeAll: (options2) => {
+      stores.forEach((store) => internals.get(store).execute(options2));
     },
     /**
      * Revalidates all query instances.
@@ -365,8 +365,8 @@ const createQuery = (queryFn, options = {}) => {
      * @remarks
      * - Only re-fetches stale queries.
      */
-    revalidateAll: (overwriteOngoingExecution) => {
-      stores.forEach((store) => internals.get(store).revalidate(overwriteOngoingExecution));
+    revalidateAll: (options2) => {
+      stores.forEach((store) => internals.get(store).revalidate(options2));
     },
     /**
      * Invalidates all query instances.
@@ -375,8 +375,8 @@ const createQuery = (queryFn, options = {}) => {
      * - Marks all queries as invalidated and triggers revalidation if active.
      * - Invalidated queries bypass `staleTime` until successfully executed again.
      */
-    invalidateAll: (overwriteOngoingExecution) => {
-      stores.forEach((store) => internals.get(store).invalidate(overwriteOngoingExecution));
+    invalidateAll: (options2) => {
+      stores.forEach((store) => internals.get(store).invalidate(options2));
     },
     /**
      * Resets all query instances.

package/esm/vanilla/store.d.mts

@@ -13,17 +13,18 @@ export type SetState<TState> = Partial<TState> | ((state: TState) => Partial<TSt
  * @param prevState - The previous state before the update
  *
  * @remarks
- * - Subscribers are always called on every `setState`, regardless of equality.
- * - It is the subscriber's responsibility to perform comparisons if needed.
+ * - Subscribers are only called when the state actually changes.
+ * - Change detection is performed per key using `Object.is`.
  */
 export type Subscriber<TState> = (state: TState, prevState: TState) => void;
 /**
  * Core store API for managing state.
  *
  * @remarks
- * - The store is intentionally simple and always notifies subscribers on updates.
- * - No internal equality checks are performed.
+ * - The store performs **shallow change detection per key** before notifying subscribers.
+ * - Subscribers are only notified when at least one field changes.
  * - Designed to be framework-agnostic (React bindings are built separately).
+ * - By default, `setState` is **disabled on the server** to prevent accidental shared state between requests.
  */
 export type StoreApi<TState extends Record<string, any>> = {
     setState: (value: SetState<TState>) => void;
@@ -47,6 +48,7 @@ export type InitStoreOptions<TState extends Record<string, any>> = {
     onSubscribe?: (state: TState, store: StoreApi<TState>) => void;
     onUnsubscribe?: (state: TState, store: StoreApi<TState>) => void;
     onLastUnsubscribe?: (state: TState, store: StoreApi<TState>) => void;
+    allowSetStateServerSide?: boolean;
 };
 /**
  * Creates a vanilla store with pub-sub capabilities.
@@ -64,6 +66,9 @@ export type InitStoreOptions<TState extends Record<string, any>> = {
  * - Subscribers are only notified when at least one updated field changes (using `Object.is` comparison).
  * - Subscribers receive both the new state and the previous state.
  * - Lifecycle hooks allow side-effect management tied to subscription count.
+ * - By default, `setState` is **disabled on the server** to prevent accidental shared state between requests.
+ *   - This avoids leaking data between users in server environments.
+ *   - You can override this by setting `allowSetStateServerSide: true`.
  *
  * @example
  * const store = initStore({ count: 0 });

package/esm/vanilla.mjs

@@ -70,7 +70,8 @@ const initStore = (initialState, options = {}) => {
     onFirstSubscribe = noop,
     onSubscribe = noop,
     onUnsubscribe = noop,
-    onLastUnsubscribe = noop
+    onLastUnsubscribe = noop,
+    allowSetStateServerSide = false
   } = options;
   const subscribers = /* @__PURE__ */ new Set();
   const getSubscribers = () => subscribers;
@@ -87,6 +88,12 @@ const initStore = (initialState, options = {}) => {
   let state = initialState;
   const getState = () => state;
   const setState = (value) => {
+    if (!isClient && !allowSetStateServerSide) {
+      console.error(
+        "setState on the server is not allowed by default. Set `allowSetStateServerSide: true` to allow it."
+      );
+      return;
+    }
     const prevState = state;
     const newValue = getValue(value, state);
     for (const key in newValue) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "floppy-disk",
   "description": "Lightweight, simple, and powerful state management library",
   "private": false,
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.3",
   "publishConfig": {
     "tag": "alpha"
   },

package/react/create-mutation.d.ts

@@ -1,4 +1,4 @@
-import { type InitStoreOptions, type SetState } from 'floppy-disk';
+import { type InitStoreOptions, type SetState } from 'floppy-disk/vanilla';
 /**
  * Represents the state of a mutation.
  *
@@ -90,8 +90,8 @@ export type MutationOptions<TData, TVariable> = InitStoreOptions<MutationState<T
  * const result = await useCreateUser.execute({ name: 'John' });
  */
 export declare const createMutation: <TData, TVariable = undefined>(mutationFn: (variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => Promise<TData>, options?: MutationOptions<TData, TVariable>) => (<TStateSlice = MutationState<TData, TVariable>>(selector?: (state: MutationState<TData, TVariable>) => TStateSlice) => TStateSlice) & {
-    subscribe: (subscriber: import("floppy-disk").Subscriber<MutationState<TData, TVariable>>) => () => void;
-    getSubscribers: () => Set<import("floppy-disk").Subscriber<MutationState<TData, TVariable>>>;
+    subscribe: (subscriber: import("../vanilla.ts").Subscriber<MutationState<TData, TVariable>>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.ts").Subscriber<MutationState<TData, TVariable>>>;
     getState: () => MutationState<TData, TVariable>;
     /**
      * Manually updates the mutation state.

package/react/create-query.d.ts

@@ -1,4 +1,4 @@
-import { type InitStoreOptions, type SetState } from 'floppy-disk';
+import { type InitStoreOptions, type SetState } from 'floppy-disk/vanilla';
 /**
  * Represents the state of a query.
  *
@@ -202,45 +202,58 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
     /**
      * Executes the query function.
      *
-     * @param overwriteOngoingExecution - Whether to start a new execution instead of reusing an ongoing one
+     * @param options - Execution options
+     * @param options.overwriteOngoingExecution - Whether to start a new execution instead of reusing an ongoing one (default: `true`)
      *
      * @returns A promise resolving to the latest query state
      *
      * @remarks
-     * - Deduplicates concurrent executions by default.
-     * - If `overwriteOngoingExecution` is true, a new execution replaces the current one.
+     * - By default, each call starts a new execution even if one is already in progress.
+     * - Set `overwriteOngoingExecution: false` to reuse an ongoing execution (deduplication).
      * - Handles:
      *   - Pending state
      *   - Success state
      *   - Error state
      *   - Retry logic
      */
-    execute: (overwriteOngoingExecution?: boolean) => Promise<QueryState<TData>>;
+    execute: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => Promise<QueryState<TData>>;
     /**
-     * Re-executes the query if the data is stale.
+     * Re-executes the query if needed based on freshness or invalidation.
      *
-     * @param overwriteOngoingExecution - Whether to overwrite an ongoing execution
+     * @param options - Revalidation options
+     * @param options.overwriteOngoingExecution - Whether to overwrite an ongoing execution (default: `true`)
      *
      * @returns The current state if still fresh, otherwise a promise of the new state
      *
      * @remarks
-     * - Skips execution if data is still fresh (`staleTime`) and the query has not been invalidated.
-     * - Used for automatic revalidation (e.g. focus or reconnect).
+     * - Skips execution if data is still fresh (`staleTime`) **AND** the query has not been invalidated.
+     * - If execution is not skipped, by default it will start a new execution even if one is already in progress.
+     * - Set `overwriteOngoingExecution: false` to reuse an ongoing execution (deduplication).
      */
-    revalidate: (overwriteOngoingExecution?: boolean) => Promise<QueryState<TData>>;
+    revalidate: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => Promise<QueryState<TData>>;
     /**
      * Marks the query as invalidated and optionally triggers re-execution.
      *
-     * @param overwriteOngoingExecution - Whether to overwrite an ongoing execution
+     * @param options - Invalidation options
+     * @param options.overwriteOngoingExecution - Whether to overwrite an ongoing execution (default: `true`)
      *
      * @returns `true` if execution was triggered, `false` otherwise
      *
      * @remarks
      * - Invalidated queries are treated as stale regardless of `staleTime`.
      * - The next `revalidate` will always execute until a successful result clears the invalidation.
-     * - If there are active subscribers, execution will be triggered immediately.
+     * - If there are active subscribers: Execution is triggered immediately.
+     * - Otherwise: The query remains invalidated and will execute on the next revalidation.
+     * - By default, starts a new execution even if one is already in progress.
+     * - Set `overwriteOngoingExecution: false` to reuse an ongoing execution (deduplication).
      */
-    invalidate: (overwriteOngoingExecution?: boolean) => boolean;
+    invalidate: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => boolean;
     /**
      * Resets the query state to its initial state.
      *
@@ -285,8 +298,8 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * - Should be used if an optimistic update fails.
      */
     rollbackOptimisticUpdate: () => TData;
-    subscribe: (subscriber: import("floppy-disk").Subscriber<QueryState<TData>>) => () => void;
-    getSubscribers: () => Set<import("floppy-disk").Subscriber<QueryState<TData>>>;
+    subscribe: (subscriber: import("../vanilla.ts").Subscriber<QueryState<TData>>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.ts").Subscriber<QueryState<TData>>>;
     getState: () => QueryState<TData>;
     setState: (value: SetState<QueryState<TData>>) => void;
 }) & {
@@ -296,14 +309,18 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * @remarks
      * - Useful for bulk refetching.
      */
-    executeAll: (overwriteOngoingExecution?: boolean) => void;
+    executeAll: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => void;
     /**
      * Revalidates all query instances.
      *
      * @remarks
      * - Only re-fetches stale queries.
      */
-    revalidateAll: (overwriteOngoingExecution?: boolean) => void;
+    revalidateAll: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => void;
     /**
      * Invalidates all query instances.
      *
@@ -311,7 +328,9 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * - Marks all queries as invalidated and triggers revalidation if active.
      * - Invalidated queries bypass `staleTime` until successfully executed again.
      */
-    invalidateAll: (overwriteOngoingExecution?: boolean) => void;
+    invalidateAll: (options?: {
+        overwriteOngoingExecution?: boolean;
+    }) => void;
     /**
      * Resets all query instances.
      */

package/react/create-store.d.ts

@@ -1,4 +1,4 @@
-import { type InitStoreOptions } from 'floppy-disk';
+import { type InitStoreOptions } from 'floppy-disk/vanilla';
 /**
  * Creates a single store with a bound React hook.
  *
@@ -22,4 +22,4 @@ import { type InitStoreOptions } from 'floppy-disk';
  *
  * useCounter.setState({ count: 1 });
  */
-export declare const createStore: <TState extends Record<string, any>>(initialState: TState, options?: InitStoreOptions<TState>) => (<TStateSlice = TState>(selector?: (state: TState) => TStateSlice) => TStateSlice) & import("floppy-disk").StoreApi<TState>;
+export declare const createStore: <TState extends Record<string, any>>(initialState: TState, options?: InitStoreOptions<TState>) => (<TStateSlice = TState>(selector?: (state: TState) => TStateSlice) => TStateSlice) & import("../vanilla.ts").StoreApi<TState>;

package/react/create-stores.d.ts

@@ -1,4 +1,4 @@
-import { type InitStoreOptions } from 'floppy-disk';
+import { type InitStoreOptions } from 'floppy-disk/vanilla';
 /**
  * Creates a factory for multiple stores identified by a key.
  *
@@ -25,8 +25,8 @@ import { type InitStoreOptions } from 'floppy-disk';
  */
 export declare const createStores: <TState extends Record<string, any>, TKey extends Record<string, any>>(initialState: TState, options?: InitStoreOptions<TState>) => (key?: TKey) => (<TStateSlice = TState>(selector?: (state: TState) => TStateSlice) => TStateSlice) & {
     delete: () => boolean;
-    setState: (value: import("floppy-disk").SetState<TState>) => void;
+    setState: (value: import("../vanilla.ts").SetState<TState>) => void;
     getState: () => TState;
-    subscribe: (subscriber: import("floppy-disk").Subscriber<TState>) => () => void;
-    getSubscribers: () => Set<import("floppy-disk").Subscriber<TState>>;
+    subscribe: (subscriber: import("../vanilla.ts").Subscriber<TState>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.ts").Subscriber<TState>>;
 };

package/react/use-store.d.ts

@@ -1,4 +1,4 @@
-import { type StoreApi } from 'floppy-disk';
+import { type StoreApi } from 'floppy-disk/vanilla';
 export declare const useStoreUpdateNotifier: <TState extends Record<string, any>, TStateSlice = TState>(store: StoreApi<TState>, selector: (state: TState) => TStateSlice) => void;
 /**
  * React hook for subscribing to a store with optional state selection.

package/react.js

@@ -1,9 +1,9 @@
 'use strict';
 
 var react = require('react');
-var floppyDisk = require('floppy-disk');
+var vanilla = require('floppy-disk/vanilla');
 
-const useIsomorphicLayoutEffect = floppyDisk.isClient ? react.useLayoutEffect : react.useEffect;
+const useIsomorphicLayoutEffect = vanilla.isClient ? react.useLayoutEffect : react.useEffect;
 
 const useStoreUpdateNotifier = (store, selector) => {
   const [, reRender] = react.useState({});
@@ -11,21 +11,21 @@ const useStoreUpdateNotifier = (store, selector) => {
   selectorRef.current = selector;
   useIsomorphicLayoutEffect(
     () => store.subscribe((state, prevState) => {
-      if (selectorRef.current === floppyDisk.identity) return reRender({});
+      if (selectorRef.current === vanilla.identity) return reRender({});
       const prevSlice = selectorRef.current(prevState);
       const nextSlice = selectorRef.current(state);
-      if (!floppyDisk.shallow(prevSlice, nextSlice)) reRender({});
+      if (!vanilla.shallow(prevSlice, nextSlice)) reRender({});
     }),
     [store]
   );
 };
-const useStoreState = (store, selector = floppyDisk.identity) => {
+const useStoreState = (store, selector = vanilla.identity) => {
   useStoreUpdateNotifier(store, selector);
   return selector(store.getState());
 };
 
 const createStore = (initialState, options) => {
-  const store = floppyDisk.initStore(initialState, options);
+  const store = vanilla.initStore(initialState, options);
   const useStore = (selector) => useStoreState(store, selector);
   return Object.assign(useStore, store);
 };
@@ -33,12 +33,12 @@ const createStore = (initialState, options) => {
 const createStores = (initialState, options) => {
   const stores = /* @__PURE__ */ new Map();
   const getStore = (key = {}) => {
-    const keyHash = floppyDisk.getHash(key);
+    const keyHash = vanilla.getHash(key);
     let store;
     if (stores.has(keyHash)) {
       store = stores.get(keyHash);
     } else {
-      store = floppyDisk.initStore(initialState, options);
+      store = vanilla.initStore(initialState, options);
       stores.set(keyHash, store);
     }
     const useStore = (selector) => {
@@ -82,9 +82,9 @@ const createQuery = (queryFn, options = {}) => {
     // 5 minutes
     revalidateOnFocus = true,
     revalidateOnReconnect = true,
-    onSuccess = floppyDisk.noop,
+    onSuccess = vanilla.noop,
     onError,
-    onSettled = floppyDisk.noop,
+    onSettled = vanilla.noop,
     shouldRetry: shouldRetryFn = (_, s) => s.retryCount === 0 ? [true, 1500] : [false]
   } = options;
   const initialState = INITIAL_STATE$1;
@@ -96,7 +96,7 @@ const createQuery = (queryFn, options = {}) => {
       (_a = options.onFirstSubscribe) == null ? void 0 : _a.call(options, state, store);
       const { metadata, revalidate: revalidate2 } = internals.get(store);
       clearTimeout(metadata.garbageCollectionTimeoutId);
-      if (floppyDisk.isClient) {
+      if (vanilla.isClient) {
         if (revalidateOnFocus) {
           focusListeners.add(revalidate2);
           if (!focusListenersAdded) {
@@ -123,7 +123,7 @@ const createQuery = (queryFn, options = {}) => {
       metadata.garbageCollectionTimeoutId = setTimeout(() => {
         store.setState(initialState);
       }, gcTime);
-      if (floppyDisk.isClient) {
+      if (vanilla.isClient) {
         if (revalidateOnFocus) {
           focusListeners.delete(revalidate2);
           if (focusListeners.size === 0) {
@@ -159,17 +159,17 @@ const createQuery = (queryFn, options = {}) => {
       }
       return false;
     },
-    execute: (overwriteOngoingExecution = false) => {
+    execute: ({ overwriteOngoingExecution = true } = {}) => {
       return execute(store, variable, overwriteOngoingExecution);
     },
-    revalidate: (overwriteOngoingExecution = false) => {
+    revalidate: ({ overwriteOngoingExecution = true } = {}) => {
       return revalidate(store, variable, overwriteOngoingExecution);
     },
-    invalidate: (overwriteOngoingExecution = false) => {
+    invalidate: (options2) => {
       const { metadata } = internals.get(store);
       metadata.isInvalidated = true;
       if (store.getSubscribers().size > 0) {
-        internals.get(store).execute(overwriteOngoingExecution);
+        internals.get(store).execute(options2);
         return true;
       }
       return false;
@@ -316,19 +316,19 @@ const createQuery = (queryFn, options = {}) => {
     return execute(store, variable, overwriteOngoingExecution);
   };
   const getStore = (variable = {}) => {
-    const variableHash = floppyDisk.getHash(variable);
+    const variableHash = vanilla.getHash(variable);
     let store;
     if (stores.has(variableHash)) {
       store = stores.get(variableHash);
     } else {
-      store = floppyDisk.initStore(initialState, configureStoreEvents());
+      store = vanilla.initStore(initialState, configureStoreEvents());
       stores.set(variableHash, store);
       internals.set(store, configureInternals(store, variable, variableHash));
     }
-    const useStore = (options2 = {}, selector = floppyDisk.identity) => {
+    const useStore = (options2 = {}, selector = vanilla.identity) => {
       useStoreUpdateNotifier(store, selector);
       useIsomorphicLayoutEffect(() => {
-        if (options2.enabled !== false) revalidate(store, variable);
+        if (options2.enabled !== false) revalidate(store, variable, false);
       }, [store, options2.enabled]);
       const storeState = store.getState();
       let storeStateToBeUsed = storeState;
@@ -358,8 +358,8 @@ const createQuery = (queryFn, options = {}) => {
      * @remarks
      * - Useful for bulk refetching.
      */
-    executeAll: (overwriteOngoingExecution) => {
-      stores.forEach((store) => internals.get(store).execute(overwriteOngoingExecution));
+    executeAll: (options2) => {
+      stores.forEach((store) => internals.get(store).execute(options2));
     },
     /**
      * Revalidates all query instances.
@@ -367,8 +367,8 @@ const createQuery = (queryFn, options = {}) => {
      * @remarks
      * - Only re-fetches stale queries.
      */
-    revalidateAll: (overwriteOngoingExecution) => {
-      stores.forEach((store) => internals.get(store).revalidate(overwriteOngoingExecution));
+    revalidateAll: (options2) => {
+      stores.forEach((store) => internals.get(store).revalidate(options2));
     },
     /**
      * Invalidates all query instances.
@@ -377,8 +377,8 @@ const createQuery = (queryFn, options = {}) => {
      * - Marks all queries as invalidated and triggers revalidation if active.
      * - Invalidated queries bypass `staleTime` until successfully executed again.
      */
-    invalidateAll: (overwriteOngoingExecution) => {
-      stores.forEach((store) => internals.get(store).invalidate(overwriteOngoingExecution));
+    invalidateAll: (options2) => {
+      stores.forEach((store) => internals.get(store).invalidate(options2));
     },
     /**
      * Resets all query instances.
@@ -407,9 +407,9 @@ const INITIAL_STATE = {
   errorUpdatedAt: void 0
 };
 const createMutation = (mutationFn, options = {}) => {
-  const { onSuccess = floppyDisk.noop, onError, onSettled = floppyDisk.noop } = options;
+  const { onSuccess = vanilla.noop, onError, onSettled = vanilla.noop } = options;
   const initialState = INITIAL_STATE;
-  const store = floppyDisk.initStore(initialState, options);
+  const store = vanilla.initStore(initialState, options);
   const useStore = (selector) => useStoreState(store, selector);
   const execute = (variable) => {
     const stateBeforeExecute = store.getState();

package/vanilla/store.d.ts

@@ -13,17 +13,18 @@ export type SetState<TState> = Partial<TState> | ((state: TState) => Partial<TSt
  * @param prevState - The previous state before the update
  *
  * @remarks
- * - Subscribers are always called on every `setState`, regardless of equality.
- * - It is the subscriber's responsibility to perform comparisons if needed.
+ * - Subscribers are only called when the state actually changes.
+ * - Change detection is performed per key using `Object.is`.
  */
 export type Subscriber<TState> = (state: TState, prevState: TState) => void;
 /**
  * Core store API for managing state.
  *
  * @remarks
- * - The store is intentionally simple and always notifies subscribers on updates.
- * - No internal equality checks are performed.
+ * - The store performs **shallow change detection per key** before notifying subscribers.
+ * - Subscribers are only notified when at least one field changes.
  * - Designed to be framework-agnostic (React bindings are built separately).
+ * - By default, `setState` is **disabled on the server** to prevent accidental shared state between requests.
  */
 export type StoreApi<TState extends Record<string, any>> = {
     setState: (value: SetState<TState>) => void;
@@ -47,6 +48,7 @@ export type InitStoreOptions<TState extends Record<string, any>> = {
     onSubscribe?: (state: TState, store: StoreApi<TState>) => void;
     onUnsubscribe?: (state: TState, store: StoreApi<TState>) => void;
     onLastUnsubscribe?: (state: TState, store: StoreApi<TState>) => void;
+    allowSetStateServerSide?: boolean;
 };
 /**
  * Creates a vanilla store with pub-sub capabilities.
@@ -64,6 +66,9 @@ export type InitStoreOptions<TState extends Record<string, any>> = {
  * - Subscribers are only notified when at least one updated field changes (using `Object.is` comparison).
  * - Subscribers receive both the new state and the previous state.
  * - Lifecycle hooks allow side-effect management tied to subscription count.
+ * - By default, `setState` is **disabled on the server** to prevent accidental shared state between requests.
+ *   - This avoids leaking data between users in server environments.
+ *   - You can override this by setting `allowSetStateServerSide: true`.
  *
  * @example
  * const store = initStore({ count: 0 });

package/vanilla.js

@@ -72,7 +72,8 @@ const initStore = (initialState, options = {}) => {
     onFirstSubscribe = noop,
     onSubscribe = noop,
     onUnsubscribe = noop,
-    onLastUnsubscribe = noop
+    onLastUnsubscribe = noop,
+    allowSetStateServerSide = false
   } = options;
   const subscribers = /* @__PURE__ */ new Set();
   const getSubscribers = () => subscribers;
@@ -89,6 +90,12 @@ const initStore = (initialState, options = {}) => {
   let state = initialState;
   const getState = () => state;
   const setState = (value) => {
+    if (!isClient && !allowSetStateServerSide) {
+      console.error(
+        "setState on the server is not allowed by default. Set `allowSetStateServerSide: true` to allow it."
+      );
+      return;
+    }
     const prevState = state;
     const newValue = getValue(value, state);
     for (const key in newValue) {