@cimplify/sdk 0.21.0 → 0.22.1

package/dist/react.js

@@ -444,6 +444,9 @@ function buildLineKey(productId, options) {
   if (options.staffId) {
     parts.push(`st:${options.staffId}`);
   }
+  if (options.resourceId) {
+    parts.push(`r:${options.resourceId}`);
+  }
   return parts.join("|");
 }
 function calculateLineSubtotal(item) {
@@ -761,7 +764,8 @@ function createCartStore(params) {
         composite_selections: normalizedOptions.compositeSelections,
         scheduled_start: normalizedOptions.scheduledStart,
         scheduled_end: normalizedOptions.scheduledEnd,
-        staff_id: normalizedOptions.staffId
+        staff_id: normalizedOptions.staffId,
+        resource_id: normalizedOptions.resourceId
       });
       if (!result.ok) {
         throw result.error;
@@ -1680,41 +1684,130 @@ function Price({ amount, className, prefix }) {
     chunk64OCG2TJ_js.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 = React3.useRef(locationId);
-  const requestIdRef = React3.useRef(0);
-  const tagsSignature = options.tags?.join(",") ?? "";
-  const propertiesSignature = options.properties ? JSON.stringify(options.properties) : "";
-  const queryOptions = React3.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 = React3.useRef(locationId);
+    const requestIdRef = React3.useRef(0);
+    const optionsRef = React3.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] = React3.useState(cached?.data ?? null);
+    const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
+    const [error, setError] = React3.useState(null);
+    const load = React3.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]
+    );
+    React3.useEffect(() => {
+      void load(false);
+    }, [load]);
+    const refetch = React3.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,
@@ -1728,301 +1821,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 = React3.useMemo(
-    () => buildProductsCacheKey(client, locationId, queryOptions),
-    [client, locationId, queryOptions]
-  );
-  const cached = productsCache.get(cacheKey);
-  const [products, setProducts] = React3.useState(cached?.products ?? []);
-  const [isComplete, setIsComplete] = React3.useState(cached?.is_complete ?? true);
-  const [totalAvailable, setTotalAvailable] = React3.useState(cached?.total_available);
-  const [pagination, setPagination] = React3.useState(cached?.pagination);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  React3.useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      productsCache.clear();
-      productsInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useRef(locationId);
-  const requestIdRef = React3.useRef(0);
-  const trackedProductRef = React3.useRef(null);
-  const normalizedSlugOrId = React3.useMemo(() => (slugOrId || "").trim(), [slugOrId]);
-  const cacheKey = React3.useMemo(
-    () => buildProductCacheKey(client, locationId, normalizedSlugOrId),
-    [client, locationId, normalizedSlugOrId]
-  );
-  const cached = productCache.get(cacheKey);
-  const [product, setProduct] = React3.useState(cached?.product ?? null);
-  const [isLoading, setIsLoading] = React3.useState(
-    enabled && normalizedSlugOrId.length > 0 && !cached
-  );
-  const [error, setError] = React3.useState(null);
-  React3.useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      productCache.clear();
-      productInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useMemo(() => buildCategoriesCacheKey(client), [client]);
-  const cached = categoriesCache.get(cacheKey);
-  const [categories, setCategories] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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();
@@ -2044,11 +1907,11 @@ function useOrder(orderId, options = {}) {
   const previousStatusRef = React3.useRef(null);
   const onStatusChangeRef = React3.useRef(options.onStatusChange);
   onStatusChangeRef.current = options.onStatusChange;
-  const cacheKey = React3.useMemo(
+  const cacheKey2 = React3.useMemo(
     () => buildOrderCacheKey(client, normalizedOrderId),
     [client, normalizedOrderId]
   );
-  const cached = orderCache.get(cacheKey);
+  const cached = orderCache.get(cacheKey2);
   const [order, setOrder] = React3.useState(cached?.order ?? null);
   const [isLoading, setIsLoading] = React3.useState(
     enabled && normalizedOrderId.length > 0 && !cached
@@ -2064,7 +1927,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);
@@ -2073,7 +1936,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) {
@@ -2083,14 +1946,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);
@@ -2111,7 +1974,7 @@ function useOrder(orderId, options = {}) {
         }
       }
     },
-    [cacheKey, client, enabled, normalizedOrderId]
+    [cacheKey2, client, enabled, normalizedOrderId]
   );
   React3.useEffect(() => {
     void load(false);
@@ -2129,9 +1992,9 @@ function useOrder(orderId, options = {}) {
     };
   }, [enabled, isTerminal, load, normalizedOrderId, poll, pollInterval]);
   const refetch = React3.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";
@@ -2234,216 +2097,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 = React3.useRef(locationId);
-  const requestIdRef = React3.useRef(0);
-  const cacheKey = React3.useMemo(
-    () => buildCollectionsCacheKey(client, locationId),
-    [client, locationId]
-  );
-  const cached = collectionsCache.get(cacheKey);
-  const [collections, setCollections] = React3.useState(cached?.collections ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  React3.useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      collectionsCache.clear();
-      collectionsInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useRef(locationId);
-  const requestIdRef = React3.useRef(0);
-  const normalizedIdOrSlug = React3.useMemo(() => (idOrSlug || "").trim(), [idOrSlug]);
-  const cacheKey = React3.useMemo(
-    () => buildCollectionCacheKey(client, locationId, normalizedIdOrSlug),
-    [client, locationId, normalizedIdOrSlug]
-  );
-  const cached = collectionCache.get(cacheKey);
-  const [collection, setCollection] = React3.useState(cached?.collection ?? null);
-  const [products, setProducts] = React3.useState(cached?.products ?? []);
-  const [isLoading, setIsLoading] = React3.useState(
-    enabled && normalizedIdOrSlug.length > 0 && !cached
-  );
-  const [error, setError] = React3.useState(null);
-  React3.useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      collectionCache.clear();
-      collectionInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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);
@@ -2614,11 +2325,11 @@ function useQuote(input, options = {}) {
     const normalized = normalizeInput(input, locationId);
     return normalized.product_id.length > 0 ? normalized : null;
   }, [inputSignature, locationId]);
-  const cacheKey = React3.useMemo(
+  const cacheKey2 = React3.useMemo(
     () => buildQuoteCacheKey(client, locationId, inputSignature),
     [client, inputSignature, locationId]
   );
-  const cached = quoteCache.get(cacheKey);
+  const cached = quoteCache.get(cacheKey2);
   const [quote, setQuote] = React3.useState(cached?.quote ?? null);
   const [isLoading, setIsLoading] = React3.useState(enabled && normalizedInput !== null && !cached);
   const [error, setError] = React3.useState(null);
@@ -2644,7 +2355,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 ?? []);
@@ -2657,7 +2368,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) {
@@ -2666,13 +2377,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 ?? []);
@@ -2689,13 +2400,13 @@ function useQuote(input, options = {}) {
         }
       }
     },
