floppy-disk 3.0.0-alpha.5 → 3.0.0-alpha.6

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

@@ -0,0 +1,82 @@
+import { type MutationOptions, type MutationState } from './create-mutation.mjs';
+/**
+ * A hook for managing async mutation state.
+ *
+ * @param mutationFn - Async function that performs the mutation.
+ * Receives the input variable and the state snapshot before execution.
+ *
+ * @param options - Optional lifecycle callbacks:
+ * - `onSuccess(data, variable, stateBeforeExecute)`
+ * - `onError(error, variable, stateBeforeExecute)`
+ * - `onSettled(variable, stateBeforeExecute)`
+ *
+ * @returns A tuple containing:
+ * - state: The current mutation state (render snapshot)
+ * - controls: An object with mutation actions and helpers
+ *
+ * @remarks
+ * - No retry mechanism is provided by default.
+ * - The mutation always resolves (never throws): the result contains either `data` or `error`.
+ * - If multiple executions triggered at the same time:
+ *   - Only the latest execution is allowed to update the state.
+ *   - Results from previous executions are ignored if a newer one exists.
+ */
+export declare const useMutation: <TData, TVariable = undefined, TError = Error>(
+/**
+ * Async function that performs the mutation.
+ *
+ * @remarks
+ * - Does NOT need to be memoized (e.g. `useCallback`).
+ * - The latest function reference is always used internally.
+ */
+mutationFn: (variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable, TError>) => Promise<TData>, 
+/**
+ * Optional lifecycle callbacks.
+ *
+ * @remarks
+ * - Callbacks do NOT need to be memoized.
+ * - The latest callbacks are always used internally.
+ */
+options?: MutationOptions<TData, TVariable, TError>) => [MutationState<TData, TVariable, TError>, {
+    /**
+     * Executes the mutation.
+     *
+     * @param variable - Input passed to the mutation function
+     *
+     * @returns A promise that always resolves with:
+     * - `{ data, variable }` on success
+     * - `{ error, variable }` on failure
+     *
+     * @remarks
+     * - The promise never rejects to simplify async handling.
+     * - If a mutation is already in progress, a warning is logged.
+     * - When a new execution starts, all previous pending executions will resolve with the result of the latest execution.
+     */
+    execute: TVariable extends undefined ? () => Promise<{
+        variable: undefined;
+        data?: TData;
+        error?: TError;
+    }> : (variable: TVariable) => Promise<{
+        variable: TVariable;
+        data?: TData;
+        error?: TError;
+    }>;
+    /**
+     * Resets the mutation state back to its initial state.
+     *
+     * @remarks
+     * - Does not cancel any ongoing execution.
+     * - If an execution is still pending, its result may override the reset state.
+     */
+    reset: () => void;
+    /**
+     * Returns the latest mutation state directly from the internal ref.
+     *
+     * @returns The most up-to-date mutation state.
+     *
+     * @remarks
+     * - Unlike the `state` returned by the hook, this value is not tied to React render cycles.
+     * - Use this inside async flows or event handlers to avoid stale reads.
+     */
+    getLatestState: () => MutationState<TData, TVariable, TError>;
+}];

package/esm/react.d.mts

@@ -3,4 +3,5 @@ export { useStoreState } from './react/use-store.mjs';
 export * from './react/create-store.mjs';
 export * from './react/create-stores.mjs';
 export * from './react/create-query.mjs';
-export * from './react/create-mutation.mjs';
+export { createMutation, type MutationOptions, type MutationState, } from './react/create-mutation.mjs';
+export * from './react/use-mutation.mjs';

package/esm/react.mjs

@@ -1,4 +1,4 @@
-import { useLayoutEffect, useEffect, useState, useRef, useMemo } from 'react';
+import { useLayoutEffect, useEffect, useState, useRef, useMemo, useCallback } from 'react';
 import { isClient, initStore, getHash, noop } from 'floppy-disk/vanilla';
 
 const useIsomorphicLayoutEffect = isClient ? useLayoutEffect : useEffect;
@@ -128,7 +128,7 @@ const createQuery = (queryFn, options = {}) => {
     onSettled = noop,
     shouldRetry: shouldRetryFn = (_, s) => s.retryCount === 0 ? [true, 1500] : [false]
   } = options;
