@bacano/sdk 1.0.0 → 1.1.0

package/index.cjs

@@ -23,28 +23,55 @@ __export(index_exports, {
   AuthError: () => AuthError,
   CheckoutError: () => CheckoutError,
   GraphQLRequestError: () => GraphQLRequestError,
+  MARKETING_SCHEMA_VERSION: () => MARKETING_SCHEMA_VERSION,
   NotInitializedError: () => NotInitializedError,
+  RateLimitError: () => RateLimitError,
+  WEBSITE_MARKETING_CONTACT_PLACEMENTS: () => WEBSITE_MARKETING_CONTACT_PLACEMENTS,
   WebsiteError: () => WebsiteError,
+  buildStorageContentMediaUrls: () => buildStorageContentMediaUrls,
   buildStorageFileUrl: () => buildStorageFileUrl,
   buildStorageMediaUrls: () => buildStorageMediaUrls,
+  buildStorageResponsiveSources: () => buildStorageResponsiveSources,
+  buildStorageTransformedFileUrl: () => buildStorageTransformedFileUrl,
+  captureWebsiteMarketingAttribution: () => captureWebsiteMarketingAttribution,
   createBacanoClient: () => createBacanoClient,
+  createWebsiteMarketingRuntime: () => createWebsiteMarketingRuntime,
+  formatMediaSrcSet: () => formatMediaSrcSet,
+  getAllowedMarketingParameters: () => getAllowedMarketingParameters,
   getPrimaryProductImage: () => getPrimaryProductImage,
+  getProductDetailVariants: () => getProductDetailVariants,
   getProductImages: () => getProductImages,
   getProductMediaByKind: () => getProductMediaByKind,
   getProductMediaKind: () => getProductMediaKind,
   getProductVideos: () => getProductVideos,
+  getWebsiteContextFromPublicConfig: () => getWebsiteContextFromPublicConfig,
+  getWebsiteMarketingAttribution: () => getWebsiteMarketingAttribution,
   getWebsitePublicConfig: () => getWebsitePublicConfig,
-  resolveProductPricing: () => resolveProductPricing
+  resolveProductPricing: () => resolveProductPricing,
+  sanitizeMarketingUrl: () => sanitizeMarketingUrl
 });
 module.exports = __toCommonJS(index_exports);
 
 // libs/sdk/src/errors.ts
 var WebsiteError = class extends Error {
   code;
-  constructor(message, code = "WEBSITE_ERROR") {
+  status;
+  retryAfterSeconds;
+  constructor(message, code = "WEBSITE_ERROR", options) {
     super(message);
     this.name = "WebsiteError";
     this.code = code;
+    this.status = options?.status ?? null;
+    this.retryAfterSeconds = options?.retryAfterSeconds ?? null;
+  }
+};
+var RateLimitError = class extends WebsiteError {
+  constructor(message, retryAfterSeconds) {
+    super(message, "RATE_LIMITED", {
+      status: 429,
+      retryAfterSeconds
+    });
+    this.name = "RateLimitError";
   }
 };
 var NotInitializedError = class extends WebsiteError {
@@ -80,7 +107,109 @@ var GraphQLRequestError = class extends WebsiteError {
   }
 };
 
+// libs/sdk/src/media.ts
+var DEFAULT_RESPONSIVE_WIDTHS = [240, 384, 640, 960, 1400];
+var CONTENT_HERO_WIDTHS = [640, 960, 1400, 1920, 2560];
+var CONTENT_HERO_MAX_WIDTH = 1920;
+var MEDIA_VARIANTS = {
+  thumbnail: { width: 240, quality: 75, format: "webp" },
+  card: { width: 640, quality: 80, format: "webp" },
+  detail: { width: 1400, quality: 85, format: "webp" }
+};
+function toSafeInteger(value) {
+  if (!Number.isFinite(value)) return void 0;
+  return Math.max(1, Math.floor(value));
+}
+function buildQuery(options) {
+  const params = new URLSearchParams();
+  const width = toSafeInteger(options.width);
+  const height = toSafeInteger(options.height);
+  const quality = toSafeInteger(options.quality);
+  if (width) params.set("w", String(width));
+  if (height) params.set("h", String(height));
+  if (quality) params.set("q", String(Math.min(100, quality)));
+  if (options.format) params.set("f", options.format);
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+function buildStorageFileUrl(storageUrl, fileId, variant = "original") {
+  if (!storageUrl || !fileId) return "";
+  const baseUrl = `${storageUrl.replace(/\/+$/, "")}/files/${fileId}`;
+  if (variant === "original") return baseUrl;
+  return `${baseUrl}${buildQuery(MEDIA_VARIANTS[variant])}`;
+}
+function buildStorageTransformedFileUrl(storageUrl, fileId, options) {
+  if (!storageUrl || !fileId) return "";
+  const baseUrl = `${storageUrl.replace(/\/+$/, "")}/files/${fileId}`;
+  return `${baseUrl}${buildQuery(options)}`;
+}
+function buildStorageResponsiveSources(storageUrl, fileId, options = {}) {
+  const widths = options.widths ?? [...DEFAULT_RESPONSIVE_WIDTHS];
+  const uniqueWidths = [...new Set(widths.map(toSafeInteger))].filter((width) => Boolean(width)).sort((left, right) => left - right);
+  return uniqueWidths.map((width) => ({
+    width,
+    url: buildStorageTransformedFileUrl(storageUrl, fileId, {
+      width,
+      quality: options.quality ?? 80,
+      format: options.format ?? "webp"
+    })
+  }));
+}
+function formatMediaSrcSet(sources) {
+  return sources.filter((source) => source.url && source.width > 0).map((source) => `${source.url} ${source.width}w`).join(", ");
+}
+function buildStorageMediaUrls(storageUrl, fileId) {
+  return {
+    originalUrl: buildStorageFileUrl(storageUrl, fileId, "original"),
+    thumbnailUrl: buildStorageFileUrl(storageUrl, fileId, "thumbnail"),
+    cardUrl: buildStorageFileUrl(storageUrl, fileId, "card"),
+    detailUrl: buildStorageFileUrl(storageUrl, fileId, "detail"),
+    responsiveSources: buildStorageResponsiveSources(storageUrl, fileId)
+  };
+}
+function buildStorageContentMediaUrls(storageUrl, fileId, originalWidth) {
+  const legacyUrls = buildStorageMediaUrls(storageUrl, fileId);
+  const safeOriginalWidth = toSafeInteger(originalWidth ?? void 0);
+  if (!safeOriginalWidth) {
+    return {
+      ...legacyUrls,
+      heroUrl: legacyUrls.originalUrl,
+      responsiveSources: []
+    };
+  }
+  const responsiveWidths = [
+    ...CONTENT_HERO_WIDTHS.filter((width) => width <= safeOriginalWidth),
+    safeOriginalWidth
+  ];
+  const heroWidth = Math.min(safeOriginalWidth, CONTENT_HERO_MAX_WIDTH);
+  return {
+    ...legacyUrls,
+    heroUrl: buildStorageTransformedFileUrl(storageUrl, fileId, {
+      width: heroWidth,
+      quality: 88,
+      format: "webp"
+    }),
+    responsiveSources: buildStorageResponsiveSources(storageUrl, fileId, {
+      widths: responsiveWidths,
+      quality: 85,
+      format: "webp"
+    })
+  };
+}
+
 // libs/sdk/src/modules/auth.ts
+function getWebsiteContextFromPublicConfig(config) {
+  if (config.contextSchemaVersion !== 1) return void 0;
+  return {
+    websiteId: config.websiteId,
+    companyId: config.companyId,
+    chainId: config.chainId ?? null,
+    name: config.name,
+    slug: config.slug,
+    domain: config.domain,
+    config: config.config ?? null
+  };
+}
 function createAuthHeaders(accessToken) {
   return accessToken ? { Authorization: `Bearer ${accessToken}` } : {};
 }
@@ -102,14 +231,18 @@ function createRequestHeadersProvider(websiteSlug, getAccessToken) {
 }
 async function getWebsitePublicConfig(options) {
   const apiUrl = options.apiUrl.replace(/\/+$/, "");
-  const headers = options.origin ? { Origin: options.origin } : void 0;
+  const headers = {};
+  if (options.origin) headers.Origin = options.origin;
+  if (options.previewToken) {
+    headers["X-Bacano-Preview-Token"] = options.previewToken;
+  }
   const params = new URLSearchParams({ websiteSlug: options.websiteSlug });
   let response;
   try {
     response = await fetch(
       `${apiUrl}/api/v1/website/public-config?${params.toString()}`,
       {
-        headers,
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
         cache: "no-store"
       }
     );
@@ -133,12 +266,71 @@ async function getWebsitePublicConfig(options) {
     require_document: false,
     document_types: []
   };
+  const marketing = raw.marketing ?? {
+    schema_version: 1,
+    enabled: false,
+    currency_code: "COP",
+    time_zone: "America/Bogota",
+    attribution_window_days: 90,
+    consent_policy: null,
+    destinations: { ga4: null, meta: null, clarity: null }
+  };
+  const legal = raw.legal ?? {
+    schema_version: 1,
+    version: 0,
+    content_hash: null,
+    documents: {
+      terms: null,
+      shipping: null,
+      returns: null,
+      privacy: null,
+      cookies: null
+    },
+    inquiries_channel: null,
+    direct_marketing_consent: null,
+    cookie_notice: {
+      enabled: false,
+      message: "Usamos cookies propias y de terceros para mejorar tu experiencia y medir el funcionamiento del sitio.",
+      button_label: "Entendido"
+    }
+  };
+  const mapConstructionImage = (image) => {
+    if (!image) return null;
+    const urls = buildStorageContentMediaUrls(
+      `${apiUrl}/storage/v1`,
+      image.file_id,
+      image.width
+    );
+    return {
+      fileId: image.file_id,
+      name: image.name,
+      altText: image.alt_text,
+      width: image.width,
+      height: image.height,
+      originalUrl: urls.originalUrl,
+      heroUrl: urls.heroUrl,
+      responsiveSources: urls.responsiveSources
+    };
+  };
+  const construction = raw.construction ?? {
+    schema_version: 1,
+    enabled: false,
+    enforced: false,
+    preview_access_granted: false,
+    title: null,
+    message: null,
+    desktop_image: null,
+    mobile_image: null
+  };
   return {
     websiteId: raw.website_id,
     companyId: raw.company_id,
+    contextSchemaVersion: raw.context_schema_version === 1 ? 1 : null,
+    chainId: raw.chain_id ?? null,
     slug: raw.slug,
     name: raw.name,
     domain: raw.domain,
+    config: raw.config ?? null,
     buyerAccountsEnabled: raw.buyer_accounts_enabled,
     clerkPublishableKey: raw.clerk_publishable_key,
     customerIdentification: {
@@ -154,56 +346,67 @@ async function getWebsitePublicConfig(options) {
           isDefault: documentType.is_default
         })
       )
+    },
+    marketing: {
+      schemaVersion: marketing.schema_version,
+      enabled: marketing.enabled,
+      currencyCode: marketing.currency_code,
+      timeZone: marketing.time_zone,
+      attributionWindowDays: marketing.attribution_window_days,
+      consentPolicy: marketing.consent_policy ? {
+        id: marketing.consent_policy.id,
+        version: marketing.consent_policy.version,
+        statement: marketing.consent_policy.statement,
+        statementHash: marketing.consent_policy.statement_hash
+      } : null,
+      destinations: {
+        ga4: marketing.destinations.ga4 ? {
+          measurementId: marketing.destinations.ga4.measurement_id,
+          diagnosticMode: marketing.destinations.ga4.diagnostic_mode ?? false
+        } : null,
+        meta: marketing.destinations.meta ? {
+          pixelId: marketing.destinations.meta.pixel_id,
+          diagnosticMode: marketing.destinations.meta.diagnostic_mode ?? false
+        } : null,
+        clarity: marketing.destinations.clarity ? { projectId: marketing.destinations.clarity.project_id } : null
+      }
+    },
+    legal: {
+      schemaVersion: legal.schema_version,
+      version: legal.version,
+      contentHash: legal.content_hash,
+      documents: {
+        terms: legal.documents.terms,
+        shipping: legal.documents.shipping ?? null,
+        returns: legal.documents.returns ?? null,
+        privacy: legal.documents.privacy,
+        cookies: legal.documents.cookies
+      },
+      inquiriesChannel: legal.inquiries_channel,
+      directMarketingConsent: legal.direct_marketing_consent ? {
+        version: legal.direct_marketing_consent.version,
+        statement: legal.direct_marketing_consent.statement,
+        statementHash: legal.direct_marketing_consent.statement_hash
+      } : null,
+      cookieNotice: {
+        enabled: legal.cookie_notice.enabled,
+        message: legal.cookie_notice.message,
+        buttonLabel: legal.cookie_notice.button_label
+      }
+    },
+    construction: {
+      schemaVersion: construction.schema_version,
+      enabled: construction.enabled,
+      enforced: construction.enforced,
+      previewAccessGranted: construction.preview_access_granted,
+      title: construction.title,
+      message: construction.message,
+      desktopImage: mapConstructionImage(construction.desktop_image),
+      mobileImage: mapConstructionImage(construction.mobile_image)
     }
   };
 }
 
-// libs/sdk/src/transport/graphql.ts
-async function executeGraphQL(url, query, variables, headers) {
-  const resolvedHeaders = typeof headers === "function" ? await headers() : headers ?? {};
-  let res;
-  try {
-    res = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...resolvedHeaders
-      },
-      body: JSON.stringify({ query, variables })
-    });
-  } catch (err) {
-    throw new WebsiteError(
-      `Network error connecting to ${url}: ${err instanceof Error ? err.message : String(err)}`,
-      "NETWORK_ERROR"
-    );
-  }
-  if (res.status === 429) {
-    throw new WebsiteError(
-      "Rate limit exceeded. Please try again later.",
-      "RATE_LIMITED"
-    );
-  }
-  let body;
-  try {
-    body = await res.json();
-  } catch {
-    throw new WebsiteError(
-      `Non-JSON response from ${url} (status ${res.status})`,
-      "INVALID_RESPONSE"
-    );
-  }
-  if (body.errors && body.errors.length > 0) {
-    throw new GraphQLRequestError(body.errors);
-  }
-  if (!body.data) {
-    throw new WebsiteError(
-      "GraphQL response contains no data",
-      "EMPTY_RESPONSE"
-    );
-  }
-  return body.data;
-}
-
 // libs/sdk/src/transport/documents.ts
 var RESOLVE_WEBSITE_BY_SLUG = (
   /* GraphQL */
@@ -1029,6 +1232,62 @@ var CHECK_AVAILABILITY = (
       product_variant_id
       in_stock
       label
+      max_purchasable_quantity
+    }
+  }
+`
+);
+var GET_PRODUCT_LIVE_STATE = (
+  /* GraphQL */
+  `
+  query GetProductLiveState(
+    $variantIds: [uuid!]!
+    $companyId: uuid!
+    $chainId: uuid!
+    $websiteId: uuid!
+  ) {
+    product_variants(
+      where: {
+        id: { _in: $variantIds }
+        is_disabled: { _eq: false }
+        product: {
+          company_id: { _eq: $companyId }
+          product_website_publications: {
+            website_id: { _eq: $websiteId }
+            is_visible: { _eq: true }
+          }
+          chain_products: {
+            chain_id: { _eq: $chainId }
+            is_enabled: { _eq: true }
+            status: { _eq: active }
+          }
+        }
+      }
+    ) {
+      id
+      product_variant_prices(
+        where: {
+          price_type: { _in: [CLIENT, SALE, WHOLESALE, WHOLESALE_2] }
+          _or: [
+            { chain_id: { _eq: $chainId } }
+            { chain_id: { _is_null: true } }
+          ]
+        }
+      ) {
+        id
+        price
+        price_type
+        chain_id
+      }
+    }
+    websiteProductAvailability(
+      product_variant_ids: $variantIds
+      chain_id: $chainId
+    ) {
+      product_variant_id
+      in_stock
+      label
+      max_purchasable_quantity
     }
   }
 `
@@ -1138,6 +1397,7 @@ var START_GUEST_CHECKOUT = (
     $contact: WebsiteGuestContactInput!
     $items: [WebsiteCheckoutItemInput!]!
     $fulfillmentFamily: String
+    $marketingAttribution: WebsiteMarketingAttributionInput
   ) {
     websiteStartGuestCheckout(
       website_id: $websiteId
@@ -1145,6 +1405,7 @@ var START_GUEST_CHECKOUT = (
       contact: $contact
       items: $items
       fulfillment_family: $fulfillmentFamily
+      marketing_attribution: $marketingAttribution
     ) {
       success
       order_id
@@ -1302,6 +1563,8 @@ var CHECKOUT = (
     $paymentMethodId: uuid
     $buyerAccountOptIn: Boolean
     $initialPayment: WebsiteInitialPaymentInput
+    $marketingAttribution: WebsiteMarketingAttributionInput
+    $advertisingConsent: WebsiteAdvertisingConsentInput
   ) {
     websiteCheckout(
       order_id: $orderId
@@ -1314,6 +1577,8 @@ var CHECKOUT = (
       payment_method_id: $paymentMethodId
       buyer_account_opt_in: $buyerAccountOptIn
       initial_payment: $initialPayment
+      marketing_attribution: $marketingAttribution
+      advertising_consent: $advertisingConsent
     ) {
       success
       order_id
@@ -2240,13 +2505,121 @@ var GET_SEARCH_SUGGESTIONS = (
 `
 );
 