-    [cacheKey, client, enabled, normalizedInput]
+    [cacheKey2, client, enabled, normalizedInput]
   );
   React3.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 {
@@ -2709,7 +2420,7 @@ function useQuote(input, options = {}) {
         debounceTimerRef.current = null;
       }
     };
-  }, [load, cacheKey, enabled, normalizedInput]);
+  }, [load, cacheKey2, enabled, normalizedInput]);
   const refresh = React3.useCallback(async () => {
     if (!enabled || !normalizedInput) {
       return;
@@ -2730,7 +2441,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 ?? []);
@@ -2746,7 +2457,7 @@ function useQuote(input, options = {}) {
         setIsLoading(false);
       }
     }
-  }, [cacheKey, client, enabled, load, normalizedInput, quote]);
+  }, [cacheKey2, client, enabled, load, normalizedInput, quote]);
   React3.useEffect(() => {
     if (!Number.isFinite(quoteExpiryTimestamp)) {
       setIsExpired(false);
@@ -2778,1930 +2489,628 @@ 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 = React3.useMemo(
-    () => buildTaxonomiesCacheKey(client, options.parentId),
-    [client, options.parentId]
-  );
-  const cached = taxonomiesCache.get(cacheKey);
-  const [taxonomies, setTaxonomies] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
+  const [isValidating, setIsValidating] = React3.useState(false);
   const [error, setError] = React3.useState(null);
-  const parentId = options.parentId;
-  const load = React3.useCallback(
-    async (force = false) => {
-      if (!enabled) {
-        setIsLoading(false);
-        return;
-      }
+  const validate = React3.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]
   );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useMemo(() => buildTaxonomyCacheKey(client, id), [client, id]);
-  const cached = taxonomyCache.get(cacheKey);
-  const [taxonomy, setTaxonomy] = React3.useState(cached ?? null);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const trackedTaxonomyRef = React3.useRef(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useMemo(() => buildTaxonomyPathCacheKey(client, id), [client, id]);
-  const cached = taxonomyPathCache.get(cacheKey);
-  const [path, setPath] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useMemo(() => buildSchedulesCacheKey(client, productId), [client, productId]);
-  const cached = schedulesCache.get(cacheKey);
-  const [schedules, setSchedules] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useRef(locationId);
-  const cacheKey = React3.useMemo(
-    () => locationId ? buildAvailabilityCacheKey(client, productId, locationId) : null,
-    [client, productId, locationId]
-  );
-  const cached = cacheKey ? availabilityCache.get(cacheKey) : void 0;
-  const [isAvailable, setIsAvailable] = React3.useState(cached?.is_available ?? null);
-  const [schedulesToday, setSchedulesToday] = React3.useState(
-    cached?.schedules_today ?? []
-  );
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached && !!locationId);
-  const [error, setError] = React3.useState(null);
-  React3.useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      availabilityCache.clear();
-      availabilityInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useRef(locationId);
-  const cacheKey = React3.useMemo(() => buildDealsCacheKey(client, locationId), [client, locationId]);
-  const cached = dealsCache.get(cacheKey);
-  const [deals, setDeals] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  React3.useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      dealsCache.clear();
-      dealsInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useMemo(() => buildOnSaleCacheKey(client), [client]);
-  const cached = onSaleCache.get(cacheKey);
-  const [products, setProducts] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useMemo(
-    () => buildProductDealsCacheKey(client, productId),
-    [client, productId]
-  );
-  const cached = productDealsCache.get(cacheKey);
-  const [deals, setDeals] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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] = React3.useState(false);
-  const [error, setError] = React3.useState(null);
-  const validate = React3.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 = React3.useRef(locationId);
-  const requestIdRef = React3.useRef(0);
-  const cacheKey = React3.useMemo(
-    () => buildBundlesCacheKey(client, locationId),
-    [client, locationId]
-  );
-  const cached = bundlesCache.get(cacheKey);
-  const [bundles, setBundles] = React3.useState(cached?.bundles ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  React3.useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      bundlesCache.clear();
-      bundlesInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 React3.useMemo(() => {
-    let unitPrice;
-    if (bundleTotalPrice != null) {
-      unitPrice = bundleTotalPrice;
-    } else if (compositePrice) {
-      unitPrice = chunk64OCG2TJ_js.parsePrice(compositePrice.final_price);
-    } else {
-      unitPrice = chunk64OCG2TJ_js.parsePrice(product.default_price);
-      if (variant?.price_adjustment) {
-        unitPrice += chunk64OCG2TJ_js.parsePrice(variant.price_adjustment);
-      }
-      if (addOnOptions) {
-        for (const option of addOnOptions) {
-          if (option.default_price) {
-            unitPrice += chunk64OCG2TJ_js.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 = React3.useRef(0);
-  const cacheKey = React3.useMemo(
-    () => buildOrdersCacheKey(client, options.status, options.limit),
-    [client, options.status, options.limit]
-  );
-  const cached = ordersCache.get(cacheKey);
-  const [orders, setOrders] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useRef(0);
-  const cacheKey = React3.useMemo(() => buildServicesCacheKey(client), [client]);
-  const cached = servicesCache.get(cacheKey);
-  const [services, setServices] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useRef(0);
-  const cacheKey = React3.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] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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 = React3.useRef(0);
-  const cacheKey = React3.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] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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;
-        }
-      }
-      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;
-          }
-          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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.useCallback(async () => {
-    if (cacheKey) {
-      availabilityCache2.delete(cacheKey);
-    }
-    await load(true);
-  }, [cacheKey, load]);
-  return { days, isLoading, error, refetch };
-}
-var bookingsCache = /* @__PURE__ */ new Map();
-var bookingsInflight = /* @__PURE__ */ new Map();
-function buildBookingsCacheKey(client, filter) {
-  return JSON.stringify({ key: client.getPublicKey(), filter });
-}
-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 = React3.useRef(0);
-  const cacheKey = React3.useMemo(
-    () => buildBookingsCacheKey(client, filter),
-    [client, filter]
-  );
-  const cached = bookingsCache.get(cacheKey);
-  const [bookings, setBookings] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.useCallback(async () => {
-    bookingsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  const cancelBooking = React3.useCallback(
-    async (bookingId, reason) => {
-      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);
-      return result.value;
-    },
-    [client, load]
-  );
-  return { bookings, 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 }."
-    );
-  }
-  const enabled = options.enabled ?? true;
-  const namespace = options.namespace;
-  const cacheKey = React3.useMemo(() => buildCacheKey(client, namespace), [client, namespace]);
-  const cached = definitionsCache.get(cacheKey);
-  const [definitions, setDefinitions] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.useCallback(async () => {
-    definitionsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { definitions, 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 }."
-    );
-  }
-  const enabled = options.enabled ?? true;
-  const cacheKey = React3.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] = React3.useState(cached ?? []);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.useCallback(async () => {
-    facetsCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { facets, isLoading, error, refetch };
-}
-function useBillingPlans(productId, options = {}) {
-  const context = useOptionalCimplifyClient();
-  const client = options.client ?? context?.client;
-  if (!client) {
-    throw new Error("useBillingPlans must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const requestIdRef = React3.useRef(0);
-  const [plans, setPlans] = React3.useState([]);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !!productId);
-  const [error, setError] = React3.useState(null);
-  const customerId = options.customerId;
-  const quantity = options.quantity;
-  const orderValue = options.orderValue;
-  const load = React3.useCallback(
-    async (force = false) => {
-      if (!enabled || !productId) {
-        setPlans([]);
-        setIsLoading(false);
-        return;
-      }
-      const nextRequestId = ++requestIdRef.current;
-      setError(null);
-      setIsLoading(true);
-      try {
-        const result = await client.catalogue.getEligibleBillingPlans(productId, {
-          customer_id: customerId,
-          quantity,
-          order_value: orderValue
-        });
-        if (!result.ok) {
-          throw result.error;
-        }
-        if (nextRequestId === requestIdRef.current) {
-          setPlans(result.value);
-          setError(null);
-        }
-      } catch (loadError) {
-        if (nextRequestId === requestIdRef.current) {
-          setError(loadError);
-        }
-      } finally {
-        if (nextRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [client, enabled, productId, customerId, quantity, orderValue]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.useCallback(async () => {
-    await load(true);
-  }, [load]);
-  const subscriptionPlans = React3.useMemo(
-    () => plans.filter((p) => p.plan_type === "subscription"),
-    [plans]
-  );
-  const installmentPlans = React3.useMemo(
-    () => plans.filter((p) => p.plan_type === "installment"),
-    [plans]
-  );
-  return { plans, subscriptionPlans, installmentPlans, isLoading, error, refetch };
-}
-function findMatchingVariant(variants, selections) {
-  const axisCount = Object.keys(selections).length;
-  if (axisCount === 0) return null;
-  return variants.find((v) => {
-    const sel = v.axis_selections;
-    if (!sel) return false;
-    return Object.entries(selections).every(([axisId, valueId]) => sel[axisId] === valueId);
-  }) ?? null;
-}
-function computeAvailableValues(variants, axes, selections) {
-  const result = {};
-  for (const axis of axes) {
-    const otherSelections = Object.entries(selections).filter(([id]) => id !== axis.id);
-    const candidates = variants.filter((v) => {
-      const sel = v.axis_selections;
-      if (!sel) return false;
-      return otherSelections.every(([axisId, valueId]) => sel[axisId] === valueId);
-    });
-    const available = /* @__PURE__ */ new Set();
-    for (const v of candidates) {
-      const val = v.axis_selections?.[axis.id];
-      if (val) available.add(val);
-    }
-    result[axis.id] = available;
-  }
-  return result;
-}
-function useVariantSelector(options) {
-  const { variants, axes } = options;
-  const [selectedValues, setSelectedValues] = React3.useState({});
-  const selectValue = React3.useCallback(
-    (axisId, valueId) => {
-      setSelectedValues((prev) => {
-        if (prev[axisId] === valueId) {
-          const next = { ...prev };
-          delete next[axisId];
-          return next;
-        }
-        return { ...prev, [axisId]: valueId };
-      });
-    },
-    []
-  );
-  const reset = React3.useCallback(() => setSelectedValues({}), []);
-  const selectedVariant = React3.useMemo(
-    () => findMatchingVariant(variants, selectedValues),
-    [variants, selectedValues]
-  );
-  const variantImage = React3.useMemo(
-    () => selectedVariant?.images?.[0] ?? null,
-    [selectedVariant]
-  );
-  const availableValues = React3.useMemo(
-    () => computeAvailableValues(variants, axes, selectedValues),
-    [variants, axes, selectedValues]
-  );
-  return {
-    selectedValues,
-    selectedVariant,
-    variantImage,
-    availableValues,
-    selectValue,
-    reset
-  };
-}
-var activityStateCache = /* @__PURE__ */ new Map();
-var activityStateInflight = /* @__PURE__ */ new Map();
-function buildActivityStateCacheKey(client) {
-  return JSON.stringify({ key: client.getPublicKey(), type: "activity_state" });
+});
+function useBundles(options = {}) {
+  const { data, isLoading, error, refetch } = bundlesQuery(options);
+  return { bundles: data ?? [], isLoading, error, refetch };
 }
-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 = React3.useMemo(() => buildActivityStateCacheKey(client), [client]);
-  const cached = activityStateCache.get(cacheKey);
-  const [state, setState] = React3.useState(cached ?? null);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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;
-        }
+function useProductPrice(input) {
+  const {
+    product,
+    quantity = 1,
+    variant,
+    addOnOptions,
+    compositePrice,
+    bundleTotalPrice
+  } = input;
+  return React3.useMemo(() => {
+    let unitPrice;
+    if (bundleTotalPrice != null) {
+      unitPrice = bundleTotalPrice;
+    } else if (compositePrice) {
+      unitPrice = chunk64OCG2TJ_js.parsePrice(compositePrice.final_price);
+    } else {
+      unitPrice = chunk64OCG2TJ_js.parsePrice(product.default_price);
+      if (variant?.price_adjustment) {
+        unitPrice += chunk64OCG2TJ_js.parsePrice(variant.price_adjustment);
       }
-      setIsLoading(true);
-      try {
-        const existing = activityStateInflight.get(cacheKey);
-        const promise = existing ?? (async () => {
-          const result = await client.activity.getState();
-          if (!result.ok) {
-            throw result.error;
+      if (addOnOptions) {
+        for (const option of addOnOptions) {
+          if (option.default_price) {
+            unitPrice += chunk64OCG2TJ_js.parsePrice(option.default_price);
           }
-          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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.useCallback(async () => {
-    activityStateCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  const dismissMessage = React3.useCallback(
-    async (code) => {
-      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);
-    },
-    [cacheKey, client, load]
-  );
-  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
-  });
+    }
+    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]);
 }
-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-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;
   }
-  const enabled = options.enabled ?? true;
-  const locationId = options.locationId ?? client.getLocationId() ?? void 0;
-  const limit = options.limit;
-  const previousLocationIdRef = React3.useRef(locationId);
-  const cacheKey = React3.useMemo(
-    () => buildRecommendationsCacheKey(client, locationId, limit),
-    [client, locationId, limit]
-  );
-  const cached = recommendationsCache.get(cacheKey);
-  const [response, setResponse] = React3.useState(cached ?? null);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  React3.useEffect(() => {
-    if (previousLocationIdRef.current !== locationId) {
-      recommendationsCache.clear();
-      recommendationsInflight.clear();
-      previousLocationIdRef.current = locationId;
-    }
-  }, [locationId]);
-  const load = React3.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]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.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();
-function buildDeliveryFeeCacheKey(client, latitude, longitude, country) {
-  return JSON.stringify({
-    key: client.getPublicKey(),
-    lat: latitude,
-    lng: longitude,
-    country
-  });
+});
+function useOrders(options = {}) {
+  const { data, isLoading, error, refetch } = ordersQuery(options);
+  return { orders: data ?? [], 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-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;
   }
-  const enabled = options.enabled ?? true;
-  const { latitude, longitude, country } = options;
-  const cacheKey = React3.useMemo(
-    () => buildDeliveryFeeCacheKey(client, latitude, longitude, country),
-    [client, latitude, longitude, country]
-  );
-  const cached = deliveryFeeCache.get(cacheKey);
-  const [fee, setFee] = React3.useState(cached ?? null);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const requestIdRef = React3.useRef(0);
-  const load = React3.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 result = await client.delivery.getFee(latitude, longitude, country);
-        if (currentRequestId !== requestIdRef.current) return;
-        if (!result.ok) {
-          throw result.error;
-        }
-        deliveryFeeCache.set(cacheKey, result.value);
-        setFee(result.value);
-      } catch (loadError) {
-        if (currentRequestId !== requestIdRef.current) return;
-        setError(loadError);
-      } finally {
-        if (currentRequestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
-      }
-    },
-    [cacheKey, client, country, enabled, latitude, longitude]
-  );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.useCallback(async () => {
-    deliveryFeeCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { fee, isLoading, error, refetch };
+});
+function useServices(options = {}) {
+  const { data, isLoading, error, refetch } = servicesQuery(options);
+  return { services: data ?? [], 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 });
+
+// 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 };
 }
-function useFxRate(options) {
+
+// 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("useFxRate must be used within CimplifyProvider or passed { client }.");
-  }
-  const enabled = options.enabled ?? true;
-  const { from, to } = options;
-  const cacheKey = React3.useMemo(
-    () => buildFxRateCacheKey(client, from, to),
-    [client, from, to]
-  );
-  const cached = fxRateCache.get(cacheKey);
-  const [rate, setRate] = React3.useState(cached ?? null);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
-  const [error, setError] = React3.useState(null);
-  const load = React3.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);
-      }
+  const { data, isLoading, error, refetch } = bookingsQuery(options);
+  const cancelBooking = React3.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;
+      bookingsQuery.clear();
+      await refetch();
+      return result.value;
     },
-    [cacheKey, client, enabled, from, to]
+    [client, refetch]
   );
-  React3.useEffect(() => {
-    void load(false);
-  }, [load]);
-  const refetch = React3.useCallback(async () => {
-    fxRateCache.delete(cacheKey);
-    await load(true);
-  }, [cacheKey, load]);
-  return { rate, isLoading, error, refetch };
+  return { bookings: data ?? [], isLoading, error, refetch, cancelBooking };
+}
+
+// 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;
+  }
+});
+function useAttributeDefinitions(options = {}) {
+  const { data, isLoading, error, refetch } = attributeDefinitionsQuery(options);
+  return { definitions: data ?? [], isLoading, error, refetch };
 }
