@kasuvia/sdk 0.0.1 → 0.0.4

package/dist/index.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,45 +15,34 @@ var __copyProps = (to, from, except, desc) => {
   }
   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,
+  STORAGE_KEYS: () => STORAGE_KEYS,
+  SdkProvider: () => SdkProvider,
+  ServiceLocationTypeEnum: () => ServiceLocationTypeEnum,
+  ServiceRecurringIntervalEnum: () => ServiceRecurringIntervalEnum,
+  ServiceTypeEnum: () => ServiceTypeEnum,
   acceptQuote: () => acceptQuote,
   addToCart: () => addToCart,
   addToGuestCart: () => addToGuestCart,
   addToWishlist: () => addToWishlist,
   approveDeliverable: () => approveDeliverable,
-  authAxios: () => authAxios,
   bespokeService: () => bespokeService,
   bookAppointment: () => bookAppointment,
   buildDeliveryAddress: () => buildDeliveryAddress,
-  buildFullName: () => buildFullName,
+  buildFullName: () => buildFullName2,
   cancelAppointment: () => cancelAppointment,
   cancelOrder: () => cancelOrder,
   checkAvailability: () => checkAvailability,
   checkInWishlist: () => checkInWishlist,
   clearCart: () => clearCart,
   clearGuestCart: () => clearGuestCart,
-  clearGuestSessionId: () => clearGuestSessionId,
-  cmsAxios: () => cmsAxios,
-  collectionKeys: () => collectionKeys,
+  clearTokens: () => clearTokens,
   configService: () => configService,
-  configureHttpClients: () => configureHttpClients,
   consultationService: () => consultationService,
   createCmsEntry: () => createCmsEntry,
   createConsultation: () => createConsultation,
