@ecomiq/storefront 0.1.0

package/dist/react.js

@@ -0,0 +1,3199 @@
+import axios from 'axios';
+import { z } from 'zod';
+import { QueryClient, hydrate, QueryClientProvider, useMutation, useQuery, useQueryClient, useInfiniteQuery } from '@tanstack/react-query';
+import { createContext, useRef, useEffect, useContext, useState, useMemo, useCallback } from 'react';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import { createAuthMiddleware, createAuthEndpoint, formCsrfMiddleware } from 'better-auth/api';
+import { APIError } from 'better-auth';
+import { setSessionCookie } from 'better-auth/cookies';
+import { parseUserOutput } from 'better-auth/db';
+import { formatCurrency as formatCurrency$1, StorefrontPageDetailSchema as StorefrontPageDetailSchema$1 } from '@ecomiq/storefront/react';
+
+// src/core/constants/api-paths.ts
+var STOREFRONT_API_PATH_PREFIX = "v1";
+
+// src/core/constants/storefront-ecomiq-oauth-cookie.ts
+var STOREFRONT_ECOMIQ_OAUTH_COOKIE_NAME = "ecomiq_sf_oauth_at";
+var STOREFRONT_ECOMIQ_OAUTH_COOKIE_PATH = "/api/store";
+
+// src/core/constants/currency.ts
+var countryCurrency = {
+  "PEN": "es-PE",
+  "USD": "en-US",
+  "COP": "es-CO",
+  "MXN": "es-MX"
+};
+
+// src/core/utils/format-currency.ts
+function formatCurrency(amount, currency = "USD") {
+  const locale = countryCurrency[currency] ?? "en-US";
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(amount);
+}
+
+// src/core/lib/customer-order-labels.ts
+var ORDER_STATUS_LABELS = {
+  New: "Pedido realizado",
+  Confirmed: "Confirmado",
+  Processing: "En preparaci\xF3n",
+  InTransit: "En camino",
+  Delivered: "Entregado",
+  Cancelled: "Cancelado",
+  Canceled: "Cancelado",
+  Refunded: "Reembolsado",
+  Pending: "Pendiente",
+  Paid: "Pagado",
+  Captured: "Pago confirmado"
+};
+function formatCustomerOrderStatus(status) {
+  const trimmed = status.trim();
+  if (!trimmed) return "Desconocido";
+  return ORDER_STATUS_LABELS[trimmed] ?? trimmed.replace(/([A-Z])/g, " $1").trim();
+}
+function customerOrderStatusTone(status) {
+  const s = status.toLowerCase();
+  if (s.includes("cancel") || s.includes("refund")) return "danger";
+  if (s.includes("deliver")) return "success";
+  if (s.includes("transit") || s.includes("ship")) return "info";
+  if (s.includes("confirm") || s.includes("paid") || s.includes("capture")) return "success";
+  if (s.includes("pending") || s.includes("new") || s.includes("process")) return "warning";
+  return "default";
+}
+function formatOrderDate(iso, locale = "es-PE") {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  return new Intl.DateTimeFormat(locale, {
+    day: "numeric",
+    month: "long",
+    year: "numeric"
+  }).format(d);
+}
+function formatOrderDateTime(iso, locale = "es-PE") {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  return new Intl.DateTimeFormat(locale, {
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  }).format(d);
+}
+
+// src/core/lib/storefront-geo-inei.ts
+function toGeoItems(data) {
+  if (!Array.isArray(data)) return [];
+  return data.map((raw) => {
+    if (!raw || typeof raw !== "object") return null;
+    const item = raw;
+    return {
+      code: String(item.code ?? ""),
+      name: String(item.name ?? "")
+    };
+  }).filter((x) => !!x && !!x.code && !!x.name);
+}
+var departmentsCache = null;
+var departmentsRequest = null;
+function loadStorefrontGeoDepartments(headers) {
+  if (departmentsCache) return Promise.resolve(departmentsCache);
+  if (departmentsRequest) return departmentsRequest;
+  departmentsRequest = fetch(
+    `/api/store/geo/departments?countryCode=PE&source=inei&limit=200`,
+    { cache: "no-store", headers }
+  ).then((r) => r.json()).then((data) => {
+    const items = toGeoItems(data);
+    departmentsCache = items;
+    return items;
+  }).catch(() => {
+    departmentsCache = [];
+    return [];
+  }).finally(() => {
+    departmentsRequest = null;
+  });
+  return departmentsRequest;
+}
+async function fetchStorefrontGeoProvinces(headers, countryCode, departmentCode) {
+  const res = await fetch(
+    `/api/store/geo/provinces?countryCode=${encodeURIComponent(
+      countryCode
+    )}&departmentCode=${encodeURIComponent(departmentCode)}&source=inei&limit=200`,
+    { headers }
+  );
+  const data = await res.json();
+  return toGeoItems(data);
+}
+async function fetchStorefrontGeoDistricts(headers, countryCode, provinceCode) {
+  const res = await fetch(
+    `/api/store/geo/districts?countryCode=${encodeURIComponent(
+      countryCode
+    )}&provinceCode=${encodeURIComponent(provinceCode)}&source=inei`,
+    { headers }
+  );
+  const data = await res.json();
+  return toGeoItems(data);
+}
+async function resolveIneiCodesFromLabels(storeId, labels, countryCode = "PE") {
+  const id = storeId.trim();
+  if (!id) return null;
+  const headers = { "X-Store-Id": id };
+  const departments = await loadStorefrontGeoDepartments(headers);
+  const dept = departments.find((d) => d.name.trim() === labels.department.trim());
+  if (!dept) return null;
+  const provinces = await fetchStorefrontGeoProvinces(headers, countryCode, dept.code);
+  const prov = provinces.find((p) => p.name.trim() === labels.province.trim());
+  if (!prov) {
+    return { departmentCode: dept.code, provinceCode: "", districtCode: "" };
+  }
+  const districts = await fetchStorefrontGeoDistricts(headers, countryCode, prov.code);
+  const dist = districts.find((d) => d.name.trim() === labels.district.trim());
+  return {
+    departmentCode: dept.code,
+    provinceCode: prov.code,
+    districtCode: dist?.code ?? ""
+  };
+}
+var ApiClient = class {
+  client;
+  storeId;
+  storeDomain;
+  constructor(baseURL = "https://storefront.ecomiq.pe") {
+    this.client = axios.create({
+      baseURL,
+      timeout: 1e4,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this.client.interceptors.request.use(
+      (config) => {
+        if (config.headers) {
+          if (this.storeId) config.headers["X-Store-Id"] = this.storeId;
+          if (this.storeDomain) config.headers["X-Store-Domain"] = this.storeDomain;
+        }
+        return config;
+      }
+    );
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        console.error("API Error:", error);
+        return Promise.reject(error);
+      }
+    );
+  }
+  setStoreId(storeId) {
+    this.storeId = storeId;
+  }
+  /** Subdominio para endpoints que usan X-Store-Domain (ej. GET /v1/storefront/settings) */
+  setStoreDomain(domain) {
+    this.storeDomain = domain;
+  }
+  get(url, config) {
+    return this.client.get(url, config).then((response) => response.data);
+  }
+  post(url, data, config) {
+    return this.client.post(url, data, config).then((response) => response.data);
+  }
+  put(url, data, config) {
+    return this.client.put(url, data, config).then((response) => response.data);
+  }
+  patch(url, data, config) {
+    return this.client.patch(url, data, config).then((response) => response.data);
+  }
+  delete(url, config) {
+    return this.client.delete(url, config).then((response) => response.data);
+  }
+};
+var apiClient = new ApiClient();
+var ProductVariantSchema = z.object({
+  id: z.coerce.string(),
+  name: z.string(),
+  storeId: z.string(),
+  productId: z.coerce.string(),
+  basePrice: z.number().positive().optional().nullable(),
+  comparePrice: z.number().positive().optional().nullable(),
+  //TODO: remove this field
+  originalPrice: z.number().positive().optional().nullable(),
+  costPrice: z.number().positive().optional().nullable(),
+  isDefault: z.boolean().optional().nullable(),
+  reserveStock: z.number().nonnegative().optional().nullable(),
+  weight: z.number().nonnegative().optional().nullable().default(0),
+  width: z.number().nonnegative().optional().nullable(),
+  height: z.number().nonnegative().optional().nullable(),
+  unitOfMeasure: z.string().optional().nullable(),
+  order: z.number().nonnegative().optional().nullable().default(0),
+  sku: z.string().optional().nullable(),
+  stock: z.number().nonnegative().optional().nullable(),
+  leadTime: z.string().optional().nullable(),
+  barCode: z.string().optional().nullable(),
+  shippingWeight: z.number().nonnegative().optional().nullable(),
+  images: z.array(z.string()).optional().nullable(),
+  attributes: z.array(z.string()).optional().nullable(),
+  variantStatus: z.string().optional().nullable(),
+  status: z.string().optional().nullable(),
+  createdOn: z.string().optional().nullable(),
+  updatedOn: z.string().optional().nullable(),
+  deletedOn: z.string().optional().nullable()
+});
+var ProductSchema = z.object({
+  id: z.coerce.string(),
+  name: z.string(),
+  images: z.array(z.object({
+    url: z.string().url(),
+    name: z.string().optional(),
+    isPrimary: z.boolean().optional()
+  })),
+  basePrice: z.number().positive().optional(),
+  salePrice: z.number().positive().optional(),
+  slug: z.string(),
+  description: z.string().optional(),
+  categories: z.array(z.object({
+    id: z.coerce.string(),
+    name: z.string(),
+    slug: z.string(),
+    logo: z.string().optional(),
+    icon: z.string().optional()
+  })).optional(),
+  tags: z.array(z.string()).optional(),
+  inStock: z.boolean().optional(),
+  variants: z.array(ProductVariantSchema).optional()
+});
+var ProductsResponseSchema = z.object({
+  items: z.array(ProductSchema),
+  meta: z.object({
+    total: z.number().int().positive(),
+    page: z.number().int().positive(),
+    pageSize: z.number().int().positive(),
+    hasNextPage: z.boolean()
+  })
+});
+var ProductsFiltersSchema = z.object({
+  category: z.string().optional(),
+  search: z.string().optional(),
+  minPrice: z.number().positive().optional(),
+  maxPrice: z.number().positive().optional(),
+  inStock: z.boolean().optional(),
+  sortBy: z.enum(["name", "price", "createdAt"]).optional(),
+  sortOrder: z.enum(["asc", "desc"]).optional(),
+  page: z.number().int().positive().optional(),
+  limit: z.number().int().positive().optional()
+});
+var StorefrontProductSchema = z.object({
+  id: z.coerce.string(),
+  name: z.string(),
+  slug: z.string(),
+  productType: z.string().optional().nullable(),
+  imageUrl: z.string().optional().nullable(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().optional().nullable(),
+  variantCount: z.number().int().nonnegative().optional().default(0),
+  isAvailable: z.boolean(),
+  totalInventory: z.number().int().nonnegative(),
+  bundleItemsCount: z.number().int().nonnegative().optional().default(0),
+  brand: z.string().optional().nullable(),
+  category: z.string().optional().nullable(),
+  status: z.string().optional().nullable(),
+  tags: z.array(z.string()).optional().nullable()
+});
+var StorefrontFacetSchema = z.object({
+  value: z.string(),
+  count: z.number().int().nonnegative()
+});
+var StorefrontProductsResponseSchema = z.object({
+  pageIndex: z.number().int().positive(),
+  pageSize: z.number().int().positive(),
+  totalCount: z.number().int().nonnegative(),
+  totalPages: z.number().int().nonnegative(),
+  products: z.array(StorefrontProductSchema),
+  categories: z.array(StorefrontFacetSchema).optional().default([]),
+  brands: z.array(StorefrontFacetSchema).optional().default([]),
+  minPrice: z.number().nonnegative().optional().nullable(),
+  maxPrice: z.number().nonnegative().optional().nullable()
+});
+var StorefrontProductsParamsSchema = z.object({
+  page: z.number().int().positive().optional().default(1),
+  pageSize: z.number().int().positive().optional().default(20),
+  sort: z.enum(["price_asc", "price_desc", "name_asc", "name_desc", "newest"]).optional().default("price_asc"),
+  sellerId: z.string().optional(),
+  search: z.string().optional(),
+  collection: z.string().optional(),
+  category: z.string().optional(),
+  brand: z.string().optional(),
+  productType: z.string().optional(),
+  inStock: z.boolean().optional(),
+  minPrice: z.number().nonnegative().optional(),
+  maxPrice: z.number().nonnegative().optional()
+});
+var StorefrontVariantOptionSchema = z.object({
+  key: z.string(),
+  name: z.string(),
+  value: z.string()
+});
+var StorefrontProductImageSchema = z.object({
+  url: z.string(),
+  name: z.string().optional().nullable(),
+  order: z.number().int().nonnegative().optional()
+});
+var StorefrontVariantSchema = z.object({
+  id: z.coerce.string().optional().default(""),
+  sku: z.string(),
+  status: z.string().optional().nullable(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().optional().nullable(),
+  quantity: z.number().int().nonnegative(),
+  options: z.array(StorefrontVariantOptionSchema).optional().default([]),
+  images: z.array(StorefrontProductImageSchema).optional().default([])
+});
+var StorefrontPriceTierSchema = z.object({
+  variantId: z.coerce.string(),
+  minQuantity: z.number().int().positive(),
+  maxQuantity: z.number().int().positive().optional().nullable(),
+  unitPrice: z.number().nonnegative()
+});
+var StorefrontBundleItemSchema = z.object({
+  productId: z.coerce.string(),
+  variantId: z.coerce.string(),
+  productName: z.string(),
+  variantName: z.string().optional().nullable(),
+  sku: z.string().optional().nullable(),
+  brand: z.string().optional().nullable(),
+  imageUrl: z.string().optional().nullable(),
+  quantity: z.number().int(),
+  availableStock: z.number().int().optional().default(0),
+  allowBackorders: z.boolean().optional().default(false),
+  requiresShipping: z.boolean().optional().default(true)
+});
+var StorefrontProductDetailSchema = z.object({
+  id: z.coerce.string(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string().optional().nullable(),
+  productType: z.string().optional().nullable(),
+  status: z.string().optional().nullable(),
+  imageUrl: z.string().optional().nullable(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().optional().nullable(),
+  isAvailable: z.boolean(),
+  totalInventory: z.number().int().nonnegative(),
+  brand: z.string().optional().nullable(),
+  category: z.string().optional().nullable(),
+  categoryId: z.coerce.string().optional().nullable(),
+  tags: z.array(z.string()).optional().nullable(),
+  specifications: z.array(z.record(z.string(), z.unknown())).optional().default([]),
+  variants: z.array(StorefrontVariantSchema).optional().default([]),
+  images: z.array(StorefrontProductImageSchema).optional().default([]),
+  bundleItems: z.array(StorefrontBundleItemSchema).optional().default([]),
+  priceTiers: z.array(StorefrontPriceTierSchema).optional().default([]),
+  createdAt: z.string().optional().nullable(),
+  updatedAt: z.string().optional().nullable()
+});
+
+// src/core/services/product.service.ts
+var ProductService = class _ProductService {
+  static instance;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_ProductService.instance) {
+      _ProductService.instance = new _ProductService();
+    }
+    return _ProductService.instance;
+  }
+  /**
+   * Obtiene todos los productos del store
+   */
+  async getProducts(filters) {
+    if (filters) {
+      ProductsFiltersSchema.parse(filters);
+    }
+    const params = new URLSearchParams();
+    if (filters) {
+      if (filters.category) params.append("category", filters.category);
+      if (filters.search) params.append("search", filters.search);
+      if (filters.minPrice) params.append("minPrice", filters.minPrice.toString());
+      if (filters.maxPrice) params.append("maxPrice", filters.maxPrice.toString());
+      if (filters.sortBy) params.append("sortBy", filters.sortBy);
+      if (filters.sortOrder) params.append("sortOrder", filters.sortOrder);
+      if (filters.page) params.append("page", filters.page.toString());
+      if (filters.limit) params.append("limit", filters.limit.toString());
+    }
+    const queryString = params.toString();
+    const url = `/${STOREFRONT_API_PATH_PREFIX}/products${queryString ? `?${queryString}` : ""}`;
+    const response = await apiClient.get(url);
+    return ProductsResponseSchema.parse(response);
+  }
+  /**
+   * Obtiene un producto específico por ID
+   */
+  async getProduct(id) {
+    const response = await apiClient.get(`/${STOREFRONT_API_PATH_PREFIX}/products/${id}`);
+    return ProductSchema.parse(response);
+  }
+  /**
+   * Obtiene un producto específico por slug
+   */
+  async getProductBySlug(slug) {
+    const response = await apiClient.get(`/${STOREFRONT_API_PATH_PREFIX}/products/${encodeURIComponent(slug)}`);
+    return ProductSchema.parse(response);
+  }
+  /**
+   * Busca productos por término de búsqueda
+   */
+  async searchProducts(query, filters) {
+    return this.getProducts({ ...filters, search: query });
+  }
+  /**
+   * Obtiene productos por categoría
+   */
+  async getProductsByCategory(category, filters) {
+    return this.getProducts({ ...filters, category });
+  }
+  /**
+   * Obtiene productos en oferta (con descuento)
+   */
+  async getProductsOnSale(filters) {
+    return this.getProducts({ ...filters, minPrice: 0 });
+  }
+  /**
+   * Obtiene productos en stock
+   */
+  async getProductsInStock(filters) {
+    return this.getProducts({ ...filters, inStock: true });
+  }
+  /**
+   * Lista de productos del storefront (API v1/storefront/products).
+   * Soporta paginación, orden y filtros por categoría, marca y precio.
+   */
+  async getStorefrontProducts(params) {
+    const parsed = StorefrontProductsParamsSchema.parse(params ?? {});
+    const searchParams = new URLSearchParams();
+    searchParams.set("page", String(parsed.page));
+    searchParams.set("pageSize", String(parsed.pageSize));
+    if (parsed.sort) searchParams.set("sort", parsed.sort);
+    if (parsed.sellerId) searchParams.set("sellerId", parsed.sellerId);
+    if (parsed.collection) searchParams.set("collection", parsed.collection);
+    if (parsed.category) searchParams.set("category", parsed.category);
+    if (parsed.brand) searchParams.set("brand", parsed.brand);
+    if (parsed.productType) searchParams.set("productType", parsed.productType);
+    if (parsed.inStock != null) searchParams.set("inStock", String(parsed.inStock));
+    if (parsed.minPrice != null) searchParams.set("minPrice", String(parsed.minPrice));
+    if (parsed.maxPrice != null) searchParams.set("maxPrice", String(parsed.maxPrice));
+    if (parsed.search) searchParams.set("search", parsed.search);
+    const url = `/${STOREFRONT_API_PATH_PREFIX}/products?${searchParams.toString()}`;
+    const response = await apiClient.get(url);
+    return StorefrontProductsResponseSchema.parse(response);
+  }
+  /**
+   * Obtiene un producto del storefront por slug (API v1/storefront/products/by-slug/:slug).
+   */
+  async getStorefrontProductBySlug(slug) {
+    const response = await apiClient.get(`/${STOREFRONT_API_PATH_PREFIX}/products/by-slug/${encodeURIComponent(slug)}`);
+    return StorefrontProductDetailSchema.parse(response);
+  }
+};
+var productService = ProductService.getInstance();
+var StorefrontCollectionSchema = z.object({
+  id: z.coerce.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  imageUrl: z.string().nullable().optional(),
+  type: z.string(),
+  productCount: z.number().int().nonnegative()
+});
+var StorefrontCollectionsResponseSchema = z.array(StorefrontCollectionSchema);
+var StorefrontCollectionDetailSchema = StorefrontCollectionSchema;
+
+// src/core/services/collection.service.ts
+var CollectionService = class _CollectionService {
+  static instance;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_CollectionService.instance) {
+      _CollectionService.instance = new _CollectionService();
+    }
+    return _CollectionService.instance;
+  }
+  /**
+   * Lista de colecciones del storefront (GET /v1/collections).
+   */
+  async getStorefrontCollections() {
+    const response = await apiClient.get(
+      `/${STOREFRONT_API_PATH_PREFIX}/collections`
+    );
+    return StorefrontCollectionsResponseSchema.parse(response);
+  }
+  /**
+   * Obtiene una colección del storefront por slug (GET /v1/collections/by-slug/:slug).
+   */
+  async getStorefrontCollectionBySlug(slug) {
+    const response = await apiClient.get(
+      `/${STOREFRONT_API_PATH_PREFIX}/collections/by-slug/${encodeURIComponent(slug)}`
+    );
+    return StorefrontCollectionDetailSchema.parse(response);
+  }
+};
+var collectionService = CollectionService.getInstance();
+var StorefrontPageListItemSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  layout: z.string()
+});
+var StorefrontPageSeoSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional()
+}).optional();
+var StorefrontPageSettingsSchema = z.object({
+  seo: StorefrontPageSeoSchema,
+  html: z.string().optional(),
+  title: z.string().optional()
+}).catchall(z.unknown());
+var StorefrontPageBlockSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  order: z.number(),
+  settings: z.record(z.unknown()).optional()
+});
+var StorefrontPageSectionSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  order: z.number(),
+  settings: z.record(z.unknown()).optional(),
+  blocks: z.array(StorefrontPageBlockSchema).optional().default([])
+});
+var StorefrontPageDetailSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  layout: z.string(),
+  settings: StorefrontPageSettingsSchema.optional(),
+  sections: z.array(StorefrontPageSectionSchema).optional()
+});
+
+// src/core/services/page.service.ts
+var PageService = class _PageService {
+  static instance;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_PageService.instance) {
+      _PageService.instance = new _PageService();
+    }
+    return _PageService.instance;
+  }
+  /**
+   * Lista de páginas del storefront (GET /v1/pages).
+   */
+  async getPages() {
+    const response = await apiClient.get(
+      `/${STOREFRONT_API_PATH_PREFIX}/pages`
+    );
+    return z.array(StorefrontPageListItemSchema).parse(response);
+  }
+  /**
+   * Obtiene una página por slug (GET /v1/pages/{slug}).
+   * sections puede no venir en la respuesta.
+   */
+  async getPageBySlug(slug) {
+    const response = await apiClient.get(
+      `/${STOREFRONT_API_PATH_PREFIX}/pages/${encodeURIComponent(slug)}`
+    );
+    return StorefrontPageDetailSchema.parse(response);
+  }
+};
+var pageService = PageService.getInstance();
+var StorefrontCheckoutSettingsSchema = z.object({
+  allowGuestCheckout: z.boolean().optional(),
+  identityScope: z.enum(["store", "tenant", "global"]).optional(),
+  signInMethods: z.array(z.string()).optional()
+});
+var looseRecord = z.record(z.string(), z.unknown());
+var StorefrontThemeConfigSchema = z.object({
+  name: z.string().nullable().optional(),
+  mode: z.string().nullable().optional(),
+  colors: looseRecord.optional(),
+  fonts: looseRecord.optional(),
+  assets: looseRecord.optional()
+}).passthrough();
+var StorefrontFeaturesEnabledSchema = z.object({
+  flags: looseRecord.optional()
+}).passthrough();
+var StorefrontCmsBrandingSchema = z.object({
+  logoUrl: z.string().nullable().optional(),
+  logoDarkUrl: z.string().nullable().optional(),
+  faviconUrl: z.string().nullable().optional(),
+  socialImageUrl: z.string().nullable().optional()
+});
+var StorefrontCmsSeoSchema = z.object({
+  siteName: z.string().nullable().optional(),
+  metaTitle: z.string().nullable().optional(),
+  metaDescription: z.string().nullable().optional(),
+  titleTemplate: z.string().nullable().optional(),
+  robotsIndex: z.boolean().optional()
+});
+var StorefrontCmsSocialLinksSchema = z.object({
+  instagram: z.string().nullable().optional(),
+  facebook: z.string().nullable().optional(),
+  tiktok: z.string().nullable().optional(),
+  youtube: z.string().nullable().optional(),
+  x: z.string().nullable().optional()
+});
+var StorefrontCmsContactSchema = z.object({
+  supportEmail: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  whatsapp: z.string().nullable().optional(),
+  address: z.string().nullable().optional(),
+  socialLinks: StorefrontCmsSocialLinksSchema.optional()
+});
+var StorefrontCmsTrackingSchema = z.object({
+  googleAnalyticsMeasurementId: z.string().nullable().optional(),
+  metaPixelId: z.string().nullable().optional(),
+  googleTagManagerContainerId: z.string().nullable().optional()
+});
+var StorefrontCmsCustomScriptsSchema = z.object({
+  enabled: z.boolean().optional(),
+  head: z.string().nullable().optional(),
+  bodyEnd: z.string().nullable().optional()
+});
+var StorefrontCmsSettingsSchema = z.object({
+  themeKey: z.string().optional(),
+  branding: StorefrontCmsBrandingSchema.optional(),
+  seo: StorefrontCmsSeoSchema.optional(),
+  contact: StorefrontCmsContactSchema.optional(),
+  tracking: StorefrontCmsTrackingSchema.optional(),
+  customScripts: StorefrontCmsCustomScriptsSchema.optional(),
+  updatedOn: z.string().nullable().optional()
+});
+var StorefrontCmsPageSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  layout: z.string().optional(),
+  version: z.number().optional(),
+  settings: z.record(z.string(), z.unknown()).optional().nullable(),
+  sections: z.array(z.unknown()).optional(),
+  status: z.string().optional(),
+  hasPublishedVersion: z.boolean().optional(),
+  publishedOn: z.string().nullable().optional(),
+  publishedBy: z.string().nullable().optional(),
+  createdOn: z.string().nullable().optional(),
+  updatedOn: z.string().nullable().optional(),
+  createdBy: z.string().nullable().optional(),
+  updatedBy: z.string().nullable().optional(),
+  lastModifiedBy: z.string().nullable().optional()
+}).passthrough();
+var StorefrontSettingsLegacyFlatSchema = z.object({
+  id: z.coerce.string(),
+  tenantId: z.string().nullable().optional(),
+  name: z.string(),
+  slug: z.coerce.string().optional(),
+  description: z.string().nullable().optional(),
+  visibility: z.string().nullable().optional(),
+  logo: z.string().nullable().optional(),
+  favicon: z.string().nullable().optional(),
+  icon: z.string().nullable().optional(),
+  currency: z.string().nullable().optional(),
+  language: z.string().nullable().optional(),
+  themeConfig: z.unknown().optional().nullable(),
+  featuresEnabled: z.unknown().optional().nullable(),
+  checkoutSettings: StorefrontCheckoutSettingsSchema.optional().nullable()
+}).passthrough();
+function unwrapSettingsResponseBody(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return v;
+  const o = v;
+  if ("data" in o && o.data != null && typeof o.data === "object" && !Array.isArray(o.data)) {
+    return o.data;
+  }
+  return v;
+}
+function isLegacyFlatSettingsPayload(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+  const o = v;
+  if ("store" in o || "schemaVersion" in o || "cms" in o) return false;
+  return (typeof o.id === "string" || typeof o.id === "number") && typeof o.name === "string";
+}
+function normalizeStorefrontSettingsPayload(v) {
+  const body = unwrapSettingsResponseBody(v);
+  if (!isLegacyFlatSettingsPayload(body)) return body;
+  const raw = body;
+  const parsed = StorefrontSettingsLegacyFlatSchema.safeParse(raw);
+  if (!parsed.success) return body;
+  const l = parsed.data;
+  const currency = l.currency?.trim() ? l.currency : "PEN";
+  const language = l.language?.trim() ? l.language : "es";
+  const slug = l.slug?.trim() ? l.slug : l.id;
+  return {
+    schemaVersion: 0,
+    generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    store: {
+      id: l.id,
+      tenantId: l.tenantId ?? void 0,
+      name: l.name,
+      slug,
+      description: l.description ?? null,
+      logo: l.logo ?? null,
+      icon: l.icon ?? null,
+      visibility: l.visibility ?? void 0,
+      currency,
+      language,
+      themeConfig: l.themeConfig ?? void 0,
+      featuresEnabled: l.featuresEnabled ?? void 0,
+      checkoutSettings: l.checkoutSettings ?? void 0
+    },
+    cms: {
+      settings: {
+        branding: {
+          faviconUrl: l.favicon ?? null,
+          logoUrl: l.logo ?? null,
+          logoDarkUrl: null,
+          socialImageUrl: null
+        }
+      },
+      pages: []
+    }
+  };
+}
+var StorefrontStoreSchema = z.object({
+  id: z.string(),
+  tenantId: z.string().optional(),
+  sellerId: z.string().optional(),
+  plan: z.string().optional(),
+  storageLimitBytes: z.number().optional(),
+  monthlyTransferLimitBytes: z.number().optional(),
+  maxUploadSizeBytes: z.number().optional(),
+  maxStores: z.number().optional(),
+  maxMembers: z.number().optional(),
+  maxProducts: z.number().optional(),
+  maxCategories: z.number().optional(),
+  maxBrands: z.number().optional(),
+  maxAttributes: z.number().optional(),
+  maxCollections: z.number().optional(),
+  enableApi: z.boolean().optional(),
+  isActive: z.boolean().optional(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  avatarUrl: z.string().nullable().optional(),
+  logo: z.string().nullable().optional(),
+  icon: z.string().nullable().optional(),
+  slug: z.string(),
+  domain: z.string().nullable().optional(),
+  domains: z.array(z.string()).optional(),
+  timeZone: z.string().nullable().optional(),
+  currency: z.string(),
+  language: z.string(),
+  visibility: z.string().optional(),
+  privateAccessHash: z.string().nullable().optional(),
+  privateAccessVersion: z.number().optional(),
+  themeConfig: StorefrontThemeConfigSchema.optional(),
+  featuresEnabled: StorefrontFeaturesEnabledSchema.optional(),
+  checkoutSettings: StorefrontCheckoutSettingsSchema.optional().nullable()
+}).passthrough();
+var StorefrontSettingsEnvelopeSchema = z.object({
+  schemaVersion: z.number(),
+  generatedAt: z.string(),
+  store: StorefrontStoreSchema,
+  cms: z.object({
+    settings: StorefrontCmsSettingsSchema,
+    pages: z.array(StorefrontCmsPageSchema)
+  })
+}).passthrough();
+var StorefrontSettingsSchema = z.preprocess(
+  normalizeStorefrontSettingsPayload,
+  StorefrontSettingsEnvelopeSchema
+);
+function storefrontStoreRecord(settings) {
+  return settings?.store ?? null;
+}
+function storefrontFaviconUrl(settings) {
+  const b = settings?.cms?.settings?.branding;
+  return b?.faviconUrl ?? settings?.store?.logo ?? settings?.store?.icon ?? null;
+}
+function storefrontOgImageUrl(settings) {
+  const b = settings?.cms?.settings?.branding;
+  return b?.socialImageUrl ?? settings?.store?.logo ?? null;
+}
+
+// src/core/services/store.service.ts
+var StoreService = class _StoreService {
+  static instance;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_StoreService.instance) {
+      _StoreService.instance = new _StoreService();
+    }
+    return _StoreService.instance;
+  }
+  /**
+   * Obtiene la configuración de la tienda por subdominio (GET /v1/settings).
+   * Usa el header X-Store-Domain. Si se pasa domain, se configura antes de la petición.
+   */
+  async getStorefrontSettings(domain) {
+    if (domain) {
+      apiClient.setStoreDomain(domain);
+    }
+    const response = await apiClient.get(`/${STOREFRONT_API_PATH_PREFIX}/settings`);
+    return StorefrontSettingsSchema.parse(response);
+  }
+};
+var storeService = StoreService.getInstance();
+var CartBuyerRequestSchema = z.object({
+  email: z.string().email(),
+  firstName: z.string().min(1),
+  lastName: z.string().min(1),
+  phone: z.string().min(1)
+});
+var CartCreateRequestSchema = z.object({
+  currencyCode: z.string(),
+  salesChannelId: z.string(),
+  email: z.string().email()
+});
+var CartAddressSchema = z.object({
+  name: z.string().min(1),
+  address1: z.string().min(1),
+  city: z.string().min(1),
+  countryCode: z.string().min(2),
+  company: z.string().nullable().optional(),
+  address2: z.string().nullable().optional(),
+  province: z.string().nullable().optional(),
+  postalCode: z.string().nullable().optional(),
+  district: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  latitude: z.number().nullable().optional(),
+  longitude: z.number().nullable().optional(),
+  geo: z.object({
+    departmentCode: z.string().nullable().optional(),
+    provinceCode: z.string().nullable().optional(),
+    districtCode: z.string().nullable().optional()
+  }).nullable().optional()
+});
+var CartAddressesRequestSchema = z.object({
+  shippingAddress: CartAddressSchema,
+  billingAddress: CartAddressSchema
+});
+var CartItemModifierRequestSchema = z.object({
+  modifierGroupId: z.coerce.string().min(1),
+  optionIds: z.array(z.coerce.string().min(1)).optional().default([])
+});
+var CartItemRequestSchema = z.object({
+  variantId: z.coerce.string().min(1),
+  quantity: z.number().int().positive(),
+  modifiers: z.array(CartItemModifierRequestSchema).optional()
+});
+var CartCouponRequestSchema = z.object({
+  code: z.string().min(1)
+});
+z.object({
+  subtotal: z.number(),
+  discount: z.number(),
+  tax: z.number(),
+  warranty: z.number().optional().default(0),
+  total: z.number()
+});
+z.object({
+  name: z.string().nullable().optional(),
+  address1: z.string(),
+  city: z.string(),
+  countryCode: z.string(),
+  company: z.string().nullable().optional(),
+  address2: z.string().nullable().optional(),
+  province: z.string().nullable().optional(),
+  postalCode: z.string().nullable().optional(),
+  district: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  latitude: z.number().nullable().optional(),
+  longitude: z.number().nullable().optional(),
+  geo: z.object({
+    departmentCode: z.string().nullable().optional(),
+    provinceCode: z.string().nullable().optional(),
+    districtCode: z.string().nullable().optional()
+  }).nullable().optional()
+});
+var CartResponseBundleItemSchema = z.object({
+  productId: z.coerce.string(),
+  variantId: z.coerce.string(),
+  productName: z.string(),
+  variantName: z.string().nullable().optional(),
+  sku: z.string().nullable().optional(),
+  brand: z.string().nullable().optional(),
+  imageUrl: z.string().nullable().optional(),
+  quantity: z.number().int()
+});
+var CartResponseItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  variantLabel: z.string().nullable().optional(),
+  thumbnail: z.string().nullable().optional(),
+  quantity: z.number().int(),
+  variantId: z.coerce.string(),
+  variantSku: z.string().nullable().optional(),
+  unitPrice: z.number(),
+  bundleItems: z.array(CartResponseBundleItemSchema).optional().default([])
+});
+z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  total: z.number(),
+  estimatedDays: z.number().int().nullable().optional(),
+  pickupPointId: z.string().nullable().optional(),
+  scheduledDate: z.string().nullable().optional(),
+  scheduledTime: z.string().nullable().optional()
+});
+var CartResponseSchema = z.object({
+  id: z.string(),
+  regionId: z.string().nullable().optional(),
+  salesChannelId: z.string().nullable().optional(),
+  email: z.string().email().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  firstName: z.string().nullable().optional(),
+  lastName: z.string().nullable().optional(),
+  currencyCode: z.string(),
+  completedAt: z.string().nullable().optional(),
+  shippingAddress: z.unknown().nullable().optional(),
+  billingAddress: z.unknown().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional().default({}),
+  promotionCodes: z.array(z.string()).optional().default([]),
+  items: z.array(CartResponseItemSchema).optional().default([]),
+  shippingMethods: z.array(z.unknown()).optional().default([]),
+  totals: z.object({
+    discountTotal: z.number(),
+    shippingTotal: z.number(),
+    subtotal: z.number(),
+    taxTotal: z.number(),
+    total: z.number(),
+    warrantyTotal: z.number()
+  })
+});
+var CartCheckoutRequestSchema = z.object({
+  paymentMethodCode: z.string().min(1),
+  externalRef: z.string().min(1),
+  receiptUrl: z.string().min(1).optional()
+});
+var CartCheckoutPaymentActionSchema = z.object({
+  publicConfiguration: z.object({
+    publishableKey: z.string().nullable().optional(),
+    checkoutMode: z.string().nullable().optional(),
+    phoneNumber: z.string().nullable().optional(),
+    accountHolder: z.string().nullable().optional(),
+    qrImageUrl: z.string().nullable().optional()
+  }).passthrough().nullable().optional(),
+  url: z.string().nullable().optional(),
+  html: z.string().nullable().optional(),
+  clientSecret: z.string().nullable().optional(),
+  qrCode: z.string().nullable().optional(),
+  expiresAt: z.string().nullable().optional()
+}).passthrough();
+var CartCheckoutPaymentSchema = z.object({
+  transactionId: z.string(),
+  paymentMethodCode: z.string(),
+  providerId: z.string().nullable().optional(),
+  status: z.string(),
+  amount: z.number(),
+  reference: z.string(),
+  actionType: z.string(),
+  receiptUrl: z.string().nullable().optional(),
+  action: CartCheckoutPaymentActionSchema.nullable().optional()
+}).passthrough();
+var CartCheckoutResponseSchema = z.object({
+  publicKey: z.string().optional(),
+  publishableKey: z.string().optional(),
+  stripePublicKey: z.string().optional(),
+  clientSecret: z.string().optional(),
+  intentClientSecret: z.string().optional(),
+  orderId: z.coerce.string().optional(),
+  orderGroup: z.string().optional(),
+  orderIds: z.array(z.coerce.string()).optional(),
+  /** Payload de pago (embedded, redirect, etc.) */
+  payment: CartCheckoutPaymentSchema.optional(),
+  cart: z.unknown().optional()
+}).passthrough();
+var CartPaymentReceiptResponseSchema = z.object({
+  id: z.string(),
+  url: z.string()
+});
+var CartPaymentMethodSchema = z.object({
+  code: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  kind: z.string(),
+  isActive: z.boolean(),
+  isDefault: z.boolean(),
+  isManual: z.boolean(),
+  sortOrder: z.number(),
+  phoneNumber: z.string().nullable().optional(),
+  accountHolder: z.string().nullable().optional(),
+  qrImageUrl: z.string().nullable().optional()
+});
+var CartPaymentMethodsResponseSchema = z.object({
+  methods: z.array(CartPaymentMethodSchema)
+});
+var CartCheckoutReadResponseSchema = z.object({
+  cart: CartResponseSchema,
+  paymentMethods: CartPaymentMethodsResponseSchema
+});
+var ShippingRateSchema = z.object({
+  shippingMethodId: z.string(),
+  name: z.string(),
+  displayName: z.string().optional(),
+  type: z.string().optional(),
+  price: z.number(),
+  currency: z.string().optional(),
+  sortOrder: z.number().optional(),
+  rateId: z.string(),
+  description: z.string().nullable().optional(),
+  deliveryLocationId: z.string().nullable().optional(),
+  deliveryLocationName: z.string().nullable().optional(),
+  estimatedDeliveryDays: z.number().nullable().optional(),
+  serviceCode: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+var ShippingOptionGroupSchema = z.object({
+  sellerId: z.string(),
+  shippingProfileId: z.string().nullable().optional(),
+  orderAmount: z.number().optional(),
+  totalWeight: z.number().optional(),
+  itemIds: z.array(z.string()).optional(),
+  rates: z.array(ShippingRateSchema)
+}).passthrough();
+var ShippingOptionsResponseSchema = z.object({
+  groups: z.array(ShippingOptionGroupSchema)
+});
+var CartShippingMethodPutRequestSchema = z.object({
+  rateId: z.string().min(1),
+  shippingMethodId: z.string().min(1),
+  serviceCode: z.string().nullable().optional(),
+  sellerId: z.string().nullable().optional(),
+  shippingProfileId: z.string().nullable().optional(),
+  locationId: z.string().nullable().optional(),
+  pickupPointId: z.string().nullable().optional(),
+  scheduledDate: z.string().nullable().optional(),
+  scheduledTime: z.string().nullable().optional()
+});
+
+// src/core/services/cart.service.ts
+var CartService = class _CartService {
+  static instance;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_CartService.instance) {
+      _CartService.instance = new _CartService();
+    }
+    return _CartService.instance;
+  }
+  /**
+   * Obtiene el carrito actual (GET /v1/carts).
+   */
+  async getCart() {
+    const response = await apiClient.get(`/${STOREFRONT_API_PATH_PREFIX}/carts`);
+    return CartResponseSchema.parse(response);
+  }
+  /**
+   * Crea un carrito nuevo (POST /v1/carts).
+   */
+  async createCart(data) {
+    const payload = CartCreateRequestSchema.parse(data);
+    const response = await apiClient.post(`/${STOREFRONT_API_PATH_PREFIX}/carts`, payload);
+    return CartResponseSchema.parse(response);
+  }
+  /**
+   * Actualiza los datos del comprador del carrito actual (PATCH /v1/carts/buyer).
+   * El carrito se resuelve en backend vía contexto (token/guest), por eso no requiere cartId.
+   */
+  async updateBuyer(data) {
+    const payload = CartBuyerRequestSchema.parse(data);
+    const response = await apiClient.patch(`/${STOREFRONT_API_PATH_PREFIX}/carts/buyer`, payload);
+    return CartResponseSchema.parse(response);
+  }
+  /**
+   * Actualiza direcciones de envío y facturación del carrito (PATCH /v1/carts/addresses).
+   */
+  async updateAddresses(data) {
+    const payload = CartAddressesRequestSchema.parse(data);
+    const response = await apiClient.patch(`/${STOREFRONT_API_PATH_PREFIX}/carts/addresses`, payload);
+    return CartResponseSchema.parse(response);
+  }
+  /**
+   * Inicializa/obtiene detalles del método de pago para el checkout (POST /v1/carts/checkout).
+   * Usado para providers como Stripe (public key, client secret, etc).
+   */
+  async checkout(data) {
+    const payload = CartCheckoutRequestSchema.parse(data);
+    const response = await apiClient.post(`/${STOREFRONT_API_PATH_PREFIX}/carts/checkout`, payload);
+    return CartCheckoutResponseSchema.parse(response);
+  }
+};
+var cartService = CartService.getInstance();
+var defaultOptions = {
+  queries: {
+    staleTime: 60 * 1e3
+  }
+};
+function QueryProvider({ children, dehydratedState }) {
+  const queryClientRef = useRef(null);
+  const hydratedRef = useRef(false);
+  if (queryClientRef.current === null) {
+    queryClientRef.current = new QueryClient({ defaultOptions });
+  }
+  const queryClient = queryClientRef.current;
+  useEffect(() => {
+    if (dehydratedState && !hydratedRef.current) {
+      hydrate(queryClient, dehydratedState);
+      hydratedRef.current = true;
+    }
+  }, [queryClient, dehydratedState]);
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children });
+}
+var StorefrontAuthContext = createContext(null);
+function StorefrontAuthProvider({
+  authClient,
+  children
+}) {
+  return /* @__PURE__ */ jsx(StorefrontAuthContext.Provider, { value: authClient, children });
+}
+function useStorefrontAuthClient() {
+  const client = useContext(StorefrontAuthContext);
+  if (!client) {
+    throw new Error(
+      "useStorefrontAuthClient debe usarse dentro de StorefrontAuthProvider (o EcomiqProvider con authClient)."
+    );
+  }
+  return client;
+}
+function storefrontSessionEndsSoon(expiresAt, skewMs = 12e4) {
+  if (!expiresAt) return false;
+  return Date.now() + skewMs >= expiresAt.getTime();
+}
+var storefrontAccessTokenNeedsRefresh = storefrontSessionEndsSoon;
+function parseStorefrontSessionExpires(at) {
+  if (!at) return void 0;
+  if (at instanceof Date) return Number.isNaN(at.getTime()) ? void 0 : at;
+  if (typeof at === "string") {
+    const d = new Date(at);
+    return Number.isNaN(d.getTime()) ? void 0 : d;
+  }
+  return void 0;
+}
+function mapSessionUser(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const u = raw;
+  const explicitFirst = typeof u.firstName === "string" ? u.firstName : typeof u.given_name === "string" ? u.given_name : "";
+  const explicitLast = typeof u.lastName === "string" ? u.lastName : typeof u.family_name === "string" ? u.family_name : "";
+  if (explicitFirst || explicitLast) {
+    return {
+      id: String(u.id ?? ""),
+      email: String(u.email ?? ""),
+      firstName: explicitFirst,
+      lastName: explicitLast,
+      name: typeof u.name === "string" ? u.name : void 0,
+      phone: typeof u.phone === "string" ? u.phone : void 0
+    };
+  }
+  const emailLocal = String(u.email ?? "").split("@")[0] ?? "";
+  const full = typeof u.name === "string" ? u.name.trim() : emailLocal.trim();
+  const parts = full ? full.split(/\s+/) : [];
+  return {
+    id: String(u.id ?? ""),
+    email: String(u.email ?? ""),
+    firstName: parts[0] ?? "",
+    lastName: parts.slice(1).join(" "),
+    name: typeof u.name === "string" ? u.name : void 0,
+    phone: typeof u.phone === "string" ? u.phone : void 0
+  };
+}
+function useStorefrontSession() {
+  const authClient = useStorefrontAuthClient();
+  const session = authClient.useSession();
+  const user = mapSessionUser(session.data?.user);
+  const storefrontSession = session.data?.session;
+  const sessionExpiresAt = parseStorefrontSessionExpires(storefrontSession?.expiresAt);
+  return {
+    session,
+    user,
+    sessionExpiresAt,
+    isAuthenticated: Boolean(session.data?.user),
+    isPending: session.isPending,
+    error: session.error,
+    refetch: session.refetch,
+    signOut: () => authClient.signOut()
+  };
+}
+
+// src/react/hooks/use-user.ts
+function useUser() {
+  return {};
+}
+
+// src/react/hooks/use-config.ts
+function useConfig() {
+  return {};
+}
+var useProducts = (storeId) => {
+  if (storeId) {
+    apiClient.setStoreId(storeId);
+  }
+  const useProductsList = (filters) => {
+    return useQuery({
+      queryKey: ["products", filters],
+      queryFn: () => productService.getProducts(filters),
+      enabled: !!storeId
+    });
+  };
+  const useInfiniteProducts = (filters) => {
+    return useInfiniteQuery({
+      queryKey: ["products", "infinite", filters],
+      queryFn: ({ pageParam = 1 }) => productService.getProducts({ ...filters, page: pageParam }),
+      getNextPageParam: (lastPage) => lastPage.meta.hasNextPage ? lastPage.meta.page + 1 : void 0,
+      initialPageParam: 1,
+      enabled: !!storeId
+    });
+  };
+  const useProduct = (id) => {
+    return useQuery({
+      queryKey: ["product", id],
+      queryFn: () => productService.getProduct(id),
+      enabled: !!id && !!storeId
+    });
+  };
+  const useProductBySlug = (slug) => {
+    return useQuery({
+      queryKey: ["product", "slug", slug],
+      queryFn: () => productService.getProductBySlug(slug),
+      enabled: !!slug && !!storeId
+    });
+  };
+  const useSearchProducts = (query, filters) => {
+    return useQuery({
+      queryKey: ["products", "search", query, filters],
+      queryFn: () => productService.searchProducts(query, filters),
+      enabled: !!query && !!storeId
+    });
+  };
+  const useProductsByCategory = (category, filters) => {
+    return useQuery({
+      queryKey: ["products", "category", category, filters],
+      queryFn: () => productService.getProductsByCategory(category, filters),
+      enabled: !!category && !!storeId
+    });
+  };
+  const useProductsOnSale = (filters) => {
+    return useQuery({
+      queryKey: ["products", "sale", filters],
+      queryFn: () => productService.getProductsOnSale(filters),
+      enabled: !!storeId
+    });
+  };
+  const useProductsInStock = (filters) => {
+    return useQuery({
+      queryKey: ["products", "stock", filters],
+      queryFn: () => productService.getProductsInStock(filters),
+      enabled: !!storeId
+    });
+  };
+  const useRefreshProducts = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+      mutationFn: () => productService.getProducts(),
+      onSuccess: (data) => {
+        queryClient.setQueryData(["products"], data);
+      }
+    });
+  };
+  const useStorefrontProductsList = (params) => {
+    return useQuery({
+      queryKey: ["storefront", "products", params],
+      queryFn: () => productService.getStorefrontProducts(params),
+      enabled: !!storeId
+    });
+  };
+  const useStorefrontInfiniteProducts = (params) => {
+    return useInfiniteQuery({
+      queryKey: ["storefront", "products", "infinite", params],
+      queryFn: ({ pageParam = 1 }) => productService.getStorefrontProducts({ ...params, page: pageParam }),
+      getNextPageParam: (lastPage) => lastPage.pageIndex < lastPage.totalPages ? lastPage.pageIndex + 1 : void 0,
+      initialPageParam: 1,
+      enabled: !!storeId
+    });
+  };
+  const useRefreshStorefrontProducts = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+      mutationFn: (params) => productService.getStorefrontProducts(params),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["storefront", "products"] });
+      }
+    });
+  };
+  return {
+    useProductsList,
+    useInfiniteProducts,
+    useProduct,
+    useProductBySlug,
+    useSearchProducts,
+    useProductsByCategory,
+    useProductsOnSale,
+    useProductsInStock,
+    useRefreshProducts,
+    useStorefrontProductsList,
+    useStorefrontInfiniteProducts,
+    useRefreshStorefrontProducts
+  };
+};
+var useCollections = (storeId) => {
+  if (storeId) {
+    apiClient.setStoreId(storeId);
+  }
+  const useStorefrontCollectionsList = () => {
+    return useQuery({
+      queryKey: ["storefront", "collections"],
+      queryFn: () => collectionService.getStorefrontCollections(),
+      enabled: !!storeId
+    });
+  };
+  const useStorefrontCollectionBySlug = (slug) => {
+    return useQuery({
+      queryKey: ["storefront", "collection", "slug", slug],
+      queryFn: () => collectionService.getStorefrontCollectionBySlug(slug),
+      enabled: !!slug && !!storeId
+    });
+  };
+  const useRefreshStorefrontCollections = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+      mutationFn: () => collectionService.getStorefrontCollections(),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["storefront", "collections"] });
+      }
+    });
+  };
+  return {
+    useStorefrontCollectionsList,
+    useStorefrontCollectionBySlug,
+    useRefreshStorefrontCollections
+  };
+};
+var usePages = (storeId) => {
+  if (storeId) {
+    apiClient.setStoreId(storeId);
+  }
+  const usePagesList = () => {
+    return useQuery({
+      queryKey: ["storefront", "pages"],
+      queryFn: () => pageService.getPages(),
+      enabled: !!storeId
+    });
+  };
+  const usePageBySlug = (slug) => {
+    return useQuery({
+      queryKey: ["storefront", "page", "slug", slug],
+      queryFn: () => pageService.getPageBySlug(slug),
+      enabled: !!slug && !!storeId
+    });
+  };
+  const useRefreshPages = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+      mutationFn: () => pageService.getPages(),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["storefront", "pages"] });
+      }
+    });
+  };
+  return {
+    usePagesList,
+    usePageBySlug,
+    useRefreshPages
+  };
+};
+var useCartAddresses = () => {
+  return useMutation({
+    mutationFn: (data) => cartService.updateAddresses(data)
+  });
+};
+var useCartGet = () => {
+  return useQuery({
+    queryKey: ["cart"],
+    queryFn: () => cartService.getCart()
+  });
+};
+var useCartCreate = () => {
+  return useMutation({
+    mutationFn: (data) => cartService.createCart(data)
+  });
+};
+function useStorefrontGeoInei(storeId, form) {
+  const [departments, setDepartments] = useState([]);
+  const [provinces, setProvinces] = useState([]);
+  const [districts, setDistricts] = useState([]);
+  const [loadingDepartments, setLoadingDepartments] = useState(false);
+  const [loadingProvinces, setLoadingProvinces] = useState(false);
+  const [loadingDistricts, setLoadingDistricts] = useState(false);
+  const prevDepartmentCode = useRef(void 0);
+  const prevProvinceCode = useRef(void 0);
+  const countryCode = (form.watch("countryCode") || "PE").toUpperCase();
+  const departmentCode = form.watch("departmentCode");
+  const provinceCode = form.watch("provinceCode");
+  const districtCode = form.watch("districtCode");
+  const storeRequestHeaders = useMemo(() => {
+    const id = storeId.trim();
+    if (!id) return null;
+    return { "X-Store-Id": id };
+  }, [storeId]);
+  const selectedDepartment = useMemo(
+    () => departments.find((d) => d.code === departmentCode),
+    [departments, departmentCode]
+  );
+  const selectedProvince = useMemo(
+    () => provinces.find((p) => p.code === provinceCode),
+    [provinces, provinceCode]
+  );
+  const selectedDistrict = useMemo(
+    () => districts.find((d) => d.code === districtCode),
+    [districts, districtCode]
+  );
+  useEffect(() => {
+    let active = true;
+    if (!storeRequestHeaders) {
+      setDepartments([]);
+      setLoadingDepartments(false);
+      return () => {
+        active = false;
+      };
+    }
+    setLoadingDepartments(true);
+    loadStorefrontGeoDepartments(storeRequestHeaders).then((items) => {
+      if (!active) return;
+      setDepartments(items);
+    }).finally(() => {
+      if (!active) return;
+      setLoadingDepartments(false);
+    });
+    return () => {
+      active = false;
+    };
+  }, [storeRequestHeaders]);
+  useEffect(() => {
+    const prev = prevDepartmentCode.current;
+    const dept = departmentCode;
+    const departmentChanged = prev !== void 0 && prev !== dept;
+    prevDepartmentCode.current = dept;
+    if (!dept) {
+      setProvinces([]);
+      setDistricts([]);
+      prevProvinceCode.current = "";
+      prevDepartmentCode.current = "";
+      return;
+    }
+    if (!storeRequestHeaders) {
+      setProvinces([]);
+      return;
+    }
+    if (departmentChanged) {
+      form.setValue("provinceCode", "", { shouldValidate: true });
+      form.setValue("provinceName", "", { shouldValidate: true });
+      form.setValue("districtCode", "", { shouldValidate: true });
+      form.setValue("districtName", "", { shouldValidate: true });
+      setDistricts([]);
+      prevProvinceCode.current = "";
+    }
+    if (selectedDepartment?.name) {
+      form.setValue("departmentName", selectedDepartment.name, {
+        shouldValidate: true
+      });
+    }
+    let active = true;
+    setLoadingProvinces(true);
+    fetchStorefrontGeoProvinces(storeRequestHeaders, countryCode, dept).then((items) => {
+      if (!active) return;
+      setProvinces(items);
+    }).catch(() => {
+      if (!active) return;
+      setProvinces([]);
+    }).finally(() => {
+      if (!active) return;
+      setLoadingProvinces(false);
+    });
+    return () => {
+      active = false;
+    };
+  }, [departmentCode, countryCode, selectedDepartment?.name, form, storeRequestHeaders]);
+  useEffect(() => {
+    const prev = prevProvinceCode.current;
+    const prov = provinceCode;
+    const provinceChanged = prev !== void 0 && prev !== prov;
+    prevProvinceCode.current = prov;
+    if (!prov) {
+      setDistricts([]);
+      prevProvinceCode.current = "";
+      return;
+    }
+    if (!storeRequestHeaders) {
+      setDistricts([]);
+      return;
+    }
+    if (provinceChanged) {
+      form.setValue("districtCode", "", { shouldValidate: true });
+      form.setValue("districtName", "", { shouldValidate: true });
+    }
+    if (selectedProvince?.name) {
+      form.setValue("provinceName", selectedProvince.name, {
+        shouldValidate: true
+      });
+    }
+    let active = true;
+    setLoadingDistricts(true);
+    fetchStorefrontGeoDistricts(storeRequestHeaders, countryCode, prov).then((items) => {
+      if (!active) return;
+      setDistricts(items);
+    }).catch(() => {
+      if (!active) return;
+      setDistricts([]);
+    }).finally(() => {
+      if (!active) return;
+      setLoadingDistricts(false);
+    });
+    return () => {
+      active = false;
+    };
+  }, [provinceCode, countryCode, selectedProvince?.name, form, storeRequestHeaders]);
+  useEffect(() => {
+    if (selectedDistrict?.name) {
+      form.setValue("districtName", selectedDistrict.name, {
+        shouldValidate: true
+      });
+    }
+  }, [selectedDistrict?.name, form]);
+  return {
+    departments,
+    provinces,
+    districts,
+    loadingDepartments,
+    loadingProvinces,
+    loadingDistricts,
+    departmentCode,
+    provinceCode,
+    districtCode,
+    selectedDepartment,
+    selectedProvince,
+    selectedDistrict,
+    storeRequestHeaders
+  };
+}
+var useStore = create()(
+  (set) => ({
+    data: null,
+    drawers: {
+      cart: false,
+      search: false,
+      menu: false,
+      filter: false
+    },
+    openDrawer: (drawer) => set((state) => ({
+      drawers: {
+        ...state.drawers,
+        [drawer]: true
+      }
+    })),
+    closeDrawer: (drawer) => set((state) => ({
+      drawers: {
+        ...state.drawers,
+        [drawer]: false
+      }
+    })),
+    toggleDrawer: (drawer) => set((state) => ({
+      drawers: {
+        ...state.drawers,
+        [drawer]: !state.drawers[drawer]
+      }
+    })),
+    closeAllDrawers: () => set((state) => ({
+      drawers: Object.keys(state.drawers).reduce(
+        (acc, key) => ({ ...acc, [key]: false }),
+        {}
+      )
+    })),
+    modals: {
+      login: false,
+      signup: false
+    },
+    openModal: (modal) => set((state) => ({
+      modals: {
+        ...state.modals,
+        login: false,
+        signup: false,
+        [modal]: true
+      }
+    })),
+    closeModal: (modal) => set((state) => ({
+      modals: {
+        ...state.modals,
+        login: false,
+        signup: false,
+        [modal]: false
+      }
+    })),
+    toggleModal: (modal) => set((state) => ({
+      modals: {
+        ...state.modals,
+        [modal]: !state.modals[modal]
+      }
+    })),
+    closeAllModals: () => set((state) => ({
+      modals: Object.keys(state.modals).reduce(
+        (acc, key) => ({ ...acc, [key]: false }),
+        {}
+      )
+    }))
+  })
+);
+var useCart = create()(
+  persist(
+    (set) => ({
+      count: 0,
+      cart: [],
+      cartTokenId: null,
+      setCartTokenId: (token) => set((state) => ({ ...state, cartTokenId: token })),
+      checkoutStep: null,
+      setCheckoutStep: (step) => set((state) => ({ ...state, checkoutStep: step })),
+      checkoutCustomerLocal: null,
+      setCheckoutCustomerLocal: (customer) => set((state) => {
+        if (!state.cartTokenId) return state;
+        return {
+          checkoutCustomerLocal: {
+            cartTokenId: state.cartTokenId,
+            customer
+          }
+        };
+      }),
+      clearCheckoutCustomerLocal: () => set(() => ({ checkoutCustomerLocal: null })),
+      addCart: (item) => set((state) => {
+        const existingItem = state.cart.find(
+          (cartItem) => cartItem.id === item.id
+        );
+        if (existingItem) {
+          const newQuantity = Math.max(0, existingItem.quantity) + 1;
+          const cart2 = state.cart.map(
+            (cartItem) => cartItem.id === item.id ? { ...cartItem, quantity: newQuantity } : cartItem
+          );
+          const count2 = cart2.reduce((sum, i) => sum + Math.max(0, i.quantity), 0);
+          return { count: count2, cart: cart2 };
+        }
+        const newItem = {
+          ...item,
+          quantity: Math.max(1, Math.max(0, item.quantity ?? 1))
+        };
+        const cart = [...state.cart, newItem];
+        const count = cart.reduce((sum, i) => sum + Math.max(0, i.quantity), 0);
+        return { count, cart };
+      }),
+      removeCart: (id) => set((state) => {
+        const existingItem = state.cart.find((item) => item.id === id);
+        if (!existingItem) return state;
+        if (existingItem.quantity > 1) {
+          const newQuantity = Math.max(0, existingItem.quantity - 1);
+          const cart2 = state.cart.map(
+            (cartItem) => cartItem.id === id ? { ...cartItem, quantity: newQuantity } : cartItem
+          );
+          const count2 = cart2.reduce((sum, i) => sum + Math.max(0, i.quantity), 0);
+          return { count: count2, cart: cart2 };
+        }
+        const cart = state.cart.filter((item) => item.id !== id);
+        const count = Math.max(0, cart.reduce((sum, i) => sum + Math.max(0, i.quantity), 0));
+        return { count, cart };
+      }),
+      clearCartSession: () => set(() => ({
+        count: 0,
+        cart: [],
+        cartTokenId: null,
+        checkoutStep: null,
+        checkoutCustomerLocal: null
+      }))
+    }),
+    { name: "cart-storage" }
+  )
+);
+
+// src/react/auth/ecomiq-oauth-password-constants.ts
+var PLUGIN_ID = "ecomiq-oauth-password";
+var ECOMIQ_OAUTH_TOKEN_URL = "https://auth.ecomiq.pe/connect/token";
+var ECOMIQ_OAUTH_USERINFO_URL = "https://auth.ecomiq.pe/connect/userinfo";
+var tokenResponseSchema = z.object({
+  access_token: z.string().min(1),
+  token_type: z.string().optional(),
+  /** Segundos hasta expiración (Ecomiq envía ej. `86399`). Sincroniza la sesión Better Auth con el bearer. */
+  expires_in: z.coerce.number().int().positive().optional()
+});
+var userInfoSchema = z.object({
+  sub: z.string(),
+  email: z.string().email().optional(),
+  family_name: z.string().optional(),
+  given_name: z.string().optional(),
+  iss: z.string().optional(),
+  aud: z.union([z.string(), z.array(z.string())]).optional()
+});
+var signInBody = z.object({
+  email: z.string().email(),
+  password: z.string().min(1),
+  callbackURL: z.string().optional(),
+  rememberMe: z.boolean().optional().default(true)
+});
+
+// src/react/auth/ecomiq-oauth-password-plugin.ts
+function ecomiqOAuthPassword() {
+  const secureCookie = true;
+  const clearStorefrontOAuthCookieMiddleware = createAuthMiddleware(async (ctx) => {
+    ctx.setCookie(STOREFRONT_ECOMIQ_OAUTH_COOKIE_NAME, "", {
+      path: STOREFRONT_ECOMIQ_OAUTH_COOKIE_PATH,
+      httpOnly: true,
+      sameSite: "lax",
+      secure: secureCookie,
+      maxAge: 0
+    });
+  });
+  return {
+    id: PLUGIN_ID,
+    schema: {
+      user: {
+        fields: {
+          firstName: { type: "string", required: false },
+          lastName: { type: "string", required: false },
+          phone: { type: "string", required: false }
+        }
+      }
+    },
+    hooks: {
+      after: [
+        {
+          matcher: (hookCtx) => hookCtx.path === "/sign-out",
+          handler: clearStorefrontOAuthCookieMiddleware
+        }
+      ]
+    },
+    endpoints: {
+      signIn: createAuthEndpoint(
+        "/ecomiq-oauth/sign-in",
+        {
+          method: "POST",
+          use: [formCsrfMiddleware],
+          body: signInBody
+        },
+        async (ctx) => {
+          const { email: loginEmail, password, callbackURL, rememberMe } = ctx.body;
+          const tokens = await exchangePasswordGrant(loginEmail, password, {
+            identityScope: ctx.getHeader("x-Identity-Scope"),
+            tenantId: ctx.getHeader("x-Tenant-Id"),
+            storeId: ctx.getHeader("x-Store-Id")
+          });
+          const profile = await fetchUserInfo(tokens.access_token);
+          const profileEmail = profile.email?.toLowerCase().trim();
+          const canonicalEmail = profileEmail ?? loginEmail.toLowerCase().trim();
+          if (profileEmail && profileEmail !== loginEmail.toLowerCase().trim()) {
+            throw APIError.from("UNAUTHORIZED", {
+              code: "ECOMIQ_EMAIL_MISMATCH",
+              message: "El correo del perfil OAuth no coincide con el inicio de sesi\xF3n"
+            });
+          }
+          const displayName = displayNameFromUserInfo(profile, canonicalEmail);
+          const existing = await ctx.context.internalAdapter.findUserByEmail(canonicalEmail);
+          let user = existing?.user;
+          if (!user) {
+            user = await ctx.context.internalAdapter.createUser({
+              email: canonicalEmail,
+              name: displayName,
+              emailVerified: true
+            });
+          } else if (user.name !== displayName) {
+            await ctx.context.internalAdapter.updateUser(user.id, { name: displayName });
+            user = { ...user, name: displayName };
+          }
+          const oauthSessionExpires = tokens.expires_in !== void 0 && tokens.expires_in > 0 ? new Date(Date.now() + tokens.expires_in * 1e3) : void 0;
+          const session = await ctx.context.internalAdapter.createSession(
+            user.id,
+            rememberMe === false,
+            oauthSessionExpires ? { expiresAt: oauthSessionExpires } : {},
+            Boolean(oauthSessionExpires)
+          );
+          if (!session) {
+            throw APIError.from("INTERNAL_SERVER_ERROR", {
+              code: "ECOMIQ_SESSION_FAILED",
+              message: "No se pudo crear la sesi\xF3n"
+            });
+          }
+          await setSessionCookie(ctx, { session, user }, rememberMe === false);
+          const oauthMaxAgeSec = oauthSessionExpires !== void 0 ? Math.max(60, Math.ceil((oauthSessionExpires.getTime() - Date.now()) / 1e3)) : tokens.expires_in !== void 0 && tokens.expires_in > 0 ? tokens.expires_in : 60 * 60 * 24;
+          await ctx.setCookie(STOREFRONT_ECOMIQ_OAUTH_COOKIE_NAME, tokens.access_token, {
+            path: STOREFRONT_ECOMIQ_OAUTH_COOKIE_PATH,
+            httpOnly: true,
+            sameSite: "lax",
+            secure: secureCookie,
+            maxAge: oauthMaxAgeSec
+          });
+          if (callbackURL) ctx.setHeader("Location", callbackURL);
+          return ctx.json({
+            redirect: !!callbackURL,
+            token: session.token,
+            url: callbackURL,
+            user: parseUserOutput(ctx.context.options, user)
+          });
+        }
+      )
+    }
+  };
+}
+function displayNameFromUserInfo(profile, fallbackEmail) {
+  const parts = [profile.given_name?.trim(), profile.family_name?.trim()].filter(Boolean);
+  const joined = parts.join(" ").trim();
+  if (joined) return joined;
+  return fallbackEmail.split("@")[0] || "Cliente";
+}
+async function fetchUserInfo(accessToken) {
+  const res = await fetch(ECOMIQ_OAUTH_USERINFO_URL, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      accept: "application/json"
+    }
+  });
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+    throw APIError.from("UNAUTHORIZED", {
+      code: "ECOMIQ_USERINFO_INVALID_BODY",
+      message: "Respuesta inv\xE1lida del endpoint userinfo"
+    });
+  }
+  if (!res.ok) {
+    const err = json;
+    throw APIError.from("UNAUTHORIZED", {
+      code: "ECOMIQ_USERINFO_REJECTED",
+      message: err.error_description ?? err.error ?? "No se pudo obtener el perfil del usuario"
+    });
+  }
+  const parsed = userInfoSchema.safeParse(json);
+  if (!parsed.success) {
+    throw APIError.from("UNAUTHORIZED", {
+      code: "ECOMIQ_USERINFO_SHAPE",
+      message: "Perfil OAuth con formato inv\xE1lido"
+    });
+  }
+  return parsed.data;
+}
+async function exchangePasswordGrant(username, password, context) {
+  const clientId = process.env.ECOMIQ_AUTH_CLIENT_ID ?? "";
+  const clientSecret = process.env.ECOMIQ_AUTH_CLIENT_SECRET ?? "";
+  const scope = process.env.ECOMIQ_AUTH_SCOPE ?? "";
+  if (!clientId || !clientSecret) {
+    throw APIError.from("INTERNAL_SERVER_ERROR", {
+      code: "ECOMIQ_AUTH_NOT_CONFIGURED",
+      message: "OAuth Ecomiq no configurado: ECOMIQ_AUTH_CLIENT_ID y ECOMIQ_AUTH_CLIENT_SECRET."
+    });
+  }
+  const body = new URLSearchParams({
+    grant_type: "password",
+    username,
+    password,
+    scope,
+    client_id: clientId,
+    client_secret: clientSecret
+  });
+  const identityScope = context.identityScope;
+  const tenantId = context.tenantId;
+  const storeId = context.storeId;
+  const headers = new Headers({
+    "content-type": "application/x-www-form-urlencoded",
+    accept: "application/json"
+  });
+  if (identityScope?.trim()) {
+    headers.set("x-Identity-Scope", identityScope.trim());
+  }
+  if (tenantId?.trim()) {
+    headers.set("x-Tenant-Id", tenantId.trim());
+  }
+  if (storeId?.trim()) {
+    headers.set("x-Store-Id", storeId.trim());
+  }
+  let res;
+  let text;
+  try {
+    res = await fetch(ECOMIQ_OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers,
+      body
+    });
+    text = await res.text();
+  } catch (e) {
+    throw mapTokenEndpointFetchFailure(e);
+  }
+  const json = safeParseJson(text);
+  if (!res.ok) {
+    throwBadRequestFromOAuth(json, res.statusText || text || `HTTP ${res.status}`);
+  }
+  const parsed = tokenResponseSchema.safeParse(json);
+  if (!parsed.success) {
+    throwBadRequestFromOAuth(json, "Token de acceso no recibido");
+  }
+  return parsed.data;
+}
+function safeParseJson(text) {
+  try {
+    return text ? JSON.parse(text) : {};
+  } catch {
+    return {};
+  }
+}
+function throwBadRequestFromOAuth(payload, fallbackMessage) {
+  const err = payload;
+  const errorCode = typeof err.error === "string" && err.error.trim() ? err.error.trim() : "invalid_grant";
+  const errorMessage = typeof err.error_description === "string" && err.error_description.trim() ? err.error_description.trim() : typeof err.error === "string" && err.error.trim() ? err.error.trim() : fallbackMessage.trim() || "Credenciales invalidas.";
+  throw APIError.from("BAD_REQUEST", {
+    code: errorCode,
+    message: errorMessage.slice(0, 500)
+  });
+}
+function mapTokenEndpointFetchFailure(e) {
+  const codes = collectNetworkErrorCodes(e);
+  const msg = e instanceof Error ? e.message : String(e);
+  const isDnsError = codes.some((c) => c === "ENOTFOUND" || c === "EAI_AGAIN");
+  if (isDnsError) {
+    throw APIError.from("BAD_GATEWAY", {
+      code: "ECOMIQ_AUTH_DNS",
+      message: "No se pudo resolver el servidor de autenticacion."
+    });
+  }
+  const isConnectionRefused = codes.includes("ECONNREFUSED");
+  if (isConnectionRefused) {
+    throw APIError.from("BAD_GATEWAY", {
+      code: "ECOMIQ_AUTH_REFUSED",
+      message: "Conexion rechazada al servidor de autenticacion."
+    });
+  }
+  const looksLikeAbortOrSocketClose = codes.some(
+    (c) => ["UND_ERR_SOCKET", "ECONNRESET", "EPIPE", "ECONNABORTED"].includes(c)
+  ) || /terminated|abort|closed|FIN|socket/i.test(msg);
+  if (looksLikeAbortOrSocketClose) {
+    throwBadRequestFromOAuth({}, "Credenciales invalidas o conexion cerrada por el servidor.");
+  }
+  throw APIError.from("INTERNAL_SERVER_ERROR", {
+    code: "ECOMIQ_AUTH_REQUEST_FAILED",
+    message: msg.slice(0, 280) || "Error al contactar el servidor de autenticacion."
+  });
+}
+function collectNetworkErrorCodes(e) {
+  const out = [];
+  const visit = (x) => {
+    if (!x || typeof x !== "object") return;
+    const code = "code" in x && typeof x.code === "string" ? x.code : void 0;
+    if (code) out.push(code);
+    if ("cause" in x && x.cause) {
+      visit(x.cause);
+    }
+  };
+  visit(e);
+  return out;
+}
+
+// src/react/auth/ecomiq-oauth-password-client.ts
+function ecomiqOAuthPasswordClient() {
+  return {
+    id: PLUGIN_ID,
+    pathMethods: {
+      "/ecomiq-oauth/sign-in": "POST"
+    },
+    atomListeners: [
+      {
+        matcher: (path) => path === "/ecomiq-oauth/sign-in",
+        signal: "$sessionSignal"
+      }
+    ]
+  };
+}
+
+// src/react/components/cms-sections/utils.ts
+var PRODUCT_SORTS = /* @__PURE__ */ new Set([
+  "price_asc",
+  "price_desc",
+  "name_asc",
+  "name_desc",
+  "newest"
+]);
+function orderedBlocks(blocks) {
+  return [...blocks ?? []].sort((a, b) => a.order - b.order);
+}
+function getCmsSectionKey(section, index) {
+  return section.id ?? `${canonicalSectionType(section.type)}-${section.order}-${index}`;
+}
+function getCmsBlockKey(block, index) {
+  return block.id ?? `${block.type}-${block.order}-${index}`;
+}
+function canonicalSectionType(type) {
+  if (type === "page-hero") {
+    return "hero";
+  }
+  if (type === "featured-products") {
+    return "product-list";
+  }
+  return type;
+}
+function storefrontHref(value) {
+  const href = value.trim();
+  if (!href) {
+    return "#";
+  }
+  if (href === "#" || href.startsWith("http://") || href.startsWith("https://") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+    return href;
+  }
+  if (href === "/") {
+    return "/store";
+  }
+  if (href.startsWith("/store") || href.startsWith("/product")) {
+    return href;
+  }
+  if (href.startsWith("/collections") || href.startsWith("/pages") || href.startsWith("/account")) {
+    return `/store${href}`;
+  }
+  return href;
+}
+function sectionTitleContent(section) {
+  return settingContent(section.settings, "title") || settingContent(section.settings, "name");
+}
+function settingString(settings, key) {
+  const value = settings?.[key];
+  return typeof value === "string" ? value : "";
+}
+function settingContent(settings, key) {
+  const value = settings?.[key];
+  if (typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  if (value == null || typeof value === "boolean") {
+    return "";
+  }
+  return value;
+}
+function settingNumber(settings, key, fallback) {
+  const value = settings?.[key];
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+}
+function layoutChildren(settings, key) {
+  const children = settings.children;
+  if (typeof children !== "object" || children === null || Array.isArray(children)) {
+    return [];
+  }
+  const value = children[key];
+  return Array.isArray(value) ? value : [];
+}
+function layoutPadding(value) {
+  switch (value) {
+    case "none":
+      return "py-0";
+    case "small":
+      return "py-6";
+    case "large":
+      return "py-16";
+    default:
+      return "py-10";
+  }
+}
+function layoutMaxWidth(value) {
+  switch (value) {
+    case "full":
+      return "max-w-none";
+    case "narrow":
+      return "max-w-3xl";
+    default:
+      return "max-w-7xl";
+  }
+}
+function layoutBackground(value) {
+  switch (value) {
+    case "muted":
+      return "bg-neutral-50";
+    case "dark":
+      return "bg-neutral-950 text-white";
+    default:
+      return "bg-white";
+  }
+}
+function layoutGap(value) {
+  switch (value) {
+    case "none":
+      return "gap-0";
+    case "small":
+      return "gap-3";
+    case "large":
+      return "gap-8";
+    default:
+      return "gap-5";
+  }
+}
+function layoutAlign(value) {
+  switch (value) {
+    case "start":
+      return "items-start";
+    case "center":
+      return "items-center";
+    case "end":
+      return "items-end";
+    default:
+      return "items-stretch";
+  }
+}
+function layoutJustify(value) {
+  switch (value) {
+    case "center":
+      return "justify-center";
+    case "end":
+      return "justify-end";
+    case "between":
+      return "justify-between";
+    default:
+      return "justify-start";
+  }
+}
+function productSortValue(value) {
+  return PRODUCT_SORTS.has(value) ? value : "newest";
+}
+function sanitizeHtml(html) {
+  return html.replace(/<script[\s\S]*?>[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?>[\s\S]*?<\/style>/gi, "").replace(/<(iframe|object|embed|link|meta)[\s\S]*?>/gi, "").replace(/\son\w+\s*=\s*(['"]).*?\1/gi, "").replace(/\s(href|src)\s*=\s*(['"])\s*javascript:[\s\S]*?\2/gi, "");
+}
+var DEFAULT_CMS_IMAGE_URL = "data:image/svg+xml;charset=UTF-8," + encodeURIComponent(`
+    <svg xmlns="http://www.w3.org/2000/svg" width="640" height="360" viewBox="0 0 640 360">
+      <rect width="640" height="360" fill="#f4f4f5"/>
+      <rect x="40" y="36" width="560" height="288" rx="20" fill="#ffffff" stroke="#d4d4d8"/>
+      <path d="M148 246l102-102 78 78 48-48 120 120H148z" fill="#d4d4d8"/>
+      <circle cx="456" cy="118" r="32" fill="#e4e4e7"/>
+    </svg>
+  `);
+function SectionHeading({ section }) {
+  const title = sectionTitleContent(section);
+  const subtitle = settingContent(section.settings, "subtitle");
+  if (!title && !subtitle) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "mb-6", children: [
+    title ? /* @__PURE__ */ jsx("h2", { className: "text-2xl font-semibold tracking-tight text-neutral-950", children: title }) : null,
+    subtitle ? /* @__PURE__ */ jsx("p", { className: "mt-2 text-sm text-neutral-600", children: subtitle }) : null
+  ] });
+}
+function EmptyState({ children }) {
+  return /* @__PURE__ */ jsx("p", { className: "rounded-lg border border-dashed p-6 text-center text-sm text-neutral-500", children });
+}
+function DefaultLink({ href, className, children }) {
+  return /* @__PURE__ */ jsx("a", { href, className, children });
+}
+function CmsImage({
+  src,
+  fallbackSrc = DEFAULT_CMS_IMAGE_URL,
+  onError,
+  ...props
+}) {
+  const imageSrc = src?.trim() || fallbackSrc;
+  return /* @__PURE__ */ jsx(
+    "img",
+    {
+      src: imageSrc,
+      onError: (event) => {
+        onError?.(event);
+        const image = event.currentTarget;
+        if (image.dataset.cmsFallback === "true") {
+          return;
+        }
+        image.dataset.cmsFallback = "true";
+        image.src = fallbackSrc;
+      },
+      ...props
+    }
+  );
+}
+function RichTextSection({ section }) {
+  const html = settingString(section.settings, "html") || settingString(section.settings, "content") || settingString(section.settings, "richText");
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-10", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    html ? /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "prose prose-neutral max-w-none",
+        dangerouslySetInnerHTML: { __html: sanitizeHtml(html) }
+      }
+    ) : null
+  ] });
+}
+function CustomHtmlSection({ section }) {
+  const html = settingString(section.settings, "html") || settingString(section.settings, "content");
+  if (!html) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "section",
+    {
+      className: "cms-custom-html",
+      dangerouslySetInnerHTML: { __html: sanitizeHtml(html) }
+    }
+  );
+}
+function FloatingBlockSection({
+  section,
+  linkComponent: LinkComponent
+}) {
+  const settings = section.settings ?? {};
+  const title = settingContent(settings, "title");
+  const text = settingContent(settings, "text");
+  const imageUrl = settingString(settings, "imageUrl");
+  const linkText = settingContent(settings, "linkText");
+  const linkUrl = storefrontHref(settingString(settings, "linkUrl"));
+  const x = boundedPercent(settingNumber(settings, "x", 8));
+  const y = boundedPercent(settingNumber(settings, "y", 12));
+  const width = Math.min(
+    Math.max(boundedPercent(settingNumber(settings, "width", 28)), 12),
+    90
+  );
+  const zIndex = Math.max(Math.round(settingNumber(settings, "zIndex", 20)), 1);
+  if (!title && !text && !imageUrl) {
+    return null;
+  }
+  const content = /* @__PURE__ */ jsxs("div", { className: "overflow-hidden rounded-lg border border-black/10 bg-white text-neutral-950 shadow-lg", children: [
+    imageUrl ? /* @__PURE__ */ jsx("div", { className: "aspect-[16/9] bg-neutral-100", children: /* @__PURE__ */ jsx(
+      CmsImage,
+      {
+        src: imageUrl,
+        alt: "",
+        className: "h-full w-full object-cover",
+        loading: "lazy"
+      }
+    ) }) : null,
+    /* @__PURE__ */ jsxs("div", { className: "p-4", children: [
+      title ? /* @__PURE__ */ jsx("p", { className: "text-base font-semibold leading-6", children: title }) : null,
+      text ? /* @__PURE__ */ jsx("p", { className: "mt-1 text-sm leading-5 text-neutral-600", children: text }) : null,
+      linkText && linkUrl !== "#" ? /* @__PURE__ */ jsx("span", { className: "mt-3 inline-flex text-sm font-medium underline underline-offset-4", children: linkText }) : null
+    ] })
+  ] });
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "absolute",
+      style: {
+        left: `${x}%`,
+        top: `${y}%`,
+        width: `${width}%`,
+        zIndex
+      },
+      children: linkText && linkUrl !== "#" ? /* @__PURE__ */ jsx(LinkComponent, { href: linkUrl, children: content }) : content
+    }
+  );
+}
+function FaqSection({ section }) {
+  const items = orderedBlocks(section.blocks);
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-12", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsx("div", { className: "divide-y rounded-lg border bg-white", children: items.map((item, index) => /* @__PURE__ */ jsxs("details", { className: "group p-4", children: [
+      /* @__PURE__ */ jsx("summary", { className: "cursor-pointer text-sm font-medium text-neutral-950", children: settingContent(item.settings, "question") || settingContent(item.settings, "title") }),
+      /* @__PURE__ */ jsx("p", { className: "mt-2 text-sm leading-6 text-neutral-600", children: settingContent(item.settings, "answer") || settingContent(item.settings, "content") })
+    ] }, getCmsBlockKey(item, index))) })
+  ] });
+}
+function boundedPercent(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(Math.max(value, 0), 100);
+}
+function NewsletterSection({ section }) {
+  const title = sectionTitleContent(section) || "Recibe novedades";
+  const subtitle = settingContent(section.settings, "subtitle");
+  const placeholder = settingString(section.settings, "placeholder") || "tu@email.com";
+  const buttonText = settingContent(section.settings, "buttonText") || "Suscribirme";
+  return /* @__PURE__ */ jsx("section", { className: "bg-neutral-950 px-4 py-14 text-white", children: /* @__PURE__ */ jsxs("div", { className: "mx-auto max-w-2xl text-center", children: [
+    /* @__PURE__ */ jsx("h2", { className: "text-3xl font-semibold", children: title }),
+    subtitle ? /* @__PURE__ */ jsx("p", { className: "mt-3 text-white/70", children: subtitle }) : null,
+    /* @__PURE__ */ jsxs("form", { className: "mt-6 flex flex-col gap-2 sm:flex-row", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "email",
+          placeholder,
+          className: "h-10 flex-1 rounded-md border border-white/20 bg-white px-3 text-sm text-neutral-950 outline-none"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "submit",
+          className: "h-10 rounded-md bg-white px-5 text-sm font-medium text-neutral-950",
+          children: buttonText
+        }
+      )
+    ] })
+  ] }) });
+}
+function IconRowSection({
+  section,
+  linkComponent: LinkComponent
+}) {
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-10", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsx("div", { className: "grid gap-3 sm:grid-cols-2 lg:grid-cols-4", children: orderedBlocks(section.blocks).map((block, index) => {
+      const settings = block.settings ?? {};
+      const href = storefrontHref(settingString(settings, "linkUrl"));
+      const content = /* @__PURE__ */ jsxs("div", { className: "rounded-lg border bg-white p-4", children: [
+        /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-neutral-950", children: settingContent(settings, "title") || settingContent(settings, "label") }),
+        /* @__PURE__ */ jsx("p", { className: "mt-1 text-sm text-neutral-600", children: settingContent(settings, "subtitle") || settingContent(settings, "description") })
+      ] });
+      return href === "#" ? /* @__PURE__ */ jsx("div", { children: content }, getCmsBlockKey(block, index)) : /* @__PURE__ */ jsx(LinkComponent, { href, children: content }, getCmsBlockKey(block, index));
+    }) })
+  ] });
+}
+function TestimonialsSection({
+  section
+}) {
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-12", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsx("div", { className: "grid gap-4 md:grid-cols-3", children: orderedBlocks(section.blocks).map((block, index) => /* @__PURE__ */ jsxs(
+      "blockquote",
+      {
+        className: "rounded-lg border bg-white p-5",
+        children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm leading-6 text-neutral-700", children: settingString(block.settings, "quote") || settingContent(block.settings, "content") || settingContent(block.settings, "text") }),
+          /* @__PURE__ */ jsx("footer", { className: "mt-4 text-sm font-medium text-neutral-950", children: settingContent(block.settings, "author") || settingContent(block.settings, "name") })
+        ]
+      },
+      getCmsBlockKey(block, index)
+    )) })
+  ] });
+}
+function StatsSection({ section }) {
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-12", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsx("div", { className: "grid gap-4 sm:grid-cols-2 lg:grid-cols-4", children: orderedBlocks(section.blocks).map((block, index) => /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "rounded-lg border bg-white p-5",
+        children: [
+          /* @__PURE__ */ jsx("p", { className: "text-3xl font-semibold text-neutral-950", children: settingContent(block.settings, "value") }),
+          /* @__PURE__ */ jsx("p", { className: "mt-2 text-sm text-neutral-600", children: settingContent(block.settings, "label") || settingContent(block.settings, "title") })
+        ]
+      },
+      getCmsBlockKey(block, index)
+    )) })
+  ] });
+}
+function TimelineSection({ section }) {
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-12", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsx("div", { className: "space-y-4 border-l pl-5", children: orderedBlocks(section.blocks).map((block, index) => /* @__PURE__ */ jsxs("article", { className: "relative", children: [
+      /* @__PURE__ */ jsx("span", { className: "absolute -left-[27px] top-1 size-3 rounded-full bg-neutral-950" }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-neutral-950", children: settingContent(block.settings, "title") }),
+      /* @__PURE__ */ jsx("p", { className: "mt-1 text-sm text-neutral-600", children: settingContent(block.settings, "description") || settingContent(block.settings, "content") })
+    ] }, getCmsBlockKey(block, index))) })
+  ] });
+}
+function ContactFormSection({ section }) {
+  const fields = orderedBlocks(section.blocks);
+  const submitText = settingString(section.settings, "submitText") || "Enviar";
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-12", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsxs("form", { className: "mx-auto grid max-w-2xl gap-3", children: [
+      (fields.length > 0 ? fields : defaultContactFields()).map(
+        (field, index) => /* @__PURE__ */ jsx(ContactField, { field }, getCmsBlockKey(field, index))
+      ),
+      /* @__PURE__ */ jsx("button", { className: "h-10 rounded-md bg-neutral-950 px-4 text-sm font-medium text-white", children: submitText })
+    ] })
+  ] });
+}
+function ContactField({ field }) {
+  const type = settingString(field.settings, "type") || "text";
+  const label = settingString(field.settings, "label");
+  const placeholder = settingString(field.settings, "placeholder");
+  const name = settingString(field.settings, "name");
+  const className = "h-10 rounded-md border px-3 text-sm";
+  if (type === "textarea") {
+    return /* @__PURE__ */ jsx(
+      "textarea",
+      {
+        name,
+        "aria-label": label || placeholder,
+        className: "min-h-32 rounded-md border px-3 py-2 text-sm",
+        placeholder: placeholder || label
+      }
+    );
+  }
+  if (type === "select") {
+    const rawOptions = field.settings?.options;
+    const options = Array.isArray(rawOptions) ? rawOptions.filter((item) => typeof item === "string") : settingString(field.settings, "options").split("\n").map((item) => item.trim()).filter(Boolean);
+    return /* @__PURE__ */ jsxs("select", { name, "aria-label": label, className, children: [
+      /* @__PURE__ */ jsx("option", { value: "", children: placeholder || label }),
+      options.map((option) => /* @__PURE__ */ jsx("option", { value: option, children: option }, option))
+    ] });
+  }
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      name,
+      type,
+      "aria-label": label || placeholder,
+      className,
+      placeholder: placeholder || label
+    }
+  );
+}
+function defaultContactFields() {
+  return [
+    {
+      type: "field",
+      order: 1,
+      settings: { name: "fullName", type: "text", label: "Nombre" }
+    },
+    {
+      type: "field",
+      order: 2,
+      settings: { name: "email", type: "email", label: "Email" }
+    },
+    {
+      type: "field",
+      order: 3,
+      settings: { name: "message", type: "textarea", label: "Mensaje" }
+    }
+  ];
+}
+function UnknownSection({ section }) {
+  return /* @__PURE__ */ jsx("section", { className: "container mx-auto px-4 py-8", children: /* @__PURE__ */ jsxs("div", { className: "rounded border border-dashed p-4 text-sm text-neutral-500", children: [
+    'Seccion tipo "',
+    section.type,
+    '" pendiente de renderer.'
+  ] }) });
+}
+function AnnouncementBarSection({
+  section,
+  linkComponent: LinkComponent
+}) {
+  const text = settingContent(section.settings, "text") || sectionTitleContent(section);
+  const linkText = settingContent(section.settings, "linkText");
+  const href = storefrontHref(settingString(section.settings, "linkUrl"));
+  if (!text) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx("section", { className: "bg-neutral-950 px-4 py-2 text-white", children: /* @__PURE__ */ jsxs("div", { className: "container mx-auto flex flex-wrap items-center justify-center gap-2 text-center text-sm", children: [
+    /* @__PURE__ */ jsx("span", { children: text }),
+    linkText && href !== "#" ? /* @__PURE__ */ jsx(
+      LinkComponent,
+      {
+        href,
+        className: "font-medium underline underline-offset-4",
+        children: linkText
+      }
+    ) : null
+  ] }) });
+}
+function HeroSection({
+  section,
+  linkComponent: LinkComponent
+}) {
+  const slides = orderedBlocks(section.blocks);
+  const fallbackSlide = {
+    id: `${section.id ?? "section"}-fallback`,
+    type: "slide",
+    order: 1,
+    settings: section.settings ?? {}
+  };
+  const visibleSlides = slides.length > 0 ? slides : [fallbackSlide];
+  return /* @__PURE__ */ jsx("section", { className: "bg-neutral-950 text-white", children: /* @__PURE__ */ jsx("div", { className: "flex snap-x overflow-x-auto", children: visibleSlides.map((slide, index) => {
+    const settings = slide.settings ?? {};
+    const imageUrl = settingString(settings, "imageUrl") || settingString(section.settings, "imageUrl") || DEFAULT_CMS_IMAGE_URL;
+    const title = settingContent(settings, "title") || settingContent(section.settings, "title") || sectionTitleContent(section);
+    const subtitle = settingContent(settings, "subtitle") || settingContent(section.settings, "subtitle");
+    const ctaText = settingContent(settings, "ctaText") || settingContent(section.settings, "ctaText");
+    const ctaUrl = settingString(settings, "ctaUrl") || settingString(section.settings, "ctaUrl");
+    const href = storefrontHref(ctaUrl);
+    return /* @__PURE__ */ jsxs(
+      "article",
+      {
+        className: "relative min-h-[520px] w-full shrink-0 snap-start overflow-hidden",
+        children: [
+          /* @__PURE__ */ jsx(
+            CmsImage,
+            {
+              src: imageUrl,
+              alt: "",
+              className: "absolute inset-0 h-full w-full object-cover opacity-75"
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: "absolute inset-0 bg-gradient-to-r from-black/70 via-black/35 to-transparent" }),
+          /* @__PURE__ */ jsx("div", { className: "container relative z-10 mx-auto flex min-h-[520px] items-center px-4", children: /* @__PURE__ */ jsxs("div", { className: "max-w-2xl py-16", children: [
+            /* @__PURE__ */ jsx("h1", { className: "text-4xl font-semibold tracking-tight md:text-6xl", children: title }),
+            subtitle ? /* @__PURE__ */ jsx("p", { className: "mt-4 max-w-xl text-base text-white/85 md:text-lg", children: subtitle }) : null,
+            ctaText && href !== "#" ? /* @__PURE__ */ jsx(
+              LinkComponent,
+              {
+                href,
+                className: "mt-8 inline-flex h-10 items-center rounded-md bg-white px-5 text-sm font-medium text-neutral-950 transition hover:bg-white/90",
+                children: ctaText
+              }
+            ) : null
+          ] }) })
+        ]
+      },
+      getCmsBlockKey(slide, index)
+    );
+  }) }) });
+}
+function ProductsSection({
+  section,
+  products,
+  carousel,
+  linkComponent,
+  currency,
+  preview
+}) {
+  const placeholders = preview && products.length === 0;
+  const count = Math.min(
+    productPreviewCount(section, carousel),
+    carousel ? 5 : 8
+  );
+  return /* @__PURE__ */ jsxs("section", { className: carousel ? "py-12" : "container mx-auto px-4 py-12", children: [
+    carousel ? /* @__PURE__ */ jsx("div", { className: "container mx-auto px-4", children: /* @__PURE__ */ jsx(SectionHeading, { section }) }) : /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsx("div", { className: carousel ? "container mx-auto overflow-x-auto px-4" : "", children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: carousel ? "flex min-w-full gap-4 pb-2" : "grid grid-cols-2 gap-4 sm:grid-cols-3 lg:grid-cols-4",
+        children: placeholders ? Array.from({ length: count }).map((_, index) => /* @__PURE__ */ jsx(ProductPlaceholder, { carousel }, index)) : products.map((product) => /* @__PURE__ */ jsx(
+          ProductCard,
+          {
+            product,
+            carousel,
+            linkComponent,
+            currency
+          },
+          product.id
+        ))
+      }
+    ) }),
+    !placeholders && products.length === 0 ? /* @__PURE__ */ jsx(EmptyState, { children: "No hay productos para mostrar." }) : null
+  ] });
+}
+function CategoryGridSection({
+  section,
+  collections,
+  linkComponent: LinkComponent,
+  preview
+}) {
+  const blockItems = orderedBlocks(section.blocks).map((block) => {
+    const settings = block.settings ?? {};
+    const name = settingContent(settings, "name") || settingContent(settings, "title");
+    const url = settingString(settings, "url") || settingString(settings, "linkUrl");
+    const imageUrl = settingString(settings, "imageUrl");
+    if (!name) {
+      return null;
+    }
+    return {
+      id: getCmsBlockKey(block, block.order),
+      name,
+      href: storefrontHref(url || "/collections"),
+      imageUrl: imageUrl || DEFAULT_CMS_IMAGE_URL
+    };
+  }).filter(Boolean);
+  const collectionItems = collections.map((collection) => ({
+    id: collection.id,
+    name: collection.name,
+    href: `/store/collections/${collection.slug}`,
+    imageUrl: collection.imageUrl || DEFAULT_CMS_IMAGE_URL
+  }));
+  const previewItems = preview ? createPreviewCollections(section) : [];
+  const items = blockItems.length > 0 ? blockItems : collectionItems.length > 0 ? collectionItems : previewItems;
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-12", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    items.length > 0 ? /* @__PURE__ */ jsx("div", { className: "grid gap-4 sm:grid-cols-2 lg:grid-cols-3", children: items.map((item) => /* @__PURE__ */ jsxs(
+      LinkComponent,
+      {
+        href: item.href,
+        className: "group overflow-hidden rounded-lg border bg-white",
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "aspect-[4/3] overflow-hidden bg-neutral-100", children: /* @__PURE__ */ jsx(
+            CmsImage,
+            {
+              src: item.imageUrl,
+              alt: "",
+              className: "h-full w-full object-cover transition duration-300 group-hover:scale-105"
+            }
+          ) }),
+          /* @__PURE__ */ jsx("div", { className: "p-4", children: /* @__PURE__ */ jsx("h3", { className: "text-base font-medium text-neutral-950", children: item.name }) })
+        ]
+      },
+      item.id
+    )) }) : /* @__PURE__ */ jsx(EmptyState, { children: "No hay categorias para mostrar." })
+  ] });
+}
+function PromoCardsSection({
+  section,
+  linkComponent: LinkComponent
+}) {
+  const cards = orderedBlocks(section.blocks);
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-12", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsx("div", { className: "grid gap-4 md:grid-cols-2", children: cards.map((card, index) => {
+      const settings = card.settings ?? {};
+      const title = settingContent(settings, "title");
+      const subtitle = settingContent(settings, "subtitle");
+      const imageUrl = settingString(settings, "imageUrl") || DEFAULT_CMS_IMAGE_URL;
+      const ctaText = settingContent(settings, "ctaText");
+      const ctaUrl = storefrontHref(
+        settingString(settings, "ctaUrl") || settingString(settings, "url")
+      );
+      return /* @__PURE__ */ jsxs(
+        LinkComponent,
+        {
+          href: ctaUrl,
+          className: "group relative min-h-[260px] overflow-hidden rounded-lg bg-neutral-900 text-white",
+          children: [
+            /* @__PURE__ */ jsx(
+              CmsImage,
+              {
+                src: imageUrl,
+                alt: "",
+                className: "absolute inset-0 h-full w-full object-cover opacity-75 transition duration-300 group-hover:scale-105"
+              }
+            ),
+            /* @__PURE__ */ jsx("div", { className: "absolute inset-0 bg-black/35" }),
+            /* @__PURE__ */ jsxs("div", { className: "relative z-10 flex min-h-[260px] flex-col justify-end p-6", children: [
+              /* @__PURE__ */ jsx("h3", { className: "text-2xl font-semibold", children: title }),
+              subtitle ? /* @__PURE__ */ jsx("p", { className: "mt-2 text-white/85", children: subtitle }) : null,
+              ctaText ? /* @__PURE__ */ jsx("span", { className: "mt-4 text-sm font-medium", children: ctaText }) : null
+            ] })
+          ]
+        },
+        getCmsBlockKey(card, index)
+      );
+    }) })
+  ] });
+}
+function LogoSliderSection({
+  section,
+  linkComponent: LinkComponent
+}) {
+  return /* @__PURE__ */ jsxs("section", { className: "container mx-auto px-4 py-10", children: [
+    /* @__PURE__ */ jsx(SectionHeading, { section }),
+    /* @__PURE__ */ jsx("div", { className: "flex gap-4 overflow-x-auto", children: orderedBlocks(section.blocks).map((block, index) => {
+      const settings = block.settings ?? {};
+      const imageUrl = settingString(settings, "imageUrl") || DEFAULT_CMS_IMAGE_URL;
+      const alt = settingString(settings, "alt") || "Logo";
+      const href = storefrontHref(settingString(settings, "linkUrl"));
+      const logo = /* @__PURE__ */ jsx("div", { className: "flex h-24 w-40 shrink-0 items-center justify-center rounded-lg border bg-white p-4", children: /* @__PURE__ */ jsx(
+        CmsImage,
+        {
+          src: imageUrl,
+          alt,
+          className: "max-h-full max-w-full object-contain"
+        }
+      ) });
+      return href !== "#" ? /* @__PURE__ */ jsx(LinkComponent, { href, children: logo }, getCmsBlockKey(block, index)) : /* @__PURE__ */ jsx("div", { children: logo }, getCmsBlockKey(block, index));
+    }) })
+  ] });
+}
+function ProductCard({
+  product,
+  carousel,
+  linkComponent: LinkComponent,
+  currency
+}) {
+  const onSale = product.compareAtPrice != null && product.compareAtPrice > product.price;
+  return /* @__PURE__ */ jsxs(
+    LinkComponent,
+    {
+      href: `/product/${product.slug}`,
+      className: carousel ? "group w-[220px] shrink-0 sm:w-[250px] md:w-[280px]" : "group",
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "aspect-square overflow-hidden rounded-lg border border-neutral-200 bg-neutral-100 transition-all duration-300 group-hover:border-neutral-300", children: /* @__PURE__ */ jsx(
+          CmsImage,
+          {
+            src: product.imageUrl || DEFAULT_CMS_IMAGE_URL,
+            alt: product.name,
+            className: "h-full w-full object-cover object-center transition-transform duration-500 group-hover:scale-105"
+          }
+        ) }),
+        /* @__PURE__ */ jsxs("div", { className: "mt-4 flex flex-col", children: [
+          /* @__PURE__ */ jsx("h3", { className: "line-clamp-2 text-sm font-medium text-neutral-950", children: product.name }),
+          /* @__PURE__ */ jsxs("div", { className: "mt-1 flex items-center gap-2", children: [
+            /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-neutral-950", children: formatCurrency(product.price, currency) }),
+            onSale ? /* @__PURE__ */ jsx("span", { className: "text-sm text-neutral-500 line-through", children: formatCurrency(product.compareAtPrice ?? 0, currency) }) : null
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+function ProductPlaceholder({ carousel }) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: carousel ? "w-[220px] shrink-0 sm:w-[250px] md:w-[280px]" : "",
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "aspect-square rounded-lg bg-neutral-100" }),
+        /* @__PURE__ */ jsx("div", { className: "mt-4 h-3 w-3/4 rounded bg-neutral-200" }),
+        /* @__PURE__ */ jsx("div", { className: "mt-2 h-3 w-1/2 rounded bg-neutral-100" })
+      ]
+    }
+  );
+}
+function productPreviewCount(section, carousel) {
+  const configuredBlocks = orderedBlocks(section.blocks).length;
+  if (configuredBlocks > 0) {
+    return configuredBlocks;
+  }
+  return settingNumber(section.settings, "limit", carousel ? 5 : 8);
+}
+function createPreviewCollections(section) {
+  const count = Math.min(settingNumber(section.settings, "limit", 6), 6);
+  return Array.from({ length: count }, (_, index) => ({
+    id: `preview-collection-${index + 1}`,
+    name: `Categoria ${index + 1}`,
+    href: "/store/collections/all",
+    imageUrl: DEFAULT_CMS_IMAGE_URL
+  }));
+}
+function LayoutSection({ section, renderSections }) {
+  const settings = section.settings ?? {};
+  const paddingY = settingString(settings, "paddingY") || "medium";
+  const maxWidth = settingString(settings, "maxWidth") || "container";
+  const background = settingString(settings, "background") || "default";
+  return /* @__PURE__ */ jsx(
+    "section",
+    {
+      className: `${layoutBackground(background)} ${layoutPadding(paddingY)}`,
+      children: /* @__PURE__ */ jsx("div", { className: `mx-auto px-4 ${layoutMaxWidth(maxWidth)}`, children: renderSections(layoutChildren(settings, "content")) })
+    }
+  );
+}
+function LayoutGrid({ section, renderSections }) {
+  const settings = section.settings ?? {};
+  const columnCount = Math.min(
+    Math.max(Math.round(settingNumber(settings, "columnCount", 2)), 1),
+    6
+  );
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `grid ${layoutGap(settingString(settings, "gap"))}`,
+      style: {
+        gridTemplateColumns: `repeat(${columnCount}, minmax(0, 1fr))`
+      },
+      children: renderSections(layoutChildren(settings, "content"))
+    }
+  );
+}
+function LayoutFlex({ section, renderSections }) {
+  const settings = section.settings ?? {};
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: [
+        "flex",
+        settingString(settings, "direction") === "column" ? "flex-col" : "flex-col md:flex-row",
+        settingString(settings, "wrap") === "nowrap" ? "flex-nowrap" : "flex-wrap",
+        layoutGap(settingString(settings, "gap")),
+        layoutAlign(settingString(settings, "align")),
+        layoutJustify(settingString(settings, "justify"))
+      ].join(" "),
+      children: renderSections(layoutChildren(settings, "content"))
+    }
+  );
+}
+function LayoutSpace({ section }) {
+  const settings = section.settings ?? {};
+  const size = settingString(settings, "size") || "24px";
+  const direction = settingString(settings, "direction") || "vertical";
+  const isHorizontal = direction === "horizontal";
+  const isBoth = direction === "both";
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "aria-hidden": "true",
+      style: {
+        display: "block",
+        width: isHorizontal || isBoth ? size : "100%",
+        height: isHorizontal ? "100%" : size
+      }
+    }
+  );
+}
+function CmsSectionsRenderer({
+  sections,
+  sectionData,
+  linkComponent,
+  currency = "PEN",
+  preview = false,
+  wrap = true
+}) {
+  const LinkComponent = linkComponent ?? DefaultLink;
+  const sortedSections = [...sections].sort((a, b) => a.order - b.order);
+  const content = /* @__PURE__ */ jsx(Fragment, { children: sortedSections.map((section, index) => {
+    const sectionKey = getCmsSectionKey(section, index);
+    return /* @__PURE__ */ jsx(
+      CmsSection,
+      {
+        section,
+        data: sectionData?.[sectionKey],
+        linkComponent: LinkComponent,
+        currency,
+        preview
+      },
+      sectionKey
+    );
+  }) });
+  return wrap ? /* @__PURE__ */ jsx("div", { className: "relative", children: content }) : content;
+}
+function CmsSection({
+  section,
+  data,
+  linkComponent,
+  currency,
+  preview
+}) {
+  const type = canonicalSectionType(section.type);
+  const renderSections = (sections) => /* @__PURE__ */ jsx(
+    CmsSectionsRenderer,
+    {
+      sections,
+      linkComponent,
+      currency,
+      preview,
+      wrap: false
+    }
+  );
+  if (type === "layout-section") {
+    return /* @__PURE__ */ jsx(
+      LayoutSection,
+      {
+        section,
+        linkComponent,
+        currency,
+        preview,
+        renderSections
+      }
+    );
+  }
+  if (type === "layout-grid") {
+    return /* @__PURE__ */ jsx(
+      LayoutGrid,
+      {
+        section,
+        linkComponent,
+        currency,
+        preview,
+        renderSections
+      }
+    );
+  }
+  if (type === "layout-flex") {
+    return /* @__PURE__ */ jsx(
+      LayoutFlex,
+      {
+        section,
+        linkComponent,
+        currency,
+        preview,
+        renderSections
+      }
+    );
+  }
+  if (type === "layout-space") {
+    return /* @__PURE__ */ jsx(
+      LayoutSpace,
+      {
+        section,
+        linkComponent,
+        currency,
+        preview,
+        renderSections
+      }
+    );
+  }
+  if (type === "hero") {
+    return /* @__PURE__ */ jsx(HeroSection, { section, linkComponent });
+  }
+  if (type === "announcement-bar") {
+    return /* @__PURE__ */ jsx(AnnouncementBarSection, { section, linkComponent });
+  }
+  if (type === "product-list" || type === "product-carousel") {
+    return /* @__PURE__ */ jsx(
+      ProductsSection,
+      {
+        section,
+        products: data?.products ?? [],
+        carousel: type === "product-carousel",
+        linkComponent,
+        currency,
+        preview
+      }
+    );
+  }
+  if (type === "category-grid" || type === "collection-list") {
+    return /* @__PURE__ */ jsx(
+      CategoryGridSection,
+      {
+        section,
+        collections: data?.collections ?? [],
+        linkComponent,
+        preview
+      }
+    );
+  }
+  if (type === "promo-cards") {
+    return /* @__PURE__ */ jsx(PromoCardsSection, { section, linkComponent });
+  }
+  if (type === "rich-text" || type === "seo-text") {
+    return /* @__PURE__ */ jsx(RichTextSection, { section });
+  }
+  if (type === "custom-html") {
+    return /* @__PURE__ */ jsx(CustomHtmlSection, { section });
+  }
+  if (type === "floating-block") {
+    return /* @__PURE__ */ jsx(FloatingBlockSection, { section, linkComponent });
+  }
+  if (type === "faq") {
+    return /* @__PURE__ */ jsx(FaqSection, { section });
+  }
+  if (type === "newsletter") {
+    return /* @__PURE__ */ jsx(NewsletterSection, { section });
+  }
+  if (type === "trust-badges" || type === "widget-row") {
+    return /* @__PURE__ */ jsx(IconRowSection, { section, linkComponent });
+  }
+  if (type === "logo-slider") {
+    return /* @__PURE__ */ jsx(LogoSliderSection, { section, linkComponent });
+  }
+  if (type === "testimonials") {
+    return /* @__PURE__ */ jsx(TestimonialsSection, { section });
+  }
+  if (type === "stats") {
+    return /* @__PURE__ */ jsx(StatsSection, { section });
+  }
+  if (type === "timeline") {
+    return /* @__PURE__ */ jsx(TimelineSection, { section });
+  }
+  if (type === "contact-form") {
+    return /* @__PURE__ */ jsx(ContactFormSection, { section });
+  }
+  return /* @__PURE__ */ jsx(UnknownSection, { section });
+}
+function buildOptionGroups(variants) {
+  const map = /* @__PURE__ */ new Map();
+  for (const v of variants) {
+    for (const opt of v.options ?? []) {
+      const key = opt.key;
+      const name = opt.name ?? key;
+      if (!map.has(key)) map.set(key, /* @__PURE__ */ new Map());
+      map.get(key).set(opt.value, name);
+    }
+  }
+  return Array.from(map.entries()).map(([key, valueMap]) => ({
+    key,
+    name: Array.from(valueMap.values())[0] ?? key,
+    values: Array.from(valueMap.keys())
+  }));
+}
+function findVariant(variants, selected, hasConfigurableOptions) {
+  if (!hasConfigurableOptions && variants.length > 0) {
+    return variants[0] ?? null;
+  }
+  if (Object.keys(selected).length === 0) return null;
+  for (const v of variants) {
+    const opts = v.options ?? [];
+    const match = opts.length > 0 && opts.every((o) => selected[o.key] === o.value);
+    if (match) return v;
+  }
+  return null;
+}
+function getInitialOptions(variants, optionGroups) {
+  const first = variants[0];
+  if (!first) return {};
+  const opts = first.options ?? [];
+  const selected = {};
+  for (const g of optionGroups) {
+    const o = opts.find((x) => x.key === g.key);
+    if (o) selected[g.key] = o.value;
+  }
+  return selected;
+}
+function ProductVariantSelector({
+  product,
+  currency = "USD",
+  features = [],
+  onVariantChange,
+  children
+}) {
+  const variants = useMemo(() => product.variants ?? [], [product.variants]);
+  const optionGroups = useMemo(() => buildOptionGroups(variants), [variants]);
+  const hasConfigurableOptions = optionGroups.length > 0;
+  const [selectedOptions, setSelectedOptions] = useState(
+    () => getInitialOptions(variants, optionGroups)
+  );
+  const selectedVariant = useMemo(
+    () => findVariant(variants, selectedOptions, hasConfigurableOptions),
+    [variants, selectedOptions, hasConfigurableOptions]
+  );
+  const displayPrice = selectedVariant?.price ?? product.price ?? 0;
+  const compareAtPrice = selectedVariant?.compareAtPrice ?? product.compareAtPrice;
+  const isAvailable = (selectedVariant ? (selectedVariant.quantity ?? 0) > 0 : product.isAvailable) ?? true;
+  useEffect(() => {
+    onVariantChange?.(selectedVariant, displayPrice);
+  }, [selectedVariant, displayPrice, onVariantChange]);
+  const setOption = useCallback((key, value) => {
+    setSelectedOptions((prev) => ({ ...prev, [key]: value }));
+  }, []);
+  const hasVariants = hasConfigurableOptions;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-5", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-2 flex-wrap", children: [
+      /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "inline-flex items-center rounded-md bg-primary/10 px-2.5 py-0.5 text-base font-semibold text-primary",
+          "data-testid": "product-display-price",
+          children: formatCurrency$1(displayPrice, currency)
+        }
+      ),
+      compareAtPrice != null && compareAtPrice > displayPrice && /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground line-through", children: formatCurrency$1(compareAtPrice, currency) })
+    ] }),
+    hasVariants && optionGroups.map((group) => /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-xs font-semibold uppercase tracking-wider text-muted-foreground", children: group.name }),
+      /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-2", children: group.values.map((value) => {
+        const isSelected = selectedOptions[group.key] === value;
+        const isColorLike = group.key.toLowerCase().includes("color") || group.key.toLowerCase().includes("colour");
+        return /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => setOption(group.key, value),
+            className: isColorLike ? `min-w-[72px] rounded-md border-2 px-3 py-2 text-sm font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-primary focus:ring-offset-2 ${isSelected ? "border-primary bg-primary text-foreground" : "border-border bg-muted/30 text-foreground hover:border-muted-foreground/50"}` : `rounded-md border px-3 py-2 text-sm font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-primary focus:ring-offset-2 ${isSelected ? "border-primary bg-muted ring-1 ring-primary" : "border-border bg-transparent text-muted-foreground hover:border-muted-foreground/50 hover:text-foreground"}`,
+            style: isColorLike && isSelected && value.toLowerCase() === "black" ? { backgroundColor: "#1a1a1a", borderColor: "#1a1a1a", color: "#fff" } : isColorLike && value.toLowerCase() === "white" ? { backgroundColor: "#fafafa", color: "#1a1a1a", borderColor: "#e5e5e5" } : void 0,
+            "data-testid": `variant-option-${group.key}-${value}`,
+            children: value
+          },
+          value
+        );
+      }) })
+    ] }, group.key)),
+    features.length > 0 && /* @__PURE__ */ jsx("ul", { className: "list-disc list-inside space-y-1 text-sm text-muted-foreground", children: features.map((f, i) => /* @__PURE__ */ jsx("li", { children: f }, i)) }),
+    children?.({
+      product,
+      selectedVariant,
+      displayPrice,
+      compareAtPrice,
+      isAvailable,
+      selectedOptions
+    })
+  ] });
+}
+function SafeThemeInjector({ theme, className }) {
+  try {
+    if (!theme || typeof theme !== "object") {
+      console.warn("ThemeInjector: Invalid theme provided");
+      return null;
+    }
+    if (!theme.colors || typeof theme.colors !== "object") {
+      console.warn("ThemeInjector: Theme colors are required");
+      return null;
+    }
+    const generateSafeCSSVariables = () => {
+      const cssRules = [":root {"];
+      const toKebabCase = (input) => input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+      const sanitizeCSSValue = (value) => {
+        if (typeof value !== "string") return null;
+        const trimmed = value.trim();
+        if (!trimmed) return null;
+        const isValidCSSValue = /^[a-zA-Z0-9\s,()#.-]+$/.test(trimmed);
+        return isValidCSSValue ? trimmed : null;
+      };
+      if (theme.colors && typeof theme.colors === "object") {
+        Object.entries(theme.colors).forEach(([key, value]) => {
+          const sanitizedValue = sanitizeCSSValue(value);
+          if (sanitizedValue) {
+            cssRules.push(`  --color-${key}: ${sanitizedValue};`);
+            cssRules.push(`  --theme-${key}: ${sanitizedValue};`);
+            cssRules.push(`  --${key}: ${sanitizedValue};`);
+            cssRules.push(`  --${toKebabCase(key)}: ${sanitizedValue};`);
+          }
+        });
+      }
+      if (theme.fonts && typeof theme.fonts === "object") {
+        Object.entries(theme.fonts).forEach(([key, value]) => {
+          const sanitizedValue = sanitizeCSSValue(value);
+          if (sanitizedValue) {
+            cssRules.push(`  --font-${key}: ${sanitizedValue};`);
+          }
+        });
+      }
+      if (theme.spacing && typeof theme.spacing === "object") {
+        Object.entries(theme.spacing).forEach(([key, value]) => {
+          const sanitizedValue = sanitizeCSSValue(value);
+          if (sanitizedValue) {
+            cssRules.push(`  --spacing-${key}: ${sanitizedValue};`);
+          }
+        });
+      }
+      if (theme.borderRadius && typeof theme.borderRadius === "object") {
+        Object.entries(theme.borderRadius).forEach(([key, value]) => {
+          const sanitizedValue = sanitizeCSSValue(value);
+          if (sanitizedValue) {
+            cssRules.push(`  --radius-${key}: ${sanitizedValue};`);
+          }
+        });
+      }
+      if (theme.shadows && typeof theme.shadows === "object") {
+        Object.entries(theme.shadows).forEach(([key, value]) => {
+          const sanitizedValue = sanitizeCSSValue(value);
+          if (sanitizedValue) {
+            cssRules.push(`  --shadow-${key}: ${sanitizedValue};`);
+          }
+        });
+      }
+      cssRules.push("}");
+      return cssRules.join("\n");
+    };
+    const cssVariables = generateSafeCSSVariables();
+    return /* @__PURE__ */ jsx(
+      "style",
+      {
+        dangerouslySetInnerHTML: { __html: cssVariables },
+        "data-theme-injector": theme.id,
+        "data-theme-name": theme.name,
+        className,
+        suppressHydrationWarning: true
+      }
+    );
+  } catch (error) {
+    console.error("ThemeInjector: Error generating theme styles", error);
+    return null;
+  }
+}
+function isRenderableCmsPage(p) {
+  if (!p.status) return true;
+  return p.status === "published";
+}
+function findStorefrontCmsPageBySlug(settings, slug) {
+  const pages = settings?.cms?.pages;
+  if (!pages?.length) return null;
+  const raw = pages.find(
+    (p) => p.slug === slug && isRenderableCmsPage(p)
+  );
+  if (!raw) return null;
+  const parsed = StorefrontPageDetailSchema$1.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+
+export { CartAddressesRequestSchema, CartBuyerRequestSchema, CartCheckoutPaymentActionSchema, CartCheckoutPaymentSchema, CartCheckoutReadResponseSchema, CartCheckoutRequestSchema, CartCheckoutResponseSchema, CartCouponRequestSchema, CartCreateRequestSchema, CartItemModifierRequestSchema, CartItemRequestSchema, CartPaymentMethodSchema, CartPaymentMethodsResponseSchema, CartPaymentReceiptResponseSchema, CartResponseBundleItemSchema, CartResponseItemSchema, CartResponseSchema, CartShippingMethodPutRequestSchema, CmsSectionsRenderer, DEFAULT_CMS_IMAGE_URL, ProductSchema, ProductVariantSchema, ProductVariantSelector, ProductsFiltersSchema, ProductsResponseSchema, QueryProvider, STOREFRONT_API_PATH_PREFIX, STOREFRONT_ECOMIQ_OAUTH_COOKIE_NAME, STOREFRONT_ECOMIQ_OAUTH_COOKIE_PATH, SafeThemeInjector, ShippingOptionGroupSchema, ShippingOptionsResponseSchema, ShippingRateSchema, StorefrontAuthProvider, StorefrontBundleItemSchema, StorefrontCheckoutSettingsSchema, StorefrontCollectionDetailSchema, StorefrontCollectionSchema, StorefrontCollectionsResponseSchema, StorefrontPageDetailSchema, StorefrontPageListItemSchema, StorefrontPriceTierSchema, StorefrontProductDetailSchema, StorefrontProductSchema, StorefrontProductsParamsSchema, StorefrontProductsResponseSchema, StorefrontSettingsLegacyFlatSchema, StorefrontSettingsSchema, StorefrontStoreSchema, apiClient, canonicalSectionType, cartService, collectionService, countryCurrency, customerOrderStatusTone, ecomiqOAuthPassword, ecomiqOAuthPasswordClient, fetchStorefrontGeoDistricts, fetchStorefrontGeoProvinces, findStorefrontCmsPageBySlug, formatCurrency, formatCustomerOrderStatus, formatOrderDate, formatOrderDateTime, getCmsSectionKey, loadStorefrontGeoDepartments, normalizeStorefrontSettingsPayload, pageService, productService, productSortValue, resolveIneiCodesFromLabels, sanitizeHtml, storeService, storefrontAccessTokenNeedsRefresh, storefrontFaviconUrl, storefrontHref, storefrontOgImageUrl, storefrontSessionEndsSoon, storefrontStoreRecord, toGeoItems, useCart, useCartAddresses, useCartCreate, useCartGet, useCollections, useConfig, usePages, useProducts, useStore, useStorefrontAuthClient, useStorefrontGeoInei, useStorefrontSession, useUser };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map