@cimplify/sdk 0.6.5 → 0.6.7

package/dist/react.mjs

@@ -1,4 +1,4 @@
-import { createContext, useContext, useState, useEffect, useRef, useMemo, useCallback } from 'react';
+import { createContext, useContext, useState, useEffect, useRef, useMemo, useCallback, useSyncExternalStore } from 'react';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 
 // src/react/index.tsx
@@ -9,6 +9,27 @@ var ELEMENT_TYPES = {
   ADDRESS: "address",
   PAYMENT: "payment"
 };
+var MESSAGE_TYPES = {
+  // Parent → Iframe
+  INIT: "init",
+  SET_TOKEN: "set_token",
+  GET_DATA: "get_data",
+  PROCESS_CHECKOUT: "process_checkout",
+  ABORT_CHECKOUT: "abort_checkout",
+  // Iframe → Parent
+  READY: "ready",
+  HEIGHT_CHANGE: "height_change",
+  AUTHENTICATED: "authenticated",
+  REQUIRES_OTP: "requires_otp",
+  ERROR: "error",
+  ADDRESS_CHANGED: "address_changed",
+  ADDRESS_SELECTED: "address_selected",
+  PAYMENT_METHOD_SELECTED: "payment_method_selected",
+  TOKEN_REFRESHED: "token_refreshed",
+  LOGOUT_COMPLETE: "logout_complete",
+  CHECKOUT_STATUS: "checkout_status",
+  CHECKOUT_COMPLETE: "checkout_complete"
+};
 var EVENT_TYPES = {
   READY: "ready",
   AUTHENTICATED: "authenticated",
@@ -362,6 +383,7 @@ function CimplifyCheckout({
   onError,
   onStatusChange,
   appearance,
+  demoMode,
   className
 }) {
   const resolvedOrderTypes = useMemo(
@@ -370,20 +392,131 @@ function CimplifyCheckout({
   );
   const [orderType, setOrderType] = useState(resolvedOrderTypes[0] || "pickup");
   const [status, setStatus] = useState(null);
+  const [statusText, setStatusText] = useState("");
   const [isSubmitting, setIsSubmitting] = useState(false);
+  const [isInitializing, setIsInitializing] = useState(false);
   const [errorMessage, setErrorMessage] = useState(null);
+  const [resolvedBusinessId, setResolvedBusinessId] = useState(businessId ?? null);
+  const [resolvedCartId, setResolvedCartId] = useState(cartId ?? null);
   const authMountRef = useRef(null);
   const addressMountRef = useRef(null);
   const paymentMountRef = useRef(null);
   const elementsRef = useRef(null);
   const activeCheckoutRef = useRef(null);
+  const initialAppearanceRef = useRef(appearance);
+  const hasWarnedInlineAppearanceRef = useRef(false);
+  const isMountedRef = useRef(true);
+  const demoRunRef = useRef(0);
+  const isDemoCheckout = demoMode ?? client.getPublicKey().trim().length === 0;
+  const isTestMode = client.isTestMode();
+  const emitStatus = useCallback(
+    (nextStatus, context = {}) => {
+      setStatus(nextStatus);
+      setStatusText(context.display_text || "");
+      onStatusChange?.(nextStatus, context);
+    },
+    [onStatusChange]
+  );
   useEffect(() => {
     if (!resolvedOrderTypes.includes(orderType)) {
       setOrderType(resolvedOrderTypes[0] || "pickup");
     }
   }, [resolvedOrderTypes, orderType]);
   useEffect(() => {
-    const elements = client.elements(businessId, { appearance });
+    if (appearance && appearance !== initialAppearanceRef.current && !hasWarnedInlineAppearanceRef.current) {
+      hasWarnedInlineAppearanceRef.current = true;
+      console.warn(
+        "[Cimplify] `appearance` prop reference changed after mount. Elements keep the initial appearance to avoid iframe remount. Memoize appearance with useMemo() to remove this warning."
+      );
+    }
+  }, [appearance]);
+  useEffect(() => {
+    let cancelled = false;
+    async function bootstrap() {
+      if (isDemoCheckout) {
+        if (!cancelled) {
+          setResolvedBusinessId(businessId ?? null);
+          setResolvedCartId(cartId ?? "cart_demo");
+          setIsInitializing(false);
+          setErrorMessage(null);
+        }
+        return;
+      }
+      const needsBusinessResolve = !businessId;
+      const needsCartResolve = !cartId;
+      if (!needsBusinessResolve && !needsCartResolve) {
+        if (!cancelled) {
+          setResolvedBusinessId(businessId || null);
+          setResolvedCartId(cartId || null);
+          setIsInitializing(false);
+          setErrorMessage(null);
+        }
+        return;
+      }
+      if (!cancelled) {
+        setIsInitializing(true);
+        setErrorMessage(null);
+      }
+      let nextBusinessId = businessId ?? null;
+      if (!nextBusinessId) {
+        try {
+          nextBusinessId = await client.resolveBusinessId();
+        } catch {
+          if (!cancelled) {
+            const message = "Unable to initialize checkout business context.";
+            setResolvedBusinessId(null);
+            setResolvedCartId(null);
+            setErrorMessage(message);
+            setIsInitializing(false);
+            onError?.({ code: "BUSINESS_ID_REQUIRED", message });
+          }
+          return;
+        }
+      }
+      let nextCartId = cartId ?? null;
+      if (!nextCartId) {
+        const cartResult = await client.cart.get();
+        if (!cartResult.ok || !cartResult.value?.id || cartResult.value.items.length === 0) {
+          if (!cancelled) {
+            const message = "Your cart is empty. Add items before checkout.";
+            setResolvedBusinessId(nextBusinessId);
+            setResolvedCartId(null);
+            setErrorMessage(message);
+            setIsInitializing(false);
+            onError?.({ code: "CART_EMPTY", message });
+          }
+          return;
+        }
+        nextCartId = cartResult.value.id;
+      }
+      if (!cancelled) {
+        setResolvedBusinessId(nextBusinessId);
+        setResolvedCartId(nextCartId);
+        setIsInitializing(false);
+        setErrorMessage(null);
+      }
+    }
+    void bootstrap();
+    return () => {
+      cancelled = true;
+    };
+  }, [businessId, cartId, client, isDemoCheckout, onError]);
+  useEffect(() => {
+    return () => {
+      isMountedRef.current = false;
+      demoRunRef.current += 1;
+      activeCheckoutRef.current?.abort();
+      activeCheckoutRef.current = null;
+    };
+  }, []);
+  useEffect(() => {
+    if (isDemoCheckout || !resolvedBusinessId) {
+      elementsRef.current = null;
+      return;
+    }
+    const elements = client.elements(resolvedBusinessId, {
+      appearance: initialAppearanceRef.current
+    });
     elementsRef.current = elements;
     const auth = elements.create("auth");
     const address = elements.create("address", { mode: "shipping" });
@@ -403,27 +536,68 @@ function CimplifyCheckout({
       elements.destroy();
       elementsRef.current = null;
     };
-  }, [client, businessId, appearance]);
-  const handleStatusChange = useCallback(
-    (nextStatus, context) => {
-      setStatus(nextStatus);
-      onStatusChange?.(nextStatus, context);
-    },
-    [onStatusChange]
-  );
+  }, [client, resolvedBusinessId, isDemoCheckout]);
   const handleSubmit = useCallback(async () => {
-    if (!elementsRef.current || isSubmitting) {
+    if (isSubmitting || isInitializing || !resolvedCartId) {
+      if (!resolvedCartId && !isInitializing) {
+        const message = "Your cart is empty. Add items before checkout.";
+        setErrorMessage(message);
+        onError?.({ code: "CART_EMPTY", message });
+      }
       return;
     }
     setErrorMessage(null);
     setIsSubmitting(true);
-    setStatus("preparing");
+    emitStatus("preparing", { display_text: statusToLabel("preparing") });
+    if (isDemoCheckout) {
+      const runId = demoRunRef.current + 1;
+      demoRunRef.current = runId;
+      const wait = async (ms) => {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+        return isMountedRef.current && runId === demoRunRef.current;
+      };
+      try {
+        if (!await wait(400)) return;
+        emitStatus("processing", { display_text: statusToLabel("processing") });
+        if (!await wait(900)) return;
+        emitStatus("polling", { display_text: statusToLabel("polling") });
+        if (!await wait(1200)) return;
+        const result = {
+          success: true,
+          order: {
+            id: `ord_demo_${Date.now()}`,
+            order_number: `DEMO-${Math.random().toString(36).slice(2, 8).toUpperCase()}`,
+            status: "confirmed",
+            total: "0.00",
+            currency: "USD"
+          }
+        };
+        emitStatus("success", {
+          order_id: result.order?.id,
+          order_number: result.order?.order_number,
+          display_text: statusToLabel("success")
+        });
+        onComplete(result);
+      } finally {
+        if (isMountedRef.current && runId === demoRunRef.current) {
+          setIsSubmitting(false);
+        }
+      }
+      return;
+    }
+    if (!elementsRef.current) {
+      const message = "Checkout is still initializing. Please try again.";
+      setErrorMessage(message);
+      onError?.({ code: "CHECKOUT_NOT_READY", message });
+      setIsSubmitting(false);
+      return;
+    }
     const checkout = elementsRef.current.processCheckout({
-      cart_id: cartId,
-      location_id: locationId,
+      cart_id: resolvedCartId,
+      location_id: locationId ?? client.getLocationId() ?? void 0,
       order_type: orderType,
       enroll_in_link: enrollInLink,
-      on_status_change: handleStatusChange
+      on_status_change: emitStatus
     });
     activeCheckoutRef.current = checkout;
     try {
@@ -437,21 +611,45 @@ function CimplifyCheckout({
       setErrorMessage(message);
       onError?.({ code, message });
     } finally {
-      activeCheckoutRef.current = null;
-      setIsSubmitting(false);
+      if (isMountedRef.current) {
+        activeCheckoutRef.current = null;
+        setIsSubmitting(false);
+      }
     }
   }, [
-    cartId,
+    resolvedCartId,
+    client,
     enrollInLink,
-    handleStatusChange,
+    emitStatus,
+    isDemoCheckout,
+    isInitializing,
     isSubmitting,
     locationId,
     onComplete,
     onError,
     orderType
   ]);
+  if (isInitializing) {
+    return /* @__PURE__ */ jsx("div", { className, "data-cimplify-checkout": "", children: /* @__PURE__ */ jsx("p", { "data-cimplify-status": "", style: { fontSize: "14px", color: "#52525b" }, children: "Preparing checkout..." }) });
+  }
+  if (!isDemoCheckout && (!resolvedBusinessId || !resolvedCartId)) {
+    return /* @__PURE__ */ jsx("div", { className, "data-cimplify-checkout": "", children: /* @__PURE__ */ jsx("p", { "data-cimplify-error": "", style: { fontSize: "14px", color: "#b91c1c" }, children: errorMessage || "Unable to initialize checkout. Please refresh and try again." }) });
+  }
   return /* @__PURE__ */ jsxs("div", { className, "data-cimplify-checkout": "", children: [
-    /* @__PURE__ */ jsx("div", { "data-cimplify-section": "auth", children: /* @__PURE__ */ jsx("div", { ref: authMountRef }) }),
+    isTestMode && !isDemoCheckout && /* @__PURE__ */ jsx(
+      "p",
+      {
+        "data-cimplify-test-mode": "",
+        style: {
+          marginBottom: "10px",
+          fontSize: "12px",
+          fontWeight: 600,
+          color: "#92400e"
+        },
+        children: "Test mode - no real charges"
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { "data-cimplify-section": "auth", children: /* @__PURE__ */ jsx("div", { ref: isDemoCheckout ? void 0 : authMountRef }) }),
     /* @__PURE__ */ jsx("div", { "data-cimplify-section": "order-type", style: { marginTop: "12px" }, children: /* @__PURE__ */ jsx(
       "div",
       {
@@ -485,10 +683,10 @@ function CimplifyCheckout({
       {
         "data-cimplify-section": "address",
         style: { marginTop: "12px", display: orderType === "delivery" ? "block" : "none" },
-        children: /* @__PURE__ */ jsx("div", { ref: addressMountRef })
+        children: /* @__PURE__ */ jsx("div", { ref: isDemoCheckout ? void 0 : addressMountRef })
       }
     ),
-    /* @__PURE__ */ jsx("div", { "data-cimplify-section": "payment", style: { marginTop: "12px" }, children: /* @__PURE__ */ jsx("div", { ref: paymentMountRef }) }),
+    /* @__PURE__ */ jsx("div", { "data-cimplify-section": "payment", style: { marginTop: "12px" }, children: /* @__PURE__ */ jsx("div", { ref: isDemoCheckout ? void 0 : paymentMountRef }) }),
     /* @__PURE__ */ jsx("div", { style: { marginTop: "12px" }, children: /* @__PURE__ */ jsx(
       "button",
       {
@@ -507,34 +705,4433 @@ function CimplifyCheckout({
         children: isSubmitting ? "Processing..." : "Complete Order"
       }
     ) }),
-    status && /* @__PURE__ */ jsx("p", { "data-cimplify-status": "", style: { marginTop: "10px", fontSize: "14px", color: "#52525b" }, children: statusToLabel(status) }),
+    status && /* @__PURE__ */ jsx("p", { "data-cimplify-status": "", style: { marginTop: "10px", fontSize: "14px", color: "#52525b" }, children: statusText || statusToLabel(status) }),
     errorMessage && /* @__PURE__ */ jsx("p", { "data-cimplify-error": "", style: { marginTop: "8px", fontSize: "14px", color: "#b91c1c" }, children: errorMessage })
   ] });
 }
-var ElementsContext = createContext({
-  elements: null,
-  isReady: false
-});
-function useElements() {
-  return useContext(ElementsContext).elements;
+
+// src/types/common.ts
+var ErrorCode = {
+  // General
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  TIMEOUT: "TIMEOUT",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  NOT_FOUND: "NOT_FOUND"};
+var DOCS_ERROR_BASE_URL = "https://docs.cimplify.io/reference/error-codes";
+function docsUrlForCode(code) {
+  return `${DOCS_ERROR_BASE_URL}#${code.toLowerCase().replace(/_/g, "-")}`;
 }
-function useElementsReady() {
-  return useContext(ElementsContext).isReady;
+var ERROR_SUGGESTIONS = {
+  UNKNOWN_ERROR: "An unexpected error occurred. Capture the request/response payload and retry with exponential backoff.",
+  NETWORK_ERROR: "Check the shopper's connection and retry. If this persists, inspect CORS, DNS, and API reachability.",
+  TIMEOUT: "The request exceeded the timeout. Retry once, then poll order status before charging again.",
+  UNAUTHORIZED: "Authentication is missing or expired. Ensure a valid access token is set and refresh the session if needed.",
+  FORBIDDEN: "The key/session lacks permission for this resource. Verify business ownership and API key scope.",
+  NOT_FOUND: "The requested resource does not exist or is not visible in this environment.",
+  VALIDATION_ERROR: "One or more fields are invalid. Validate required fields and enum values before retrying.",
+  CART_EMPTY: "The cart has no items. Redirect back to menu/catalogue and require at least one line item.",
+  CART_EXPIRED: "This cart is no longer active. Recreate a new cart and re-add shopper selections.",
+  CART_NOT_FOUND: "Cart could not be located. It may have expired or belongs to a different key/location.",
+  ITEM_UNAVAILABLE: "The selected item is unavailable at this location/time. Prompt the shopper to pick an alternative.",
+  VARIANT_NOT_FOUND: "The requested variant no longer exists. Refresh product data and require re-selection.",
+  VARIANT_OUT_OF_STOCK: "The selected variant is out of stock. Show in-stock variants and block checkout for this line.",
+  ADDON_REQUIRED: "A required add-on is missing. Ensure required modifier groups are completed before add-to-cart.",
+  ADDON_MAX_EXCEEDED: "Too many add-ons were selected. Enforce max selections client-side before submission.",
+  CHECKOUT_VALIDATION_FAILED: "Checkout payload failed validation. Verify customer, order type, and address fields are complete.",
+  DELIVERY_ADDRESS_REQUIRED: "Delivery orders require an address. Collect and pass address info before processing checkout.",
+  CUSTOMER_INFO_REQUIRED: "Customer details are required. Ensure name/email/phone are available before checkout.",
+  PAYMENT_FAILED: "Payment provider rejected or failed processing. Show retry/change-method options to the shopper.",
+  PAYMENT_CANCELLED: "Payment was cancelled by the shopper or provider flow. Allow a safe retry path.",
+  INSUFFICIENT_FUNDS: "Payment method has insufficient funds. Prompt shopper to use another method.",
+  CARD_DECLINED: "Card was declined. Ask shopper to retry or switch payment method.",
+  INVALID_OTP: "Authorization code is invalid. Let shopper re-enter OTP/PIN and retry.",
+  OTP_EXPIRED: "Authorization code expired. Request a new OTP and re-submit authorization.",
+  AUTHORIZATION_FAILED: "Additional payment authorization failed. Retry authorization or change payment method.",
+  PAYMENT_ACTION_NOT_COMPLETED: "Required payment action was not completed. Resume provider flow and poll for status.",
+  SLOT_UNAVAILABLE: "Selected schedule slot is unavailable. Refresh available slots and ask shopper to reselect.",
+  BOOKING_CONFLICT: "The requested booking conflicts with an existing reservation. Pick another slot/resource.",
+  SERVICE_NOT_FOUND: "Requested service no longer exists. Refresh service catalogue and retry selection.",
+  OUT_OF_STOCK: "Inventory is depleted for this item. Remove it or reduce quantity before checkout.",
+  INSUFFICIENT_QUANTITY: "Requested quantity exceeds available inventory. Reduce quantity and retry.",
+  BUSINESS_ID_REQUIRED: "Business context could not be resolved. Verify the public key and business bootstrap call.",
+  INVALID_CART: "Cart is invalid for checkout. Sync cart state, ensure items exist, then retry.",
+  ORDER_TYPE_REQUIRED: "Order type is required. Provide one of delivery, pickup, or dine_in before checkout.",
+  NO_PAYMENT_ELEMENT: "PaymentElement is required for processCheckout(). Mount it before triggering checkout.",
+  PAYMENT_NOT_MOUNTED: "PaymentElement iframe is not mounted. Mount it in the DOM before processCheckout().",
+  AUTH_INCOMPLETE: "AuthElement has not completed authentication. Wait for AUTHENTICATED before checkout.",
+  AUTH_LOST: "Session was cleared during checkout. Re-authenticate and restart checkout safely.",
+  ALREADY_PROCESSING: "Checkout is already in progress. Disable duplicate submits until completion.",
+  CHECKOUT_NOT_READY: "Checkout elements are still initializing. Wait for readiness before submit.",
+  CANCELLED: "Checkout was cancelled. Preserve cart state and allow shopper to retry.",
+  REQUEST_TIMEOUT: "Provider call timed out. Poll payment/order status before issuing another charge attempt.",
+  POPUP_BLOCKED: "Browser blocked provider popup. Ask shopper to enable popups and retry.",
+  FX_QUOTE_FAILED: "Failed to lock FX quote. Retry currency quote or fallback to base currency."
+};
+var ERROR_HINTS = Object.fromEntries(
+  Object.entries(ERROR_SUGGESTIONS).map(([code, suggestion]) => [
+    code,
+    {
+      docs_url: docsUrlForCode(code),
+      suggestion
+    }
+  ])
+);
+var CimplifyError = class extends Error {
+  constructor(code, message, retryable = false, docs_url, suggestion) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.docs_url = docs_url;
+    this.suggestion = suggestion;
+    this.name = "CimplifyError";
+  }
+  /** User-friendly message safe to display */
+  get userMessage() {
+    return this.message;
+  }
+};
+function getErrorHint(code) {
+  return ERROR_HINTS[code];
 }
-function ElementsProvider({
-  client,
-  businessId,
-  options,
-  children
-}) {
-  const [elements, setElements] = useState(null);
-  const [isReady, setIsReady] = useState(false);
-  useEffect(() => {
-    const instance = client.elements(businessId, options);
-    setElements(instance);
-    setIsReady(true);
-    return () => instance.destroy();
-  }, [client, businessId, options]);
+function enrichError(error, options = {}) {
+  const hint = getErrorHint(error.code);
+  if (hint) {
+    if (!error.docs_url) {
+      error.docs_url = hint.docs_url;
+    }
+    if (!error.suggestion) {
+      error.suggestion = hint.suggestion;
+    }
+  } else if (!error.docs_url) {
+    error.docs_url = docsUrlForCode(error.code || ErrorCode.UNKNOWN_ERROR);
+  }
+  if (options.isTestMode && !error.message.includes("pk_test_")) {
+    error.message = `${error.message}
+
+\u2139 Your API key is a test-mode key (pk_test_...). Verify test data/session before retrying.`;
+  }
+  return error;
+}
+
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// src/catalogue.ts
+function toCimplifyError(error) {
+  if (error instanceof CimplifyError) return enrichError(error);
+  if (error instanceof Error) {
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
+  }
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
+}
+async function safe(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError(error));
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readFinalPrice(value) {
+  if (!isRecord(value)) return void 0;
+  const finalPrice = value.final_price;
+  if (typeof finalPrice === "string" || typeof finalPrice === "number") {
+    return finalPrice;
+  }
+  return void 0;
+}
+function normalizeCatalogueProductPayload(product) {
+  const normalized = { ...product };
+  const defaultPrice = normalized["default_price"];
+  if (defaultPrice === void 0 || defaultPrice === null || defaultPrice === "") {
+    const derivedDefaultPrice = readFinalPrice(normalized["default_price_info"]) || readFinalPrice(normalized["price_info"]) || (typeof normalized["final_price"] === "string" || typeof normalized["final_price"] === "number" ? normalized["final_price"] : void 0);
+    normalized["default_price"] = derivedDefaultPrice ?? "0";
+  }
+  const variants = normalized["variants"];
+  if (Array.isArray(variants)) {
+    normalized["variants"] = variants.map((variant) => {
+      if (!isRecord(variant)) return variant;
+      const normalizedVariant = { ...variant };
+      const variantAdjustment = normalizedVariant["price_adjustment"];
+      if (variantAdjustment === void 0 || variantAdjustment === null || variantAdjustment === "") {
+        normalizedVariant["price_adjustment"] = readFinalPrice(normalizedVariant["price_info"]) ?? "0";
+      }
+      return normalizedVariant;
+    });
+  }
+  const addOns = normalized["add_ons"];
+  if (Array.isArray(addOns)) {
+    normalized["add_ons"] = addOns.map((addOn) => {
+      if (!isRecord(addOn)) return addOn;
+      const normalizedAddOn = { ...addOn };
+      const options = normalizedAddOn["options"];
+      if (!Array.isArray(options)) return normalizedAddOn;
+      normalizedAddOn["options"] = options.map((option) => {
+        if (!isRecord(option)) return option;
+        const normalizedOption = { ...option };
+        const optionPrice = normalizedOption["default_price"];
+        if (optionPrice === void 0 || optionPrice === null || optionPrice === "") {
+          normalizedOption["default_price"] = readFinalPrice(normalizedOption["default_price_info"]) || readFinalPrice(normalizedOption["price_info"]) || "0";
+        }
+        return normalizedOption;
+      });
+      return normalizedAddOn;
+    });
+  }
+  return normalized;
+}
+function findProductBySlug(products, slug) {
+  return products.find((product) => {
+    const value = product["slug"];
+    return typeof value === "string" && value === slug;
+  });
+}
+var CatalogueQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getProducts(options) {
+    let query = "products";
+    const filters = [];
+    if (options?.category) {
+      filters.push(`@.category_id=='${options.category}'`);
+    }
+    if (options?.featured !== void 0) {
+      filters.push(`@.featured==${options.featured}`);
+    }
+    if (options?.in_stock !== void 0) {
+      filters.push(`@.in_stock==${options.in_stock}`);
+    }
+    if (options?.search) {
+      filters.push(`@.name contains '${options.search}'`);
+    }
+    if (options?.min_price !== void 0) {
+      filters.push(`@.price>=${options.min_price}`);
+    }
+    if (options?.max_price !== void 0) {
+      filters.push(`@.price<=${options.max_price}`);
+    }
+    if (filters.length > 0) {
+      query += `[?(${filters.join(" && ")})]`;
+    }
+    if (options?.sort_by) {
+      query += `#sort(${options.sort_by},${options.sort_order || "asc"})`;
+    }
+    if (options?.limit) {
+      query += `#limit(${options.limit})`;
+    }
+    if (options?.offset) {
+      query += `#offset(${options.offset})`;
+    }
+    const result = await safe(this.client.query(query));
+    if (!result.ok) return result;
+    return ok(result.value.map((product) => normalizeCatalogueProductPayload(product)));
+  }
+  async getProduct(id) {
+    const result = await safe(this.client.query(`products.${id}`));
+    if (!result.ok) return result;
+    return ok(normalizeCatalogueProductPayload(result.value));
+  }
+  async getProductBySlug(slug) {
+    const filteredResult = await safe(
+      this.client.query(`products[?(@.slug=='${slug}')]`)
+    );
+    if (!filteredResult.ok) return filteredResult;
+    const exactMatch = findProductBySlug(filteredResult.value, slug);
+    if (exactMatch) {
+      return ok(normalizeCatalogueProductPayload(exactMatch));
+    }
+    if (filteredResult.value.length === 1) {
+      return ok(normalizeCatalogueProductPayload(filteredResult.value[0]));
+    }
+    const unfilteredResult = await safe(this.client.query("products"));
+    if (!unfilteredResult.ok) return unfilteredResult;
+    const fallbackMatch = findProductBySlug(unfilteredResult.value, slug);
+    if (!fallbackMatch) {
+      return err(new CimplifyError("NOT_FOUND", `Product not found: ${slug}`, false));
+    }
+    return ok(normalizeCatalogueProductPayload(fallbackMatch));
+  }
+  async getVariants(productId) {
+    return safe(this.client.query(`products.${productId}.variants`));
+  }
+  async getVariantAxes(productId) {
+    return safe(this.client.query(`products.${productId}.variant_axes`));
+  }
+  /**
+   * Find a variant by axis selections (e.g., { "Size": "Large", "Color": "Red" })
+   * Returns the matching variant or null if no match found.
+   */
+  async getVariantByAxisSelections(productId, selections) {
+    return safe(
+      this.client.query(`products.${productId}.variant`, {
+        axis_selections: selections
+      })
+    );
+  }
+  /**
+   * Get a specific variant by its ID
+   */
+  async getVariantById(productId, variantId) {
+    return safe(this.client.query(`products.${productId}.variant.${variantId}`));
+  }
+  async getAddOns(productId) {
+    return safe(this.client.query(`products.${productId}.add_ons`));
+  }
+  async getCategories() {
+    return safe(this.client.query("categories"));
+  }
+  async getCategory(id) {
+    return safe(this.client.query(`categories.${id}`));
+  }
+  async getCategoryBySlug(slug) {
+    const result = await safe(
+      this.client.query(`categories[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Category not found: ${slug}`, false));
+    }
+    return ok(result.value[0]);
+  }
+  async getCategoryProducts(categoryId) {
+    return safe(this.client.query(`products[?(@.category_id=='${categoryId}')]`));
+  }
+  async getCollections() {
+    return safe(this.client.query("collections"));
+  }
+  async getCollection(id) {
+    return safe(this.client.query(`collections.${id}`));
+  }
+  async getCollectionBySlug(slug) {
+    const result = await safe(
+      this.client.query(`collections[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Collection not found: ${slug}`, false));
+    }
+    return ok(result.value[0]);
+  }
+  async getCollectionProducts(collectionId) {
+    return safe(this.client.query(`collections.${collectionId}.products`));
+  }
+  async searchCollections(query, limit = 20) {
+    return safe(
+      this.client.query(`collections[?(@.name contains '${query}')]#limit(${limit})`)
+    );
+  }
+  async getBundles() {
+    return safe(this.client.query("bundles"));
+  }
+  async getBundle(id) {
+    return safe(this.client.query(`bundles.${id}`));
+  }
+  async getBundleBySlug(slug) {
+    const result = await safe(
+      this.client.query(`bundles[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Bundle not found: ${slug}`, false));
+    }
+    return ok(result.value[0]);
+  }
+  async searchBundles(query, limit = 20) {
+    return safe(
+      this.client.query(`bundles[?(@.name contains '${query}')]#limit(${limit})`)
+    );
+  }
+  async getComposites(options) {
+    let query = "composites";
+    if (options?.limit) {
+      query += `#limit(${options.limit})`;
+    }
+    return safe(this.client.query(query));
+  }
+  async getComposite(id) {
+    return safe(this.client.query(`composites.${id}`));
+  }
+  async getCompositeByProductId(productId) {
+    return safe(this.client.query(`composites.by_product.${productId}`));
+  }
+  async calculateCompositePrice(compositeId, selections, locationId) {
+    return safe(
+      this.client.call("composite.calculatePrice", {
+        composite_id: compositeId,
+        selections,
+        location_id: locationId
+      })
+    );
+  }
+  async fetchQuote(input) {
+    return safe(this.client.call("catalogue.createQuote", input));
+  }
+  async getQuote(quoteId) {
+    return safe(
+      this.client.call("catalogue.getQuote", {
+        quote_id: quoteId
+      })
+    );
+  }
+  async refreshQuote(input) {
+    return safe(this.client.call("catalogue.refreshQuote", input));
+  }
+  async search(query, options) {
+    const limit = options?.limit ?? 20;
+    let searchQuery = `products[?(@.name contains '${query}')]`;
+    if (options?.category) {
+      searchQuery = `products[?(@.name contains '${query}' && @.category_id=='${options.category}')]`;
+    }
+    searchQuery += `#limit(${limit})`;
+    return safe(this.client.query(searchQuery));
+  }
+  async searchProducts(query, options) {
+    return safe(
+      this.client.call("catalogue.search", {
+        query,
+        limit: options?.limit ?? 20,
+        category: options?.category
+      })
+    );
+  }
+  async getMenu(options) {
+    let query = "menu";
+    if (options?.category) {
+      query = `menu[?(@.category=='${options.category}')]`;
+    }
+    if (options?.limit) {
+      query += `#limit(${options.limit})`;
+    }
+    return safe(this.client.query(query));
+  }
+  async getMenuCategory(categoryId) {
+    return safe(this.client.query(`menu.category.${categoryId}`));
+  }
+  async getMenuItem(itemId) {
+    return safe(this.client.query(`menu.${itemId}`));
+  }
+};
+
+// src/cart.ts
+function toCimplifyError2(error) {
+  if (error instanceof CimplifyError) return enrichError(error);
+  if (error instanceof Error) {
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
+  }
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
+}
+async function safe2(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError2(error));
+  }
+}
+function isUICartResponse(value) {
+  return "cart" in value;
+}
+function unwrapEnrichedCart(value) {
+  return isUICartResponse(value) ? value.cart : value;
+}
+var CartOperations = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get() {
+    const result = await safe2(this.client.query("cart#enriched"));
+    if (!result.ok) return result;
+    return ok(unwrapEnrichedCart(result.value));
+  }
+  async getRaw() {
+    return safe2(this.client.query("cart"));
+  }
+  async getItems() {
+    return safe2(this.client.query("cart_items"));
+  }
+  async getCount() {
+    return safe2(this.client.query("cart#count"));
+  }
+  async getTotal() {
+    return safe2(this.client.query("cart#total"));
+  }
+  async getSummary() {
+    const cartResult = await this.get();
+    if (!cartResult.ok) return cartResult;
+    const cart = cartResult.value;
+    return ok({
+      item_count: cart.items.length,
+      total_items: cart.items.reduce((sum, item) => sum + item.quantity, 0),
+      subtotal: cart.pricing.subtotal,
+      discount_amount: cart.pricing.total_discounts,
+      tax_amount: cart.pricing.tax_amount,
+      total: cart.pricing.total_price,
+      currency: cart.pricing.currency
+    });
+  }
+  async addItem(input) {
+    return safe2(this.client.call("cart.addItem", input));
+  }
+  async updateItem(cartItemId, updates) {
+    return safe2(
+      this.client.call("cart.updateItem", {
+        cart_item_id: cartItemId,
+        ...updates
+      })
+    );
+  }
+  async updateQuantity(cartItemId, quantity) {
+    return safe2(
+      this.client.call("cart.updateItemQuantity", {
+        cart_item_id: cartItemId,
+        quantity
+      })
+    );
+  }
+  async removeItem(cartItemId) {
+    return safe2(
+      this.client.call("cart.removeItem", {
+        cart_item_id: cartItemId
+      })
+    );
+  }
+  async clear() {
+    return safe2(this.client.call("cart.clearCart"));
+  }
+  async applyCoupon(code) {
+    return safe2(
+      this.client.call("cart.applyCoupon", {
+        coupon_code: code
+      })
+    );
+  }
+  async removeCoupon() {
+    return safe2(this.client.call("cart.removeCoupon"));
+  }
+  async isEmpty() {
+    const countResult = await this.getCount();
+    if (!countResult.ok) return countResult;
+    return ok(countResult.value === 0);
+  }
+  async hasItem(productId, variantId) {
+    const itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    const found = itemsResult.value.some((item) => {
+      const matchesProduct = item.item_id === productId;
+      if (!variantId) return matchesProduct;
+      const config = item.configuration;
+      if ("variant" in config && config.variant) {
+        return matchesProduct && config.variant.variant_id === variantId;
+      }
+      return matchesProduct;
+    });
+    return ok(found);
+  }
+  async findItem(productId, variantId) {
+    const itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    const found = itemsResult.value.find((item) => {
+      const matchesProduct = item.item_id === productId;
+      if (!variantId) return matchesProduct;
+      const config = item.configuration;
+      if ("variant" in config && config.variant) {
+        return matchesProduct && config.variant.variant_id === variantId;
+      }
+      return matchesProduct;
+    });
+    return ok(found);
+  }
+};
+
+// src/constants.ts
+var LINK_QUERY = {
+  DATA: "link.data",
+  ADDRESSES: "link.addresses",
+  MOBILE_MONEY: "link.mobile_money",
+  PREFERENCES: "link.preferences"};
+var LINK_MUTATION = {
+  CHECK_STATUS: "link.check_status",
+  ENROLL: "link.enroll",
+  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
+  UPDATE_PREFERENCES: "link.update_preferences",
+  CREATE_ADDRESS: "link.create_address",
+  UPDATE_ADDRESS: "link.update_address",
+  DELETE_ADDRESS: "link.delete_address",
+  SET_DEFAULT_ADDRESS: "link.set_default_address",
+  TRACK_ADDRESS_USAGE: "link.track_address_usage",
+  CREATE_MOBILE_MONEY: "link.create_mobile_money",
+  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
+  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
+  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
+  VERIFY_MOBILE_MONEY: "link.verify_mobile_money"};
+var AUTH_MUTATION = {
+  REQUEST_OTP: "auth.request_otp",
+  VERIFY_OTP: "auth.verify_otp"
+};
+var CHECKOUT_MUTATION = {
+  PROCESS: "checkout.process"
+};
+var PAYMENT_MUTATION = {
+  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
+  CHECK_STATUS: "order.poll_payment_status"
+};
+var ORDER_MUTATION = {
+  UPDATE_CUSTOMER: "order.update_order_customer"
+};
+
+// src/utils/price.ts
+function parsePrice(value) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  if (typeof value === "number") {
+    return isNaN(value) ? 0 : value;
+  }
+  const cleaned = value.replace(/[^\d.-]/g, "");
+  const parsed = parseFloat(cleaned);
+  return isNaN(parsed) ? 0 : parsed;
+}
+
+// src/utils/payment.ts
+var PAYMENT_SUCCESS_STATUSES = /* @__PURE__ */ new Set([
+  "success",
+  "succeeded",
+  "paid",
+  "captured",
+  "completed",
+  "authorized"
+]);
+var PAYMENT_FAILURE_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "declined",
+  "cancelled",
+  "voided",
+  "error"
+]);
+var PAYMENT_REQUIRES_ACTION_STATUSES = /* @__PURE__ */ new Set([
+  "requires_action",
+  "requires_payment_method",
+  "requires_capture"
+]);
+var PAYMENT_STATUS_ALIAS_MAP = {
+  ok: "success",
+  done: "success",
+  paid: "paid",
+  paid_in_full: "paid",
+  paid_successfully: "paid",
+  succeeded: "success",
+  captured: "captured",
+  completed: "completed",
+  pending_confirmation: "pending_confirmation",
+  requires_authorization: "requires_action",
+  requires_action: "requires_action",
+  requires_payment_method: "requires_payment_method",
+  requires_capture: "requires_capture",
+  partially_paid: "partially_paid",
+  partially_refunded: "partially_refunded",
+  card_declined: "declined",
+  canceled: "cancelled",
+  authorized: "authorized",
+  cancelled: "cancelled",
+  unresolved: "pending"
+};
+var KNOWN_PAYMENT_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "processing",
+  "created",
+  "pending_confirmation",
+  "success",
+  "succeeded",
+  "failed",
+  "declined",
+  "authorized",
+  "refunded",
+  "partially_refunded",
+  "partially_paid",
+  "paid",
+  "unpaid",
+  "requires_action",
+  "requires_payment_method",
+  "requires_capture",
+  "captured",
+  "cancelled",
+  "completed",
+  "voided",
+  "error",
+  "unknown"
+]);
+function normalizeStatusToken(status) {
+  return status?.trim().toLowerCase().replace(/[\s-]+/g, "_") ?? "";
+}
+function normalizePaymentStatusValue(status) {
+  const normalized = normalizeStatusToken(status);
+  if (Object.prototype.hasOwnProperty.call(PAYMENT_STATUS_ALIAS_MAP, normalized)) {
+    return PAYMENT_STATUS_ALIAS_MAP[normalized];
+  }
+  return KNOWN_PAYMENT_STATUSES.has(normalized) ? normalized : "unknown";
+}
+function isPaymentStatusSuccess(status) {
+  const normalizedStatus = normalizePaymentStatusValue(status);
+  return PAYMENT_SUCCESS_STATUSES.has(normalizedStatus);
+}
+function isPaymentStatusFailure(status) {
+  const normalizedStatus = normalizePaymentStatusValue(status);
+  return PAYMENT_FAILURE_STATUSES.has(normalizedStatus);
+}
+function isPaymentStatusRequiresAction(status) {
+  const normalizedStatus = normalizePaymentStatusValue(status);
+  return PAYMENT_REQUIRES_ACTION_STATUSES.has(normalizedStatus);
+}
+function normalizeStatusResponse(response) {
+  if (!response || typeof response !== "object") {
+    return {
+      status: "pending",
+      paid: false,
+      message: "No status available"
+    };
+  }
+  const res = response;
+  const normalizedStatus = normalizePaymentStatusValue(res.status ?? void 0);
+  const paidValue = res.paid === true;
+  const derivedPaid = paidValue || [
+    "success",
+    "succeeded",
+    "paid",
+    "captured",
+    "authorized",
+    "completed"
+  ].includes(normalizedStatus);
+  return {
+    status: normalizedStatus,
+    paid: derivedPaid,
+    amount: res.amount,
+    currency: res.currency,
+    reference: res.reference,
+    message: res.message || ""
+  };
+}
+
+// src/utils/paystack.ts
+async function openPaystackPopup(options, signal) {
+  if (typeof window === "undefined") {
+    return { success: false, error: "PROVIDER_UNAVAILABLE" };
+  }
+  let PaystackPop;
+  try {
+    const imported = await import('@paystack/inline-js');
+    PaystackPop = imported.default;
+  } catch {
+    return { success: false, error: "PROVIDER_UNAVAILABLE" };
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const resolveOnce = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve(result);
+    };
+    const onAbort = () => {
+      resolveOnce({ success: false, error: "CANCELLED" });
+    };
+    if (signal?.aborted) {
+      resolveOnce({ success: false, error: "CANCELLED" });
+      return;
+    }
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      const popup = new PaystackPop();
+      popup.newTransaction({
+        key: options.key,
+        email: options.email,
+        amount: options.amount,
+        currency: options.currency,
+        reference: options.reference,
+        accessCode: options.accessCode,
+        onSuccess: (transaction) => {
+          resolveOnce({
+            success: true,
+            reference: transaction.reference ?? options.reference
+          });
+        },
+        onCancel: () => {
+          resolveOnce({ success: false, error: "PAYMENT_CANCELLED" });
+        },
+        onError: (error) => {
+          resolveOnce({
+            success: false,
+            error: error?.message || "PAYMENT_FAILED"
+          });
+        }
+      });
+    } catch {
+      resolveOnce({ success: false, error: "POPUP_BLOCKED" });
+    }
+  });
+}
+
+// src/utils/checkout-resolver.ts
+var DEFAULT_POLL_INTERVAL_MS = 3e3;
+var DEFAULT_MAX_POLL_ATTEMPTS = 60;
+var MAX_CONSECUTIVE_NETWORK_ERRORS = 5;
+var CARD_PROVIDER_PAYSTACK = "paystack";
+function normalizeCardPopupError(error) {
+  if (!error || error === "PAYMENT_CANCELLED" || error === "CANCELLED") {
+    return "PAYMENT_CANCELLED";
+  }
+  if (error === "PROVIDER_UNAVAILABLE") {
+    return "PROVIDER_UNAVAILABLE";
+  }
+  if (error === "POPUP_BLOCKED") {
+    return "POPUP_BLOCKED";
+  }
+  return "PAYMENT_FAILED";
+}
+function normalizeCardProvider(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : CARD_PROVIDER_PAYSTACK;
+}
+async function openCardPopup(provider, checkoutResult, email, currency, signal) {
+  if (typeof window === "undefined") {
+    return { success: false, error: "PROVIDER_UNAVAILABLE" };
+  }
+  if (provider === CARD_PROVIDER_PAYSTACK) {
+    return openPaystackPopup(
+      {
+        key: checkoutResult.public_key || "",
+        email,
+        accessCode: checkoutResult.client_secret,
+        reference: checkoutResult.payment_reference || checkoutResult.client_secret,
+        currency
+      },
+      signal
+    );
+  }
+  return { success: false, error: "PROVIDER_UNAVAILABLE" };
+}
+function normalizeAuthorizationType(value) {
+  return value === "otp" || value === "pin" ? value : void 0;
+}
+function formatMoney2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value.toFixed(2);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value;
+  }
+  return "0.00";
+}
+function createAbortError() {
+  const error = new Error("CANCELLED");
+  error.name = "AbortError";
+  return error;
+}
+function isAbortError(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  return error instanceof Error && (error.name === "AbortError" || error.message === "CANCELLED");
+}
+var CheckoutResolver = class {
+  constructor(options) {
+    this.client = options.client;
+    this.checkoutData = options.checkoutData;
+    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.maxPollAttempts = options.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS;
+    this.onStatusChange = options.onStatusChange;
+    this.onAuthorizationRequired = options.onAuthorizationRequired;
+    this.signal = options.signal;
+    this.returnUrl = options.returnUrl;
+    this.enrollInLink = options.enrollInLink !== false;
+    this.businessId = options.businessId;
+    this.addressData = options.addressData;
+    this.paymentData = options.paymentData;
+    this.orderType = options.orderType;
+    this.cartTotal = options.cartTotal;
+    this.cartCurrency = options.cartCurrency;
+    this.allowPopups = options.allowPopups ?? typeof window !== "undefined";
+  }
+  async resolve(checkoutResult) {
+    try {
+      this.ensureNotAborted();
+      if (!checkoutResult.order_id) {
+        return this.fail("CHECKOUT_FAILED", "Checkout did not return an order ID.", false);
+      }
+      let latestCheckoutResult = checkoutResult;
+      let authorizationType = normalizeAuthorizationType(checkoutResult.authorization_type);
+      let paymentReference = checkoutResult.payment_reference;
+      if (this.isSuccessfulStatus(checkoutResult.payment_status)) {
+        return this.finalizeSuccess(checkoutResult);
+      }
+      if (checkoutResult.client_secret && checkoutResult.public_key) {
+        const provider = normalizeCardProvider(checkoutResult.provider);
+        this.emit("awaiting_authorization", {
+          display_text: "Complete payment in the card authorization popup.",
+          order_id: checkoutResult.order_id,
+          order_number: checkoutResult.order_number
+        });
+        if (!this.allowPopups) {
+          return this.fail(
+            "PROVIDER_UNAVAILABLE",
+            "Card payment popup is unavailable in this environment.",
+            false
+          );
+        }
+        const popupResult = await openCardPopup(
+          provider,
+          checkoutResult,
+          this.checkoutData.customer.email || "customer@cimplify.io",
+          this.getOrderCurrency(checkoutResult),
+          this.signal
+        );
+        if (!popupResult.success) {
+          const popupError = normalizeCardPopupError(popupResult.error);
+          if (popupError === "POPUP_BLOCKED") {
+            return this.fail(
+              "POPUP_BLOCKED",
+              "Unable to open card payment popup. Please allow popups and try again.",
+              true
+            );
+          }
+          if (popupError === "PROVIDER_UNAVAILABLE") {
+            return this.fail(
+              "PROVIDER_UNAVAILABLE",
+              "Card payment provider is unavailable.",
+              false
+            );
+          }
+          return this.fail(
+            "PAYMENT_CANCELLED",
+            "Card payment was cancelled before completion.",
+            true
+          );
+        }
+        paymentReference = popupResult.reference || paymentReference;
+      }
+      if (checkoutResult.authorization_url) {
+        if (typeof window !== "undefined" && this.returnUrl) {
+          window.location.assign(checkoutResult.authorization_url);
+          return this.fail(
+            "REDIRECT_REQUIRED",
+            "Redirecting to complete payment authorization.",
+            true
+          );
+        }
+        if (typeof window !== "undefined") {
+          const popup = window.open(
+            checkoutResult.authorization_url,
+            "cimplify-auth",
+            "width=520,height=760,noopener,noreferrer"
+          );
+          if (!popup) {
+            return this.fail(
+              "POPUP_BLOCKED",
+              "Authorization popup was blocked. Please allow popups and retry.",
+              true
+            );
+          }
+        }
+      }
+      if (checkoutResult.requires_authorization || isPaymentStatusRequiresAction(checkoutResult.payment_status)) {
+        const authorization = await this.handleAuthorization({
+          authorizationType,
+          paymentReference,
+          displayText: checkoutResult.display_text,
+          provider: checkoutResult.provider
+        });
+        if (!authorization.ok) {
+          return authorization.result;
+        }
+        if (authorization.value) {
+          latestCheckoutResult = authorization.value;
+          paymentReference = authorization.value.payment_reference || paymentReference;
+          authorizationType = normalizeAuthorizationType(authorization.value.authorization_type) || authorizationType;
+          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
+            return this.finalizeSuccess(authorization.value);
+          }
+          if (this.isFailureStatus(authorization.value.payment_status)) {
+            return this.fail(
+              "AUTHORIZATION_FAILED",
+              authorization.value.display_text || "Payment authorization failed.",
+              false
+            );
+          }
+        }
+      }
+      return this.pollUntilTerminal({
+        orderId: checkoutResult.order_id,
+        latestCheckoutResult,
+        paymentReference,
+        authorizationType
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        return this.fail("CANCELLED", "Checkout was cancelled.", true);
+      }
+      const message = error instanceof Error ? error.message : "Checkout failed unexpectedly.";
+      return this.fail("CHECKOUT_FAILED", message, true);
+    }
+  }
+  async pollUntilTerminal(input) {
+    let consecutiveErrors = 0;
+    let latestCheckoutResult = input.latestCheckoutResult;
+    let paymentReference = input.paymentReference;
+    let authorizationType = input.authorizationType;
+    for (let attempt = 0; attempt < this.maxPollAttempts; attempt++) {
+      this.ensureNotAborted();
+      this.emit("polling", {
+        poll_attempt: attempt,
+        max_poll_attempts: this.maxPollAttempts,
+        order_id: input.orderId,
+        order_number: latestCheckoutResult.order_number
+      });
+      const statusResult = await this.client.checkout.pollPaymentStatus(input.orderId);
+      if (!statusResult.ok) {
+        consecutiveErrors += 1;
+        if (consecutiveErrors >= MAX_CONSECUTIVE_NETWORK_ERRORS) {
+          return this.fail(
+            "NETWORK_ERROR",
+            "Unable to confirm payment due to repeated network errors.",
+            true
+          );
+        }
+        await this.wait(this.pollIntervalMs);
+        continue;
+      }
+      consecutiveErrors = 0;
+      if (statusResult.value.reference) {
+        paymentReference = statusResult.value.reference;
+      }
+      const normalized = normalizeStatusResponse(statusResult.value);
+      if (normalized.paid || isPaymentStatusSuccess(normalized.status)) {
+        return this.finalizeSuccess(latestCheckoutResult);
+      }
+      if (isPaymentStatusFailure(normalized.status)) {
+        return this.fail(
+          normalized.status ? normalized.status.toUpperCase() : "PAYMENT_FAILED",
+          normalized.message || "Payment failed during confirmation.",
+          false
+        );
+      }
+      if (isPaymentStatusRequiresAction(normalized.status)) {
+        const authorization = await this.handleAuthorization({
+          authorizationType,
+          paymentReference,
+          displayText: normalized.message || latestCheckoutResult.display_text,
+          provider: latestCheckoutResult.provider
+        });
+        if (!authorization.ok) {
+          return authorization.result;
+        }
+        if (authorization.value) {
+          latestCheckoutResult = authorization.value;
+          paymentReference = authorization.value.payment_reference || paymentReference;
+          authorizationType = normalizeAuthorizationType(authorization.value.authorization_type) || authorizationType;
+          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
+            return this.finalizeSuccess(authorization.value);
+          }
+          if (this.isFailureStatus(authorization.value.payment_status)) {
+            return this.fail(
+              "AUTHORIZATION_FAILED",
+              authorization.value.display_text || "Payment authorization failed.",
+              false
+            );
+          }
+        }
+      }
+      await this.wait(this.pollIntervalMs);
+    }
+    return this.fail(
+      "PAYMENT_TIMEOUT",
+      "Payment confirmation timed out. Please retry checkout.",
+      true
+    );
+  }
+  async handleAuthorization(input) {
+    const authorizationType = input.authorizationType;
+    const paymentReference = input.paymentReference;
+    if (!authorizationType || !paymentReference) {
+      return { ok: true };
+    }
+    this.emit("awaiting_authorization", {
+      authorization_type: authorizationType,
+      display_text: input.displayText,
+      provider: input.provider
+    });
+    let authorizationResult;
+    const submit = async (code) => {
+      this.ensureNotAborted();
+      const trimmedCode = code.trim();
+      if (!trimmedCode) {
+        throw new Error("Authorization code is required.");
+      }
+      const submitResult = await this.client.checkout.submitAuthorization({
+        reference: paymentReference,
+        auth_type: authorizationType,
+        value: trimmedCode
+      });
+      if (!submitResult.ok) {
+        throw new Error(submitResult.error.message || "Authorization failed.");
+      }
+      authorizationResult = submitResult.value;
+    };
+    try {
+      if (this.onAuthorizationRequired) {
+        await this.onAuthorizationRequired(authorizationType, submit);
+      } else {
+        return {
+          ok: false,
+          result: this.fail(
+            "AUTHORIZATION_REQUIRED",
+            "Authorization callback is required in headless checkout mode.",
+            false
+          )
+        };
+      }
+    } catch (error) {
+      if (isAbortError(error)) {
+        return {
+          ok: false,
+          result: this.fail("CANCELLED", "Checkout was cancelled.", true)
+        };
+      }
+      const message = error instanceof Error ? error.message : "Payment authorization failed.";
+      return {
+        ok: false,
+        result: this.fail("AUTHORIZATION_FAILED", message, true)
+      };
+    }
+    return {
+      ok: true,
+      value: authorizationResult
+    };
+  }
+  async finalizeSuccess(checkoutResult) {
+    this.emit("finalizing", {
+      order_id: checkoutResult.order_id,
+      order_number: checkoutResult.order_number
+    });
+    const enrolledInLink = await this.maybeEnrollInLink(checkoutResult.order_id);
+    this.emit("success", {
+      order_id: checkoutResult.order_id,
+      order_number: checkoutResult.order_number
+    });
+    return {
+      success: true,
+      order: {
+        id: checkoutResult.order_id,
+        order_number: checkoutResult.order_number || checkoutResult.order_id,
+        status: checkoutResult.payment_status || "paid",
+        total: this.getOrderTotal(checkoutResult),
+        currency: this.getOrderCurrency(checkoutResult)
+      },
+      enrolled_in_link: enrolledInLink
+    };
+  }
+  async maybeEnrollInLink(orderId) {
+    if (!this.enrollInLink || !orderId) {
+      return false;
+    }
+    let businessId = this.businessId;
+    if (!businessId) {
+      const businessResult = await this.client.business.getInfo();
+      if (!businessResult.ok || !businessResult.value?.id) {
+        return false;
+      }
+      businessId = businessResult.value.id;
+    }
+    const address = this.getEnrollmentAddress();
+    const mobileMoney = this.getEnrollmentMobileMoney();
+    try {
+      const enrollment = await this.client.link.enrollAndLinkOrder({
+        order_id: orderId,
+        business_id: businessId,
+        order_type: this.orderType || this.checkoutData.order_type,
+        address,
+        mobile_money: mobileMoney
+      });
+      return enrollment.ok && enrollment.value.success;
+    } catch {
+      return false;
+    }
+  }
+  getEnrollmentAddress() {
+    const source = this.addressData ?? this.checkoutData.address_info;
+    if (!source?.street_address) {
+      return void 0;
+    }
+    return {
+      label: "Default",
+      street_address: source.street_address,
+      apartment: source.apartment || void 0,
+      city: source.city || "",
+      region: source.region || "",
+      delivery_instructions: source.delivery_instructions || void 0,
+      phone_for_delivery: source.phone_for_delivery || void 0
+    };
+  }
+  getEnrollmentMobileMoney() {
+    if (this.paymentData?.type === "mobile_money" && this.paymentData.phone_number && this.paymentData.provider) {
+      return {
+        phone_number: this.paymentData.phone_number,
+        provider: this.paymentData.provider,
+        label: this.paymentData.label || "Mobile Money"
+      };
+    }
+    if (this.checkoutData.mobile_money_details?.phone_number) {
+      return {
+        phone_number: this.checkoutData.mobile_money_details.phone_number,
+        provider: this.checkoutData.mobile_money_details.provider,
+        label: "Mobile Money"
+      };
+    }
+    return void 0;
+  }
+  getOrderTotal(checkoutResult) {
+    if (checkoutResult.fx?.pay_amount !== void 0) {
+      return formatMoney2(checkoutResult.fx.pay_amount);
+    }
+    if (this.cartTotal !== void 0) {
+      return formatMoney2(this.cartTotal);
+    }
+    return "0.00";
+  }
+  getOrderCurrency(checkoutResult) {
+    if (checkoutResult.fx?.pay_currency) {
+      return checkoutResult.fx.pay_currency;
+    }
+    if (this.cartCurrency) {
+      return this.cartCurrency;
+    }
+    if (this.checkoutData.pay_currency) {
+      return this.checkoutData.pay_currency;
+    }
+    return "GHS";
+  }
+  emit(status, context = {}) {
+    if (!this.onStatusChange) {
+      return;
+    }
+    try {
+      this.onStatusChange(status, context);
+    } catch {
+    }
+  }
+  fail(code, message, recoverable) {
+    this.emit("failed", {
+      display_text: message
+    });
+    return {
+      success: false,
+      error: {
+        code,
+        message,
+        recoverable
+      }
+    };
+  }
+  isSuccessfulStatus(status) {
+    const normalized = normalizeStatusResponse({ status, paid: false });
+    return normalized.paid || isPaymentStatusSuccess(normalized.status);
+  }
+  isFailureStatus(status) {
+    const normalized = normalizeStatusResponse({ status, paid: false });
+    return isPaymentStatusFailure(normalized.status);
+  }
+  ensureNotAborted() {
+    if (this.signal?.aborted) {
+      throw createAbortError();
+    }
+  }
+  wait(ms) {
+    this.ensureNotAborted();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.signal) {
+          this.signal.removeEventListener("abort", onAbort);
+        }
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(createAbortError());
+      };
+      if (this.signal) {
+        this.signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+  }
+};
+
+// src/checkout.ts
+function toCimplifyError3(error) {
+  if (error instanceof CimplifyError) return enrichError(error);
+  if (error instanceof Error) {
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
+  }
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
+}
+async function safe3(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError3(error));
+  }
+}
+function toTerminalFailure(code, message, recoverable) {
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      recoverable
+    }
+  };
+}
+function generateIdempotencyKey() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return `idem_${crypto.randomUUID()}`;
+  }
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 15);
+  return `idem_${timestamp}_${random}`;
+}
+var CheckoutService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async process(data) {
+    const checkoutData = {
+      ...data,
+      idempotency_key: data.idempotency_key || generateIdempotencyKey()
+    };
+    return safe3(
+      this.client.call(CHECKOUT_MUTATION.PROCESS, {
+        checkout_data: checkoutData
+      })
+    );
+  }
+  async initializePayment(orderId, method) {
+    return safe3(
+      this.client.call("order.initializePayment", {
+        order_id: orderId,
+        payment_method: method
+      })
+    );
+  }
+  async submitAuthorization(input) {
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
+    );
+  }
+  async pollPaymentStatus(orderId) {
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
+    );
+  }
+  async updateOrderCustomer(orderId, customer) {
+    return safe3(
+      this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
+        order_id: orderId,
+        ...customer
+      })
+    );
+  }
+  async verifyPayment(orderId) {
+    return safe3(
+      this.client.call("order.verifyPayment", {
+        order_id: orderId
+      })
+    );
+  }
+  async processAndResolve(data) {
+    data.on_status_change?.("preparing", {});
+    if (!data.cart_id) {
+      return ok(
+        toTerminalFailure(
+          "INVALID_CART",
+          "A valid cart is required before checkout can start.",
+          false
+        )
+      );
+    }
+    const cartResult = await this.client.cart.get();
+    if (!cartResult.ok || !cartResult.value?.id) {
+      return ok(
+        toTerminalFailure(
+          "INVALID_CART",
+          "Unable to load cart for checkout.",
+          false
+        )
+      );
+    }
+    const cart = cartResult.value;
+    if (cart.id !== data.cart_id || cart.items.length === 0) {
+      return ok(
+        toTerminalFailure(
+          "INVALID_CART",
+          "Cart is empty or no longer valid. Please refresh and try again.",
+          false
+        )
+      );
+    }
+    const checkoutData = {
+      cart_id: data.cart_id,
+      location_id: data.location_id,
+      customer: data.customer,
+      order_type: data.order_type,
+      address_info: data.address_info,
+      payment_method: data.payment_method,
+      mobile_money_details: data.mobile_money_details,
+      special_instructions: data.special_instructions,
+      link_address_id: data.link_address_id,
+      link_payment_method_id: data.link_payment_method_id,
+      idempotency_key: data.idempotency_key || generateIdempotencyKey(),
+      metadata: data.metadata,
+      pay_currency: data.pay_currency,
+      fx_quote_id: data.fx_quote_id
+    };
+    const baseCurrency = (cart.pricing.currency || checkoutData.pay_currency || "GHS").toUpperCase();
+    const payCurrency = data.pay_currency?.trim().toUpperCase();
+    const cartTotalAmount = Number.parseFloat(cart.pricing.total_price || "0");
+    if (payCurrency && payCurrency !== baseCurrency && !checkoutData.fx_quote_id && Number.isFinite(cartTotalAmount) && cartTotalAmount > 0) {
+      const fxQuoteResult = await this.client.fx.lockQuote({
+        from: baseCurrency,
+        to: payCurrency,
+        amount: cartTotalAmount
+      });
+      if (!fxQuoteResult.ok) {
+        return ok(
+          toTerminalFailure(
+            "FX_QUOTE_FAILED",
+            fxQuoteResult.error.message || "Unable to lock FX quote for checkout.",
+            true
+          )
+        );
+      }
+      checkoutData.pay_currency = payCurrency;
+      checkoutData.fx_quote_id = fxQuoteResult.value.id;
+    }
+    data.on_status_change?.("processing", {});
+    const processResult = await this.process(checkoutData);
+    if (!processResult.ok) {
+      return ok(
+        toTerminalFailure(
+          processResult.error.code || "CHECKOUT_FAILED",
+          processResult.error.message || "Unable to process checkout.",
+          processResult.error.retryable ?? true
+        )
+      );
+    }
+    const resolver = new CheckoutResolver({
+      client: this.client,
+      checkoutData,
+      pollIntervalMs: data.poll_interval_ms,
+      maxPollAttempts: data.max_poll_attempts,
+      onStatusChange: data.on_status_change,
+      onAuthorizationRequired: data.on_authorization_required,
+      signal: data.signal,
+      returnUrl: data.return_url,
+      enrollInLink: data.enroll_in_link,
+      cartTotal: cart.pricing.total_price,
+      cartCurrency: checkoutData.pay_currency || cart.pricing.currency || "GHS",
+      orderType: checkoutData.order_type,
+      allowPopups: data.allow_popups
+    });
+    const resolved = await resolver.resolve(processResult.value);
+    return ok(resolved);
+  }
+};
+
+// src/orders.ts
+function toCimplifyError4(error) {
+  if (error instanceof CimplifyError) return enrichError(error);
+  if (error instanceof Error) {
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
+  }
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
+}
+async function safe4(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError4(error));
+  }
+}
+var OrderQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    let query = "orders";
+    if (options?.status) {
+      query += `[?(@.status=='${options.status}')]`;
+    }
+    query += "#sort(created_at,desc)";
+    if (options?.limit) {
+      query += `#limit(${options.limit})`;
+    }
+    if (options?.offset) {
+      query += `#offset(${options.offset})`;
+    }
+    return safe4(this.client.query(query));
+  }
+  async get(orderId) {
+    return safe4(this.client.query(`orders.${orderId}`));
+  }
+  async getRecent(limit = 5) {
+    return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
+  }
+  async getByStatus(status) {
+    return safe4(this.client.query(`orders[?(@.status=='${status}')]`));
+  }
+  async cancel(orderId, reason) {
+    return safe4(
+      this.client.call("order.cancelOrder", {
+        order_id: orderId,
+        reason
+      })
+    );
+  }
+};
+
+// src/link.ts
+function toCimplifyError5(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe5(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError5(error));
+  }
+}
+var LinkService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async requestOtp(input) {
+    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
+  }
+  async verifyOtp(input) {
+    const result = await safe5(
+      this.client.linkPost("/v1/link/auth/verify-otp", input)
+    );
+    if (result.ok && result.value.session_token) {
+      this.client.setSessionToken(result.value.session_token);
+    }
+    return result;
+  }
+  async logout() {
+    const result = await safe5(this.client.linkPost("/v1/link/auth/logout"));
+    if (result.ok) {
+      this.client.clearSession();
+    }
+    return result;
+  }
+  async checkStatus(contact) {
+    return safe5(
+      this.client.call(LINK_MUTATION.CHECK_STATUS, {
+        contact
+      })
+    );
+  }
+  async getLinkData() {
+    return safe5(this.client.query(LINK_QUERY.DATA));
+  }
+  async getAddresses() {
+    return safe5(this.client.query(LINK_QUERY.ADDRESSES));
+  }
+  async getMobileMoney() {
+    return safe5(this.client.query(LINK_QUERY.MOBILE_MONEY));
+  }
+  async getPreferences() {
+    return safe5(this.client.query(LINK_QUERY.PREFERENCES));
+  }
+  async enroll(data) {
+    return safe5(this.client.call(LINK_MUTATION.ENROLL, data));
+  }
+  async enrollAndLinkOrder(data) {
+    return safe5(
+      this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data)
+    );
+  }
+  async updatePreferences(preferences) {
+    return safe5(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
+  }
+  async createAddress(input) {
+    return safe5(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
+  }
+  async updateAddress(input) {
+    return safe5(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
+  }
+  async deleteAddress(addressId) {
+    return safe5(this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId));
+  }
+  async setDefaultAddress(addressId) {
+    return safe5(this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId));
+  }
+  async trackAddressUsage(addressId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
+        address_id: addressId
+      })
+    );
+  }
+  async createMobileMoney(input) {
+    return safe5(this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input));
+  }
+  async deleteMobileMoney(mobileMoneyId) {
+    return safe5(this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId));
+  }
+  async setDefaultMobileMoney(mobileMoneyId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.SET_DEFAULT_MOBILE_MONEY, mobileMoneyId)
+    );
+  }
+  async trackMobileMoneyUsage(mobileMoneyId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
+        mobile_money_id: mobileMoneyId
+      })
+    );
+  }
+  async verifyMobileMoney(mobileMoneyId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
+    );
+  }
+  async getSessions() {
+    return safe5(this.client.linkGet("/v1/link/sessions"));
+  }
+  async revokeSession(sessionId) {
+    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
+  }
+  async revokeAllSessions() {
+    return safe5(this.client.linkDelete("/v1/link/sessions"));
+  }
+  async getAddressesRest() {
+    return safe5(this.client.linkGet("/v1/link/addresses"));
+  }
+  async createAddressRest(input) {
+    return safe5(this.client.linkPost("/v1/link/addresses", input));
+  }
+  async deleteAddressRest(addressId) {
+    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
+  }
+  async setDefaultAddressRest(addressId) {
+    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
+  }
+  async getMobileMoneyRest() {
+    return safe5(this.client.linkGet("/v1/link/mobile-money"));
+  }
+  async createMobileMoneyRest(input) {
+    return safe5(this.client.linkPost("/v1/link/mobile-money", input));
+  }
+  async deleteMobileMoneyRest(mobileMoneyId) {
+    return safe5(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
+  }
+  async setDefaultMobileMoneyRest(mobileMoneyId) {
+    return safe5(
+      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
+    );
+  }
+};
+
+// src/auth.ts
+function toCimplifyError6(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe6(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError6(error));
+  }
+}
+var AuthService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getStatus() {
+    return safe6(this.client.query("auth"));
+  }
+  async getCurrentUser() {
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.customer || null);
+  }
+  async isAuthenticated() {
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.is_authenticated);
+  }
+  async requestOtp(contact, contactType) {
+    return safe6(
+      this.client.call(AUTH_MUTATION.REQUEST_OTP, {
+        contact,
+        contact_type: contactType
+      })
+    );
+  }
+  async verifyOtp(code, contact) {
+    return safe6(
+      this.client.call(AUTH_MUTATION.VERIFY_OTP, {
+        otp_code: code,
+        contact
+      })
+    );
+  }
+  async logout() {
+    return safe6(this.client.call("auth.logout"));
+  }
+  async updateProfile(input) {
+    return safe6(this.client.call("auth.update_profile", input));
+  }
+  async changePassword(input) {
+    return safe6(this.client.call("auth.change_password", input));
+  }
+  async resetPassword(email) {
+    return safe6(this.client.call("auth.reset_password", { email }));
+  }
+};
+
+// src/business.ts
+function toCimplifyError7(error) {
+  if (error instanceof CimplifyError) return enrichError(error);
+  if (error instanceof Error) {
+    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
+  }
+  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
+}
+async function safe7(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError7(error));
+  }
+}
+var BusinessService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getInfo() {
+    return safe7(this.client.query("business.info"));
+  }
+  async getByHandle(handle) {
+    return safe7(this.client.query(`business.handle.${handle}`));
+  }
+  async getByDomain(domain) {
+    return safe7(this.client.query("business.domain", { domain }));
+  }
+  async getSettings() {
+    return safe7(this.client.query("business.settings"));
+  }
+  async getTheme() {
+    return safe7(this.client.query("business.theme"));
+  }
+  async getLocations() {
+    return safe7(this.client.query("business.locations"));
+  }
+  async getLocation(locationId) {
+    return safe7(this.client.query(`business.locations.${locationId}`));
+  }
+  async getHours() {
+    return safe7(this.client.query("business.hours"));
+  }
+  async getLocationHours(locationId) {
+    return safe7(this.client.query(`business.locations.${locationId}.hours`));
+  }
+  async getBootstrap() {
+    const [businessResult, locationsResult, categoriesResult] = await Promise.all([
+      this.getInfo(),
+      this.getLocations(),
+      safe7(this.client.query("categories#select(id,name,slug)"))
+    ]);
+    if (!businessResult.ok) return businessResult;
+    if (!locationsResult.ok) return locationsResult;
+    if (!categoriesResult.ok) return categoriesResult;
+    const business = businessResult.value;
+    const locations = locationsResult.value;
+    const categories = categoriesResult.value;
+    const defaultLocation = locations[0];
+    return ok({
+      business,
+      location: defaultLocation,
+      locations,
+      categories,
+      currency: business.default_currency,
+      is_open: defaultLocation?.accepts_online_orders ?? false,
+      accepts_orders: defaultLocation?.accepts_online_orders ?? false
+    });
+  }
+};
+
+// src/inventory.ts
+function toCimplifyError8(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe8(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError8(error));
+  }
+}
+var InventoryService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getStockLevels() {
+    return safe8(this.client.query("inventory.stock_levels"));
+  }
+  async getProductStock(productId, locationId) {
+    if (locationId) {
+      return safe8(
+        this.client.query("inventory.product", {
+          product_id: productId,
+          location_id: locationId
+        })
+      );
+    }
+    return safe8(
+      this.client.query("inventory.product", {
+        product_id: productId
+      })
+    );
+  }
+  async getVariantStock(variantId, locationId) {
+    return safe8(
+      this.client.query("inventory.variant", {
+        variant_id: variantId,
+        location_id: locationId
+      })
+    );
+  }
+  async checkProductAvailability(productId, quantity, locationId) {
+    return safe8(
+      this.client.query("inventory.check_availability", {
+        product_id: productId,
+        quantity,
+        location_id: locationId
+      })
+    );
+  }
+  async checkVariantAvailability(variantId, quantity, locationId) {
+    return safe8(
+      this.client.query("inventory.check_availability", {
+        variant_id: variantId,
+        quantity,
+        location_id: locationId
+      })
+    );
+  }
+  async checkMultipleAvailability(items, locationId) {
+    const results = await Promise.all(
+      items.map(
+        (item) => item.variant_id ? this.checkVariantAvailability(item.variant_id, item.quantity, locationId) : this.checkProductAvailability(item.product_id, item.quantity, locationId)
+      )
+    );
+    for (const result of results) {
+      if (!result.ok) return result;
+    }
+    return ok(results.map((r) => r.value));
+  }
+  async getSummary() {
+    return safe8(this.client.query("inventory.summary"));
+  }
+  async isInStock(productId, locationId) {
+    const result = await this.checkProductAvailability(productId, 1, locationId);
+    if (!result.ok) return result;
+    return ok(result.value.is_available);
+  }
+  async getAvailableQuantity(productId, locationId) {
+    const result = await this.getProductStock(productId, locationId);
+    if (!result.ok) return result;
+    return ok(result.value.available_quantity);
+  }
+};
+
+// src/scheduling.ts
+function toVariables(input) {
+  return Object.fromEntries(Object.entries(input));
+}
+function toCimplifyError9(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe9(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError9(error));
+  }
+}
+var SchedulingService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getServices() {
+    return safe9(this.client.query("scheduling.services"));
+  }
+  /**
+   * Get a specific service by ID
+   * Note: Filters from all services client-side (no single-service endpoint)
+   */
+  async getService(serviceId) {
+    const result = await this.getServices();
+    if (!result.ok) return result;
+    return ok(result.value.find((s) => s.id === serviceId) || null);
+  }
+  async getAvailableSlots(input) {
+    return safe9(
+      this.client.query("scheduling.slots", toVariables(input))
+    );
+  }
+  async checkSlotAvailability(input) {
+    return safe9(
+      this.client.query(
+        "scheduling.check_availability",
+        toVariables(input)
+      )
+    );
+  }
+  async getServiceAvailability(params) {
+    return safe9(
+      this.client.query(
+        "scheduling.availability",
+        toVariables(params)
+      )
+    );
+  }
+  async getBooking(bookingId) {
+    return safe9(this.client.query(`scheduling.${bookingId}`));
+  }
+  async getCustomerBookings() {
+    return safe9(this.client.query("scheduling"));
+  }
+  async getUpcomingBookings() {
+    return safe9(
+      this.client.query(
+        "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
+      )
+    );
+  }
+  async getPastBookings(limit = 10) {
+    return safe9(
+      this.client.query(
+        `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
+      )
+    );
+  }
+  async cancelBooking(input) {
+    return safe9(this.client.call("scheduling.cancel_booking", input));
+  }
+  async rescheduleBooking(input) {
+    return safe9(this.client.call("scheduling.reschedule_booking", input));
+  }
+  async getNextAvailableSlot(serviceId, fromDate) {
+    const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const result = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
+    });
+    if (!result.ok) return result;
+    return ok(result.value.find((slot) => slot.is_available) || null);
+  }
+  async hasAvailabilityOn(serviceId, date) {
+    const result = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
+    });
+    if (!result.ok) return result;
+    return ok(result.value.some((slot) => slot.is_available));
+  }
+};
+
+// src/lite.ts
+function toCimplifyError10(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe10(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError10(error));
+  }
+}
+var LiteService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getBootstrap() {
+    return safe10(this.client.query("lite.bootstrap"));
+  }
+  async getTable(tableId) {
+    return safe10(this.client.query(`lite.table.${tableId}`));
+  }
+  async getTableByNumber(tableNumber, locationId) {
+    return safe10(
+      this.client.query("lite.table_by_number", {
+        table_number: tableNumber,
+        location_id: locationId
+      })
+    );
+  }
+  async sendToKitchen(tableId, items) {
+    return safe10(
+      this.client.call("lite.send_to_kitchen", {
+        table_id: tableId,
+        items
+      })
+    );
+  }
+  async callWaiter(tableId, reason) {
+    return safe10(
+      this.client.call("lite.call_waiter", {
+        table_id: tableId,
+        reason
+      })
+    );
+  }
+  async requestBill(tableId) {
+    return safe10(
+      this.client.call("lite.request_bill", {
+        table_id: tableId
+      })
+    );
+  }
+  async getMenu() {
+    return safe10(this.client.query("lite.menu"));
+  }
+  async getMenuByCategory(categoryId) {
+    return safe10(this.client.query(`lite.menu.category.${categoryId}`));
+  }
+};
+
+// src/fx.ts
+function toCimplifyError11(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe11(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError11(error));
+  }
+}
+var FxService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getRate(from, to) {
+    return safe11(this.client.call("fx.getRate", { from, to }));
+  }
+  async lockQuote(request) {
+    return safe11(this.client.call("fx.lockQuote", request));
+  }
+};
+
+// src/elements.ts
+function toCheckoutError(code, message, recoverable) {
+  const hint = getErrorHint(code);
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      recoverable,
+      docs_url: hint?.docs_url,
+      suggestion: hint?.suggestion
+    }
+  };
+}
+var DEFAULT_LINK_URL = "https://link.cimplify.io";
+function isAllowedOrigin(origin) {
+  try {
+    const url = new URL(origin);
+    const hostname = url.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return true;
+    }
+    if (url.protocol !== "https:") {
+      return false;
+    }
+    return hostname === "cimplify.io" || hostname.endsWith(".cimplify.io");
+  } catch {
+    return false;
+  }
+}
+function parseIframeMessage(data) {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const maybeType = data.type;
+  if (typeof maybeType !== "string") {
+    return null;
+  }
+  return data;
+}
+var CimplifyElements = class {
+  constructor(client, businessId, options = {}) {
+    this.elements = /* @__PURE__ */ new Map();
+    this.accessToken = null;
+    this.accountId = null;
+    this.customerId = null;
+    this.customerData = null;
+    this.addressData = null;
+    this.paymentData = null;
+    this.checkoutInProgress = false;
+    this.activeCheckoutAbort = null;
+    this.hasWarnedMissingAuthElement = false;
+    this.businessIdResolvePromise = null;
+    this.client = client;
+    this.businessId = businessId ?? null;
+    this.linkUrl = options.linkUrl || DEFAULT_LINK_URL;
+    this.options = options;
+    this.boundHandleMessage = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.boundHandleMessage);
+    }
+  }
+  create(type, options = {}) {
+    const existing = this.elements.get(type);
+    if (existing) return existing;
+    const element = new CimplifyElement(type, this.businessId, this.linkUrl, options, this);
+    this.elements.set(type, element);
+    return element;
+  }
+  getElement(type) {
+    return this.elements.get(type);
+  }
+  destroy() {
+    this.elements.forEach((element) => element.destroy());
+    this.elements.clear();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.boundHandleMessage);
+    }
+  }
+  async submitCheckout(data) {
+    const result = await this.processCheckout({
+      cart_id: data.cart_id,
+      order_type: data.order_type ?? "delivery",
+      location_id: data.location_id,
+      notes: data.notes,
+      scheduled_time: data.scheduled_time,
+      tip_amount: data.tip_amount,
+      enroll_in_link: true
+    });
+    if (result.success) {
+      return {
+        success: true,
+        order: {
+          id: result.order?.id || "",
+          status: result.order?.status || "unknown",
+          total: result.order?.total || ""
+        }
+      };
+    }
+    return {
+      success: false,
+      error: {
+        code: result.error?.code || "CHECKOUT_FAILED",
+        message: result.error?.message || "Checkout failed"
+      }
+    };
+  }
+  processCheckout(options) {
+    let abortFn = null;
+    const task = (async () => {
+      if (this.checkoutInProgress) {
+        return toCheckoutError(
+          "ALREADY_PROCESSING",
+          "Checkout is already in progress.",
+          false
+        );
+      }
+      if (!options.cart_id) {
+        return toCheckoutError(
+          "INVALID_CART",
+          "A valid cart is required before checkout can start.",
+          false
+        );
+      }
+      if (!options.order_type) {
+        return toCheckoutError(
+          "ORDER_TYPE_REQUIRED",
+          "Order type is required before checkout can start.",
+          false
+        );
+      }
+      const paymentElement = this.elements.get(ELEMENT_TYPES.PAYMENT);
+      if (!paymentElement) {
+        return toCheckoutError(
+          "NO_PAYMENT_ELEMENT",
+          "Payment element must be mounted before checkout.",
+          false
+        );
+      }
+      if (!paymentElement.isMounted()) {
+        return toCheckoutError(
+          "PAYMENT_NOT_MOUNTED",
+          "Payment element must be mounted before checkout.",
+          false
+        );
+      }
+      const authElement = this.elements.get(ELEMENT_TYPES.AUTH);
+      if (!authElement && !this.hasWarnedMissingAuthElement) {
+        this.hasWarnedMissingAuthElement = true;
+        console.warn(
+          "[Cimplify] processCheckout() called without AuthElement mounted. For best conversion and Link enrollment, mount <AuthElement> before checkout."
+        );
+      }
+      if (authElement && !this.accessToken) {
+        return toCheckoutError(
+          "AUTH_INCOMPLETE",
+          "Authentication must complete before checkout can start.",
+          true
+        );
+      }
+      const addressElement = this.elements.get(ELEMENT_TYPES.ADDRESS);
+      if (addressElement) {
+        await addressElement.getData();
+      }
+      await this.hydrateCustomerData();
+      const processMessage = {
+        type: MESSAGE_TYPES.PROCESS_CHECKOUT,
+        cart_id: options.cart_id,
+        order_type: options.order_type,
+        location_id: options.location_id,
+        notes: options.notes,
+        scheduled_time: options.scheduled_time,
+        tip_amount: options.tip_amount,
+        pay_currency: options.pay_currency,
+        enroll_in_link: options.enroll_in_link ?? true,
+        address: this.addressData ?? void 0,
+        customer: this.customerData ? {
+          name: this.customerData.name,
+          email: this.customerData.email,
+          phone: this.customerData.phone
+        } : null,
+        account_id: this.accountId ?? void 0,
+        customer_id: this.customerId ?? void 0
+      };
+      const timeoutMs = options.timeout_ms ?? 18e4;
+      const paymentWindow = paymentElement.getContentWindow();
+      this.checkoutInProgress = true;
+      return new Promise((resolve) => {
+        let settled = false;
+        const cleanup = () => {
+          if (typeof window !== "undefined") {
+            window.removeEventListener("message", handleCheckoutMessage);
+          }
+          clearTimeout(timeout);
+          this.checkoutInProgress = false;
+          this.activeCheckoutAbort = null;
+        };
+        const settle = (result) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          cleanup();
+          resolve(result);
+        };
+        const timeout = setTimeout(() => {
+          settle(
+            toCheckoutError(
+              "TIMEOUT",
+              "Checkout timed out before receiving a terminal response.",
+              true
+            )
+          );
+        }, timeoutMs);
+        const handleCheckoutMessage = (event) => {
+          if (!isAllowedOrigin(event.origin)) {
+            return;
+          }
+          const message = parseIframeMessage(event.data);
+          if (!message) {
+            return;
+          }
+          if (message.type === MESSAGE_TYPES.LOGOUT_COMPLETE) {
+            paymentElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
+            settle(
+              toCheckoutError(
+                "AUTH_LOST",
+                "Authentication was cleared during checkout.",
+                true
+              )
+            );
+            return;
+          }
+          if (paymentWindow && event.source && event.source !== paymentWindow) {
+            return;
+          }
+          if (message.type === MESSAGE_TYPES.CHECKOUT_STATUS) {
+            options.on_status_change?.(message.status, message.context);
+            return;
+          }
+          if (message.type === MESSAGE_TYPES.CHECKOUT_COMPLETE) {
+            settle({
+              success: message.success,
+              order: message.order,
+              error: message.error,
+              enrolled_in_link: message.enrolled_in_link
+            });
+          }
+        };
+        if (typeof window !== "undefined") {
+          window.addEventListener("message", handleCheckoutMessage);
+        }
+        abortFn = () => {
+          paymentElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
+          settle(
+            toCheckoutError(
+              "CANCELLED",
+              "Checkout was cancelled.",
+              true
+            )
+          );
+        };
+        this.activeCheckoutAbort = abortFn;
+        paymentElement.sendMessage(processMessage);
+      });
+    })();
+    const abortable = task;
+    abortable.abort = () => {
+      if (abortFn) {
+        abortFn();
+      }
+    };
+    return abortable;
+  }
+  isAuthenticated() {
+    return this.accessToken !== null;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  getPublicKey() {
+    return this.client.getPublicKey();
+  }
+  getBusinessId() {
+    return this.businessId;
+  }
+  async resolveBusinessId() {
+    if (this.businessId) {
+      return this.businessId;
+    }
+    if (this.businessIdResolvePromise) {
+      return this.businessIdResolvePromise;
+    }
+    this.businessIdResolvePromise = this.client.resolveBusinessId().then((resolvedBusinessId) => {
+      this.businessId = resolvedBusinessId;
+      return resolvedBusinessId;
+    }).catch(() => null).finally(() => {
+      this.businessIdResolvePromise = null;
+    });
+    return this.businessIdResolvePromise;
+  }
+  getAppearance() {
+    return this.options.appearance;
+  }
+  async hydrateCustomerData() {
+    if (!this.accessToken || this.customerData) {
+      return;
+    }
+    if (!this.client.getAccessToken()) {
+      this.client.setAccessToken(this.accessToken);
+    }
+    const linkDataResult = await this.client.link.getLinkData();
+    if (!linkDataResult.ok || !linkDataResult.value?.customer) {
+      return;
+    }
+    const customer = linkDataResult.value.customer;
+    this.customerData = {
+      name: customer.name || "",
+      email: customer.email || null,
+      phone: customer.phone || null
+    };
+  }
+  handleMessage(event) {
+    if (!isAllowedOrigin(event.origin)) {
+      return;
+    }
+    const message = parseIframeMessage(event.data);
+    if (!message) return;
+    switch (message.type) {
+      case MESSAGE_TYPES.AUTHENTICATED:
+        const customer = message.customer ?? {
+          name: "",
+          email: null,
+          phone: null
+        };
+        this.accessToken = message.token;
+        this.accountId = message.accountId;
+        this.customerId = message.customerId;
+        this.customerData = customer;
+        this.client.setAccessToken(message.token);
+        this.elements.forEach((element, type) => {
+          if (type !== ELEMENT_TYPES.AUTH) {
+            element.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token: message.token });
+          }
+        });
+        break;
+      case MESSAGE_TYPES.TOKEN_REFRESHED:
+        this.accessToken = message.token;
+        break;
+      case MESSAGE_TYPES.ADDRESS_CHANGED:
+      case MESSAGE_TYPES.ADDRESS_SELECTED:
+        this.addressData = message.address;
+        break;
+      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
+        this.paymentData = message.method;
+        break;
+      case MESSAGE_TYPES.LOGOUT_COMPLETE:
+        if (this.checkoutInProgress && this.activeCheckoutAbort) {
+          this.activeCheckoutAbort();
+        }
+        this.accessToken = null;
+        this.accountId = null;
+        this.customerId = null;
+        this.customerData = null;
+        this.addressData = null;
+        this.paymentData = null;
+        this.client.clearSession();
+        break;
+    }
+  }
+  _setAddressData(data) {
+    this.addressData = data;
+  }
+  _setPaymentData(data) {
+    this.paymentData = data;
+  }
+};
+var CimplifyElement = class {
+  constructor(type, businessId, linkUrl, options, parent) {
+    this.iframe = null;
+    this.container = null;
+    this.mounted = false;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+    this.type = type;
+    this.businessId = businessId;
+    this.linkUrl = linkUrl;
+    this.options = options;
+    this.parent = parent;
+    this.boundHandleMessage = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.boundHandleMessage);
+    }
+  }
+  mount(container) {
+    if (this.mounted) {
+      console.warn(`Element ${this.type} is already mounted`);
+      return;
+    }
+    const target = typeof container === "string" ? document.querySelector(container) : container;
+    if (!target) {
+      console.error(`Container not found: ${container}`);
+      return;
+    }
+    this.container = target;
+    this.mounted = true;
+    void this.createIframe();
+  }
+  destroy() {
+    if (this.iframe) {
+      this.iframe.remove();
+      this.iframe = null;
+    }
+    this.container = null;
+    this.mounted = false;
+    this.eventHandlers.clear();
+    this.resolvers.forEach((entry) => clearTimeout(entry.timeoutId));
+    this.resolvers.clear();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.boundHandleMessage);
+    }
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  async getData() {
+    if (!this.isMounted()) {
+      return null;
+    }
+    return new Promise((resolve) => {
+      const id = Math.random().toString(36).slice(2);
+      const timeoutId = setTimeout(() => {
+        const entry = this.resolvers.get(id);
+        if (!entry) {
+          return;
+        }
+        this.resolvers.delete(id);
+        entry.resolve(null);
+      }, 5e3);
+      this.resolvers.set(id, { resolve, timeoutId });
+      this.sendMessage({ type: MESSAGE_TYPES.GET_DATA });
+    });
+  }
+  sendMessage(message) {
+    if (this.iframe?.contentWindow) {
+      this.iframe.contentWindow.postMessage(message, this.linkUrl);
+    }
+  }
+  getContentWindow() {
+    return this.iframe?.contentWindow ?? null;
+  }
+  isMounted() {
+    return this.mounted && Boolean(this.iframe) && this.iframe?.isConnected === true;
+  }
+  async createIframe() {
+    if (!this.container) return;
+    const resolvedBusinessId = this.businessId ?? await this.parent.resolveBusinessId();
+    if (!resolvedBusinessId || !this.container || !this.mounted) {
+      console.error("Unable to mount element without a resolved business ID");
+      this.emit(EVENT_TYPES.ERROR, {
+        code: "BUSINESS_ID_REQUIRED",
+        message: "Unable to initialize checkout without a business ID."
+      });
+      return;
+    }
+    this.businessId = resolvedBusinessId;
+    const iframe = document.createElement("iframe");
+    const url = new URL(`${this.linkUrl}/elements/${this.type}`);
+    url.searchParams.set("businessId", resolvedBusinessId);
+    if (this.options.prefillEmail) url.searchParams.set("email", this.options.prefillEmail);
+    if (this.options.mode) url.searchParams.set("mode", this.options.mode);
+    iframe.src = url.toString();
+    iframe.style.border = "none";
+    iframe.style.width = "100%";
+    iframe.style.display = "block";
+    iframe.style.overflow = "hidden";
+    iframe.setAttribute("allowtransparency", "true");
+    iframe.setAttribute("frameborder", "0");
+    iframe.setAttribute(
+      "sandbox",
+      "allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
+    );
+    this.iframe = iframe;
+    this.container.appendChild(iframe);
+    iframe.onload = () => {
+      const publicKey = this.parent.getPublicKey();
+      this.sendMessage({
+        type: MESSAGE_TYPES.INIT,
+        businessId: resolvedBusinessId,
+        publicKey,
+        demoMode: publicKey.length === 0,
+        prefillEmail: this.options.prefillEmail,
+        appearance: this.parent.getAppearance()
+      });
+      const token = this.parent.getAccessToken();
+      if (token && this.type !== ELEMENT_TYPES.AUTH) {
+        this.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token });
+      }
+    };
+  }
+  handleMessage(event) {
+    if (!isAllowedOrigin(event.origin)) {
+      return;
+    }
+    const message = parseIframeMessage(event.data);
+    if (!message) return;
+    switch (message.type) {
+      case MESSAGE_TYPES.READY:
+        this.emit(EVENT_TYPES.READY, { height: message.height });
+        break;
+      case MESSAGE_TYPES.HEIGHT_CHANGE:
+        if (this.iframe) this.iframe.style.height = `${message.height}px`;
+        break;
+      case MESSAGE_TYPES.AUTHENTICATED:
+        const customer = message.customer ?? {
+          name: "",
+          email: null,
+          phone: null
+        };
+        this.emit(EVENT_TYPES.AUTHENTICATED, {
+          accountId: message.accountId,
+          customerId: message.customerId,
+          token: message.token,
+          customer
+        });
+        break;
+      case MESSAGE_TYPES.REQUIRES_OTP:
+        this.emit(EVENT_TYPES.REQUIRES_OTP, { contactMasked: message.contactMasked });
+        break;
+      case MESSAGE_TYPES.ERROR:
+        this.emit(EVENT_TYPES.ERROR, { code: message.code, message: message.message });
+        break;
+      case MESSAGE_TYPES.ADDRESS_CHANGED:
+      case MESSAGE_TYPES.ADDRESS_SELECTED:
+        this.parent._setAddressData(message.address);
+        this.emit(EVENT_TYPES.CHANGE, { address: message.address });
+        this.resolveData(message.address);
+        break;
+      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
+        this.parent._setPaymentData(message.method);
+        this.emit(EVENT_TYPES.CHANGE, { paymentMethod: message.method });
+        this.resolveData(message.method);
+        break;
+    }
+  }
+  emit(event, data) {
+    this.eventHandlers.get(event)?.forEach((handler) => handler(data));
+  }
+  resolveData(data) {
+    this.resolvers.forEach((entry) => {
+      clearTimeout(entry.timeoutId);
+      entry.resolve(data);
+    });
+    this.resolvers.clear();
+  }
+};
+function createElements(client, businessId, options) {
+  return new CimplifyElements(client, businessId, options);
+}
+
+// src/client.ts
+var ACCESS_TOKEN_STORAGE_KEY = "cimplify_access_token";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryable(error) {
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return true;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof CimplifyError) {
+    return error.retryable;
+  }
+  if (error instanceof CimplifyError && error.code === "SERVER_ERROR") {
+    return true;
+  }
+  return false;
+}
+function toNetworkError(error, isTestMode) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return enrichError(
+      new CimplifyError(
+        ErrorCode.TIMEOUT,
+        "Request timed out. Please check your connection and try again.",
+        true
+      ),
+      { isTestMode }
+    );
+  }
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return enrichError(
+      new CimplifyError(
+        ErrorCode.NETWORK_ERROR,
+        "Network error. Please check your internet connection.",
+        true
+      ),
+      { isTestMode }
+    );
+  }
+  if (error instanceof CimplifyError) {
+    return enrichError(error, { isTestMode });
+  }
+  return enrichError(
+    new CimplifyError(
+      ErrorCode.UNKNOWN_ERROR,
+      error instanceof Error ? error.message : "An unknown error occurred",
+      false
+    ),
+    { isTestMode }
+  );
+}
+function deriveUrls() {
+  const hostname = typeof window !== "undefined" ? window.location.hostname : "";
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    const protocol = window.location.protocol;
+    return {
+      baseUrl: `${protocol}//${hostname}:8082`,
+      linkApiUrl: `${protocol}//${hostname}:8080`
+    };
+  }
+  return {
+    baseUrl: "https://storefronts.cimplify.io",
+    linkApiUrl: "https://api.cimplify.io"
+  };
+}
+function getEnvPublicKey() {
+  try {
+    const env = globalThis.process;
+    return env?.env.NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY || void 0;
+  } catch {
+    return void 0;
+  }
+}
+var CimplifyClient = class {
+  constructor(config = {}) {
+    this.accessToken = null;
+    this.context = {};
+    this.businessId = null;
+    this.businessIdResolvePromise = null;
+    this.inflightRequests = /* @__PURE__ */ new Map();
+    this.publicKey = config.publicKey || getEnvPublicKey() || "";
+    const urls = deriveUrls();
+    this.baseUrl = urls.baseUrl;
+    this.linkApiUrl = urls.linkApiUrl;
+    this.credentials = config.credentials || "include";
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+    this.hooks = config.hooks ?? {};
+    this.accessToken = this.loadAccessToken();
+    if (!this.publicKey) {
+      console.warn(
+        '[Cimplify] No public key found. Set NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY in your environment, or pass { publicKey: "pk_..." } to createCimplifyClient().'
+      );
+    }
+  }
+  /** @deprecated Use getAccessToken() instead */
+  getSessionToken() {
+    return this.accessToken;
+  }
+  /** @deprecated Use setAccessToken() instead */
+  setSessionToken(token) {
+    this.setAccessToken(token);
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  getPublicKey() {
+    return this.publicKey;
+  }
+  isTestMode() {
+    return this.publicKey.trim().startsWith("pk_test_");
+  }
+  setAccessToken(token) {
+    const previous = this.accessToken;
+    this.accessToken = token;
+    this.saveAccessToken(token);
+    this.hooks.onSessionChange?.({
+      previousToken: previous,
+      newToken: token,
+      source: "manual"
+    });
+  }
+  clearSession() {
+    const previous = this.accessToken;
+    this.accessToken = null;
+    this.saveAccessToken(null);
+    this.hooks.onSessionChange?.({
+      previousToken: previous,
+      newToken: null,
+      source: "clear"
+    });
+  }
+  /** Set the active location/branch for all subsequent requests */
+  setLocationId(locationId) {
+    if (locationId) {
+      this.context.location_id = locationId;
+    } else {
+      delete this.context.location_id;
+    }
+  }
+  /** Get the currently active location ID */
+  getLocationId() {
+    return this.context.location_id ?? null;
+  }
+  /** Cache a resolved business ID for future element/checkouts initialization. */
+  setBusinessId(businessId) {
+    const normalized = businessId.trim();
+    if (!normalized) {
+      return;
+    }
+    this.businessId = normalized;
+  }
+  /** Get cached business ID if available. */
+  getBusinessId() {
+    return this.businessId;
+  }
+  /**
+   * Resolve business ID from public key once and cache it.
+   * Subsequent calls return the cached value (or shared in-flight promise).
+   */
+  async resolveBusinessId() {
+    if (this.businessId) {
+      return this.businessId;
+    }
+    if (this.businessIdResolvePromise) {
+      return this.businessIdResolvePromise;
+    }
+    this.businessIdResolvePromise = (async () => {
+      const result = await this.business.getInfo();
+      if (!result.ok || !result.value?.id) {
+        throw new CimplifyError(
+          ErrorCode.NOT_FOUND,
+          "Unable to resolve business ID from the current public key.",
+          true
+        );
+      }
+      this.businessId = result.value.id;
+      return result.value.id;
+    })();
+    try {
+      return await this.businessIdResolvePromise;
+    } finally {
+      this.businessIdResolvePromise = null;
+    }
+  }
+  loadAccessToken() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return localStorage.getItem(ACCESS_TOKEN_STORAGE_KEY);
+    }
+    return null;
+  }
+  saveAccessToken(token) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      if (token) {
+        localStorage.setItem(ACCESS_TOKEN_STORAGE_KEY, token);
+      } else {
+        localStorage.removeItem(ACCESS_TOKEN_STORAGE_KEY);
+      }
+    }
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.publicKey
+    };
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    return headers;
+  }
+  async resilientFetch(url, options) {
+    const method = options.method || "GET";
+    const path = url.replace(this.baseUrl, "").replace(this.linkApiUrl, "");
+    const startTime = Date.now();
+    let retryCount = 0;
+    const context = {
+      method,
+      path,
+      url,
+      body: options.body ? JSON.parse(options.body) : void 0,
+      startTime
+    };
+    this.hooks.onRequestStart?.(context);
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          ...options,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok || response.status >= 400 && response.status < 500) {
+          this.hooks.onRequestSuccess?.({
+            ...context,
+            status: response.status,
+            durationMs: Date.now() - startTime
+          });
+          return response;
+        }
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          retryCount++;
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          this.hooks.onRetry?.({
+            ...context,
+            attempt: retryCount,
+            delayMs: delay,
+            error: new Error(`Server error: ${response.status}`)
+          });
+          await sleep(delay);
+          continue;
+        }
+        this.hooks.onRequestSuccess?.({
+          ...context,
+          status: response.status,
+          durationMs: Date.now() - startTime
+        });
+        return response;
+      } catch (error) {
+        lastError = error;
+        const networkError = toNetworkError(error, this.isTestMode());
+        const errorRetryable = isRetryable(error);
+        if (!errorRetryable || attempt >= this.maxRetries) {
+          this.hooks.onRequestError?.({
+            ...context,
+            error: networkError,
+            durationMs: Date.now() - startTime,
+            retryCount,
+            retryable: errorRetryable
+          });
+          throw networkError;
+        }
+        retryCount++;
+        const delay = this.retryDelay * Math.pow(2, attempt);
+        this.hooks.onRetry?.({
+          ...context,
+          attempt: retryCount,
+          delayMs: delay,
+          error: networkError
+        });
+        await sleep(delay);
+      }
+    }
+    const finalError = toNetworkError(lastError, this.isTestMode());
+    this.hooks.onRequestError?.({
+      ...context,
+      error: finalError,
+      durationMs: Date.now() - startTime,
+      retryCount,
+      retryable: false
+    });
+    throw finalError;
+  }
+  getDedupeKey(type, payload) {
+    return `${type}:${JSON.stringify(payload)}`;
+  }
+  async deduplicatedRequest(key, requestFn) {
+    const existing = this.inflightRequests.get(key);
+    if (existing) {
+      return existing;
+    }
+    const request = requestFn().finally(() => {
+      this.inflightRequests.delete(key);
+    });
+    this.inflightRequests.set(key, request);
+    return request;
+  }
+  async query(query, variables) {
+    const body = { query };
+    if (variables) {
+      body.variables = variables;
+    }
+    if (Object.keys(this.context).length > 0) {
+      body.context = this.context;
+    }
+    const key = this.getDedupeKey("query", body);
+    return this.deduplicatedRequest(key, async () => {
+      const response = await this.resilientFetch(`${this.baseUrl}/api/q`, {
+        method: "POST",
+        credentials: this.credentials,
+        headers: this.getHeaders(),
+        body: JSON.stringify(body)
+      });
+      return this.handleResponse(response);
+    });
+  }
+  async call(method, args) {
+    const body = {
+      method,
+      args: args !== void 0 ? [args] : []
+    };
+    if (Object.keys(this.context).length > 0) {
+      body.context = this.context;
+    }
+    const response = await this.resilientFetch(`${this.baseUrl}/api/m`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: JSON.stringify(body)
+    });
+    return this.handleResponse(response);
+  }
+  async get(path) {
+    const key = this.getDedupeKey("get", path);
+    return this.deduplicatedRequest(key, async () => {
+      const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
+        method: "GET",
+        credentials: this.credentials,
+        headers: this.getHeaders()
+      });
+      return this.handleRestResponse(response);
+    });
+  }
+  async post(path, body) {
+    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRestResponse(response);
+  }
+  async delete(path) {
+    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    return this.handleRestResponse(response);
+  }
+  async linkGet(path) {
+    const key = this.getDedupeKey("linkGet", path);
+    return this.deduplicatedRequest(key, async () => {
+      const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+        method: "GET",
+        credentials: this.credentials,
+        headers: this.getHeaders()
+      });
+      return this.handleRestResponse(response);
+    });
+  }
+  async linkPost(path, body) {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRestResponse(response);
+  }
+  async linkDelete(path) {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+      method: "DELETE",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    return this.handleRestResponse(response);
+  }
+  async handleRestResponse(response) {
+    const json = await response.json();
+    if (!response.ok) {
+      const error = enrichError(
+        new CimplifyError(
+          json.error?.error_code || "API_ERROR",
+          json.error?.error_message || "An error occurred",
+          false
+        ),
+        { isTestMode: this.isTestMode() }
+      );
+      if (response.status === 401 || error.code === ErrorCode.UNAUTHORIZED) {
+        console.warn(
+          "[Cimplify] Received 401 Unauthorized. Access token may be missing/expired. Refresh authentication and retry the request."
+        );
+      }
+      throw error;
+    }
+    return json.data;
+  }
+  async handleResponse(response) {
+    const json = await response.json();
+    if (!json.success || json.error) {
+      const error = enrichError(
+        new CimplifyError(
+          json.error?.code || "UNKNOWN_ERROR",
+          json.error?.message || "An unknown error occurred",
+          json.error?.retryable || false
+        ),
+        { isTestMode: this.isTestMode() }
+      );
+      if (response.status === 401 || error.code === ErrorCode.UNAUTHORIZED) {
+        console.warn(
+          "[Cimplify] Received 401 Unauthorized. Access token may be missing/expired. Refresh authentication and retry the request."
+        );
+      }
+      throw error;
+    }
+    return json.data;
+  }
+  get catalogue() {
+    if (!this._catalogue) {
+      this._catalogue = new CatalogueQueries(this);
+    }
+    return this._catalogue;
+  }
+  get cart() {
+    if (!this._cart) {
+      this._cart = new CartOperations(this);
+    }
+    return this._cart;
+  }
+  get checkout() {
+    if (!this._checkout) {
+      this._checkout = new CheckoutService(this);
+    }
+    return this._checkout;
+  }
+  get orders() {
+    if (!this._orders) {
+      this._orders = new OrderQueries(this);
+    }
+    return this._orders;
+  }
+  get link() {
+    if (!this._link) {
+      this._link = new LinkService(this);
+    }
+    return this._link;
+  }
+  get auth() {
+    if (!this._auth) {
+      this._auth = new AuthService(this);
+    }
+    return this._auth;
+  }
+  get business() {
+    if (!this._business) {
+      this._business = new BusinessService(this);
+    }
+    return this._business;
+  }
+  get inventory() {
+    if (!this._inventory) {
+      this._inventory = new InventoryService(this);
+    }
+    return this._inventory;
+  }
+  get scheduling() {
+    if (!this._scheduling) {
+      this._scheduling = new SchedulingService(this);
+    }
+    return this._scheduling;
+  }
+  get lite() {
+    if (!this._lite) {
+      this._lite = new LiteService(this);
+    }
+    return this._lite;
+  }
+  get fx() {
+    if (!this._fx) {
+      this._fx = new FxService(this);
+    }
+    return this._fx;
+  }
+  /**
+   * Create a CimplifyElements instance for embedding checkout components.
+   * Like Stripe's stripe.elements().
+   *
+   * @param businessId - The business ID for checkout context
+   * @param options - Optional configuration for elements
+   *
+   * @example
+   * ```ts
+   * const elements = client.elements('bus_xxx');
+   * const authElement = elements.create('auth');
+   * authElement.mount('#auth-container');
+   * ```
+   */
+  elements(businessId, options) {
+    if (businessId) {
+      this.setBusinessId(businessId);
+    }
+    return createElements(this, businessId ?? this.businessId ?? void 0, options);
+  }
+};
+function createCimplifyClient(config = {}) {
+  return new CimplifyClient(config);
+}
+var LOCATION_STORAGE_KEY = "cimplify_location_id";
+var DEFAULT_CURRENCY = "USD";
+var DEFAULT_COUNTRY = "US";
+function createDefaultClient() {
+  const processRef = globalThis.process;
+  const envPublicKey = processRef?.env?.NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY || "";
+  return createCimplifyClient({ publicKey: envPublicKey });
+}
+function getStoredLocationId() {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return null;
+  }
+  const value = window.localStorage.getItem(LOCATION_STORAGE_KEY);
+  if (!value) {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function setStoredLocationId(locationId) {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return;
+  }
+  if (!locationId) {
+    window.localStorage.removeItem(LOCATION_STORAGE_KEY);
+    return;
+  }
+  window.localStorage.setItem(LOCATION_STORAGE_KEY, locationId);
+}
+function resolveInitialLocation(locations) {
+  if (locations.length === 0) {
+    return null;
+  }
+  const storedId = getStoredLocationId();
+  if (storedId) {
+    const matched = locations.find((location) => location.id === storedId);
+    if (matched) {
+      return matched;
+    }
+  }
+  return locations[0];
+}
+var CimplifyContext = createContext(null);
+function CimplifyProvider({
+  client,
+  children,
+  onLocationChange
+}) {
+  const resolvedClient = useMemo(() => client ?? createDefaultClient(), [client]);
+  const onLocationChangeRef = useRef(onLocationChange);
+  const [business, setBusiness] = useState(null);
+  const [locations, setLocations] = useState([]);
+  const [currentLocation, setCurrentLocationState] = useState(null);
+  const [isReady, setIsReady] = useState(false);
+  useEffect(() => {
+    onLocationChangeRef.current = onLocationChange;
+  }, [onLocationChange]);
+  const isDemoMode = resolvedClient.getPublicKey().trim().length === 0;
+  const setCurrentLocation = useCallback(
+    (location) => {
+      setCurrentLocationState(location);
+      resolvedClient.setLocationId(location.id);
+      setStoredLocationId(location.id);
+      onLocationChangeRef.current?.(location);
+    },
+    [resolvedClient]
+  );
+  useEffect(() => {
+    let cancelled = false;
+    async function bootstrap() {
+      setIsReady(false);
+      if (isDemoMode) {
+        if (!cancelled) {
+          setBusiness(null);
+          setLocations([]);
+          setCurrentLocationState(null);
+          resolvedClient.setLocationId(null);
+          setStoredLocationId(null);
+          setIsReady(true);
+        }
+        return;
+      }
+      const [businessResult, locationsResult] = await Promise.all([
+        resolvedClient.business.getInfo(),
+        resolvedClient.business.getLocations()
+      ]);
+      if (cancelled) {
+        return;
+      }
+      const nextBusiness = businessResult.ok ? businessResult.value : null;
+      const nextLocations = locationsResult.ok && Array.isArray(locationsResult.value) ? locationsResult.value : [];
+      const initialLocation = resolveInitialLocation(nextLocations);
+      setBusiness(nextBusiness);
+      if (nextBusiness?.id) {
+        resolvedClient.setBusinessId(nextBusiness.id);
+      }
+      setLocations(nextLocations);
+      if (initialLocation) {
+        setCurrentLocationState(initialLocation);
+        resolvedClient.setLocationId(initialLocation.id);
+        setStoredLocationId(initialLocation.id);
+      } else {
+        setCurrentLocationState(null);
+        resolvedClient.setLocationId(null);
+        setStoredLocationId(null);
+      }
+      setIsReady(true);
+    }
+    bootstrap().catch(() => {
+      if (cancelled) {
+        return;
+      }
+      setBusiness(null);
+      setLocations([]);
+      setCurrentLocationState(null);
+      resolvedClient.setLocationId(null);
+      setStoredLocationId(null);
+      setIsReady(true);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [resolvedClient, isDemoMode]);
+  const contextValue = useMemo(
+    () => ({
+      client: resolvedClient,
+      business,
+      currency: business?.default_currency || DEFAULT_CURRENCY,
+      country: business?.country_code || DEFAULT_COUNTRY,
+      locations,
+      currentLocation,
+      setCurrentLocation,
+      isReady,
+      isDemoMode
+    }),
+    [
+      resolvedClient,
+      business,
+      locations,
+      currentLocation,
+      setCurrentLocation,
+      isReady,
+      isDemoMode
+    ]
+  );
+  return /* @__PURE__ */ jsx(CimplifyContext.Provider, { value: contextValue, children });
+}
+function useCimplify() {
+  const context = useContext(CimplifyContext);
+  if (!context) {
+    throw new Error("useCimplify must be used within CimplifyProvider");
+  }
+  return context;
+}
+function useOptionalCimplify() {
+  return useContext(CimplifyContext);
+}
+var productsCache = /* @__PURE__ */ new Map();
+var productsInflight = /* @__PURE__ */ new Map();
+function buildProductsCacheKey(client, locationId, options) {
+  return JSON.stringify({
+    key: client.getPublicKey(),
+    location_id: locationId || "__none__",
+    options
+  });
+}
+function useProducts(options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useProducts must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const locationId = client.getLocationId();
+  const previousLocationIdRef = useRef(locationId);
+  const requestIdRef = useRef(0);
+  const queryOptions = useMemo(
+    () => ({
+      category: options.category,
+      collection: options.collection,
+      search: options.search,
+      featured: options.featured,
+      limit: options.limit
+    }),
+    [options.category, options.collection, options.featured, options.limit, options.search]
+  );
+  const cacheKey = useMemo(
+    () => buildProductsCacheKey(client, locationId, queryOptions),
+    [client, locationId, queryOptions]
+  );
+  const cached = productsCache.get(cacheKey);
+  const [products, setProducts] = useState(cached?.products ?? []);
+  const [isLoading, setIsLoading] = useState(enabled && !cached);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (previousLocationIdRef.current !== locationId) {
+      productsCache.clear();
+      productsInflight.clear();
+      previousLocationIdRef.current = locationId;
+    }
+  }, [locationId]);
+  const load = useCallback(
+    async (force = false) => {
+      if (!enabled) {
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = productsCache.get(cacheKey);
+        if (cacheEntry) {
+          setProducts(cacheEntry.products);
+          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 });
+        if (nextRequestId === requestIdRef.current) {
+          setProducts(value);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, queryOptions]
+  );
+  useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = useCallback(async () => {
+    productsCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { products, isLoading, error, refetch };
+}
+var productCache = /* @__PURE__ */ new Map();
+var productInflight = /* @__PURE__ */ new Map();
+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
+  });
+}
+function useProduct(slugOrId, options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useProduct must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const locationId = client.getLocationId();
+  const previousLocationIdRef = useRef(locationId);
+  const requestIdRef = useRef(0);
+  const normalizedSlugOrId = useMemo(() => (slugOrId || "").trim(), [slugOrId]);
+  const cacheKey = useMemo(
+    () => buildProductCacheKey(client, locationId, normalizedSlugOrId),
+    [client, locationId, normalizedSlugOrId]
+  );
+  const cached = productCache.get(cacheKey);
+  const [product, setProduct] = useState(cached?.product ?? null);
+  const [isLoading, setIsLoading] = useState(
+    enabled && normalizedSlugOrId.length > 0 && !cached
+  );
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (previousLocationIdRef.current !== locationId) {
+      productCache.clear();
+      productInflight.clear();
+      previousLocationIdRef.current = locationId;
+    }
+  }, [locationId]);
+  const load = useCallback(
+    async (force = false) => {
+      if (!enabled || normalizedSlugOrId.length === 0) {
+        setProduct(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = productCache.get(cacheKey);
+        if (cacheEntry) {
+          setProduct(cacheEntry.product);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = productInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = isLikelySlug(normalizedSlugOrId) ? await client.catalogue.getProductBySlug(normalizedSlugOrId) : await client.catalogue.getProduct(normalizedSlugOrId);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          productInflight.set(
+            cacheKey,
+            promise.finally(() => {
+              productInflight.delete(cacheKey);
+            })
+          );
+        }
+        const value = await promise;
+        productCache.set(cacheKey, { product: value });
+        if (nextRequestId === requestIdRef.current) {
+          setProduct(value);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, normalizedSlugOrId]
+  );
+  useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = useCallback(async () => {
+    productCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { product, isLoading, error, refetch };
+}
+var categoriesCache = /* @__PURE__ */ new Map();
+var categoriesInflight = /* @__PURE__ */ new Map();
+function buildCategoriesCacheKey(client) {
+  return client.getPublicKey() || "__demo__";
+}
+function useCategories(options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useCategories must be used within CimplifyProvider or passed { client }.");
+  }
+  const enabled = options.enabled ?? true;
+  const cacheKey = useMemo(() => buildCategoriesCacheKey(client), [client]);
+  const cached = categoriesCache.get(cacheKey);
+  const [categories, setCategories] = useState(cached ?? []);
+  const [isLoading, setIsLoading] = useState(enabled && !cached);
+  const [error, setError] = useState(null);
+  const load = useCallback(
+    async (force = false) => {
+      if (!enabled) {
+        setIsLoading(false);
+        return;
+      }
+      setError(null);
+      if (!force) {
+        const cachedCategories = categoriesCache.get(cacheKey);
+        if (cachedCategories) {
+          setCategories(cachedCategories);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = categoriesInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = await client.catalogue.getCategories();
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          categoriesInflight.set(
+            cacheKey,
+            promise.finally(() => {
+              categoriesInflight.delete(cacheKey);
+            })
+          );
+        }
+        const value = await promise;
+        categoriesCache.set(cacheKey, value);
+        setCategories(value);
+      } catch (loadError) {
+        setError(loadError);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [cacheKey, client, enabled]
+  );
+  useEffect(() => {
+    void load(false);
+  }, [load]);
+  const refetch = useCallback(async () => {
+    categoriesCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { categories, isLoading, error, refetch };
+}
+var CART_STORAGE_PREFIX = "cimplify:cart:v2";
+var DEFAULT_TAX_RATE = 0.08875;
+var cartStores = /* @__PURE__ */ new Map();
+function toNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function roundMoney(value) {
+  return Math.max(0, Number(value.toFixed(2)));
+}
+function clampQuantity(quantity) {
+  if (!Number.isFinite(quantity)) {
+    return 1;
+  }
+  return Math.max(1, Math.floor(quantity));
+}
+function normalizeOptionIds(value) {
+  if (!value || value.length === 0) {
+    return void 0;
+  }
+  const normalized = Array.from(
+    new Set(
+      value.map((entry) => entry.trim()).filter((entry) => entry.length > 0)
+    )
+  ).sort();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function buildLineKey(productId, options) {
+  const parts = [productId];
+  if (options.locationId) {
+    parts.push(`l:${options.locationId}`);
+  }
+  if (options.variantId) {
+    parts.push(`v:${options.variantId}`);
+  }
+  const addOnOptionIds = normalizeOptionIds(options.addOnOptionIds);
+  if (addOnOptionIds && addOnOptionIds.length > 0) {
+    parts.push(`a:${addOnOptionIds.join(",")}`);
+  }
+  if (options.bundleSelections && options.bundleSelections.length > 0) {
+    parts.push(`b:${JSON.stringify(options.bundleSelections)}`);
+  }
+  if (options.compositeSelections && options.compositeSelections.length > 0) {
+    parts.push(`c:${JSON.stringify(options.compositeSelections)}`);
+  }
+  if (options.quoteId) {
+    parts.push(`q:${options.quoteId}`);
+  }
+  return parts.join("|");
+}
+function calculateLineSubtotal(item) {
+  let unitPrice = parsePrice(item.product.default_price);
+  if (item.variant?.price_adjustment) {
+    unitPrice += parsePrice(item.variant.price_adjustment);
+  }
+  for (const option of item.addOnOptions || []) {
+    if (option.default_price) {
+      unitPrice += parsePrice(option.default_price);
+    }
+  }
+  return roundMoney(unitPrice * item.quantity);
+}
+function calculateSummary(items) {
+  const subtotal = roundMoney(items.reduce((sum, item) => sum + calculateLineSubtotal(item), 0));
+  const tax = roundMoney(subtotal * DEFAULT_TAX_RATE);
+  return {
+    subtotal,
+    tax,
+    total: roundMoney(subtotal + tax)
+  };
+}
+function toProductFromServerItem(item, businessId) {
+  return {
+    id: item.item_id,
+    business_id: businessId,
+    category_id: item.category_id,
+    name: item.name,
+    slug: item.item_id,
+    description: item.description,
+    image_url: item.image_url,
+    default_price: item.base_price,
+    product_type: "product",
+    inventory_type: "none",
+    variant_strategy: "fetch_all",
+    is_active: item.is_available,
+    created_at: item.created_at,
+    updated_at: item.updated_at,
+    metadata: {
+      from_sdk: true
+    }
+  };
+}
+function mapServerCart(serverCart) {
+  const items = serverCart.items.map((item) => {
+    const variant = item.variant_info || item.variant_name ? {
+      id: item.variant_info?.id || item.variant_id || "",
+      name: item.variant_info?.name || item.variant_name || "Variant",
+      price_adjustment: item.variant_info?.price_adjustment
+    } : void 0;
+    const quoteId = typeof item.metadata?.quote_id === "string" ? item.metadata.quote_id : void 0;
+    return {
+      id: item.id,
+      product: toProductFromServerItem(item, serverCart.business_id),
+      quantity: clampQuantity(item.quantity),
+      locationId: serverCart.location_id,
+      variantId: item.variant_id,
+      variant,
+      quoteId,
+      addOnOptionIds: item.add_on_option_ids || void 0,
+      addOnOptions: (item.add_on_options || []).map((option) => ({
+        id: option.id,
+        name: option.name,
+        default_price: option.price
+      })),
+      bundleSelections: item.bundle_selections || void 0,
+      compositeSelections: item.composite_selections || void 0,
+      specialInstructions: item.special_instructions
+    };
+  });
+  return {
+    items,
+    subtotal: roundMoney(toNumber(serverCart.pricing.subtotal)),
+    tax: roundMoney(toNumber(serverCart.pricing.tax_amount)),
+    total: roundMoney(toNumber(serverCart.pricing.total_price)),
+    currency: serverCart.pricing.currency || "USD"
+  };
+}
+function buildStorageKey(storeKey) {
+  return `${CART_STORAGE_PREFIX}:${storeKey}`;
+}
+function createEmptySnapshot(currency) {
+  return {
+    items: [],
+    subtotal: 0,
+    tax: 0,
+    total: 0,
+    currency,
+    isLoading: true
+  };
+}
+function createCartStore(params) {
+  const { client, storeKey, locationId, isDemoMode, currency } = params;
+  const storageKey = buildStorageKey(storeKey);
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = createEmptySnapshot(currency);
+  let initialized = false;
+  let initializePromise = null;
+  function emit() {
+    listeners.forEach((listener) => {
+      listener();
+    });
+  }
+  function setSnapshot(nextSnapshot) {
+    snapshot = nextSnapshot;
+    persistSnapshot();
+    emit();
+  }
+  function updateSnapshot(updater) {
+    setSnapshot(updater(snapshot));
+  }
+  function persistSnapshot() {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return;
+    }
+    try {
+      window.localStorage.setItem(
+        storageKey,
+        JSON.stringify({
+          items: snapshot.items,
+          subtotal: snapshot.subtotal,
+          tax: snapshot.tax,
+          total: snapshot.total,
+          currency: snapshot.currency
+        })
+      );
+    } catch {
+    }
+  }
+  function hydrateFromStorage() {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return;
+    }
+    try {
+      const raw = window.localStorage.getItem(storageKey);
+      if (!raw) {
+        return;
+      }
+      const parsed = JSON.parse(raw);
+      if (!parsed || !Array.isArray(parsed.items)) {
+        return;
+      }
+      snapshot = {
+        items: parsed.items,
+        subtotal: toNumber(parsed.subtotal),
+        tax: toNumber(parsed.tax),
+        total: toNumber(parsed.total),
+        currency: typeof parsed.currency === "string" && parsed.currency ? parsed.currency : currency,
+        isLoading: !isDemoMode
+      };
+      emit();
+    } catch {
+    }
+  }
+  async function sync() {
+    if (isDemoMode) {
+      updateSnapshot((current) => ({
+        ...current,
+        isLoading: false
+      }));
+      return;
+    }
+    updateSnapshot((current) => ({
+      ...current,
+      isLoading: true
+    }));
+    const result = await client.cart.get();
+    if (!result.ok) {
+      updateSnapshot((current) => ({
+        ...current,
+        isLoading: false
+      }));
+      throw result.error;
+    }
+    const next = mapServerCart(result.value);
+    setSnapshot({
+      ...next,
+      isLoading: false
+    });
+  }
+  async function maybeResolveQuoteId(product, quantity, options) {
+    if (options.quoteId) {
+      return options.quoteId;
+    }
+    const addOnOptionIds = normalizeOptionIds(options.addOnOptionIds);
+    const requiresQuote = Boolean(
+      options.variantId || addOnOptionIds && addOnOptionIds.length > 0 || options.bundleSelections && options.bundleSelections.length > 0 || options.compositeSelections && options.compositeSelections.length > 0
+    );
+    if (!requiresQuote || isDemoMode) {
+      return void 0;
+    }
+    const quoteResult = await client.catalogue.fetchQuote({
+      product_id: product.id,
+      quantity,
+      location_id: options.locationId || locationId || void 0,
+      variant_id: options.variantId,
+      add_on_option_ids: addOnOptionIds,
+      bundle_selections: options.bundleSelections,
+      composite_selections: options.compositeSelections
+    });
+    if (!quoteResult.ok) {
+      throw quoteResult.error;
+    }
+    return quoteResult.value.quote_id;
+  }
+  async function addItem(product, quantity = 1, options = {}) {
+    const resolvedQuantity = clampQuantity(quantity);
+    const normalizedOptions = {
+      ...options,
+      locationId: options.locationId || locationId || void 0,
+      addOnOptionIds: normalizeOptionIds(options.addOnOptionIds)
+    };
+    const maybeProductWithVariants = product;
+    if (Array.isArray(maybeProductWithVariants.variants) && maybeProductWithVariants.variants.length > 0 && !normalizedOptions.variantId) {
+      console.warn(
+        "[Cimplify] addItem() called without variantId for a product that has variants. Default variant pricing will be used."
+      );
+    }
+    const previousSnapshot = snapshot;
+    const lineKey = buildLineKey(product.id, normalizedOptions);
+    const optimisticItem = {
+      id: `tmp_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+      product,
+      quantity: resolvedQuantity,
+      locationId: normalizedOptions.locationId,
+      variantId: normalizedOptions.variantId,
+      variant: normalizedOptions.variant,
+      quoteId: normalizedOptions.quoteId,
+      addOnOptionIds: normalizedOptions.addOnOptionIds,
+      addOnOptions: normalizedOptions.addOnOptions,
+      bundleSelections: normalizedOptions.bundleSelections,
+      compositeSelections: normalizedOptions.compositeSelections,
+      specialInstructions: normalizedOptions.specialInstructions
+    };
+    updateSnapshot((current) => {
+      const existingIndex = current.items.findIndex((item) => {
+        const itemKey = buildLineKey(item.product.id, {
+          locationId: item.locationId,
+          variantId: item.variantId,
+          quoteId: item.quoteId,
+          addOnOptionIds: item.addOnOptionIds,
+          bundleSelections: item.bundleSelections,
+          compositeSelections: item.compositeSelections
+        });
+        return itemKey === lineKey;
+      });
+      const nextItems = [...current.items];
+      if (existingIndex >= 0) {
+        const existing = nextItems[existingIndex];
+        nextItems[existingIndex] = {
+          ...existing,
+          quantity: existing.quantity + resolvedQuantity
+        };
+      } else {
+        nextItems.push(optimisticItem);
+      }
+      const summary = calculateSummary(nextItems);
+      return {
+        ...current,
+        items: nextItems,
+        subtotal: summary.subtotal,
+        tax: summary.tax,
+        total: summary.total
+      };
+    });
+    if (isDemoMode) {
+      return;
+    }
+    try {
+      const quoteId = await maybeResolveQuoteId(product, resolvedQuantity, normalizedOptions);
+      const result = await client.cart.addItem({
+        item_id: product.id,
+        quantity: resolvedQuantity,
+        variant_id: normalizedOptions.variantId,
+        quote_id: quoteId,
+        add_on_options: normalizedOptions.addOnOptionIds,
+        special_instructions: normalizedOptions.specialInstructions,
+        bundle_selections: normalizedOptions.bundleSelections,
+        composite_selections: normalizedOptions.compositeSelections
+      });
+      if (!result.ok) {
+        throw result.error;
+      }
+      await sync();
+    } catch (error) {
+      snapshot = previousSnapshot;
+      persistSnapshot();
+      emit();
+      throw error;
+    }
+  }
+  async function removeItem(itemId) {
+    const previousSnapshot = snapshot;
+    updateSnapshot((current) => {
+      const nextItems = current.items.filter((item) => item.id !== itemId);
+      const summary = calculateSummary(nextItems);
+      return {
+        ...current,
+        items: nextItems,
+        subtotal: summary.subtotal,
+        tax: summary.tax,
+        total: summary.total
+      };
+    });
+    if (isDemoMode) {
+      return;
+    }
+    try {
+      const result = await client.cart.removeItem(itemId);
+      if (!result.ok) {
+        throw result.error;
+      }
+      await sync();
+    } catch (error) {
+      snapshot = previousSnapshot;
+      persistSnapshot();
+      emit();
+      throw error;
+    }
+  }
+  async function updateQuantity(itemId, quantity) {
+    if (quantity <= 0) {
+      await removeItem(itemId);
+      return;
+    }
+    const resolvedQuantity = clampQuantity(quantity);
+    const previousSnapshot = snapshot;
+    updateSnapshot((current) => {
+      const nextItems = current.items.map(
+        (item) => item.id === itemId ? {
+          ...item,
+          quantity: resolvedQuantity
+        } : item
+      );
+      const summary = calculateSummary(nextItems);
+      return {
+        ...current,
+        items: nextItems,
+        subtotal: summary.subtotal,
+        tax: summary.tax,
+        total: summary.total
+      };
+    });
+    if (isDemoMode) {
+      return;
+    }
+    try {
+      const result = await client.cart.updateQuantity(itemId, resolvedQuantity);
+      if (!result.ok) {
+        throw result.error;
+      }
+      await sync();
+    } catch (error) {
+      snapshot = previousSnapshot;
+      persistSnapshot();
+      emit();
+      throw error;
+    }
+  }
+  async function clearCart() {
+    const previousSnapshot = snapshot;
+    updateSnapshot((current) => ({
+      ...current,
+      items: [],
+      subtotal: 0,
+      tax: 0,
+      total: 0
+    }));
+    if (isDemoMode) {
+      return;
+    }
+    try {
+      const result = await client.cart.clear();
+      if (!result.ok) {
+        throw result.error;
+      }
+      await sync();
+    } catch (error) {
+      snapshot = previousSnapshot;
+      persistSnapshot();
+      emit();
+      throw error;
+    }
+  }
+  async function initialize() {
+    if (initialized) {
+      if (initializePromise) {
+        await initializePromise;
+      }
+      return;
+    }
+    initialized = true;
+    hydrateFromStorage();
+    if (isDemoMode) {
+      updateSnapshot((current) => ({
+        ...current,
+        isLoading: false
+      }));
+      return;
+    }
+    initializePromise = sync().catch(() => {
+      updateSnapshot((current) => ({
+        ...current,
+        isLoading: false
+      }));
+    });
+    await initializePromise;
+    initializePromise = null;
+  }
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    initialize,
+    addItem,
+    removeItem,
+    updateQuantity,
+    clearCart,
+    sync
+  };
+}
+function getStoreKey(client, locationId, isDemoMode) {
+  return [
+    client.getPublicKey() || "__demo__",
+    locationId || "__no_location__",
+    isDemoMode ? "demo" : "live"
+  ].join(":");
+}
+function getOrCreateStore(params) {
+  const { client, locationId, isDemoMode, currency } = params;
+  const storeKey = getStoreKey(client, locationId, isDemoMode);
+  const existing = cartStores.get(storeKey);
+  if (existing) {
+    return existing;
+  }
+  const created = createCartStore({
+    client,
+    storeKey,
+    locationId,
+    isDemoMode,
+    currency
+  });
+  cartStores.set(storeKey, created);
+  return created;
+}
+function useCart(options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useCart must be used within CimplifyProvider or passed { client }.");
+  }
+  const locationId = options.locationId ?? client.getLocationId();
+  const isDemoMode = options.demoMode ?? context?.isDemoMode ?? client.getPublicKey().trim().length === 0;
+  const currency = options.currency ?? context?.currency ?? "USD";
+  const store = useMemo(
+    () => getOrCreateStore({
+      client,
+      locationId,
+      isDemoMode,
+      currency
+    }),
+    [client, currency, isDemoMode, locationId]
+  );
+  const snapshot = useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  useEffect(() => {
+    void store.initialize();
+  }, [store]);
+  const addItem = useCallback(
+    async (product, quantity, addOptions) => {
+      await store.addItem(product, quantity, addOptions);
+    },
+    [store]
+  );
+  const removeItem = useCallback(
+    async (itemId) => {
+      await store.removeItem(itemId);
+    },
+    [store]
+  );
+  const updateQuantity = useCallback(
+    async (itemId, quantity) => {
+      await store.updateQuantity(itemId, quantity);
+    },
+    [store]
+  );
+  const clearCart = useCallback(async () => {
+    await store.clearCart();
+  }, [store]);
+  const sync = useCallback(async () => {
+    try {
+      await store.sync();
+    } catch (syncError) {
+      throw syncError;
+    }
+  }, [store]);
+  const itemCount = useMemo(
+    () => snapshot.items.reduce((sum, item) => sum + item.quantity, 0),
+    [snapshot.items]
+  );
+  return {
+    items: snapshot.items,
+    itemCount,
+    subtotal: snapshot.subtotal,
+    tax: snapshot.tax,
+    total: snapshot.total,
+    currency: snapshot.currency,
+    isEmpty: itemCount === 0,
+    isLoading: snapshot.isLoading,
+    addItem,
+    removeItem,
+    updateQuantity,
+    clearCart,
+    sync
+  };
+}
+var orderCache = /* @__PURE__ */ new Map();
+var orderInflight = /* @__PURE__ */ new Map();
+function buildOrderCacheKey(client, orderId) {
+  return `${client.getPublicKey() || "__demo__"}:${orderId}`;
+}
+function useOrder(orderId, options = {}) {
+  const context = useOptionalCimplify();
+  const client = options.client ?? context?.client;
+  if (!client) {
+    throw new Error("useOrder must be used within CimplifyProvider or passed { client }.");
+  }
+  const normalizedOrderId = useMemo(() => (orderId || "").trim(), [orderId]);
+  const enabled = options.enabled ?? true;
+  const poll = options.poll ?? false;
+  const pollInterval = options.pollInterval ?? 5e3;
+  const requestIdRef = useRef(0);
+  const cacheKey = useMemo(
+    () => buildOrderCacheKey(client, normalizedOrderId),
+    [client, normalizedOrderId]
+  );
+  const cached = orderCache.get(cacheKey);
+  const [order, setOrder] = useState(cached?.order ?? null);
+  const [isLoading, setIsLoading] = useState(
+    enabled && normalizedOrderId.length > 0 && !cached
+  );
+  const [error, setError] = useState(null);
+  const load = useCallback(
+    async (force = false) => {
+      if (!enabled || normalizedOrderId.length === 0) {
+        setOrder(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextRequestId = ++requestIdRef.current;
+      setError(null);
+      if (!force) {
+        const cacheEntry = orderCache.get(cacheKey);
+        if (cacheEntry) {
+          setOrder(cacheEntry.order);
+          setIsLoading(false);
+          return;
+        }
+      }
+      setIsLoading(true);
+      try {
+        const existing = orderInflight.get(cacheKey);
+        const promise = existing ?? (async () => {
+          const result = await client.orders.get(normalizedOrderId);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        })();
+        if (!existing) {
+          orderInflight.set(
+            cacheKey,
+            promise.finally(() => {
+              orderInflight.delete(cacheKey);
+            })
+          );
+        }
+        const value = await promise;
+        orderCache.set(cacheKey, { order: value });
+        if (nextRequestId === requestIdRef.current) {
+          setOrder(value);
+          setError(null);
+        }
+      } catch (loadError) {
+        if (nextRequestId === requestIdRef.current) {
+          setError(loadError);
+        }
+      } finally {
+        if (nextRequestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [cacheKey, client, enabled, normalizedOrderId]
+  );
+  useEffect(() => {
+    void load(false);
+  }, [load]);
+  useEffect(() => {
+    if (!poll || !enabled || normalizedOrderId.length === 0) {
+      return;
+    }
+    const timer = window.setInterval(() => {
+      void load(true);
+    }, Math.max(1e3, pollInterval));
+    return () => {
+      window.clearInterval(timer);
+    };
+  }, [enabled, load, normalizedOrderId.length, poll, pollInterval]);
+  const refetch = useCallback(async () => {
+    orderCache.delete(cacheKey);
+    await load(true);
+  }, [cacheKey, load]);
+  return { order, isLoading, error, refetch };
+}
+var LOCATION_STORAGE_KEY2 = "cimplify_location_id";
+function readStoredLocationId() {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return null;
+  }
+  const value = window.localStorage.getItem(LOCATION_STORAGE_KEY2);
+  if (!value) {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function writeStoredLocationId(locationId) {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return;
+  }
+  if (!locationId) {
+    window.localStorage.removeItem(LOCATION_STORAGE_KEY2);
+    return;
+  }
+  window.localStorage.setItem(LOCATION_STORAGE_KEY2, locationId);
+}
+function resolveLocation(locations, preferredId) {
+  if (locations.length === 0) {
+    return null;
+  }
+  if (preferredId) {
+    const found = locations.find((location) => location.id === preferredId);
+    if (found) {
+      return found;
+    }
+  }
+  return locations[0];
+}
+function useLocations(options = {}) {
+  const context = useOptionalCimplify();
+  if (context && (!options.client || context.client === options.client)) {
+    return {
+      locations: context.locations,
+      currentLocation: context.currentLocation,
+      setCurrentLocation: context.setCurrentLocation,
+      isLoading: !context.isReady
+    };
+  }
+  const client = options.client;
+  const [locations, setLocations] = useState([]);
+  const [currentLocation, setCurrentLocationState] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const setCurrentLocation = useCallback(
+    (location) => {
+      setCurrentLocationState(location);
+      if (client) {
+        client.setLocationId(location.id);
+      }
+      writeStoredLocationId(location.id);
+    },
+    [client]
+  );
+  useEffect(() => {
+    if (!client) {
+      setLocations([]);
+      setCurrentLocationState(null);
+      setIsLoading(false);
+      return;
+    }
+    const activeClient = client;
+    let cancelled = false;
+    async function loadLocations() {
+      setIsLoading(true);
+      const result = await activeClient.business.getLocations();
+      if (cancelled) {
+        return;
+      }
+      if (!result.ok) {
+        setLocations([]);
+        setCurrentLocationState(null);
+        setIsLoading(false);
+        return;
+      }
+      const nextLocations = result.value;
+      const preferredId = activeClient.getLocationId() ?? readStoredLocationId();
+      const resolved = resolveLocation(nextLocations, preferredId);
+      setLocations(nextLocations);
+      setCurrentLocationState(resolved);
+      activeClient.setLocationId(resolved?.id || null);
+      writeStoredLocationId(resolved?.id || null);
+      setIsLoading(false);
+    }
+    void loadLocations();
+    return () => {
+      cancelled = true;
+    };
+  }, [client]);
+  return {
+    locations,
+    currentLocation,
+    setCurrentLocation,
+    isLoading
+  };
+}
+var ElementsContext = createContext({
+  elements: null,
+  isReady: false
+});
+function useElements() {
+  return useContext(ElementsContext).elements;
+}
+function useElementsReady() {
+  return useContext(ElementsContext).isReady;
+}
+function ElementsProvider({
+  client,
+  businessId,
+  options,
+  children
+}) {
+  const [elements, setElements] = useState(null);
+  const [isReady, setIsReady] = useState(false);
+  const initialOptionsRef = useRef(options);
+  useEffect(() => {
+    let cancelled = false;
+    let instance = null;
+    setIsReady(false);
+    setElements(null);
+    async function bootstrap() {
+      const resolvedBusinessId = businessId ?? await client.resolveBusinessId().catch(() => null);
+      if (!resolvedBusinessId) {
+        if (!cancelled) {
+          setIsReady(false);
+          setElements(null);
+        }
+        return;
+      }
+      instance = client.elements(resolvedBusinessId, initialOptionsRef.current);
+      if (cancelled) {
+        instance.destroy();
+        return;
+      }
+      setElements(instance);
+      setIsReady(true);
+    }
+    void bootstrap();
+    return () => {
+      cancelled = true;
+      if (instance) {
+        instance.destroy();
+      }
+    };
+  }, [client, businessId]);
   return /* @__PURE__ */ jsx(ElementsContext.Provider, { value: { elements, isReady }, children });
 }
 function AuthElement({
@@ -646,4 +5243,4 @@ function useCheckout() {
   return { submit, process, isLoading };
 }
 
-export { Ad, AdProvider, AddressElement, AuthElement, CimplifyCheckout, ElementsProvider, PaymentElement, useAds, useCheckout, useElements, useElementsReady };
+export { Ad, AdProvider, AddressElement, AuthElement, CimplifyCheckout, CimplifyProvider, ElementsProvider, PaymentElement, useAds, useCart, useCategories, useCheckout, useCimplify, useElements, useElementsReady, useLocations, useOptionalCimplify, useOrder, useProduct, useProducts };