@@ -69,7 +56,6 @@ __export(index_exports, {
   getAppointments: () => getAppointments,
   getAuthUser: () => getAuthUser,
   getAvailableSlots: () => getAvailableSlots,
-  getBackendUrl: () => getBackendUrl,
   getBusinessConfig: () => getBusinessConfig,
   getCacheTier: () => getCacheTier,
   getCart: () => getCart,
@@ -77,43 +63,38 @@ __export(index_exports, {
   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,
+  getLowStockProducts: () => getLowStockProducts,
   getMe: () => getMe,
   getNewProducts: () => getNewProducts,
-  getOrCreateGuestSessionId: () => getOrCreateGuestSessionId,
+  getOnSaleProducts: () => getOnSaleProducts,
   getOrders: () => getOrders,
   getPopularProducts: () => getPopularProducts,
   getRecommendedProducts: () => getRecommendedProducts,
-  getRuntimeConfig: () => getRuntimeConfig,
   getSellerShippingAddress: () => getSellerShippingAddress,
   getShippingRates: () => getShippingRates,
-  getStates: () => getStates,
+  getStoredTokens: () => getStoredTokens,
   getStorefrontCollectionBySlug: () => getStorefrontCollectionBySlug,
   getStorefrontCollections: () => getStorefrontCollections,
   getStorefrontProductBySlug: () => getStorefrontProductBySlug,
   getStorefrontProducts: () => getStorefrontProducts,
+  getStorefrontUrl: () => getStorefrontUrl,
   getSupportedCurrencies: () => getSupportedCurrencies,
-  getSupportedCurrenciesList: () => getSupportedCurrenciesList,
   getSupportedLanguages: () => getSupportedLanguages,
-  getSupportedLanguagesList: () => getSupportedLanguagesList,
   getTransactionStatus: () => getTransactionStatus,
   getWishlist: () => getWishlist,
   googleTranslate: () => googleTranslate,
-  initSdk: () => initSdk,
   initiatePayment: () => initiatePayment,
-  isInitialized: () => isInitialized,
   listCmsEntries: () => listCmsEntries,
+  localStore: () => localStore,
   logger: () => logger,
   loginCustomer: () => loginCustomer,
   logisticsService: () => logisticsService,
@@ -122,10 +103,7 @@ __export(index_exports, {
   mergeGuestCart: () => mergeGuestCart,
   mergeGuestCartIfPresent: () => mergeGuestCartIfPresent,
   notificationsService: () => notificationsService,
-  paymentAxios: () => paymentAxios,
   paymentService: () => paymentService,
-  productKeys: () => productKeys,
-  publicStoreAxios: () => publicStoreAxios,
   refreshToken: () => refreshToken,
   registerCustomer: () => registerCustomer,
   rejectQuote: () => rejectQuote,
@@ -135,649 +113,74 @@ __export(index_exports, {
   removeProductFromWishlist: () => removeProductFromWishlist,
   requestQuote: () => requestQuote,
   requestRevision: () => requestRevision,
-  resetConfig: () => resetConfig,
-  resetGraphQLClient: () => resetGraphQLClient,
   sanitizeBaseUrl: () => sanitizeBaseUrl,
   sendContactConfirmation: () => sendContactConfirmation,
   sendContactEmail: () => sendContactEmail,
   sendMessage: () => sendMessage,
   serviceBookingService: () => serviceBookingService,
+  sessionStore: () => sessionStore,
   setEnvironmentMode: () => setEnvironmentMode,
   setLoggerEnvironmentMode: () => setLoggerEnvironmentMode,
   silentRefresh: () => silentRefresh,
-  splitFullName: () => splitFullName,
-  storeManagementAxios: () => storeManagementAxios,
+  splitFullName: () => splitFullName2,
   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,
+  useSdkContext: () => useSdkContext,
+  validateConfirmPassword: () => validateConfirmPassword,
+  validateEmail: () => validateEmail,
+  validateMessage: () => validateMessage,
+  validateName: () => validateName,
+  validatePassword: () => validatePassword,
+  validateRequired: () => validateRequired,
   validateShippingAddress: () => validateShippingAddress,
   verifySocialToken: () => verifySocialToken,
-  verifyTransaction: () => verifyTransaction,
-  wishlistKeys: () => wishlistKeys
+  verifyTransaction: () => verifyTransaction
 });
 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/context/sdk-context.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var SdkContext = (0, import_react.createContext)(null);
+function SdkProvider({ config, accessToken, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SdkContext.Provider, { value: { config, accessToken }, children });
 }
-
-// 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;
+function useSdkContext() {
+  return (0, import_react.useContext)(SdkContext);
 }
 
-// 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"
+// src/constants.ts
+var STORAGE_KEYS = {
+  ACCESS_TOKEN: "kasuvia_access_token",
+  REFRESH_TOKEN: "kasuvia_refresh_token",
+  CHECKOUT_STATE: "kasuvia_checkout_state",
+  ORDERS_LINKED: "kasuvia_orders_linked",
+  STOREFRONT_STATE: "storefront_state_v3"
 };
-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/types/store/index.ts
+var ServiceTypeEnum = /* @__PURE__ */ ((ServiceTypeEnum2) => {
+  ServiceTypeEnum2["APPOINTMENT"] = "appointment";
+  ServiceTypeEnum2["PROJECT"] = "project";
+  ServiceTypeEnum2["RECURRING"] = "recurring";
+  return ServiceTypeEnum2;
+})(ServiceTypeEnum || {});
+var ServiceLocationTypeEnum = /* @__PURE__ */ ((ServiceLocationTypeEnum2) => {
+  ServiceLocationTypeEnum2["REMOTE"] = "remote";
+  ServiceLocationTypeEnum2["PHYSICAL"] = "physical";
+  ServiceLocationTypeEnum2["BOTH"] = "both";
+  return ServiceLocationTypeEnum2;
+})(ServiceLocationTypeEnum || {});
+var ServiceRecurringIntervalEnum = /* @__PURE__ */ ((ServiceRecurringIntervalEnum2) => {
+  ServiceRecurringIntervalEnum2["WEEKLY"] = "weekly";
+  ServiceRecurringIntervalEnum2["MONTHLY"] = "monthly";
+  ServiceRecurringIntervalEnum2["YEARLY"] = "yearly";
+  return ServiceRecurringIntervalEnum2;
+})(ServiceRecurringIntervalEnum || {});
 
 // src/services/cart.service.ts
 function parseItems(items) {
@@ -786,21 +189,25 @@ function parseItems(items) {
     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 [];
+async function getGuestCart(config, guestSessionId) {
+  if (!guestSessionId) return [];
   try {
-    const { data } = await storeManagementAxios.get("cart/", {
-      headers: { "X-Guest-Session": sid }
+    const response = await fetch(`${config.backendUrls.store}/cart/`, {
+      headers: {
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId,
+        "X-Guest-Session": guestSessionId
+      }
     });
+    if (!response.ok) return [];
+    const data = await response.json();
     return parseItems(data.items || []);
   } catch {
     return [];
   }
 }
-async function addToGuestCart(item) {
-  const sid = getOrCreateGuestSessionId();
-  if (!sid) return [];
+async function addToGuestCart(config, guestSessionId, item) {
+  if (!guestSessionId) return [];
   const payload = {
     product_id: item.product_id,
     product_slug: item.product_slug,
@@ -813,66 +220,132 @@ async function addToGuestCart(item) {
     custom_measurements: item.custom_measurements,
     is_bespoke: item.is_bespoke
   };
-  const { data } = await storeManagementAxios.post("cart/", payload, {
-    headers: { "X-Guest-Session": sid }
+  const response = await fetch(`${config.backendUrls.store}/cart/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+      "X-Guest-Session": guestSessionId
+    },
+    body: JSON.stringify(payload)
   });
+  if (!response.ok) return [];
+  const data = await response.json();
   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 } }
-  );
+async function updateGuestCartItemQuantity(config, guestSessionId, itemId, quantity) {
+  if (!guestSessionId) return [];
+  const response = await fetch(`${config.backendUrls.store}/cart/${itemId}`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+      "X-Guest-Session": guestSessionId
+    },
+    body: JSON.stringify({ quantity })
+  });
+  if (!response.ok) return [];
+  const data = await response.json();
   return parseItems(data.items || []);
 }
-async function removeFromGuestCart(itemId) {
-  const sid = getGuestSessionId();
-  if (!sid) return [];
-  await storeManagementAxios.delete(`cart/${itemId}`, {
-    headers: { "X-Guest-Session": sid }
+async function removeFromGuestCart(config, guestSessionId, itemId) {
+  if (!guestSessionId) return [];
+  await fetch(`${config.backendUrls.store}/cart/${itemId}`, {
+    method: "DELETE",
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+      "X-Guest-Session": guestSessionId
+    }
   });
-  return getGuestCart();
+  return getGuestCart(config, guestSessionId);
 }
-async function clearGuestCart() {
-  const sid = getGuestSessionId();
-  if (!sid) return;
-  await storeManagementAxios.delete("cart/clear", {
-    headers: { "X-Guest-Session": sid }
+async function clearGuestCart(config, guestSessionId) {
+  if (!guestSessionId) return;
+  await fetch(`${config.backendUrls.store}/cart/clear`, {
+    method: "DELETE",
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+      "X-Guest-Session": guestSessionId
+    }
   });
 }
-async function getCart() {
-  const { data } = await storeManagementAxios.get("cart/");
+async function getCart(config, accessToken) {
+  if (!accessToken) {
+    return { id: "", items: [], subtotal: 0, total: 0, product_type: "physical" };
+  }
+  const response = await fetch(`${config.backendUrls.store}/cart/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to fetch cart");
+  const data = await response.json();
   const parsedItems = parseItems(data.items || []);
   return { ...data, items: parsedItems };
 }
-async function addToCart(item) {
-  const { data } = await storeManagementAxios.post("cart/", item);
+async function addToCart(config, accessToken, item) {
+  const response = await fetch(`${config.backendUrls.store}/cart/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(item)
+  });
+  if (!response.ok) throw new Error("Failed to add to cart");
+  const data = await response.json();
   const parsedItems = parseItems(data.items || []);
   return { ...data, items: parsedItems };
 }
-async function updateCartItem(itemId, quantity) {
-  const { data } = await storeManagementAxios.patch(
-    `cart/${itemId}`,
-    { quantity }
-  );
+async function updateCartItem(config, accessToken, itemId, quantity) {
+  const response = await fetch(`${config.backendUrls.store}/cart/${itemId}`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({ quantity })
+  });
+  if (!response.ok) throw new Error("Failed to update cart item");
+  const data = await response.json();
   const parsedItems = parseItems(data.items || []);
   return { ...data, items: parsedItems };
 }
-async function removeFromCart(itemId) {
-  await storeManagementAxios.delete(`cart/${itemId}`);
-  return getCart();
+async function removeFromCart(config, accessToken, itemId) {
+  await fetch(`${config.backendUrls.store}/cart/${itemId}`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  return getCart(config, accessToken);
 }
-async function clearCart() {
-  await storeManagementAxios.delete("cart/clear");
+async function clearCart(config, accessToken) {
+  await fetch(`${config.backendUrls.store}/cart/clear`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
 }
-async function mergeGuestCart() {
-  const sid = getGuestSessionId();
-  const guestItems = sid ? await getGuestCart() : [];
+async function mergeGuestCart(config, accessToken, guestSessionId) {
+  const guestItems = guestSessionId ? await getGuestCart(config, guestSessionId) : [];
   if (guestItems.length === 0) {
-    return getCart();
+    return getCart(config, accessToken);
   }
   const payloadItems = guestItems.map((item) => ({
     product_id: item.product_id,
@@ -886,19 +359,29 @@ async function mergeGuestCart() {
     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();
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${accessToken}`,
+    "X-Storefront-Key": config.storefrontApiKey,
+    "X-Business-ID": config.businessId
+  };
+  if (guestSessionId) {
+    headers["X-Guest-Session"] = guestSessionId;
+  }
+  const response = await fetch(`${config.backendUrls.store}/cart/merge`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ items: payloadItems })
+  });
+  if (!response.ok) throw new Error("Failed to merge guest cart");
+  const data = await response.json();
   return { ...data, items: parseItems(data.items || []) };
 }
-async function mergeGuestCartIfPresent() {
+async function mergeGuestCartIfPresent(config, accessToken, guestSessionId) {
   try {
-    const guestItems = await getGuestCart();
+    const guestItems = await getGuestCart(config, guestSessionId);
     if (guestItems.length === 0) return;
-    await mergeGuestCart();
+    await mergeGuestCart(config, accessToken, guestSessionId);
   } catch (error) {
     console.warn("[Cart] Failed to merge guest cart:", error);
   }
@@ -972,88 +455,173 @@ function normaliseStorefrontOrder(raw) {
     guestName: raw.guest_name
   };
 }
-async function createOrder(payload) {
-  const { data } = await storeManagementAxios.post("orders/storefront", payload);
+async function createOrder(config, accessToken, payload) {
+  const response = await fetch(`${config.backendUrls.store}/orders/storefront`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to create order");
+  const data = await response.json();
   return normaliseStorefrontOrder(data);
 }
-async function findOrder(params) {
-  const { data } = await publicStoreAxios.get("orders/find/", { params });
+async function findOrder(config, params) {
+  const queryParams = new URLSearchParams();
+  if (params.email) queryParams.set("email", params.email);
+  if (params.order_id) queryParams.set("order_id", params.order_id);
+  if (params.guest_token) queryParams.set("guest_token", params.guest_token);
+  const response = await fetch(`${config.backendUrls.store}/orders/find/?${queryParams.toString()}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to find order");
+  const data = await response.json();
   return normaliseStorefrontOrder(data);
 }
-async function findOrderByToken(token) {
-  const { data } = await publicStoreAxios.get("orders/find/", {
-    params: { guest_token: token }
+async function findOrderByToken(config, token) {
+  const response = await fetch(`${config.backendUrls.store}/orders/find/?guest_token=${token}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
   });
+  if (!response.ok) throw new Error("Failed to find order by token");
+  const data = await response.json();
   return normaliseStorefrontOrder(data);
 }
-async function getOrders(params) {
-  const { data } = await storeManagementAxios.get("orders/", { params });
+async function getOrders(config, accessToken, params) {
+  const queryParams = new URLSearchParams();
+  if (params?.email) queryParams.set("email", params.email);
+  if (params?.page) queryParams.set("page", params.page.toString());
+  if (params?.page_size) queryParams.set("page_size", params.page_size.toString());
+  const response = await fetch(`${config.backendUrls.store}/orders/?${queryParams.toString()}`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get orders");
+  const data = await response.json();
   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 });
+async function cancelOrder(config, accessToken, orderId, reason) {
+  const response = await fetch(`${config.backendUrls.store}/orders/${orderId}/cancel/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({ reason })
+  });
+  if (!response.ok) throw new Error("Failed to cancel order");
+  const data = await response.json();
   return normaliseStorefrontOrder(data);
 }
-async function trackOrder(orderId, token) {
-  const { data } = await publicStoreAxios.get(`orders/track/${orderId}`, {
-    params: token ? { token } : void 0
+async function trackOrder(config, orderId, token) {
+  const queryParams = token ? `?token=${token}` : "";
+  const response = await fetch(`${config.backendUrls.store}/orders/track/${orderId}${queryParams}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
   });
+  if (!response.ok) throw new Error("Failed to track order");
+  const data = await response.json();
   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
+async function loginCustomer(config, payload) {
+  const response = await fetch(`${config.backendUrls.auth}/auth/login/customer/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      ...payload,
+      tenant_id: config.businessId
+    })
   });
-  tokenStore.setAccessToken(data.access);
-  tokenStore.setRefreshToken(data.refresh);
-  resetGraphQLClient();
-  await mergeGuestCartIfPresent();
+  if (!response.ok) {
+    throw new Error("Login failed");
+  }
+  const data = await response.json();
   return data;
 }
-async function registerCustomer(payload) {
-  const config = getRuntimeConfig();
-  const { data } = await authAxios.post("/auth/register/customer/", {
-    ...payload,
-    tenant_id: config.businessId
+async function registerCustomer(config, payload) {
+  const response = await fetch(`${config.backendUrls.auth}/auth/register/customer/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      ...payload,
+      tenant_id: config.businessId
+    })
   });
-  tokenStore.setAccessToken(data.access);
-  tokenStore.setRefreshToken(data.refresh);
-  resetGraphQLClient();
-  await mergeGuestCartIfPresent();
+  if (!response.ok) {
+    throw new Error("Registration failed");
+  }
+  const data = await response.json();
   return data;
 }
-async function refreshToken2(refresh) {
-  const { data } = await refreshAxios2.post("/auth/token/refresh/", { refresh });
+async function refreshToken(config, refresh) {
+  const response = await fetch(`${config.backendUrls.auth}/auth/token/refresh/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ refresh })
+  });
+  if (!response.ok) {
+    throw new Error("Token refresh failed");
+  }
+  const data = await response.json();
   return data;
 }
-async function logout() {
-  const refresh = tokenStore.getRefreshToken();
+async function logout(config, refresh) {
   const payload = refresh ? { refresh } : {};
   try {
-    await authAxios.post("/auth/logout/", payload);
+    await fetch(`${config.backendUrls.auth}/auth/logout/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
   } catch {
-  } finally {
-    tokenStore.clearAll();
-    resetGraphQLClient();
   }
 }
-async function verifySocialToken(provider, token) {
-  const config = getRuntimeConfig();
-  const { data } = await authAxios.post(
-    `/auth/social/verify/${provider}/`,
-    {
+async function verifySocialToken(config, provider, token) {
+  const response = await fetch(`${config.backendUrls.auth}/auth/social/verify/${provider}/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
       id_token: token,
       storefront_key: config.storefrontApiKey
-    }
-  );
-  tokenStore.setAccessToken(data.access);
-  tokenStore.setRefreshToken(data.refresh);
-  resetGraphQLClient();
+    })
+  });
+  if (!response.ok) {
+    throw new Error("Social token verification failed");
+  }
+  const data = await response.json();
   return data;
 }
 function parseJwtPayload(token) {
@@ -1087,7 +655,7 @@ function mapAuthUserToCustomer(data, provider) {
     firstname,
     lastname,
     phone,
-    full_name: buildFullName2(firstname, lastname),
+    full_name: buildFullName(firstname, lastname),
     avatar: resolveAvatar(data.profile?.profile_picture),
     provider: provider ?? resolveProvider(data)
   };
@@ -1095,7 +663,7 @@ function mapAuthUserToCustomer(data, provider) {
 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);
+  const { firstname: splitFirst, lastname: splitLast } = splitFullName(jwtFullName);
   return {
     id: String(claims.user_id ?? claims.sub ?? ""),
     email: String(claims.email ?? ""),
@@ -1107,86 +675,91 @@ function buildCustomerFromClaims(claims) {
     provider
   };
 }
-async function getMe() {
-  const { data } = await authAxios.get("/auth/profile/");
+async function getMe(config, accessToken) {
+  if (!config || !accessToken) {
+    const response2 = await fetch("/api/auth/me", { credentials: "include" });
+    if (!response2.ok) throw new Error("Failed to fetch profile");
+    const data2 = await response2.json();
+    return data2.user;
+  }
+  const response = await fetch(`${config.backendUrls.auth}/auth/profile/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch profile");
+  }
+  const data = await response.json();
   return mapAuthUserToCustomer(data);
 }
-async function getAuthUser() {
-  const { data } = await authAxios.get("/auth/profile/");
+async function getAuthUser(config, accessToken) {
+  if (!config || !accessToken) {
+    const response2 = await fetch("/api/auth/me", { credentials: "include" });
+    if (!response2.ok) throw new Error("Failed to fetch auth user");
+    const data2 = await response2.json();
+    return data2.user;
+  }
+  const response = await fetch(`${config.backendUrls.auth}/auth/profile/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch auth user");
+  }
+  const data = await response.json();
   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));
-    }
+async function updateProfile(configOrPayload, accessTokenOrPayload, payloadParam) {
+  const isArg1Config = typeof configOrPayload === "object" && configOrPayload !== null && "businessId" in configOrPayload;
+  if (!isArg1Config) {
+    const payload2 = configOrPayload;
+    const response2 = await fetch("/api/auth/profile", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(payload2)
+    });
+    if (!response2.ok) throw new Error("Failed to update profile");
+    return response2.json();
   }
-  throw lastError;
+  const config = configOrPayload;
+  const accessToken = accessTokenOrPayload;
+  const payload = payloadParam;
+  const response = await fetch(`${config.backendUrls.auth}/auth/profile/`, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to update profile");
+  }
+  const data = await response.json();
+  return mapAuthUserToCustomer(data);
 }
-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();
+async function silentRefresh(config, refresh) {
+  try {
+    const data = await refreshToken(config, refresh);
+    if (!data.access || !data.refresh) {
       return null;
-    } finally {
-      refreshPromise = null;
     }
-  })();
-  return refreshPromise;
-}
-function storeTokens(access, refresh, remember = true) {
-  tokenStore.setAccessToken(access);
-  tokenStore.setRefreshToken(refresh, remember);
+    const claims = parseJwtPayload(data.access);
+    const user = buildCustomerFromClaims(claims);
+    const provider = user.provider;
+    return { user, provider, newAccessToken: data.access, newRefreshToken: data.refresh };
+  } catch {
+    return null;
+  }
 }
-function buildFullName2(firstname, lastname) {
+function buildFullName(firstname, lastname) {
   if (firstname && lastname) return `${firstname} ${lastname}`;
   return firstname || lastname || "";
 }
-function splitFullName2(fullName) {
+function splitFullName(fullName) {
   if (!fullName) return { firstname: "", lastname: "" };
   const parts = fullName.trim().split(/\s+/);
   if (parts.length === 1) {
@@ -1197,8 +770,39 @@ function splitFullName2(fullName) {
     lastname: parts.slice(1).join(" ")
   };
 }
+function storeTokens(accessToken, refreshToken2) {
+  if (typeof window !== "undefined") {
+    localStorage.setItem(STORAGE_KEYS.ACCESS_TOKEN, accessToken);
+    localStorage.setItem(STORAGE_KEYS.REFRESH_TOKEN, refreshToken2);
+  }
+}
+function clearTokens() {
+  if (typeof window !== "undefined") {
+    localStorage.removeItem(STORAGE_KEYS.ACCESS_TOKEN);
+    localStorage.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+  }
+}
+function getStoredTokens() {
+  if (typeof window === "undefined") {
+    return { accessToken: null, refreshToken: null };
+  }
+  return {
+    accessToken: localStorage.getItem(STORAGE_KEYS.ACCESS_TOKEN),
+    refreshToken: localStorage.getItem(STORAGE_KEYS.REFRESH_TOKEN)
+  };
+}
 
 // src/services/product.service.ts
+var import_graphql_request = require("graphql-request");
+function createGraphQLClient(config) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    "X-Storefront-Key": config.storefrontApiKey,
+    "X-Business-ID": config.businessId
+  };
+  return new import_graphql_request.GraphQLClient(`${config.backendUrls.store}/graphql`, { headers });
+}
 var GET_STOREFRONT_PRODUCTS = `
   query GetStorefrontProducts($page: Int!, $pageSize: Int!, $collectionSlug: String, $search: String) {
     storefront_products(page: $page, pageSize: $pageSize, collectionSlug: $collectionSlug, search: $search) {
@@ -1215,7 +819,7 @@ var GET_STOREFRONT_PRODUCTS = `
         is_bespoke
         base_price
         currency
-        images { url alt id }
+        images
         tags
         custom_fields { label unit required }
         is_published
@@ -1238,7 +842,7 @@ var GET_STOREFRONT_PRODUCTS = `
           sku
           attributes
           price
-          images { url alt id }
+          images
           weight_kg
           is_active
           inventory {
@@ -1265,7 +869,7 @@ var GET_STOREFRONT_PRODUCTS = `
           name
           slug
           description
-          image { url alt id }
+          image
           collection_type
           rules
           status
@@ -1296,7 +900,7 @@ var GET_STOREFRONT_PRODUCT_BY_SLUG = `
       is_bespoke
       base_price
       currency
-      images { url alt id }
+      images
       tags
       custom_fields { label unit required }
       is_published
@@ -1319,7 +923,7 @@ var GET_STOREFRONT_PRODUCT_BY_SLUG = `
         sku
         attributes
         price
-        images { url alt id }
+        images
         weight_kg
         is_active
         inventory {
@@ -1346,7 +950,7 @@ var GET_STOREFRONT_PRODUCT_BY_SLUG = `
         name
         slug
         description
-        image { url alt id }
+        image
         collection_type
         rules
         status
@@ -1373,7 +977,7 @@ var GET_STOREFRONT_LATEST = `
         is_bespoke
         base_price
         currency
-        images { url alt id }
+        images
         tags
         custom_fields { label unit required }
         is_published
@@ -1396,7 +1000,7 @@ var GET_STOREFRONT_LATEST = `
           sku
           attributes
           price
-          images { url alt id }
+          images
           weight_kg
           is_active
           inventory {
@@ -1423,7 +1027,7 @@ var GET_STOREFRONT_LATEST = `
           name
           slug
           description
-          image { url alt id }
+          image
           collection_type
           rules
           status
@@ -1455,7 +1059,7 @@ var GET_STOREFRONT_POPULAR = `
         is_bespoke
         base_price
         currency
-        images { url alt id }
+        images
         tags
         custom_fields { label unit required }
         is_published
@@ -1478,7 +1082,7 @@ var GET_STOREFRONT_POPULAR = `
           sku
           attributes
           price
-          images { url alt id }
+          images
           weight_kg
           is_active
           inventory {
@@ -1505,7 +1109,7 @@ var GET_STOREFRONT_POPULAR = `
           name
           slug
           description
-          image { url alt id }
+          image
           collection_type
           rules
           status
@@ -1537,7 +1141,7 @@ var GET_STOREFRONT_FEATURED = `
         is_bespoke
         base_price
         currency
-        images { url alt id }
+        images
         tags
         custom_fields { label unit required }
         is_published
@@ -1560,7 +1164,7 @@ var GET_STOREFRONT_FEATURED = `
           sku
           attributes
           price
-          images { url alt id }
+          images
           weight_kg
           is_active
           inventory {
@@ -1587,7 +1191,7 @@ var GET_STOREFRONT_FEATURED = `
           name
           slug
           description
-          image { url alt id }
+          image
           collection_type
           rules
           status
@@ -1619,7 +1223,180 @@ var GET_STOREFRONT_NEW = `
         is_bespoke
         base_price
         currency
-        images { url alt id }
+        sale_price
+        sale_start
+        sale_end
+        images
+        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
+          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
+          collection_type
+          rules
+          status
+          sort_order
+          created_at
+          updated_at
+        }
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var GET_STOREFRONT_ON_SALE = `
+  query GetStorefrontOnSale($page: Int!, $pageSize: Int!) {
+    storefront_on_sale(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        brand
+        product_type
+        requires_shipping
+        is_consumable
+        is_bespoke
+        base_price
+        currency
+        sale_price
+        sale_start
+        sale_end
+        images
+        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
+          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
+          collection_type
+          rules
+          status
+          sort_order
+          created_at
+          updated_at
+        }
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var GET_STOREFRONT_LOW_STOCK = `
+  query GetStorefrontLowStock($page: Int!, $pageSize: Int!) {
+    storefront_low_stock(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        brand
+        product_type
+        requires_shipping
+        is_consumable
+        is_bespoke
+        base_price
+        currency
+        sale_price
+        sale_start
+        sale_end
+        images
         tags
         custom_fields { label unit required }
         is_published
@@ -1642,7 +1419,7 @@ var GET_STOREFRONT_NEW = `
           sku
           attributes
           price
-          images { url alt id }
+          images
           weight_kg
           is_active
           inventory {
@@ -1669,7 +1446,7 @@ var GET_STOREFRONT_NEW = `
           name
           slug
           description
-          image { url alt id }
+          image
           collection_type
           rules
           status
@@ -1701,7 +1478,7 @@ var GET_STOREFRONT_RECOMMENDED = `
         is_bespoke
         base_price
         currency
-        images { url alt id }
+        images
         tags
         custom_fields { label unit required }
         is_published
@@ -1724,7 +1501,7 @@ var GET_STOREFRONT_RECOMMENDED = `
           sku
           attributes
           price
-          images { url alt id }
+          images
           weight_kg
           is_active
           inventory {
@@ -1751,7 +1528,7 @@ var GET_STOREFRONT_RECOMMENDED = `
           name
           slug
           description
-          image { url alt id }
+          image
           collection_type
           rules
           status
@@ -1767,8 +1544,8 @@ var GET_STOREFRONT_RECOMMENDED = `
     }
   }
 `;
-async function getStorefrontProducts(params) {
-  const client = getGraphQLClient();
+async function getStorefrontProducts(config, params) {
+  const client = createGraphQLClient(config);
   const variables = {
     page: params?.page || 1,
     pageSize: params?.pageSize || 20,
@@ -1778,13 +1555,13 @@ async function getStorefrontProducts(params) {
   const data = await client.request(GET_STOREFRONT_PRODUCTS, variables);
   return data.storefront_products;
 }
-async function getStorefrontProductBySlug(slug) {
-  const client = getGraphQLClient();
+async function getStorefrontProductBySlug(config, slug) {
+  const client = createGraphQLClient(config);
   const data = await client.request(GET_STOREFRONT_PRODUCT_BY_SLUG, { slug });
   return data.storefront_product_by_slug;
 }
-async function getLatestProducts(params) {
-  const client = getGraphQLClient();
+async function getLatestProducts(config, params) {
+  const client = createGraphQLClient(config);
   const variables = {
     page: params?.page || 1,
     pageSize: params?.pageSize || 4
@@ -1792,8 +1569,8 @@ async function getLatestProducts(params) {
   const data = await client.request(GET_STOREFRONT_LATEST, variables);
   return data.storefront_latest;
 }
-async function getPopularProducts(params) {
-  const client = getGraphQLClient();
+async function getPopularProducts(config, params) {
+  const client = createGraphQLClient(config);
   const variables = {
     page: params?.page || 1,
     pageSize: params?.pageSize || 4
@@ -1801,8 +1578,8 @@ async function getPopularProducts(params) {
   const data = await client.request(GET_STOREFRONT_POPULAR, variables);
   return data.storefront_popular;
 }
-async function getFeaturedProducts(params) {
-  const client = getGraphQLClient();
+async function getFeaturedProducts(config, params) {
+  const client = createGraphQLClient(config);
   const variables = {
     page: params?.page || 1,
     pageSize: params?.pageSize || 4
@@ -1810,8 +1587,8 @@ async function getFeaturedProducts(params) {
   const data = await client.request(GET_STOREFRONT_FEATURED, variables);
   return data.storefront_featured;
 }
-async function getNewProducts(params) {
-  const client = getGraphQLClient();
+async function getNewProducts(config, params) {
+  const client = createGraphQLClient(config);
   const variables = {
     page: params?.page || 1,
     pageSize: params?.pageSize || 4
@@ -1819,8 +1596,26 @@ async function getNewProducts(params) {
   const data = await client.request(GET_STOREFRONT_NEW, variables);
   return data.storefront_new;
 }
-async function getRecommendedProducts(params) {
-  const client = getGraphQLClient();
+async function getOnSaleProducts(config, params) {
+  const client = createGraphQLClient(config);
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 4
+  };
+  const data = await client.request(GET_STOREFRONT_ON_SALE, variables);
+  return data.storefront_on_sale;
+}
+async function getLowStockProducts(config, params) {
+  const client = createGraphQLClient(config);
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 4
+  };
+  const data = await client.request(GET_STOREFRONT_LOW_STOCK, variables);
+  return data.storefront_low_stock;
+}
+async function getRecommendedProducts(config, params) {
+  const client = createGraphQLClient(config);
   const variables = {
     page: params?.page || 1,
     pageSize: params?.pageSize || 4,
@@ -1831,6 +1626,7 @@ async function getRecommendedProducts(params) {
 }
 
 // src/services/collection.service.ts
+var import_graphql_request2 = require("graphql-request");
 var GET_STOREFRONT_COLLECTIONS = `
   query GetStorefrontCollections($page: Int!, $pageSize: Int!) {
     storefront_collections(page: $page, pageSize: $pageSize) {
@@ -1840,7 +1636,7 @@ var GET_STOREFRONT_COLLECTIONS = `
         name
         slug
         description
-        image { url alt id }
+        image 
         collection_type
         rules
         status
@@ -1863,7 +1659,7 @@ var GET_STOREFRONT_COLLECTION_BY_SLUG = `
       name
       slug
       description
-      image { url alt id }
+      image 
       collection_type
       rules
       status
@@ -1873,8 +1669,17 @@ var GET_STOREFRONT_COLLECTION_BY_SLUG = `
     }
   }
 `;
-async function getStorefrontCollections(params) {
-  const client = getGraphQLClient();
+function createGraphQLClient2(config) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    "X-Storefront-Key": config.storefrontApiKey,
+    "X-Business-ID": config.businessId
+  };
+  return new import_graphql_request2.GraphQLClient(`${config.backendUrls.store}/graphql`, { headers });
+}
+async function getStorefrontCollections(config, params) {
+  const client = createGraphQLClient2(config);
   const variables = {
     page: params?.page || 1,
     pageSize: params?.pageSize || 20
@@ -1882,16 +1687,17 @@ async function getStorefrontCollections(params) {
   const data = await client.request(GET_STOREFRONT_COLLECTIONS, variables);
   return data.storefront_collections;
 }
-async function getStorefrontCollectionBySlug(slug) {
-  const client = getGraphQLClient();
+async function getStorefrontCollectionBySlug(config, slug) {
+  const client = createGraphQLClient2(config);
   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) {
+var import_graphql_request3 = require("graphql-request");
+var GET_STOREFRONT_WISHLIST = `
+  query GetStorefrontWishlist($page: Int!, $pageSize: Int!) {
+    storefront_wishlist(page: $page, pageSize: $pageSize) {
       items {
         id
         product_id
@@ -1900,6 +1706,7 @@ var GET_WISHLIST = `
         product_name
         product_slug
         product_price
+        currency
         product_image
       }
       total
@@ -1909,79 +1716,136 @@ var GET_WISHLIST = `
     }
   }
 `;
-var CHECK_IN_WISHLIST = `
-  query CheckInWishlist($productId: String!) {
-    check_in_wishlist(productId: $productId) {
+var CHECK_IN_STOREFRONT_WISHLIST = `
+  query CheckInStorefrontWishlist($productId: String!) {
+    check_in_storefront_wishlist(productId: $productId) {
       in_wishlist
     }
   }
 `;
-async function getWishlist(params) {
-  const client = getGraphQLClient();
+function createGraphQLClient3(config, accessToken) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    "X-Storefront-Key": config.storefrontApiKey,
+    "X-Business-ID": config.businessId
+  };
+  if (accessToken) {
+    headers["Authorization"] = `Bearer ${accessToken}`;
+  }
+  return new import_graphql_request3.GraphQLClient(`${config.backendUrls.store}/graphql`, { headers });
+}
+async function getWishlist(config, accessToken, params) {
+  const client = createGraphQLClient3(config, accessToken);
   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
+  const data = await client.request(GET_STOREFRONT_WISHLIST, variables);
+  return data.storefront_wishlist;
+}
+async function checkInWishlist(config, accessToken, productId) {
+  const client = createGraphQLClient3(config, accessToken);
+  const data = await client.request(CHECK_IN_STOREFRONT_WISHLIST, { productId });
+  return data.check_in_storefront_wishlist;
+}
+async function addToWishlist(config, accessToken, productId, notes) {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      product_id: productId,
+      notes: notes || void 0
+    })
   });
-  return data;
+  if (!response.ok) throw new Error("Failed to add to wishlist");
+  return response.json();
 }
-async function removeFromWishlist(itemId) {
-  await storeManagementAxios.delete(`wishlist/${itemId}`);
+async function removeFromWishlist(config, accessToken, itemId) {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/${itemId}`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to remove from wishlist");
 }
-async function removeProductFromWishlist(productId) {
-  await storeManagementAxios.delete(`wishlist/product/${productId}`);
+async function removeProductFromWishlist(config, accessToken, productId) {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/product/${productId}`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to remove product from wishlist");
 }
 
 // src/services/payment.service.ts
-async function createDedicatedAccount(request) {
+async function createDedicatedAccount(config, accessToken, 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",
-    {
+  const response = await fetch(`${config.backendUrls.payment}/payments/dedicated-account`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
       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
-    }
-  );
+    })
+  });
+  if (!response.ok) throw new Error("Failed to create dedicated account");
+  const data = await response.json();
   return data;
 }
-async function initiatePayment(request) {
+async function initiatePayment(config, accessToken, 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 ?? "",
+  const response = await fetch(`${config.backendUrls.payment}/payments/storefront/initiate`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      amount: request.amount,
+      currency: request.currency,
       order_id: validOrderId,
-      ...request.metadata ?? {}
-    },
-    idempotency_key: request.idempotency_key
+      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
+    })
   });
+  if (!response.ok) throw new Error("Failed to initiate payment");
+  const data = await response.json();
   return {
     id: data.id,
     gateway_ref: data.gateway_ref,
@@ -1990,20 +1854,53 @@ async function initiatePayment(request) {
     checkout_url: data.metadata_json?.checkout_url ?? ""
   };
 }
-async function requestQuote(amount) {
-  const { data } = await paymentAxios.post("payments/quote", { amount });
+async function requestQuote(config, amount) {
+  const response = await fetch(`${config.backendUrls.payment}/payments/quote`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({ amount })
+  });
+  if (!response.ok) throw new Error("Failed to request quote");
+  const data = await response.json();
   return data;
 }
-async function verifyTransaction(reference) {
-  const { data } = await paymentAxios.post(
-    `payments/verify/${reference}`
-  );
+async function verifyTransaction(configOrReference, reference) {
+  if (typeof configOrReference === "string") {
+    const ref2 = configOrReference;
+    const response2 = await fetch(`/api/payments/verify/${ref2}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response2.ok) throw new Error("Failed to verify transaction");
+    return response2.json();
+  }
+  const config = configOrReference;
+  const ref = reference || "";
+  const response = await fetch(`${config.backendUrls.payment}/payments/verify/${ref}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to verify transaction");
+  const data = await response.json();
   return data;
 }
-async function getTransactionStatus(transactionId) {
-  const { data } = await paymentAxios.get(
-    `payments/transactions/${transactionId}`
-  );
+async function getTransactionStatus(config, transactionId) {
+  const response = await fetch(`${config.backendUrls.payment}/payments/transactions/${transactionId}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get transaction status");
+  const data = await response.json();
   return data;
 }
 var paymentService = {
@@ -2015,28 +1912,81 @@ var paymentService = {
 };
 
 // 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 createConsultation(config, accessToken, payload) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to create consultation");
+  return response.json();
 }
-async function getConsultation(id) {
-  const { data } = await storeManagementAxios.get(`social/consultations/${id}`);
-  return data;
+async function getConsultations(config, accessToken) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get consultations");
+  return response.json();
 }
-async function sendMessage(id, payload) {
-  await storeManagementAxios.post(`social/consultations/${id}/messages`, payload);
+async function getConsultation(config, accessToken, id) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get consultation");
+  return response.json();
 }
-async function acceptQuote(id, payload) {
-  const { data } = await storeManagementAxios.post(`social/consultations/${id}/accept-quote`, payload);
-  return data;
+async function sendMessage(config, accessToken, id, payload) {
+  await fetch(`${config.backendUrls.store}/social/consultations/${id}/messages`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
 }
-async function rejectQuote(id, reason) {
-  const { data } = await storeManagementAxios.post(`social/consultations/${id}/reject-quote`, { reason });
-  return data;
+async function acceptQuote(config, accessToken, id, payload) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}/accept-quote`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to accept quote");
+  return response.json();
+}
+async function rejectQuote(config, accessToken, id, reason) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}/reject-quote`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({ reason })
+  });
+  if (!response.ok) throw new Error("Failed to reject quote");
+  return response.json();
 }
 var consultationService = {
   createConsultation,
@@ -2048,20 +1998,41 @@ var consultationService = {
 };
 
 // src/services/logistics.service.ts
-async function getShippingRates(payload) {
-  const { data } = await storeManagementAxios.post(
-    "logistics/shipping/rates",
-    payload
-  );
-  return data;
+async function getShippingRates(config, payload) {
+  const response = await fetch(`${config.backendUrls.store}/logistics/shipping/rates`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to get shipping rates");
+  return response.json();
 }
-async function getSellerShippingAddress() {
-  const { data } = await storeManagementAxios.get("logistics/shipping-address");
-  return data;
+async function getSellerShippingAddress(config) {
+  const response = await fetch(`${config.backendUrls.store}/logistics/shipping-address`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get seller shipping address");
+  return response.json();
 }
-async function validateShippingAddress(payload) {
-  const { data } = await storeManagementAxios.post("logistics/shipping-address/validate", payload);
-  return data;
+async function validateShippingAddress(config, payload) {
+  const response = await fetch(`${config.backendUrls.store}/logistics/shipping-address/validate`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to validate shipping address");
+  return response.json();
 }
 var logisticsService = {
   getShippingRates,
@@ -2070,54 +2041,124 @@ var logisticsService = {
 };
 
 // src/services/bespoke.service.ts
-async function checkAvailability(product_id) {
-  const { data } = await storeManagementAxios.get(`bespoke/availability/${product_id}`);
-  return data;
+async function checkAvailability(config, product_id) {
+  const response = await fetch(`${config.backendUrls.store}/bespoke/availability/${product_id}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to check bespoke availability");
+  return response.json();
 }
 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 } }
+async function getAvailableSlots(config, product_id, date_from, date_to) {
+  const response = await fetch(
+    `${config.backendUrls.store}/service/available-slots/${product_id}?date_from=${date_from}&date_to=${date_to}`,
+    {
+      headers: {
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      }
+    }
   );
-  return data;
-}
-async function bookAppointment(payload) {
-  const { data } = await storeManagementAxios.post("service/appointments/", payload);
-  return data;
+  if (!response.ok) throw new Error("Failed to get available slots");
+  return response.json();
+}
+async function bookAppointment(config, accessToken, payload) {
+  const response = await fetch(`${config.backendUrls.store}/service/appointments/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to book appointment");
+  return response.json();
 }
-async function getAppointments() {
-  const { data } = await storeManagementAxios.get("service/bookings/my");
-  return data;
+async function getAppointments(config, accessToken) {
+  const response = await fetch(`${config.backendUrls.store}/service/bookings/my`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get appointments");
+  return response.json();
 }
-async function getAppointment(id) {
-  const { data } = await storeManagementAxios.get(`service/bookings/${id}`);
-  return data;
+async function getAppointment(config, accessToken, id) {
+  const response = await fetch(`${config.backendUrls.store}/service/bookings/${id}`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get appointment");
+  return response.json();
 }
-async function cancelAppointment(id) {
-  await storeManagementAxios.delete(`service/bookings/${id}`);
+async function cancelAppointment(config, accessToken, id) {
+  await fetch(`${config.backendUrls.store}/service/bookings/${id}`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
 }
-async function getDeliverables(order_id) {
-  const { data } = await storeManagementAxios.get(`service/projects/${order_id}/deliverables/`);
-  return data;
+async function getDeliverables(config, accessToken, order_id) {
+  const response = await fetch(`${config.backendUrls.store}/service/projects/${order_id}/deliverables/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get deliverables");
+  return response.json();
 }
-async function approveDeliverable(order_id, deliverable_id) {
-  const { data } = await storeManagementAxios.post(
-    `service/projects/${order_id}/deliverables/${deliverable_id}/approve`,
-    { approved: true }
+async function approveDeliverable(config, accessToken, order_id, deliverable_id) {
+  const response = await fetch(
+    `${config.backendUrls.store}/service/projects/${order_id}/deliverables/${deliverable_id}/approve`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      },
+      body: JSON.stringify({ approved: true })
+    }
   );
-  return data;
+  if (!response.ok) throw new Error("Failed to approve deliverable");
+  return response.json();
 }
-async function requestRevision(order_id, deliverable_id, feedback) {
-  const { data } = await storeManagementAxios.post(
-    `service/projects/${order_id}/deliverables/${deliverable_id}/revision`,
-    { approved: false, feedback }
+async function requestRevision(config, accessToken, order_id, deliverable_id, feedback) {
+  const response = await fetch(
+    `${config.backendUrls.store}/service/projects/${order_id}/deliverables/${deliverable_id}/revision`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      },
+      body: JSON.stringify({ approved: false, feedback })
+    }
   );
-  return data;
+  if (!response.ok) throw new Error("Failed to request revision");
+  return response.json();
 }
 var serviceBookingService = {
   getAvailableSlots,
@@ -2131,19 +2172,31 @@ var serviceBookingService = {
 };
 
 // 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;
+async function sendContactEmail(config, payload) {
+  const response = await fetch(`${config.backendUrls.notifications}/contact/send-contact-email`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to send contact email");
+  return response.json();
+}
+async function sendContactConfirmation(config, payload) {
+  const response = await fetch(`${config.backendUrls.notifications}/contact/send-contact-confirmation`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to send contact confirmation");
+  return response.json();
 }
 var notificationsService = {
   sendContactEmail,
@@ -2164,17 +2217,35 @@ async function googleTranslate(text, target, source = "en") {
 }
 
 // src/services/config.service.ts
-async function getSupportedLanguages() {
-  const { data } = await paymentAxios.get("/config/supported-languages");
-  return data;
+async function getSupportedLanguages(config) {
+  const response = await fetch(`${config.backendUrls.payment}/config/supported-languages`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get supported languages");
+  return response.json();
 }
-async function getSupportedCurrencies() {
-  const { data } = await paymentAxios.get("/config/supported-currencies");
-  return data;
+async function getSupportedCurrencies(config) {
+  const response = await fetch(`${config.backendUrls.payment}/config/supported-currencies`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get supported currencies");
+  return response.json();
 }
-async function getBusinessConfig() {
-  const { data } = await publicStoreAxios.get("business/profile");
-  return data;
+async function getBusinessConfig(config) {
+  const response = await fetch(`${config.backendUrls.auth}/internal/businesses/${config.businessId}/`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get business config");
+  return response.json();
 }
 var configService = {
   getSupportedLanguages,
@@ -2183,1180 +2254,443 @@ var configService = {
 };
 
 // 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`,
+async function listCmsEntries(config, modelSlug, params) {
+  const queryParams = new URLSearchParams();
+  queryParams.set("page", (params?.page || 1).toString());
+  queryParams.set("page_size", (params?.page_size || 50).toString());
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries?${queryParams.toString()}`,
     {
-      params: {
-        page: params?.page || 1,
-        page_size: params?.page_size || 50
+      headers: {
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
       }
     }
   );
-  return response.data;
+  if (!response.ok) throw new Error("Failed to list CMS entries");
+  return response.json();
 }
-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
+async function getCmsEntry(config, modelSlug, entryId) {
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+    {
+      headers: {
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      }
+    }
   );
-  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
+  if (!response.ok) throw new Error("Failed to get CMS entry");
+  return response.json();
+}
+async function createCmsEntry(config, accessToken, modelSlug, params) {
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      },
+      body: JSON.stringify(params)
+    }
   );
-  return response.data;
+  if (!response.ok) throw new Error("Failed to create CMS entry");
+  return response.json();
 }
-async function deleteCmsEntry(modelSlug, entryId) {
-  const config = getRuntimeConfig();
-  const { businessId } = config;
-  await cmsAxios.delete(
-    `/sdk/${businessId}/${modelSlug}/entries/${entryId}`
+async function updateCmsEntry(config, accessToken, modelSlug, entryId, params) {
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+    {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      },
+      body: JSON.stringify(params)
+    }
   );
+  if (!response.ok) throw new Error("Failed to update CMS entry");
+  return response.json();
 }
-
-// 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"
-          });
-        }
+async function deleteCmsEntry(config, accessToken, modelSlug, entryId) {
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+    {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
       }
     }
-  });
-  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
-  };
+  );
+  if (!response.ok) throw new Error("Failed to delete CMS entry");
 }
 
-// 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/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/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()
-  });
+// src/utils/logger.ts
+var isDevelopment2 = true;
+function setLoggerEnvironmentMode(development) {
+  isDevelopment2 = development;
 }
-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"] });
+var logger = {
+  log: (...args) => {
+    if (isDevelopment2) {
+      console.log(...args);
     }
-  });
-}
-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"] });
+  },
+  warn: (...args) => {
+    if (isDevelopment2) {
+      console.warn(...args);
     }
-  });
-}
-function useUpdateProfile() {
-  const queryClient = (0, import_react_query3.useQueryClient)();
-  return (0, import_react_query3.useMutation)({
-    mutationFn: updateProfile,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["auth-user"] });
+  },
+  /**
+   * 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);
     }
-  });
-}
-function useLogout() {
-  const queryClient = (0, import_react_query3.useQueryClient)();
-  return (0, import_react_query3.useMutation)({
-    mutationFn: logout,
-    onSuccess: () => {
-      queryClient.clear();
+  },
+  error: (...args) => {
+    if (isDevelopment2) {
+      console.error(...args);
     }
-  });
-}
-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();
+  },
+  info: (...args) => {
+    if (isDevelopment2) {
+      console.info(...args);
     }
-  };
-}
-
-// 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);
+  },
+  createScope: (scope) => ({
+    log: (...args) => {
+      if (isDevelopment2) {
+        console.log(`[${scope}]`, ...args);
+      }
     },
-    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);
+    warn: (...args) => {
+      if (isDevelopment2) {
+        console.warn(`[${scope}]`, ...args);
+      }
     },
-    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);
+    warning: (...args) => {
+      if (isDevelopment2) {
+        console.warn(`[${scope}]`, ...args);
+      }
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: wishlistKeys.all });
-      queryClient.invalidateQueries({ queryKey: ["wishlist", "check"] });
+    error: (...args) => {
+      if (isDevelopment2) {
+        console.error(`[${scope}]`, ...args);
+      }
+    },
+    info: (...args) => {
+      if (isDevelopment2) {
+        console.info(`[${scope}]`, ...args);
+      }
     }
-  });
-}
-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/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/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()
-  });
+// src/utils/customer.ts
+function buildFullName2(firstname, lastname) {
+  const name = [firstname, lastname].filter(Boolean).join(" ").trim();
+  return name || void 0;
 }
-function useConsultation(id) {
-  return (0, import_react_query13.useQuery)({
-    queryKey: ["consultation", id],
-    queryFn: () => consultationService.getConsultation(id),
-    enabled: !!id
-  });
+function splitFullName2(fullName) {
+  if (!fullName?.trim()) return { firstname: "", lastname: "" };
+  const parts = fullName.trim().split(/\s+/);
+  return {
+    firstname: parts[0] ?? "",
+    lastname: parts.slice(1).join(" ")
+  };
 }
-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 getCustomerDisplayName(user) {
+  const fromParts = buildFullName2(user.firstname, user.lastname);
+  return fromParts || user.full_name || user.email.split("@")[0];
 }
-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 getStorefrontUrl(businessId, customDomain) {
+  if (customDomain && customDomain.trim()) {
+    const cleanDomain = customDomain.trim().replace(/^https?:\/\//, "");
+    return `https://${cleanDomain}`;
+  }
+  const cleanBid = (businessId || "store").toLowerCase().trim();
+  return `https://${cleanBid}.kasuvia.com`;
 }
-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] });
-    }
-  });
+
+// src/utils/checkout.ts
+function buildDeliveryAddress(customer, location) {
+  return {
+    first_name: customer.first_name,
+    last_name: customer.last_name,
+    phone: customer.phone,
+    ...location
+  };
 }
-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] });
-    }
-  });
+function getCheckoutCustomerName(customer) {
+  return buildFullName2(customer.first_name, customer.last_name) ?? customer.email.split("@")[0];
 }
-
-// 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 };
+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/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/utils/error-handler.ts
+function getErrorMessage(error, fallback = "Something went wrong") {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error instanceof Response) {
+    return `HTTP ${error.status}: ${error.statusText}`;
+  }
+  if (typeof error === "object" && error !== null) {
+    const err = error;
+    return err.detail || err.message || fallback;
+  }
+  return fallback;
 }
 
-// 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/utils/storage.ts
+function getPrefixedKey(businessId, key) {
+  const cleanKey = key.startsWith("kasuvia_") ? key.substring(5) : key;
+  return businessId ? `kasuvia-sf-${businessId}-${cleanKey}` : `kasuvia-sf-anon-${cleanKey}`;
 }
-
-// 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)(() => {
+var sessionStore = {
+  get: (businessIdOrKey, key) => {
+    if (typeof window === "undefined") return null;
+    const bId = key ? businessIdOrKey : "";
+    const k = key || businessIdOrKey;
+    return sessionStorage.getItem(getPrefixedKey(bId, k));
+  },
+  set: (businessIdOrKey, keyOrVal, val) => {
     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)(() => {
+    const bId = val !== void 0 ? businessIdOrKey : "";
+    const k = val !== void 0 ? keyOrVal : businessIdOrKey;
+    const v = val !== void 0 ? val : keyOrVal;
+    sessionStorage.setItem(getPrefixedKey(bId, k), v);
+  },
+  remove: (businessIdOrKey, key) => {
     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 bId = key ? businessIdOrKey : "";
+    const k = key || businessIdOrKey;
+    sessionStorage.removeItem(getPrefixedKey(bId, k));
+  },
+  getJSON: (businessIdOrKey, key) => {
+    if (typeof window === "undefined") return null;
+    const bId = key ? businessIdOrKey : "";
+    const k = key || businessIdOrKey;
+    const value = sessionStorage.getItem(getPrefixedKey(bId, k));
+    if (!value) return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
     }
-    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)(() => {
+  },
+  setJSON: (businessIdOrKey, keyOrVal, val) => {
     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);
+    const bId = val !== void 0 ? businessIdOrKey : "";
+    const k = val !== void 0 ? keyOrVal : businessIdOrKey;
+    const v = val !== void 0 ? val : keyOrVal;
+    sessionStorage.setItem(getPrefixedKey(bId, k), JSON.stringify(v));
+  }
+};
+var localStore = {
+  get: (businessIdOrKey, key) => {
+    if (typeof window === "undefined") return null;
+    const bId = key ? businessIdOrKey : "";
+    const k = key || businessIdOrKey;
+    return localStorage.getItem(getPrefixedKey(bId, k));
+  },
+  set: (businessIdOrKey, keyOrVal, val) => {
+    if (typeof window === "undefined") return;
+    const bId = val !== void 0 ? businessIdOrKey : "";
+    const k = val !== void 0 ? keyOrVal : businessIdOrKey;
+    const v = val !== void 0 ? val : keyOrVal;
+    localStorage.setItem(getPrefixedKey(bId, k), v);
+  },
+  remove: (businessIdOrKey, key) => {
+    if (typeof window === "undefined") return;
+    const bId = key ? businessIdOrKey : "";
+    const k = key || businessIdOrKey;
+    localStorage.removeItem(getPrefixedKey(bId, k));
+  },
+  getJSON: (businessIdOrKey, key) => {
+    if (typeof window === "undefined") return null;
+    const bId = key ? businessIdOrKey : "";
+    const k = key || businessIdOrKey;
+    const value = localStorage.getItem(getPrefixedKey(bId, k));
+    if (!value) return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
     }
-  }, [appLang, isLoaded, changeLanguage]);
-  return { isLoaded };
-}
+  },
+  setJSON: (businessIdOrKey, keyOrVal, val) => {
+    if (typeof window === "undefined") return;
+    const bId = val !== void 0 ? businessIdOrKey : "";
+    const k = val !== void 0 ? keyOrVal : businessIdOrKey;
+    const v = val !== void 0 ? val : keyOrVal;
+    localStorage.setItem(getPrefixedKey(bId, k), JSON.stringify(v));
+  }
+};
 
-// 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/utils/validators.ts
+function validateEmail(email) {
+  if (!email || email.trim() === "") {
+    return "Email is required";
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return "Please enter a valid email address";
+  }
+  return null;
 }
-
-// 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 validatePassword(password) {
+  if (!password || password.trim() === "") {
+    return "Password is required";
+  }
+  if (password.length < 8) {
+    return "Password must be at least 8 characters";
+  }
+  if (password.length > 72) {
+    return "Password cannot exceed 72 characters";
+  }
+  if (!/[A-Z]/.test(password)) {
+    return "Password must contain at least one uppercase letter";
+  }
+  if (!/[a-z]/.test(password)) {
+    return "Password must contain at least one lowercase letter";
+  }
+  if (!/[0-9]/.test(password)) {
+    return "Password must contain at least one number";
+  }
+  return null;
 }
-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 validateName(name, fieldName = "Name") {
+  if (!name || name.trim() === "") {
+    return `${fieldName} is required`;
+  }
+  if (name.trim().length < 2) {
+    return `${fieldName} must be at least 2 characters`;
+  }
+  if (name.trim().length > 50) {
+    return `${fieldName} cannot exceed 50 characters`;
+  }
+  const nameRegex = /^[a-zA-Z\s\-'\u00C0-\u017F]+$/;
+  if (!nameRegex.test(name.trim())) {
+    return `${fieldName} can only contain letters, spaces, hyphens, and apostrophes`;
+  }
+  return null;
 }
-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 validateRequired(value, fieldName) {
+  if (!value || value.trim() === "") {
+    return `${fieldName} is required`;
+  }
+  return null;
 }
-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 validateConfirmPassword(password, confirmPassword) {
+  if (!confirmPassword) return null;
+  if (confirmPassword !== password) {
+    return "Passwords do not match";
+  }
+  return null;
 }
-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
-  };
+function validateMessage(message) {
+  if (!message || message.trim() === "") {
+    return "Message is required";
+  }
+  if (message.trim().length < 10) {
+    return "Message must be at least 10 characters";
+  }
+  return null;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AuthCtx,
-  AuthProvider,
-  CartCtx,
-  CartProvider,
   InvalidBaseURLError,
+  STORAGE_KEYS,
+  SdkProvider,
+  ServiceLocationTypeEnum,
+  ServiceRecurringIntervalEnum,
+  ServiceTypeEnum,
   acceptQuote,
   addToCart,
   addToGuestCart,
   addToWishlist,
   approveDeliverable,
-  authAxios,
   bespokeService,
   bookAppointment,
   buildDeliveryAddress,
@@ -3367,11 +2701,8 @@ function useDeleteCmsEntry(modelSlug) {
   checkInWishlist,
   clearCart,
   clearGuestCart,
-  clearGuestSessionId,
-  cmsAxios,
-  collectionKeys,
+  clearTokens,
   configService,
-  configureHttpClients,
   consultationService,
   createCmsEntry,
   createConsultation,
@@ -3385,7 +2716,6 @@ function useDeleteCmsEntry(modelSlug) {
   getAppointments,
   getAuthUser,
   getAvailableSlots,
-  getBackendUrl,
   getBusinessConfig,
   getCacheTier,
   getCart,
@@ -3393,43 +2723,38 @@ function useDeleteCmsEntry(modelSlug) {
   getCmsEntry,
   getConsultation,
   getConsultations,
-  getCountries,
   getCustomerDisplayName,
   getDeliverables,
   getErrorMessage,
   getFeaturedProducts,
-  getGraphQLClient,
   getGuestCart,
   getGuestCartCount,
   getGuestCartProductType,
   getGuestCartSubtotal,
-  getGuestSessionId,
   getLatestProducts,
+  getLowStockProducts,
   getMe,
   getNewProducts,
-  getOrCreateGuestSessionId,
+  getOnSaleProducts,
   getOrders,
   getPopularProducts,
   getRecommendedProducts,
-  getRuntimeConfig,
   getSellerShippingAddress,
   getShippingRates,
-  getStates,
+  getStoredTokens,
   getStorefrontCollectionBySlug,
   getStorefrontCollections,
   getStorefrontProductBySlug,
   getStorefrontProducts,
+  getStorefrontUrl,
   getSupportedCurrencies,
-  getSupportedCurrenciesList,
   getSupportedLanguages,
-  getSupportedLanguagesList,
   getTransactionStatus,
   getWishlist,
   googleTranslate,
-  initSdk,
   initiatePayment,
-  isInitialized,
   listCmsEntries,
+  localStore,
   logger,
   loginCustomer,
   logisticsService,
@@ -3438,10 +2763,7 @@ function useDeleteCmsEntry(modelSlug) {
   mergeGuestCart,
   mergeGuestCartIfPresent,
   notificationsService,
-  paymentAxios,
   paymentService,
-  productKeys,
-  publicStoreAxios,
   refreshToken,
   registerCustomer,
   rejectQuote,
@@ -3451,90 +2773,31 @@ function useDeleteCmsEntry(modelSlug) {
   removeProductFromWishlist,
   requestQuote,
   requestRevision,
-  resetConfig,
-  resetGraphQLClient,
   sanitizeBaseUrl,
   sendContactConfirmation,
   sendContactEmail,
   sendMessage,
   serviceBookingService,
+  sessionStore,
   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,
+  useSdkContext,
+  validateConfirmPassword,
+  validateEmail,
+  validateMessage,
+  validateName,
+  validatePassword,
+  validateRequired,
   validateShippingAddress,
   verifySocialToken,
-  verifyTransaction,
-  wishlistKeys
+  verifyTransaction
 });
 //# sourceMappingURL=index.js.map