-var bootstrapCache = /* @__PURE__ */ new Map();
-var bootstrapInflight = /* @__PURE__ */ new Map();
-function buildBootstrapCacheKey(client) {
-  return JSON.stringify({ key: client.getPublicKey(), type: "bootstrap" });
+
+// 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;
+  }
+});
+function usePropertyFacets(options = {}) {
+  const { data, isLoading, error, refetch } = propertyFacetsQuery(options);
+  return { facets: data ?? [], isLoading, error, refetch };
 }
-function useBootstrap(options = {}) {
+function useBillingPlans(productId, options = {}) {
   const context = useOptionalCimplifyClient();
   const client = options.client ?? context?.client;
   if (!client) {
-    throw new Error("useBootstrap must be used within CimplifyProvider or passed { client }.");
+    throw new Error("useBillingPlans must be used within CimplifyProvider or passed { client }.");
   }
   const enabled = options.enabled ?? true;
-  const cacheKey = React3.useMemo(() => buildBootstrapCacheKey(client), [client]);
-  const cached = bootstrapCache.get(cacheKey);
-  const [bootstrap, setBootstrap] = React3.useState(cached ?? null);
-  const [isLoading, setIsLoading] = React3.useState(enabled && !cached);
+  const requestIdRef = React3.useRef(0);
+  const [plans, setPlans] = React3.useState([]);
+  const [isLoading, setIsLoading] = React3.useState(enabled && !!productId);
   const [error, setError] = React3.useState(null);
+  const customerId = options.customerId;
+  const quantity = options.quantity;
+  const orderValue = options.orderValue;
   const load = React3.useCallback(
     async (force = false) => {
-      if (!enabled) {
+      if (!enabled || !productId) {
+        setPlans([]);
         setIsLoading(false);
         return;
       }
+      const nextRequestId = ++requestIdRef.current;
       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 result = await client.catalogue.getEligibleBillingPlans(productId, {
+          customer_id: customerId,
+          quantity,
+          order_value: orderValue
+        });
+        if (!result.ok) {
+          throw result.error;
+        }
+        if (nextRequestId === requestIdRef.current) {
+          setPlans(result.value);
+          setError(null);
         }
-        const value = await promise;
-        bootstrapCache.set(cacheKey, value);
-        setBootstrap(value);
       } catch (loadError) {
-        setError(loadError);
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
       } finally {
-        setIsLoading(false);
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
       }
     },
-    [cacheKey, client, enabled]
+    [client, enabled, productId, customerId, quantity, orderValue]
   );
   React3.useEffect(() => {
     void load(false);
   }, [load]);
   const refetch = React3.useCallback(async () => {
-    bootstrapCache.delete(cacheKey);
     await load(true);
-  }, [cacheKey, load]);
-  return { bootstrap, isLoading, error, refetch };
+  }, [load]);
+  const subscriptionPlans = React3.useMemo(
+    () => plans.filter((p) => p.plan_type === "subscription"),
+    [plans]
+  );
+  const installmentPlans = React3.useMemo(
+    () => plans.filter((p) => p.plan_type === "installment"),
+    [plans]
+  );
+  return { plans, subscriptionPlans, installmentPlans, isLoading, error, refetch };
+}
+function findMatchingVariant(variants, selections) {
+  const axisCount = Object.keys(selections).length;
+  if (axisCount === 0) return null;
+  return variants.find((v) => {
+    const sel = v.axis_selections;
+    if (!sel) return false;
+    return Object.entries(selections).every(([axisId, valueId]) => sel[axisId] === valueId);
+  }) ?? null;
+}
+function computeAvailableValues(variants, axes, selections) {
+  const result = {};
+  for (const axis of axes) {
+    const otherSelections = Object.entries(selections).filter(([id]) => id !== axis.id);
+    const candidates = variants.filter((v) => {
+      const sel = v.axis_selections;
+      if (!sel) return false;
+      return otherSelections.every(([axisId, valueId]) => sel[axisId] === valueId);
+    });
+    const available = /* @__PURE__ */ new Set();
+    for (const v of candidates) {
+      const val = v.axis_selections?.[axis.id];
+      if (val) available.add(val);
+    }
+    result[axis.id] = available;
+  }
+  return result;
+}
+function useVariantSelector(options) {
+  const { variants, axes } = options;
+  const [selectedValues, setSelectedValues] = React3.useState({});
+  const selectValue = React3.useCallback(
+    (axisId, valueId) => {
+      setSelectedValues((prev) => {
+        if (prev[axisId] === valueId) {
+          const next = { ...prev };
+          delete next[axisId];
+          return next;
+        }
+        return { ...prev, [axisId]: valueId };
+      });
+    },
+    []
+  );
+  const reset = React3.useCallback(() => setSelectedValues({}), []);
+  const selectedVariant = React3.useMemo(
+    () => findMatchingVariant(variants, selectedValues),
+    [variants, selectedValues]
+  );
+  const variantImage = React3.useMemo(
+    () => selectedVariant?.images?.[0] ?? null,
+    [selectedVariant]
+  );
+  const availableValues = React3.useMemo(
+    () => computeAvailableValues(variants, axes, selectedValues),
+    [variants, axes, selectedValues]
+  );
+  return {
+    selectedValues,
+    selectedVariant,
+    variantImage,
+    availableValues,
+    selectValue,
+    reset
+  };
+}
+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;
+  const { data, isLoading, error, refetch } = activityStateQuery(options);
+  const dismissMessage = React3.useCallback(
+    async (code) => {
+      if (!client) return;
+      const result = await client.activity.dismissMessage(code);
+      if (!result.ok) return;
+      activityStateQuery.clear();
+      await refetch();
+    },
+    [client, refetch]
+  );
+  return {
+    state: data,
+    messages: data?.messages ?? [],
+    intent: data?.intent ?? "",
+    isLoading,
+    error,
+    refetch,
+    dismissMessage
+  };
+}
+
+// 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;
+  }
+});
+function useRecommendations(options = {}) {
+  const { data, isLoading, error, refetch } = recommendationsQuery(options);
+  return {
+    recommendations: data?.recommendations ?? [],
+    intent: data?.intent ?? "",
+    isLoading,
+    error,
+    refetch
+  };
+}
+
+// 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;
+  }
+});
+function useDeliveryFee(options) {
+  const { data, isLoading, error, refetch } = deliveryFeeQuery(options);
+  return { fee: data, isLoading, error, refetch };
+}
+
+// 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;
+  }
+});
+function useFxRate(options) {
+  const { data, isLoading, error, refetch } = fxRateQuery(options);
+  return { rate: data, isLoading, error, refetch };
+}
+
+// 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;
+  }
+});
+function useBootstrap(options = {}) {
+  const { data, isLoading, error, refetch } = bootstrapQuery(options);
+  return { bootstrap: data, isLoading, error, refetch };
 }
 var ElementsContext = React3.createContext({
   elements: null,
@@ -6882,11 +5291,8 @@ function ProductCard({
       "div",
       {
         "data-cimplify-product-card-image-container": true,
-        className: classNames?.imageContainer,
-        style: {
-          overflow: "hidden",
-          ...ASPECT_STYLES2[aspectRatio]
-        },
+        className: cn("overflow-hidden rounded-t-xl", classNames?.imageContainer),
+        style: ASPECT_STYLES2[aspectRatio],
         children: renderImage ? renderImage({
           src: imageUrl,
           alt: product.name,
@@ -6896,8 +5302,7 @@ function ProductCard({
           {
             src: imageUrl,
             alt: product.name,
-            className: classNames?.image,
-            style: { width: "100%", height: "100%", objectFit: "cover" },
+            className: cn("w-full h-full object-cover transition-transform duration-300 group-hover:scale-105", classNames?.image),
             "data-cimplify-product-card-image": true
           }
         )
@@ -6907,13 +5312,13 @@ function ProductCard({
       "div",
       {
         "data-cimplify-product-card-body": true,
-        className: classNames?.body,
+        className: cn("p-4 flex flex-col gap-1", classNames?.body),
         children: [
           /* @__PURE__ */ jsxRuntime.jsx(
             "span",
             {
               "data-cimplify-product-card-name": true,
-              className: classNames?.name,
+              className: cn("font-semibold text-foreground leading-tight", classNames?.name),
               children: product.name
             }
           ),
@@ -6921,13 +5326,7 @@ function ProductCard({
             "span",
             {
               "data-cimplify-product-card-description": true,
-              className: classNames?.description,
-              style: {
-                display: "-webkit-box",
-                WebkitLineClamp: 2,
-                WebkitBoxOrient: "vertical",
-                overflow: "hidden"
-              },
+              className: cn("text-sm text-muted-foreground line-clamp-2", classNames?.description),
               children: product.description
             }
           ),
@@ -6935,7 +5334,7 @@ function ProductCard({
             Price,
             {
               amount: product.default_price,
-              className: classNames?.price
+              className: cn("text-sm font-medium text-foreground mt-1", classNames?.price)
             }
           )
         ]
@@ -6944,7 +5343,7 @@ function ProductCard({
   ] });
   if (mode === "page") {
     const linkHref = href ?? `/menu/${product.slug}`;
-    const linkClassName = cn("block no-underline text-[inherit]", className, classNames?.root);
+    const linkClassName = cn("group block no-underline text-[inherit] rounded-xl border border-border bg-background transition-shadow duration-200 hover:shadow-md", className, classNames?.root);
     if (renderLink) {
       return renderLink({ href: linkHref, className: linkClassName, children: cardBody });
     }
@@ -6967,7 +5366,7 @@ function ProductCard({
         "data-cimplify-product-card": true,
         "data-display-mode": "card",
         className: cn(
-          "block w-full text-left bg-transparent border-none p-0 cursor-pointer font-[inherit] text-[inherit]",
+          "group block w-full text-left p-0 cursor-pointer font-[inherit] text-[inherit] rounded-xl border border-border bg-background transition-shadow duration-200 hover:shadow-md",
           className,
           classNames?.root
         ),
@@ -8301,10 +6700,14 @@ function BookingCard({
     {
       "data-cimplify-booking-card": true,
       "data-status": booking.status,
-      className: cn(className, classNames?.root),
+      className: cn(
+        "rounded-xl border border-border bg-background p-4 flex flex-col gap-3",
+        className,
+        classNames?.root
+      ),
       children: [
-        /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-main": true, children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-cimplify-booking-service": true, className: classNames?.service, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-main": true, className: "flex items-center justify-between gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-cimplify-booking-service": true, className: cn("font-semibold text-foreground", classNames?.service), children: [
             "Booking #",
             booking.order_id.slice(0, 8)
           ] }),
@@ -8313,22 +6716,37 @@ function BookingCard({
             {
               "data-cimplify-booking-status": true,
               "data-status": booking.status,
-              className: classNames?.status,
+              className: cn(
+                "text-xs font-medium px-2 py-0.5 rounded-full",
+                active ? "bg-primary/10 text-primary" : "bg-muted text-muted-foreground",
+                classNames?.status
+              ),
               children: STATUS_LABELS3[booking.status] ?? booking.status
             }
           )
         ] }),
-        firstItem?.confirmation_code && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-booking-code": true, className: classNames?.confirmationCode, children: firstItem.confirmation_code }),
-        scheduledTime && /* @__PURE__ */ jsxRuntime.jsx("time", { "data-cimplify-booking-time": true, className: classNames?.time, children: scheduledTime }),
-        /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-booking-total": true, className: classNames?.total, children: /* @__PURE__ */ jsxRuntime.jsx(Price, { amount: booking.total_price }) }),
-        active && (onCancel || onReschedule) && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-actions": true, className: classNames?.actions, children: [
+        firstItem?.confirmation_code && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-booking-code": true, className: cn("text-xs font-mono text-muted-foreground tracking-wide", classNames?.confirmationCode), children: firstItem.confirmation_code }),
+        scheduledTime && /* @__PURE__ */ jsxRuntime.jsx(
+          "time",
+          {
+            "data-cimplify-booking-time": true,
+            dateTime: firstItem?.scheduled_start ?? void 0,
+            className: cn("text-sm text-foreground", classNames?.time),
+            children: scheduledTime
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-booking-total": true, className: cn("text-sm font-medium text-foreground", classNames?.total), children: /* @__PURE__ */ jsxRuntime.jsx(Price, { amount: booking.total_price }) }),
+        active && (onCancel || onReschedule) && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-actions": true, className: cn("flex gap-2 pt-1 border-t border-border mt-1", classNames?.actions), children: [
           onReschedule && /* @__PURE__ */ jsxRuntime.jsx(
             "button",
             {
               type: "button",
               onClick: () => onReschedule(booking),
               "data-cimplify-booking-reschedule": true,
-              className: classNames?.rescheduleButton,
+              className: cn(
+                "flex-1 text-sm font-medium py-2 rounded-lg border border-border bg-background text-foreground transition-colors hover:bg-muted cursor-pointer",
+                classNames?.rescheduleButton
+              ),
               children: "Reschedule"
             }
           ),
@@ -8338,7 +6756,10 @@ function BookingCard({
               type: "button",
               onClick: () => onCancel(booking),
               "data-cimplify-booking-cancel": true,
-              className: classNames?.cancelButton,
+              className: cn(
+                "flex-1 text-sm font-medium py-2 rounded-lg border border-border bg-background text-destructive transition-colors hover:bg-destructive/10 cursor-pointer",
+                classNames?.cancelButton
+              ),
               children: "Cancel"
             }
           )
@@ -8451,11 +6872,8 @@ function ServiceCard({
       "div",
       {
         "data-cimplify-service-card-image-container": true,
-        className: classNames?.imageContainer,
-        style: {
-          overflow: "hidden",
-          ...ASPECT_STYLES3[aspectRatio]
-        },
+        className: cn("overflow-hidden rounded-t-xl", classNames?.imageContainer),
+        style: ASPECT_STYLES3[aspectRatio],
         children: renderImage ? renderImage({
           src: imageUrl,
           alt: service.name,
@@ -8465,36 +6883,35 @@ function ServiceCard({
           {
             src: imageUrl,
             alt: service.name,
-            className: classNames?.image,
-            style: { width: "100%", height: "100%", objectFit: "cover" },
+            className: cn("w-full h-full object-cover transition-transform duration-300 group-hover:scale-105", classNames?.image),
             "data-cimplify-service-card-image": true
           }
         )
       }
     ),
-    /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-service-card-body": true, className: classNames?.body, children: [
-      /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-service-card-name": true, className: classNames?.name, children: service.name }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-service-card-body": true, className: cn("p-4 flex flex-col gap-1.5", classNames?.body), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-service-card-name": true, className: cn("font-semibold text-foreground leading-tight", classNames?.name), children: service.name }),
       service.description && /* @__PURE__ */ jsxRuntime.jsx(
         "span",
         {
           "data-cimplify-service-card-description": true,
-          className: classNames?.description,
-          style: {
-            display: "-webkit-box",
-            WebkitLineClamp: 2,
-            WebkitBoxOrient: "vertical",
-            overflow: "hidden"
-          },
+          className: cn("text-sm text-muted-foreground line-clamp-2", classNames?.description),
           children: service.description
         }
       ),
-      /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-service-card-meta": true, className: classNames?.meta, children: [
-        /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-service-card-duration": true, className: classNames?.duration, children: formatDuration2(service.duration_minutes, service.duration_unit) }),
-        service.price && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-service-card-price": true, className: classNames?.price, children: /* @__PURE__ */ jsxRuntime.jsx(Price, { amount: service.price }) })
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-service-card-meta": true, className: cn("flex items-center gap-2 mt-1 text-sm", classNames?.meta), children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-service-card-duration": true, className: cn("text-muted-foreground", classNames?.duration), children: formatDuration2(service.duration_minutes, service.duration_unit) }),
+        service.price && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-service-card-price": true, className: cn("font-medium text-foreground", classNames?.price), children: /* @__PURE__ */ jsxRuntime.jsx(Price, { amount: service.price }) })
       ] })
     ] }),
-    !href && onBook && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-service-card-action": true, className: classNames?.action, children: actionLabel })
+    !href && onBook && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-service-card-action": true, className: cn("px-4 pb-4 pt-1 text-sm font-medium text-primary", classNames?.action), children: actionLabel })
   ] });
+  const cardClasses = cn(
+    "group block w-full rounded-xl border border-border bg-background text-left transition-shadow duration-200 hover:shadow-md",
+    !service.is_available && "opacity-60",
+    className,
+    classNames?.root
+  );
   if (href) {
     return /* @__PURE__ */ jsxRuntime.jsx(
       "a",
@@ -8502,8 +6919,7 @@ function ServiceCard({
         href,
         "data-cimplify-service-card": true,
         "data-available": service.is_available || void 0,
-        className: cn(className, classNames?.root),
-        style: { display: "block", textDecoration: "none", color: "inherit" },
+        className: cn(cardClasses, "no-underline text-[inherit]"),
         children: cardBody
       }
     );
@@ -8516,18 +6932,7 @@ function ServiceCard({
       disabled: !service.is_available,
       "data-cimplify-service-card": true,
       "data-available": service.is_available || void 0,
-      className: cn(className, classNames?.root),
-      style: {
-        display: "block",
-        width: "100%",
-        textAlign: "inherit",
-        background: "none",
-        border: "none",
-        padding: 0,
-        cursor: service.is_available ? "pointer" : "default",
-        font: "inherit",
-        color: "inherit"
-      },
+      className: cn(cardClasses, "cursor-pointer font-[inherit] p-0 border-border"),
       children: cardBody
     }
   );
@@ -9263,10 +7668,114 @@ function DealsPage({
     isEmpty && /* @__PURE__ */ jsxRuntime.jsx("div", { "data-cimplify-deals-empty": true, className: classNames?.empty, children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: "No deals available right now. Check back soon!" }) })
   ] });
 }
+var ANY_VALUE2 = "__any__";
+function roomToResource(room) {
+  return {
+    id: room.id,
+    name: room.name,
+    capacity: room.capacity,
+    floor: room.floor,
+    is_available: room.status === "available"
+  };
+}
+function ResourcePicker({
+  resources,
+  selectedResourceId,
+  onResourceSelect,
+  showAnyOption = true,
+  anyLabel = "Any available",
+  renderImage,
+  className,
+  classNames
+}) {
+  const groupValue = selectedResourceId === null ? ANY_VALUE2 : selectedResourceId ?? "";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    radioGroup.RadioGroup,
+    {
+      "data-cimplify-resource-picker": true,
+      className: cn("flex flex-col gap-2", className, classNames?.root),
+      value: groupValue,
+      onValueChange: (value) => {
+        onResourceSelect?.(value === ANY_VALUE2 ? null : value);
+      },
+      children: [
+        showAnyOption && /* @__PURE__ */ jsxRuntime.jsx(
+          radio.Radio.Root,
+          {
+            value: ANY_VALUE2,
+            "data-cimplify-resource-option": true,
+            "data-selected": selectedResourceId === null || void 0,
+            "data-any": true,
+            className: cn(
+              "flex items-center gap-3 rounded-lg border border-border p-3 transition-colors cursor-pointer",
+              "hover:bg-muted data-[checked]:border-primary data-[checked]:bg-primary/5",
+              classNames?.option
+            ),
+            children: /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-resource-name": true, className: cn("font-medium text-foreground", classNames?.name), children: anyLabel })
+          }
+        ),
+        resources.map((resource) => {
+          const unavailable = resource.is_available === false;
+          return /* @__PURE__ */ jsxRuntime.jsxs(
+            radio.Radio.Root,
+            {
+              value: resource.id,
+              disabled: unavailable,
+              "data-cimplify-resource-option": true,
+              "data-selected": selectedResourceId === resource.id || void 0,
+              "data-unavailable": unavailable || void 0,
+              className: cn(
+                "flex items-center gap-3 rounded-lg border border-border p-3 transition-colors cursor-pointer",
+                "hover:bg-muted data-[checked]:border-primary data-[checked]:bg-primary/5",
+                unavailable && "opacity-50 cursor-not-allowed",
+                classNames?.option,
+                unavailable ? classNames?.unavailable : void 0
+              ),
+              children: [
+                resource.image_url && (renderImage ? renderImage({
+                  src: resource.image_url,
+                  alt: resource.name,
+                  className: classNames?.image
+                }) : /* @__PURE__ */ jsxRuntime.jsx(
+                  "img",
+                  {
+                    src: resource.image_url,
+                    alt: resource.name,
+                    "data-cimplify-resource-image": true,
+                    className: cn("w-10 h-10 rounded-lg object-cover", classNames?.image)
+                  }
+                )),
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-0.5 flex-1 min-w-0", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-resource-name": true, className: cn("font-medium text-foreground", classNames?.name), children: resource.name }),
+                  resource.description && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-resource-description": true, className: cn("text-sm text-muted-foreground truncate", classNames?.description), children: resource.description }),
+                  /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-resource-meta": true, className: cn("flex items-center gap-2 text-xs text-muted-foreground", classNames?.meta), children: [
+                    resource.capacity !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-cimplify-resource-capacity": true, className: classNames?.capacity, children: [
+                      "Up to ",
+                      resource.capacity
+                    ] }),
+                    resource.floor && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-cimplify-resource-floor": true, className: classNames?.floor, children: resource.floor })
+                  ] })
+                ] })
+              ]
+            },
+            resource.id
+          );
+        })
+      ]
+    }
+  );
+}
+var STEP = {
+  SELECT_SLOT: "select-slot",
+  SELECT_RESOURCE: "select-resource",
+  SELECT_STAFF: "select-staff",
+  CONFIRM: "confirm"
+};
 function BookingPage({
   service,
   product,
   staff,
+  resources,
   participantCount,
   title,
   onBooked,
@@ -9280,12 +7789,14 @@ function BookingPage({
   const { addItem } = useCart();
   const { client } = useCimplifyClient();
   const isReschedule = existingBooking !== void 0;
-  const [step, setStep] = React3.useState("select-slot");
+  const [step, setStep] = React3.useState(STEP.SELECT_SLOT);
   const [selectedSlot, setSelectedSlot] = React3.useState(null);
   const [selectedDate, setSelectedDate] = React3.useState(null);
   const [selectedStaffId, setSelectedStaffId] = React3.useState(null);
+  const [selectedResourceId, setSelectedResourceId] = React3.useState(null);
   const [isSubmitting, setIsSubmitting] = React3.useState(false);
   const [error, setError] = React3.useState(null);
+  const hasResourceStep = resources && resources.length > 0;
   const hasStaffStep = staff && staff.length > 0;
   const depositType = product?.deposit_type;
   const depositAmount = product?.deposit_amount;
@@ -9297,28 +7808,45 @@ function BookingPage({
       setSelectedSlot(slot);
       setSelectedDate(date);
       setError(null);
+      if (hasResourceStep) {
+        setStep(STEP.SELECT_RESOURCE);
+      } else if (hasStaffStep) {
+        setStep(STEP.SELECT_STAFF);
+      } else {
+        setStep(STEP.CONFIRM);
+      }
+    },
+    [hasResourceStep, hasStaffStep]
+  );
+  const handleResourceSelect = React3.useCallback(
+    (resourceId) => {
+      setSelectedResourceId(resourceId);
       if (hasStaffStep) {
-        setStep("select-staff");
+        setStep(STEP.SELECT_STAFF);
       } else {
-        setStep("confirm");
+        setStep(STEP.CONFIRM);
       }
     },
     [hasStaffStep]
   );
   const handleStaffSelect = React3.useCallback((staffId) => {
     setSelectedStaffId(staffId);
-    setStep("confirm");
+    setStep(STEP.CONFIRM);
   }, []);
   const handleBack = React3.useCallback(() => {
     setError(null);
-    if (step === "confirm" && hasStaffStep) {
-      setStep("select-staff");
-    } else if (step === "confirm" || step === "select-staff") {
-      setStep("select-slot");
+    if (step === STEP.CONFIRM && hasStaffStep) {
+      setStep(STEP.SELECT_STAFF);
+    } else if (step === STEP.CONFIRM && hasResourceStep) {
+      setStep(STEP.SELECT_RESOURCE);
+    } else if (step === STEP.SELECT_STAFF && hasResourceStep) {
+      setStep(STEP.SELECT_RESOURCE);
+    } else if (step === STEP.CONFIRM || step === STEP.SELECT_STAFF || step === STEP.SELECT_RESOURCE) {
+      setStep(STEP.SELECT_SLOT);
     } else {
       onBack?.();
     }
-  }, [step, hasStaffStep, onBack]);
+  }, [step, hasStaffStep, hasResourceStep, onBack]);
   const handleConfirm = React3.useCallback(async () => {
     if (!selectedSlot || !selectedDate) return;
     setIsSubmitting(true);
@@ -9358,7 +7886,8 @@ function BookingPage({
         await addItem(serviceProduct, 1, {
           scheduledStart: selectedSlot.start_time,
           scheduledEnd: selectedSlot.end_time,
-          staffId: selectedStaffId || void 0
+          staffId: selectedStaffId || void 0,
+          resourceId: selectedResourceId || void 0
         });
         onBooked?.(selectedSlot, selectedStaffId);
       }
@@ -9371,7 +7900,7 @@ function BookingPage({
   }, [selectedSlot, selectedDate, selectedStaffId, service, addItem, onBooked, isReschedule, existingBooking, client, onRescheduled]);
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-page": true, className: cn(className, classNames?.root), children: [
     /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-page-header": true, className: classNames?.header, children: [
-      onBack && step === "select-slot" && /* @__PURE__ */ jsxRuntime.jsx(
+      onBack && step === STEP.SELECT_SLOT && /* @__PURE__ */ jsxRuntime.jsx(
         "button",
         {
           type: "button",
@@ -9381,7 +7910,7 @@ function BookingPage({
           children: "Back"
         }
       ),
-      step !== "select-slot" && /* @__PURE__ */ jsxRuntime.jsx(
+      step !== STEP.SELECT_SLOT && /* @__PURE__ */ jsxRuntime.jsx(
         "button",
         {
           type: "button",
@@ -9416,7 +7945,7 @@ function BookingPage({
       ] })
     ] }),
     error && /* @__PURE__ */ jsxRuntime.jsx("div", { "data-cimplify-booking-error": true, className: classNames?.error, children: error }),
-    step === "select-slot" && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-step": "select-slot", className: classNames?.step, children: [
+    step === STEP.SELECT_SLOT && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-step": "select-slot", className: classNames?.step, children: [
       /* @__PURE__ */ jsxRuntime.jsx("h2", { "data-cimplify-booking-step-title": true, className: classNames?.stepTitle, children: "Select a date & time" }),
       /* @__PURE__ */ jsxRuntime.jsx(
         DateSlotPicker,
@@ -9429,7 +7958,18 @@ function BookingPage({
         }
       )
     ] }),
-    step === "select-staff" && staff && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-step": "select-staff", className: classNames?.step, children: [
+    step === STEP.SELECT_RESOURCE && resources && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-step": "select-resource", className: cn(classNames?.step, classNames?.resourceStep), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h2", { "data-cimplify-booking-step-title": true, className: classNames?.stepTitle, children: "Choose a room" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ResourcePicker,
+        {
+          resources,
+          selectedResourceId,
+          onResourceSelect: handleResourceSelect
+        }
+      )
+    ] }),
+    step === STEP.SELECT_STAFF && staff && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-step": "select-staff", className: classNames?.step, children: [
       /* @__PURE__ */ jsxRuntime.jsx("h2", { "data-cimplify-booking-step-title": true, className: classNames?.stepTitle, children: "Choose a provider" }),
       /* @__PURE__ */ jsxRuntime.jsx(
         StaffPicker,
@@ -9440,7 +7980,7 @@ function BookingPage({
         }
       )
     ] }),
-    step === "confirm" && selectedSlot && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-step": "confirm", className: classNames?.step, children: [
+    step === STEP.CONFIRM && selectedSlot && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-step": "confirm", className: classNames?.step, children: [
       /* @__PURE__ */ jsxRuntime.jsx("h2", { "data-cimplify-booking-step-title": true, className: classNames?.stepTitle, children: "Confirm your booking" }),
       /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-summary": true, className: classNames?.summary, children: [
         /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-summary-row": true, className: classNames?.summaryRow, children: [
@@ -9462,6 +8002,10 @@ function BookingPage({
           /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Duration" }),
           /* @__PURE__ */ jsxRuntime.jsx("span", { children: formatDuration2(service.duration_minutes, service.duration_unit) })
         ] }),
