@kasuvia/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,3540 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthCtx: () => AuthCtx,
+  AuthProvider: () => AuthProvider,
+  CartCtx: () => CartCtx,
+  CartProvider: () => CartProvider,
+  InvalidBaseURLError: () => InvalidBaseURLError,
+  acceptQuote: () => acceptQuote,
+  addToCart: () => addToCart,
+  addToGuestCart: () => addToGuestCart,
+  addToWishlist: () => addToWishlist,
+  approveDeliverable: () => approveDeliverable,
+  authAxios: () => authAxios,
+  bespokeService: () => bespokeService,
+  bookAppointment: () => bookAppointment,
+  buildDeliveryAddress: () => buildDeliveryAddress,
+  buildFullName: () => buildFullName,
+  cancelAppointment: () => cancelAppointment,
+  cancelOrder: () => cancelOrder,
+  checkAvailability: () => checkAvailability,
+  checkInWishlist: () => checkInWishlist,
+  clearCart: () => clearCart,
+  clearGuestCart: () => clearGuestCart,
+  clearGuestSessionId: () => clearGuestSessionId,
+  cmsAxios: () => cmsAxios,
+  collectionKeys: () => collectionKeys,
+  configService: () => configService,
+  configureHttpClients: () => configureHttpClients,
+  consultationService: () => consultationService,
+  createCmsEntry: () => createCmsEntry,
+  createConsultation: () => createConsultation,
+  createDedicatedAccount: () => createDedicatedAccount,
+  createOrder: () => createOrder,
+  deleteCmsEntry: () => deleteCmsEntry,
+  enrichCompletedOrder: () => enrichCompletedOrder,
+  findOrder: () => findOrder,
+  findOrderByToken: () => findOrderByToken,
+  getAppointment: () => getAppointment,
+  getAppointments: () => getAppointments,
+  getAuthUser: () => getAuthUser,
+  getAvailableSlots: () => getAvailableSlots,
+  getBackendUrl: () => getBackendUrl,
+  getBusinessConfig: () => getBusinessConfig,
+  getCacheTier: () => getCacheTier,
+  getCart: () => getCart,
+  getCheckoutCustomerName: () => getCheckoutCustomerName,
+  getCmsEntry: () => getCmsEntry,
+  getConsultation: () => getConsultation,
+  getConsultations: () => getConsultations,
+  getCountries: () => getCountries,
+  getCustomerDisplayName: () => getCustomerDisplayName,
+  getDeliverables: () => getDeliverables,
+  getErrorMessage: () => getErrorMessage,
+  getFeaturedProducts: () => getFeaturedProducts,
+  getGraphQLClient: () => getGraphQLClient,
+  getGuestCart: () => getGuestCart,
+  getGuestCartCount: () => getGuestCartCount,
+  getGuestCartProductType: () => getGuestCartProductType,
+  getGuestCartSubtotal: () => getGuestCartSubtotal,
+  getGuestSessionId: () => getGuestSessionId,
+  getLatestProducts: () => getLatestProducts,
+  getMe: () => getMe,
+  getNewProducts: () => getNewProducts,
+  getOrCreateGuestSessionId: () => getOrCreateGuestSessionId,
+  getOrders: () => getOrders,
+  getPopularProducts: () => getPopularProducts,
+  getRecommendedProducts: () => getRecommendedProducts,
+  getRuntimeConfig: () => getRuntimeConfig,
+  getSellerShippingAddress: () => getSellerShippingAddress,
+  getShippingRates: () => getShippingRates,
+  getStates: () => getStates,
+  getStorefrontCollectionBySlug: () => getStorefrontCollectionBySlug,
+  getStorefrontCollections: () => getStorefrontCollections,
+  getStorefrontProductBySlug: () => getStorefrontProductBySlug,
+  getStorefrontProducts: () => getStorefrontProducts,
+  getSupportedCurrencies: () => getSupportedCurrencies,
+  getSupportedCurrenciesList: () => getSupportedCurrenciesList,
+  getSupportedLanguages: () => getSupportedLanguages,
+  getSupportedLanguagesList: () => getSupportedLanguagesList,
+  getTransactionStatus: () => getTransactionStatus,
+  getWishlist: () => getWishlist,
+  googleTranslate: () => googleTranslate,
+  initSdk: () => initSdk,
+  initiatePayment: () => initiatePayment,
+  isInitialized: () => isInitialized,
+  listCmsEntries: () => listCmsEntries,
+  logger: () => logger,
+  loginCustomer: () => loginCustomer,
+  logisticsService: () => logisticsService,
+  logout: () => logout,
+  mapAuthUserToCustomer: () => mapAuthUserToCustomer,
+  mergeGuestCart: () => mergeGuestCart,
+  mergeGuestCartIfPresent: () => mergeGuestCartIfPresent,
+  notificationsService: () => notificationsService,
+  paymentAxios: () => paymentAxios,
+  paymentService: () => paymentService,
+  productKeys: () => productKeys,
+  publicStoreAxios: () => publicStoreAxios,
+  refreshToken: () => refreshToken,
+  registerCustomer: () => registerCustomer,
+  rejectQuote: () => rejectQuote,
+  removeFromCart: () => removeFromCart,
+  removeFromGuestCart: () => removeFromGuestCart,
+  removeFromWishlist: () => removeFromWishlist,
+  removeProductFromWishlist: () => removeProductFromWishlist,
+  requestQuote: () => requestQuote,
+  requestRevision: () => requestRevision,
+  resetConfig: () => resetConfig,
+  resetGraphQLClient: () => resetGraphQLClient,
+  sanitizeBaseUrl: () => sanitizeBaseUrl,
+  sendContactConfirmation: () => sendContactConfirmation,
+  sendContactEmail: () => sendContactEmail,
+  sendMessage: () => sendMessage,
+  serviceBookingService: () => serviceBookingService,
+  setEnvironmentMode: () => setEnvironmentMode,
+  setLoggerEnvironmentMode: () => setLoggerEnvironmentMode,
+  silentRefresh: () => silentRefresh,
+  splitFullName: () => splitFullName,
+  storeManagementAxios: () => storeManagementAxios,
+  storeTokens: () => storeTokens,
+  tokenStore: () => tokenStore,
+  trackOrder: () => trackOrder,
+  updateCartItem: () => updateCartItem,
+  updateCmsEntry: () => updateCmsEntry,
+  updateGuestCartItemQuantity: () => updateGuestCartItemQuantity,
+  updateProfile: () => updateProfile,
+  useAcceptQuote: () => useAcceptQuote,
+  useAddToWishlist: () => useAddToWishlist,
+  useAppointment: () => useAppointment,
+  useAppointments: () => useAppointments,
+  useApproveDeliverable: () => useApproveDeliverable,
+  useAuth: () => useAuth,
+  useAuthUser: () => useAuthUser,
+  useAvailableSlots: () => useAvailableSlots,
+  useBespokeAvailability: () => useBespokeAvailability,
+  useBookAppointment: () => useBookAppointment,
+  useCancelAppointment: () => useCancelAppointment,
+  useCancelOrder: () => useCancelOrder,
+  useCart: () => useCart,
+  useCheckInWishlist: () => useCheckInWishlist,
+  useCmsEntries: () => useCmsEntries,
+  useCmsEntry: () => useCmsEntry,
+  useConsultation: () => useConsultation,
+  useConsultationStream: () => useConsultationStream,
+  useConsultations: () => useConsultations,
+  useCountries: () => useCountries,
+  useCreateCmsEntry: () => useCreateCmsEntry,
+  useCreateConsultation: () => useCreateConsultation,
+  useCreateDVA: () => useCreateDVA,
+  useCreateOrder: () => useCreateOrder,
+  useCurrencies: () => useCurrencies,
+  useDeleteCmsEntry: () => useDeleteCmsEntry,
+  useDeliverables: () => useDeliverables,
+  useFeaturedProducts: () => useFeaturedProducts,
+  useFindOrder: () => useFindOrder,
+  useGoogleTranslate: () => useGoogleTranslate,
+  useInitiatePayment: () => useInitiatePayment,
+  useIsMounted: () => useIsMounted,
+  useLatestProducts: () => useLatestProducts,
+  useLogin: () => useLogin,
+  useLogout: () => useLogout,
+  useNewProducts: () => useNewProducts,
+  useOrder: () => useOrder,
+  useOrderStream: () => useOrderStream,
+  useOrderTracking: () => useOrderTracking,
+  useOrders: () => useOrders,
+  useOrdersList: () => useOrdersList,
+  usePollTransactionStatus: () => usePollTransactionStatus,
+  usePopularProducts: () => usePopularProducts,
+  useProduct: () => useProduct,
+  useRecommendedProducts: () => useRecommendedProducts,
+  useRegister: () => useRegister,
+  useRejectQuote: () => useRejectQuote,
+  useRemoveFromWishlist: () => useRemoveFromWishlist,
+  useRemoveProductFromWishlist: () => useRemoveProductFromWishlist,
+  useRequestRevision: () => useRequestRevision,
+  useSendMessage: () => useSendMessage,
+  useStates: () => useStates,
+  useStorefrontCollection: () => useStorefrontCollection,
+  useStorefrontCollections: () => useStorefrontCollections,
+  useStorefrontProducts: () => useStorefrontProducts,
+  useSupportedLanguages: () => useSupportedLanguages,
+  useTransactionStatus: () => useTransactionStatus,
+  useUpdateCmsEntry: () => useUpdateCmsEntry,
+  useUpdateProfile: () => useUpdateProfile,
+  useVerifyTransaction: () => useVerifyTransaction,
+  useWishlist: () => useWishlist,
+  useWishlistCount: () => useWishlistCount,
+  validateShippingAddress: () => validateShippingAddress,
+  verifySocialToken: () => verifySocialToken,
+  verifyTransaction: () => verifyTransaction,
+  wishlistKeys: () => wishlistKeys
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/cache.ts
+var CACHE_TIERS = {
+  none: { staleTime: 0, gcTime: 0 },
+  infinity: { staleTime: Infinity, gcTime: 0 },
+  low: { staleTime: 1e3 * 30, gcTime: 1e3 * 60 },
+  // 30s / 1m
+  medium: { staleTime: 1e3 * 60 * 5, gcTime: 1e3 * 60 * 10 },
+  // 5m / 10m
+  high: { staleTime: 1e3 * 60 * 30, gcTime: 1e3 * 60 * 60 }
+  // 30m / 1h
+};
+var isDevelopment = true;
+function setEnvironmentMode(development) {
+  isDevelopment = development;
+}
+var getCacheTier = (tier) => {
+  if (isDevelopment) return CACHE_TIERS.none;
+  return CACHE_TIERS[tier];
+};
+
+// src/utils/logger.ts
+var isDevelopment2 = true;
+function setLoggerEnvironmentMode(development) {
+  isDevelopment2 = development;
+}
+var logger = {
+  log: (...args) => {
+    if (isDevelopment2) {
+      console.log(...args);
+    }
+  },
+  warn: (...args) => {
+    if (isDevelopment2) {
+      console.warn(...args);
+    }
+  },
+  /**
+   * Logs a warning to the console in development only.
+   * Alias for warn() for Python logging compatibility.
+   * In production, this is a no-op.
+   */
+  warning: (...args) => {
+    if (isDevelopment2) {
+      console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    if (isDevelopment2) {
+      console.error(...args);
+    }
+  },
+  info: (...args) => {
+    if (isDevelopment2) {
+      console.info(...args);
+    }
+  },
+  createScope: (scope) => ({
+    log: (...args) => {
+      if (isDevelopment2) {
+        console.log(`[${scope}]`, ...args);
+      }
+    },
+    warn: (...args) => {
+      if (isDevelopment2) {
+        console.warn(`[${scope}]`, ...args);
+      }
+    },
+    warning: (...args) => {
+      if (isDevelopment2) {
+        console.warn(`[${scope}]`, ...args);
+      }
+    },
+    error: (...args) => {
+      if (isDevelopment2) {
+        console.error(`[${scope}]`, ...args);
+      }
+    },
+    info: (...args) => {
+      if (isDevelopment2) {
+        console.info(`[${scope}]`, ...args);
+      }
+    }
+  })
+};
+
+// src/utils/sanitize-url.ts
+var InvalidBaseURLError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidBaseURLError";
+  }
+};
+var ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "ws:", "wss:"]);
+function sanitizeBaseUrl(url, name = "URL") {
+  if (url == null) {
+    throw new InvalidBaseURLError(`${name} is not set`);
+  }
+  const cleaned0 = url.trim();
+  if (!cleaned0) {
+    throw new InvalidBaseURLError(`${name} is empty`);
+  }
+  const cleaned = cleaned0.replace(/\/+$/, "");
+  let parsed;
+  try {
+    parsed = new URL(cleaned);
+  } catch {
+    throw new InvalidBaseURLError(
+      `${name} must start with http://, https://, ws://, or wss://, got: ${url}`
+    );
+  }
+  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+    throw new InvalidBaseURLError(
+      `${name} must start with http://, https://, ws://, or wss://, got: ${url}`
+    );
+  }
+  if (!parsed.hostname) {
+    throw new InvalidBaseURLError(`${name} is missing a host: ${url}`);
+  }
+  if (parsed.search || parsed.hash) {
+    throw new InvalidBaseURLError(
+      `${name} should not contain a query or fragment: ${url}`
+    );
+  }
+  return cleaned;
+}
+
+// src/utils/customer.ts
+function buildFullName(firstname, lastname) {
+  const name = [firstname, lastname].filter(Boolean).join(" ").trim();
+  return name || void 0;
+}
+function splitFullName(fullName) {
+  if (!fullName?.trim()) return { firstname: "", lastname: "" };
+  const parts = fullName.trim().split(/\s+/);
+  return {
+    firstname: parts[0] ?? "",
+    lastname: parts.slice(1).join(" ")
+  };
+}
+function getCustomerDisplayName(user) {
+  const fromParts = buildFullName(user.firstname, user.lastname);
+  return fromParts || user.full_name || user.email.split("@")[0];
+}
+
+// src/utils/checkout.ts
+function buildDeliveryAddress(customer, location) {
+  return {
+    first_name: customer.first_name,
+    last_name: customer.last_name,
+    phone: customer.phone,
+    ...location
+  };
+}
+function getCheckoutCustomerName(customer) {
+  return buildFullName(customer.first_name, customer.last_name) ?? customer.email.split("@")[0];
+}
+function enrichCompletedOrder(order, options) {
+  const customerName = getCheckoutCustomerName(options.customer);
+  return {
+    ...order,
+    customerName: order.customerName || customerName,
+    customerEmail: order.customerEmail || options.customer.email,
+    shippingAddress: order.shippingAddress ?? (options.productType === "physical" && options.location ? buildDeliveryAddress(options.customer, options.location) : void 0),
+    bespokeBrief: order.bespokeBrief ?? options.bespokeBrief
+  };
+}
+
+// src/utils/error-handler.ts
+var import_axios = __toESM(require("axios"));
+function getErrorMessage(error, fallback = "Something went wrong") {
+  if (import_axios.default.isAxiosError(error)) {
+    return error.response?.data?.detail || error.response?.data?.message || error.message || fallback;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return fallback;
+}
+
+// src/config/index.ts
+var runtimeConfig = null;
+var BACKEND_URLS = {
+  auth: "https://127.0.0.1:8000/api/v1",
+  store: "https://127.0.0.1:8001/api/v1",
+  payment: "https://127.0.0.1:8002/api/v1",
+  notifications: "https://127.0.0.1:8007/api/v1",
+  cms: "https://127.0.0.1:8003/api/v1"
+};
+function initSdk(config) {
+  runtimeConfig = {
+    businessId: config.businessId,
+    storefrontApiKey: config.storefrontApiKey
+  };
+  const isDevelopment3 = typeof window === "undefined" && globalThis.process?.env?.NODE_ENV === "development";
+  setEnvironmentMode(isDevelopment3);
+  setLoggerEnvironmentMode(isDevelopment3);
+  logger.log("SDK initialized with businessId:", config.businessId);
+}
+function getRuntimeConfig() {
+  if (!runtimeConfig) {
+    throw new Error("SDK not initialized. Call initSdk() before using SDK functions.");
+  }
+  return runtimeConfig;
+}
+function getBackendUrl(service) {
+  return BACKEND_URLS[service];
+}
+function isInitialized() {
+  return runtimeConfig !== null;
+}
+function resetConfig() {
+  runtimeConfig = null;
+}
+
+// src/client/httpClient.ts
+var import_axios3 = __toESM(require("axios"));
+
+// src/client/authClient.ts
+var import_axios2 = __toESM(require("axios"));
+var _accessToken = null;
+var _isRefreshing = false;
+var _pendingQueue = [];
+function getStorageKey() {
+  if (!isInitialized()) return "kasuvia-sf-anon-refresh";
+  const config = getRuntimeConfig();
+  return `kasuvia-sf-${config.businessId}-refresh`;
+}
+function drainQueue(error, newToken = null) {
+  _pendingQueue.forEach(({ resolve, reject }) => {
+    if (newToken) resolve(newToken);
+    else reject(error);
+  });
+  _pendingQueue = [];
+}
+var tokenStore = {
+  getAccessToken: () => _accessToken,
+  setAccessToken: (token) => {
+    _accessToken = token;
+  },
+  getRefreshToken: () => {
+    if (typeof window === "undefined") return null;
+    const key = getStorageKey();
+    return localStorage.getItem(key) || sessionStorage.getItem(key);
+  },
+  setRefreshToken: (token, remember = true) => {
+    if (typeof window === "undefined") return;
+    const key = getStorageKey();
+    localStorage.removeItem(key);
+    sessionStorage.removeItem(key);
+    if (token) {
+      const store = remember ? localStorage : sessionStorage;
+      store.setItem(key, token);
+    }
+  },
+  clearAll: () => {
+    _accessToken = null;
+    if (typeof window !== "undefined") {
+      const key = getStorageKey();
+      localStorage.removeItem(key);
+      sessionStorage.removeItem(key);
+    }
+  },
+  hasSession: () => {
+    if (typeof window === "undefined") return false;
+    const key = getStorageKey();
+    return !!(localStorage.getItem(key) || sessionStorage.getItem(key));
+  },
+  isPersistent: () => {
+    if (typeof window === "undefined") return true;
+    const key = getStorageKey();
+    return !!localStorage.getItem(key);
+  }
+};
+var refreshAxios = import_axios2.default.create({
+  baseURL: getBackendUrl("auth"),
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  },
+  withCredentials: true,
+  timeout: 3e4
+});
+async function refreshToken() {
+  if (_isRefreshing) {
+    return new Promise((resolve, reject) => {
+      _pendingQueue.push({ resolve, reject });
+    });
+  }
+  _isRefreshing = true;
+  const refresh = tokenStore.getRefreshToken();
+  if (!refresh) {
+    _isRefreshing = false;
+    tokenStore.clearAll();
+    throw new Error("[kasuvia SDK] No refresh token available");
+  }
+  try {
+    const { data } = await refreshAxios.post("/auth/token/refresh/", { refresh });
+    const newAccess = data.access;
+    tokenStore.setAccessToken(newAccess);
+    if (data.refresh) {
+      tokenStore.setRefreshToken(data.refresh, tokenStore.isPersistent());
+    }
+    drainQueue(null, newAccess);
+    return newAccess;
+  } catch (err) {
+    drainQueue(err);
+    tokenStore.clearAll();
+    throw err;
+  } finally {
+    _isRefreshing = false;
+  }
+}
+
+// src/client/httpClient.ts
+var _guestSessionId = null;
+function getOrCreateGuestSessionId() {
+  if (_guestSessionId) return _guestSessionId;
+  const storageKey = isInitialized() ? `kasuvia-guest-${getRuntimeConfig().businessId}` : "kasuvia-guest-anon";
+  if (typeof window !== "undefined") {
+    _guestSessionId = sessionStorage.getItem(storageKey) || crypto.randomUUID();
+    sessionStorage.setItem(storageKey, _guestSessionId);
+  } else {
+    _guestSessionId = crypto.randomUUID();
+  }
+  return _guestSessionId;
+}
+function getGuestSessionId() {
+  if (!_guestSessionId && typeof window !== "undefined") {
+    const storageKey = isInitialized() ? `kasuvia-guest-${getRuntimeConfig().businessId}` : "kasuvia-guest-anon";
+    _guestSessionId = sessionStorage.getItem(storageKey);
+  }
+  return _guestSessionId;
+}
+function clearGuestSessionId() {
+  _guestSessionId = null;
+  if (typeof window !== "undefined") {
+    const storageKey = isInitialized() ? `kasuvia-guest-${getRuntimeConfig().businessId}` : "kasuvia-guest-anon";
+    sessionStorage.removeItem(storageKey);
+  }
+}
+var storeManagementAxios = import_axios3.default.create({
+  baseURL: getBackendUrl("store"),
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  },
+  timeout: 3e4
+});
+storeManagementAxios.interceptors.request.use((cfg) => {
+  const config = getRuntimeConfig();
+  const token = tokenStore.getAccessToken();
+  if (token) {
+    cfg.headers = cfg.headers ?? {};
+    cfg.headers["Authorization"] = `Bearer ${token}`;
+  }
+  cfg.headers = cfg.headers ?? {};
+  cfg.headers["X-Storefront-Key"] = config.storefrontApiKey;
+  cfg.headers["X-Business-ID"] = config.businessId;
+  if (!token) {
+    const sid = getOrCreateGuestSessionId();
+    if (sid) cfg.headers["X-Guest-Session"] = sid;
+  }
+  return cfg;
+});
+storeManagementAxios.interceptors.response.use(
+  (res) => res,
+  async (err) => {
+    const originalRequest = err.config;
+    if (!originalRequest) return Promise.reject(err);
+    const status = err.response?.status;
+    const isUnauthorized = status === 401;
+    const isRefreshEndpoint = originalRequest.url?.includes("/auth/token/refresh/");
+    const alreadyRetried = originalRequest._retry === true;
+    if (isUnauthorized && isRefreshEndpoint) {
+      tokenStore.clearAll();
+      return Promise.reject(err);
+    }
+    if (!isUnauthorized || alreadyRetried) return Promise.reject(err);
+    try {
+      const newToken = await refreshToken();
+      originalRequest._retry = true;
+      if (originalRequest.headers) {
+        originalRequest.headers["Authorization"] = `Bearer ${newToken}`;
+      }
+      return storeManagementAxios(originalRequest);
+    } catch (refreshErr) {
+      tokenStore.clearAll();
+      return Promise.reject(refreshErr);
+    }
+  }
+);
+var publicStoreAxios = import_axios3.default.create({
+  baseURL: getBackendUrl("store"),
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  },
+  timeout: 3e4
+});
+publicStoreAxios.interceptors.request.use((cfg) => {
+  const config = getRuntimeConfig();
+  cfg.headers = cfg.headers ?? {};
+  cfg.headers["X-Storefront-Key"] = config.storefrontApiKey;
+  cfg.headers["X-Business-ID"] = config.businessId;
+  return cfg;
+});
+publicStoreAxios.interceptors.response.use(
+  (res) => res,
+  (err) => Promise.reject(err)
+);
+var authAxios = import_axios3.default.create({
+  baseURL: getBackendUrl("auth"),
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  },
+  withCredentials: true,
+  timeout: 3e4
+});
+authAxios.interceptors.request.use((cfg) => {
+  const config = getRuntimeConfig();
+  const token = tokenStore.getAccessToken();
+  if (token) {
+    cfg.headers = cfg.headers ?? {};
+    cfg.headers["Authorization"] = `Bearer ${token}`;
+  }
+  cfg.headers = cfg.headers ?? {};
+  cfg.headers["X-Storefront-Key"] = config.storefrontApiKey;
+  cfg.headers["X-Business-ID"] = config.businessId;
+  return cfg;
+});
+authAxios.interceptors.response.use(
+  (res) => res,
+  async (err) => {
+    const originalRequest = err.config;
+    if (!originalRequest) return Promise.reject(err);
+    const status = err.response?.status;
+    const isUnauthorized = status === 401;
+    const isRefreshEndpoint = originalRequest.url?.includes("/auth/token/refresh/");
+    const alreadyRetried = originalRequest._retry === true;
+    if (isUnauthorized && isRefreshEndpoint) {
+      tokenStore.clearAll();
+      return Promise.reject(err);
+    }
+    if (!isUnauthorized || alreadyRetried) return Promise.reject(err);
+    try {
+      const newToken = await refreshToken();
+      originalRequest._retry = true;
+      if (originalRequest.headers) {
+        originalRequest.headers["Authorization"] = `Bearer ${newToken}`;
+      }
+      return authAxios(originalRequest);
+    } catch (refreshErr) {
+      tokenStore.clearAll();
+      return Promise.reject(refreshErr);
+    }
+  }
+);
+var paymentAxios = import_axios3.default.create({
+  baseURL: getBackendUrl("payment"),
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  },
+  timeout: 3e4
+});
+paymentAxios.interceptors.request.use((cfg) => {
+  const config = getRuntimeConfig();
+  cfg.headers = cfg.headers ?? {};
+  cfg.headers["X-Storefront-Key"] = config.storefrontApiKey;
+  cfg.headers["X-Business-ID"] = config.businessId;
+  return cfg;
+});
+paymentAxios.interceptors.response.use(
+  (res) => res,
+  (err) => Promise.reject(err)
+);
+var notificationsAxios = import_axios3.default.create({
+  baseURL: getBackendUrl("notifications"),
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  },
+  timeout: 3e4
+});
+notificationsAxios.interceptors.response.use(
+  (res) => res,
+  (err) => Promise.reject(err)
+);
+var cmsAxios = import_axios3.default.create({
+  baseURL: getBackendUrl("cms"),
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  },
+  timeout: 3e4
+});
+cmsAxios.interceptors.request.use((cfg) => {
+  const config = getRuntimeConfig();
+  cfg.headers = cfg.headers ?? {};
+  cfg.headers["X-Storefront-Key"] = config.storefrontApiKey;
+  cfg.headers["X-Business-ID"] = config.businessId;
+  return cfg;
+});
+cmsAxios.interceptors.response.use(
+  (res) => res,
+  (err) => Promise.reject(err)
+);
+var refreshAxios2 = import_axios3.default.create({
+  baseURL: getBackendUrl("auth"),
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  },
+  withCredentials: true,
+  timeout: 3e4
+});
+function configureHttpClients() {
+  if (!isInitialized()) return;
+  const storeUrl = getBackendUrl("store");
+  const authUrl = getBackendUrl("auth");
+  const paymentUrl = getBackendUrl("payment");
+  const notificationsUrl = getBackendUrl("notifications");
+  const cmsUrl = getBackendUrl("cms");
+  storeManagementAxios.defaults.baseURL = storeUrl;
+  publicStoreAxios.defaults.baseURL = storeUrl;
+  authAxios.defaults.baseURL = authUrl;
+  paymentAxios.defaults.baseURL = paymentUrl;
+  notificationsAxios.defaults.baseURL = notificationsUrl;
+  cmsAxios.defaults.baseURL = cmsUrl;
+  refreshAxios2.defaults.baseURL = authUrl;
+}
+
+// src/client/graphqlClient.ts
+var import_graphql_request = require("graphql-request");
+var GRAPHQL_URL = `${getBackendUrl("store")}/graphql`;
+function buildHeaders() {
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  if (isInitialized()) {
+    const config = getRuntimeConfig();
+    headers["X-Storefront-Key"] = config.storefrontApiKey;
+    headers["X-Business-ID"] = config.businessId;
+  }
+  const token = tokenStore.getAccessToken();
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  return headers;
+}
+function getGraphQLClient() {
+  return new import_graphql_request.GraphQLClient(GRAPHQL_URL, { headers: buildHeaders() });
+}
+function resetGraphQLClient() {
+}
+
+// src/services/cart.service.ts
+function parseItems(items) {
+  return items.map((item) => ({
+    ...item,
+    variant_attributes: item.variant_attributes && typeof item.variant_attributes === "string" ? JSON.parse(item.variant_attributes) : item.variant_attributes
+  }));
+}
+async function getGuestCart() {
+  const sid = getGuestSessionId();
+  if (!sid) return [];
+  try {
+    const { data } = await storeManagementAxios.get("cart/", {
+      headers: { "X-Guest-Session": sid }
+    });
+    return parseItems(data.items || []);
+  } catch {
+    return [];
+  }
+}
+async function addToGuestCart(item) {
+  const sid = getOrCreateGuestSessionId();
+  if (!sid) return [];
+  const payload = {
+    product_id: item.product_id,
+    product_slug: item.product_slug,
+    product_name: item.product_name,
+    image: item.image,
+    variant_id: item.variant_id,
+    variant_attributes: typeof item.variant_attributes === "string" ? item.variant_attributes : JSON.stringify(item.variant_attributes),
+    unit_price: item.unit_price,
+    quantity: item.quantity,
+    custom_measurements: item.custom_measurements,
+    is_bespoke: item.is_bespoke
+  };
+  const { data } = await storeManagementAxios.post("cart/", payload, {
+    headers: { "X-Guest-Session": sid }
+  });
+  return parseItems(data.items || []);
+}
+async function updateGuestCartItemQuantity(itemId, quantity) {
+  const sid = getGuestSessionId();
+  if (!sid) return [];
+  const { data } = await storeManagementAxios.patch(
+    `cart/${itemId}`,
+    { quantity },
+    { headers: { "X-Guest-Session": sid } }
+  );
+  return parseItems(data.items || []);
+}
+async function removeFromGuestCart(itemId) {
+  const sid = getGuestSessionId();
+  if (!sid) return [];
+  await storeManagementAxios.delete(`cart/${itemId}`, {
+    headers: { "X-Guest-Session": sid }
+  });
+  return getGuestCart();
+}
+async function clearGuestCart() {
+  const sid = getGuestSessionId();
+  if (!sid) return;
+  await storeManagementAxios.delete("cart/clear", {
+    headers: { "X-Guest-Session": sid }
+  });
+}
+async function getCart() {
+  const { data } = await storeManagementAxios.get("cart/");
+  const parsedItems = parseItems(data.items || []);
+  return { ...data, items: parsedItems };
+}
+async function addToCart(item) {
+  const { data } = await storeManagementAxios.post("cart/", item);
+  const parsedItems = parseItems(data.items || []);
+  return { ...data, items: parsedItems };
+}
+async function updateCartItem(itemId, quantity) {
+  const { data } = await storeManagementAxios.patch(
+    `cart/${itemId}`,
+    { quantity }
+  );
+  const parsedItems = parseItems(data.items || []);
+  return { ...data, items: parsedItems };
+}
+async function removeFromCart(itemId) {
+  await storeManagementAxios.delete(`cart/${itemId}`);
+  return getCart();
+}
+async function clearCart() {
+  await storeManagementAxios.delete("cart/clear");
+}
+async function mergeGuestCart() {
+  const sid = getGuestSessionId();
+  const guestItems = sid ? await getGuestCart() : [];
+  if (guestItems.length === 0) {
+    return getCart();
+  }
+  const payloadItems = guestItems.map((item) => ({
+    product_id: item.product_id,
+    product_slug: item.product_slug,
+    product_name: item.product_name,
+    image: item.image,
+    variant_id: item.variant_id,
+    variant_attributes: typeof item.variant_attributes === "string" ? item.variant_attributes : JSON.stringify(item.variant_attributes ?? {}),
+    unit_price: item.unit_price,
+    quantity: item.quantity,
+    custom_measurements: typeof item.custom_measurements === "string" ? item.custom_measurements : JSON.stringify(item.custom_measurements ?? {}),
+    is_bespoke: item.is_bespoke
+  }));
+  const { data } = await storeManagementAxios.post(
+    "cart/merge",
+    { items: payloadItems },
+    sid ? { headers: { "X-Guest-Session": sid } } : {}
+  );
+  clearGuestSessionId();
+  return { ...data, items: parseItems(data.items || []) };
+}
+async function mergeGuestCartIfPresent() {
+  try {
+    const guestItems = await getGuestCart();
+    if (guestItems.length === 0) return;
+    await mergeGuestCart();
+  } catch (error) {
+    console.warn("[Cart] Failed to merge guest cart:", error);
+  }
+}
+function getGuestCartCount() {
+  return 0;
+}
+function getGuestCartSubtotal() {
+  return 0;
+}
+function getGuestCartProductType() {
+  return "physical";
+}
+
+// src/services/order.service.ts
+function deriveCustomerName(raw) {
+  if (raw.customer_name) return raw.customer_name;
+  if (raw.guest_name) return raw.guest_name;
+  const addr = typeof raw.shipping_address === "object" && raw.shipping_address !== null ? raw.shipping_address : null;
+  if (addr) {
+    const full = `${addr.first_name ?? ""} ${addr.last_name ?? ""}`.trim();
+    if (full) return full;
+  }
+  const email = raw.guest_email ?? raw.customer_email ?? "";
+  if (email) return email.split("@")[0];
+  return "";
+}
+function normaliseStorefrontOrder(raw) {
+  const items = (raw.items ?? []).map((item) => ({
+    id: item.id,
+    productName: item.product_name ?? item.productName ?? "",
+    image: item.image ?? "",
+    quantity: item.quantity ?? 1,
+    price: item.unit_price ?? item.price ?? 0
+  }));
+  const addr = typeof raw.shipping_address === "object" && raw.shipping_address !== null ? raw.shipping_address : null;
+  return {
+    id: raw.id,
+    display_id: raw.display_id,
+    items,
+    total: raw.total_amount ?? raw.total ?? 0,
+    status: raw.status,
+    customerEmail: raw.guest_email ?? raw.customer_email ?? "",
+    customerName: deriveCustomerName(raw),
+    createdAt: raw.created_at ? new Date(raw.created_at).getTime() : Date.now(),
+    updatedAt: raw.updated_at ? new Date(raw.updated_at).getTime() : Date.now(),
+    deliveryMethod: raw.delivery_method,
+    trackingNumber: raw.tracking_number,
+    deliveryAddress: typeof raw.shipping_address === "string" ? raw.shipping_address : addr ? `${addr.street}, ${addr.city}, ${addr.state}, ${addr.country}` : void 0,
+    shippingAddress: addr ? {
+      first_name: addr.first_name ?? "",
+      last_name: addr.last_name ?? "",
+      phone: addr.phone ?? "",
+      street: addr.street ?? "",
+      city: addr.city ?? "",
+      state: addr.state ?? "",
+      lga: addr.lga ?? "",
+      country: addr.country ?? "",
+      postal: addr.postal ?? ""
+    } : void 0,
+    cancellationReason: raw.cancellation_reason,
+    hasBespoke: raw.product_type === "bespoke",
+    bespokeStage: raw.bespoke_stage,
+    bespokeBrief: raw.bespoke_brief,
+    deliveryStatus: raw.delivery_status,
+    carrierName: raw.carrier_name,
+    terminalShipmentId: raw.terminal_shipment_id,
+    guestToken: raw.guest_token,
+    guestEmail: raw.guest_email,
+    guestPhone: raw.guest_phone,
+    guestName: raw.guest_name
+  };
+}
+async function createOrder(payload) {
+  const { data } = await storeManagementAxios.post("orders/storefront", payload);
+  return normaliseStorefrontOrder(data);
+}
+async function findOrder(params) {
+  const { data } = await publicStoreAxios.get("orders/find/", { params });
+  return normaliseStorefrontOrder(data);
+}
+async function findOrderByToken(token) {
+  const { data } = await publicStoreAxios.get("orders/find/", {
+    params: { guest_token: token }
+  });
+  return normaliseStorefrontOrder(data);
+}
+async function getOrders(params) {
+  const { data } = await storeManagementAxios.get("orders/", { params });
+  const items = Array.isArray(data) ? data : data.items ?? [];
+  return items.map(normaliseStorefrontOrder);
+}
+async function cancelOrder(orderId, reason) {
+  const { data } = await storeManagementAxios.post(`orders/${orderId}/cancel/`, { reason });
+  return normaliseStorefrontOrder(data);
+}
+async function trackOrder(orderId, token) {
+  const { data } = await publicStoreAxios.get(`orders/track/${orderId}`, {
+    params: token ? { token } : void 0
+  });
+  return normaliseStorefrontOrder(data);
+}
+
+// src/services/auth.service.ts
+async function loginCustomer(payload) {
+  const config = getRuntimeConfig();
+  const { data } = await authAxios.post("/auth/login/customer/", {
+    ...payload,
+    tenant_id: config.businessId
+  });
+  tokenStore.setAccessToken(data.access);
+  tokenStore.setRefreshToken(data.refresh);
+  resetGraphQLClient();
+  await mergeGuestCartIfPresent();
+  return data;
+}
+async function registerCustomer(payload) {
+  const config = getRuntimeConfig();
+  const { data } = await authAxios.post("/auth/register/customer/", {
+    ...payload,
+    tenant_id: config.businessId
+  });
+  tokenStore.setAccessToken(data.access);
+  tokenStore.setRefreshToken(data.refresh);
+  resetGraphQLClient();
+  await mergeGuestCartIfPresent();
+  return data;
+}
+async function refreshToken2(refresh) {
+  const { data } = await refreshAxios2.post("/auth/token/refresh/", { refresh });
+  return data;
+}
+async function logout() {
+  const refresh = tokenStore.getRefreshToken();
+  const payload = refresh ? { refresh } : {};
+  try {
+    await authAxios.post("/auth/logout/", payload);
+  } catch {
+  } finally {
+    tokenStore.clearAll();
+    resetGraphQLClient();
+  }
+}
+async function verifySocialToken(provider, token) {
+  const config = getRuntimeConfig();
+  const { data } = await authAxios.post(
+    `/auth/social/verify/${provider}/`,
+    {
+      id_token: token,
+      storefront_key: config.storefrontApiKey
+    }
+  );
+  tokenStore.setAccessToken(data.access);
+  tokenStore.setRefreshToken(data.refresh);
+  resetGraphQLClient();
+  return data;
+}
+function parseJwtPayload(token) {
+  try {
+    return JSON.parse(atob(token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")));
+  } catch {
+    return {};
+  }
+}
+function resolveProvider(data) {
+  if (data.is_google_auth_enabled) return "google";
+  if (data.is_facebook_auth_enabled) return "facebook";
+  return "email";
+}
+function resolveAvatar(profilePicture) {
+  if (!profilePicture) return null;
+  if (typeof profilePicture === "string") return profilePicture;
+  if (typeof profilePicture === "object" && profilePicture !== null && "url" in profilePicture) {
+    const url = profilePicture.url;
+    return typeof url === "string" ? url : null;
+  }
+  return null;
+}
+function mapAuthUserToCustomer(data, provider) {
+  const firstname = data.profile?.firstname?.trim() || void 0;
+  const lastname = data.profile?.lastname?.trim() || void 0;
+  const phone = data.profile?.phone?.trim() || void 0;
+  return {
+    id: String(data.id),
+    email: data.email,
+    firstname,
+    lastname,
+    phone,
+    full_name: buildFullName2(firstname, lastname),
+    avatar: resolveAvatar(data.profile?.profile_picture),
+    provider: provider ?? resolveProvider(data)
+  };
+}
+function buildCustomerFromClaims(claims) {
+  const provider = claims.is_google_auth_enabled ? "google" : claims.is_facebook_auth_enabled ? "facebook" : "email";
+  const jwtFullName = String(claims.full_name ?? claims.name ?? "").trim() || void 0;
+  const { firstname: splitFirst, lastname: splitLast } = splitFullName2(jwtFullName);
+  return {
+    id: String(claims.user_id ?? claims.sub ?? ""),
+    email: String(claims.email ?? ""),
+    firstname: splitFirst || void 0,
+    lastname: splitLast || void 0,
+    phone: String(claims.phone ?? "").trim() || void 0,
+    full_name: jwtFullName,
+    avatar: claims.avatar,
+    provider
+  };
+}
+async function getMe() {
+  const { data } = await authAxios.get("/auth/profile/");
+  return mapAuthUserToCustomer(data);
+}
+async function getAuthUser() {
+  const { data } = await authAxios.get("/auth/profile/");
+  return data;
+}
+async function updateProfile(payload) {
+  const { data } = await authAxios.put("/auth/profile/", payload);
+  return mapAuthUserToCustomer(data);
+}
+var refreshPromise = null;
+function classifyError(error) {
+  const err = error;
+  const isNetworkError = !!(!err.response && (err.code === "ECONNABORTED" || err.code === "ERR_NETWORK" || err.message?.includes("Network Error")));
+  const isAuthError = !!(err.response?.status === 401 || err.response?.status === 403);
+  const isBlacklistedError = !!(err.response?.data?.detail === "Token is blacklisted" || err.message === "Token is blacklisted");
+  return { isNetworkError, isAuthError, isBlacklistedError };
+}
+async function retryWithBackoff(fn, maxRetries = 2, baseDelay = 1e3) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const { isNetworkError, isAuthError } = classifyError(error);
+      if (!isNetworkError || isAuthError) {
+        throw error;
+      }
+      if (attempt === maxRetries) {
+        throw error;
+      }
+      const delay = baseDelay * Math.pow(2, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+async function silentRefresh() {
+  const refresh = tokenStore.getRefreshToken();
+  if (!refresh) return null;
+  if (refreshPromise) return refreshPromise;
+  refreshPromise = (async () => {
+    try {
+      const tokens = await retryWithBackoff(() => refreshToken2(refresh), 2, 1e3);
+      tokenStore.setAccessToken(tokens.access);
+      if (tokens.refresh) tokenStore.setRefreshToken(tokens.refresh, tokenStore.isPersistent());
+      const claims = parseJwtPayload(tokens.access);
+      const user = buildCustomerFromClaims(claims);
+      return { user, provider: user.provider };
+    } catch (error) {
+      const { isNetworkError, isAuthError, isBlacklistedError } = classifyError(error);
+      if (isNetworkError) {
+        logger.warn("[silentRefresh] Network error during token refresh (offline/CORS), clearing session:", error);
+      } else if (isBlacklistedError) {
+        logger.log("[silentRefresh] Token was blacklisted (likely from logout), clearing session");
+      } else if (isAuthError) {
+        logger.log("[silentRefresh] Token refresh failed with auth error (expired/invalid), clearing session");
+      } else {
+        logger.error("[silentRefresh] Unexpected error during token refresh, clearing session:", error);
+      }
+      tokenStore.clearAll();
+      return null;
+    } finally {
+      refreshPromise = null;
+    }
+  })();
+  return refreshPromise;
+}
+function storeTokens(access, refresh, remember = true) {
+  tokenStore.setAccessToken(access);
+  tokenStore.setRefreshToken(refresh, remember);
+}
+function buildFullName2(firstname, lastname) {
+  if (firstname && lastname) return `${firstname} ${lastname}`;
+  return firstname || lastname || "";
+}
+function splitFullName2(fullName) {
+  if (!fullName) return { firstname: "", lastname: "" };
+  const parts = fullName.trim().split(/\s+/);
+  if (parts.length === 1) {
+    return { firstname: parts[0], lastname: "" };
+  }
+  return {
+    firstname: parts[0],
+    lastname: parts.slice(1).join(" ")
+  };
+}
+
+// src/services/product.service.ts
+var GET_STOREFRONT_PRODUCTS = `
+  query GetStorefrontProducts($page: Int!, $pageSize: Int!, $collectionSlug: String, $search: String) {
+    storefront_products(page: $page, pageSize: $pageSize, collectionSlug: $collectionSlug, search: $search) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        brand
+        product_type
+        requires_shipping
+        is_consumable
+        is_bespoke
+        base_price
+        currency
+        images { url alt id }
+        tags
+        custom_fields { label unit required }
+        is_published
+        is_featured
+        is_popular
+        is_new
+        is_temporary
+        digital_file_key
+        download_limit
+        download_expires_at
+        weight_kg
+        length_cm
+        width_cm
+        height_cm
+        created_at
+        updated_at
+        variants {
+          id
+          product_id
+          sku
+          attributes
+          price
+          images { url alt id }
+          weight_kg
+          is_active
+          inventory {
+            id
+            product_id
+            variant_id
+            quantity
+            reserved
+            reorder_point
+            reorder_quantity
+            track_quantity
+            allow_backorder
+            available
+            is_in_stock
+            is_low_stock
+            updated_at
+          }
+          created_at
+          updated_at
+        }
+        collections {
+          id
+          business_id
+          name
+          slug
+          description
+          image { url alt id }
+          collection_type
+          rules
+          status
+          sort_order
+          created_at
+          updated_at
+        }
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var GET_STOREFRONT_PRODUCT_BY_SLUG = `
+  query GetStorefrontProductBySlug($slug: String!) {
+    storefront_product_by_slug(slug: $slug) {
+      id
+      business_id
+      name
+      slug
+      description
+      brand
+      product_type
+      requires_shipping
+      is_consumable
+      is_bespoke
+      base_price
+      currency
+      images { url alt id }
+      tags
+      custom_fields { label unit required }
+      is_published
+      is_featured
+      is_popular
+      is_new
+      is_temporary
+      digital_file_key
+      download_limit
+      download_expires_at
+      weight_kg
+      length_cm
+      width_cm
+      height_cm
+      created_at
+      updated_at
+      variants {
+        id
+        product_id
+        sku
+        attributes
+        price
+        images { url alt id }
+        weight_kg
+        is_active
+        inventory {
+          id
+          product_id
+          variant_id
+          quantity
+          reserved
+          reorder_point
+          reorder_quantity
+          track_quantity
+          allow_backorder
+          available
+          is_in_stock
+          is_low_stock
+          updated_at
+        }
+        created_at
+        updated_at
+      }
+      collections {
+        id
+        business_id
+        name
+        slug
+        description
+        image { url alt id }
+        collection_type
+        rules
+        status
+        sort_order
+        created_at
+        updated_at
+      }
+    }
+  }
+`;
+var GET_STOREFRONT_LATEST = `
+  query GetStorefrontLatest($page: Int!, $pageSize: Int!) {
+    storefront_latest(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        brand
+        product_type
+        requires_shipping
+        is_consumable
+        is_bespoke
+        base_price
+        currency
+        images { url alt id }
+        tags
+        custom_fields { label unit required }
+        is_published
+        is_featured
+        is_popular
+        is_new
+        is_temporary
+        digital_file_key
+        download_limit
+        download_expires_at
+        weight_kg
+        length_cm
+        width_cm
+        height_cm
+        created_at
+        updated_at
+        variants {
+          id
+          product_id
+          sku
+          attributes
+          price
+          images { url alt id }
+          weight_kg
+          is_active
+          inventory {
+            id
+            product_id
+            variant_id
+            quantity
+            reserved
+            reorder_point
+            reorder_quantity
+            track_quantity
+            allow_backorder
+            available
+            is_in_stock
+            is_low_stock
+            updated_at
+          }
+          created_at
+          updated_at
+        }
+        collections {
+          id
+          business_id
+          name
+          slug
+          description
+          image { url alt id }
+          collection_type
+          rules
+          status
+          sort_order
+          created_at
+          updated_at
+        }
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var GET_STOREFRONT_POPULAR = `
+  query GetStorefrontPopular($page: Int!, $pageSize: Int!) {
+    storefront_popular(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        brand
+        product_type
+        requires_shipping
+        is_consumable
+        is_bespoke
+        base_price
+        currency
+        images { url alt id }
+        tags
+        custom_fields { label unit required }
+        is_published
+        is_featured
+        is_popular
+        is_new
+        is_temporary
+        digital_file_key
+        download_limit
+        download_expires_at
+        weight_kg
+        length_cm
+        width_cm
+        height_cm
+        created_at
+        updated_at
+        variants {
+          id
+          product_id
+          sku
+          attributes
+          price
+          images { url alt id }
+          weight_kg
+          is_active
+          inventory {
+            id
+            product_id
+            variant_id
+            quantity
+            reserved
+            reorder_point
+            reorder_quantity
+            track_quantity
+            allow_backorder
+            available
+            is_in_stock
+            is_low_stock
+            updated_at
+          }
+          created_at
+          updated_at
+        }
+        collections {
+          id
+          business_id
+          name
+          slug
+          description
+          image { url alt id }
+          collection_type
+          rules
+          status
+          sort_order
+          created_at
+          updated_at
+        }
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var GET_STOREFRONT_FEATURED = `
+  query GetStorefrontFeatured($page: Int!, $pageSize: Int!) {
+    storefront_featured(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        brand
+        product_type
+        requires_shipping
+        is_consumable
+        is_bespoke
+        base_price
+        currency
+        images { url alt id }
+        tags
+        custom_fields { label unit required }
+        is_published
+        is_featured
+        is_popular
+        is_new
+        is_temporary
+        digital_file_key
+        download_limit
+        download_expires_at
+        weight_kg
+        length_cm
+        width_cm
+        height_cm
+        created_at
+        updated_at
+        variants {
+          id
+          product_id
+          sku
+          attributes
+          price
+          images { url alt id }
+          weight_kg
+          is_active
+          inventory {
+            id
+            product_id
+            variant_id
+            quantity
+            reserved
+            reorder_point
+            reorder_quantity
+            track_quantity
+            allow_backorder
+            available
+            is_in_stock
+            is_low_stock
+            updated_at
+          }
+          created_at
+          updated_at
+        }
+        collections {
+          id
+          business_id
+          name
+          slug
+          description
+          image { url alt id }
+          collection_type
+          rules
+          status
+          sort_order
+          created_at
+          updated_at
+        }
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var GET_STOREFRONT_NEW = `
+  query GetStorefrontNew($page: Int!, $pageSize: Int!) {
+    storefront_new(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        brand
+        product_type
+        requires_shipping
+        is_consumable
+        is_bespoke
+        base_price
+        currency
+        images { url alt id }
+        tags
+        custom_fields { label unit required }
+        is_published
+        is_featured
+        is_popular
+        is_new
+        is_temporary
+        digital_file_key
+        download_limit
+        download_expires_at
+        weight_kg
+        length_cm
+        width_cm
+        height_cm
+        created_at
+        updated_at
+        variants {
+          id
+          product_id
+          sku
+          attributes
+          price
+          images { url alt id }
+          weight_kg
+          is_active
+          inventory {
+            id
+            product_id
+            variant_id
+            quantity
+            reserved
+            reorder_point
+            reorder_quantity
+            track_quantity
+            allow_backorder
+            available
+            is_in_stock
+            is_low_stock
+            updated_at
+          }
+          created_at
+          updated_at
+        }
+        collections {
+          id
+          business_id
+          name
+          slug
+          description
+          image { url alt id }
+          collection_type
+          rules
+          status
+          sort_order
+          created_at
+          updated_at
+        }
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var GET_STOREFRONT_RECOMMENDED = `
+  query GetStorefrontRecommended($page: Int!, $pageSize: Int!, $excludeProductId: String) {
+    storefront_recommended(page: $page, pageSize: $pageSize, excludeProductId: $excludeProductId) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        brand
+        product_type
+        requires_shipping
+        is_consumable
+        is_bespoke
+        base_price
+        currency
+        images { url alt id }
+        tags
+        custom_fields { label unit required }
+        is_published
+        is_featured
+        is_popular
+        is_new
+        is_temporary
+        digital_file_key
+        download_limit
+        download_expires_at
+        weight_kg
+        length_cm
+        width_cm
+        height_cm
+        created_at
+        updated_at
+        variants {
+          id
+          product_id
+          sku
+          attributes
+          price
+          images { url alt id }
+          weight_kg
+          is_active
+          inventory {
+            id
+            product_id
+            variant_id
+            quantity
+            reserved
+            reorder_point
+            reorder_quantity
+            track_quantity
+            allow_backorder
+            available
+            is_in_stock
+            is_low_stock
+            updated_at
+          }
+          created_at
+          updated_at
+        }
+        collections {
+          id
+          business_id
+          name
+          slug
+          description
+          image { url alt id }
+          collection_type
+          rules
+          status
+          sort_order
+          created_at
+          updated_at
+        }
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+async function getStorefrontProducts(params) {
+  const client = getGraphQLClient();
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 20,
+    collectionSlug: params?.collectionSlug,
+    search: params?.search
+  };
+  const data = await client.request(GET_STOREFRONT_PRODUCTS, variables);
+  return data.storefront_products;
+}
+async function getStorefrontProductBySlug(slug) {
+  const client = getGraphQLClient();
+  const data = await client.request(GET_STOREFRONT_PRODUCT_BY_SLUG, { slug });
+  return data.storefront_product_by_slug;
+}
+async function getLatestProducts(params) {
+  const client = getGraphQLClient();
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 4
+  };
+  const data = await client.request(GET_STOREFRONT_LATEST, variables);
+  return data.storefront_latest;
+}
+async function getPopularProducts(params) {
+  const client = getGraphQLClient();
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 4
+  };
+  const data = await client.request(GET_STOREFRONT_POPULAR, variables);
+  return data.storefront_popular;
+}
+async function getFeaturedProducts(params) {
+  const client = getGraphQLClient();
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 4
+  };
+  const data = await client.request(GET_STOREFRONT_FEATURED, variables);
+  return data.storefront_featured;
+}
+async function getNewProducts(params) {
+  const client = getGraphQLClient();
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 4
+  };
+  const data = await client.request(GET_STOREFRONT_NEW, variables);
+  return data.storefront_new;
+}
+async function getRecommendedProducts(params) {
+  const client = getGraphQLClient();
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 4,
+    excludeProductId: params?.excludeProductId
+  };
+  const data = await client.request(GET_STOREFRONT_RECOMMENDED, variables);
+  return data.storefront_recommended;
+}
+
+// src/services/collection.service.ts
+var GET_STOREFRONT_COLLECTIONS = `
+  query GetStorefrontCollections($page: Int!, $pageSize: Int!) {
+    storefront_collections(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        image { url alt id }
+        collection_type
+        rules
+        status
+        sort_order
+        created_at
+        updated_at
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var GET_STOREFRONT_COLLECTION_BY_SLUG = `
+  query GetStorefrontCollectionBySlug($slug: String!) {
+    storefront_collection_by_slug(slug: $slug) {
+      id
+      business_id
+      name
+      slug
+      description
+      image { url alt id }
+      collection_type
+      rules
+      status
+      sort_order
+      created_at
+      updated_at
+    }
+  }
+`;
+async function getStorefrontCollections(params) {
+  const client = getGraphQLClient();
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 20
+  };
+  const data = await client.request(GET_STOREFRONT_COLLECTIONS, variables);
+  return data.storefront_collections;
+}
+async function getStorefrontCollectionBySlug(slug) {
+  const client = getGraphQLClient();
+  const data = await client.request(GET_STOREFRONT_COLLECTION_BY_SLUG, { slug });
+  return data.storefront_collection_by_slug;
+}
+
+// src/services/wishlist.service.ts
+var GET_WISHLIST = `
+  query GetWishlist($page: Int!, $pageSize: Int!) {
+    wishlist(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        product_id
+        notes
+        created_at
+        product_name
+        product_slug
+        product_price
+        product_image
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var CHECK_IN_WISHLIST = `
+  query CheckInWishlist($productId: String!) {
+    check_in_wishlist(productId: $productId) {
+      in_wishlist
+    }
+  }
+`;
+async function getWishlist(params) {
+  const client = getGraphQLClient();
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 20
+  };
+  const data = await client.request(GET_WISHLIST, variables);
+  return data.wishlist;
+}
+async function checkInWishlist(productId) {
+  const client = getGraphQLClient();
+  const data = await client.request(CHECK_IN_WISHLIST, { productId });
+  return data.check_in_wishlist;
+}
+async function addToWishlist(productId, notes) {
+  const { data } = await storeManagementAxios.post("wishlist/", {
+    product_id: productId,
+    notes: notes || void 0
+  });
+  return data;
+}
+async function removeFromWishlist(itemId) {
+  await storeManagementAxios.delete(`wishlist/${itemId}`);
+}
+async function removeProductFromWishlist(productId) {
+  await storeManagementAxios.delete(`wishlist/product/${productId}`);
+}
+
+// src/services/payment.service.ts
+async function createDedicatedAccount(request) {
+  const isValidUUID = (str) => {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(str);
+  };
+  const { data } = await paymentAxios.post(
+    "payments/dedicated-account",
+    {
+      order_id: request.order_id && isValidUUID(request.order_id) ? request.order_id : void 0,
+      amount: request.amount,
+      customer_email: request.customer_email,
+      customer_name: request.customer_name,
+      currency: request.currency,
+      idempotency_key: request.idempotency_key
+    }
+  );
+  return data;
+}
+async function initiatePayment(request) {
+  const isValidUUID = (str) => {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(str);
+  };
+  const validOrderId = request.order_id && isValidUUID(request.order_id) ? request.order_id : void 0;
+  const { data } = await paymentAxios.post("payments/storefront/initiate", {
+    amount: request.amount,
+    currency: request.currency,
+    order_id: validOrderId,
+    quote_id: request.quote_id,
+    metadata_json: {
+      customer_email: request.customer_email,
+      customer_name: request.customer_name ?? "",
+      order_id: validOrderId,
+      ...request.metadata ?? {}
+    },
+    idempotency_key: request.idempotency_key
+  });
+  return {
+    id: data.id,
+    gateway_ref: data.gateway_ref,
+    gateway: data.gateway,
+    status: data.status,
+    checkout_url: data.metadata_json?.checkout_url ?? ""
+  };
+}
+async function requestQuote(amount) {
+  const { data } = await paymentAxios.post("payments/quote", { amount });
+  return data;
+}
+async function verifyTransaction(reference) {
+  const { data } = await paymentAxios.post(
+    `payments/verify/${reference}`
+  );
+  return data;
+}
+async function getTransactionStatus(transactionId) {
+  const { data } = await paymentAxios.get(
+    `payments/transactions/${transactionId}`
+  );
+  return data;
+}
+var paymentService = {
+  createDedicatedAccount,
+  initiatePayment,
+  requestQuote,
+  verifyTransaction,
+  getTransactionStatus
+};
+
+// src/services/consultation.service.ts
+async function createConsultation(payload) {
+  const { data } = await storeManagementAxios.post("social/consultations/", payload);
+  return data;
+}
+async function getConsultations() {
+  const { data } = await storeManagementAxios.get("social/consultations/");
+  return data;
+}
+async function getConsultation(id) {
+  const { data } = await storeManagementAxios.get(`social/consultations/${id}`);
+  return data;
+}
+async function sendMessage(id, payload) {
+  await storeManagementAxios.post(`social/consultations/${id}/messages`, payload);
+}
+async function acceptQuote(id, payload) {
+  const { data } = await storeManagementAxios.post(`social/consultations/${id}/accept-quote`, payload);
+  return data;
+}
+async function rejectQuote(id, reason) {
+  const { data } = await storeManagementAxios.post(`social/consultations/${id}/reject-quote`, { reason });
+  return data;
+}
+var consultationService = {
+  createConsultation,
+  getConsultations,
+  getConsultation,
+  sendMessage,
+  acceptQuote,
+  rejectQuote
+};
+
+// src/services/logistics.service.ts
+async function getShippingRates(payload) {
+  const { data } = await storeManagementAxios.post(
+    "logistics/shipping/rates",
+    payload
+  );
+  return data;
+}
+async function getSellerShippingAddress() {
+  const { data } = await storeManagementAxios.get("logistics/shipping-address");
+  return data;
+}
+async function validateShippingAddress(payload) {
+  const { data } = await storeManagementAxios.post("logistics/shipping-address/validate", payload);
+  return data;
+}
+var logisticsService = {
+  getShippingRates,
+  getSellerShippingAddress,
+  validateShippingAddress
+};
+
+// src/services/bespoke.service.ts
+async function checkAvailability(product_id) {
+  const { data } = await storeManagementAxios.get(`bespoke/availability/${product_id}`);
+  return data;
+}
+var bespokeService = {
+  checkAvailability
+};
+
+// src/services/service-booking.service.ts
+async function getAvailableSlots(product_id, date_from, date_to) {
+  const { data } = await storeManagementAxios.get(
+    `service/available-slots/${product_id}`,
+    { params: { date_from, date_to } }
+  );
+  return data;
+}
+async function bookAppointment(payload) {
+  const { data } = await storeManagementAxios.post("service/appointments/", payload);
+  return data;
+}
+async function getAppointments() {
+  const { data } = await storeManagementAxios.get("service/bookings/my");
+  return data;
+}
+async function getAppointment(id) {
+  const { data } = await storeManagementAxios.get(`service/bookings/${id}`);
+  return data;
+}
+async function cancelAppointment(id) {
+  await storeManagementAxios.delete(`service/bookings/${id}`);
+}
+async function getDeliverables(order_id) {
+  const { data } = await storeManagementAxios.get(`service/projects/${order_id}/deliverables/`);
+  return data;
+}
+async function approveDeliverable(order_id, deliverable_id) {
+  const { data } = await storeManagementAxios.post(
+    `service/projects/${order_id}/deliverables/${deliverable_id}/approve`,
+    { approved: true }
+  );
+  return data;
+}
+async function requestRevision(order_id, deliverable_id, feedback) {
+  const { data } = await storeManagementAxios.post(
+    `service/projects/${order_id}/deliverables/${deliverable_id}/revision`,
+    { approved: false, feedback }
+  );
+  return data;
+}
+var serviceBookingService = {
+  getAvailableSlots,
+  bookAppointment,
+  getAppointments,
+  getAppointment,
+  cancelAppointment,
+  getDeliverables,
+  approveDeliverable,
+  requestRevision
+};
+
+// src/services/notifications.service.ts
+async function sendContactEmail(payload) {
+  const { data } = await notificationsAxios.post(
+    "contact/send-contact-email",
+    payload
+  );
+  return data;
+}
+async function sendContactConfirmation(payload) {
+  const { data } = await notificationsAxios.post(
+    "contact/send-contact-confirmation",
+    payload
+  );
+  return data;
+}
+var notificationsService = {
+  sendContactEmail,
+  sendContactConfirmation
+};
+
+// src/services/app.service.ts
+async function googleTranslate(text, target, source = "en") {
+  if (!text || target === source) return text;
+  try {
+    const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${source}&tl=${target}&dt=t&q=${encodeURIComponent(text)}`;
+    const res = await fetch(url);
+    const data = await res.json();
+    return (data?.[0] || []).map((s) => s[0]).join("");
+  } catch {
+    return text;
+  }
+}
+
+// src/services/config.service.ts
+async function getSupportedLanguages() {
+  const { data } = await paymentAxios.get("/config/supported-languages");
+  return data;
+}
+async function getSupportedCurrencies() {
+  const { data } = await paymentAxios.get("/config/supported-currencies");
+  return data;
+}
+async function getBusinessConfig() {
+  const { data } = await publicStoreAxios.get("business/profile");
+  return data;
+}
+var configService = {
+  getSupportedLanguages,
+  getSupportedCurrencies,
+  getBusinessConfig
+};
+
+// src/services/cms.service.ts
+async function listCmsEntries(modelSlug, params) {
+  const config = getRuntimeConfig();
+  const { businessId } = config;
+  const response = await cmsAxios.get(
+    `/sdk/${businessId}/${modelSlug}/entries`,
+    {
+      params: {
+        page: params?.page || 1,
+        page_size: params?.page_size || 50
+      }
+    }
+  );
+  return response.data;
+}
+async function getCmsEntry(modelSlug, entryId) {
+  const config = getRuntimeConfig();
+  const { businessId } = config;
+  const response = await cmsAxios.get(
+    `/sdk/${businessId}/${modelSlug}/entries/${entryId}`
+  );
+  return response.data;
+}
+async function createCmsEntry(modelSlug, params) {
+  const config = getRuntimeConfig();
+  const { businessId } = config;
+  const response = await cmsAxios.post(
+    `/sdk/${businessId}/${modelSlug}/entries`,
+    params
+  );
+  return response.data;
+}
+async function updateCmsEntry(modelSlug, entryId, params) {
+  const config = getRuntimeConfig();
+  const { businessId } = config;
+  const response = await cmsAxios.put(
+    `/sdk/${businessId}/${modelSlug}/entries/${entryId}`,
+    params
+  );
+  return response.data;
+}
+async function deleteCmsEntry(modelSlug, entryId) {
+  const config = getRuntimeConfig();
+  const { businessId } = config;
+  await cmsAxios.delete(
+    `/sdk/${businessId}/${modelSlug}/entries/${entryId}`
+  );
+}
+
+// src/hooks/use-cart.ts
+var import_react = __toESM(require("react"));
+var import_react_query = require("@tanstack/react-query");
+var import_axios4 = __toESM(require("axios"));
+var CartCtx = import_react.default.createContext ? import_react.default.createContext(null) : null;
+function CartProvider({ children }) {
+  const [isOpen, setIsOpen] = (0, import_react.useState)(false);
+  if (!CartCtx) return children;
+  return import_react.default.createElement(CartCtx.Provider, { value: { isOpen, setOpen: setIsOpen } }, children);
+}
+function useCart() {
+  const queryClient = (0, import_react_query.useQueryClient)();
+  const context = CartCtx ? (0, import_react.useContext)(CartCtx) : null;
+  const isOpen = context ? context.isOpen : false;
+  const setOpen = context ? context.setOpen : () => {
+  };
+  const [productTypeMismatch, setProductTypeMismatch] = (0, import_react.useState)(null);
+  const cartQuery = (0, import_react_query.useQuery)({
+    queryKey: ["cart"],
+    queryFn: getCart,
+    enabled: isInitialized()
+  });
+  const addToCartMutation = (0, import_react_query.useMutation)({
+    mutationFn: addToCart,
+    onSuccess: () => {
+      setProductTypeMismatch(null);
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+    },
+    onError: (error) => {
+      if (import_axios4.default.isAxiosError(error) && error.response?.status === 409) {
+        const responseData = error.response?.data;
+        const errorDetail = responseData?.detail;
+        if (errorDetail?.code === "CART_PRODUCT_TYPE_MISMATCH") {
+          setProductTypeMismatch({
+            message: errorDetail.message ?? "Your cart contains incompatible items.",
+            existing_type: errorDetail.existing_type ?? "physical",
+            new_type: errorDetail.new_type ?? "physical"
+          });
+        }
+      }
+    }
+  });
+  const updateCartItemMutation = (0, import_react_query.useMutation)({
+    mutationFn: ({ itemId, quantity }) => updateCartItem(itemId, quantity),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+    }
+  });
+  const removeFromCartMutation = (0, import_react_query.useMutation)({
+    mutationFn: removeFromCart,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+    }
+  });
+  const clearCartMutation = (0, import_react_query.useMutation)({
+    mutationFn: clearCart,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+    }
+  });
+  const mergeGuestCartMutation = (0, import_react_query.useMutation)({
+    mutationFn: mergeGuestCartIfPresent,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+    }
+  });
+  const addItem = (product, variantId, quantity = 1, customMeasurements) => {
+    const variant = variantId ? product.variants.find((v) => v.id === variantId) : void 0;
+    return addToCartMutation.mutate({
+      product_id: product.id,
+      product_slug: product.slug,
+      product_name: product.name,
+      image: product.images[0]?.url,
+      variant_id: variantId,
+      variant_attributes: variant?.attributes ? JSON.stringify(variant.attributes) : void 0,
+      unit_price: variant?.price ?? product.base_price,
+      quantity,
+      custom_measurements: customMeasurements ? JSON.stringify(customMeasurements) : void 0,
+      is_bespoke: product.is_bespoke
+    });
+  };
+  const items = cartQuery.data?.items || [];
+  const subtotal = cartQuery.data?.subtotal || 0;
+  const count = items.reduce((total, item) => total + item.quantity, 0);
+  const updateQty = (itemId, quantity) => {
+    updateCartItemMutation.mutate({ itemId, quantity });
+  };
+  const removeItem = (itemId) => {
+    removeFromCartMutation.mutate(itemId);
+  };
+  const handleClearCartAndAdd = () => {
+    clearCartMutation.mutate();
+    setProductTypeMismatch(null);
+  };
+  const handleKeepCurrentCart = () => {
+    setProductTypeMismatch(null);
+  };
+  return {
+    cart: cartQuery.data,
+    items,
+    count,
+    isOpen,
+    setOpen,
+    isLoading: cartQuery.isLoading,
+    error: cartQuery.error,
+    addToCart: addToCartMutation.mutate,
+    updateCartItem: updateCartItemMutation.mutate,
+    removeFromCart: removeFromCartMutation.mutate,
+    clearCart: clearCartMutation.mutate,
+    clear: clearCartMutation.mutate,
+    // Alias for storefront compatibility
+    mergeGuestCart: mergeGuestCartMutation.mutate,
+    addItem,
+    updateQty,
+    removeItem,
+    subtotal,
+    productTypeMismatch,
+    handleClearCartAndAdd,
+    handleKeepCurrentCart
+  };
+}
+
+// src/hooks/use-orders.ts
+var import_react_query2 = require("@tanstack/react-query");
+function useOrders(params) {
+  return (0, import_react_query2.useQuery)({
+    queryKey: ["orders", params],
+    queryFn: () => getOrders(params)
+  });
+}
+function useOrdersList(params) {
+  return useOrders(params);
+}
+function useFindOrder(params) {
+  return (0, import_react_query2.useQuery)({
+    queryKey: ["order", params],
+    queryFn: () => findOrder(params),
+    enabled: !!params.email && !!params.order_id
+  });
+}
+function useOrder(params) {
+  return useFindOrder(params);
+}
+function useOrderTracking(orderId, token) {
+  return (0, import_react_query2.useQuery)({
+    queryKey: ["order-tracking", orderId, token],
+    queryFn: () => trackOrder(orderId, token),
+    enabled: !!orderId,
+    refetchInterval: 3e4
+    // Refetch every 30 seconds for tracking updates
+  });
+}
+function useCreateOrder() {
+  const queryClient = (0, import_react_query2.useQueryClient)();
+  return (0, import_react_query2.useMutation)({
+    mutationFn: createOrder,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["orders"] });
+    }
+  });
+}
+function useCancelOrder() {
+  const queryClient = (0, import_react_query2.useQueryClient)();
+  return (0, import_react_query2.useMutation)({
+    mutationFn: ({ orderId, reason }) => cancelOrder(orderId, reason),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["orders"] });
+    }
+  });
+}
+
+// src/hooks/use-auth.ts
+var import_react2 = __toESM(require("react"));
+var import_react_query3 = require("@tanstack/react-query");
+var AuthCtx = import_react2.default.createContext ? import_react2.default.createContext(null) : null;
+function AuthProvider({ children }) {
+  const [customer, setCustomer] = (0, import_react2.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(true);
+  const [isModalOpen, setIsModalOpen] = (0, import_react2.useState)(false);
+  (0, import_react2.useEffect)(() => {
+    let voided = false;
+    (async () => {
+      setIsLoading(true);
+      try {
+        const result = await silentRefresh();
+        if (!voided && result) {
+          setCustomer(result.user);
+          resetGraphQLClient();
+        }
+      } catch (error) {
+        logger.error("[AuthProvider] Session restore failed:", error);
+        if (!voided) setCustomer(null);
+      } finally {
+        if (!voided) setIsLoading(false);
+      }
+    })();
+    return () => {
+      voided = true;
+    };
+  }, []);
+  const openModal = (0, import_react2.useCallback)(() => setIsModalOpen(true), []);
+  const closeModal = (0, import_react2.useCallback)(() => {
+    setIsModalOpen(false);
+    if (typeof window !== "undefined" && (window.location.hash === "#login" || window.location.hash === "#signup")) {
+      window.history.replaceState(null, "", window.location.pathname + window.location.search);
+    }
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    const handleHash = () => {
+      if (typeof window === "undefined") return;
+      if (window.location.hash === "#login" || window.location.hash === "#signup") {
+        if (!isLoading && customer) {
+          window.history.replaceState(null, "", window.location.pathname + window.location.search);
+        } else if (!isLoading && !customer) {
+          setIsModalOpen(true);
+        }
+      }
+    };
+    handleHash();
+    window.addEventListener("hashchange", handleHash);
+    return () => window.removeEventListener("hashchange", handleHash);
+  }, [customer, isLoading]);
+  (0, import_react2.useEffect)(() => {
+    resetGraphQLClient();
+  }, [customer]);
+  const handleLogout = (0, import_react2.useCallback)(async () => {
+    await logout();
+    setCustomer(null);
+    setIsModalOpen(false);
+    resetGraphQLClient();
+  }, []);
+  const value = {
+    customer,
+    isLoading,
+    isModalOpen,
+    openModal,
+    closeModal,
+    setCustomer,
+    logout: handleLogout
+  };
+  if (!AuthCtx) return children;
+  return import_react2.default.createElement(AuthCtx.Provider, { value }, children);
+}
+function useAuthUser() {
+  return (0, import_react_query3.useQuery)({
+    queryKey: ["auth-user"],
+    queryFn: getAuthUser,
+    enabled: !!tokenStore.getAccessToken()
+  });
+}
+function useLogin() {
+  const queryClient = (0, import_react_query3.useQueryClient)();
+  return (0, import_react_query3.useMutation)({
+    mutationFn: loginCustomer,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["auth-user"] });
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+    }
+  });
+}
+function useRegister() {
+  const queryClient = (0, import_react_query3.useQueryClient)();
+  return (0, import_react_query3.useMutation)({
+    mutationFn: registerCustomer,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["auth-user"] });
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+    }
+  });
+}
+function useUpdateProfile() {
+  const queryClient = (0, import_react_query3.useQueryClient)();
+  return (0, import_react_query3.useMutation)({
+    mutationFn: updateProfile,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["auth-user"] });
+    }
+  });
+}
+function useLogout() {
+  const queryClient = (0, import_react_query3.useQueryClient)();
+  return (0, import_react_query3.useMutation)({
+    mutationFn: logout,
+    onSuccess: () => {
+      queryClient.clear();
+    }
+  });
+}
+function useAuth() {
+  const context = AuthCtx ? (0, import_react2.useContext)(AuthCtx) : null;
+  if (context) return context;
+  const authUserQuery = useAuthUser();
+  const logoutMutation = useLogout();
+  return {
+    customer: authUserQuery.data,
+    isLoading: authUserQuery.isLoading,
+    isModalOpen: false,
+    openModal: () => {
+    },
+    closeModal: () => {
+    },
+    setCustomer: () => {
+    },
+    logout: async () => {
+      await logoutMutation.mutateAsync();
+    }
+  };
+}
+
+// src/hooks/use-countries.ts
+var import_react_query4 = require("@tanstack/react-query");
+async function getCountries() {
+  const { data } = await authAxios.get("auth/countries/");
+  return data;
+}
+function useCountries() {
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["countries"],
+    queryFn: () => getCountries(),
+    retry: 1,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    staleTime: 24 * 60 * 60 * 1e3
+    // 24 hours
+  });
+}
+
+// src/hooks/use-states.ts
+var import_react_query5 = require("@tanstack/react-query");
+async function getStates(countryIso) {
+  if (!countryIso) return [];
+  const { data } = await authAxios.get("auth/countries/", {
+    params: { iso: countryIso }
+  });
+  return data;
+}
+function useStates(countryIso) {
+  return (0, import_react_query5.useQuery)({
+    queryKey: ["states", countryIso],
+    queryFn: () => getStates(countryIso),
+    enabled: !!countryIso,
+    retry: 1,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    staleTime: 24 * 60 * 60 * 1e3
+    // 24 hours
+  });
+}
+
+// src/hooks/use-languages.ts
+var import_react_query6 = require("@tanstack/react-query");
+async function getSupportedLanguagesList() {
+  const data = await getSupportedLanguages();
+  return data.languages.map((language) => ({
+    code: language.code,
+    appCode: language.code,
+    label: language.label,
+    native: language.label,
+    flag: language.flag
+  }));
+}
+function useSupportedLanguages() {
+  return (0, import_react_query6.useQuery)({
+    queryKey: ["supported-languages"],
+    queryFn: () => getSupportedLanguagesList(),
+    enabled: isInitialized(),
+    retry: 1,
+    ...getCacheTier("high")
+  });
+}
+
+// src/hooks/use-currencies.ts
+var import_react_query7 = require("@tanstack/react-query");
+async function getSupportedCurrenciesList() {
+  const data = await getSupportedCurrencies();
+  return data.currencies || [];
+}
+function useCurrencies() {
+  return (0, import_react_query7.useQuery)({
+    queryKey: ["supported-currencies"],
+    queryFn: () => getSupportedCurrenciesList(),
+    enabled: isInitialized(),
+    retry: 1,
+    ...getCacheTier("high")
+  });
+}
+
+// src/hooks/use-bespoke-availability.ts
+var import_react_query8 = require("@tanstack/react-query");
+function useBespokeAvailability(product_id) {
+  return (0, import_react_query8.useQuery)({
+    queryKey: ["bespoke-availability", product_id],
+    queryFn: () => bespokeService.checkAvailability(product_id),
+    enabled: !!product_id,
+    retry: false
+    // Don't retry if no config exists (returns 404)
+  });
+}
+
+// src/hooks/use-collections.ts
+var import_react_query9 = require("@tanstack/react-query");
+var collectionKeys = {
+  all: ["core", "collections"],
+  list: (params) => ["core", "collections", "list", params ?? {}],
+  slug: (slug) => ["core", "collections", "slug", slug]
+};
+function useStorefrontCollections(params) {
+  return (0, import_react_query9.useQuery)({
+    queryKey: collectionKeys.list(params),
+    queryFn: () => getStorefrontCollections(params),
+    // medium — collections change infrequently
+    ...getCacheTier("medium")
+  });
+}
+function useStorefrontCollection(slug) {
+  return (0, import_react_query9.useQuery)({
+    queryKey: collectionKeys.slug(slug),
+    queryFn: () => getStorefrontCollectionBySlug(slug),
+    // medium — collection details change infrequently
+    ...getCacheTier("medium"),
+    enabled: !!slug
+  });
+}
+
+// src/hooks/use-products.ts
+var import_react_query10 = require("@tanstack/react-query");
+var productKeys = {
+  all: ["products"],
+  list: (params) => [...productKeys.all, "list", params],
+  detail: (slug) => [...productKeys.all, "detail", slug],
+  recommended: (params) => [...productKeys.all, "recommended", params],
+  latest: (params) => [...productKeys.all, "latest", params],
+  popular: (params) => [...productKeys.all, "popular", params],
+  featured: (params) => [...productKeys.all, "featured", params],
+  new: (params) => [...productKeys.all, "new", params]
+};
+function useLatestProducts(params) {
+  return (0, import_react_query10.useQuery)({
+    queryKey: productKeys.latest(params),
+    queryFn: () => getLatestProducts(params),
+    // medium — latest products change infrequently
+    ...getCacheTier("medium")
+  });
+}
+function usePopularProducts(params) {
+  return (0, import_react_query10.useQuery)({
+    queryKey: productKeys.popular(params),
+    queryFn: () => getPopularProducts(params),
+    // medium — popular products change infrequently
+    ...getCacheTier("medium")
+  });
+}
+function useFeaturedProducts(params) {
+  return (0, import_react_query10.useQuery)({
+    queryKey: productKeys.featured(params),
+    queryFn: () => getFeaturedProducts(params),
+    // medium — featured products change infrequently
+    ...getCacheTier("medium")
+  });
+}
+function useNewProducts(params) {
+  return (0, import_react_query10.useQuery)({
+    queryKey: productKeys.new(params),
+    queryFn: () => getNewProducts(params),
+    // medium — new products change infrequently
+    ...getCacheTier("medium")
+  });
+}
+function useStorefrontProducts(params) {
+  return (0, import_react_query10.useQuery)({
+    queryKey: productKeys.list(params),
+    queryFn: () => getStorefrontProducts(params),
+    // medium — product catalog changes infrequently
+    ...getCacheTier("medium")
+  });
+}
+function useProduct(slug) {
+  return (0, import_react_query10.useQuery)({
+    queryKey: productKeys.detail(slug),
+    queryFn: () => getStorefrontProductBySlug(slug),
+    // medium — product details change infrequently
+    ...getCacheTier("medium"),
+    enabled: !!slug
+  });
+}
+function useRecommendedProducts(params) {
+  return (0, import_react_query10.useQuery)({
+    queryKey: productKeys.recommended(params),
+    queryFn: () => getRecommendedProducts(params),
+    // medium — recommendations change infrequently
+    ...getCacheTier("medium")
+  });
+}
+
+// src/hooks/use-wishlist.ts
+var import_react_query11 = require("@tanstack/react-query");
+var wishlistKeys = {
+  all: ["wishlist"],
+  list: () => [...wishlistKeys.all, "list"],
+  check: (productId) => [...wishlistKeys.all, "check", productId]
+};
+function useWishlist(params) {
+  return (0, import_react_query11.useQuery)({
+    queryKey: [...wishlistKeys.list(), params],
+    queryFn: () => getWishlist(params),
+    // medium — wishlist changes infrequently
+    ...getCacheTier("medium")
+  });
+}
+function useCheckInWishlist(productId) {
+  return (0, import_react_query11.useQuery)({
+    queryKey: wishlistKeys.check(productId),
+    queryFn: () => checkInWishlist(productId),
+    // low — wishlist check changes frequently
+    ...getCacheTier("low"),
+    enabled: !!productId
+  });
+}
+function useAddToWishlist() {
+  const queryClient = (0, import_react_query11.useQueryClient)();
+  return (0, import_react_query11.useMutation)({
+    mutationFn: ({ productId, notes }) => {
+      return addToWishlist(productId, notes);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: wishlistKeys.all });
+      queryClient.invalidateQueries({ queryKey: ["wishlist", "check"] });
+    }
+  });
+}
+function useRemoveFromWishlist() {
+  const queryClient = (0, import_react_query11.useQueryClient)();
+  return (0, import_react_query11.useMutation)({
+    mutationFn: (itemId) => {
+      return removeFromWishlist(itemId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: wishlistKeys.all });
+      queryClient.invalidateQueries({ queryKey: ["wishlist", "check"] });
+    }
+  });
+}
+function useRemoveProductFromWishlist() {
+  const queryClient = (0, import_react_query11.useQueryClient)();
+  return (0, import_react_query11.useMutation)({
+    mutationFn: (productId) => {
+      return removeProductFromWishlist(productId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: wishlistKeys.all });
+      queryClient.invalidateQueries({ queryKey: ["wishlist", "check"] });
+    }
+  });
+}
+function useWishlistCount() {
+  const backendQuery = (0, import_react_query11.useQuery)({
+    queryKey: wishlistKeys.list(),
+    queryFn: () => getWishlist(),
+    // low — wishlist count changes frequently
+    ...getCacheTier("low"),
+    select: (data) => data.total
+  });
+  return backendQuery;
+}
+
+// src/hooks/use-service-booking.ts
+var import_react_query12 = require("@tanstack/react-query");
+function useAvailableSlots(product_id, date_from, date_to) {
+  return (0, import_react_query12.useQuery)({
+    queryKey: ["available-slots", product_id, date_from, date_to],
+    queryFn: () => serviceBookingService.getAvailableSlots(product_id, date_from, date_to),
+    enabled: !!product_id && !!date_from && !!date_to
+  });
+}
+function useBookAppointment() {
+  const queryClient = (0, import_react_query12.useQueryClient)();
+  return (0, import_react_query12.useMutation)({
+    mutationFn: serviceBookingService.bookAppointment,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] });
+    }
+  });
+}
+function useAppointments() {
+  return (0, import_react_query12.useQuery)({
+    queryKey: ["appointments"],
+    queryFn: serviceBookingService.getAppointments
+  });
+}
+function useAppointment(id) {
+  return (0, import_react_query12.useQuery)({
+    queryKey: ["appointment", id],
+    queryFn: () => serviceBookingService.getAppointment(id),
+    enabled: !!id
+  });
+}
+function useCancelAppointment() {
+  const queryClient = (0, import_react_query12.useQueryClient)();
+  return (0, import_react_query12.useMutation)({
+    mutationFn: (id) => serviceBookingService.cancelAppointment(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] });
+    }
+  });
+}
+function useDeliverables(order_id) {
+  return (0, import_react_query12.useQuery)({
+    queryKey: ["deliverables", order_id],
+    queryFn: () => serviceBookingService.getDeliverables(order_id),
+    enabled: !!order_id
+  });
+}
+function useApproveDeliverable(order_id, deliverable_id) {
+  const queryClient = (0, import_react_query12.useQueryClient)();
+  return (0, import_react_query12.useMutation)({
+    mutationFn: () => serviceBookingService.approveDeliverable(order_id, deliverable_id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] });
+    }
+  });
+}
+function useRequestRevision(order_id, deliverable_id) {
+  const queryClient = (0, import_react_query12.useQueryClient)();
+  return (0, import_react_query12.useMutation)({
+    mutationFn: (feedback) => serviceBookingService.requestRevision(order_id, deliverable_id, feedback),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] });
+    }
+  });
+}
+
+// src/hooks/use-consultations.ts
+var import_react_query13 = require("@tanstack/react-query");
+function useConsultations() {
+  return (0, import_react_query13.useQuery)({
+    queryKey: ["consultations"],
+    queryFn: () => consultationService.getConsultations()
+  });
+}
+function useConsultation(id) {
+  return (0, import_react_query13.useQuery)({
+    queryKey: ["consultation", id],
+    queryFn: () => consultationService.getConsultation(id),
+    enabled: !!id
+  });
+}
+function useCreateConsultation() {
+  const queryClient = (0, import_react_query13.useQueryClient)();
+  return (0, import_react_query13.useMutation)({
+    mutationFn: (payload) => consultationService.createConsultation(payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["consultations"] });
+    }
+  });
+}
+function useSendMessage(consultationId) {
+  const queryClient = (0, import_react_query13.useQueryClient)();
+  return (0, import_react_query13.useMutation)({
+    mutationFn: (payload) => consultationService.sendMessage(consultationId, payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["consultation", consultationId] });
+    }
+  });
+}
+function useAcceptQuote(consultationId) {
+  const queryClient = (0, import_react_query13.useQueryClient)();
+  return (0, import_react_query13.useMutation)({
+    mutationFn: (payload) => consultationService.acceptQuote(consultationId, payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["consultation", consultationId] });
+    }
+  });
+}
+function useRejectQuote(consultationId) {
+  const queryClient = (0, import_react_query13.useQueryClient)();
+  return (0, import_react_query13.useMutation)({
+    mutationFn: (reason) => consultationService.rejectQuote(consultationId, reason),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["consultation", consultationId] });
+    }
+  });
+}
+
+// src/hooks/use-consultation-stream.ts
+var import_react3 = require("react");
+var import_fetch_event_source = require("@microsoft/fetch-event-source");
+function useConsultationStream({
+  consultationId,
+  onMessage,
+  onQuote,
+  onStatusChange,
+  onError
+}) {
+  const abortControllerRef = (0, import_react3.useRef)(null);
+  const [isConnected, setIsConnected] = (0, import_react3.useState)(false);
+  const [lastEvent, setLastEvent] = (0, import_react3.useState)(null);
+  (0, import_react3.useEffect)(() => {
+    if (!consultationId) {
+      return;
+    }
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    const paymentUrl = getBackendUrl("payment");
+    const streamUrl = `${paymentUrl}/events/stream/consultation/${consultationId}`;
+    (0, import_fetch_event_source.fetchEventSource)(streamUrl, {
+      method: "GET",
+      signal: abortController.signal,
+      onmessage: (event) => {
+        try {
+          if (!event.data || event.data.trim() === "") {
+            return;
+          }
+          const data = JSON.parse(event.data);
+          logger.log("[ConsultationStream] Received event:", data);
+          setLastEvent(data);
+          if (data.event === "consultation.message") {
+            logger.log("[ConsultationStream] Message detected, calling onMessage");
+            if (onMessage) {
+              onMessage(data);
+            }
+          }
+          if (data.event === "consultation.quote") {
+            logger.log("[ConsultationStream] Quote detected, calling onQuote");
+            if (onQuote) {
+              onQuote(data);
+            }
+          }
+          if (data.event === "consultation.status") {
+            logger.log("[ConsultationStream] Status change detected, calling onStatusChange");
+            if (onStatusChange) {
+              onStatusChange(data);
+            }
+          }
+        } catch (error) {
+          logger.error("[ConsultationStream] Error parsing event:", error);
+        }
+      },
+      onerror: (error) => {
+        if (abortController.signal.aborted) {
+          logger.log("[ConsultationStream] Connection closed via AbortController");
+          return;
+        }
+        logger.error("[ConsultationStream] Connection error:", error);
+        setIsConnected(false);
+        if (onError) {
+          onError(error);
+        }
+      },
+      onopen: async (response) => {
+        if (response.ok && response.headers.get("content-type")?.includes("text/event-stream")) {
+          logger.log("[ConsultationStream] Connection established for consultation:", consultationId);
+          setIsConnected(true);
+          return;
+        }
+        throw new Error(`Unexpected response: ${response.status}`);
+      }
+    }).catch((error) => {
+      if (abortController.signal.aborted || error.name === "AbortError") {
+        return;
+      }
+      logger.error("[ConsultationStream] fetchEventSource failed:", error);
+    });
+    return () => {
+      abortController.abort();
+      setIsConnected(false);
+    };
+  }, [consultationId, onMessage, onQuote, onStatusChange, onError]);
+  return { isConnected, lastEvent };
+}
+
+// src/hooks/use-order-stream.ts
+var import_react4 = require("react");
+var import_fetch_event_source2 = require("@microsoft/fetch-event-source");
+function useOrderStream({
+  orderId,
+  onPaymentComplete,
+  onDigitalReady,
+  onBespokeUpdate,
+  onConsultationUpdate,
+  onServiceBookingUpdate,
+  onError
+}) {
+  const abortControllerRef = (0, import_react4.useRef)(null);
+  (0, import_react4.useEffect)(() => {
+    if (!orderId) {
+      return;
+    }
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    const paymentUrl = getBackendUrl("payment");
+    const streamUrl = `${paymentUrl}/events/stream/order/${encodeURIComponent(orderId)}`;
+    (0, import_fetch_event_source2.fetchEventSource)(streamUrl, {
+      method: "GET",
+      signal: abortController.signal,
+      onmessage: (event) => {
+        try {
+          if (!event.data || event.data.trim() === "") {
+            return;
+          }
+          const data = JSON.parse(event.data);
+          logger.log("[OrderStream] Received event:", data);
+          if (data.event === "payment.success") {
+            logger.log("[OrderStream] Payment success detected, calling onPaymentComplete");
+            if (onPaymentComplete) {
+              onPaymentComplete(data);
+            }
+            abortController.abort();
+          }
+          if (data.event === "digital.ready") {
+            logger.log("[OrderStream] Digital delivery ready detected, calling onDigitalReady");
+            if (onDigitalReady) {
+              onDigitalReady(data);
+            }
+          }
+          if (data.event === "bespoke.update") {
+            logger.log("[OrderStream] Bespoke update detected, calling onBespokeUpdate");
+            if (onBespokeUpdate) {
+              onBespokeUpdate(data);
+            }
+          }
+          if (data.event === "consultation.update") {
+            logger.log("[OrderStream] Consultation update detected, calling onConsultationUpdate");
+            if (onConsultationUpdate) {
+              onConsultationUpdate(data);
+            }
+          }
+          if (data.event === "service_booking.update") {
+            logger.log("[OrderStream] Service booking update detected, calling onServiceBookingUpdate");
+            if (onServiceBookingUpdate) {
+              onServiceBookingUpdate(data);
+            }
+          }
+        } catch (error) {
+          logger.error("[OrderStream] Error parsing event:", error);
+        }
+      },
+      onerror: (error) => {
+        if (abortController.signal.aborted) {
+          logger.log("[OrderStream] Connection closed via AbortController");
+          return;
+        }
+        if (error.message?.includes("404") || error.message?.includes("Not Found")) {
+          logger.warn("[OrderStream] Stream endpoint unavailable for order:", orderId);
+          return;
+        }
+        logger.error("[OrderStream] Connection error:", error);
+        if (onError) {
+          onError(error);
+        }
+      },
+      onopen: async (response) => {
+        if (response.ok && response.headers.get("content-type")?.includes("text/event-stream")) {
+          logger.log("[OrderStream] Connection established for order:", orderId);
+          return;
+        }
+        if (response.status === 404) {
+          logger.warn("[OrderStream] Stream endpoint unavailable for order:", orderId);
+          return;
+        }
+        throw new Error(`Unexpected response: ${response.status}`);
+      }
+    }).catch((error) => {
+      if (abortController.signal.aborted || error.name === "AbortError") {
+        return;
+      }
+      logger.error("[OrderStream] fetchEventSource failed:", error);
+    });
+    return () => {
+      abortController.abort();
+    };
+  }, [orderId, onPaymentComplete, onDigitalReady, onBespokeUpdate, onConsultationUpdate, onServiceBookingUpdate, onError]);
+  return null;
+}
+
+// src/hooks/use-is-mounted.ts
+var import_react5 = require("react");
+function useIsMounted() {
+  const [mounted, setMounted] = (0, import_react5.useState)(false);
+  (0, import_react5.useEffect)(() => {
+    setMounted(true);
+  }, []);
+  return mounted;
+}
+
+// src/hooks/use-google-translate.ts
+var import_react6 = require("react");
+var SCRIPT_ID = "google-translate-script";
+var ELEMENT_ID = "google_translate_element";
+function fireChange(googleCode) {
+  const combo = document.querySelector(".goog-te-combo");
+  if (combo) {
+    combo.value = googleCode;
+    combo.dispatchEvent(new Event("change"));
+    return true;
+  }
+  return false;
+}
+function useGoogleTranslate(appLang) {
+  const [isLoaded, setIsLoaded] = (0, import_react6.useState)(false);
+  const initRef = (0, import_react6.useRef)(false);
+  const { data: supportedLangs = [] } = useSupportedLanguages();
+  const clearCookies = (0, import_react6.useCallback)(() => {
+    if (typeof window === "undefined") return;
+    const domains = [
+      window.location.hostname,
+      "." + window.location.hostname,
+      "." + window.location.hostname.split(".").slice(-2).join(".")
+    ];
+    const path = "/";
+    document.cookie = `googtrans=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=${path};`;
+    domains.forEach((domain) => {
+      document.cookie = `googtrans=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=${path}; domain=${domain};`;
+    });
+  }, []);
+  const resetToEnglish = (0, import_react6.useCallback)(() => {
+    if (typeof window === "undefined") return;
+    const googtrans = document.cookie.split("; ").find((row) => row.startsWith("googtrans="))?.split("=")[1];
+    const domains = [
+      window.location.hostname,
+      "." + window.location.hostname,
+      window.location.hostname.split(".").slice(-2).join("."),
+      "." + window.location.hostname.split(".").slice(-2).join(".")
+    ];
+    const clear = (name) => {
+      document.cookie = `${name}=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;`;
+      domains.forEach((d) => {
+        document.cookie = `${name}=; Path=/; Domain=${d}; Expires=Thu, 01 Jan 1970 00:00:01 GMT;`;
+      });
+    };
+    clear("googtrans");
+    if (googtrans || document.documentElement.classList.contains("translated-ltr") || document.querySelector(".goog-te-banner-frame")) {
+      window.location.reload();
+      return;
+    }
+    document.body.style.top = "0";
+    document.documentElement.classList.remove("translated-ltr", "translated-rtl");
+    const container = document.getElementById(":1.container");
+    if (container) container.style.display = "none";
+  }, []);
+  const changeLanguage = (0, import_react6.useCallback)((nextAppCode) => {
+    if (nextAppCode === "en") {
+      resetToEnglish();
+      return;
+    }
+    const googleCode = nextAppCode;
+    const container = document.getElementById(":1.container");
+    if (container) container.style.display = "block";
+    let tries = 0;
+    const tick = () => {
+      if (fireChange(googleCode)) return;
+      if (tries++ < 30) setTimeout(tick, 200);
+    };
+    tick();
+  }, [resetToEnglish]);
+  (0, import_react6.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    if (appLang === "en" && !initRef.current) return;
+    if (initRef.current) return;
+    if (supportedLangs.length === 0) return;
+    initRef.current = true;
+    if (!document.getElementById(ELEMENT_ID)) {
+      const host = document.createElement("div");
+      host.id = ELEMENT_ID;
+      host.style.display = "none";
+      document.body.appendChild(host);
+    }
+    const includedLanguages = supportedLangs.map((l) => l.code).join(",");
+    window.googleTranslateElementInit = () => {
+      if (window.google?.translate?.TranslateElement) {
+        new window.google.translate.TranslateElement(
+          { pageLanguage: "en", includedLanguages, autoDisplay: false },
+          ELEMENT_ID
+        );
+        setIsLoaded(true);
+      }
+    };
+    if (!document.getElementById(SCRIPT_ID)) {
+      const script = document.createElement("script");
+      script.id = SCRIPT_ID;
+      script.src = "//translate.google.com/translate_a/element.js?cb=googleTranslateElementInit";
+      script.async = true;
+      document.body.appendChild(script);
+    } else {
+      if (window.google?.translate) window.googleTranslateElementInit?.();
+    }
+  }, [appLang, supportedLangs]);
+  (0, import_react6.useEffect)(() => {
+    if (isLoaded || appLang === "en" && initRef.current) {
+      changeLanguage(appLang);
+    }
+  }, [appLang, isLoaded, changeLanguage]);
+  return { isLoaded };
+}
+
+// src/hooks/use-payment.ts
+var import_react_query14 = require("@tanstack/react-query");
+function useCreateDVA() {
+  const queryClient = (0, import_react_query14.useQueryClient)();
+  return (0, import_react_query14.useMutation)({
+    mutationFn: (request) => paymentService.createDedicatedAccount(request),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["payment"] });
+    }
+  });
+}
+function useInitiatePayment() {
+  return (0, import_react_query14.useMutation)({
+    mutationFn: (request) => paymentService.initiatePayment(request)
+  });
+}
+function useVerifyTransaction() {
+  return (0, import_react_query14.useMutation)({
+    mutationFn: (reference) => paymentService.verifyTransaction(reference)
+  });
+}
+function useTransactionStatus(transactionId, enabled = false) {
+  return (0, import_react_query14.useQuery)({
+    queryKey: ["transaction", "status", transactionId],
+    queryFn: () => paymentService.getTransactionStatus(transactionId),
+    enabled: isInitialized() && enabled,
+    ...getCacheTier("none"),
+    refetchInterval: 3e3
+    // Poll every 3 seconds
+  });
+}
+function usePollTransactionStatus(reference, enabled = false) {
+  return (0, import_react_query14.useQuery)({
+    queryKey: ["transaction", "poll", reference],
+    queryFn: () => paymentService.verifyTransaction(reference),
+    enabled: isInitialized() && enabled,
+    ...getCacheTier("none"),
+    refetchInterval: 2e3,
+    // Poll every 2 seconds
+    retry: 10
+    // Retry up to 10 times
+  });
+}
+
+// src/hooks/use-cms.ts
+var import_react_query15 = require("@tanstack/react-query");
+function useCmsEntries(modelSlug, params) {
+  const query = (0, import_react_query15.useQuery)({
+    queryKey: ["cms-entries", modelSlug, params],
+    queryFn: () => listCmsEntries(modelSlug, params),
+    enabled: isInitialized() && !!modelSlug
+  });
+  return {
+    entries: query.data?.entries || [],
+    total: query.data?.total || 0,
+    page: query.data?.page || 1,
+    page_size: query.data?.page_size || 50,
+    isLoading: query.isLoading,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useCmsEntry(modelSlug, entryId) {
+  const query = (0, import_react_query15.useQuery)({
+    queryKey: ["cms-entry", modelSlug, entryId],
+    queryFn: () => getCmsEntry(modelSlug, entryId),
+    enabled: isInitialized() && !!modelSlug && !!entryId
+  });
+  return {
+    entry: query.data,
+    isLoading: query.isLoading,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useCreateCmsEntry(modelSlug) {
+  const queryClient = (0, import_react_query15.useQueryClient)();
+  const mutation = (0, import_react_query15.useMutation)({
+    mutationFn: (params) => createCmsEntry(modelSlug, params),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["cms-entries", modelSlug] });
+    }
+  });
+  return {
+    createEntry: mutation.mutate,
+    isLoading: mutation.isPending,
+    error: mutation.error
+  };
+}
+function useUpdateCmsEntry(modelSlug) {
+  const queryClient = (0, import_react_query15.useQueryClient)();
+  const mutation = (0, import_react_query15.useMutation)({
+    mutationFn: ({ entryId, params }) => updateCmsEntry(modelSlug, entryId, params),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["cms-entries", modelSlug] });
+      queryClient.invalidateQueries({ queryKey: ["cms-entry", modelSlug] });
+    }
+  });
+  return {
+    updateEntry: (entryId, params) => mutation.mutate({ entryId, params }),
+    isLoading: mutation.isPending,
+    error: mutation.error
+  };
+}
+function useDeleteCmsEntry(modelSlug) {
+  const queryClient = (0, import_react_query15.useQueryClient)();
+  const mutation = (0, import_react_query15.useMutation)({
+    mutationFn: (entryId) => deleteCmsEntry(modelSlug, entryId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["cms-entries", modelSlug] });
+      queryClient.invalidateQueries({ queryKey: ["cms-entry", modelSlug] });
+    }
+  });
+  return {
+    deleteEntry: mutation.mutate,
+    isLoading: mutation.isPending,
+    error: mutation.error
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthCtx,
+  AuthProvider,
+  CartCtx,
+  CartProvider,
+  InvalidBaseURLError,
+  acceptQuote,
+  addToCart,
+  addToGuestCart,
+  addToWishlist,
+  approveDeliverable,
+  authAxios,
+  bespokeService,
+  bookAppointment,
+  buildDeliveryAddress,
+  buildFullName,
+  cancelAppointment,
+  cancelOrder,
+  checkAvailability,
+  checkInWishlist,
+  clearCart,
+  clearGuestCart,
+  clearGuestSessionId,
+  cmsAxios,
+  collectionKeys,
+  configService,
+  configureHttpClients,
+  consultationService,
+  createCmsEntry,
+  createConsultation,
+  createDedicatedAccount,
+  createOrder,
+  deleteCmsEntry,
+  enrichCompletedOrder,
+  findOrder,
+  findOrderByToken,
+  getAppointment,
+  getAppointments,
+  getAuthUser,
+  getAvailableSlots,
+  getBackendUrl,
+  getBusinessConfig,
+  getCacheTier,
+  getCart,
+  getCheckoutCustomerName,
+  getCmsEntry,
+  getConsultation,
+  getConsultations,
+  getCountries,
+  getCustomerDisplayName,
+  getDeliverables,
+  getErrorMessage,
+  getFeaturedProducts,
+  getGraphQLClient,
+  getGuestCart,
+  getGuestCartCount,
+  getGuestCartProductType,
+  getGuestCartSubtotal,
+  getGuestSessionId,
+  getLatestProducts,
+  getMe,
+  getNewProducts,
+  getOrCreateGuestSessionId,
+  getOrders,
+  getPopularProducts,
+  getRecommendedProducts,
+  getRuntimeConfig,
+  getSellerShippingAddress,
+  getShippingRates,
+  getStates,
+  getStorefrontCollectionBySlug,
+  getStorefrontCollections,
+  getStorefrontProductBySlug,
+  getStorefrontProducts,
+  getSupportedCurrencies,
+  getSupportedCurrenciesList,
+  getSupportedLanguages,
+  getSupportedLanguagesList,
+  getTransactionStatus,
+  getWishlist,
+  googleTranslate,
+  initSdk,
+  initiatePayment,
+  isInitialized,
+  listCmsEntries,
+  logger,
+  loginCustomer,
+  logisticsService,
+  logout,
+  mapAuthUserToCustomer,
+  mergeGuestCart,
+  mergeGuestCartIfPresent,
+  notificationsService,
+  paymentAxios,
+  paymentService,
+  productKeys,
+  publicStoreAxios,
+  refreshToken,
+  registerCustomer,
+  rejectQuote,
+  removeFromCart,
+  removeFromGuestCart,
+  removeFromWishlist,
+  removeProductFromWishlist,
+  requestQuote,
+  requestRevision,
+  resetConfig,
+  resetGraphQLClient,
+  sanitizeBaseUrl,
+  sendContactConfirmation,
+  sendContactEmail,
+  sendMessage,
+  serviceBookingService,
+  setEnvironmentMode,
+  setLoggerEnvironmentMode,
+  silentRefresh,
+  splitFullName,
+  storeManagementAxios,
+  storeTokens,
+  tokenStore,
+  trackOrder,
+  updateCartItem,
+  updateCmsEntry,
+  updateGuestCartItemQuantity,
+  updateProfile,
+  useAcceptQuote,
+  useAddToWishlist,
+  useAppointment,
+  useAppointments,
+  useApproveDeliverable,
+  useAuth,
+  useAuthUser,
+  useAvailableSlots,
+  useBespokeAvailability,
+  useBookAppointment,
+  useCancelAppointment,
+  useCancelOrder,
+  useCart,
+  useCheckInWishlist,
+  useCmsEntries,
+  useCmsEntry,
+  useConsultation,
+  useConsultationStream,
+  useConsultations,
+  useCountries,
+  useCreateCmsEntry,
+  useCreateConsultation,
+  useCreateDVA,
+  useCreateOrder,
+  useCurrencies,
+  useDeleteCmsEntry,
+  useDeliverables,
+  useFeaturedProducts,
+  useFindOrder,
+  useGoogleTranslate,
+  useInitiatePayment,
+  useIsMounted,
+  useLatestProducts,
+  useLogin,
+  useLogout,
+  useNewProducts,
+  useOrder,
+  useOrderStream,
+  useOrderTracking,
+  useOrders,
+  useOrdersList,
+  usePollTransactionStatus,
+  usePopularProducts,
+  useProduct,
+  useRecommendedProducts,
+  useRegister,
+  useRejectQuote,
+  useRemoveFromWishlist,
+  useRemoveProductFromWishlist,
+  useRequestRevision,
+  useSendMessage,
+  useStates,
+  useStorefrontCollection,
+  useStorefrontCollections,
+  useStorefrontProducts,
+  useSupportedLanguages,
+  useTransactionStatus,
+  useUpdateCmsEntry,
+  useUpdateProfile,
+  useVerifyTransaction,
+  useWishlist,
+  useWishlistCount,
+  validateShippingAddress,
+  verifySocialToken,
+  verifyTransaction,
+  wishlistKeys
+});
+//# sourceMappingURL=index.js.map