-  const initialState = INITIAL_STATE$1;
+  const initialState = { ...INITIAL_STATE$1 };
   const stores = /* @__PURE__ */ new Map();
   const configureStoreEvents = () => ({
     ...options,
@@ -367,7 +367,7 @@ const createQuery = (queryFn, options = {}) => {
       internals.set(store, configureInternals(store, variable, variableHash));
     }
     const useStore = (options2 = {}) => {
-      const { enabled = true, keepPreviousData } = options2;
+      const { revalidateOnMount = true, keepPreviousData } = options2;
       const storeState = store.getState();
       const prevState = useRef({});
       let storeStateToBeUsed = storeState;
@@ -380,7 +380,7 @@ const createQuery = (queryFn, options = {}) => {
         storeStateToBeUsed = { ...storeState, ...prevState.current };
       }
       const [trackedState, usedPathsRef] = useStoreStateProxy(
-        enabled && storeState.state === "INITIAL" ? (
+        revalidateOnMount && storeState.state === "INITIAL" ? (
           // Optimize rendering on initial state
           // Do { isPending: true } → result
           // instead of { isPending: false } → { isPending: true } → result
@@ -404,8 +404,8 @@ const createQuery = (queryFn, options = {}) => {
         });
       }, [store]);
       useIsomorphicLayoutEffect(() => {
-        if (enabled !== false) revalidate(store, variable, false);
-      }, [store, enabled]);
+        if (revalidateOnMount !== false) revalidate(store, variable, false);
+      }, [store, revalidateOnMount]);
       if (keepPreviousData) {
         !!trackedState.error;
       }
@@ -479,19 +479,26 @@ const INITIAL_STATE = {
 };
 const createMutation = (mutationFn, options = {}) => {
   const { onSuccess = noop, onError, onSettled = noop } = options;
-  const initialState = INITIAL_STATE;
+  const initialState = { ...INITIAL_STATE };
+  let ongoingPromise;
+  const resolveFns = /* @__PURE__ */ new Set([]);
   const store = initStore(initialState, options);
   const useStore = () => useStoreState(store.getState(), store.subscribe);
   const execute = (variable) => {
+    let currentResolveFn;
     const stateBeforeExecute = store.getState();
     if (stateBeforeExecute.isPending) {
       console.warn(
-        "Mutation executed while a previous execution is still pending. This may cause race conditions or unexpected state updates."
+        "A mutation was executed while a previous execution is still pending. The previous execution will be ignored (latest execution wins)."
       );
     }
     store.setState({ isPending: true });
-    return new Promise((resolve) => {
+    const promise = new Promise((resolve) => {
+      currentResolveFn = resolve;
       mutationFn(variable, stateBeforeExecute).then((data) => {
+        if (promise !== ongoingPromise) {
+          return resolve({ data, variable });
+        }
         store.setState({
           state: "SUCCESS",
           isPending: false,
@@ -504,8 +511,12 @@ const createMutation = (mutationFn, options = {}) => {
           errorUpdatedAt: void 0
         });
         resolve({ data, variable });
+        resolveFns.clear();
         onSuccess(data, variable, stateBeforeExecute);
       }).catch((error) => {
+        if (promise !== ongoingPromise) {
+          return resolve({ error, variable });
+        }
         store.setState({
           state: "ERROR",
           isPending: false,
@@ -518,12 +529,19 @@ const createMutation = (mutationFn, options = {}) => {
           errorUpdatedAt: Date.now()
         });
         resolve({ error, variable });
+        resolveFns.clear();
         if (onError) onError(error, variable, stateBeforeExecute);
         else console.error(store.getState());
       }).finally(() => {
+        if (promise !== ongoingPromise) return;
         onSettled(variable, stateBeforeExecute);
+        ongoingPromise = void 0;
       });
     });
+    if (ongoingPromise) resolveFns.forEach((resolveFn) => resolveFn(promise));
+    resolveFns.add(currentResolveFn);
+    ongoingPromise = promise;
+    return promise;
   };
   return Object.assign(useStore, {
     subscribe: store.subscribe,
@@ -550,17 +568,17 @@ const createMutation = (mutationFn, options = {}) => {
      * - `{ error, variable }` on failure
      *
      * @remarks
-     * - If a mutation is already in progress, a warning is logged.
-     * - Concurrent executions are allowed but may lead to race conditions.
      * - The promise never rejects to simplify async handling.
+     * - If a mutation is already in progress, a warning is logged.
+     * - When a new execution starts, all previous pending executions will resolve with the result of the latest execution.
      */
     execute,
     /**
      * Resets the mutation state back to its initial state.
      *
      * @remarks
-     * - Does not cancel any ongoing request.
-     * - If a request is still pending, its result may override the reset state.
+     * - Does not cancel any ongoing execution.
+     * - If an execution is still pending, its result may override the reset state.
      */
     reset: () => {
       if (store.getState().isPending) {
@@ -573,4 +591,107 @@ const createMutation = (mutationFn, options = {}) => {
   });
 };
 
-export { createMutation, createQuery, createStore, createStores, useIsomorphicLayoutEffect, useStoreState };
+const useMutation = (mutationFn, options = {}) => {
+  const { onSuccess = noop, onError, onSettled = noop } = options;
+  const callbackRef = useRef({ onSuccess, onError, onSettled });
+  callbackRef.current.onSuccess = onSuccess;
+  callbackRef.current.onError = onError;
+  callbackRef.current.onSettled = onSettled;
+  const stateRef = useRef({ ...INITIAL_STATE });
+  const [, reRender] = useState({});
+  const refs = useRef({
+    mutationFn,
+    ongoingPromise: void 0,
+    resolveFns: /* @__PURE__ */ new Set()
+  });
+  refs.current.mutationFn = mutationFn;
+  const execute = useCallback((variable) => {
+    let currentResolveFn;
+    const stateBeforeExecute = stateRef.current;
+    if (stateBeforeExecute.isPending) {
+      console.warn(
+        "A mutation was executed while a previous execution is still pending. The previous execution will be ignored (latest execution wins)."
+      );
+    }
+    stateRef.current.isPending = true;
+    reRender({});
+    const promise = new Promise(
+      (resolve) => {
+        currentResolveFn = resolve;
+        refs.current.mutationFn(variable, stateBeforeExecute).then((data) => {
+          if (promise !== refs.current.ongoingPromise) {
+            return resolve({ data, variable });
+          }
+          stateRef.current = {
+            state: "SUCCESS",
+            isPending: false,
+            isSuccess: true,
+            isError: false,
+            variable,
+            data,
+            dataUpdatedAt: Date.now(),
+            error: void 0,
+            errorUpdatedAt: void 0
+          };
+          reRender({});
+          resolve({ data, variable });
+          refs.current.resolveFns.clear();
+          callbackRef.current.onSuccess(data, variable, stateBeforeExecute);
+        }).catch((error) => {
+          if (promise !== refs.current.ongoingPromise) {
+            return resolve({ error, variable });
+          }
+          stateRef.current = {
+            state: "ERROR",
+            isPending: false,
+            isSuccess: false,
+            isError: true,
+            variable,
+            data: void 0,
+            dataUpdatedAt: void 0,
+            error,
+            errorUpdatedAt: Date.now()
+          };
+          reRender({});
+          resolve({ error, variable });
+          refs.current.resolveFns.clear();
+          if (callbackRef.current.onError) {
+            callbackRef.current.onError(error, variable, stateBeforeExecute);
+          } else {
+            console.error(stateRef.current);
+          }
+        }).finally(() => {
+          if (promise !== refs.current.ongoingPromise) return;
+          callbackRef.current.onSettled(variable, stateBeforeExecute);
+          refs.current.ongoingPromise = void 0;
+        });
+      }
+    );
+    if (refs.current.ongoingPromise) {
+      refs.current.resolveFns.forEach((resolveFn) => resolveFn(promise));
+    }
+    refs.current.resolveFns.add(currentResolveFn);
+    refs.current.ongoingPromise = promise;
+    return promise;
+  }, []);
+  const reset = useCallback(() => {
+    if (stateRef.current.isPending) {
+      console.warn(
+        "Mutation state was reset while a request is still pending. The request will continue, but its result may override the reset state."
+      );
+    }
+    stateRef.current = { ...INITIAL_STATE };
+    reRender({});
+  }, []);
+  const r = [
+    stateRef.current,
+    {
+      execute,
+      reset,
+      getLatestState: () => stateRef.current
+    }
+  ];
+  return r;
+};
+
+export { createMutation, createQuery, createStore, createStores, useIsomorphicLayoutEffect, useMutation, useStoreState };

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.5",
+  "version": "3.0.0-alpha.6",
   "publishConfig": {
     "tag": "alpha"
   },

package/react/create-mutation.d.ts

@@ -14,7 +14,7 @@ import { type InitStoreOptions, type SetState } from 'floppy-disk/vanilla';
  * - No retry mechanism
  * - No caching across executions
  */
-export type MutationState<TData, TVariable> = {
+export type MutationState<TData, TVariable, TError> = {
     isPending: boolean;
 } & ({
     state: 'INITIAL';
@@ -41,28 +41,42 @@ export type MutationState<TData, TVariable> = {
     variable: TVariable;
     data: undefined;
     dataUpdatedAt: undefined;
-    error: any;
+    error: TError;
     errorUpdatedAt: number;
 });
+export declare const INITIAL_STATE: {
+    state: string;
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    variable: undefined;
+    data: undefined;
+    dataUpdatedAt: undefined;
+    error: undefined;
+    errorUpdatedAt: undefined;
+};
 /**
  * Configuration options for a mutation.
  *
  * @remarks
  * Lifecycle callbacks are triggered for each execution.
  */
-export type MutationOptions<TData, TVariable> = InitStoreOptions<MutationState<TData, TVariable>> & {
+export type MutationOptions<TData, TVariable, TError = Error> = InitStoreOptions<MutationState<TData, TVariable, TError>> & {
     /**
-     * Called when the mutation succeeds.
+     * Called when the mutation succeeds.\
+     * If multiple concurrent executions happened, only the latest execution triggers this callback.
      */
-    onSuccess?: (data: TData, variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => void;
+    onSuccess?: (data: TData, variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable, TError>) => void;
     /**
-     * Called when the mutation fails.
+     * Called when the mutation fails.\
+     * If multiple concurrent executions happened, only the latest execution triggers this callback.
      */
-    onError?: (error: any, variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => void;
+    onError?: (error: TError, variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable, TError>) => void;
     /**
-     * Called after the mutation settles (either success or error).
+     * Called after the mutation settles (either success or error).\
+     * If multiple concurrent executions happened, only the latest execution triggers this callback.
      */
-    onSettled?: (variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable>) => void;
+    onSettled?: (variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable, TError>) => void;
 };
 /**
  * Creates a mutation store for handling async operations that modify data.
@@ -78,8 +92,10 @@ export type MutationOptions<TData, TVariable> = InitStoreOptions<MutationState<T
  * - Mutations are **not cached** and only track the latest execution.
  * - Designed for operations that change data (e.g. create, update, delete).
  * - No retry mechanism is provided by default.
- * - Each execution overwrites the previous state.
  * - The mutation always resolves (never throws): the result contains either `data` or `error`.
+ * - If multiple executions triggered at the same time:
+ *   - Only the latest execution is allowed to update the state.
+ *   - Results from previous executions are ignored if a newer one exists.
  *
  * @example
  * const useCreateUser = createMutation(async (input) => {
@@ -89,10 +105,10 @@ export type MutationOptions<TData, TVariable> = InitStoreOptions<MutationState<T
  * const { isPending } = useCreateUser();
  * 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>) => (() => 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>;
+export declare const createMutation: <TData, TVariable = undefined, TError = Error>(mutationFn: (variable: TVariable, stateBeforeExecute: MutationState<TData, TVariable, TError>) => Promise<TData>, options?: MutationOptions<TData, TVariable, TError>) => (() => MutationState<TData, TVariable, TError>) & {
+    subscribe: (subscriber: import("../vanilla.ts").Subscriber<MutationState<TData, TVariable, TError>>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.ts").Subscriber<MutationState<TData, TVariable, TError>>>;
+    getState: () => MutationState<TData, TVariable, TError>;
     /**
      * Manually updates the mutation state.
      *
@@ -100,7 +116,7 @@ export declare const createMutation: <TData, TVariable = undefined>(mutationFn:
      * - Intended for advanced use cases.
      * - Prefer using provided mutation actions (`execute`, `reset`) instead.
      */
-    setState: (value: SetState<MutationState<TData, TVariable>>) => void;
+    setState: (value: SetState<MutationState<TData, TVariable, TError>>) => void;
     /**
      * Executes the mutation.
      *
@@ -111,25 +127,25 @@ export declare const createMutation: <TData, TVariable = undefined>(mutationFn:
      * - `{ error, variable }` on failure
      *
      * @remarks
-     * - If a mutation is already in progress, a warning is logged.
-     * - Concurrent executions are allowed but may lead to race conditions.
      * - The promise never rejects to simplify async handling.
+     * - If a mutation is already in progress, a warning is logged.
+     * - When a new execution starts, all previous pending executions will resolve with the result of the latest execution.
      */
     execute: TVariable extends undefined ? () => Promise<{
         variable: undefined;
         data?: TData;
-        error?: any;
+        error?: TError;
     }> : (variable: TVariable) => Promise<{
         variable: TVariable;
         data?: TData;
-        error?: any;
+        error?: TError;
     }>;
     /**
      * Resets the mutation state back to its initial state.
      *
      * @remarks
-     * - Does not cancel any ongoing request.
-     * - If a request is still pending, its result may override the reset state.
+     * - Does not cancel any ongoing execution.
+     * - If an execution is still pending, its result may override the reset state.
      */
     reset: () => void;
 };

package/react/create-query.d.ts

@@ -19,7 +19,7 @@ import { type InitStoreOptions, type SetState } from 'floppy-disk/vanilla';
  * @remarks
  * - Data and error are mutually exclusive except in `SUCCESS_BUT_REVALIDATION_ERROR`.
  */
-export type QueryState<TData> = {
+export type QueryState<TData, TError> = {
     isPending: boolean;
     isRevalidating: boolean;
     isRetrying: boolean;
@@ -46,7 +46,7 @@ export type QueryState<TData> = {
     isError: true;
     data: undefined;
     dataUpdatedAt: undefined;
-    error: any;
+    error: TError;
     errorUpdatedAt: number;
 } | {
     state: 'SUCCESS_BUT_REVALIDATION_ERROR';
@@ -54,7 +54,7 @@ export type QueryState<TData> = {
     isError: false;
     data: TData;
     dataUpdatedAt: number;
-    error: any;
+    error: TError;
     errorUpdatedAt: number;
 });
 /**
@@ -63,7 +63,7 @@ export type QueryState<TData> = {
  * @remarks
  * Controls caching, retry behavior, lifecycle, and side effects of an async operation.
  */
-export type QueryOptions<TData, TVariable extends Record<string, any>> = InitStoreOptions<QueryState<TData>> & {
+export type QueryOptions<TData, TVariable extends Record<string, any>, TError = Error> = InitStoreOptions<QueryState<TData, TError>> & {
     /**
      * Time (in milliseconds) that data is considered fresh.
      *
@@ -95,15 +95,15 @@ export type QueryOptions<TData, TVariable extends Record<string, any>> = InitSto
     /**
      * Called when the query succeeds.
      */
-    onSuccess?: (data: TData, variable: TVariable, stateBeforeExecute: QueryState<TData>) => void;
+    onSuccess?: (data: TData, variable: TVariable, stateBeforeExecute: QueryState<TData, TError>) => void;
     /**
      * Called when the query fails and will not retry.
      */
-    onError?: (error: any, variable: TVariable, stateBeforeExecute: QueryState<TData>) => void;
+    onError?: (error: TError, variable: TVariable, stateBeforeExecute: QueryState<TData, TError>) => void;
     /**
      * Called after the query settles (success or final failure).
      */
-    onSettled?: (variable: TVariable, stateBeforeExecute: QueryState<TData>) => void;
+    onSettled?: (variable: TVariable, stateBeforeExecute: QueryState<TData, TError>) => void;
     /**
      * Determines whether a failed query should retry.
      *
@@ -120,7 +120,7 @@ export type QueryOptions<TData, TVariable extends Record<string, any>> = InitSto
      *   return [false];
      * }
      */
-    shouldRetry?: (error: any, currentState: QueryState<TData>) => [true, number] | [false];
+    shouldRetry?: (error: TError, currentState: QueryState<TData, TError>) => [true, number] | [false];
 };
 /**
  * Creates a query factory for managing cached async operations.
@@ -157,13 +157,15 @@ export type QueryOptions<TData, TVariable extends Record<string, any>> = InitSto
  *   // ...
  * }
  */
-export declare const createQuery: <TData, TVariable extends Record<string, any> = never>(queryFn: (variable: TVariable, currentState: QueryState<TData>) => Promise<TData>, options?: QueryOptions<TData, TVariable>) => ((variable?: TVariable) => ((options?: {
+export declare const createQuery: <TData, TVariable extends Record<string, any> = never, TError = Error>(queryFn: (variable: TVariable, currentState: QueryState<TData, TError>) => Promise<TData>, options?: QueryOptions<TData, TVariable, TError>) => ((variable?: TVariable) => ((options?: {
     /**
-     * Whether the query should execute automatically on mount.
+     * Whether the query should be ravalidated automatically on mount.
+     *
+     * Revalidate means execute the queryFn **if stale/invalidated**.
      *
      * @default true
      */
-    enabled?: boolean;
+    revalidateOnMount?: boolean;
     /**
      * Whether to keep previous successful data while a new variable is loading.
      *
@@ -180,13 +182,13 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * // While loading userId=2, still show userId=1 data
      * useQuery({ id: userId }, { keepPreviousData: true });
      */ keepPreviousData?: boolean;
-}) => QueryState<TData>) & {
+}) => QueryState<TData, TError>) & {
     metadata: {
         isInvalidated?: boolean;
-        promise?: Promise<QueryState<TData>> | undefined;
-        promiseResolver?: ((value: QueryState<TData> | PromiseLike<QueryState<TData>>) => void) | undefined;
+        promise?: Promise<QueryState<TData, TError>> | undefined;
+        promiseResolver?: ((value: QueryState<TData, TError> | PromiseLike<QueryState<TData, TError>>) => void) | undefined;
         retryTimeoutId?: number;
-        retryResolver?: ((value: QueryState<TData> | PromiseLike<QueryState<TData>>) => void) | undefined;
+        retryResolver?: ((value: QueryState<TData, TError> | PromiseLike<QueryState<TData, TError>>) => void) | undefined;
         garbageCollectionTimeoutId?: number;
         rollbackData?: TData | undefined;
     };
@@ -222,7 +224,7 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      */
     execute: (options?: {
         overwriteOngoingExecution?: boolean;
-    }) => Promise<QueryState<TData>>;
+    }) => Promise<QueryState<TData, TError>>;
     /**
      * Re-executes the query if needed based on freshness or invalidation.
      *
@@ -238,7 +240,7 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      */
     revalidate: (options?: {
         overwriteOngoingExecution?: boolean;
-    }) => Promise<QueryState<TData>>;
+    }) => Promise<QueryState<TData, TError>>;
     /**
      * Marks the query as invalidated and optionally triggers re-execution.
      *
@@ -290,7 +292,7 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * const { rollback, revalidate } = query.optimisticUpdate(newData);
      */
     optimisticUpdate: (data: TData) => {
-        revalidate: () => Promise<QueryState<TData>>;
+        revalidate: () => Promise<QueryState<TData, TError>>;
         rollback: () => TData;
     };
     /**
@@ -302,10 +304,10 @@ export declare const createQuery: <TData, TVariable extends Record<string, any>
      * - Should be used if an optimistic update fails.
      */
     rollbackOptimisticUpdate: () => 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;
+    subscribe: (subscriber: import("../vanilla.ts").Subscriber<QueryState<TData, TError>>) => () => void;
+    getSubscribers: () => Set<import("../vanilla.ts").Subscriber<QueryState<TData, TError>>>;
+    getState: () => QueryState<TData, TError>;
+    setState: (value: SetState<QueryState<TData, TError>>) => void;
 }) & {
     /**
      * Executes all query instances.