+// libs/sdk/src/transport/graphql.ts
+var DEFAULT_MAX_ATTEMPTS = 4;
+var DEFAULT_MAX_TOTAL_WAIT_MS = 3 * 60 * 1e3;
+var DEFAULT_JITTER_RATIO = 0.1;
+function parseRetryAfterSeconds(res, body) {
+  const header = res.headers?.get?.("Retry-After")?.trim();
+  if (header) {
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0) return Math.ceil(seconds);
+    const retryAt = Date.parse(header);
+    if (Number.isFinite(retryAt)) {
+      return Math.max(Math.ceil((retryAt - Date.now()) / 1e3), 0);
+    }
+  }
+  if (body && typeof body === "object") {
+    const seconds = Number(
+      body.retry_after_seconds
+    );
+    if (Number.isFinite(seconds) && seconds >= 0) return Math.ceil(seconds);
+  }
+  return 1;
+}
+async function createRateLimitError(res) {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = null;
+  }
+  const message = body && typeof body === "object" && typeof body.message === "string" ? body.message : "Rate limit exceeded. Please try again later.";
+  return new RateLimitError(message, parseRetryAfterSeconds(res, body));
+}
+function getRetryDelayMs(error, options) {
+  const retryAfterMs = (error.retryAfterSeconds ?? 1) * 1e3;
+  const jitterRatio = Math.max(
+    0,
+    Math.min(options.jitterRatio ?? DEFAULT_JITTER_RATIO, 1)
+  );
+  return Math.ceil(retryAfterMs * (1 + Math.random() * jitterRatio));
+}
+function wait(delayMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+async function executeGraphQL(url, query, variables, headers, options) {
+  const retry = options?.retry;
+  const maxAttempts = Math.max(
+    1,
+    Math.floor(retry?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS)
+  );
+  const maxTotalWaitMs = Math.max(
+    0,
+    retry?.maxTotalWaitMs ?? DEFAULT_MAX_TOTAL_WAIT_MS
+  );
+  let totalWaitMs = 0;
+  let res = null;
+  for (let attempt = 1; attempt <= (retry ? maxAttempts : 1); attempt += 1) {
+    const resolvedHeaders = typeof headers === "function" ? await headers() : headers ?? {};
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...resolvedHeaders
+        },
+        body: JSON.stringify({ query, variables })
+      });
+    } catch (err) {
+      throw new WebsiteError(
+        `Network error connecting to ${url}: ${err instanceof Error ? err.message : String(err)}`,
+        "NETWORK_ERROR"
+      );
+    }
+    if (res.status !== 429) break;
+    const rateLimitError = await createRateLimitError(res);
+    const delayMs = getRetryDelayMs(rateLimitError, retry ?? {});
+    const canRetry = Boolean(retry) && attempt < maxAttempts && totalWaitMs + delayMs <= maxTotalWaitMs;
+    if (!canRetry) throw rateLimitError;
+    totalWaitMs += delayMs;
+    await wait(delayMs);
+  }
+  if (!res) {
+    throw new WebsiteError(
+      "GraphQL request did not produce a response",
+      "EMPTY_RESPONSE"
+    );
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new WebsiteError(
+      `Non-JSON response from ${url} (status ${res.status})`,
+      "INVALID_RESPONSE"
+    );
+  }
+  if (body.errors && body.errors.length > 0) {
+    throw new GraphQLRequestError(body.errors);
+  }
+  if (!body.data) {
+    throw new WebsiteError(
+      "GraphQL response contains no data",
+      "EMPTY_RESPONSE"
+    );
+  }
+  return body.data;
+}
+
 // libs/sdk/src/modules/availability.ts
 var MAX_AVAILABILITY_VARIANT_IDS = 100;
 function mapAvailability(raw) {
   return {
     productVariantId: raw.product_variant_id,
     inStock: raw.in_stock,
-    label: raw.label
+    label: raw.label,
+    maxPurchasableQuantity: raw.max_purchasable_quantity
   };
 }
 function chunkArray(items, chunkSize) {
@@ -2272,7 +2645,10 @@ function createAvailabilityModule(graphqlUrl, getHeaders, getContext) {
       if (productVariantIds.length === 0) return [];
       const variantIds = uniqueValues(productVariantIds);
       const results = [];
-      for (const chunk of chunkArray(variantIds, MAX_AVAILABILITY_VARIANT_IDS)) {
+      for (const chunk of chunkArray(
+        variantIds,
+        MAX_AVAILABILITY_VARIANT_IDS
+      )) {
         const data = await executeGraphQL(
           graphqlUrl,
           CHECK_AVAILABILITY,
@@ -2291,6 +2667,255 @@ function createAvailabilityModule(graphqlUrl, getHeaders, getContext) {
   };
 }
 
+// libs/sdk/src/marketing/sanitize.ts
+var SENSITIVE_PARAMETER_PATTERNS = [
+  /token/i,
+  /secret/i,
+  /password/i,
+  /authorization/i,
+  /session/i,
+  /ticket/i,
+  /code_verifier/i,
+  /client_secret/i,
+  /payment/i,
+  /order[_-]?(?:id|token)/i,
+  /public[_-]?order/i,
+  /clerk/i,
+  /oauth/i,
+  /email/i,
+  /phone/i,
+  /document/i
+];
+var ALLOWED_MARKETING_PARAMETERS = /* @__PURE__ */ new Set([
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content",
+  "utm_source_platform",
+  "utm_id",
+  "gclid",
+  "gbraid",
+  "wbraid",
+  "fbclid",
+  "ttclid",
+  "msclkid"
+]);
+function sanitizeMarketingUrl(input, baseUrl) {
+  try {
+    const url = new URL(input, baseUrl);
+    const safeParameters = new URLSearchParams();
+    for (const [key, value] of url.searchParams.entries()) {
+      if (ALLOWED_MARKETING_PARAMETERS.has(key.toLowerCase()) && !SENSITIVE_PARAMETER_PATTERNS.some((pattern) => pattern.test(key))) {
+        safeParameters.set(key.toLowerCase(), value.slice(0, 500));
+      }
+    }
+    url.search = safeParameters.toString();
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return "";
+  }
+}
+function getAllowedMarketingParameters(input, baseUrl) {
+  const sanitized = sanitizeMarketingUrl(input, baseUrl);
+  if (!sanitized) return {};
+  const url = new URL(sanitized);
+  return Object.fromEntries(url.searchParams.entries());
+}
+
+// libs/sdk/src/marketing/attribution.ts
+var STORAGE_PREFIX = "bacano:marketing:attribution:v1";
+var GA4_CLIENT_ID_PATTERN = /^\d+\.\d+$/;
+var META_BROWSER_ID_PATTERN = /^fb\.\d+\.\d+\.[A-Za-z0-9_-]+$/;
+function storageKey(websiteId) {
+  return `${STORAGE_PREFIX}:${websiteId}`;
+}
+function readStored(websiteId) {
+  if (typeof window === "undefined") return null;
+  try {
+    const value = window.localStorage.getItem(storageKey(websiteId));
+    if (!value) return null;
+    const parsed = JSON.parse(value);
+    if (new Date(parsed.expiresAt).getTime() <= Date.now()) {
+      window.localStorage.removeItem(storageKey(websiteId));
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeStored(websiteId, value) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(storageKey(websiteId), JSON.stringify(value));
+  } catch {
+  }
+}
+function readCookie(name) {
+  if (typeof document === "undefined") return void 0;
+  try {
+    const prefix = `${name}=`;
+    return document.cookie.split(";").map((part) => part.trim()).find((part) => part.startsWith(prefix))?.slice(prefix.length);
+  } catch {
+    return void 0;
+  }
+}
+function validMetaBrowserId(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length <= 512 && META_BROWSER_ID_PATTERN.test(normalized) ? normalized : void 0;
+}
+function optional(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized.slice(0, 500) : void 0;
+}
+function buildTouchpoint() {
+  if (typeof window === "undefined") return null;
+  const params = getAllowedMarketingParameters(window.location.href);
+  const referrerHost = (() => {
+    if (!document.referrer) return void 0;
+    try {
+      const hostname = new URL(document.referrer).hostname;
+      return hostname === window.location.hostname ? void 0 : hostname.slice(0, 255);
+    } catch {
+      return void 0;
+    }
+  })();
+  return {
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    landingUrl: sanitizeMarketingUrl(window.location.href),
+    referrerHost,
+    source: optional(params.utm_source),
+    medium: optional(params.utm_medium),
+    campaign: optional(params.utm_campaign),
+    term: optional(params.utm_term),
+    content: optional(params.utm_content),
+    sourcePlatform: optional(params.utm_source_platform),
+    campaignId: optional(params.utm_id),
+    gclid: optional(params.gclid),
+    gbraid: optional(params.gbraid),
+    wbraid: optional(params.wbraid),
+    fbclid: optional(params.fbclid),
+    ttclid: optional(params.ttclid),
+    msclkid: optional(params.msclkid)
+  };
+}
+function isNonDirect(touchpoint) {
+  return Boolean(
+    touchpoint.source || touchpoint.medium || touchpoint.campaign || touchpoint.gclid || touchpoint.gbraid || touchpoint.wbraid || touchpoint.fbclid || touchpoint.ttclid || touchpoint.msclkid || touchpoint.referrerHost
+  );
+}
+function toPublic(stored) {
+  return {
+    schemaVersion: 1,
+    firstTouch: stored.firstTouch,
+    lastNonDirectTouch: stored.lastNonDirectTouch,
+    ga4ClientId: stored.ga4ClientId,
+    ga4SessionId: stored.ga4SessionId,
+    metaFbp: stored.metaFbp,
+    metaFbc: stored.metaFbc,
+    clientUserAgent: stored.clientUserAgent,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    expiresAt: stored.expiresAt
+  };
+}
+function refreshWebsiteMarketingMetaContext(websiteId) {
+  try {
+    const stored = readStored(websiteId);
+    if (!stored || typeof window === "undefined") return false;
+    const fbp = validMetaBrowserId(readCookie("_fbp"));
+    const clickTouchpoint = stored.lastNonDirectTouch ?? stored.firstTouch;
+    const derivedFbc = clickTouchpoint.fbclid ? `fb.1.${new Date(clickTouchpoint.capturedAt).getTime()}.${clickTouchpoint.fbclid}` : void 0;
+    const fbc = validMetaBrowserId(readCookie("_fbc") ?? derivedFbc);
+    const clientUserAgent = window.navigator?.userAgent.trim().slice(0, 1024);
+    writeStored(websiteId, {
+      ...stored,
+      metaFbp: fbp ?? stored.metaFbp,
+      metaFbc: fbc ?? stored.metaFbc,
+      clientUserAgent: clientUserAgent || stored.clientUserAgent
+    });
+    return Boolean(fbp || fbc || clientUserAgent);
+  } catch {
+    return false;
+  }
+}
+function storeWebsiteMarketingGa4ClientId(websiteId, clientId) {
+  if (typeof clientId !== "string") return false;
+  const normalized = clientId.trim();
+  if (!GA4_CLIENT_ID_PATTERN.test(normalized)) return false;
+  const stored = readStored(websiteId);
+  if (!stored) return false;
+  writeStored(websiteId, { ...stored, ga4ClientId: normalized });
+  return true;
+}
+function storeWebsiteMarketingGa4SessionId(websiteId, sessionId) {
+  const normalized = typeof sessionId === "number" && Number.isSafeInteger(sessionId) ? String(sessionId) : typeof sessionId === "string" ? sessionId.trim() : "";
+  const numericValue = Number(normalized);
+  if (!/^\d{1,16}$/.test(normalized) || !Number.isSafeInteger(numericValue) || numericValue <= 0) {
+    return false;
+  }
+  const stored = readStored(websiteId);
+  if (!stored) return false;
+  writeStored(websiteId, { ...stored, ga4SessionId: normalized });
+  return true;
+}
+function captureWebsiteMarketingAttribution(websiteId, windowDays) {
+  const current = buildTouchpoint();
+  if (!current) return null;
+  const stored = readStored(websiteId);
+  const expiresAt = stored?.expiresAt ?? new Date(Date.now() + Math.max(1, windowDays) * 864e5).toISOString();
+  const next = {
+    firstTouch: stored?.firstTouch ?? current,
+    lastNonDirectTouch: isNonDirect(current) ? current : stored?.lastNonDirectTouch ?? null,
+    ga4ClientId: stored?.ga4ClientId,
+    ga4SessionId: stored?.ga4SessionId,
+    metaFbp: stored?.metaFbp,
+    metaFbc: stored?.metaFbc,
+    clientUserAgent: stored?.clientUserAgent,
+    expiresAt
+  };
+  writeStored(websiteId, next);
+  return toPublic(next);
+}
+function getWebsiteMarketingAttribution(websiteId) {
+  const stored = readStored(websiteId);
+  return stored ? toPublic(stored) : null;
+}
+function serializeTouchpoint(touchpoint) {
+  return {
+    captured_at: touchpoint.capturedAt,
+    landing_url: touchpoint.landingUrl,
+    referrer_host: touchpoint.referrerHost,
+    source: touchpoint.source,
+    medium: touchpoint.medium,
+    campaign: touchpoint.campaign,
+    term: touchpoint.term,
+    content: touchpoint.content,
+    source_platform: touchpoint.sourcePlatform,
+    campaign_id: touchpoint.campaignId,
+    gclid: touchpoint.gclid,
+    gbraid: touchpoint.gbraid,
+    wbraid: touchpoint.wbraid,
+    fbclid: touchpoint.fbclid,
+    ttclid: touchpoint.ttclid,
+    msclkid: touchpoint.msclkid
+  };
+}
+function serializeWebsiteMarketingAttribution(attribution) {
+  return {
+    schema_version: attribution.schemaVersion,
+    first_touch: serializeTouchpoint(attribution.firstTouch),
+    last_non_direct_touch: attribution.lastNonDirectTouch ? serializeTouchpoint(attribution.lastNonDirectTouch) : null,
+    ga4_client_id: attribution.ga4ClientId,
+    ga4_session_id: attribution.ga4SessionId,
+    meta_fbp: attribution.metaFbp,
+    meta_fbc: attribution.metaFbc,
+    client_user_agent: attribution.clientUserAgent,
+    captured_at: attribution.capturedAt
+  };
+}
+
 // libs/sdk/src/modules/cart.ts
 function mapCartItem(raw) {
   return {
@@ -2411,7 +3036,8 @@ function createCartModule(graphqlUrl, getHeaders, getContext, cartSessionStorage
           items: input.items.map((item) => ({
             product_variant_id: item.productVariantId,
             quantity: item.quantity
-          }))
+          })),
+          marketingAttribution: input.marketingAttribution ? serializeWebsiteMarketingAttribution(input.marketingAttribution) : void 0
         },
         getHeaders
       );
@@ -2533,7 +3159,9 @@ function createCartSessionStorage(kind, getSlug) {
           const key = readKey();
           const match = document.cookie.split("; ").find((row) => row.startsWith(`${key}=`));
           if (!match) return null;
-          return JSON.parse(decodeURIComponent(match.split("=").slice(1).join("=")));
+          return JSON.parse(
+            decodeURIComponent(match.split("=").slice(1).join("="))
+          );
         } catch {
           return null;
         }
@@ -2573,46 +3201,129 @@ function createCartSessionStorage(kind, getSlug) {
   };
 }
 
-// libs/sdk/src/media.ts
-var MEDIA_VARIANTS = {
-  thumbnail: { width: 240, quality: 75, format: "webp" },
-  card: { width: 640, quality: 80, format: "webp" },
-  detail: { width: 1400, quality: 85, format: "webp" }
-};
-function toSafeInteger(value) {
-  if (!Number.isFinite(value)) return void 0;
-  return Math.max(1, Math.floor(value));
-}
-function buildQuery(options) {
-  const params = new URLSearchParams();
-  const width = toSafeInteger(options.width);
-  const height = toSafeInteger(options.height);
-  const quality = toSafeInteger(options.quality);
-  if (width) params.set("w", String(width));
-  if (height) params.set("h", String(height));
-  if (quality) params.set("q", String(Math.min(100, quality)));
-  if (options.format) params.set("f", options.format);
-  const query = params.toString();
-  return query ? `?${query}` : "";
-}
-function buildStorageFileUrl(storageUrl, fileId, variant = "original") {
-  if (!storageUrl || !fileId) return "";
-  const baseUrl = `${storageUrl.replace(/\/+$/, "")}/files/${fileId}`;
-  if (variant === "original") return baseUrl;
-  return `${baseUrl}${buildQuery(MEDIA_VARIANTS[variant])}`;
-}
-function buildStorageMediaUrls(storageUrl, fileId) {
-  return {
-    originalUrl: buildStorageFileUrl(storageUrl, fileId, "original"),
-    thumbnailUrl: buildStorageFileUrl(storageUrl, fileId, "thumbnail"),
-    cardUrl: buildStorageFileUrl(storageUrl, fileId, "card"),
-    detailUrl: buildStorageFileUrl(storageUrl, fileId, "detail")
+// libs/sdk/src/modules/static-catalog.ts
+var STATIC_CATALOG_PAGE_SIZE = 100;
+var STATIC_CATALOG_MAX_PRODUCTS = 1e4;
+var STATIC_CATALOG_INITIAL_PAGE_SIZE = 24;
+async function collectStaticCatalog({
+  websiteId,
+  snapshot: options,
+  bootstrap,
+  loadPage
+}) {
+  const pageSize = options.pageSize ?? STATIC_CATALOG_PAGE_SIZE;
+  const maxProducts = options.maxProducts ?? STATIC_CATALOG_MAX_PRODUCTS;
+  const initialPageSize = bootstrap?.initialPageSize ?? STATIC_CATALOG_INITIAL_PAGE_SIZE;
+  const sortBy = bootstrap?.sortBy ?? "name_asc";
+  if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) {
+    throw new WebsiteError(
+      "Static catalog pageSize must be an integer between 1 and 100.",
+      "INVALID_STATIC_CATALOG_PAGE_SIZE"
+    );
+  }
+  if (!Number.isInteger(maxProducts) || maxProducts < 1 || maxProducts > STATIC_CATALOG_MAX_PRODUCTS) {
+    throw new WebsiteError(
+      `Static catalog maxProducts must be an integer between 1 and ${STATIC_CATALOG_MAX_PRODUCTS}.`,
+      "INVALID_STATIC_CATALOG_MAX_PRODUCTS"
+    );
+  }
+  if (bootstrap && (!Number.isInteger(initialPageSize) || initialPageSize < 1 || initialPageSize > 100)) {
+    throw new WebsiteError(
+      "Static catalog initialPageSize must be an integer between 1 and 100.",
+      "INVALID_STATIC_CATALOG_INITIAL_PAGE_SIZE"
+    );
+  }
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const products = [];
+  let pageCount = 0;
+  let expectedTotal = null;
+  let firstPage = null;
+  for (let offset = 0; ; ) {
+    const includeBootstrapData = Boolean(bootstrap && offset === 0);
+    const requestLimit = includeBootstrapData ? Math.max(pageSize, initialPageSize) : pageSize;
+    const page = await loadPage({
+      categoryListKey: options.categoryListKey,
+      attributeListKey: options.attributeListKey,
+      sortBy,
+      limit: requestLimit,
+      offset,
+      include: {
+        products: true,
+        detailVariants: true,
+        categories: includeBootstrapData,
+        attributes: true,
+        filters: includeBootstrapData,
+        brands: includeBootstrapData,
+        debug: false
+      }
+    });
+    if (offset === 0) firstPage = page;
+    pageCount += 1;
+    const pageTotal = page.pagination.total;
+    if (expectedTotal === null) {
+      expectedTotal = pageTotal;
+    } else if (pageTotal !== expectedTotal) {
+      throwCatalogChanged();
+    }
+    if (pageTotal > maxProducts) {
+      throw new WebsiteError(
+        `Static catalog contains ${pageTotal} products and exceeds maxProducts ${maxProducts}.`,
+        "STATIC_CATALOG_LIMIT_EXCEEDED"
+      );
+    }
+    products.push(...page.products);
+    if (!page.pagination.hasMore) break;
+    if (page.products.length === 0) {
+      throw new WebsiteError(
+        "Static catalog pagination did not advance.",
+        "STATIC_CATALOG_PAGINATION_STALLED"
+      );
+    }
+    offset += page.products.length;
+  }
+  const total = expectedTotal ?? 0;
+  const uniqueProductIds = new Set(products.map((product) => product.id));
+  if (products.length !== total || uniqueProductIds.size !== total) {
+    throwCatalogChanged();
+  }
+  const snapshot = {
+    schemaVersion: 1,
+    snapshotId: `${websiteId}:${generatedAt}`,
+    generatedAt,
+    websiteId,
+    products,
+    total,
+    pageSize,
+    pageCount
   };
+  const initialPage = bootstrap && firstPage ? {
+    ...firstPage,
+    products: firstPage.products.slice(0, initialPageSize),
+    pagination: {
+      ...firstPage.pagination,
+      limit: initialPageSize,
+      offset: 0,
+      hasMore: total > initialPageSize
+    }
+  } : null;
+  return { snapshot, initialPage };
+}
+function throwCatalogChanged() {
+  throw new WebsiteError(
+    "Static catalog changed while it was being collected. Retry the build to get a consistent snapshot.",
+    "STATIC_CATALOG_CHANGED_DURING_BUILD"
+  );
 }
 
 // libs/sdk/src/modules/catalog.ts
 var MAX_AVAILABILITY_VARIANT_IDS2 = 100;
 var DEFAULT_FILTER_ATTRIBUTE_LIST_KEY = "atributos";
+var MAX_LIVE_STATE_VARIANT_IDS = 100;
+var STATIC_CATALOG_RETRY = {
+  maxAttempts: 4,
+  maxTotalWaitMs: 3 * 60 * 1e3,
+  jitterRatio: 0.1
+};
 function mapPrice(raw) {
   return {
     id: raw.id,
@@ -2645,6 +3356,9 @@ function getProductImages(media) {
 function getProductVideos(media) {
   return getProductMediaByKind(media, "video");
 }
+function getProductDetailVariants(product) {
+  return product.detailVariants ?? product.variants;
+}
 function getPrimaryProductImage(media) {
   return getProductImages(media)[0] ?? null;
 }
@@ -2802,6 +3516,9 @@ function mapRelatedProduct(raw, storageUrl) {
   };
 }
 function mapProduct(raw, storageUrl, labels, chainId) {
+  const detailVariants = raw.product_variants.map((variant) => mapVariant(variant, labels, chainId)).filter((variant) => variant.pricing.currentPrice != null);
+  const listingVariantIds = raw.listing_variant_ids ? new Set(raw.listing_variant_ids) : null;
+  const variants = listingVariantIds ? detailVariants.filter((variant) => listingVariantIds.has(variant.id)) : detailVariants;
   return {
     id: raw.id,
     name: raw.name,
@@ -2818,9 +3535,8 @@ function mapProduct(raw, storageUrl, labels, chainId) {
     measurementUnit: raw.measurement_unit,
     createdAt: raw.created_at,
     updatedAt: raw.updated_at ?? raw.created_at,
-    variants: raw.product_variants.map(
-      (variant) => mapVariant(variant, labels, chainId)
-    ),
+    variants,
+    detailVariants,
     media: raw.product_media.map((m) => mapMedia(m, storageUrl)),
     attributes: raw.product_attributes.map(
       (attribute) => mapProductAttribute(attribute, labels)
@@ -3263,15 +3979,171 @@ function createCatalogModule(graphqlUrl, getHeaders, getContext, storageUrl) {
     const publicAttributeLabels = buildPublicAttributeLabels(
       data.catalog_attribute_lists
     );
+    const mappedProduct = mapProduct(
+      product,
+      storageUrl,
+      publicAttributeLabels,
+      ctx.chainId
+    );
     const filteredProducts = await filterProductsForWebsiteStock(
       graphqlUrl,
       getHeaders,
-      [mapProduct(product, storageUrl, publicAttributeLabels, ctx.chainId)],
+      [mappedProduct],
       ctx.chainId
     );
-    return filteredProducts[0] ?? null;
+    if (!filteredProducts[0]) return null;
+    return {
+      ...mappedProduct,
+      variants: getProductDetailVariants(mappedProduct)
+    };
+  };
+  const loadCatalogPage = async (opts, retryRateLimits = false) => {
+    const ctx = getContext();
+    if (!ctx.chainId) {
+      throw new WebsiteError(
+        "This website has no chain configured. Catalog requires a chain_id.",
+        "NO_CHAIN"
+      );
+    }
+    const chainId = ctx.chainId;
+    const filters = {
+      category_slug: opts.categorySlug,
+      subcategory_slug: opts.subcategorySlug,
+      tags: opts.tags,
+      search: opts.search,
+      brand_id: opts.brandId,
+      min_price: opts.minPrice,
+      max_price: opts.maxPrice,
+      attributes_by_slug: opts.attributesBySlug,
+      sort_by: opts.sortBy,
+      limit: opts.limit,
+      offset: opts.offset
+    };
+    const data = await executeGraphQL(
+      graphqlUrl,
+      WEBSITE_GET_CATALOG_PAGE,
+      {
+        websiteId: ctx.websiteId,
+        categoryListKey: opts.categoryListKey,
+        attributeListKey: opts.attributeListKey,
+        filters,
+        include: opts.include
+      },
+      getHeaders,
+      retryRateLimits ? { retry: STATIC_CATALOG_RETRY } : void 0
+    );
+    if (!data.result.success) {
+      throw new WebsiteError(
+        data.result.errors.join("; ") || "Unable to resolve catalog page",
+        "CATALOG_PAGE_ERROR"
+      );
+    }
+    const products = parseActionJson(data.result.products, []);
+    const categoryList = parseActionJson(
+      data.result.category_list,
+      null
+    );
+    const attributeList = parseActionJson(
+      data.result.attribute_list,
+      null
+    );
+    const filtersResult = parseActionJson(
+      data.result.filters,
+      null
+    );
+    const brands = parseActionJson(data.result.brands, []);
+    const pagination = parseActionJson(
+      data.result.pagination,
+      {
+        limit: opts.limit ?? 24,
+        offset: opts.offset ?? 0,
+        total: 0,
+        hasMore: false
+      }
+    );
+    const appliedFilters = parseActionJson(
+      data.result.applied_filters,
+      {}
+    );
+    const debug = parseActionJson(
+      data.result.debug,
+      null
+    );
+    const labels = buildPublicAttributeLabels(
+      attributeList ? [attributeList] : []
+    );
+    return {
+      products: products.map(
+        (product) => mapProduct(product, storageUrl, labels, chainId)
+      ),
+      categories: categoryList ? mapCategoryList(categoryList) : null,
+      attributes: attributeList ? mapAttributeList(attributeList) : null,
+      filters: filtersResult,
+      brands,
+      pagination,
+      appliedFilters,
+      debug
+    };
   };
   return {
+    async getProductLiveState(productVariantIds) {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Product live state requires a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const chainId = ctx.chainId;
+      const variantIds = [...new Set(productVariantIds)];
+      if (variantIds.length === 0) return [];
+      if (variantIds.length > MAX_LIVE_STATE_VARIANT_IDS) {
+        throw new WebsiteError(
+          `Product live state accepts at most ${MAX_LIVE_STATE_VARIANT_IDS} variants per request.`,
+          "PRODUCT_LIVE_STATE_LIMIT_EXCEEDED"
+        );
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PRODUCT_LIVE_STATE,
+        {
+          variantIds,
+          companyId: ctx.companyId,
+          chainId,
+          websiteId: ctx.websiteId
+        },
+        getHeaders
+      );
+      const variantsById = new Map(
+        (data.product_variants ?? []).map((variant) => [variant.id, variant])
+      );
+      const availabilityById = new Map(
+        (data.websiteProductAvailability ?? []).map((availability) => [
+          availability.product_variant_id,
+          availability
+        ])
+      );
+      return variantIds.flatMap((variantId) => {
+        const variant = variantsById.get(variantId);
+        if (!variant) return [];
+        const availability = availabilityById.get(variantId);
+        const pricing = resolveProductPricing(
+          selectPublicPrices(
+            variant.product_variant_prices.map(mapPrice),
+            chainId
+          )
+        );
+        return [
+          {
+            productVariantId: variantId,
+            inStock: availability?.in_stock ?? false,
+            availabilityLabel: availability?.label ?? "Agotado",
+            maxPurchasableQuantity: availability?.max_purchasable_quantity ?? 0,
+            pricing
+          }
+        ];
+      });
+    },
     async getProductRecommendations(opts) {
       const ctx = getContext();
       const limit = opts.limit ?? 16;
@@ -3346,86 +4218,36 @@ function createCatalogModule(graphqlUrl, getHeaders, getContext, storageUrl) {
         }
       };
     },
-    async getCatalogPage(opts) {
+    getCatalogPage: loadCatalogPage,
+    async getStaticCatalogSnapshot(opts) {
       const ctx = getContext();
-      if (!ctx.chainId) {
-        throw new WebsiteError(
-          "This website has no chain configured. Catalog requires a chain_id.",
-          "NO_CHAIN"
-        );
-      }
-      const chainId = ctx.chainId;
-      const filters = {
-        category_slug: opts.categorySlug,
-        subcategory_slug: opts.subcategorySlug,
-        tags: opts.tags,
-        search: opts.search,
-        brand_id: opts.brandId,
-        min_price: opts.minPrice,
-        max_price: opts.maxPrice,
-        attributes_by_slug: opts.attributesBySlug,
-        sort_by: opts.sortBy,
-        limit: opts.limit,
-        offset: opts.offset
-      };
-      const data = await executeGraphQL(
-        graphqlUrl,
-        WEBSITE_GET_CATALOG_PAGE,
-        {
-          websiteId: ctx.websiteId,
-          categoryListKey: opts.categoryListKey,
-          attributeListKey: opts.attributeListKey,
-          filters,
-          include: opts.include
+      return (await collectStaticCatalog({
+        websiteId: ctx.websiteId,
+        snapshot: opts,
+        loadPage: (options) => loadCatalogPage(options, true)
+      })).snapshot;
+    },
+    async getStaticCatalogBootstrap(opts) {
+      const ctx = getContext();
+      const { snapshot, initialPage } = await collectStaticCatalog({
+        websiteId: ctx.websiteId,
+        snapshot: opts,
+        bootstrap: {
+          initialPageSize: opts.initialPageSize,
+          sortBy: opts.sortBy
         },
-        getHeaders
-      );
-      if (!data.result.success) {
+        loadPage: (options) => loadCatalogPage(options, true)
+      });
+      if (!initialPage) {
         throw new WebsiteError(
-          data.result.errors.join("; ") || "Unable to resolve catalog page",
-          "CATALOG_PAGE_ERROR"
+          "Static catalog bootstrap could not resolve its initial page.",
+          "STATIC_CATALOG_BOOTSTRAP_MISSING_INITIAL_PAGE"
         );
       }
-      const products = parseActionJson(data.result.products, []);
-      const categoryList = parseActionJson(
-        data.result.category_list,
-        null
-      );
-      const attributeList = parseActionJson(
-        data.result.attribute_list,
-        null
-      );
-      const filtersResult = parseActionJson(
-        data.result.filters,
-        null
-      );
-      const brands = parseActionJson(data.result.brands, []);
-      const pagination = parseActionJson(
-        data.result.pagination,
-        { limit: opts.limit ?? 24, offset: opts.offset ?? 0, total: 0, hasMore: false }
-      );
-      const appliedFilters = parseActionJson(
-        data.result.applied_filters,
-        {}
-      );
-      const debug = parseActionJson(
-        data.result.debug,
-        null
-      );
-      const labels = buildPublicAttributeLabels(
-        attributeList ? [attributeList] : []
-      );
       return {
-        products: products.map(
-          (product) => mapProduct(product, storageUrl, labels, chainId)
-        ),
-        categories: categoryList ? mapCategoryList(categoryList) : null,
-        attributes: attributeList ? mapAttributeList(attributeList) : null,
-        filters: filtersResult,
-        brands,
-        pagination,
-        appliedFilters,
-        debug
+        ...snapshot,
+        bootstrapSchemaVersion: 1,
+        initialPage
       };
     },
     async getProducts(opts) {
@@ -3892,6 +4714,7 @@ function mapCouponResult(raw) {
   };
 }
 function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionStorage) {
+  let shippingPolicyCache = null;
   return {
     async getLocationOptions() {
       const context = getContext();
@@ -3989,22 +4812,39 @@ function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionSto
       }));
     },
     async getShippingPolicy() {
+      const now = Date.now();
+      if (shippingPolicyCache && shippingPolicyCache.expiresAt > now) {
+        return shippingPolicyCache.request;
+      }
       const context = getContext();
-      const data = await executeGraphQL(
+      const request = executeGraphQL(
         graphqlUrl,
         GET_SHIPPING_POLICY,
         { websiteId: context.websiteId },
         getHeaders
-      );
-      const result = data.websiteGetShippingPolicy;
-      if (!result.success || !result.policy) {
-        throw new CheckoutError(result.errors ?? ["SHIPPING_POLICY_FAILED"]);
-      }
-      return {
-        freeShippingEnabled: result.policy.free_shipping_enabled,
-        freeShippingThreshold: result.policy.free_shipping_threshold,
-        currency: result.policy.currency
+      ).then((data) => {
+        const result = data.websiteGetShippingPolicy;
+        if (!result.success || !result.policy) {
+          throw new CheckoutError(result.errors ?? ["SHIPPING_POLICY_FAILED"]);
+        }
+        return {
+          freeShippingEnabled: result.policy.free_shipping_enabled,
+          freeShippingThreshold: result.policy.free_shipping_threshold,
+          currency: result.policy.currency
+        };
+      });
+      shippingPolicyCache = {
+        expiresAt: now + 5 * 60 * 1e3,
+        request
       };
+      try {
+        return await request;
+      } catch (error) {
+        if (shippingPolicyCache?.request === request) {
+          shippingPolicyCache = null;
+        }
+        throw error;
+      }
     },
     async getFreeShippingProgress(input) {
       if (input.items.length === 0) {
@@ -4170,6 +5010,13 @@ function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionSto
           initialPayment: input.initialPayment ? {
             amount: input.initialPayment.amount,
             payment_method_id: input.initialPayment.paymentMethodId
+          } : void 0,
+          marketingAttribution: input.marketingAttribution ? serializeWebsiteMarketingAttribution(input.marketingAttribution) : void 0,
+          advertisingConsent: input.advertisingConsent ? {
+            policy_id: input.advertisingConsent.policyId,
+            policy_version: input.advertisingConsent.policyVersion,
+            statement_hash: input.advertisingConsent.statementHash,
+            granted: input.advertisingConsent.granted
           } : void 0
         },
         getHeaders
@@ -4305,18 +5152,23 @@ function readOptionalText(value) {
 function enrichMediaValue(value, storageUrl) {
   const fileId = typeof value.fileId === "string" && value.fileId.trim() ? value.fileId.trim() : "";
   if (!fileId) return value;
-  const urls = buildStorageMediaUrls(storageUrl, fileId);
+  const isProductMedia = typeof value.id === "string" && typeof value.order === "number";
+  const isEditorialImage = value.mediaKind === "image" && !isProductMedia;
+  const originalWidth = typeof value.originalWidth === "number" ? value.originalWidth : null;
+  const urls = isEditorialImage ? buildStorageContentMediaUrls(storageUrl, fileId, originalWidth) : buildStorageMediaUrls(storageUrl, fileId);
   return {
     ...value,
     ...urls,
-    url: value.url ?? urls.originalUrl
+    url: value.url ?? urls.originalUrl,
+    src: value.src ?? value.url ?? urls.originalUrl
   };
 }
 function normalizeRichTextNode(value, storageUrl) {
   const type = value.type;
   const attrs = isRecord(value.attrs) ? value.attrs : null;
   if (attrs && (type === "bacanoImage" || type === "bacanoVideo") && typeof attrs.fileId === "string") {
-    const urls = buildStorageMediaUrls(storageUrl, attrs.fileId);
+    const originalWidth = typeof attrs.originalWidth === "number" ? attrs.originalWidth : null;
+    const urls = type === "bacanoImage" ? buildStorageContentMediaUrls(storageUrl, attrs.fileId, originalWidth) : buildStorageMediaUrls(storageUrl, attrs.fileId);
     const altText = readOptionalText(attrs.altText) ?? readOptionalText(attrs.alt);
     const caption = readOptionalText(attrs.caption);
     const showCaption = Boolean(caption) && attrs.showCaption !== false;
@@ -4448,6 +5300,452 @@ function createContentModule(graphqlUrl, getHeaders, getContext, storageUrl) {
   };
 }
 
+// libs/sdk/src/marketing/clarity.ts
+var initializedDestinations = /* @__PURE__ */ new Set();
+function clarityWindow() {
+  return typeof window === "undefined" ? null : window;
+}
+function prepareClarity(projectId) {
+  const target = clarityWindow();
+  if (!target || initializedDestinations.has(projectId)) return;
+  if (!target.clarity) {
+    const clarity = function() {
+      clarity.q ??= [];
+      clarity.q.push(arguments);
+    };
+    target.clarity = clarity;
+  }
+  initializedDestinations.add(projectId);
+}
+function loadClarityScript(projectId) {
+  if (typeof document === "undefined") return;
+  const id = `bacano-clarity-${projectId}`;
+  if (document.getElementById(id)) return;
+  const script = document.createElement("script");
+  script.id = id;
+  script.async = true;
+  script.src = `https://www.clarity.ms/tag/${encodeURIComponent(projectId)}`;
+  script.referrerPolicy = "strict-origin-when-cross-origin";
+  document.head.appendChild(script);
+}
+function sendClarityEvent(eventName) {
+  clarityWindow()?.clarity?.("event", eventName);
+}
+
+// libs/sdk/src/marketing/domain.ts
+function matchesCanonicalMarketingHost(canonicalDomain, currentHostname) {
+  if (canonicalDomain === void 0) return true;
+  if (!canonicalDomain?.trim()) return false;
+  try {
+    const configuredHost = new URL(
+      canonicalDomain.includes("://") ? canonicalDomain : `https://${canonicalDomain}`
+    ).hostname.toLowerCase();
+    return currentHostname.toLowerCase() === configuredHost;
+  } catch {
+    return false;
+  }
+}
+
+// libs/sdk/src/marketing/ga4.ts
+function mapGa4Items(items) {
+  return items?.map((item) => ({
+    item_id: item.itemId,
+    item_name: item.itemName,
+    item_variant: item.itemVariant,
+    item_brand: item.itemBrand,
+    item_category: item.itemCategory,
+    price: item.price,
+    quantity: item.quantity,
+    index: item.index,
+    sku: item.sku
+  }));
+}
+
+// libs/sdk/src/marketing/types.ts
+var MARKETING_SCHEMA_VERSION = 1;
+var WEBSITE_MARKETING_CONTACT_PLACEMENTS = [
+  "product_detail",
+  "floating",
+  "header",
+  "footer",
+  "contact_page"
+];
+
+// libs/sdk/src/marketing/runtime.ts
+var initializedGa4Destinations = /* @__PURE__ */ new Set();
+var initializedMetaDestinations = /* @__PURE__ */ new Set();
+function marketingWindow() {
+  return typeof window === "undefined" ? null : window;
+}
+function loadScriptOnce(id, source) {
+  if (typeof document === "undefined" || document.getElementById(id)) return;
+  const script = document.createElement("script");
+  script.id = id;
+  script.async = true;
+  script.src = source;
+  script.referrerPolicy = "strict-origin-when-cross-origin";
+  document.head.appendChild(script);
+}
+function prepareGa4(measurementId) {
+  const target = marketingWindow();
+  if (!target) return;
+  if (initializedGa4Destinations.has(measurementId)) return;
+  target.dataLayer ??= [];
+  target.gtag ??= function() {
+    target.dataLayer?.push(arguments);
+  };
+  target.gtag("js", /* @__PURE__ */ new Date());
+  target.gtag("config", measurementId, { send_page_view: false });
+  initializedGa4Destinations.add(measurementId);
+}
+function loadGa4Script(measurementId) {
+  loadScriptOnce(
+    `bacano-ga4-${measurementId}`,
+    `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(measurementId)}`
+  );
+}
+function captureGa4ClientId(measurementId, websiteId, diagnostic) {
+  const target = marketingWindow();
+  target?.gtag?.("get", measurementId, "client_id", (clientId) => {
+    if (storeWebsiteMarketingGa4ClientId(websiteId, clientId)) return;
+    diagnostic?.({
+      level: "warning",
+      code: "GA4_CLIENT_ID_UNAVAILABLE",
+      message: "GA4 did not provide a valid browser client identifier"
+    });
+  });
+}
+function captureGa4SessionId(measurementId, websiteId, diagnostic) {
+  const target = marketingWindow();
+  target?.gtag?.("get", measurementId, "session_id", (sessionId) => {
+    if (storeWebsiteMarketingGa4SessionId(websiteId, sessionId)) return;
+    diagnostic?.({
+      level: "warning",
+      code: "GA4_SESSION_ID_UNAVAILABLE",
+      message: "GA4 did not provide a valid browser session identifier"
+    });
+  });
+}
+function prepareMeta(pixelId) {
+  const target = marketingWindow();
+  if (!target) return;
+  if (initializedMetaDestinations.has(pixelId)) return;
+  if (!target.fbq) {
+    const queue = [];
+    const fbq = ((...args) => {
+      if (fbq.callMethod) {
+        fbq.callMethod(...args);
+        return;
+      }
+      queue.push(args);
+    });
+    fbq.push = fbq;
+    fbq.loaded = true;
+    fbq.version = "2.0";
+    fbq.queue = queue;
+    target.fbq = fbq;
+    target._fbq = fbq;
+  }
+  target.fbq("init", pixelId);
+  initializedMetaDestinations.add(pixelId);
+}
+function loadMetaScript() {
+  loadScriptOnce(
+    "bacano-meta-pixel",
+    "https://connect.facebook.net/en_US/fbevents.js"
+  );
+}
+function scheduleScriptLoad(load, strategy) {
+  const target = marketingWindow();
+  if (!target || strategy !== "idle") {
+    load();
+    return () => void 0;
+  }
+  let completed = false;
+  let idleHandle = null;
+  let timeoutHandle = null;
+  const interactionEvents = ["pointerdown", "keydown", "touchstart"];
+  const cleanup = () => {
+    for (const eventName of interactionEvents) {
+      target.removeEventListener(eventName, finish, true);
+    }
+    if (idleHandle !== null) target.cancelIdleCallback?.(idleHandle);
+    if (timeoutHandle !== null) target.clearTimeout(timeoutHandle);
+  };
+  const finish = () => {
+    if (completed) return;
+    completed = true;
+    cleanup();
+    load();
+  };
+  for (const eventName of interactionEvents) {
+    target.addEventListener(eventName, finish, {
+      capture: true,
+      once: true,
+      passive: true
+    });
+  }
+  if (target.requestIdleCallback) {
+    idleHandle = target.requestIdleCallback(finish, { timeout: 2e3 });
+  } else {
+    timeoutHandle = target.setTimeout(finish, 1500);
+  }
+  return cleanup;
+}
+function metaEventName(eventName) {
+  const standard = {
+    page_view: "PageView",
+    search: "Search",
+    view_item: "ViewContent",
+    add_to_cart: "AddToCart",
+    begin_checkout: "InitiateCheckout",
+    add_payment_info: "AddPaymentInfo",
+    contact: "Contact"
+  };
+  return standard[eventName] ?? eventName;
+}
+function isWebsiteMarketingContactPlacement(value) {
+  return WEBSITE_MARKETING_CONTACT_PLACEMENTS.some(
+    (candidate) => candidate === value
+  );
+}
+function contactPlacementFor(event) {
+  const placement = event.contactPlacement;
+  if (event.eventName !== "contact" || !isWebsiteMarketingContactPlacement(placement)) {
+    return void 0;
+  }
+  return placement;
+}
+function sendGa4(event, diagnosticMode) {
+  const target = marketingWindow();
+  const contactPlacement = contactPlacementFor(event);
+  target?.gtag?.("event", event.eventName, {
+    currency: event.currency,
+    value: event.value,
+    search_term: event.searchTerm,
+    item_list_id: event.itemListId,
+    item_list_name: event.itemListName,
+    shipping_tier: event.shippingTier,
+    payment_type: event.paymentType,
+    method: event.contactMethod,
+    ...contactPlacement ? { contact_placement: contactPlacement } : void 0,
+    page_location: event.pageLocation,
+    page_title: event.pageTitle,
+    items: mapGa4Items(event.items),
+    event_id: event.eventId,
+    debug_mode: diagnosticMode ? true : void 0
+  });
+}
+function sendMeta(event) {
+  const target = marketingWindow();
+  const eventName = metaEventName(event.eventName);
+  const isStandard = eventName !== event.eventName;
+  const contactPlacement = contactPlacementFor(event);
+  target?.fbq?.(
+    isStandard ? "track" : "trackCustom",
+    eventName,
+    {
+      currency: event.currency,
+      value: event.value,
+      search_string: event.searchTerm,
+      content_ids: event.items?.map((item) => item.itemId),
+      contents: event.items?.map((item) => ({
+        id: item.itemId,
+        quantity: item.quantity ?? 1,
+        item_price: item.price
+      })),
+      content_type: event.items?.length ? "product" : void 0,
+      contact_method: event.contactMethod,
+      ...contactPlacement ? { contact_placement: contactPlacement } : void 0
+    },
+    { eventID: event.eventId }
+  );
+}
+function newEventId() {
+  return typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+function createWebsiteMarketingRuntime(options) {
+  let destroyed = false;
+  let cancelScheduledLoad = () => void 0;
+  const target = marketingWindow();
+  const enabled = options.config.enabled && Boolean(
+    target && matchesCanonicalMarketingHost(
+      options.canonicalDomain,
+      target.location.hostname
+    )
+  ) && Boolean(
+    options.config.destinations.ga4 || options.config.destinations.meta || options.config.destinations.clarity
+  );
+  if (enabled) {
+    try {
+      if (options.config.destinations.ga4) {
+        prepareGa4(options.config.destinations.ga4.measurementId);
+      }
+      if (options.config.destinations.meta) {
+        prepareMeta(options.config.destinations.meta.pixelId);
+      }
+      if (options.config.destinations.clarity) {
+        prepareClarity(options.config.destinations.clarity.projectId);
+      }
+      cancelScheduledLoad = scheduleScriptLoad(() => {
+        if (destroyed) return;
+        if (options.config.destinations.ga4) {
+          loadGa4Script(options.config.destinations.ga4.measurementId);
+        }
+        if (options.config.destinations.meta) loadMetaScript();
+        if (options.config.destinations.clarity) {
+          loadClarityScript(options.config.destinations.clarity.projectId);
+        }
+      }, options.scriptLoadStrategy);
+      captureWebsiteMarketingAttribution(
+        options.websiteId,
+        options.config.attributionWindowDays
+      );
+      if (options.config.destinations.ga4) {
+        captureGa4ClientId(
+          options.config.destinations.ga4.measurementId,
+          options.websiteId,
+          options.diagnostic
+        );
+        captureGa4SessionId(
+          options.config.destinations.ga4.measurementId,
+          options.websiteId,
+          options.diagnostic
+        );
+      }
+      if (options.config.destinations.meta) {
+        refreshWebsiteMarketingMetaContext(options.websiteId);
+      }
+    } catch (error) {
+      options.diagnostic?.({
+        level: "warning",
+        code: "RUNTIME_INITIALIZATION_FAILED",
+        message: error instanceof Error ? error.message : "Initialization failed"
+      });
+    }
+  }
+  return {
+    enabled,
+    track(input) {
+      if (!enabled || destroyed) return;
+      const event = {
+        ...input,
+        schemaVersion: 1,
+        eventId: input.eventId ?? newEventId(),
+        occurredAt: input.occurredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        currency: input.currency ?? options.config.currencyCode,
+        pageLocation: sanitizeMarketingUrl(
+          input.pageLocation ?? (typeof window === "undefined" ? "" : window.location.href)
+        )
+      };
+      try {
+        if (options.config.destinations.ga4) {
+          sendGa4(event, options.config.destinations.ga4.diagnosticMode);
+        }
+        if (options.config.destinations.meta) sendMeta(event);
+        if (options.config.destinations.clarity) {
+          sendClarityEvent(event.eventName);
+        }
+        options.diagnostic?.({
+          level: "debug",
+          code: "EVENT_DISPATCHED",
+          message: "Marketing event dispatched",
+          eventName: event.eventName
+        });
+      } catch (error) {
+        options.diagnostic?.({
+          level: "warning",
+          code: "EVENT_DISPATCH_FAILED",
+          message: error instanceof Error ? error.message : "Dispatch failed",
+          eventName: event.eventName
+        });
+      }
+    },
+    captureAttribution() {
+      if (!enabled) return null;
+      captureWebsiteMarketingAttribution(
+        options.websiteId,
+        options.config.attributionWindowDays
+      );
+      if (options.config.destinations.meta) {
+        refreshWebsiteMarketingMetaContext(options.websiteId);
+      }
+      return getWebsiteMarketingAttribution(options.websiteId);
+    },
+    getAttribution() {
+      if (!enabled) return null;
+      if (options.config.destinations.meta) {
+        refreshWebsiteMarketingMetaContext(options.websiteId);
+      }
+      return getWebsiteMarketingAttribution(options.websiteId);
+    },
+    destroy() {
+      destroyed = true;
+      cancelScheduledLoad();
+    }
+  };
+}
+
+// libs/sdk/src/modules/marketing.ts
+function readRetryAfter(response) {
+  const value = Number(response.headers.get("Retry-After") ?? "1");
+  return Number.isFinite(value) && value >= 0 ? Math.ceil(value) : 1;
+}
+function createMarketingModule(apiUrl, websiteSlug, getContext) {
+  return {
+    async captureLead(input) {
+      const context = getContext();
+      const attribution = getWebsiteMarketingAttribution(context.websiteId);
+      let response;
+      try {
+        response = await fetch(
+          `${apiUrl.replace(/\/+$/, "")}/api/v1/website/campaign-captures`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              websiteSlug,
+              campaignKey: input.campaignKey,
+              idempotencyKey: input.idempotencyKey,
+              source: input.source ?? "WEBSITE",
+              commercialConsent: input.commercialConsent,
+              contact: input.contact,
+              answers: input.answers ?? {},
+              attribution: attribution ? serializeWebsiteMarketingAttribution(attribution) : null
+            })
+          }
+        );
+      } catch (error) {
+        throw new WebsiteError(
+          `Could not capture the campaign lead: ${error instanceof Error ? error.message : String(error)}`,
+          "NETWORK_ERROR"
+        );
+      }
+      if (response.status === 429) {
+        throw new RateLimitError(
+          "Rate limit exceeded. Please try again later.",
+          readRetryAfter(response)
+        );
+      }
+      if (!response.ok) {
+        throw new WebsiteError(
+          `Could not capture the campaign lead (status ${response.status})`,
+          response.status === 403 ? "ORIGIN_NOT_ALLOWED" : "INVALID_RESPONSE",
+          { status: response.status }
+        );
+      }
+      const result = await response.json();
+      if (typeof result.accepted !== "boolean" || typeof result.message !== "string") {
+        throw new WebsiteError(
+          "Campaign capture returned an invalid response",
+          "INVALID_RESPONSE"
+        );
+      }
+      return { accepted: result.accepted, message: result.message };
+    }
+  };
+}
+
 // libs/sdk/src/modules/orders.ts
 function mapOrderItem(raw) {
   return {
@@ -4622,13 +5920,13 @@ function createOrdersModule(graphqlUrl, getHeaders, getContext) {
         )) {
           return order;
         }
-        await wait(intervalMs);
+        await wait2(intervalMs);
       }
       throw new CheckoutError(["PAYMENT_STATUS_TIMEOUT"]);
     }
   };
 }
-function wait(ms) {
+function wait2(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -4787,6 +6085,9 @@ function createProfileModule(graphqlUrl, getHeaders) {
 }
 
 // libs/sdk/src/modules/website.ts
+var WEBSITE_CONTEXT_CACHE_TTL_MS = 5 * 60 * 1e3;
+var WEBSITE_CONTEXT_CACHE_MAX_ENTRIES = 100;
+var websiteContextCache = /* @__PURE__ */ new Map();
 function mapWebsite(raw) {
   return {
     websiteId: raw.id,
@@ -4800,10 +6101,7 @@ function mapWebsite(raw) {
 }
 async function resolveWebsite(graphqlUrl, slug, headers) {
   if (!slug.trim()) {
-    throw new WebsiteError(
-      "websiteSlug is required",
-      "INVALID_CONFIG"
-    );
+    throw new WebsiteError("websiteSlug is required", "INVALID_CONFIG");
   }
   const data = await executeGraphQL(
     graphqlUrl,
@@ -4819,6 +6117,31 @@ async function resolveWebsite(graphqlUrl, slug, headers) {
   }
   return mapWebsite(data.websites[0]);
 }
+function resolveWebsiteCached(graphqlUrl, slug, headers) {
+  const normalizedSlug = slug.trim();
+  const cacheKey = `${graphqlUrl}::${normalizedSlug}`;
+  const now = Date.now();
+  const cached = websiteContextCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) return cached.request;
+  if (cached) websiteContextCache.delete(cacheKey);
+  const request = resolveWebsite(graphqlUrl, normalizedSlug, headers).catch(
+    (error) => {
+      if (websiteContextCache.get(cacheKey)?.request === request) {
+        websiteContextCache.delete(cacheKey);
+      }
+      throw error;
+    }
+  );
+  if (websiteContextCache.size >= WEBSITE_CONTEXT_CACHE_MAX_ENTRIES) {
+    const oldestKey = websiteContextCache.keys().next().value;
+    if (oldestKey) websiteContextCache.delete(oldestKey);
+  }
+  websiteContextCache.set(cacheKey, {
+    expiresAt: now + WEBSITE_CONTEXT_CACHE_TTL_MS,
+    request
+  });
+  return request;
+}
 
 // libs/sdk/src/client.ts
 function normalizeApiUrl(apiUrl) {
@@ -4829,10 +6152,17 @@ function createBacanoClient(config) {
     throw new WebsiteError("apiUrl is required", "INVALID_CONFIG");
   if (!config.websiteSlug?.trim())
     throw new WebsiteError("websiteSlug is required", "INVALID_CONFIG");
+  if (config.initialContext && config.initialContext.slug.trim() !== config.websiteSlug.trim()) {
+    throw new WebsiteError(
+      "initialContext slug must match websiteSlug",
+      "INVALID_CONFIG"
+    );
+  }
   const apiUrl = normalizeApiUrl(config.apiUrl);
   const graphqlUrl = `${apiUrl}/api/v1/website/graphql`;
   const storageUrl = `${apiUrl}/storage/v1`;
-  let context = null;
+  let context = config.initialContext ? { ...config.initialContext } : null;
+  let initialization = null;
   function getContext() {
     if (!context) throw new NotInitializedError();
     return context;
@@ -4877,13 +6207,27 @@ function createBacanoClient(config) {
     getContext,
     storageUrl
   );
+  const marketingModule = createMarketingModule(
+    apiUrl,
+    config.websiteSlug,
+    getContext
+  );
   return {
     async init() {
-      context = await resolveWebsite(
-        graphqlUrl,
-        config.websiteSlug,
-        getWebsiteHeaders
-      );
+      if (context) return;
+      if (!initialization) {
+        initialization = resolveWebsiteCached(
+          graphqlUrl,
+          config.websiteSlug,
+          getWebsiteHeaders
+        ).then((resolvedContext) => {
+          context = resolvedContext;
+        }).catch((error) => {
+          initialization = null;
+          throw error;
+        });
+      }
+      await initialization;
     },
     getContext,
     auth: {
@@ -4898,8 +6242,11 @@ function createBacanoClient(config) {
     },
     catalog: {
       getCatalogPage: catalogModule.getCatalogPage.bind(catalogModule),
+      getStaticCatalogSnapshot: catalogModule.getStaticCatalogSnapshot.bind(catalogModule),
+      getStaticCatalogBootstrap: catalogModule.getStaticCatalogBootstrap.bind(catalogModule),
       getProductSeoEntries: catalogModule.getProductSeoEntries.bind(catalogModule),
       getProductRecommendations: catalogModule.getProductRecommendations.bind(catalogModule),
+      getProductLiveState: catalogModule.getProductLiveState.bind(catalogModule),
       getProducts: catalogModule.getProducts.bind(catalogModule),
       getProduct: catalogModule.getProduct.bind(catalogModule),
       getProductBySlug: catalogModule.getProductBySlug.bind(catalogModule),
@@ -4951,6 +6298,9 @@ function createBacanoClient(config) {
       get: profileModule.get.bind(profileModule),
       getAddresses: profileModule.getAddresses.bind(profileModule),
       update: profileModule.update.bind(profileModule)
+    },
+    marketing: {
+      captureLead: marketingModule.captureLead.bind(marketingModule)
     }
   };
 }