@numueg/theme-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2669 @@
+import { createContext, useContext, useMemo, useState, useEffect, useCallback, useRef, createElement, Component } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/hooks/useShop.ts
+var ShopContext = createContext(null);
+var ProductContext = createContext(null);
+var CollectionContext = createContext(null);
+var CartContext = createContext(null);
+var CustomerContext = createContext(null);
+var ThemeSettingsContext = createContext(null);
+var LocalizationContext = createContext(null);
+var PageContext = createContext(null);
+function useLocalization() {
+  const ctx = useContext(LocalizationContext);
+  if (!ctx) throw new Error("useLocalization must be used within NuMuProvider");
+  return ctx;
+}
+function useDirection() {
+  const { direction } = useLocalization();
+  return direction;
+}
+function useLocale() {
+  const { locale } = useLocalization();
+  return locale;
+}
+function useTranslation() {
+  const { translations, locale } = useLocalization();
+  return {
+    t: (key, fallback) => translations[key] || fallback || key,
+    locale
+  };
+}
+function useFieldTranslation(entity, field) {
+  const { locale } = useLocalization();
+  if (!entity) return void 0;
+  const translated = entity.attributes && typeof entity.attributes === "object" ? entity.attributes[`${field}_${locale}`] : void 0;
+  if (typeof translated === "string" && translated) return translated;
+  const base = entity[field];
+  if (typeof base === "string") return base;
+  if (base == null) return void 0;
+  return String(base);
+}
+function useNumberFormat() {
+  const { formatNumber } = useLocalization();
+  return formatNumber;
+}
+
+// src/hooks/useShop.ts
+var DEFAULT_PROTOCOL = typeof window !== "undefined" ? window.location.protocol.replace(":", "") : "https";
+function resolveDomain(store) {
+  if (store.domain) return store.domain;
+  if (store.subdomain) {
+    const platform = typeof window !== "undefined" && window.__NUMU_PLATFORM_DOMAIN || "numueg.app";
+    return `${store.subdomain}.${platform}`;
+  }
+  return store.slug;
+}
+function useShop() {
+  const ctx = useContext(ShopContext);
+  if (!ctx) throw new Error("useShop must be used within NuMuProvider");
+  const locale = useLocale();
+  return useMemo(() => {
+    const domain = resolveDomain(ctx);
+    const settings = ctx.settings;
+    const localePrefixEnabled = Boolean(
+      settings && settings.locale_url_prefix_enabled
+    );
+    const defaultLocale = ctx.default_language || "en";
+    const prefixedLocales = settings?.locale_url_prefix_locales || null;
+    const shouldPrefix = (l) => {
+      if (!localePrefixEnabled) return false;
+      if (prefixedLocales) return prefixedLocales.includes(l);
+      return l !== defaultLocale;
+    };
+    const formatUrl = (path) => {
+      if (!path) return `${DEFAULT_PROTOCOL}://${domain}/`;
+      if (/^https?:\/\//i.test(path)) return path;
+      if (path.startsWith("//")) return `${DEFAULT_PROTOCOL}:${path}`;
+      let normalized = path.startsWith("/") ? path : `/${path}`;
+      if (locale && shouldPrefix(locale)) {
+        const prefix = `/${locale}/`;
+        const root = `/${locale}`;
+        if (normalized !== root && !normalized.startsWith(prefix)) {
+          normalized = `${root}${normalized}`;
+        }
+      }
+      return `${DEFAULT_PROTOCOL}://${domain}${normalized}`;
+    };
+    return { ...ctx, domain, formatUrl };
+  }, [ctx, locale]);
+}
+function useProduct() {
+  const ctx = useContext(ProductContext);
+  if (!ctx) throw new Error("useProduct must be used within ProductProvider");
+  return ctx;
+}
+function useProductOptional() {
+  return useContext(ProductContext);
+}
+function useCollection() {
+  const ctx = useContext(CollectionContext);
+  if (!ctx) throw new Error("useCollection must be used within CollectionProvider");
+  return ctx;
+}
+function useCollectionOptional() {
+  return useContext(CollectionContext);
+}
+function useCart() {
+  const ctx = useContext(CartContext);
+  if (!ctx) throw new Error("useCart must be used within NuMuProvider");
+  return ctx;
+}
+function useCustomer() {
+  return useContext(CustomerContext);
+}
+function useThemeSettings() {
+  const ctx = useContext(ThemeSettingsContext);
+  if (!ctx) throw new Error("useThemeSettings must be used within NuMuProvider");
+  return ctx;
+}
+function usePage() {
+  return useContext(PageContext);
+}
+var SectionContext = createContext(null);
+function useSection() {
+  const ctx = useContext(SectionContext);
+  if (!ctx) throw new Error("useSection must be used within a section component");
+  return ctx;
+}
+function useSectionOptional() {
+  return useContext(SectionContext);
+}
+
+// src/hooks/useMoney.ts
+function useMoney(currencyOverride) {
+  const { formatMoney } = useLocalization();
+  const shop = useShop();
+  const ccy = currencyOverride || shop?.currency;
+  return (amount) => formatMoney(amount, ccy);
+}
+var DEFAULT_WIDTHS = [320, 480, 640, 768, 1024, 1280, 1600, 1920];
+var DEFAULT_SIZES = "(min-width: 1024px) 25vw, (min-width: 640px) 50vw, 100vw";
+function useImage(src, opts = {}) {
+  const { sizes = DEFAULT_SIZES, widths = DEFAULT_WIDTHS, alt = "" } = opts;
+  return useMemo(() => {
+    if (!src) return { src: null, srcSet: null, sizes, alt };
+    if (/[?&]w=\d+/.test(src)) return { src, srcSet: null, sizes, alt };
+    const sep = src.includes("?") ? "&" : "?";
+    const srcSet = widths.map((w) => `${src}${sep}w=${w} ${w}w`).join(", ");
+    return { src, srcSet, sizes, alt };
+  }, [src, sizes, widths, alt]);
+}
+function useProducts(opts = {}) {
+  const { limit, fetchIfMissing = false } = opts;
+  const page = usePage();
+  const shop = useShop();
+  const initial = page?.data?.products ?? null;
+  const [products, setProducts] = useState(initial ?? []);
+  const [loading, setLoading] = useState(
+    initial == null && fetchIfMissing
+  );
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (initial != null) return;
+    if (!fetchIfMissing) return;
+    if (!shop?.id) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const params = new URLSearchParams({ store_id: shop.id });
+        if (limit) params.set("limit", String(limit));
+        const res = await fetch(`/api/products?${params.toString()}`);
+        if (!res.ok) throw new Error(`/api/products \u2192 ${res.status}`);
+        const data = await res.json();
+        if (cancelled) return;
+        setProducts(data.products ?? []);
+        setLoading(false);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [initial, fetchIfMissing, limit, shop?.id]);
+  const sliced = limit != null ? products.slice(0, limit) : products;
+  return { products: sliced, loading, error };
+}
+function useCollections(opts = {}) {
+  const { limit, fetchIfMissing = false } = opts;
+  const page = usePage();
+  const shop = useShop();
+  const initial = page?.data?.collections ?? null;
+  const [collections, setCollections] = useState(initial ?? []);
+  const [loading, setLoading] = useState(
+    initial == null && fetchIfMissing
+  );
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (initial != null) return;
+    if (!fetchIfMissing) return;
+    if (!shop?.id) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const params = new URLSearchParams({ store_id: shop.id });
+        const res = await fetch(`/api/collections?${params.toString()}`);
+        if (!res.ok) throw new Error(`/api/collections \u2192 ${res.status}`);
+        const data = await res.json();
+        if (cancelled) return;
+        setCollections(data.collections ?? []);
+        setLoading(false);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [initial, fetchIfMissing, shop?.id]);
+  const sliced = limit != null ? collections.slice(0, limit) : collections;
+  return { collections: sliced, loading, error };
+}
+var NOOP_ACTIONS = {
+  login: async () => ({}),
+  register: async () => ({}),
+  logout: async () => ({}),
+  requestRecover: async () => ({}),
+  confirmReset: async () => ({}),
+  verifyEmail: async () => ({}),
+  resendVerification: async () => ({}),
+  updateProfile: async () => ({}),
+  changePassword: async () => ({}),
+  refresh: async () => void 0
+};
+var CustomerActionsContext = createContext(NOOP_ACTIONS);
+
+// src/hooks/useCustomerActions.ts
+function useCustomerActions() {
+  return useContext(CustomerActionsContext);
+}
+function unwrap(json) {
+  if (json && typeof json === "object" && "data" in json) {
+    return json.data;
+  }
+  return json;
+}
+function useOrders() {
+  const customer = useCustomer();
+  const [orders, setOrders] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (!customer) {
+      setOrders([]);
+      setError(null);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    void (async () => {
+      try {
+        const res = await fetch("/api/customer/me/orders", {
+          method: "GET",
+          credentials: "include",
+          cache: "no-store"
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const body = unwrap(await res.json());
+        if (cancelled) return;
+        const list = Array.isArray(body) ? body : Array.isArray(body?.items) ? body.items : [];
+        setOrders(list);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [customer, tick]);
+  return {
+    orders,
+    loading,
+    error,
+    refresh: () => setTick((t) => t + 1)
+  };
+}
+function useOrder(id) {
+  const customer = useCustomer();
+  const [order, setOrder] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (!customer || !id) {
+      setOrder(null);
+      setError(null);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    void (async () => {
+      try {
+        const res = await fetch(
+          `/api/customer/me/orders/${encodeURIComponent(id)}`,
+          {
+            method: "GET",
+            credentials: "include",
+            cache: "no-store"
+          }
+        );
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const body = unwrap(await res.json());
+        if (cancelled) return;
+        setOrder(body);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [customer, id, tick]);
+  return {
+    order,
+    loading,
+    error,
+    refresh: () => setTick((t) => t + 1)
+  };
+}
+function unwrap2(json) {
+  if (json && typeof json === "object" && "data" in json) {
+    return json.data;
+  }
+  return json;
+}
+async function readBody(res) {
+  try {
+    return unwrap2(await res.json());
+  } catch {
+    return null;
+  }
+}
+function useCustomerAddresses() {
+  const customer = useCustomer();
+  const [addresses, setAddresses] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (!customer) {
+      setAddresses([]);
+      setLoading(false);
+      setError(null);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    void (async () => {
+      try {
+        const res = await fetch("/api/customer/me/addresses", {
+          method: "GET",
+          credentials: "include",
+          cache: "no-store"
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const body = await readBody(res);
+        if (cancelled) return;
+        const list = Array.isArray(body) ? body : Array.isArray(body?.items) ? body.items : [];
+        setAddresses(list);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [customer, tick]);
+  const refresh = useCallback(() => setTick((t) => t + 1), []);
+  function readCsrf() {
+    if (typeof document === "undefined") return null;
+    const m = document.cookie.match(/(?:^|; )numu_csrf=([^;]+)/);
+    return m ? decodeURIComponent(m[1]) : null;
+  }
+  function mutationHeaders() {
+    const h = { "Content-Type": "application/json" };
+    const csrf = readCsrf();
+    if (csrf) h["x-numu-csrf"] = csrf;
+    return h;
+  }
+  const addAddress = useCallback(
+    async (input) => {
+      const res = await fetch("/api/customer/me/addresses", {
+        method: "POST",
+        credentials: "include",
+        headers: mutationHeaders(),
+        body: JSON.stringify(input)
+      });
+      if (!res.ok) return null;
+      const created = await readBody(res);
+      refresh();
+      return created;
+    },
+    [refresh]
+  );
+  const updateAddress = useCallback(
+    async (id, input) => {
+      const res = await fetch(
+        `/api/customer/me/addresses/${encodeURIComponent(id)}`,
+        {
+          method: "PUT",
+          credentials: "include",
+          headers: mutationHeaders(),
+          body: JSON.stringify(input)
+        }
+      );
+      if (!res.ok) return null;
+      const updated = await readBody(res);
+      refresh();
+      return updated;
+    },
+    [refresh]
+  );
+  const deleteAddress = useCallback(
+    async (id) => {
+      const res = await fetch(
+        `/api/customer/me/addresses/${encodeURIComponent(id)}`,
+        {
+          method: "DELETE",
+          credentials: "include",
+          headers: mutationHeaders()
+        }
+      );
+      if (!res.ok) return false;
+      refresh();
+      return true;
+    },
+    [refresh]
+  );
+  const setDefaultAddress = useCallback(
+    async (id) => {
+      const res = await fetch(
+        `/api/customer/me/addresses/${encodeURIComponent(id)}/default`,
+        {
+          method: "PUT",
+          credentials: "include",
+          headers: mutationHeaders()
+        }
+      );
+      if (!res.ok) return false;
+      refresh();
+      return true;
+    },
+    [refresh]
+  );
+  return {
+    addresses,
+    loading,
+    error,
+    refresh,
+    addAddress,
+    updateAddress,
+    deleteAddress,
+    setDefaultAddress
+  };
+}
+var cache = /* @__PURE__ */ new Map();
+function useNavigation(handle, options) {
+  const [items, setItems] = useState(
+    options?.initialItems ?? cache.get(handle) ?? []
+  );
+  const [loading, setLoading] = useState(
+    !options?.initialItems && !cache.has(handle)
+  );
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (!handle) {
+      setItems([]);
+      setLoading(false);
+      return;
+    }
+    if (cache.has(handle) && !options?.initialItems) {
+      setItems(cache.get(handle) || []);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    void (async () => {
+      try {
+        const res = await fetch(
+          `/api/storefront/navigation/${encodeURIComponent(handle)}`,
+          { cache: "no-store" }
+        );
+        if (!res.ok) {
+          if (cancelled) return;
+          cache.set(handle, []);
+          setItems([]);
+          return;
+        }
+        const json = await res.json();
+        const list = Array.isArray(json) ? json : json.items || [];
+        if (cancelled) return;
+        cache.set(handle, list);
+        setItems(list);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setItems([]);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [handle]);
+  return { items, loading, error };
+}
+var EMPTY = {
+  products: [],
+  collections: [],
+  pages: [],
+  articles: [],
+  total: 0
+};
+function useSearch(query, options = {}) {
+  const {
+    mode = "predictive",
+    types,
+    limit,
+    debounceMs = 200,
+    immediate = false
+  } = options;
+  const [results, setResults] = useState(EMPTY);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const lastRequestId = useRef(0);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const trimmed = query.trim();
+    if (!trimmed) {
+      setResults(EMPTY);
+      setLoading(false);
+      setError(null);
+      return;
+    }
+    const requestId = ++lastRequestId.current;
+    setLoading(true);
+    setError(null);
+    const run = async () => {
+      try {
+        const params = new URLSearchParams({ q: trimmed, mode });
+        if (types?.length) params.set("types", types.join(","));
+        if (limit) params.set("limit", String(limit));
+        const res = await fetch(`/api/storefront/search?${params}`, {
+          cache: "no-store"
+        });
+        if (requestId !== lastRequestId.current) return;
+        if (!res.ok) {
+          setResults(EMPTY);
+          return;
+        }
+        const json = await res.json();
+        const body = json.data || json;
+        if (requestId !== lastRequestId.current) return;
+        setResults({
+          products: body.products || [],
+          collections: body.collections || [],
+          pages: body.pages || [],
+          articles: body.articles || [],
+          total: body.total || 0
+        });
+      } catch (err) {
+        if (requestId !== lastRequestId.current) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setResults(EMPTY);
+      } finally {
+        if (requestId === lastRequestId.current) setLoading(false);
+      }
+    };
+    if (immediate || mode === "full") {
+      void run();
+      return;
+    }
+    const t = setTimeout(run, debounceMs);
+    return () => clearTimeout(t);
+  }, [query, mode, debounceMs, immediate, limit, types?.join(",")]);
+  return { query, results, loading, error };
+}
+function useAnalytics() {
+  const track = useCallback(
+    (eventName, payload = {}) => {
+      if (typeof window === "undefined") return;
+      try {
+        window.dispatchEvent(
+          new CustomEvent("numu:analytics:event", {
+            detail: { event: eventName, payload, ts: Date.now() }
+          })
+        );
+      } catch {
+      }
+      void (async () => {
+        try {
+          await fetch("/api/storefront/track", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              event: eventName,
+              payload,
+              ts: Date.now()
+            }),
+            keepalive: true
+            // survive page-unload (e.g. begin_checkout → redirect)
+          });
+        } catch {
+        }
+      })();
+    },
+    []
+  );
+  return useMemo(() => ({ track }), [track]);
+}
+function useApp(slug) {
+  const shop = useShop();
+  const [state, setState] = useState({ data: null, loading: true, available: false, error: null });
+  const fetchApp = useCallback(async () => {
+    if (!slug) {
+      setState({ data: null, loading: false, available: false, error: null });
+      return;
+    }
+    setState((s) => ({ ...s, loading: true, error: null }));
+    try {
+      const url = `/api/storefront/apps/${encodeURIComponent(slug)}`;
+      const res = await fetch(url, {
+        credentials: "include",
+        headers: { Accept: "application/json" }
+      });
+      if (res.status === 404) {
+        setState({
+          data: null,
+          loading: false,
+          available: false,
+          error: null
+        });
+        return;
+      }
+      if (!res.ok) {
+        throw new Error(`useApp(${slug}) failed: HTTP ${res.status}`);
+      }
+      const body = await res.json();
+      const payload = body.data;
+      if (!payload) {
+        setState({
+          data: null,
+          loading: false,
+          available: false,
+          error: null
+        });
+        return;
+      }
+      setState({
+        data: payload,
+        loading: false,
+        available: payload.available !== false,
+        error: null
+      });
+    } catch (e) {
+      setState({
+        data: null,
+        loading: false,
+        available: false,
+        error: e instanceof Error ? e : new Error(String(e))
+      });
+    }
+  }, [slug, shop.id]);
+  useEffect(() => {
+    void fetchApp();
+  }, [fetchApp]);
+  return { ...state, refresh: fetchApp };
+}
+function storageKey(storeId) {
+  return `numu_wishlist_${storeId}`;
+}
+function readLocal(storeId) {
+  if (typeof window === "undefined") return [];
+  try {
+    const raw = window.localStorage.getItem(storageKey(storeId));
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function writeLocal(storeId, items) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(storageKey(storeId), JSON.stringify(items));
+  } catch {
+  }
+}
+function sameItem(a, productId, variantId) {
+  return a.product_id === productId && (a.variant_id ?? null) === (variantId ?? null);
+}
+function useWishlist(storeId) {
+  const customer = useCustomer();
+  const [items, setItems] = useState([]);
+  const [loading, setLoading] = useState(true);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    setItems(readLocal(storeId));
+    setLoading(false);
+  }, [storeId, customer?.id]);
+  const has = useCallback(
+    (productId, variantId) => items.some((it) => sameItem(it, productId, variantId)),
+    [items]
+  );
+  const addToWishlist = useCallback(
+    (productId, variantId) => {
+      setItems((prev) => {
+        if (prev.some((it) => sameItem(it, productId, variantId))) {
+          return prev;
+        }
+        const next = [
+          ...prev,
+          {
+            product_id: productId,
+            variant_id: variantId ?? null,
+            added_at: Date.now()
+          }
+        ];
+        writeLocal(storeId, next);
+        return next;
+      });
+    },
+    [storeId]
+  );
+  const removeFromWishlist = useCallback(
+    (productId, variantId) => {
+      setItems((prev) => {
+        const next = prev.filter((it) => !sameItem(it, productId, variantId));
+        writeLocal(storeId, next);
+        return next;
+      });
+    },
+    [storeId]
+  );
+  const clear = useCallback(() => {
+    setItems([]);
+    writeLocal(storeId, []);
+  }, [storeId]);
+  return { items, loading, has, addToWishlist, removeFromWishlist, clear };
+}
+function useRelatedProducts(productId, options = {}) {
+  const limit = options.limit ?? 4;
+  const [items, setItems] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (!productId) {
+      setItems([]);
+      setLoading(false);
+      setError(null);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    void (async () => {
+      try {
+        const res = await fetch(
+          `/api/storefront/products/${encodeURIComponent(productId)}/related?limit=${limit}`,
+          { cache: "no-store" }
+        );
+        if (!res.ok) {
+          if (cancelled) return;
+          setItems([]);
+          return;
+        }
+        const json = await res.json();
+        const list = Array.isArray(json) ? json : Array.isArray(json.data) ? json.data : Array.isArray(json.items) ? json.items : [];
+        if (cancelled) return;
+        setItems(list);
+      } catch (err) {
+        if (cancelled) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setItems([]);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [productId, limit]);
+  return { items, loading, error };
+}
+var COOKIE_NAME = "numu_currency";
+var COOKIE_MAX_AGE = 60 * 60 * 24 * 30;
+function readCookie(name) {
+  if (typeof document === "undefined") return null;
+  const match = document.cookie.match(
+    new RegExp(`(?:^|;\\s*)${name}=([^;]+)`)
+  );
+  return match ? decodeURIComponent(match[1]) : null;
+}
+function writeCookie(name, value) {
+  if (typeof document === "undefined") return;
+  document.cookie = `${name}=${encodeURIComponent(value)}; path=/; max-age=${COOKIE_MAX_AGE}; SameSite=Lax`;
+}
+function useCurrency() {
+  const shop = useShop();
+  const [config, setConfig] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [selected, setSelectedState] = useState("");
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const res = await fetch(`/api/storefront/currencies`, {
+          credentials: "include",
+          headers: { Accept: "application/json" }
+        });
+        if (!res.ok) throw new Error(`currencies: HTTP ${res.status}`);
+        const body = await res.json();
+        if (cancelled) return;
+        setConfig(body.data);
+        const cookie = readCookie(COOKIE_NAME);
+        const valid = cookie && body.data.presentment.includes(cookie) ? cookie : null;
+        setSelectedState(valid || body.data.default_presentment || body.data.base);
+      } catch {
+        if (cancelled) return;
+        setConfig(null);
+        setSelectedState(shop.currency || "EGP");
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [shop.id, shop.currency]);
+  const rates = useMemo(() => {
+    const out = {};
+    if (!config) return out;
+    for (const [k, v] of Object.entries(config.rates)) {
+      const n = Number.parseFloat(v);
+      if (Number.isFinite(n)) out[k] = n;
+    }
+    return out;
+  }, [config]);
+  const convert = useCallback(
+    (cents, target) => {
+      if (!config) return cents;
+      const to = target || selected;
+      if (!to || to === config.base) return cents;
+      const rate = rates[to];
+      if (!rate || !Number.isFinite(rate)) return cents;
+      return Math.round(cents * rate);
+    },
+    [config, rates, selected]
+  );
+  const setSelected = useCallback((currency) => {
+    setSelectedState(currency);
+    writeCookie(COOKIE_NAME, currency);
+  }, []);
+  return {
+    base: config?.base || shop.currency || "EGP",
+    selected: selected || config?.base || shop.currency || "EGP",
+    presentment: config?.presentment || [shop.currency || "EGP"],
+    rates,
+    autoConvert: Boolean(config?.auto_convert),
+    loading,
+    setSelected,
+    convert
+  };
+}
+
+// src/utils/variants.ts
+function findVariantByOptions(product, selection) {
+  const variants = product.variants || [];
+  if (variants.length === 0) return null;
+  if (variants.length === 1 && Object.keys(selection).length === 0) {
+    return variants[0];
+  }
+  for (const v of variants) {
+    const opts = v.option_values || v.options || {};
+    const matches = Object.entries(selection).every(
+      ([axis, value]) => opts[axis] === value
+    );
+    if (matches && Object.keys(selection).length === Object.keys(opts).length) {
+      return v;
+    }
+  }
+  return null;
+}
+function defaultVariant(product) {
+  const variants = product.variants || [];
+  if (variants.length === 0) return null;
+  const inStock = variants.find((v) => v.is_in_stock || v.in_stock);
+  return inStock || variants[0];
+}
+function availableValues(product, selection) {
+  const axes = product.options || [];
+  const variants = product.variants || [];
+  const out = {};
+  for (const axis of axes) {
+    out[axis.name] = /* @__PURE__ */ new Set();
+    for (const v of variants) {
+      const opts = v.option_values || v.options || {};
+      const compatible = Object.entries(selection).every(
+        ([k, val]) => k === axis.name || opts[k] === val
+      );
+      if (compatible && opts[axis.name]) {
+        out[axis.name].add(opts[axis.name]);
+      }
+    }
+  }
+  return out;
+}
+function useVariantSelection(product, opts = {}) {
+  const autoSelect = opts.autoSelect ?? true;
+  const initial = useMemo(() => {
+    if (!autoSelect) return {};
+    const dv = defaultVariant(product);
+    if (!dv) return {};
+    const opts2 = dv.option_values || dv.options || {};
+    return { ...opts2 };
+  }, [product, autoSelect]);
+  const [selection, setSelection] = useState(initial);
+  const select = useCallback((axis, value) => {
+    setSelection((prev) => ({ ...prev, [axis]: value }));
+  }, []);
+  const reset = useCallback(() => setSelection({}), []);
+  const variant = useMemo(
+    () => findVariantByOptions(product, selection),
+    [product, selection]
+  );
+  const availability = useMemo(
+    () => availableValues(product, selection),
+    [product, selection]
+  );
+  const isComplete = useMemo(() => {
+    const axes = product.options || [];
+    if (axes.length === 0) return true;
+    return axes.every((a) => Boolean(selection[a.name]));
+  }, [product, selection]);
+  return { selection, variant, select, reset, availability, isComplete };
+}
+function useGiftCardBalance() {
+  const [balance, setBalance] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const check = useCallback(async (code) => {
+    if (typeof window === "undefined") return null;
+    const trimmed = (code || "").trim();
+    if (!trimmed) {
+      setError(new Error("Enter a gift card code."));
+      setBalance(null);
+      return null;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await fetch(
+        `/api/gift-cards/${encodeURIComponent(trimmed)}`,
+        { cache: "no-store" }
+      );
+      if (!res.ok) {
+        setBalance(null);
+        if (res.status === 404) {
+          setError(new Error("That gift card isn't valid or has been used up."));
+          return null;
+        }
+        setError(new Error(`Couldn't check gift card (HTTP ${res.status}).`));
+        return null;
+      }
+      const json = await res.json();
+      const data = json?.data;
+      if (!data) {
+        setBalance(null);
+        setError(new Error("Unexpected response from server."));
+        return null;
+      }
+      setBalance(data);
+      return data;
+    } catch (err) {
+      setBalance(null);
+      setError(err instanceof Error ? err : new Error(String(err)));
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const reset = useCallback(() => {
+    setBalance(null);
+    setError(null);
+  }, []);
+  return { balance, loading, error, check, reset };
+}
+function useReorder() {
+  const [result, setResult] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const reorder = useCallback(
+    async (orderId) => {
+      if (typeof window === "undefined") return null;
+      if (!orderId) {
+        setError(new Error("Order id is required."));
+        return null;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const csrf = typeof document !== "undefined" ? document.cookie.match(/(?:^|; )numu_csrf=([^;]+)/)?.[1] ?? "" : "";
+        const res = await fetch(
+          `/api/customer/orders/${encodeURIComponent(orderId)}/reorder`,
+          {
+            method: "POST",
+            headers: csrf ? { "x-numu-csrf": csrf } : {},
+            credentials: "include"
+          }
+        );
+        if (!res.ok) {
+          if (res.status === 401) {
+            setError(new Error("Please sign in to reorder."));
+          } else if (res.status === 404) {
+            setError(new Error("That order can't be found on your account."));
+          } else {
+            setError(new Error(`Couldn't reorder (HTTP ${res.status}).`));
+          }
+          return null;
+        }
+        const json = await res.json();
+        const data = json?.data;
+        if (!data) {
+          setError(new Error("Unexpected response from server."));
+          return null;
+        }
+        setResult(data);
+        return data;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    []
+  );
+  const reset = useCallback(() => {
+    setResult(null);
+    setError(null);
+  }, []);
+  return { result, loading, error, reorder, reset };
+}
+var STORAGE_KEY = "numu_checkout_state";
+var EMPTY_STATE = {
+  email: "",
+  phone: "",
+  shipping_address: {},
+  selected_shipping_rate_id: null,
+  shipping_method: null,
+  payment_method: null,
+  cod_requested: false,
+  deposit_gateway: null,
+  saved_payment_method_id: null,
+  customer_notes: "",
+  coupon_code: ""
+};
+function readState() {
+  if (typeof window === "undefined") return { ...EMPTY_STATE };
+  try {
+    const raw = window.sessionStorage.getItem(STORAGE_KEY);
+    if (!raw) return { ...EMPTY_STATE };
+    return { ...EMPTY_STATE, ...JSON.parse(raw) };
+  } catch {
+    return { ...EMPTY_STATE };
+  }
+}
+function writeState(state) {
+  if (typeof window === "undefined") return;
+  try {
+    window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+    window.dispatchEvent(new CustomEvent("numu:checkout:updated"));
+  } catch {
+  }
+}
+function hasContact(s) {
+  return Boolean(
+    s.email && s.shipping_address?.line1 && s.shipping_address?.city && s.shipping_address?.country
+  );
+}
+function hasShipping(s) {
+  return hasContact(s) && Boolean(s.selected_shipping_rate_id);
+}
+function hasPayment(s) {
+  return hasShipping(s) && Boolean(s.payment_method);
+}
+function resolveStep(s) {
+  if (!hasContact(s)) return "contact";
+  if (!hasShipping(s)) return "shipping";
+  if (!hasPayment(s)) return "payment";
+  return "review";
+}
+function useCheckout() {
+  const [state, setState] = useState(() => readState());
+  const [rates, setRates] = useState(null);
+  const [ratesLoading, setRatesLoading] = useState(false);
+  useEffect(() => {
+    function onChange() {
+      setState(readState());
+    }
+    window.addEventListener("numu:checkout:updated", onChange);
+    window.addEventListener("storage", (e) => {
+      if (e.key === STORAGE_KEY) onChange();
+    });
+    return () => {
+      window.removeEventListener("numu:checkout:updated", onChange);
+    };
+  }, []);
+  const patch = useCallback((partial) => {
+    setState((prev) => {
+      const next = { ...prev, ...partial };
+      writeState(next);
+      return next;
+    });
+  }, []);
+  const refreshShipping = useCallback(async () => {
+    setRatesLoading(true);
+    try {
+      const res = await fetch("/api/shipping/options", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ shipping_address: state.shipping_address })
+      });
+      if (!res.ok) {
+        setRates([]);
+        return [];
+      }
+      const body = await res.json();
+      const list = body?.data?.options || body?.data || body?.options || [];
+      setRates(list);
+      return list;
+    } catch {
+      setRates([]);
+      return [];
+    } finally {
+      setRatesLoading(false);
+    }
+  }, [state.shipping_address]);
+  const placeOrder = useCallback(async () => {
+    const payload = {
+      line_items: [],
+      shipping_address: state.shipping_address,
+      payment_method: state.payment_method,
+      selected_shipping_rate_id: state.selected_shipping_rate_id,
+      shipping_method: state.shipping_method,
+      guest_email: state.email,
+      cod_requested: state.cod_requested,
+      deposit_gateway: state.deposit_gateway,
+      saved_payment_method_id: state.saved_payment_method_id,
+      customer_notes: state.customer_notes || null,
+      coupon_code: state.coupon_code || null
+    };
+    const res = await fetch("/api/checkout", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        // Idempotency-Key prevents a double-click double-charge.
+        "Idempotency-Key": typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random()}`
+      },
+      body: JSON.stringify(payload)
+    });
+    const body = await res.json();
+    if (!res.ok) {
+      const detail = body?.detail || body?.error || `Checkout failed (${res.status})`;
+      throw new Error(typeof detail === "string" ? detail : JSON.stringify(detail));
+    }
+    const data = body?.data || body;
+    return data;
+  }, [state]);
+  const step = useMemo(() => resolveStep(state), [state]);
+  const api = useMemo(
+    () => ({
+      state,
+      step,
+      contact: {
+        set: (input) => patch({
+          ...input.email !== void 0 && { email: input.email },
+          ...input.phone !== void 0 && { phone: input.phone },
+          ...input.shipping_address && {
+            shipping_address: {
+              ...state.shipping_address,
+              ...input.shipping_address
+            },
+            // Invalidate downstream picks when address changes.
+            selected_shipping_rate_id: null,
+            shipping_method: null
+          }
+        }),
+        isComplete: () => hasContact(state)
+      },
+      shipping: {
+        rates,
+        loading: ratesLoading,
+        refresh: refreshShipping,
+        select: (rateId) => {
+          const rate = rates?.find((r) => r.id === rateId);
+          patch({
+            selected_shipping_rate_id: rateId,
+            shipping_method: rate?.name || null
+          });
+        },
+        isComplete: () => hasShipping(state)
+      },
+      payment: {
+        select: (method, opts) => patch({
+          payment_method: method,
+          cod_requested: method === "cod",
+          deposit_gateway: opts?.deposit_gateway || null,
+          saved_payment_method_id: opts?.saved_payment_method_id || null
+        }),
+        isComplete: () => hasPayment(state)
+      },
+      setNotes: (notes) => patch({ customer_notes: notes }),
+      setCoupon: (code) => patch({ coupon_code: code }),
+      placeOrder,
+      reset: () => {
+        if (typeof window !== "undefined") {
+          try {
+            window.sessionStorage.removeItem(STORAGE_KEY);
+          } catch {
+          }
+        }
+        setState({ ...EMPTY_STATE });
+        setRates(null);
+      }
+    }),
+    [state, step, rates, ratesLoading, refreshShipping, placeOrder, patch]
+  );
+  return api;
+}
+function isAddressSufficient(a) {
+  if (!a) return false;
+  return Boolean(a.country);
+}
+function useShippingRates({
+  address,
+  location_id,
+  enabled = true
+} = {}) {
+  const [rates, setRates] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    if (!isAddressSufficient(address)) {
+      setRates(null);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await fetch("/api/shipping/options", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          shipping_address: address,
+          ...location_id ? { location_id } : {}
+        })
+      });
+      if (!res.ok) {
+        if (res.status === 404) {
+          setRates([]);
+          return;
+        }
+        throw new Error(`shipping rates: HTTP ${res.status}`);
+      }
+      const body = await res.json();
+      const list = body?.data?.options || body?.data || body?.options || [];
+      setRates(list);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+      setRates([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [address, location_id]);
+  useEffect(() => {
+    if (!enabled) return;
+    void refresh();
+  }, [enabled, refresh]);
+  return { rates, loading, error, refresh };
+}
+var RTL_LOCALES = ["ar", "he", "fa", "ur"];
+var EMPTY_CART = {
+  id: "",
+  items: [],
+  subtotal: 0,
+  total: 0,
+  currency: "EGP"
+};
+function readCsrfCookie() {
+  if (typeof document === "undefined") return null;
+  const match = document.cookie.match(/(?:^|;\s*)numu_csrf=([^;]+)/);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+async function postCartMutation(endpoint, body, applyCart, reserveToken) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const csrf = readCsrfCookie();
+  if (csrf) headers["x-numu-csrf"] = csrf;
+  const idempotencyKey = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  headers["x-numu-idempotency-key"] = idempotencyKey;
+  const res = await fetch(endpoint, {
+    method: body === void 0 ? "DELETE" : "POST",
+    headers,
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  if (!res.ok) return;
+  const data = await res.json();
+  applyCart(data);
+}
+function NuMuProvider({
+  store,
+  themeSettings,
+  initialCart,
+  customer,
+  locale: initialLocale,
+  translations: initialTranslations,
+  children
+}) {
+  const [cart, setCart] = useState(
+    initialCart || { ...EMPTY_CART, currency: store.currency }
+  );
+  const [loading, setLoading] = useState(false);
+  const [locale, setLocale] = useState(() => {
+    if (initialLocale) return initialLocale;
+    if (typeof document !== "undefined") {
+      const m = document.cookie.match(/(?:^|; )numu_locale=([^;]+)/);
+      if (m) return decodeURIComponent(m[1]);
+    }
+    return store.default_language || "en";
+  });
+  const [translations] = useState(initialTranslations || {});
+  const [customerState, setCustomerState] = useState(
+    customer ?? null
+  );
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (customer) return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const res = await fetch("/api/customer/me", {
+          method: "GET",
+          credentials: "include",
+          cache: "no-store"
+        });
+        if (cancelled) return;
+        if (!res.ok) return;
+        const json = await res.json();
+        const next = json && typeof json === "object" && "data" in json ? json.data : json;
+        if (next && typeof next === "object") {
+          setCustomerState(next);
+        }
+      } catch {
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const refreshCustomer = useCallback(async () => {
+    if (typeof window === "undefined") return;
+    try {
+      const res = await fetch("/api/customer/me", {
+        method: "GET",
+        credentials: "include",
+        cache: "no-store"
+      });
+      if (res.status === 401) {
+        setCustomerState(null);
+        return;
+      }
+      if (!res.ok) return;
+      const json = await res.json();
+      const next = json && typeof json === "object" && "data" in json ? json.data : json;
+      setCustomerState(next ?? null);
+    } catch {
+    }
+  }, []);
+  function readCsrf() {
+    if (typeof document === "undefined") return null;
+    const m = document.cookie.match(/(?:^|; )numu_csrf=([^;]+)/);
+    return m ? decodeURIComponent(m[1]) : null;
+  }
+  async function postCustomer(path, body) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const csrf = readCsrf();
+    if (csrf) headers["x-numu-csrf"] = csrf;
+    const res = await fetch(path, {
+      method: "POST",
+      credentials: "include",
+      cache: "no-store",
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    let json = null;
+    try {
+      json = await res.json();
+    } catch {
+    }
+    return json;
+  }
+  async function putCustomer(path, body) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const csrf = readCsrf();
+    if (csrf) headers["x-numu-csrf"] = csrf;
+    const res = await fetch(path, {
+      method: "PUT",
+      credentials: "include",
+      cache: "no-store",
+      headers,
+      body: JSON.stringify(body ?? {})
+    });
+    try {
+      return await res.json();
+    } catch {
+      return null;
+    }
+  }
+  const customerActions = useMemo(
+    () => ({
+      login: async (input) => {
+        const r = await postCustomer("/api/customer/login", input);
+        await refreshCustomer();
+        return r;
+      },
+      register: async (input) => {
+        const r = await postCustomer("/api/customer/register", input);
+        await refreshCustomer();
+        return r;
+      },
+      logout: async () => {
+        const r = await postCustomer("/api/customer/logout", {});
+        setCustomerState(null);
+        return r;
+      },
+      requestRecover: (input) => postCustomer("/api/customer/recover", input),
+      confirmReset: async (input) => {
+        const r = await postCustomer("/api/customer/reset", input);
+        setCustomerState(null);
+        return r;
+      },
+      verifyEmail: async (input) => {
+        const r = await postCustomer("/api/customer/verify-email", input);
+        await refreshCustomer();
+        return r;
+      },
+      resendVerification: (input) => postCustomer("/api/customer/resend-verification", input),
+      updateProfile: async (input) => {
+        const r = await putCustomer("/api/customer/me", input);
+        await refreshCustomer();
+        return r;
+      },
+      changePassword: (input) => putCustomer("/api/customer/me/password", input),
+      refresh: refreshCustomer
+    }),
+    [refreshCustomer]
+  );
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const res = await fetch("/api/cart", {
+          method: "GET",
+          credentials: "include",
+          cache: "no-store"
+        });
+        if (!res.ok || cancelled) return;
+        const data = await res.json();
+        if (data && typeof data === "object") {
+          setCart(data);
+        }
+      } catch {
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const nextRequestId = useRef(0);
+  const latestApplied = useRef(0);
+  const reserveToken = useCallback(() => {
+    nextRequestId.current += 1;
+    return nextRequestId.current;
+  }, []);
+  const buildApplyCart = useCallback(
+    (token) => (newCart) => {
+      if (token < latestApplied.current) {
+        return;
+      }
+      latestApplied.current = token;
+      setCart(newCart);
+    },
+    []
+  );
+  const mutate = useCallback(
+    async (endpoint, body) => {
+      const token = reserveToken();
+      setLoading(true);
+      try {
+        await postCartMutation(
+          endpoint,
+          body,
+          buildApplyCart(token),
+          () => token
+          // already reserved; just return the same token
+        );
+      } finally {
+        setLoading(false);
+      }
+    },
+    [reserveToken, buildApplyCart]
+  );
+  const addItem = useCallback(
+    async (productId, variantId, quantity) => {
+      await mutate("/api/cart/add", {
+        product_id: productId,
+        variant_id: variantId,
+        quantity: quantity || 1
+      });
+    },
+    [mutate]
+  );
+  const removeItem = useCallback(
+    async (itemId) => {
+      await mutate("/api/cart/remove", { item_id: itemId });
+    },
+    [mutate]
+  );
+  const updateQuantity = useCallback(
+    async (itemId, quantity) => {
+      await mutate("/api/cart/update", { item_id: itemId, quantity });
+    },
+    [mutate]
+  );
+  const applyDiscount = useCallback(
+    async (code) => {
+      await mutate("/api/cart/discount", { code });
+    },
+    [mutate]
+  );
+  const removeDiscount = useCallback(async () => {
+    await mutate("/api/cart/discount", void 0);
+  }, [mutate]);
+  const updateNote = useCallback(
+    async (note) => {
+      await mutate("/api/cart/update", { note });
+    },
+    [mutate]
+  );
+  const clearCart = useCallback(async () => {
+    setCart({ ...EMPTY_CART, currency: store.currency });
+  }, [store.currency]);
+  const cartFirstRender = useRef(true);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (cartFirstRender.current) {
+      cartFirstRender.current = false;
+      return;
+    }
+    window.dispatchEvent(
+      new CustomEvent("numu:cart:updated", { detail: cart })
+    );
+  }, [cart]);
+  const cartValue = useMemo(
+    () => ({
+      cart,
+      addItem,
+      removeItem,
+      updateQuantity,
+      applyDiscount,
+      removeDiscount,
+      updateNote,
+      clearCart,
+      loading
+    }),
+    [
+      cart,
+      addItem,
+      removeItem,
+      updateQuantity,
+      applyDiscount,
+      removeDiscount,
+      updateNote,
+      clearCart,
+      loading
+    ]
+  );
+  const safeCurrency = (store.currency || "USD").toUpperCase();
+  const numeralSystem = store.settings?.numerals === "arabic" ? "arab" : "latn";
+  const intlLocale = `${locale}-u-nu-${numeralSystem}`;
+  const moneyFmt = useMemo(() => {
+    try {
+      return new Intl.NumberFormat(intlLocale, {
+        style: "currency",
+        currency: safeCurrency
+      });
+    } catch {
+      return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: safeCurrency
+      });
+    }
+  }, [intlLocale, locale, safeCurrency]);
+  const dateFmt = useMemo(() => {
+    try {
+      return new Intl.DateTimeFormat(intlLocale, {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+    } catch {
+      return new Intl.DateTimeFormat(locale, {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+    }
+  }, [intlLocale, locale]);
+  const availableLocales = useMemo(() => {
+    const list = store.available_locales;
+    if (Array.isArray(list) && list.length > 0) return list;
+    return [locale];
+  }, [store, locale]);
+  const switchLocale = useCallback((next) => {
+    if (typeof document === "undefined") return;
+    if (!next) return;
+    document.cookie = `numu_locale=${encodeURIComponent(next)}; Path=/; Max-Age=${60 * 60 * 24 * 365}; SameSite=Lax`;
+    setLocale(next);
+    if (typeof window !== "undefined") {
+      window.location.reload();
+    }
+  }, []);
+  const defaultNumberFmt = useMemo(() => {
+    try {
+      return new Intl.NumberFormat(intlLocale);
+    } catch {
+      return new Intl.NumberFormat(locale);
+    }
+  }, [intlLocale, locale]);
+  const localization = useMemo(
+    () => ({
+      locale,
+      direction: RTL_LOCALES.includes(locale) ? "rtl" : "ltr",
+      translations,
+      availableLocales,
+      setLocale: switchLocale,
+      formatMoney: (amount, currency) => {
+        const ccy = (currency || safeCurrency).toUpperCase();
+        if (ccy !== safeCurrency) {
+          try {
+            return new Intl.NumberFormat(intlLocale, {
+              style: "currency",
+              currency: ccy
+            }).format(amount);
+          } catch {
+            return moneyFmt.format(amount);
+          }
+        }
+        return moneyFmt.format(amount);
+      },
+      formatDate: (date) => dateFmt.format(typeof date === "string" ? new Date(date) : date),
+      formatNumber: (n, options) => {
+        if (!options) return defaultNumberFmt.format(n);
+        try {
+          return new Intl.NumberFormat(intlLocale, options).format(n);
+        } catch {
+          return String(n);
+        }
+      }
+    }),
+    [
+      locale,
+      translations,
+      safeCurrency,
+      moneyFmt,
+      dateFmt,
+      availableLocales,
+      switchLocale,
+      intlLocale,
+      defaultNumberFmt
+    ]
+  );
+  return /* @__PURE__ */ jsx(ShopContext.Provider, { value: store, children: /* @__PURE__ */ jsx(ThemeSettingsContext.Provider, { value: themeSettings, children: /* @__PURE__ */ jsx(LocalizationContext.Provider, { value: localization, children: /* @__PURE__ */ jsx(CartContext.Provider, { value: cartValue, children: /* @__PURE__ */ jsx(CustomerContext.Provider, { value: customerState, children: /* @__PURE__ */ jsx(CustomerActionsContext.Provider, { value: customerActions, children }) }) }) }) }) });
+}
+function ProductProvider({ product, children }) {
+  return /* @__PURE__ */ jsx(ProductContext.Provider, { value: product, children });
+}
+function CollectionProvider({ collection, children }) {
+  return /* @__PURE__ */ jsx(CollectionContext.Provider, { value: collection, children });
+}
+function Money({
+  amount,
+  currency,
+  compareAt,
+  className,
+  as = "span"
+}) {
+  const { formatMoney } = useLocalization();
+  const shop = useShop();
+  const ccy = currency || shop?.currency;
+  const showCompare = compareAt != null && compareAt > amount;
+  const children = [
+    /* @__PURE__ */ jsx("span", { children: formatMoney(amount, ccy) }, "amt")
+  ];
+  if (showCompare) {
+    children.push(" ");
+    children.push(
+      /* @__PURE__ */ jsx("s", { style: { opacity: 0.6 }, children: formatMoney(compareAt, ccy) }, "cmp")
+    );
+  }
+  return createElement(
+    as,
+    { className, dir: "auto" },
+    children
+  );
+}
+var DEFAULT_WIDTHS2 = [320, 480, 640, 768, 1024, 1280, 1600, 1920];
+function buildSrcSet(src, widths = DEFAULT_WIDTHS2) {
+  if (/[?&]w=\d+/.test(src)) return "";
+  const sep = src.includes("?") ? "&" : "?";
+  return widths.map((w) => `${src}${sep}w=${w} ${w}w`).join(", ");
+}
+function Image({
+  src,
+  alt,
+  sizes = "(min-width: 1024px) 25vw, (min-width: 640px) 50vw, 100vw",
+  responsive = true,
+  loading = "lazy",
+  className,
+  style,
+  ...rest
+}) {
+  if (!src) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className,
+        role: "img",
+        "aria-label": alt,
+        style: {
+          backgroundColor: "rgba(0,0,0,0.05)",
+          display: "block",
+          ...style
+        }
+      }
+    );
+  }
+  const srcSet = responsive ? buildSrcSet(src) : void 0;
+  return /* @__PURE__ */ jsx(
+    "img",
+    {
+      src,
+      alt,
+      srcSet: srcSet || void 0,
+      sizes: srcSet ? sizes : void 0,
+      loading,
+      decoding: "async",
+      className,
+      style,
+      ...rest
+    }
+  );
+}
+var ABSOLUTE_URL = /^[a-z]+:|^\/\//i;
+function Link({ to, children, ...rest }) {
+  const shop = useShop();
+  const isAbsolute = ABSOLUTE_URL.test(to);
+  let href = to;
+  if (!isAbsolute && shop && !to.startsWith("/")) {
+    href = `/${to}`;
+  }
+  return /* @__PURE__ */ jsx("a", { href, ...rest, children });
+}
+function AddToCartButton({
+  product,
+  variant,
+  quantity = 1,
+  label = "Add to cart",
+  loadingLabel = "Adding\u2026",
+  soldOutLabel = "Sold out",
+  errorLabel = "Couldn't add \u2014 try again",
+  onAdded,
+  ...rest
+}) {
+  const { addItem } = useCart();
+  const [state, setState] = useState("idle");
+  const inStock = variant?.in_stock ?? product.in_stock;
+  if (!inStock) {
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        disabled: true,
+        "aria-disabled": "true",
+        ...rest,
+        children: soldOutLabel
+      }
+    );
+  }
+  async function handleClick() {
+    if (state === "adding") return;
+    setState("adding");
+    try {
+      await addItem(product.id, variant?.id, quantity);
+      setState("idle");
+      onAdded?.(product, variant);
+    } catch {
+      setState("error");
+      setTimeout(() => setState("idle"), 2e3);
+    }
+  }
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: handleClick,
+      disabled: state === "adding",
+      "aria-busy": state === "adding",
+      ...rest,
+      children: state === "adding" ? loadingLabel : state === "error" ? errorLabel : label
+    }
+  );
+}
+var SectionErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error) {
+    console.error(
+      `[Section ${this.props.sectionType}#${this.props.sectionId}] threw:`,
+      error
+    );
+    if (typeof window !== "undefined" && window.parent !== window) {
+      try {
+        window.parent.postMessage(
+          {
+            type: "numu:editor:section-error",
+            payload: {
+              sectionId: this.props.sectionId,
+              sectionType: this.props.sectionType,
+              message: error.message
+            }
+          },
+          "*"
+        );
+      } catch {
+      }
+    }
+  }
+  render() {
+    if (this.state.error) return this.props.fallback;
+    return this.props.children;
+  }
+};
+function defaultSectionFallback(sectionType, sectionId) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "alert",
+      "data-numu-section-error": "true",
+      style: {
+        padding: "1rem",
+        border: "1px dashed #f87171",
+        background: "#fef2f2",
+        color: "#b91c1c",
+        fontFamily: "system-ui, -apple-system, BlinkMacSystemFont, sans-serif",
+        fontSize: "0.875rem",
+        lineHeight: 1.5,
+        borderRadius: "0.375rem",
+        margin: "0.5rem 0"
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", { style: { fontWeight: 600, marginBottom: "0.25rem" }, children: "Section failed to render" }),
+        /* @__PURE__ */ jsxs("div", { style: { opacity: 0.9 }, children: [
+          /* @__PURE__ */ jsx("code", { style: { fontFamily: "monospace" }, children: sectionType }),
+          " threw an error. Check the browser console for details."
+        ] }),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              opacity: 0.6,
+              fontSize: "0.75rem",
+              marginTop: "0.25rem",
+              fontFamily: "monospace"
+            },
+            children: [
+              "section #",
+              sectionId
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function Section({
+  id,
+  type,
+  groupId,
+  errorFallback,
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ jsx(
+    "section",
+    {
+      "data-section-id": id,
+      "data-section-type": type,
+      "data-group-id": groupId,
+      ...rest,
+      children: /* @__PURE__ */ jsx(
+        SectionErrorBoundary,
+        {
+          sectionId: id,
+          sectionType: type,
+          fallback: errorFallback ?? defaultSectionFallback(type, id),
+          children
+        }
+      )
+    }
+  );
+}
+function Block({ id, type, errorFallback, children, ...rest }) {
+  return /* @__PURE__ */ jsx("div", { "data-block-id": id, "data-block-type": type, ...rest, children: /* @__PURE__ */ jsx(
+    SectionErrorBoundary,
+    {
+      sectionId: id,
+      sectionType: type,
+      fallback: errorFallback ?? defaultSectionFallback(type, id),
+      children
+    }
+  ) });
+}
+var ABSOLUTE_URL2 = /^[a-z]+:|^\/\//i;
+function readCsrfCookie2() {
+  if (typeof document === "undefined") return null;
+  const m = document.cookie.match(/(?:^|;\s*)numu_csrf=([^;]+)/);
+  return m ? decodeURIComponent(m[1]) : null;
+}
+function newIdempotencyKey() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function Form({
+  action,
+  method = "POST",
+  onSuccess,
+  onError,
+  children,
+  ...rest
+}) {
+  const [submitting, setSubmitting] = useState(false);
+  const [error, setError] = useState(null);
+  async function handleSubmit(e) {
+    e.preventDefault();
+    if (ABSOLUTE_URL2.test(action)) {
+      const err = new Error(
+        `<Form action> must be a same-origin path (got "${action}"). Use a /api/* proxy route or your route handler.`
+      );
+      setError(err);
+      onError?.(err);
+      return;
+    }
+    setSubmitting(true);
+    setError(null);
+    try {
+      const formData = new FormData(e.currentTarget);
+      const isMutation = method !== "GET";
+      const isMultipart = e.currentTarget.dataset?.numuMultipart === "true";
+      const headers = {};
+      if (!isMultipart) headers["Content-Type"] = "application/json";
+      if (isMutation) {
+        const csrf = readCsrfCookie2();
+        if (csrf) headers["x-numu-csrf"] = csrf;
+        headers["x-numu-idempotency-key"] = newIdempotencyKey();
+      }
+      let url = action;
+      let body;
+      if (method === "GET") {
+        const params = new URLSearchParams();
+        for (const [k, v] of formData.entries()) {
+          if (typeof v === "string") params.append(k, v);
+        }
+        const sep = action.includes("?") ? "&" : "?";
+        url = `${action}${sep}${params.toString()}`;
+      } else if (isMultipart) {
+        body = formData;
+      } else {
+        const obj = {};
+        for (const [k, v] of formData.entries()) obj[k] = v;
+        body = JSON.stringify(obj);
+      }
+      const res = await fetch(url, { method, headers, body });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(
+          `${method} ${action} failed: ${res.status} ${res.statusText}${text ? ` \u2014 ${text.slice(0, 200)}` : ""}`
+        );
+      }
+      const json = res.headers.get("content-type")?.includes("application/json") ? await res.json() : await res.text();
+      onSuccess?.(json);
+    } catch (err) {
+      const e2 = err instanceof Error ? err : new Error(String(err));
+      setError(e2);
+      onError?.(e2);
+    } finally {
+      setSubmitting(false);
+    }
+  }
+  return /* @__PURE__ */ jsx(
+    "form",
+    {
+      onSubmit: handleSubmit,
+      method,
+      action,
+      "aria-busy": submitting,
+      ...rest,
+      children: typeof children === "function" ? children({ submitting, error }) : children
+    }
+  );
+}
+function joinClass(...names) {
+  return names.filter(Boolean).join(" ");
+}
+function ProductCard({
+  product,
+  href,
+  className,
+  slots,
+  imageSizes
+}) {
+  const target = href ?? `/products/${product.slug}`;
+  const firstImage = product.images?.[0];
+  const inStock = product.in_stock;
+  const badge = slots?.badge !== void 0 ? slots.badge : inStock ? null : /* @__PURE__ */ jsx("span", { className: "numu-product-card__badge", children: "Sold out" });
+  return /* @__PURE__ */ jsxs("article", { className: joinClass("numu-product-card", className), children: [
+    /* @__PURE__ */ jsxs(Link, { to: target, className: "numu-product-card__link", children: [
+      /* @__PURE__ */ jsxs("div", { className: "numu-product-card__media", children: [
+        /* @__PURE__ */ jsx(
+          Image,
+          {
+            src: firstImage?.url,
+            alt: firstImage?.alt || product.name,
+            sizes: imageSizes,
+            className: "numu-product-card__image"
+          }
+        ),
+        badge
+      ] }),
+      slots?.title ?? /* @__PURE__ */ jsx("h3", { className: "numu-product-card__title", children: product.name }),
+      slots?.price ?? /* @__PURE__ */ jsx("div", { className: "numu-product-card__price", children: /* @__PURE__ */ jsx(
+        Money,
+        {
+          amount: product.price,
+          compareAt: product.compare_at_price,
+          currency: product.currency
+        }
+      ) })
+    ] }),
+    slots?.cta === null ? null : /* @__PURE__ */ jsx("div", { className: "numu-product-card__cta", children: slots?.cta ?? /* @__PURE__ */ jsx(AddToCartButton, { product }) })
+  ] });
+}
+function joinClass2(...names) {
+  return names.filter(Boolean).join(" ");
+}
+function CollectionCard({
+  collection,
+  href,
+  className,
+  slots,
+  imageSizes
+}) {
+  const target = href ?? `/collections/${collection.slug}`;
+  const productCount = typeof collection.product_count === "number" ? collection.product_count : void 0;
+  return /* @__PURE__ */ jsx("article", { className: joinClass2("numu-collection-card", className), children: /* @__PURE__ */ jsxs(Link, { to: target, className: "numu-collection-card__link", children: [
+    /* @__PURE__ */ jsx("div", { className: "numu-collection-card__media", children: /* @__PURE__ */ jsx(
+      Image,
+      {
+        src: collection.image_url,
+        alt: collection.name,
+        sizes: imageSizes,
+        className: "numu-collection-card__image"
+      }
+    ) }),
+    slots?.title ?? /* @__PURE__ */ jsx("h3", { className: "numu-collection-card__title", children: collection.name }),
+    slots?.count === null ? null : slots?.count ?? (productCount !== void 0 && /* @__PURE__ */ jsx("p", { className: "numu-collection-card__count", children: productCount === 1 ? "1 product" : `${productCount} products` }))
+  ] }) });
+}
+var ALLOWED_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "br",
+  "hr",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "pre",
+  "code",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "u",
+  "s",
+  "sub",
+  "sup",
+  "mark",
+  "ul",
+  "ol",
+  "li",
+  "dl",
+  "dt",
+  "dd",
+  "a",
+  "img",
+  "table",
+  "thead",
+  "tbody",
+  "tr",
+  "th",
+  "td",
+  "span",
+  "div"
+]);
+var ALLOWED_ATTRS_BY_TAG = {
+  a: /* @__PURE__ */ new Set(["href", "target", "rel", "class", "title"]),
+  img: /* @__PURE__ */ new Set(["src", "alt", "width", "height", "loading", "class"]),
+  span: /* @__PURE__ */ new Set(["class"]),
+  div: /* @__PURE__ */ new Set(["class"]),
+  p: /* @__PURE__ */ new Set(["class"]),
+  h1: /* @__PURE__ */ new Set(["class"]),
+  h2: /* @__PURE__ */ new Set(["class"]),
+  h3: /* @__PURE__ */ new Set(["class"]),
+  h4: /* @__PURE__ */ new Set(["class"]),
+  h5: /* @__PURE__ */ new Set(["class"]),
+  h6: /* @__PURE__ */ new Set(["class"]),
+  blockquote: /* @__PURE__ */ new Set(["class"]),
+  pre: /* @__PURE__ */ new Set(["class"]),
+  code: /* @__PURE__ */ new Set(["class"]),
+  ul: /* @__PURE__ */ new Set(["class"]),
+  ol: /* @__PURE__ */ new Set(["class"]),
+  li: /* @__PURE__ */ new Set(["class"]),
+  table: /* @__PURE__ */ new Set(["class"]),
+  thead: /* @__PURE__ */ new Set(["class"]),
+  tbody: /* @__PURE__ */ new Set(["class"]),
+  tr: /* @__PURE__ */ new Set(["class"]),
+  th: /* @__PURE__ */ new Set(["class"]),
+  td: /* @__PURE__ */ new Set(["class"])
+};
+var URL_SAFE_PROTOCOLS = /^(https?|mailto|tel):/i;
+function isSafeUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return false;
+  if (trimmed.startsWith("/") || trimmed.startsWith("#") || trimmed.startsWith("?")) {
+    return true;
+  }
+  return URL_SAFE_PROTOCOLS.test(trimmed);
+}
+function sanitizeHtml(input) {
+  if (!input) return "";
+  if (typeof window === "undefined" || typeof DOMParser === "undefined") {
+    return sanitizeHtmlServer(input);
+  }
+  return sanitizeHtmlClient(input);
+}
+function sanitizeHtmlClient(input) {
+  const doc = new DOMParser().parseFromString(
+    `<div>${input}</div>`,
+    "text/html"
+  );
+  const root = doc.body.firstElementChild;
+  if (!root) return "";
+  walk(root);
+  return root.innerHTML;
+}
+function walk(node) {
+  const children = Array.from(node.children);
+  for (const child of children) {
+    const tag = child.tagName.toLowerCase();
+    if (!ALLOWED_TAGS.has(tag)) {
+      if (tag === "script" || tag === "style" || tag === "iframe" || tag === "object" || tag === "embed") {
+        child.remove();
+      } else {
+        const text = child.textContent || "";
+        child.replaceWith(document.createTextNode(text));
+      }
+      continue;
+    }
+    const allowed = ALLOWED_ATTRS_BY_TAG[tag] || /* @__PURE__ */ new Set();
+    for (const attr of Array.from(child.attributes)) {
+      const name = attr.name.toLowerCase();
+      if (name.startsWith("on")) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      if (!allowed.has(name)) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      if ((name === "href" || name === "src") && !isSafeUrl(attr.value)) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+    }
+    if (tag === "a" && child.getAttribute("target") === "_blank") {
+      child.setAttribute("rel", "noopener noreferrer");
+    }
+    walk(child);
+  }
+}
+function sanitizeHtmlServer(input) {
+  let s = input.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<iframe[\s\S]*?<\/iframe>/gi, "").replace(/<object[\s\S]*?<\/object>/gi, "").replace(/<embed[\s\S]*?<\/embed>/gi, "").replace(/<link[\s\S]*?>/gi, "").replace(/<meta[\s\S]*?>/gi, "");
+  s = s.replace(/\s+on\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+  s = s.replace(
+    /\s+(href|src)\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi,
+    (full, attr, val) => {
+      const cleaned = String(val).replace(/^['"]|['"]$/g, "");
+      return isSafeUrl(cleaned) ? full : "";
+    }
+  );
+  return s;
+}
+function RichText({ html, className, as = "div" }) {
+  const safe = useMemo(() => sanitizeHtml(html || ""), [html]);
+  if (!safe) return null;
+  const Tag = as;
+  return /* @__PURE__ */ jsx(
+    Tag,
+    {
+      className,
+      dangerouslySetInnerHTML: { __html: safe }
+    }
+  );
+}
+function CurrencySwitcher({
+  className,
+  onSelect,
+  render
+}) {
+  const { presentment, selected, setSelected, loading } = useCurrency();
+  const handleChange = useCallback(
+    (next) => {
+      if (next === selected) return;
+      setSelected(next);
+      onSelect?.(next);
+    },
+    [selected, setSelected, onSelect]
+  );
+  if (loading) return null;
+  if (presentment.length <= 1) return null;
+  if (render) {
+    return /* @__PURE__ */ jsx(Fragment, { children: render({
+      currencies: presentment,
+      current: selected,
+      onChange: handleChange
+    }) });
+  }
+  return /* @__PURE__ */ jsx(
+    "select",
+    {
+      className: className ?? "numu-currency-switcher",
+      value: selected,
+      onChange: (e) => handleChange(e.target.value),
+      "aria-label": "Currency",
+      children: presentment.map((c) => /* @__PURE__ */ jsx("option", { value: c, children: c }, c))
+    }
+  );
+}
+var LANG_LABELS = {
+  ar: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
+  en: "English",
+  fr: "Fran\xE7ais",
+  he: "\u05E2\u05D1\u05E8\u05D9\u05EA",
+  fa: "\u0641\u0627\u0631\u0633\u06CC",
+  ur: "\u0627\u0631\u062F\u0648",
+  es: "Espa\xF1ol",
+  de: "Deutsch"
+};
+function LocaleSwitcher({
+  className,
+  onSelect,
+  render
+}) {
+  const shop = useShop();
+  const { locale } = useLocalization();
+  const available = shop.available_locales || [];
+  const list = available.length > 0 ? available : shop.default_language === "en" ? ["en"] : Array.from(/* @__PURE__ */ new Set([shop.default_language, "en"]));
+  const labelFor = useCallback((code) => {
+    return LANG_LABELS[code] || code.toUpperCase();
+  }, []);
+  const handleChange = useCallback(
+    (next) => {
+      if (next === locale) return;
+      onSelect?.(next);
+      if (typeof document !== "undefined") {
+        const oneYear = 60 * 60 * 24 * 365;
+        document.cookie = `numu_locale=${encodeURIComponent(next)}; path=/; max-age=${oneYear}; samesite=lax`;
+      }
+      if (typeof window !== "undefined") {
+        window.location.reload();
+      }
+    },
+    [locale, onSelect]
+  );
+  if (list.length <= 1) return null;
+  if (render) {
+    return /* @__PURE__ */ jsx(Fragment, { children: render({ locales: list, current: locale, labelFor, onChange: handleChange }) });
+  }
+  return /* @__PURE__ */ jsx(
+    "select",
+    {
+      className: className ?? "numu-locale-switcher",
+      value: locale,
+      onChange: (e) => handleChange(e.target.value),
+      "aria-label": "Language",
+      children: list.map((l) => /* @__PURE__ */ jsx("option", { value: l, children: labelFor(l) }, l))
+    }
+  );
+}
+
+// src/utils/normalize.ts
+var DEFAULT_THEME_ID = typeof process !== "undefined" && process.env?.NUMU_DEFAULT_THEME_ID || "modern";
+function resolveThemeSettings(raw) {
+  const safeRaw = raw ?? {};
+  if (safeRaw.schema_version === 3) {
+    return safeRaw;
+  }
+  const themeBlock = safeRaw.theme || {};
+  const themeId = typeof themeBlock.base_theme === "string" && themeBlock.base_theme || DEFAULT_THEME_ID;
+  const globalSettings = {};
+  for (const key of [
+    "primary_color",
+    "secondary_color",
+    "font_family",
+    "logo_url"
+  ]) {
+    if (themeBlock[key] !== void 0) globalSettings[key] = themeBlock[key];
+  }
+  if (safeRaw.identity) globalSettings.identity = safeRaw.identity;
+  const sections = {};
+  const order = [];
+  const hero = safeRaw.hero;
+  if (hero) {
+    sections["hero_1"] = {
+      type: "hero",
+      settings: {
+        // Mirrors backend `normalize_legacy_to_v3` exactly — includes
+        // headline_ar so Arabic content survives the round-trip.
+        headline: hero.headline ?? "",
+        headline_ar: hero.headline_ar ?? "",
+        subtitle: hero.subtitle ?? "",
+        background_image: hero.hero_image_url ?? "",
+        cta_text: hero.cta_text ?? "",
+        cta_link: hero.cta_link ?? ""
+      }
+    };
+    order.push("hero_1");
+  }
+  const products = safeRaw.products;
+  if (products) {
+    sections["featured_1"] = {
+      type: "featured-products",
+      settings: products
+    };
+    order.push("featured_1");
+  }
+  const templates = {};
+  if (Object.keys(sections).length > 0) {
+    templates["home"] = { name: "Home", sections, order };
+  }
+  const sectionGroups = {
+    header: {
+      name: "Header Group",
+      sections: {
+        header_1: {
+          type: "header",
+          settings: safeRaw.header || {}
+        }
+      },
+      order: ["header_1"]
+    },
+    footer: {
+      name: "Footer Group",
+      sections: {
+        footer_1: {
+          type: "footer",
+          settings: safeRaw.footer || {}
+        }
+      },
+      order: ["footer_1"]
+    }
+  };
+  let externalTheme = null;
+  const ext = safeRaw.external_theme;
+  if (ext && typeof ext === "object" && typeof ext.bundle_url === "string" && ext.bundle_url) {
+    externalTheme = {
+      bundle_url: ext.bundle_url,
+      css_url: typeof ext.css_url === "string" ? ext.css_url : null,
+      mode: typeof ext.mode === "string" ? ext.mode : "production"
+    };
+  }
+  return {
+    schema_version: 3,
+    theme_id: themeId,
+    global_settings: globalSettings,
+    templates,
+    section_groups: sectionGroups,
+    external_theme: externalTheme
+  };
+}
+
+// src/utils/federation.ts
+var SDK_SYMBOL_KEY = "__NUMU_SDK_SLOT__";
+var REACT_SYMBOL_KEY = "__NUMU_REACT_SLOT__";
+function globalSlot(name, slotKey) {
+  const g = globalThis;
+  let sym = g[slotKey];
+  if (!sym) {
+    sym = Symbol.for(name);
+    g[slotKey] = sym;
+  }
+  return sym;
+}
+function sdkSlot() {
+  return globalSlot("@numueg/theme-sdk:singleton", SDK_SYMBOL_KEY);
+}
+function reactSlot() {
+  return globalSlot("@numueg/theme-sdk:react", REACT_SYMBOL_KEY);
+}
+function registerSdkSingleton(sdk) {
+  if (typeof globalThis === "undefined") return;
+  globalThis[sdkSlot()] = sdk;
+}
+function getSdkSingleton() {
+  if (typeof globalThis === "undefined") return null;
+  return globalThis[sdkSlot()] ?? null;
+}
+function registerReactSingleton(react, reactDom) {
+  if (typeof globalThis === "undefined") return;
+  globalThis[reactSlot()] = {
+    React: react,
+    ReactDOM: reactDom
+  };
+}
+function getReactSingleton() {
+  if (typeof globalThis === "undefined") return null;
+  return globalThis[reactSlot()] ?? null;
+}
+function isSdkAvailable() {
+  return getSdkSingleton() !== null;
+}
+
+// src/utils/defineSection.ts
+var SECTION_MARKER = /* @__PURE__ */ Symbol.for("numu.theme.section");
+var BLOCK_MARKER = /* @__PURE__ */ Symbol.for("numu.theme.block");
+function defineSection(input) {
+  if (!input?.schema?.type) {
+    throw new Error(
+      "defineSection: `schema.type` is required and must be a stable string id."
+    );
+  }
+  if (!/^[a-z][a-z0-9_-]*$/.test(input.schema.type)) {
+    throw new Error(
+      `defineSection: section type '${input.schema.type}' must be lowercase alphanumeric with dashes/underscores. The codegen step uses this as a TS key.`
+    );
+  }
+  if (typeof input.render !== "function") {
+    throw new Error(
+      "defineSection: `render` must be a React component function."
+    );
+  }
+  return Object.freeze({
+    schema: input.schema,
+    render: input.render,
+    [SECTION_MARKER]: true
+  });
+}
+function defineBlock(input) {
+  if (!input?.schema?.type) {
+    throw new Error("defineBlock: `schema.type` is required.");
+  }
+  if (!/^[a-z@][a-z0-9_/-]*$/i.test(input.schema.type)) {
+    throw new Error(
+      `defineBlock: block type '${input.schema.type}' has illegal chars. Use a-z, 0-9, dashes/underscores; @app/<slug>/<block> form is also accepted.`
+    );
+  }
+  if (typeof input.render !== "function") {
+    throw new Error(
+      "defineBlock: `render` must be a React component function."
+    );
+  }
+  return Object.freeze({
+    schema: input.schema,
+    render: input.render,
+    [BLOCK_MARKER]: true
+  });
+}
+function isDefinedSection(v) {
+  return typeof v === "object" && v !== null && v[SECTION_MARKER] === true;
+}
+function isDefinedBlock(v) {
+  return typeof v === "object" && v !== null && v[BLOCK_MARKER] === true;
+}
+function collectSections(modules) {
+  const out = {};
+  for (const [path, mod] of Object.entries(modules)) {
+    const def = mod.default;
+    if (!isDefinedSection(def)) {
+      if (typeof console !== "undefined") {
+        console.warn(
+          `[numu] ${path}: default export is not a defineSection() result; skipped.`
+        );
+      }
+      continue;
+    }
+    if (out[def.schema.type]) {
+      throw new Error(
+        `[numu] duplicate section type '${def.schema.type}': previously defined, now also defined in ${path}.`
+      );
+    }
+    out[def.schema.type] = def;
+  }
+  return out;
+}
+function collectBlocks(modules) {
+  const out = {};
+  for (const [path, mod] of Object.entries(modules)) {
+    const def = mod.default;
+    if (!isDefinedBlock(def)) {
+      if (typeof console !== "undefined") {
+        console.warn(
+          `[numu] ${path}: default export is not a defineBlock() result; skipped.`
+        );
+      }
+      continue;
+    }
+    if (out[def.schema.type]) {
+      throw new Error(
+        `[numu] duplicate block type '${def.schema.type}': previously defined, now also defined in ${path}.`
+      );
+    }
+    out[def.schema.type] = def;
+  }
+  return out;
+}
+
+// src/utils/assetUrl.ts
+function getRuntime() {
+  if (typeof window === "undefined") return {};
+  return window;
+}
+function assetUrl(name) {
+  if (!name) return "";
+  if (/^https?:\/\//i.test(name) || name.startsWith("//")) return name;
+  const runtime = getRuntime();
+  const manifest = runtime.__NUMU_ASSET_MANIFEST;
+  const base = runtime.__NUMU_ASSET_BASE_URL || "/assets/";
+  let key = name.replace(/^\.\//, "");
+  if (key.startsWith("/")) key = key.slice(1);
+  if (key.startsWith("assets/")) key = key.slice("assets/".length);
+  const hashed = manifest?.[key];
+  const filename = hashed || key;
+  const cleanBase = base.endsWith("/") ? base : `${base}/`;
+  return `${cleanBase}${filename}`;
+}
+
+// src/utils/locales.ts
+function flattenMessages(source, prefix = "") {
+  const out = {};
+  for (const [key, val] of Object.entries(source)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (val === null || val === void 0) continue;
+    if (typeof val === "string") {
+      out[fullKey] = val;
+    } else if (typeof val === "object" && !Array.isArray(val)) {
+      Object.assign(
+        out,
+        flattenMessages(val, fullKey)
+      );
+    } else if (typeof console !== "undefined") {
+      console.warn(
+        `[numu] locale key '${fullKey}' has non-string value (${typeof val}); skipped.`
+      );
+    }
+  }
+  return out;
+}
+function pickTranslations(bundle, locale) {
+  const fallback = bundle["en"] || bundle["en.default"] || {};
+  const requested = bundle[locale];
+  if (!requested) return fallback;
+  return { ...fallback, ...requested };
+}
+function buildLocaleBundle(modules) {
+  const bundle = {};
+  for (const [path, raw] of Object.entries(modules)) {
+    const m = /\/([^/]+)\.json$/.exec(path);
+    if (!m) continue;
+    let code = m[1];
+    if (code !== "en.default") {
+      code = code.replace(/\.default$/, "");
+    }
+    const value = raw;
+    if (typeof value === "object" && value !== null) {
+      bundle[code] = flattenMessages(value);
+    }
+  }
+  return bundle;
+}
+
+export { AddToCartButton, Block, CartContext, CollectionCard, CollectionContext, CollectionProvider, CurrencySwitcher, CustomerContext, Form, Image, Link, LocaleSwitcher, LocalizationContext, Money, NuMuProvider, PageContext, ProductCard, ProductContext, ProductProvider, RichText, Section, SectionContext, ShopContext, ThemeSettingsContext, assetUrl, availableValues, buildLocaleBundle, collectBlocks, collectSections, defaultVariant, defineBlock, defineSection, findVariantByOptions, flattenMessages, getReactSingleton, getSdkSingleton, isDefinedBlock, isDefinedSection, isSdkAvailable, pickTranslations, registerReactSingleton, registerSdkSingleton, resolveThemeSettings, sanitizeHtml, useAnalytics, useApp, useCart, useCheckout, useCollection, useCollectionOptional, useCollections, useCurrency, useCustomer, useCustomerActions, useCustomerAddresses, useDirection, useFieldTranslation, useGiftCardBalance, useImage, useLocale, useLocalization, useMoney, useNavigation, useNumberFormat, useOrder, useOrders, usePage, useProduct, useProductOptional, useProducts, useRelatedProducts, useReorder, useSearch, useSection, useSectionOptional, useShippingRates, useShop, useThemeSettings, useTranslation, useVariantSelection, useWishlist };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map