@cimplify/sdk 0.22.0 → 0.22.2

package/dist/react.mjs

@@ -3,7 +3,7 @@ import { getVariantDisplayName, createCimplifyClient } from './chunk-W3DMONZR.mj
 export { getVariantDisplayName } from './chunk-W3DMONZR.mjs';
 import { ELEMENT_TYPES, EVENT_TYPES } from './chunk-R4EYMPSN.mjs';
 import { isSupportedCurrency, formatPrice, parsePrice, isOnSale, getDiscountPercentage, getBasePrice } from './chunk-JFT63H34.mjs';
-import React3, { createContext, useContext, useState, useEffect, useRef, useMemo, useSyncExternalStore, useCallback, useId } from 'react';
+import React3, { createContext, useRef, useState, useCallback, useEffect, useContext, useMemo, useSyncExternalStore, useId } from 'react';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 import { NumberField } from '@base-ui/react/number-field';
 import { clsx } from 'clsx';
@@ -1679,41 +1679,130 @@ function Price({ amount, className, prefix }) {
     formatPrice(convertPrice(amount), displayCurrency)
   ] });
 }
-var productsCache = /* @__PURE__ */ new Map();
-var productsInflight = /* @__PURE__ */ new Map();
-function buildProductsCacheKey(client, locationId, options) {
-  return [
-    client.getPublicKey(),
-    locationId ?? "",
-    options.category ?? "",
-    options.taxonomy ?? "",
-    options.search ?? "",
-    options.featured ?? "",
-    options.limit ?? "",
-    options.sort_by ?? "",
-    options.sort_order ?? "",
-    options.tags?.join(",") ?? "",
-    options.in_stock ?? "",
-    options.min_price ?? "",
-    options.max_price ?? "",
-    options.page ?? "",
-    options.properties ? JSON.stringify(options.properties) : ""
-  ].join("|");
-}
-function useProducts(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useProducts must be used within CimplifyProvider or passed { client }.");
+function createCachedQuery(config) {
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  const gcMaxAge = config.gcMaxAge ?? 3e5;
+  let lastSweep = 0;
+  function sweep() {
+    const now = Date.now();
+    if (now - lastSweep < 6e4) return;
+    lastSweep = now;
+    const cutoff = now - gcMaxAge;
+    for (const [key, entry] of cache) {
+      if (entry.ts < cutoff) cache.delete(key);
+    }
   }
-  const enabled = options.enabled ?? true;
-  const locationId = client.getLocationId();
-  const previousLocationIdRef = useRef(locationId);
-  const requestIdRef = useRef(0);
-  const tagsSignature = options.tags?.join(",") ?? "";
-  const propertiesSignature = options.properties ? JSON.stringify(options.properties) : "";
-  const queryOptions = useMemo(
-    () => ({
+  function useCachedQuery(options = {}) {
+    const context = useOptionalCimplifyClient();
+    const client = options.client ?? context?.client;
+    if (!client) {
+      throw new Error(
+        `${config.name} must be used within CimplifyProvider or passed { client }.`
+      );
+    }
+    const enabled = options.enabled ?? true;
+    const locationId = client.getLocationId();
+    const previousLocationRef = useRef(locationId);
+    const requestIdRef = useRef(0);
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    if (config.locationSensitive && previousLocationRef.current !== locationId) {
+      cache.clear();
+      inflight.clear();
+      previousLocationRef.current = locationId;
+    }
+    sweep();
+    const cacheKey2 = config.key(client, options);
+    const cached = cache.get(cacheKey2);
+    const [data, setData] = useState(cached?.data ?? null);
+    const [isLoading, setIsLoading] = useState(enabled && !cached);
+    const [error, setError] = useState(null);
+    const load = useCallback(
+      async (force = false) => {
+        if (!enabled) {
+          setIsLoading(false);
+          return;
+        }
+        const nextRequestId = ++requestIdRef.current;
+        setError(null);
+        if (!force) {
+          const hit = cache.get(cacheKey2);
+          if (hit) {
+            setData(hit.data);
+            setIsLoading(false);
+            return;
+          }
+        }
+        setIsLoading(true);
+        try {
+          const existing = inflight.get(cacheKey2);
+          const promise = existing ?? (async () => config.fetch(client, optionsRef.current))();
+          if (!existing) {
+            inflight.set(cacheKey2, promise);
+            promise.finally(() => inflight.delete(cacheKey2)).catch(() => {
+            });
+          }
+          const value = await promise;
+          cache.set(cacheKey2, { data: value, ts: Date.now() });
+          if (nextRequestId === requestIdRef.current) {
+            setData(value);
+            setError(null);
+          }
+        } catch (loadError) {
+          if (nextRequestId === requestIdRef.current) {
+            setError(loadError);
+          }
+        } finally {
+          if (nextRequestId === requestIdRef.current) {
+            setIsLoading(false);
+          }
+        }
+      },
+      [cacheKey2, client, enabled]
+    );
+    useEffect(() => {
+      void load(false);
+    }, [load]);
+    const refetch = useCallback(async () => {
+      cache.delete(cacheKey2);
+      await load(true);
+    }, [cacheKey2, load]);
+    return { data, isLoading, error, refetch };
+  }
+  useCachedQuery.clear = () => {
+    cache.clear();
+    inflight.clear();
+  };
+  return useCachedQuery;
+}
+function cacheKey(...parts) {
+  return parts.map((p) => String(p ?? "")).join("|");
+}
+
+// src/react/hooks/use-products.ts
+var productsQuery = createCachedQuery({
+  name: "useProducts",
+  locationSensitive: true,
+  key: (client, options) => cacheKey(
+    client.getPublicKey(),
+    client.getLocationId(),
+    options.category,
+    options.taxonomy,
+    options.search,
+    options.featured,
+    options.limit,
+    options.sort_by,
+    options.sort_order,
+    options.tags?.join(","),
+    options.in_stock,
+    options.min_price,
+    options.max_price,
+    options.page,
+    options.properties ? JSON.stringify(options.properties) : void 0
+  ),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getProducts({
       category: options.category,
       taxonomy: options.taxonomy,
       search: options.search,
@@ -1727,301 +1816,71 @@ function useProducts(options = {}) {
       max_price: options.max_price,
       page: options.page,
       properties: options.properties
-    }),
-    [
-      options.category,
-      options.taxonomy,
-      options.search,
-      options.featured,
-      options.limit,
-      options.sort_by,
-      options.sort_order,
-      tagsSignature,
-      options.in_stock,
-      options.min_price,
-      options.max_price,
-      options.page,
-      propertiesSignature
-    ]
-  );
-  const cacheKey = useMemo(
-    () => buildProductsCacheKey(client, locationId, queryOptions),
-    [client, locationId, queryOptions]
-  );
-  const cached = productsCache.get(cacheKey);
-  const [products, setProducts] = useState(cached?.products ?? []);
-  const [isComplete, setIsComplete] = useState(cached?.is_complete ?? true);
-  const [totalAvailable, setTotalAvailable] = useState(cached?.total_available);
-  const [pagination, setPagination] = useState(cached?.pagination);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      productsCache.clear();
-      productsInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cacheEntry = productsCache.get(cacheKey);
-        if (cacheEntry) {
-          setProducts(cacheEntry.products);
-          setIsComplete(cacheEntry.is_complete);
-          setTotalAvailable(cacheEntry.total_available);
-          setPagination(cacheEntry.pagination);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = productsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getProducts(queryOptions);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          productsInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              productsInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        productsCache.set(cacheKey, {
-          products: value.items,
-          is_complete: value.is_complete,
-          total_available: value.total_available,
-          pagination: value.pagination
-        });
-        if (nextRequestId === requestIdRef.current) {
-          setProducts(value.items);
-          setIsComplete(value.is_complete);
-          setTotalAvailable(value.total_available);
-          setPagination(value.pagination);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled, queryOptions]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    productsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
+    });
+    if (!result.ok) throw result.error;
+    return {
+      products: result.value.items,
+      is_complete: result.value.is_complete,
+      total_available: result.value.total_available,
+      pagination: result.value.pagination
+    };
+  }
+});
+function useProducts(options = {}) {
+  const { data, isLoading, error, refetch } = productsQuery(options);
   return {
-    products,
-    is_complete: isComplete,
-    total_available: totalAvailable,
-    pagination,
+    products: data?.products ?? [],
+    is_complete: data?.is_complete ?? true,
+    total_available: data?.total_available,
+    pagination: data?.pagination,
     isLoading,
     error,
     refetch
   };
 }
-var productCache = /* @__PURE__ */ new Map();
-var productInflight = /* @__PURE__ */ new Map();
+
+// src/react/hooks/use-product.ts
 function isLikelySlug(value) {
   return /^[a-z0-9-]+$/.test(value);
 }
-function buildProductCacheKey(client, locationId, slugOrId) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    location_id: locationId || "__none__",
-    slug_or_id: slugOrId
+var productQuery = createCachedQuery({
+  name: "useProduct",
+  locationSensitive: true,
+  key: (client, options) => cacheKey(client.getPublicKey(), client.getLocationId(), options.slugOrId),
+  fetch: async (client, options) => {
+    const result = isLikelySlug(options.slugOrId) ? await client.catalogue.getProductBySlug(options.slugOrId) : await client.catalogue.getProduct(options.slugOrId);
+    if (!result.ok) throw result.error;
+    client.activity.trackProductView(result.value.id, {
+      productName: result.value.name,
+      categoryId: result.value.category_id,
+      price: String(result.value.default_price)
+    });
+    return result.value;
+  }
+});
+function useProduct(slugOrId, options = {}) {
+  const normalized = (slugOrId || "").trim();
+  const { data, isLoading, error, refetch } = productQuery({
+    ...options,
+    slugOrId: normalized,
+    enabled: (options.enabled ?? true) && normalized.length > 0
   });
+  return { product: data, isLoading, error, refetch };
 }
-function useProduct(slugOrId, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useProduct must be used within CimplifyProvider or passed { client }.");
+
+// src/react/hooks/use-categories.ts
+var categoriesQuery = createCachedQuery({
+  name: "useCategories",
+  key: (client) => client.getPublicKey() || "__demo__",
+  fetch: async (client) => {
+    const result = await client.catalogue.getCategories();
+    if (!result.ok) throw result.error;
+    return result.value;
   }
-  const enabled = options.enabled ?? true;
-  const locationId = client.getLocationId();
-  const previousLocationIdRef = useRef(locationId);
-  const requestIdRef = useRef(0);
-  const trackedProductRef = useRef(null);
-  const normalizedSlugOrId = useMemo(() => (slugOrId || "").trim(), [slugOrId]);
-  const cacheKey = useMemo(
-    () => buildProductCacheKey(client, locationId, normalizedSlugOrId),
-    [client, locationId, normalizedSlugOrId]
-  );
-  const cached = productCache.get(cacheKey);
-  const [product, setProduct] = useState(cached?.product ?? null);
-  const [isLoading, setIsLoading] = useState(
-    enabled && normalizedSlugOrId.length > 0 && !cached
-  );
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      productCache.clear();
-      productInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled || normalizedSlugOrId.length === 0) {
-        setProduct(null);
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cacheEntry = productCache.get(cacheKey);
-        if (cacheEntry) {
-          setProduct(cacheEntry.product);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = productInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = isLikelySlug(normalizedSlugOrId) ? await client.catalogue.getProductBySlug(normalizedSlugOrId) : await client.catalogue.getProduct(normalizedSlugOrId);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          productInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              productInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        productCache.set(cacheKey, { product: value });
-        if (nextRequestId === requestIdRef.current) {
-          setProduct(value);
-          setError(null);
-          if (value && trackedProductRef.current !== value.id) {
-            trackedProductRef.current = value.id;
-            client.activity.trackProductView(value.id, {
-              productName: value.name,
-              categoryId: value.category_id,
-              price: String(value.default_price)
-            });
-          }
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled, normalizedSlugOrId]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    productCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { product, isLoading, error, refetch };
-}
-var categoriesCache = /* @__PURE__ */ new Map();
-var categoriesInflight = /* @__PURE__ */ new Map();
-function buildCategoriesCacheKey(client) {
-  return client.getPublicKey() || "__demo__";
-}
+});
 function useCategories(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useCategories must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(() => buildCategoriesCacheKey(client), [client]);
-  const cached = categoriesCache.get(cacheKey);
-  const [categories, setCategories] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedCategories = categoriesCache.get(cacheKey);
-        if (cachedCategories) {
-          setCategories(cachedCategories);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = categoriesInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getCategories();
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          categoriesInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              categoriesInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        categoriesCache.set(cacheKey, value);
-        setCategories(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    categoriesCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { categories, isLoading, error, refetch };
+  const { data, isLoading, error, refetch } = categoriesQuery(options);
+  return { categories: data ?? [], isLoading, error, refetch };
 }
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled", "refunded"]);
 var orderCache = /* @__PURE__ */ new Map();
@@ -2043,11 +1902,11 @@ function useOrder(orderId, options = {}) {
   const previousStatusRef = useRef(null);
   const onStatusChangeRef = useRef(options.onStatusChange);
   onStatusChangeRef.current = options.onStatusChange;
-  const cacheKey = useMemo(
+  const cacheKey2 = useMemo(
     () => buildOrderCacheKey(client, normalizedOrderId),
     [client, normalizedOrderId]
   );
-  const cached = orderCache.get(cacheKey);
+  const cached = orderCache.get(cacheKey2);
   const [order, setOrder] = useState(cached?.order ?? null);
   const [isLoading, setIsLoading] = useState(
     enabled && normalizedOrderId.length > 0 && !cached
@@ -2063,7 +1922,7 @@ function useOrder(orderId, options = {}) {
       const nextRequestId = ++requestIdRef.current;
       setError(null);
       if (!force) {
-        const cacheEntry = orderCache.get(cacheKey);
+        const cacheEntry = orderCache.get(cacheKey2);
         if (cacheEntry) {
           setOrder(cacheEntry.order);
           setIsLoading(false);
@@ -2072,7 +1931,7 @@ function useOrder(orderId, options = {}) {
       }
       setIsLoading(true);
       try {
-        const existing = orderInflight.get(cacheKey);
+        const existing = orderInflight.get(cacheKey2);
         const promise = existing ?? (async () => {
           const result = await client.orders.get(normalizedOrderId);
           if (!result.ok) {
@@ -2082,14 +1941,14 @@ function useOrder(orderId, options = {}) {
         })();
         if (!existing) {
           orderInflight.set(
-            cacheKey,
+            cacheKey2,
             promise.finally(() => {
-              orderInflight.delete(cacheKey);
+              orderInflight.delete(cacheKey2);
             })
           );
         }
         const value = await promise;
-        orderCache.set(cacheKey, { order: value });
+        orderCache.set(cacheKey2, { order: value });
         if (nextRequestId === requestIdRef.current) {
           setOrder(value);
           setError(null);
@@ -2110,7 +1969,7 @@ function useOrder(orderId, options = {}) {
         }
       }
     },
-    [cacheKey, client, enabled, normalizedOrderId]
+    [cacheKey2, client, enabled, normalizedOrderId]
   );
   useEffect(() => {
     void load(false);
@@ -2128,9 +1987,9 @@ function useOrder(orderId, options = {}) {
     };
   }, [enabled, isTerminal, load, normalizedOrderId, poll, pollInterval]);
   const refetch = useCallback(async () => {
-    orderCache.delete(cacheKey);
+    orderCache.delete(cacheKey2);
     await load(true);
-  }, [cacheKey, load]);
+  }, [cacheKey2, load]);
   return { order, isLoading, error, refetch, isTerminal };
 }
 var LOCATION_STORAGE_KEY2 = "cimplify_location_id";
@@ -2233,216 +2092,64 @@ function useLocations(options = {}) {
     isLoading
   };
 }
-var collectionsCache = /* @__PURE__ */ new Map();
-var collectionsInflight = /* @__PURE__ */ new Map();
-function buildCollectionsCacheKey(client, locationId) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    location_id: locationId || "__none__"
+
+// src/react/hooks/use-collections.ts
+var collectionsQuery = createCachedQuery({
+  name: "useCollections",
+  locationSensitive: true,
+  key: (client) => cacheKey(client.getPublicKey(), client.getLocationId()),
+  fetch: async (client) => {
+    const result = await client.catalogue.getCollections();
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useCollections(options = {}) {
+  const { data, isLoading, error, refetch } = collectionsQuery(options);
+  return { collections: data ?? [], isLoading, error, refetch };
+}
+
+// src/react/hooks/use-collection.ts
+function isLikelySlug2(value) {
+  return /^[a-z0-9-]+$/.test(value);
+}
+var collectionQuery = createCachedQuery({
+  name: "useCollection",
+  locationSensitive: true,
+  key: (client, options) => cacheKey(client.getPublicKey(), client.getLocationId(), options.idOrSlug),
+  fetch: async (client, options) => {
+    const collectionResult = isLikelySlug2(options.idOrSlug) ? await client.catalogue.getCollectionBySlug(options.idOrSlug) : await client.catalogue.getCollection(options.idOrSlug);
+    if (!collectionResult.ok) throw collectionResult.error;
+    const productsResult = await client.catalogue.getCollectionProducts(
+      collectionResult.value.id
+    );
+    if (!productsResult.ok) throw productsResult.error;
+    return {
+      collection: collectionResult.value,
+      products: productsResult.value
+    };
+  }
+});
+function useCollection(idOrSlug, options = {}) {
+  const normalized = (idOrSlug || "").trim();
+  const { data, isLoading, error, refetch } = collectionQuery({
+    ...options,
+    idOrSlug: normalized,
+    enabled: (options.enabled ?? true) && normalized.length > 0
   });
+  return {
+    collection: data?.collection ?? null,
+    products: data?.products ?? [],
+    isLoading,
+    error,
+    refetch
+  };
 }
-function useCollections(options = {}) {
+function useSearch(options = {}) {
   const context = useOptionalCimplifyClient();
   const client = options.client ?? context?.client;
   if (!client) {
-    throw new Error("useCollections must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const locationId = client.getLocationId();
-  const previousLocationIdRef = useRef(locationId);
-  const requestIdRef = useRef(0);
-  const cacheKey = useMemo(
-    () => buildCollectionsCacheKey(client, locationId),
-    [client, locationId]
-  );
-  const cached = collectionsCache.get(cacheKey);
-  const [collections, setCollections] = useState(cached?.collections ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      collectionsCache.clear();
-      collectionsInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cacheEntry = collectionsCache.get(cacheKey);
-        if (cacheEntry) {
-          setCollections(cacheEntry.collections);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = collectionsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getCollections();
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          collectionsInflight.set(cacheKey, promise);
-          promise.finally(() => {
-            collectionsInflight.delete(cacheKey);
-          }).catch(() => void 0);
-        }
-        const value = await promise;
-        collectionsCache.set(cacheKey, { collections: value });
-        if (nextRequestId === requestIdRef.current) {
-          setCollections(value);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    collectionsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { collections, isLoading, error, refetch };
-}
-var collectionCache = /* @__PURE__ */ new Map();
-var collectionInflight = /* @__PURE__ */ new Map();
-function isLikelySlug2(value) {
-  return /^[a-z0-9-]+$/.test(value);
-}
-function buildCollectionCacheKey(client, locationId, idOrSlug) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    location_id: locationId || "__none__",
-    collection: idOrSlug
-  });
-}
-function useCollection(idOrSlug, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useCollection must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const locationId = client.getLocationId();
-  const previousLocationIdRef = useRef(locationId);
-  const requestIdRef = useRef(0);
-  const normalizedIdOrSlug = useMemo(() => (idOrSlug || "").trim(), [idOrSlug]);
-  const cacheKey = useMemo(
-    () => buildCollectionCacheKey(client, locationId, normalizedIdOrSlug),
-    [client, locationId, normalizedIdOrSlug]
-  );
-  const cached = collectionCache.get(cacheKey);
-  const [collection, setCollection] = useState(cached?.collection ?? null);
-  const [products, setProducts] = useState(cached?.products ?? []);
-  const [isLoading, setIsLoading] = useState(
-    enabled && normalizedIdOrSlug.length > 0 && !cached
-  );
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      collectionCache.clear();
-      collectionInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled || normalizedIdOrSlug.length === 0) {
-        setCollection(null);
-        setProducts([]);
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cacheEntry = collectionCache.get(cacheKey);
-        if (cacheEntry) {
-          setCollection(cacheEntry.collection);
-          setProducts(cacheEntry.products);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = collectionInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const collectionResult = isLikelySlug2(normalizedIdOrSlug) ? await client.catalogue.getCollectionBySlug(normalizedIdOrSlug) : await client.catalogue.getCollection(normalizedIdOrSlug);
-          if (!collectionResult.ok) {
-            throw collectionResult.error;
-          }
-          const productsResult = await client.catalogue.getCollectionProducts(
-            collectionResult.value.id
-          );
-          if (!productsResult.ok) {
-            throw productsResult.error;
-          }
-          return {
-            collection: collectionResult.value,
-            products: productsResult.value
-          };
-        })();
-        if (!existing) {
-          collectionInflight.set(cacheKey, promise);
-          promise.finally(() => {
-            collectionInflight.delete(cacheKey);
-          }).catch(() => void 0);
-        }
-        const value = await promise;
-        collectionCache.set(cacheKey, value);
-        if (nextRequestId === requestIdRef.current) {
-          setCollection(value.collection);
-          setProducts(value.products);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled, normalizedIdOrSlug]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    collectionCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { collection, products, isLoading, error, refetch };
-}
-function useSearch(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useSearch must be used within CimplifyProvider or passed { client }.");
+    throw new Error("useSearch must be used within CimplifyProvider or passed { client }.");
   }
   const minLength = Math.max(0, options.minLength ?? 2);
   const debounceMs = Math.max(0, options.debounceMs ?? 300);
@@ -2613,11 +2320,11 @@ function useQuote(input, options = {}) {
     const normalized = normalizeInput(input, locationId);
     return normalized.product_id.length > 0 ? normalized : null;
   }, [inputSignature, locationId]);
-  const cacheKey = useMemo(
+  const cacheKey2 = useMemo(
     () => buildQuoteCacheKey(client, locationId, inputSignature),
     [client, inputSignature, locationId]
   );
-  const cached = quoteCache.get(cacheKey);
+  const cached = quoteCache.get(cacheKey2);
   const [quote, setQuote] = useState(cached?.quote ?? null);
   const [isLoading, setIsLoading] = useState(enabled && normalizedInput !== null && !cached);
   const [error, setError] = useState(null);
@@ -2643,7 +2350,7 @@ function useQuote(input, options = {}) {
       const nextRequestId = ++requestIdRef.current;
       setError(null);
       if (!force) {
-        const cacheEntry = quoteCache.get(cacheKey);
+        const cacheEntry = quoteCache.get(cacheKey2);
         if (cacheEntry) {
           setQuote(cacheEntry.quote);
           setMessages(cacheEntry.quote?.ui_messages ?? []);
@@ -2656,7 +2363,7 @@ function useQuote(input, options = {}) {
       setQuote(null);
       setMessages([]);
       try {
-        const existing = quoteInflight.get(cacheKey);
+        const existing = quoteInflight.get(cacheKey2);
         const promise = existing ?? (async () => {
           const result = await client.catalogue.fetchQuote(normalizedInput);
           if (!result.ok) {
@@ -2665,13 +2372,13 @@ function useQuote(input, options = {}) {
           return result.value;
         })();
         if (!existing) {
-          quoteInflight.set(cacheKey, promise);
+          quoteInflight.set(cacheKey2, promise);
           promise.finally(() => {
-            quoteInflight.delete(cacheKey);
+            quoteInflight.delete(cacheKey2);
           }).catch(() => void 0);
         }
         const value = await promise;
-        quoteCache.set(cacheKey, { quote: value });
+        quoteCache.set(cacheKey2, { quote: value });
         if (nextRequestId === requestIdRef.current) {
           setQuote(value);
           setMessages(value.ui_messages ?? []);
@@ -2688,13 +2395,13 @@ function useQuote(input, options = {}) {
         }
       }
     },
-    [cacheKey, client, enabled, normalizedInput]
+    [cacheKey2, client, enabled, normalizedInput]
   );
   useEffect(() => {
     if (debounceTimerRef.current) {
       clearTimeout(debounceTimerRef.current);
     }
-    const hasCached = quoteCache.has(cacheKey);
+    const hasCached = quoteCache.has(cacheKey2);
     if (hasCached || !enabled || !normalizedInput) {
       void load(false);
     } else {
@@ -2708,7 +2415,7 @@ function useQuote(input, options = {}) {
         debounceTimerRef.current = null;
       }
     };
-  }, [load, cacheKey, enabled, normalizedInput]);
+  }, [load, cacheKey2, enabled, normalizedInput]);
   const refresh = useCallback(async () => {
     if (!enabled || !normalizedInput) {
       return;
@@ -2729,7 +2436,7 @@ function useQuote(input, options = {}) {
         throw result.error;
       }
       const refreshed = result.value.quote;
-      quoteCache.set(cacheKey, { quote: refreshed });
+      quoteCache.set(cacheKey2, { quote: refreshed });
       if (nextRequestId === requestIdRef.current) {
         setQuote(refreshed);
         setMessages(refreshed.ui_messages ?? []);
@@ -2745,7 +2452,7 @@ function useQuote(input, options = {}) {
         setIsLoading(false);
       }
     }
-  }, [cacheKey, client, enabled, load, normalizedInput, quote]);
+  }, [cacheKey2, client, enabled, load, normalizedInput, quote]);
   useEffect(() => {
     if (!Number.isFinite(quoteExpiryTimestamp)) {
       setIsExpired(false);
@@ -2777,1402 +2484,391 @@ function useQuote(input, options = {}) {
   }, [autoRefresh, enabled, quoteExpiryTimestamp, refresh, refreshBeforeExpiryMs]);
   return { quote, isLoading, error, refresh, isExpired, messages };
 }
-var taxonomiesCache = /* @__PURE__ */ new Map();
-var taxonomiesInflight = /* @__PURE__ */ new Map();
-function buildTaxonomiesCacheKey(client, parentId) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    parent_id: parentId || "__root__"
-  });
-}
+
+// src/react/hooks/use-taxonomies.ts
+var taxonomiesQuery = createCachedQuery({
+  name: "useTaxonomies",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.parentId ?? "__root__"),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getTaxonomies(options.parentId);
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
 function useTaxonomies(options = {}) {
+  const { data, isLoading, error, refetch } = taxonomiesQuery(options);
+  return { taxonomies: data ?? [], isLoading, error, refetch };
+}
+
+// src/react/hooks/use-taxonomy.ts
+var taxonomyQuery = createCachedQuery({
+  name: "useTaxonomy",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.id),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getTaxonomy(options.id);
+    if (!result.ok) throw result.error;
+    client.activity.trackCategoryView(result.value.id, {
+      categoryName: result.value.name
+    });
+    return result.value;
+  }
+});
+function useTaxonomy(id, options = {}) {
+  const { data, isLoading, error, refetch } = taxonomyQuery({ ...options, id });
+  return { taxonomy: data, isLoading, error, refetch };
+}
+
+// src/react/hooks/use-taxonomy-path.ts
+var taxonomyPathQuery = createCachedQuery({
+  name: "useTaxonomyPath",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.id),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getTaxonomyPath(options.id);
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useTaxonomyPath(id, options = {}) {
+  const { data, isLoading, error, refetch } = taxonomyPathQuery({ ...options, id });
+  return { path: data ?? [], isLoading, error, refetch };
+}
+
+// src/react/hooks/use-product-schedules.ts
+var productSchedulesQuery = createCachedQuery({
+  name: "useProductSchedules",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.productId),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getProductSchedules(options.productId);
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useProductSchedules(productId, options = {}) {
+  const { data, isLoading, error, refetch } = productSchedulesQuery({ ...options, productId });
+  return { schedules: data ?? [], isLoading, error, refetch };
+}
+
+// src/react/hooks/use-product-availability.ts
+var productAvailabilityQuery = createCachedQuery({
+  name: "useProductAvailability",
+  locationSensitive: true,
+  key: (client, options) => {
+    const locationId = options.locationId ?? client.getLocationId();
+    return cacheKey(client.getPublicKey(), options.productId, locationId);
+  },
+  fetch: async (client, options) => {
+    const locationId = options.locationId ?? client.getLocationId();
+    if (!locationId) return null;
+    const result = await client.catalogue.checkProductAvailableNow(options.productId, locationId);
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useProductAvailability(productId, options = {}) {
+  const { data, isLoading, error, refetch } = productAvailabilityQuery({ ...options, productId });
+  return {
+    isAvailable: data?.is_available ?? null,
+    schedulesToday: data?.schedules_today ?? [],
+    isLoading,
+    error,
+    refetch
+  };
+}
+
+// src/react/hooks/use-deals.ts
+function resolveLocationId(client, options) {
+  return options.locationId ?? client.getLocationId() ?? void 0;
+}
+var dealsQuery = createCachedQuery({
+  name: "useDeals",
+  locationSensitive: true,
+  key: (client, options) => cacheKey(client.getPublicKey(), resolveLocationId(client, options)),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getDeals(resolveLocationId(client, options));
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useDeals(options = {}) {
+  const { data, isLoading, error, refetch } = dealsQuery(options);
+  return { deals: data ?? [], isLoading, error, refetch };
+}
+
+// src/react/hooks/use-products-on-sale.ts
+var productsOnSaleQuery = createCachedQuery({
+  name: "useProductsOnSale",
+  key: (client) => client.getPublicKey() || "__demo__",
+  fetch: async (client) => {
+    const result = await client.catalogue.getProductsOnSale();
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useProductsOnSale(options = {}) {
+  const { data, isLoading, error, refetch } = productsOnSaleQuery(options);
+  return { products: data ?? [], isLoading, error, refetch };
+}
+
+// src/react/hooks/use-product-deals.ts
+var productDealsQuery = createCachedQuery({
+  name: "useProductDeals",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.productId),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getProductDeals(options.productId);
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useProductDeals(productId, options = {}) {
+  const { data, isLoading, error, refetch } = productDealsQuery({ ...options, productId });
+  return { deals: data ?? [], isLoading, error, refetch };
+}
+function useValidateDiscount(options = {}) {
   const context = useOptionalCimplifyClient();
   const client = options.client ?? context?.client;
   if (!client) {
-    throw new Error("useTaxonomies must be used within CimplifyProvider or passed { client }.");
+    throw new Error("useValidateDiscount must be used within CimplifyProvider or passed { client }.");
   }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(
-    () => buildTaxonomiesCacheKey(client, options.parentId),
-    [client, options.parentId]
-  );
-  const cached = taxonomiesCache.get(cacheKey);
-  const [taxonomies, setTaxonomies] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
+  const [isValidating, setIsValidating] = useState(false);
   const [error, setError] = useState(null);
-  const parentId = options.parentId;
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
+  const validate = useCallback(
+    async (code, orderSubtotal, locationId) => {
       setError(null);
-      if (!force) {
-        const cachedTaxonomies = taxonomiesCache.get(cacheKey);
-        if (cachedTaxonomies) {
-          setTaxonomies(cachedTaxonomies);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
+      setIsValidating(true);
       try {
-        const existing = taxonomiesInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getTaxonomies(parentId);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          taxonomiesInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              taxonomiesInflight.delete(cacheKey);
-            })
-          );
+        const result = await client.catalogue.validateDiscountCode(code, orderSubtotal, locationId);
+        if (!result.ok) {
+          setError(result.error);
+          return null;
         }
-        const value = await promise;
-        taxonomiesCache.set(cacheKey, value);
-        setTaxonomies(value);
-      } catch (loadError) {
-        setError(loadError);
+        return result.value;
+      } catch (validateError) {
+        setError(validateError);
+        return null;
       } finally {
-        setIsLoading(false);
+        setIsValidating(false);
       }
     },
-    [cacheKey, client, enabled, parentId]
+    [client]
   );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    taxonomiesCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { taxonomies, isLoading, error, refetch };
-}
-var taxonomyCache = /* @__PURE__ */ new Map();
-var taxonomyInflight = /* @__PURE__ */ new Map();
-function buildTaxonomyCacheKey(client, id) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    id
-  });
+  return { validate, isValidating, error };
 }
-function useTaxonomy(id, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useTaxonomy must be used within CimplifyProvider or passed { client }.");
+
+// src/react/hooks/use-bundles.ts
+var bundlesQuery = createCachedQuery({
+  name: "useBundles",
+  locationSensitive: true,
+  key: (client) => cacheKey(client.getPublicKey(), client.getLocationId()),
+  fetch: async (client) => {
+    const result = await client.catalogue.getBundles();
+    if (!result.ok) throw result.error;
+    return result.value;
   }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(() => buildTaxonomyCacheKey(client, id), [client, id]);
-  const cached = taxonomyCache.get(cacheKey);
-  const [taxonomy, setTaxonomy] = useState(cached ?? null);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const trackedTaxonomyRef = useRef(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedTaxonomy = taxonomyCache.get(cacheKey);
-        if (cachedTaxonomy) {
-          setTaxonomy(cachedTaxonomy);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = taxonomyInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getTaxonomy(id);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          taxonomyInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              taxonomyInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        taxonomyCache.set(cacheKey, value);
-        setTaxonomy(value);
-        if (value && trackedTaxonomyRef.current !== value.id) {
-          trackedTaxonomyRef.current = value.id;
-          client.activity.trackCategoryView(value.id, {
-            categoryName: value.name
-          });
-        }
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, id]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    taxonomyCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { taxonomy, isLoading, error, refetch };
-}
-var taxonomyPathCache = /* @__PURE__ */ new Map();
-var taxonomyPathInflight = /* @__PURE__ */ new Map();
-function buildTaxonomyPathCacheKey(client, id) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    id
-  });
-}
-function useTaxonomyPath(id, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useTaxonomyPath must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(() => buildTaxonomyPathCacheKey(client, id), [client, id]);
-  const cached = taxonomyPathCache.get(cacheKey);
-  const [path, setPath] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedPath = taxonomyPathCache.get(cacheKey);
-        if (cachedPath) {
-          setPath(cachedPath);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = taxonomyPathInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getTaxonomyPath(id);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          taxonomyPathInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              taxonomyPathInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        taxonomyPathCache.set(cacheKey, value);
-        setPath(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, id]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    taxonomyPathCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { path, isLoading, error, refetch };
-}
-var schedulesCache = /* @__PURE__ */ new Map();
-var schedulesInflight = /* @__PURE__ */ new Map();
-function buildSchedulesCacheKey(client, productId) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    product_id: productId
-  });
-}
-function useProductSchedules(productId, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useProductSchedules must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(() => buildSchedulesCacheKey(client, productId), [client, productId]);
-  const cached = schedulesCache.get(cacheKey);
-  const [schedules, setSchedules] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedSchedules = schedulesCache.get(cacheKey);
-        if (cachedSchedules) {
-          setSchedules(cachedSchedules);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = schedulesInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getProductSchedules(productId);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          schedulesInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              schedulesInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        schedulesCache.set(cacheKey, value);
-        setSchedules(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, productId]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    schedulesCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { schedules, isLoading, error, refetch };
-}
-var availabilityCache = /* @__PURE__ */ new Map();
-var availabilityInflight = /* @__PURE__ */ new Map();
-function buildAvailabilityCacheKey(client, productId, locationId) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    product_id: productId,
-    location_id: locationId
-  });
-}
-function useProductAvailability(productId, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useProductAvailability must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const locationId = options.locationId ?? client.getLocationId();
-  const previousLocationIdRef = useRef(locationId);
-  const cacheKey = useMemo(
-    () => locationId ? buildAvailabilityCacheKey(client, productId, locationId) : null,
-    [client, productId, locationId]
-  );
-  const cached = cacheKey ? availabilityCache.get(cacheKey) : void 0;
-  const [isAvailable, setIsAvailable] = useState(cached?.is_available ?? null);
-  const [schedulesToday, setSchedulesToday] = useState(
-    cached?.schedules_today ?? []
-  );
-  const [isLoading, setIsLoading] = useState(enabled && !cached && !!locationId);
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      availabilityCache.clear();
-      availabilityInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled || !locationId || !cacheKey) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedAvailability = availabilityCache.get(cacheKey);
-        if (cachedAvailability) {
-          setIsAvailable(cachedAvailability.is_available);
-          setSchedulesToday(cachedAvailability.schedules_today);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = availabilityInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.checkProductAvailableNow(productId, locationId);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          availabilityInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              availabilityInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        availabilityCache.set(cacheKey, value);
-        setIsAvailable(value.is_available);
-        setSchedulesToday(value.schedules_today);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, locationId, productId]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    if (cacheKey) {
-      availabilityCache.delete(cacheKey);
-    }
-    await load(true);
-  }, [cacheKey, load]);
-  return { isAvailable, schedulesToday, isLoading, error, refetch };
-}
-var dealsCache = /* @__PURE__ */ new Map();
-var dealsInflight = /* @__PURE__ */ new Map();
-function buildDealsCacheKey(client, locationId) {
-  return JSON.stringify({ key: client.getPublicKey(), location_id: locationId });
-}
-function useDeals(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useDeals must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const locationId = options.locationId ?? client.getLocationId() ?? void 0;
-  const previousLocationIdRef = useRef(locationId);
-  const cacheKey = useMemo(() => buildDealsCacheKey(client, locationId), [client, locationId]);
-  const cached = dealsCache.get(cacheKey);
-  const [deals, setDeals] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      dealsCache.clear();
-      dealsInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedDeals = dealsCache.get(cacheKey);
-        if (cachedDeals) {
-          setDeals(cachedDeals);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = dealsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getDeals(locationId);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          dealsInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              dealsInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        dealsCache.set(cacheKey, value);
-        setDeals(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, locationId]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    dealsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { deals, isLoading, error, refetch };
-}
-var onSaleCache = /* @__PURE__ */ new Map();
-var onSaleInflight = /* @__PURE__ */ new Map();
-function buildOnSaleCacheKey(client) {
-  return client.getPublicKey() || "__demo__";
-}
-function useProductsOnSale(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useProductsOnSale must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(() => buildOnSaleCacheKey(client), [client]);
-  const cached = onSaleCache.get(cacheKey);
-  const [products, setProducts] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedProducts = onSaleCache.get(cacheKey);
-        if (cachedProducts) {
-          setProducts(cachedProducts);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = onSaleInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getProductsOnSale();
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          onSaleInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              onSaleInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        onSaleCache.set(cacheKey, value);
-        setProducts(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    onSaleCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { products, isLoading, error, refetch };
-}
-var productDealsCache = /* @__PURE__ */ new Map();
-var productDealsInflight = /* @__PURE__ */ new Map();
-function buildProductDealsCacheKey(client, productId) {
-  return JSON.stringify({ key: client.getPublicKey(), product_id: productId });
-}
-function useProductDeals(productId, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useProductDeals must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(
-    () => buildProductDealsCacheKey(client, productId),
-    [client, productId]
-  );
-  const cached = productDealsCache.get(cacheKey);
-  const [deals, setDeals] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedDeals = productDealsCache.get(cacheKey);
-        if (cachedDeals) {
-          setDeals(cachedDeals);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = productDealsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getProductDeals(productId);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          productDealsInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              productDealsInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        productDealsCache.set(cacheKey, value);
-        setDeals(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, productId]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    productDealsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { deals, isLoading, error, refetch };
-}
-function useValidateDiscount(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useValidateDiscount must be used within CimplifyProvider or passed { client }.");
-  }
-  const [isValidating, setIsValidating] = useState(false);
-  const [error, setError] = useState(null);
-  const validate = useCallback(
-    async (code, orderSubtotal, locationId) => {
-      setError(null);
-      setIsValidating(true);
-      try {
-        const result = await client.catalogue.validateDiscountCode(code, orderSubtotal, locationId);
-        if (!result.ok) {
-          setError(result.error);
-          return null;
-        }
-        return result.value;
-      } catch (validateError) {
-        setError(validateError);
-        return null;
-      } finally {
-        setIsValidating(false);
-      }
-    },
-    [client]
-  );
-  return { validate, isValidating, error };
-}
-var bundlesCache = /* @__PURE__ */ new Map();
-var bundlesInflight = /* @__PURE__ */ new Map();
-function buildBundlesCacheKey(client, locationId) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    location_id: locationId || "__none__"
-  });
-}
-function useBundles(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useBundles must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const locationId = client.getLocationId();
-  const previousLocationIdRef = useRef(locationId);
-  const requestIdRef = useRef(0);
-  const cacheKey = useMemo(
-    () => buildBundlesCacheKey(client, locationId),
-    [client, locationId]
-  );
-  const cached = bundlesCache.get(cacheKey);
-  const [bundles, setBundles] = useState(cached?.bundles ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      bundlesCache.clear();
-      bundlesInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cacheEntry = bundlesCache.get(cacheKey);
-        if (cacheEntry) {
-          setBundles(cacheEntry.bundles);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = bundlesInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getBundles();
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          bundlesInflight.set(cacheKey, promise);
-          promise.finally(() => {
-            bundlesInflight.delete(cacheKey);
-          }).catch(() => void 0);
-        }
-        const value = await promise;
-        bundlesCache.set(cacheKey, { bundles: value });
-        if (nextRequestId === requestIdRef.current) {
-          setBundles(value);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    bundlesCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { bundles, isLoading, error, refetch };
-}
-function useProductPrice(input) {
-  const {
-    product,
-    quantity = 1,
-    variant,
-    addOnOptions,
-    compositePrice,
-    bundleTotalPrice
-  } = input;
-  return useMemo(() => {
-    let unitPrice;
-    if (bundleTotalPrice != null) {
-      unitPrice = bundleTotalPrice;
-    } else if (compositePrice) {
-      unitPrice = parsePrice(compositePrice.final_price);
-    } else {
-      unitPrice = parsePrice(product.default_price);
-      if (variant?.price_adjustment) {
-        unitPrice += parsePrice(variant.price_adjustment);
-      }
-      if (addOnOptions) {
-        for (const option of addOnOptions) {
-          if (option.default_price) {
-            unitPrice += parsePrice(option.default_price);
-          }
-        }
-      }
-    }
-    unitPrice = Math.round(unitPrice * 100) / 100;
-    const totalPrice = Math.round(unitPrice * quantity * 100) / 100;
-    return {
-      unitPrice,
-      totalPrice,
-      displayTotalPrice: totalPrice
-    };
-  }, [product.default_price, quantity, variant?.price_adjustment, addOnOptions, compositePrice, bundleTotalPrice]);
-}
-var ordersCache = /* @__PURE__ */ new Map();
-var ordersInflight = /* @__PURE__ */ new Map();
-function buildOrdersCacheKey(client, status, limit) {
-  return JSON.stringify({ key: client.getPublicKey(), status, limit });
-}
-function useOrders(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useOrders must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const requestIdRef = useRef(0);
-  const cacheKey = useMemo(
-    () => buildOrdersCacheKey(client, options.status, options.limit),
-    [client, options.status, options.limit]
-  );
-  const cached = ordersCache.get(cacheKey);
-  const [orders, setOrders] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cachedOrders = ordersCache.get(cacheKey);
-        if (cachedOrders) {
-          setOrders(cachedOrders);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = ordersInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.orders.list({
-            status: options.status,
-            limit: options.limit
-          });
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          ordersInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              ordersInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        ordersCache.set(cacheKey, value);
-        if (nextRequestId === requestIdRef.current) {
-          setOrders(value);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled, options.status, options.limit]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    ordersCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { orders, isLoading, error, refetch };
-}
-var servicesCache = /* @__PURE__ */ new Map();
-var servicesInflight = /* @__PURE__ */ new Map();
-function buildServicesCacheKey(client) {
-  return JSON.stringify({ key: client.getPublicKey() });
-}
-function useServices(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useServices must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const requestIdRef = useRef(0);
-  const cacheKey = useMemo(() => buildServicesCacheKey(client), [client]);
-  const cached = servicesCache.get(cacheKey);
-  const [services, setServices] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cachedServices = servicesCache.get(cacheKey);
-        if (cachedServices) {
-          setServices(cachedServices);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = servicesInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.scheduling.getServices();
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          servicesInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              servicesInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        servicesCache.set(cacheKey, value);
-        if (nextRequestId === requestIdRef.current) {
-          setServices(value);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    servicesCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { services, isLoading, error, refetch };
-}
-var slotsCache = /* @__PURE__ */ new Map();
-var slotsInflight = /* @__PURE__ */ new Map();
-function buildSlotsCacheKey(client, serviceId, date, participantCount) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    serviceId,
-    date,
-    participantCount
-  });
-}
-function useAvailableSlots(serviceId, date, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useAvailableSlots must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = (options.enabled ?? true) && !!serviceId && !!date;
-  const requestIdRef = useRef(0);
-  const cacheKey = useMemo(
-    () => serviceId && date ? buildSlotsCacheKey(client, serviceId, date, options.participantCount) : null,
-    [client, serviceId, date, options.participantCount]
-  );
-  const cached = cacheKey ? slotsCache.get(cacheKey) : void 0;
-  const [slots, setSlots] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled || !cacheKey || !serviceId || !date) {
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cachedSlots = slotsCache.get(cacheKey);
-        if (cachedSlots) {
-          setSlots(cachedSlots);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = slotsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.scheduling.getAvailableSlots({
-            service_id: serviceId,
-            date,
-            participant_count: options.participantCount
-          });
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          slotsInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              slotsInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        slotsCache.set(cacheKey, value);
-        if (nextRequestId === requestIdRef.current) {
-          setSlots(value);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled, serviceId, date, options.participantCount]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    if (cacheKey) {
-      slotsCache.delete(cacheKey);
-    }
-    await load(true);
-  }, [cacheKey, load]);
-  return { slots, isLoading, error, refetch };
-}
-var availabilityCache2 = /* @__PURE__ */ new Map();
-var availabilityInflight2 = /* @__PURE__ */ new Map();
-function buildAvailabilityCacheKey2(client, serviceId, startDate, endDate, participantCount) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    serviceId,
-    startDate,
-    endDate,
-    participantCount
-  });
-}
-function useServiceAvailability(serviceId, startDate, endDate, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error(
-      "useServiceAvailability must be used within CimplifyProvider or passed { client }."
-    );
-  }
-  const enabled = (options.enabled ?? true) && !!serviceId && !!startDate && !!endDate;
-  const requestIdRef = useRef(0);
-  const cacheKey = useMemo(
-    () => serviceId && startDate && endDate ? buildAvailabilityCacheKey2(
-      client,
-      serviceId,
-      startDate,
-      endDate,
-      options.participantCount
-    ) : null,
-    [client, serviceId, startDate, endDate, options.participantCount]
-  );
-  const cached = cacheKey ? availabilityCache2.get(cacheKey) : void 0;
-  const [days, setDays] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled || !cacheKey || !serviceId || !startDate || !endDate) {
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cachedDays = availabilityCache2.get(cacheKey);
-        if (cachedDays) {
-          setDays(cachedDays);
-          setIsLoading(false);
-          return;
-        }
+});
+function useBundles(options = {}) {
+  const { data, isLoading, error, refetch } = bundlesQuery(options);
+  return { bundles: data ?? [], isLoading, error, refetch };
+}
+function useProductPrice(input) {
+  const {
+    product,
+    quantity = 1,
+    variant,
+    addOnOptions,
+    compositePrice,
+    bundleTotalPrice
+  } = input;
+  return useMemo(() => {
+    let unitPrice;
+    if (bundleTotalPrice != null) {
+      unitPrice = bundleTotalPrice;
+    } else if (compositePrice) {
+      unitPrice = parsePrice(compositePrice.final_price);
+    } else {
+      unitPrice = parsePrice(product.default_price);
+      if (variant?.price_adjustment) {
+        unitPrice += parsePrice(variant.price_adjustment);
       }
-      setIsLoading(true);
-      try {
-        const existing = availabilityInflight2.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.scheduling.getServiceAvailability({
-            service_id: serviceId,
-            start_date: startDate,
-            end_date: endDate,
-            location_id: options.locationId,
-            participant_count: options.participantCount
-          });
-          if (!result.ok) {
-            throw result.error;
+      if (addOnOptions) {
+        for (const option of addOnOptions) {
+          if (option.default_price) {
+            unitPrice += parsePrice(option.default_price);
           }
-          return result.value.availability;
-        })();
-        if (!existing) {
-          availabilityInflight2.set(
-            cacheKey,
-            promise.finally(() => {
-              availabilityInflight2.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        availabilityCache2.set(cacheKey, value);
-        if (nextRequestId === requestIdRef.current) {
-          setDays(value);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
         }
       }
-    },
-    [cacheKey, client, enabled, serviceId, startDate, endDate, options.locationId, options.participantCount]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    if (cacheKey) {
-      availabilityCache2.delete(cacheKey);
     }
-    await load(true);
-  }, [cacheKey, load]);
-  return { days, isLoading, error, refetch };
+    unitPrice = Math.round(unitPrice * 100) / 100;
+    const totalPrice = Math.round(unitPrice * quantity * 100) / 100;
+    return {
+      unitPrice,
+      totalPrice,
+      displayTotalPrice: totalPrice
+    };
+  }, [product.default_price, quantity, variant?.price_adjustment, addOnOptions, compositePrice, bundleTotalPrice]);
+}
+
+// src/react/hooks/use-orders.ts
+var ordersQuery = createCachedQuery({
+  name: "useOrders",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.status, options.limit),
+  fetch: async (client, options) => {
+    const result = await client.orders.list({
+      status: options.status,
+      limit: options.limit
+    });
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useOrders(options = {}) {
+  const { data, isLoading, error, refetch } = ordersQuery(options);
+  return { orders: data ?? [], isLoading, error, refetch };
+}
+
+// src/react/hooks/use-services.ts
+var servicesQuery = createCachedQuery({
+  name: "useServices",
+  key: (client) => cacheKey(client.getPublicKey()),
+  fetch: async (client) => {
+    const result = await client.scheduling.getServices();
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useServices(options = {}) {
+  const { data, isLoading, error, refetch } = servicesQuery(options);
+  return { services: data ?? [], isLoading, error, refetch };
 }
-var bookingsCache = /* @__PURE__ */ new Map();
-var bookingsInflight = /* @__PURE__ */ new Map();
-function buildBookingsCacheKey(client, filter) {
-  return JSON.stringify({ key: client.getPublicKey(), filter });
+
+// src/react/hooks/use-available-slots.ts
+var slotsQuery = createCachedQuery({
+  name: "useAvailableSlots",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.serviceId, options.date, options.participantCount),
+  fetch: async (client, options) => {
+    const result = await client.scheduling.getAvailableSlots({
+      service_id: options.serviceId,
+      date: options.date,
+      participant_count: options.participantCount
+    });
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
+function useAvailableSlots(serviceId, date, options = {}) {
+  const { data, isLoading, error, refetch } = slotsQuery({
+    ...options,
+    serviceId: serviceId || "",
+    date: date || "",
+    enabled: (options.enabled ?? true) && !!serviceId && !!date
+  });
+  return { slots: data ?? [], isLoading, error, refetch };
 }
+
+// src/react/hooks/use-service-availability.ts
+var serviceAvailabilityQuery = createCachedQuery({
+  name: "useServiceAvailability",
+  key: (client, options) => cacheKey(
+    client.getPublicKey(),
+    options.serviceId,
+    options.startDate,
+    options.endDate,
+    options.participantCount
+  ),
+  fetch: async (client, options) => {
+    const result = await client.scheduling.getServiceAvailability({
+      service_id: options.serviceId,
+      start_date: options.startDate,
+      end_date: options.endDate,
+      location_id: options.locationId,
+      participant_count: options.participantCount
+    });
+    if (!result.ok) throw result.error;
+    return result.value.availability;
+  }
+});
+function useServiceAvailability(serviceId, startDate, endDate, options = {}) {
+  const { data, isLoading, error, refetch } = serviceAvailabilityQuery({
+    ...options,
+    serviceId: serviceId || "",
+    startDate: startDate || "",
+    endDate: endDate || "",
+    enabled: (options.enabled ?? true) && !!serviceId && !!startDate && !!endDate
+  });
+  return { days: data ?? [], isLoading, error, refetch };
+}
+var bookingsQuery = createCachedQuery({
+  name: "useBookings",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.filter ?? "all"),
+  fetch: async (client, options) => {
+    const filter = options.filter ?? "all";
+    let result;
+    switch (filter) {
+      case "upcoming":
+        result = await client.scheduling.getUpcomingBookings();
+        break;
+      case "past":
+        result = await client.scheduling.getPastBookings();
+        break;
+      default:
+        result = await client.scheduling.getCustomerBookings();
+        break;
+    }
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
 function useBookings(options = {}) {
   const context = useOptionalCimplifyClient();
   const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useBookings must be used within CimplifyProvider or passed { client }.");
-  }
-  const filter = options.filter ?? "all";
-  const enabled = options.enabled ?? true;
-  const requestIdRef = useRef(0);
-  const cacheKey = useMemo(
-    () => buildBookingsCacheKey(client, filter),
-    [client, filter]
-  );
-  const cached = bookingsCache.get(cacheKey);
-  const [bookings, setBookings] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      if (!force) {
-        const cachedBookings = bookingsCache.get(cacheKey);
-        if (cachedBookings) {
-          setBookings(cachedBookings);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = bookingsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          let result;
-          switch (filter) {
-            case "upcoming":
-              result = await client.scheduling.getUpcomingBookings();
-              break;
-            case "past":
-              result = await client.scheduling.getPastBookings();
-              break;
-            default:
-              result = await client.scheduling.getCustomerBookings();
-              break;
-          }
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          bookingsInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              bookingsInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        bookingsCache.set(cacheKey, value);
-        if (nextRequestId === requestIdRef.current) {
-          setBookings(value);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, enabled, filter]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    bookingsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
+  const { data, isLoading, error, refetch } = bookingsQuery(options);
   const cancelBooking = useCallback(
     async (bookingId, reason) => {
+      if (!client) throw new Error("useBookings must be used within CimplifyProvider or passed { client }.");
       const result = await client.scheduling.cancelBooking({
         booking_id: bookingId,
         reason
       });
-      if (!result.ok) {
-        throw result.error;
-      }
-      for (const key of bookingsCache.keys()) {
-        bookingsCache.delete(key);
-      }
-      await load(true);
+      if (!result.ok) throw result.error;
+      bookingsQuery.clear();
+      await refetch();
       return result.value;
     },
-    [client, load]
+    [client, refetch]
   );
-  return { bookings, isLoading, error, refetch, cancelBooking };
+  return { bookings: data ?? [], isLoading, error, refetch, cancelBooking };
 }
-var definitionsCache = /* @__PURE__ */ new Map();
-var definitionsInflight = /* @__PURE__ */ new Map();
-function buildCacheKey(client, namespace) {
-  return `attr_defs_${client.getPublicKey() || "__demo__"}${namespace ? `_${namespace}` : ""}`;
-}
-function useAttributeDefinitions(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error(
-      "useAttributeDefinitions must be used within CimplifyProvider or passed { client }."
-    );
+
+// src/react/hooks/use-attribute-definitions.ts
+var attributeDefinitionsQuery = createCachedQuery({
+  name: "useAttributeDefinitions",
+  key: (client, options) => cacheKey(client.getPublicKey() || "__demo__", options.namespace),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getAttributeDefinitions(options.namespace);
+    if (!result.ok) throw result.error;
+    return result.value;
   }
-  const enabled = options.enabled ?? true;
-  const namespace = options.namespace;
-  const cacheKey = useMemo(() => buildCacheKey(client, namespace), [client, namespace]);
-  const cached = definitionsCache.get(cacheKey);
-  const [definitions, setDefinitions] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedDefs = definitionsCache.get(cacheKey);
-        if (cachedDefs) {
-          setDefinitions(cachedDefs);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = definitionsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getAttributeDefinitions(namespace);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          definitionsInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              definitionsInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        definitionsCache.set(cacheKey, value);
-        setDefinitions(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    definitionsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { definitions, isLoading, error, refetch };
+});
+function useAttributeDefinitions(options = {}) {
+  const { data, isLoading, error, refetch } = attributeDefinitionsQuery(options);
+  return { definitions: data ?? [], isLoading, error, refetch };
 }
-var facetsCache = /* @__PURE__ */ new Map();
-var facetsInflight = /* @__PURE__ */ new Map();
-function usePropertyFacets(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error(
-      "usePropertyFacets must be used within CimplifyProvider or passed { client }."
-    );
+
+// src/react/hooks/use-property-facets.ts
+var propertyFacetsQuery = createCachedQuery({
+  name: "usePropertyFacets",
+  key: (client, options) => cacheKey(client.getPublicKey() || "__demo__", options.category_id, options.product_type),
+  fetch: async (client, options) => {
+    const result = await client.catalogue.getPropertyFacets({
+      category_id: options.category_id,
+      product_type: options.product_type
+    });
+    if (!result.ok) throw result.error;
+    return result.value;
   }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(
-    () => `facets_${client.getPublicKey() || "__demo__"}_${options.category_id ?? ""}_${options.product_type ?? ""}`,
-    [client, options.category_id, options.product_type]
-  );
-  const cached = facetsCache.get(cacheKey);
-  const [facets, setFacets] = useState(cached ?? []);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedFacets = facetsCache.get(cacheKey);
-        if (cachedFacets) {
-          setFacets(cachedFacets);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = facetsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.catalogue.getPropertyFacets({
-            category_id: options.category_id,
-            product_type: options.product_type
-          });
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          facetsInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              facetsInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        facetsCache.set(cacheKey, value);
-        setFacets(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, options.category_id, options.product_type]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    facetsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { facets, isLoading, error, refetch };
+});
+function usePropertyFacets(options = {}) {
+  const { data, isLoading, error, refetch } = propertyFacetsQuery(options);
+  return { facets: data ?? [], isLoading, error, refetch };
 }
 function useBillingPlans(productId, options = {}) {
   const context = useOptionalCimplifyClient();
@@ -4304,417 +3000,112 @@ function useVariantSelector(options) {
     reset
   };
 }
-var activityStateCache = /* @__PURE__ */ new Map();
-var activityStateInflight = /* @__PURE__ */ new Map();
-function buildActivityStateCacheKey(client) {
-  return JSON.stringify({ key: client.getPublicKey(), type: "activity_state" });
-}
+var activityStateQuery = createCachedQuery({
+  name: "useActivityState",
+  key: (client) => cacheKey(client.getPublicKey()),
+  fetch: async (client) => {
+    const result = await client.activity.getState();
+    if (!result.ok) throw result.error;
+    return result.value;
+  }
+});
 function useActivityState(options = {}) {
   const context = useOptionalCimplifyClient();
   const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useActivityState must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(() => buildActivityStateCacheKey(client), [client]);
-  const cached = activityStateCache.get(cacheKey);
-  const [state, setState] = useState(cached ?? null);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedState = activityStateCache.get(cacheKey);
-        if (cachedState) {
-          setState(cachedState);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = activityStateInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.activity.getState();
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          activityStateInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              activityStateInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        activityStateCache.set(cacheKey, value);
-        setState(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    activityStateCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
+  const { data, isLoading, error, refetch } = activityStateQuery(options);
   const dismissMessage = useCallback(
     async (code) => {
+      if (!client) return;
       const result = await client.activity.dismissMessage(code);
-      if (!result.ok) {
-        setError(result.error);
-        return;
-      }
-      setState((prev) => {
-        if (!prev) return prev;
-        return { ...prev, messages: result.value.messages };
-      });
-      activityStateCache.delete(cacheKey);
-      await load(true);
+      if (!result.ok) return;
+      activityStateQuery.clear();
+      await refetch();
     },
-    [cacheKey, client, load]
+    [client, refetch]
   );
-  const messages = state?.messages ?? [];
-  const intent = state?.intent ?? "";
-  return { state, messages, intent, isLoading, error, refetch, dismissMessage };
-}
-var recommendationsCache = /* @__PURE__ */ new Map();
-var recommendationsInflight = /* @__PURE__ */ new Map();
-function buildRecommendationsCacheKey(client, locationId, limit) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    type: "recommendations",
-    location_id: locationId,
-    limit
-  });
+  return {
+    state: data,
+    messages: data?.messages ?? [],
+    intent: data?.intent ?? "",
+    isLoading,
+    error,
+    refetch,
+    dismissMessage
+  };
 }
-function useRecommendations(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error(
-      "useRecommendations must be used within CimplifyProvider or passed { client }."
-    );
+
+// src/react/hooks/use-recommendations.ts
+var recommendationsQuery = createCachedQuery({
+  name: "useRecommendations",
+  locationSensitive: true,
+  key: (client, options) => {
+    const locationId = options.locationId ?? client.getLocationId();
+    return cacheKey(client.getPublicKey(), locationId, options.limit);
+  },
+  fetch: async (client, options) => {
+    const locationId = options.locationId ?? client.getLocationId() ?? void 0;
+    const result = await client.activity.getRecommendations({
+      location_id: locationId,
+      limit: options.limit
+    });
+    if (!result.ok) throw result.error;
+    return result.value;
   }
-  const enabled = options.enabled ?? true;
-  const locationId = options.locationId ?? client.getLocationId() ?? void 0;
-  const limit = options.limit;
-  const previousLocationIdRef = useRef(locationId);
-  const cacheKey = useMemo(
-    () => buildRecommendationsCacheKey(client, locationId, limit),
-    [client, locationId, limit]
-  );
-  const cached = recommendationsCache.get(cacheKey);
-  const [response, setResponse] = useState(cached ?? null);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      recommendationsCache.clear();
-      recommendationsInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedResponse = recommendationsCache.get(cacheKey);
-        if (cachedResponse) {
-          setResponse(cachedResponse);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = recommendationsInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.activity.getRecommendations({
-            location_id: locationId,
-            limit
-          });
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          recommendationsInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              recommendationsInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        recommendationsCache.set(cacheKey, value);
-        setResponse(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, locationId, limit]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    recommendationsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  const recommendations = response?.recommendations ?? [];
-  const intent = response?.intent ?? "";
-  return { recommendations, intent, isLoading, error, refetch };
-}
-var deliveryFeeCache = /* @__PURE__ */ new Map();
-var deliveryFeeInflight = /* @__PURE__ */ new Map();
-function buildDeliveryFeeCacheKey(client, latitude, longitude, country) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    lat: latitude,
-    lng: longitude,
-    country
-  });
+});
+function useRecommendations(options = {}) {
+  const { data, isLoading, error, refetch } = recommendationsQuery(options);
+  return {
+    recommendations: data?.recommendations ?? [],
+    intent: data?.intent ?? "",
+    isLoading,
+    error,
+    refetch
+  };
 }
-function useDeliveryFee(options) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useDeliveryFee must be used within CimplifyProvider or passed { client }.");
+
+// src/react/hooks/use-delivery-fee.ts
+var deliveryFeeQuery = createCachedQuery({
+  name: "useDeliveryFee",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.latitude, options.longitude, options.country),
+  fetch: async (client, options) => {
+    const result = await client.delivery.getFee(options.latitude, options.longitude, options.country);
+    if (!result.ok) throw result.error;
+    return result.value;
   }
-  const enabled = options.enabled ?? true;
-  const { latitude, longitude, country } = options;
-  const cacheKey = useMemo(
-    () => buildDeliveryFeeCacheKey(client, latitude, longitude, country),
-    [client, latitude, longitude, country]
-  );
-  const cached = deliveryFeeCache.get(cacheKey);
-  const [fee, setFee] = useState(cached ?? null);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const requestIdRef = useRef(0);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedFee = deliveryFeeCache.get(cacheKey);
-        if (cachedFee) {
-          setFee(cachedFee);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      const currentRequestId = ++requestIdRef.current;
-      try {
-        const existing = deliveryFeeInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.delivery.getFee(latitude, longitude, country);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          deliveryFeeInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              deliveryFeeInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        if (currentRequestId !== requestIdRef.current) return;
-        deliveryFeeCache.set(cacheKey, value);
-        setFee(value);
-      } catch (loadError) {
-        if (currentRequestId !== requestIdRef.current) return;
-        setError(loadError);
-      } finally {
-        if (currentRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, country, enabled, latitude, longitude]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    deliveryFeeCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { fee, isLoading, error, refetch };
-}
-var fxRateCache = /* @__PURE__ */ new Map();
-var fxRateInflight = /* @__PURE__ */ new Map();
-function buildFxRateCacheKey(client, from, to) {
-  return JSON.stringify({ key: client.getPublicKey(), from, to });
+});
+function useDeliveryFee(options) {
+  const { data, isLoading, error, refetch } = deliveryFeeQuery(options);
+  return { fee: data, isLoading, error, refetch };
 }
-function useFxRate(options) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useFxRate must be used within CimplifyProvider or passed { client }.");
+
+// src/react/hooks/use-fx-rate.ts
+var fxRateQuery = createCachedQuery({
+  name: "useFxRate",
+  key: (client, options) => cacheKey(client.getPublicKey(), options.from, options.to),
+  fetch: async (client, options) => {
+    const result = await client.fx.getRate(options.from, options.to);
+    if (!result.ok) throw result.error;
+    return result.value;
   }
-  const enabled = options.enabled ?? true;
-  const { from, to } = options;
-  const cacheKey = useMemo(
-    () => buildFxRateCacheKey(client, from, to),
-    [client, from, to]
-  );
-  const cached = fxRateCache.get(cacheKey);
-  const [rate, setRate] = useState(cached ?? null);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedRate = fxRateCache.get(cacheKey);
-        if (cachedRate) {
-          setRate(cachedRate);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = fxRateInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.fx.getRate(from, to);
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          fxRateInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              fxRateInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        fxRateCache.set(cacheKey, value);
-        setRate(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled, from, to]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    fxRateCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { rate, isLoading, error, refetch };
-}
-var bootstrapCache = /* @__PURE__ */ new Map();
-var bootstrapInflight = /* @__PURE__ */ new Map();
-function buildBootstrapCacheKey(client) {
-  return JSON.stringify({ key: client.getPublicKey(), type: "bootstrap" });
+});
+function useFxRate(options) {
+  const { data, isLoading, error, refetch } = fxRateQuery(options);
+  return { rate: data, isLoading, error, refetch };
 }
-function useBootstrap(options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useBootstrap must be used within CimplifyProvider or passed { client }.");
+
+// src/react/hooks/use-bootstrap.ts
+var bootstrapQuery = createCachedQuery({
+  name: "useBootstrap",
+  key: (client) => cacheKey(client.getPublicKey()),
+  fetch: async (client) => {
+    const result = await client.business.getBootstrap();
+    if (!result.ok) throw result.error;
+    return result.value;
   }
-  const enabled = options.enabled ?? true;
-  const cacheKey = useMemo(() => buildBootstrapCacheKey(client), [client]);
-  const cached = bootstrapCache.get(cacheKey);
-  const [bootstrap, setBootstrap] = useState(cached ?? null);
-  const [isLoading, setIsLoading] = useState(enabled && !cached);
-  const [error, setError] = useState(null);
-  const load = useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
-      setError(null);
-      if (!force) {
-        const cachedBootstrap = bootstrapCache.get(cacheKey);
-        if (cachedBootstrap) {
-          setBootstrap(cachedBootstrap);
-          setIsLoading(false);
-          return;
-        }
-      }
-      setIsLoading(true);
-      try {
-        const existing = bootstrapInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.business.getBootstrap();
-          if (!result.ok) {
-            throw result.error;
-          }
-          return result.value;
-        })();
-        if (!existing) {
-          bootstrapInflight.set(
-            cacheKey,
-            promise.finally(() => {
-              bootstrapInflight.delete(cacheKey);
-            })
-          );
-        }
-        const value = await promise;
-        bootstrapCache.set(cacheKey, value);
-        setBootstrap(value);
-      } catch (loadError) {
-        setError(loadError);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [cacheKey, client, enabled]
-  );
-  useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = useCallback(async () => {
-    bootstrapCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { bootstrap, isLoading, error, refetch };
+});
+function useBootstrap(options = {}) {
+  const { data, isLoading, error, refetch } = bootstrapQuery(options);
+  return { bootstrap: data, isLoading, error, refetch };
 }
 var ElementsContext = createContext({
   elements: null,