@braine/quantum-query 1.2.0 → 1.2.1

package/README.md

@@ -1,22 +1,23 @@
 # @braine/quantum-query
 
 **State Management at the Speed of Light.**
-> A unified architecture that merges Store, Actions, and API Logic into single, high-performance "Smart Models".
+> A unified, signal-based architecture that merges Store, Actions, and API Logic into a single, high-performance ecosystem.
 
 [![npm version](https://img.shields.io/npm/v/@braine/quantum-query.svg)](https://www.npmjs.com/package/@braine/quantum-query)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Why "Quantum"?
-Existing libraries behave like "Buses". They stop at every station (component) to check if someone needs to get off (re-render).
+## ⚡️ Why "Quantum"?
+Existing libraries (Redux, RTK Query) behave like "Buses". They stop at every station (component) to check if someone needs to get off (re-render via O(n) selectors).
+
 **Quantum-Query** behaves like a teleporter. It updates *only* the specific component listening to a specific property, instantly.
 
-*   **O(1) Reactivity**: No selectors. No linear scans.
-*   **Zero Boilerplate**: No reduces, no thunks, no providers.
-*   **Enterprise Grade**: Built-in HTTP client with automatic deduplication, retries, and cancellation.
+*   **O(1) Reactivity**: Powered by Atomic Signals. Zero selectors. No "Top-Down" re-renders.
+*   **Zero Boilerplate**: No reducers, no providers, no slices, no thunks.
+*   **Enterprise Ecosystem**: Persistence, Plugins, Deduplication, and Validation included.
 
 ---
 
-## Installation
+## 📦 Installation
 
 ```bash
 npm install @braine/quantum-query
@@ -24,13 +25,32 @@ npm install @braine/quantum-query
 
 ---
 
-## The "Smart Model" Pattern
+## 🚀 Quick Start (React Hooks)
+
+If you just want to fetch data, it works exactly like you expect.
+
+```typescript
+import { useQuery } from '@braine/quantum-query';
+
+function UserProfile({ id }) {
+    const { data, isLoading } = useQuery({
+        queryKey: ['user', id],
+        queryFn: () => fetch(`/api/user/${id}`).then(r => r.json()),
+        staleTime: 5000 // Auto-cache for 5s
+    });
+
+    if (isLoading) return <div>Loading...</div>;
+    return <div>Hello, {data.name}!</div>;
+}
+```
+
+---
 
-Stop splitting your logic between Redux (Client) and React Query (Server). Use **Smart Models**.
+## 🧠 The "Smart Model" Pattern (Advanced)
 
-### 1. Define It
-`defineModel` wraps your state, computed properties, and actions into one reactive entity.
+Stop splitting your logic between Redux (Client State) and React Query (Server State). **Smart Models** combine state, computed properties, and actions into one reactive entity.
 
+### 1. Define Model
 ```typescript
 import { defineModel } from '@braine/quantum-query';
 
@@ -45,48 +65,47 @@ export const TodoModel = defineModel({
   computed: {
     activeCount() {
       return this.items.length;
+    },
+    isEmpty() {
+      return this.items.length === 0;
     }
   },
 
   // 3. Actions (Sync + Async + Optimistic)
   actions: {
-    async add(text: string) {
-      // Optimistic Update (Instant UI)
-      this.items.push(text);
-      
-      try {
-        await api.post('/todos', { text });
-      } catch (err) {
-        this.items.pop(); // Auto-Rollback
-      }
+    add(text: string) {
+      this.items.push(text); // Direct mutation (proxied)
+    },
+    async save() {
+       await api.post('/todos', { items: this.items });
     }
   }
 });
 ```
 
-### 2. Use It
-Just use it.
-
+### 2. Use Model
 ```tsx
 import { useStore } from '@braine/quantum-query';
 import { TodoModel } from './models/TodoModel';
 
 function TodoApp() {
-  const model = useStore(TodoModel); // Auto-subscribes!
+  // auto-subscribes ONLY to properties accessed in this component
+  const model = useStore(TodoModel); 
 
   return (
-    <button onClick={() => model.add("Ship it")}>
-      Active: {model.activeCount}
-    </button>
+    <div>
+      <h1>Active: {model.activeCount}</h1>
+      <button onClick={() => model.add("Ship it")}>Add</button>
+    </div>
   );
 }
 ```
 
 ---
 
-## Enterprise HTTP Client
+## 🌐 Enterprise HTTP Client
 
-We built a fetch wrapper that matches **RTK Query** in power but keeps **Axios** simplicity.
+We built a fetch wrapper that matches **RTK Query** in power but keeps **Axios** simplicity. It includes **Automatic Deduplication** and **Retries**.
 
 ```typescript
 import { createHttpClient } from '@braine/quantum-query';
@@ -94,9 +113,9 @@ import { createHttpClient } from '@braine/quantum-query';
 export const api = createHttpClient({
   baseURL: 'https://api.myapp.com',
   timeout: 5000, 
-  retry: { retries: 3 }, // Exponential backoff for 5xx/Network errors
+  retry: { retries: 3 }, // Exponential backoff for Network errors
   
-  // Auth Handling
+  // Auth Handling (Auto-Refresh)
   auth: {
     getToken: () => localStorage.getItem('token'),
     onTokenExpired: async () => {
@@ -107,97 +126,87 @@ export const api = createHttpClient({
   }
 });
 
-// Automatic Deduplication
-// If 5 components call this at once, only 1 request is sent!
-const users = await api.get('/users');
+// data is strictly typed!
+const user = await api.get<User>('/me');
 ```
 
 ---
 
-## Data Integrity (Runtime Safety)
+## 🛡️ Data Integrity (Runtime Safety)
 
-Don't trust the backend. Validate it. We support **Zod**, **Valibot**, or **Yup** directly.
+Don't trust the backend. Validate it. We support **Zod**, **Valibot**, or **Yup** schemas directly in the hook.
 
 ```typescript
 import { z } from 'zod';
 
 const UserSchema = z.object({
   id: z.string(),
-  name: z.string()
+  name: z.string(),
+  role: z.enum(['admin', 'user'])
 });
 
-// 1. Runtime Validation: Throws error if API returns garbage
-// 2. Auto-Typing: 'user' is inferred as { id: string, name: string }
-const user = await api.get('/me', { 
-  schema: UserSchema 
+const { data } = useQuery({
+   queryKey: ['user'],
+   queryFn: fetchUser,
+   schema: UserSchema // Throws descriptive error if API returns garbage
 });
 ```
 
 ---
 
-## Enterprise Query Features ✨
+## 🔌 Plugin System (Middleware) 🆕
 
-TanStack Query-level features with simpler API:
+Inject logic into every request lifecycle (Logging, Analytics, Performance Monitoring).
 
 ```typescript
-import { useQuery, usePaginatedQuery, useInfiniteQuery, useMutation } from '@braine/quantum-query';
-
-// Background refetch (stale-while-revalidate)
-const { data, isStale } = useQuery({
-    queryKey: ['user'],
-    queryFn: () => api.get('/me'),
-    staleTime: 30000,
-    refetchOnWindowFocus: true  // Auto-refresh on tab return
-});
+import { queryCache } from '@braine/quantum-query';
 
-// Pagination
-const { data, nextPage, hasNext } = usePaginatedQuery({
-    queryKey: ['users'],
-    queryFn: (page) => api.get(`/users?page=${page}`)
+queryCache.use({
+    name: 'logger',
+    onFetchStart: (key) => console.log('Fetching', key),
+    onFetchError: (key, error) => console.error(`Fetch failed for ${key}:`, error)
 });
+```
 
-// Infinite Scroll
-const { data, fetchNextPage, hasNextPage } = useInfiniteQuery({
-    queryKey: ['feed'],
-    queryFn: ({ pageParam }) => api.get(`/feed?cursor=${pageParam}`),
-    getNextPageParam: (last) => last.nextCursor
-});
+---
 
-// Optimistic Updates
-const addTodo = useMutation({
-    mutationFn: (todo) => api.post('/todos', todo),
-    onMutate: async (newTodo) => {
-        // Instant UI update
-        const prev = optimisticHelpers.getQueryData(['todos']);
-        optimisticHelpers.setQueryData(['todos'], old => [...old, newTodo]);
-        return { prev };
-    },
-    onError: (err, vars, ctx) => {
-        // Auto-rollback on error
-        optimisticHelpers.setQueryData(['todos'], ctx.prev);
-    }
+## 💾 Persistence Adapter 🆕
+
+Persist your cache to `localStorage` (or IndexedDB/AsyncStorage) automatically. Works offline.
+
+```typescript
+import { persistQueryClient, createLocalStoragePersister } from '@braine/quantum-query/persist';
+
+persistQueryClient({
+    queryClient: queryCache,
+    persister: createLocalStoragePersister(),
+    maxAge: 1000 * 60 * 60 * 24 // 24 hours
 });
 ```
 
 ---
 
-## Comparison
+## 📚 Documentation
 
-| Feature | Redux Toolkit + RTK Query | TanStack Query | **Quantum-Query** |
-| :--- | :--- | :--- | :--- |
-| **State + Queries** | Separate (Redux + RTK) | Queries only | **Unified** ✅ |
-| **Boilerplate** | High | Medium | **Minimal** ✅ |
-| **Performance** | Good | Good | **O(1) Reactivity** ✅ |
-| **Pagination** | Yes | Yes | **Yes** ✅ |
-| **Infinite Scroll** | Yes | Yes | **Yes** ✅ |
-| **Optimistic Updates** | Manual | Yes | **Yes** ✅ |
-| **Bundle Size** | ~40kb | ~13kb | **~8kb** ✅ |
-| **Learning Curve** | Steep | Medium | **Gentle** ✅ |
+*   **[API Reference](docs/api.md)**: Full method signatures and options.
+*   **[Recipes](docs/recipes.md)**: Common patterns (Auth, Infinite Scroll, Optimistic UI).
+*   **[Migration Guide](docs/migration.md)**: Step-by-step guide from RTK Query / Redux.
 
-**Alpha Status:** Battle-testing in progress. Use for new projects, migrate carefully for production.
+---
+
+## 🆚 Comparison
+
+| Feature | RTK Query | TanStack Query | **Quantum-Query** |
+| :--- | :--- | :--- | :--- |
+| **Architecture** | Redux (Store + Slices) | Observers | **Atomic Signals** ✅ |
+| **Boilerplate** | High (Provider + Store) | Medium | **Zero** ✅ |
+| **Re-Renders** | Selector-based (O(n)) | Observer-based | **Signal-based (O(1))** ✅ |
+| **Smart Models** | ❌ (Requires Redux) | ❌ | **Built-in** ✅ |
+| **Bundle Size** | ~17kb | ~13kb | **~3kb** ✅ |
+| **Deduplication** | Yes | Yes | **Yes** ✅ |
+| **Persistence** | `redux-persist` | Experimental | **Built-in First Class** ✅ |
 
 ---
 
 ## License
 MIT
-# -braine-quantum-query

package/dist/index.cjs

@@ -686,16 +686,16 @@ var QueryCache = class {
   /**
    * Generate cache key from query key array
    */
-  generateKey(queryKey) {
+  generateKey = (queryKey) => {
     if (Array.isArray(queryKey)) {
       return stableHash(queryKey);
     }
     return stableHash([queryKey.key, queryKey.params]);
-  }
+  };
   /**
    * Get data (wrapper around signal.get)
    */
-  get(queryKey) {
+  get = (queryKey) => {
     const key = this.generateKey(queryKey);
     const signal = this.signals.get(key);
     if (!signal) return void 0;
@@ -708,12 +708,12 @@ var QueryCache = class {
       return void 0;
     }
     return entry.data;
-  }
+  };
   /**
    * Get Signal for a key (Low level API for hooks)
    * Automatically creates a signal if one doesn't exist
    */
-  getSignal(queryKey) {
+  getSignal = (queryKey) => {
     const key = this.generateKey(queryKey);
     let signal = this.signals.get(key);
     if (!signal) {
@@ -721,11 +721,11 @@ var QueryCache = class {
       this.signals.set(key, signal);
     }
     return signal;
-  }
+  };
   /**
    * Check if data is stale
    */
-  isStale(queryKey) {
+  isStale = (queryKey) => {
     const key = this.generateKey(queryKey);
     const signal = this.signals.get(key);
     if (!signal) return true;
@@ -734,11 +734,11 @@ var QueryCache = class {
     const now = Date.now();
     const age = now - entry.timestamp;
     return age > entry.staleTime;
-  }
+  };
   /**
    * Set cached data (updates signal)
    */
-  set(queryKey, data, options) {
+  set = (queryKey, data, options) => {
     const key = this.generateKey(queryKey);
     const entry = {
       data,
@@ -755,7 +755,7 @@ var QueryCache = class {
     }
     const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
     this.plugins.forEach((p) => p.onQueryUpdated?.(normalizedKey, data));
-  }
+  };
   // --- DEDUPLICATION ---
   deduplicationCache = /* @__PURE__ */ new Map();
   // --- MIDDLEWARE / PLUGINS ---
@@ -763,15 +763,15 @@ var QueryCache = class {
   /**
    * Register a middleware plugin
    */
-  use(plugin) {
+  use = (plugin) => {
     this.plugins.push(plugin);
     return this;
-  }
+  };
   /**
    * Fetch data with deduplication.
    * If a request for the same key is already in flight, returns the existing promise.
    */
-  async fetch(queryKey, fn) {
+  fetch = async (queryKey, fn) => {
     const key = this.generateKey(queryKey);
     const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
     if (this.deduplicationCache.has(key)) {
@@ -792,12 +792,12 @@ var QueryCache = class {
     );
     this.deduplicationCache.set(key, promise);
     return promise;
-  }
+  };
   /**
    * Invalidate queries matching the key prefix
    * Marks them as undefined to trigger refetches without breaking subscriptions
    */
-  invalidate(queryKey) {
+  invalidate = (queryKey) => {
     const prefix = this.generateKey(queryKey);
     const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
     this.plugins.forEach((p) => p.onInvalidate?.(normalizedKey));
@@ -813,23 +813,23 @@ var QueryCache = class {
         invalidateKey(key);
       }
     }
-  }
+  };
   /**
    * Remove all cache entries
    */
-  clear() {
+  clear = () => {
     this.signals.clear();
-  }
+  };
   /**
    * Prefetch data (same as set but explicit intent)
    */
-  prefetch(queryKey, data, options) {
+  prefetch = (queryKey, data, options) => {
     this.set(queryKey, data, options);
-  }
+  };
   /**
    * Garbage collection - remove expired entries
    */
-  startGarbageCollection() {
+  startGarbageCollection = () => {
     this.gcInterval = setInterval(() => {
       const now = Date.now();
       for (const [key, signal] of this.signals.entries()) {
@@ -841,37 +841,37 @@ var QueryCache = class {
         }
       }
     }, 60 * 1e3);
-  }
+  };
   /**
    * Stop garbage collection
    */
-  destroy() {
+  destroy = () => {
     if (this.gcInterval) {
       clearInterval(this.gcInterval);
       this.gcInterval = null;
     }
     this.clear();
-  }
+  };
   /**
    * Get cache stats (for debugging)
    */
-  getStats() {
+  getStats = () => {
     return {
       size: this.signals.size,
       keys: Array.from(this.signals.keys())
     };
-  }
+  };
   /**
    * Get all entries (wrapper for DevTools)
    */
-  getAll() {
+  getAll = () => {
     const map = /* @__PURE__ */ new Map();
     for (const [key, signal] of this.signals.entries()) {
       const val = signal.get();
       if (val) map.set(key, val);
     }
     return map;
-  }
+  };
 };
 var queryCache = new QueryCache();
 

package/dist/index.d.cts

@@ -155,50 +155,50 @@ declare class QueryCache {
     /**
      * Get data (wrapper around signal.get)
      */
-    get<T>(queryKey: QueryKeyInput): T | undefined;
+    get: <T>(queryKey: QueryKeyInput) => T | undefined;
     /**
      * Get Signal for a key (Low level API for hooks)
      * Automatically creates a signal if one doesn't exist
      */
-    getSignal<T>(queryKey: QueryKeyInput): Signal<CacheEntry<T> | undefined>;
+    getSignal: <T>(queryKey: QueryKeyInput) => Signal<CacheEntry<T> | undefined>;
     /**
      * Check if data is stale
      */
-    isStale(queryKey: QueryKeyInput): boolean;
+    isStale: (queryKey: QueryKeyInput) => boolean;
     /**
      * Set cached data (updates signal)
      */
-    set<T>(queryKey: QueryKeyInput, data: T, options?: {
+    set: <T>(queryKey: QueryKeyInput, data: T, options?: {
         staleTime?: number;
         cacheTime?: number;
-    }): void;
+    }) => void;
     private deduplicationCache;
     private plugins;
     /**
      * Register a middleware plugin
      */
-    use(plugin: QueryPlugin): this;
+    use: (plugin: QueryPlugin) => this;
     /**
      * Fetch data with deduplication.
      * If a request for the same key is already in flight, returns the existing promise.
      */
-    fetch<T>(queryKey: QueryKeyInput, fn: () => Promise<T>): Promise<T>;
+    fetch: <T>(queryKey: QueryKeyInput, fn: () => Promise<T>) => Promise<T>;
     /**
      * Invalidate queries matching the key prefix
      * Marks them as undefined to trigger refetches without breaking subscriptions
      */
-    invalidate(queryKey: QueryKeyInput): void;
+    invalidate: (queryKey: QueryKeyInput) => void;
     /**
      * Remove all cache entries
      */
-    clear(): void;
+    clear: () => void;
     /**
      * Prefetch data (same as set but explicit intent)
      */
-    prefetch<T>(queryKey: QueryKeyInput, data: T, options?: {
+    prefetch: <T>(queryKey: QueryKeyInput, data: T, options?: {
         staleTime?: number;
         cacheTime?: number;
-    }): void;
+    }) => void;
     /**
      * Garbage collection - remove expired entries
      */
@@ -206,18 +206,18 @@ declare class QueryCache {
     /**
      * Stop garbage collection
      */
-    destroy(): void;
+    destroy: () => void;
     /**
      * Get cache stats (for debugging)
      */
-    getStats(): {
+    getStats: () => {
         size: number;
         keys: string[];
     };
     /**
      * Get all entries (wrapper for DevTools)
      */
-    getAll(): Map<string, CacheEntry>;
+    getAll: () => Map<string, CacheEntry>;
 }
 declare const queryCache: QueryCache;
 

package/dist/index.d.ts

@@ -155,50 +155,50 @@ declare class QueryCache {
     /**
      * Get data (wrapper around signal.get)
      */
-    get<T>(queryKey: QueryKeyInput): T | undefined;
+    get: <T>(queryKey: QueryKeyInput) => T | undefined;
     /**
      * Get Signal for a key (Low level API for hooks)
      * Automatically creates a signal if one doesn't exist
      */
-    getSignal<T>(queryKey: QueryKeyInput): Signal<CacheEntry<T> | undefined>;
+    getSignal: <T>(queryKey: QueryKeyInput) => Signal<CacheEntry<T> | undefined>;
     /**
      * Check if data is stale
      */
-    isStale(queryKey: QueryKeyInput): boolean;
+    isStale: (queryKey: QueryKeyInput) => boolean;
     /**
      * Set cached data (updates signal)
      */
-    set<T>(queryKey: QueryKeyInput, data: T, options?: {
+    set: <T>(queryKey: QueryKeyInput, data: T, options?: {
         staleTime?: number;
         cacheTime?: number;
-    }): void;
+    }) => void;
     private deduplicationCache;
     private plugins;
     /**
      * Register a middleware plugin
      */
-    use(plugin: QueryPlugin): this;
+    use: (plugin: QueryPlugin) => this;
     /**
      * Fetch data with deduplication.
      * If a request for the same key is already in flight, returns the existing promise.
      */
-    fetch<T>(queryKey: QueryKeyInput, fn: () => Promise<T>): Promise<T>;
+    fetch: <T>(queryKey: QueryKeyInput, fn: () => Promise<T>) => Promise<T>;
     /**
      * Invalidate queries matching the key prefix
      * Marks them as undefined to trigger refetches without breaking subscriptions
      */
-    invalidate(queryKey: QueryKeyInput): void;
+    invalidate: (queryKey: QueryKeyInput) => void;
     /**
      * Remove all cache entries
      */
-    clear(): void;
+    clear: () => void;
     /**
      * Prefetch data (same as set but explicit intent)
      */
-    prefetch<T>(queryKey: QueryKeyInput, data: T, options?: {
+    prefetch: <T>(queryKey: QueryKeyInput, data: T, options?: {
         staleTime?: number;
         cacheTime?: number;
-    }): void;
+    }) => void;
     /**
      * Garbage collection - remove expired entries
      */
@@ -206,18 +206,18 @@ declare class QueryCache {
     /**
      * Stop garbage collection
      */
-    destroy(): void;
+    destroy: () => void;
     /**
      * Get cache stats (for debugging)
      */
-    getStats(): {
+    getStats: () => {
         size: number;
         keys: string[];
     };
     /**
      * Get all entries (wrapper for DevTools)
      */
-    getAll(): Map<string, CacheEntry>;
+    getAll: () => Map<string, CacheEntry>;
 }
 declare const queryCache: QueryCache;
 

package/dist/index.js

@@ -638,16 +638,16 @@ var QueryCache = class {
   /**
    * Generate cache key from query key array
    */
-  generateKey(queryKey) {
+  generateKey = (queryKey) => {
     if (Array.isArray(queryKey)) {
       return stableHash(queryKey);
     }
     return stableHash([queryKey.key, queryKey.params]);
-  }
+  };
   /**
    * Get data (wrapper around signal.get)
    */
-  get(queryKey) {
+  get = (queryKey) => {
     const key = this.generateKey(queryKey);
     const signal = this.signals.get(key);
     if (!signal) return void 0;
@@ -660,12 +660,12 @@ var QueryCache = class {
       return void 0;
     }
     return entry.data;
-  }
+  };
   /**
    * Get Signal for a key (Low level API for hooks)
    * Automatically creates a signal if one doesn't exist
    */
-  getSignal(queryKey) {
+  getSignal = (queryKey) => {
     const key = this.generateKey(queryKey);
     let signal = this.signals.get(key);
     if (!signal) {
@@ -673,11 +673,11 @@ var QueryCache = class {
       this.signals.set(key, signal);
     }
     return signal;
-  }
+  };
   /**
    * Check if data is stale
    */
-  isStale(queryKey) {
+  isStale = (queryKey) => {
     const key = this.generateKey(queryKey);
     const signal = this.signals.get(key);
     if (!signal) return true;
@@ -686,11 +686,11 @@ var QueryCache = class {
     const now = Date.now();
     const age = now - entry.timestamp;
     return age > entry.staleTime;
-  }
+  };
   /**
    * Set cached data (updates signal)
    */
-  set(queryKey, data, options) {
+  set = (queryKey, data, options) => {
     const key = this.generateKey(queryKey);
     const entry = {
       data,
@@ -707,7 +707,7 @@ var QueryCache = class {
     }
     const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
     this.plugins.forEach((p) => p.onQueryUpdated?.(normalizedKey, data));
-  }
+  };
   // --- DEDUPLICATION ---
   deduplicationCache = /* @__PURE__ */ new Map();
   // --- MIDDLEWARE / PLUGINS ---
@@ -715,15 +715,15 @@ var QueryCache = class {
   /**
    * Register a middleware plugin
    */
-  use(plugin) {
+  use = (plugin) => {
     this.plugins.push(plugin);
     return this;
-  }
+  };
   /**
    * Fetch data with deduplication.
    * If a request for the same key is already in flight, returns the existing promise.
    */
-  async fetch(queryKey, fn) {
+  fetch = async (queryKey, fn) => {
     const key = this.generateKey(queryKey);
     const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
     if (this.deduplicationCache.has(key)) {
@@ -744,12 +744,12 @@ var QueryCache = class {
     );
     this.deduplicationCache.set(key, promise);
     return promise;
-  }
+  };
   /**
    * Invalidate queries matching the key prefix
    * Marks them as undefined to trigger refetches without breaking subscriptions
    */
-  invalidate(queryKey) {
+  invalidate = (queryKey) => {
     const prefix = this.generateKey(queryKey);
     const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
     this.plugins.forEach((p) => p.onInvalidate?.(normalizedKey));
@@ -765,23 +765,23 @@ var QueryCache = class {
         invalidateKey(key);
       }
     }
-  }
+  };
   /**
    * Remove all cache entries
    */
-  clear() {
+  clear = () => {
     this.signals.clear();
-  }
+  };
   /**
    * Prefetch data (same as set but explicit intent)
    */
-  prefetch(queryKey, data, options) {
+  prefetch = (queryKey, data, options) => {
     this.set(queryKey, data, options);
-  }
+  };
   /**
    * Garbage collection - remove expired entries
    */
-  startGarbageCollection() {
+  startGarbageCollection = () => {
     this.gcInterval = setInterval(() => {
       const now = Date.now();
       for (const [key, signal] of this.signals.entries()) {
@@ -793,37 +793,37 @@ var QueryCache = class {
         }
       }
     }, 60 * 1e3);
-  }
+  };
   /**
    * Stop garbage collection
    */
-  destroy() {
+  destroy = () => {
     if (this.gcInterval) {
       clearInterval(this.gcInterval);
       this.gcInterval = null;
     }
     this.clear();
-  }
+  };
   /**
    * Get cache stats (for debugging)
    */
-  getStats() {
+  getStats = () => {
     return {
       size: this.signals.size,
       keys: Array.from(this.signals.keys())
     };
-  }
+  };
   /**
    * Get all entries (wrapper for DevTools)
    */
-  getAll() {
+  getAll = () => {
     const map = /* @__PURE__ */ new Map();
     for (const [key, signal] of this.signals.entries()) {
       const val = signal.get();
       if (val) map.set(key, val);
     }
     return map;
-  }
+  };
 };
 var queryCache = new QueryCache();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@braine/quantum-query",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "type": "module",
   "main": "index.js",
   "scripts": {