+        selectedResourceId && resources && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-summary-row": true, className: classNames?.summaryRow, children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Room" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: resources.find((r) => r.id === selectedResourceId)?.name ?? "Selected" })
+        ] }),
         selectedStaffId && staff && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-cimplify-booking-summary-row": true, className: classNames?.summaryRow, children: [
           /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Provider" }),
           /* @__PURE__ */ jsxRuntime.jsx("span", { children: staff.find((s) => s.id === selectedStaffId)?.name ?? "Selected" })
@@ -10079,6 +8623,7 @@ exports.ProductSheet = ProductSheet;
 exports.QuantitySelector = QuantitySelector;
 exports.RecentlyViewed = RecentlyViewed;
 exports.RecommendationCarousel = RecommendationCarousel;
+exports.ResourcePicker = ResourcePicker;
 exports.SaleBadge = SaleBadge;
 exports.SearchInput = SearchInput;
 exports.SearchPage = SearchPage;
@@ -10090,6 +8635,7 @@ exports.StaffPicker = StaffPicker;
 exports.StoreNav = StoreNav;
 exports.VariantSelector = VariantSelector;
 exports.cn = cn;
+exports.roomToResource = roomToResource;
 exports.useActivityState = useActivityState;
 exports.useAds = useAds;
 exports.useAttributeDefinitions = useAttributeDefinitions;