@bacano/sdk 1.0.0

package/index.js

@@ -0,0 +1,4933 @@
+// libs/sdk/src/errors.ts
+var WebsiteError = class extends Error {
+  code;
+  constructor(message, code = "WEBSITE_ERROR") {
+    super(message);
+    this.name = "WebsiteError";
+    this.code = code;
+  }
+};
+var NotInitializedError = class extends WebsiteError {
+  constructor() {
+    super(
+      "BacanoClient has not been initialized. Call client.init() first.",
+      "NOT_INITIALIZED"
+    );
+    this.name = "NotInitializedError";
+  }
+};
+var AuthError = class extends WebsiteError {
+  constructor(message) {
+    super(message, "AUTH_ERROR");
+    this.name = "AuthError";
+  }
+};
+var CheckoutError = class extends WebsiteError {
+  errors;
+  constructor(errors) {
+    super(errors.join("; "), "CHECKOUT_ERROR");
+    this.name = "CheckoutError";
+    this.errors = errors;
+  }
+};
+var GraphQLRequestError = class extends WebsiteError {
+  graphqlErrors;
+  constructor(errors) {
+    const message = errors.map((e) => e.message).join("; ");
+    super(message, "GRAPHQL_ERROR");
+    this.name = "GraphQLRequestError";
+    this.graphqlErrors = errors;
+  }
+};
+
+// libs/sdk/src/modules/auth.ts
+function createAuthHeaders(accessToken) {
+  return accessToken ? { Authorization: `Bearer ${accessToken}` } : {};
+}
+function createRequestHeadersProvider(websiteSlug, getAccessToken) {
+  return async () => {
+    const headers = { "X-Bacano-Website-Slug": websiteSlug };
+    if (!getAccessToken) return headers;
+    try {
+      return {
+        ...headers,
+        ...createAuthHeaders(await getAccessToken())
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Could not obtain the buyer access token: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+}
+async function getWebsitePublicConfig(options) {
+  const apiUrl = options.apiUrl.replace(/\/+$/, "");
+  const headers = options.origin ? { Origin: options.origin } : void 0;
+  const params = new URLSearchParams({ websiteSlug: options.websiteSlug });
+  let response;
+  try {
+    response = await fetch(
+      `${apiUrl}/api/v1/website/public-config?${params.toString()}`,
+      {
+        headers,
+        cache: "no-store"
+      }
+    );
+  } catch (error) {
+    throw new WebsiteError(
+      `Could not load website auth configuration: ${error instanceof Error ? error.message : String(error)}`,
+      "NETWORK_ERROR"
+    );
+  }
+  if (!response.ok) {
+    throw new WebsiteError(
+      `Could not load website auth configuration (status ${response.status})`,
+      response.status === 403 ? "ORIGIN_NOT_ALLOWED" : "INVALID_RESPONSE"
+    );
+  }
+  const raw = await response.json();
+  const customerIdentification = raw.customer_identification ?? {
+    primary_identifier: "AUTO",
+    require_email: false,
+    require_phone: false,
+    require_document: false,
+    document_types: []
+  };
+  return {
+    websiteId: raw.website_id,
+    companyId: raw.company_id,
+    slug: raw.slug,
+    name: raw.name,
+    domain: raw.domain,
+    buyerAccountsEnabled: raw.buyer_accounts_enabled,
+    clerkPublishableKey: raw.clerk_publishable_key,
+    customerIdentification: {
+      primaryIdentifier: customerIdentification.primary_identifier,
+      requireEmail: customerIdentification.require_email,
+      requirePhone: customerIdentification.require_phone,
+      requireDocument: customerIdentification.require_document,
+      documentTypes: customerIdentification.document_types.map(
+        (documentType) => ({
+          code: documentType.code,
+          name: documentType.name,
+          shortLabel: documentType.short_label,
+          isDefault: documentType.is_default
+        })
+      )
+    }
+  };
+}
+
+// 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 */
+  `
+  query ResolveWebsiteBySlug($slug: String!) {
+    websites(
+      where: { slug: { _eq: $slug }, is_active: { _eq: true } }
+      limit: 1
+    ) {
+      id
+      company_id
+      chain_id
+      name
+      slug
+      domain
+      config
+    }
+  }
+`
+);
+var GET_PRODUCTS = (
+  /* GraphQL */
+  `
+  query GetProducts(
+    $companyId: uuid!
+    $chainId: uuid!
+    $websiteId: uuid!
+    $limit: Int = 20
+    $offset: Int = 0
+    $where: products_bool_exp = {}
+    $orderBy: [products_order_by!] = [{ name: asc }]
+  ) {
+    products(
+      where: {
+        _and: [
+          { 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 }
+            }
+          }
+          $where
+        ]
+      }
+      limit: $limit
+      offset: $offset
+      order_by: $orderBy
+    ) {
+      id
+      name
+      description
+      long_description
+      slug
+      seo_title
+      seo_description
+      seo_image_file_id
+      category
+      subcategory
+      color
+      measurement_unit
+      created_at
+      updated_at
+      brand {
+        id
+        name
+      }
+      seo_image_file {
+        mimeType
+        name
+      }
+      product_variants(
+        where: { is_disabled: { _eq: false } }
+        order_by: { order: asc }
+      ) {
+        id
+        sku
+        barcode
+        order
+        weight
+        depth
+        height
+        length
+        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
+        }
+        product_variant_attributes(order_by: { order: asc }) {
+          id
+          value
+          order
+          attribute_value {
+            id
+            code
+            sort_order
+            metadata
+          }
+          attribute {
+            id
+            name
+          }
+        }
+      }
+      product_media(order_by: { order: asc }) {
+        id
+        file_id
+        order
+        file {
+          mimeType
+          name
+        }
+      }
+      product_related_products(
+        where: {
+          related_product: {
+            chain_products: {
+              chain_id: { _eq: $chainId }
+              is_enabled: { _eq: true }
+              status: { _eq: active }
+            }
+          }
+        }
+        order_by: { sort_order: asc }
+      ) {
+        id
+        related_product_id
+        display_label
+        sort_order
+        related_product {
+          id
+          slug
+          name
+          sku
+          product_media(
+            where: { file: { mimeType: { _ilike: "image/%" } } }
+            order_by: { order: asc }
+            limit: 1
+          ) {
+            id
+            file_id
+            order
+            file {
+              mimeType
+              name
+            }
+          }
+        }
+      }
+      product_attributes {
+        id
+        value
+        attribute_value {
+          id
+          code
+          sort_order
+          metadata
+        }
+        attribute {
+          id
+          name
+        }
+      }
+    }
+    catalog_attribute_lists(
+      where: { company_id: { _eq: $companyId }, status: { _eq: published } }
+      order_by: { updated_at: desc }
+    ) {
+      id
+      key
+      name
+      description
+      status
+      items(
+        where: { is_visible: { _eq: true } }
+        order_by: [{ sort_order: asc }, { public_label: asc }]
+      ) {
+        id
+        attribute_id
+        public_label
+        public_slug
+        sort_order
+        attribute {
+          id
+          name
+          type
+        }
+        values(
+          where: { is_visible: { _eq: true } }
+          order_by: [{ sort_order: asc }, { public_label: asc }]
+        ) {
+          id
+          attribute_value_id
+          public_label
+          public_slug
+          sort_order
+          attribute_value {
+            id
+            code
+            metadata
+          }
+        }
+      }
+    }
+  }
+`
+);
+var GET_PRODUCT_BY_PK = (
+  /* GraphQL */
+  `
+  query GetProductByPk(
+    $productId: uuid!
+    $companyId: uuid!
+    $chainId: uuid!
+    $websiteId: uuid!
+  ) {
+    products(
+      where: {
+        id: { _eq: $productId }
+        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 }
+        }
+      }
+      limit: 1
+    ) {
+      id
+      name
+      description
+      long_description
+      slug
+      seo_title
+      seo_description
+      seo_image_file_id
+      category
+      subcategory
+      color
+      measurement_unit
+      created_at
+      updated_at
+      brand {
+        id
+        name
+      }
+      seo_image_file {
+        mimeType
+        name
+      }
+      product_variants(
+        where: { is_disabled: { _eq: false } }
+        order_by: { order: asc }
+      ) {
+        id
+        sku
+        barcode
+        order
+        weight
+        depth
+        height
+        length
+        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
+        }
+        product_variant_attributes(order_by: { order: asc }) {
+          id
+          value
+          order
+          attribute_value {
+            id
+            code
+            sort_order
+            metadata
+          }
+          attribute {
+            id
+            name
+          }
+        }
+      }
+      product_media(order_by: { order: asc }) {
+        id
+        file_id
+        order
+        file {
+          mimeType
+          name
+        }
+      }
+      product_related_products(
+        where: {
+          related_product: {
+            chain_products: {
+              chain_id: { _eq: $chainId }
+              is_enabled: { _eq: true }
+              status: { _eq: active }
+            }
+          }
+        }
+        order_by: { sort_order: asc }
+      ) {
+        id
+        related_product_id
+        display_label
+        sort_order
+        related_product {
+          id
+          slug
+          name
+          sku
+          product_media(
+            where: { file: { mimeType: { _ilike: "image/%" } } }
+            order_by: { order: asc }
+            limit: 1
+          ) {
+            id
+            file_id
+            order
+            file {
+              mimeType
+              name
+            }
+          }
+        }
+      }
+      product_attributes {
+        id
+        value
+        attribute_value {
+          id
+          code
+          sort_order
+          metadata
+        }
+        attribute {
+          id
+          name
+        }
+      }
+    }
+    catalog_attribute_lists(
+      where: { company_id: { _eq: $companyId }, status: { _eq: published } }
+      order_by: { updated_at: desc }
+    ) {
+      id
+      key
+      name
+      description
+      status
+      items(
+        where: { is_visible: { _eq: true } }
+        order_by: [{ sort_order: asc }, { public_label: asc }]
+      ) {
+        id
+        attribute_id
+        public_label
+        public_slug
+        sort_order
+        attribute {
+          id
+          name
+          type
+        }
+        values(
+          where: { is_visible: { _eq: true } }
+          order_by: [{ sort_order: asc }, { public_label: asc }]
+        ) {
+          id
+          attribute_value_id
+          public_label
+          public_slug
+          sort_order
+          attribute_value {
+            id
+            code
+            metadata
+          }
+        }
+      }
+    }
+  }
+`
+);
+var GET_PRODUCT_BY_SLUG = (
+  /* GraphQL */
+  GET_PRODUCT_BY_PK.replace(
+    "query GetProductByPk(",
+    "query GetProductBySlug("
+  ).replace("$productId: uuid!", "$slug: String!").replace("id: { _eq: $productId }", "slug: { _eq: $slug }")
+);
+var GET_PRODUCT_SEO_ENTRIES = (
+  /* GraphQL */
+  `
+  query GetProductSeoEntries(
+    $companyId: uuid!
+    $chainId: uuid!
+    $websiteId: uuid!
+    $limit: Int!
+    $offset: Int!
+  ) {
+    products(
+      where: {
+        company_id: { _eq: $companyId }
+        slug: { _is_null: false }
+        product_website_publications: {
+          website_id: { _eq: $websiteId }
+          is_visible: { _eq: true }
+        }
+        chain_products: {
+          chain_id: { _eq: $chainId }
+          is_enabled: { _eq: true }
+          status: { _eq: active }
+        }
+      }
+      limit: $limit
+      offset: $offset
+      order_by: [{ updated_at: desc }, { created_at: desc }]
+    ) {
+      id
+      name
+      slug
+      seo_title
+      seo_description
+      seo_image_file_id
+      category
+      subcategory
+      created_at
+      updated_at
+      seo_image_file {
+        mimeType
+        name
+      }
+      product_media(
+        where: { file: { mimeType: { _ilike: "image/%" } } }
+        order_by: { order: asc }
+        limit: 1
+      ) {
+        id
+        file_id
+        order
+        file {
+          mimeType
+          name
+        }
+      }
+      product_variants(
+        where: { is_disabled: { _eq: false } }
+        order_by: { order: asc }
+      ) {
+        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
+        }
+      }
+    }
+  }
+`
+);
+var GET_CATEGORIES = (
+  /* GraphQL */
+  `
+  query GetCategories {
+    product_categories {
+      name
+      description
+      product_subcategories {
+        id
+        name
+        description
+      }
+    }
+  }
+`
+);
+var GET_CATALOG_CATEGORY_LIST = (
+  /* GraphQL */
+  `
+  query GetCatalogCategoryList($companyId: uuid!, $key: String!) {
+    list: catalog_category_lists(
+      where: {
+        company_id: { _eq: $companyId }
+        key: { _eq: $key }
+        status: { _eq: published }
+      }
+      limit: 1
+    ) {
+      id
+      key
+      name
+      description
+      status
+      items(
+        where: { is_visible: { _eq: true } }
+        order_by: [{ sort_order: asc }, { public_label: asc }]
+      ) {
+        id
+        source_type
+        product_category
+        product_subcategory_id
+        public_label
+        public_slug
+        sort_order
+        category_ref {
+          name
+          description
+        }
+        subcategory_ref {
+          id
+          name
+          description
+          category
+        }
+      }
+    }
+  }
+`
+);
+var GET_CATALOG_ATTRIBUTE_LIST = (
+  /* GraphQL */
+  `
+  query GetCatalogAttributeList($companyId: uuid!, $key: String!) {
+    list: catalog_attribute_lists(
+      where: {
+        company_id: { _eq: $companyId }
+        key: { _eq: $key }
+        status: { _eq: published }
+      }
+      limit: 1
+    ) {
+      id
+      key
+      name
+      description
+      status
+      items(
+        where: { is_visible: { _eq: true } }
+        order_by: [{ sort_order: asc }, { public_label: asc }]
+      ) {
+        id
+        attribute_id
+        public_label
+        public_slug
+        sort_order
+        attribute {
+          id
+          name
+          type
+        }
+        values(
+          where: { is_visible: { _eq: true } }
+          order_by: [{ sort_order: asc }, { public_label: asc }]
+        ) {
+          id
+          attribute_value_id
+          public_label
+          public_slug
+          sort_order
+          attribute_value {
+            id
+            code
+            metadata
+          }
+        }
+      }
+    }
+  }
+`
+);
+var GET_CONTEXTUAL_CATALOG_ATTRIBUTE_LIST = (
+  /* GraphQL */
+  `
+  mutation GetContextualCatalogAttributeList(
+    $websiteId: uuid!
+    $key: String!
+    $onlyApplicable: Boolean
+    $filters: WebsiteCatalogFiltersInput
+  ) {
+    websiteGetAttributeList(
+      website_id: $websiteId
+      key: $key
+      only_applicable: $onlyApplicable
+      filters: $filters
+    ) {
+      success
+      errors
+      list {
+        id
+        key
+        name
+        description
+        status
+        items {
+          id
+          attribute_id
+          attribute_name
+          attribute_type
+          public_label
+          public_slug
+          sort_order
+          values {
+            id
+            attribute_value_id
+            code
+            public_label
+            public_slug
+            sort_order
+            metadata
+          }
+        }
+      }
+    }
+  }
+`
+);
+var WEBSITE_GET_CATALOG_PAGE = (
+  /* GraphQL */
+  `
+  mutation WebsiteGetCatalogPage(
+    $websiteId: uuid!
+    $categoryListKey: String!
+    $attributeListKey: String!
+    $filters: WebsiteCatalogPageFiltersInput
+    $include: WebsiteCatalogPageIncludeInput
+  ) {
+    result: websiteGetCatalogPage(
+      website_id: $websiteId
+      category_list_key: $categoryListKey
+      attribute_list_key: $attributeListKey
+      filters: $filters
+      include: $include
+    ) {
+      success
+      products
+      category_list
+      attribute_list
+      filters
+      brands
+      pagination
+      applied_filters
+      debug
+      errors
+    }
+  }
+`
+);
+var WEBSITE_GET_PRODUCT_RECOMMENDATIONS = (
+  /* GraphQL */
+  `
+  mutation WebsiteGetProductRecommendations(
+    $websiteId: uuid!
+    $productId: uuid!
+    $limit: Int
+  ) {
+    result: websiteGetProductRecommendations(
+      website_id: $websiteId
+      product_id: $productId
+      limit: $limit
+    ) {
+      success
+      products
+      strategy
+      errors
+    }
+  }
+`
+);
+var GET_BRANDS = (
+  /* GraphQL */
+  `
+  query GetBrands($companyId: uuid!, $chainId: uuid!) {
+    brands(
+      where: {
+        company_id: { _eq: $companyId }
+        products: {
+          chain_products: {
+            chain_id: { _eq: $chainId }
+            is_enabled: { _eq: true }
+            status: { _eq: active }
+          }
+        }
+      }
+      order_by: { name: asc }
+    ) {
+      id
+      name
+    }
+  }
+`
+);
+var CONTENT_ENTRY_FIELDS = (
+  /* GraphQL */
+  `
+  id
+  key
+  category_key
+  name
+  locale
+  status
+  tags
+  content_json
+  resolved_fields
+  published_at
+  updated_at
+  content_type {
+    id
+    key
+    name
+    kind
+  }
+`
+);
+var WEBSITE_GET_CONTENT = (
+  /* GraphQL */
+  `
+  mutation WebsiteGetContent(
+    $websiteId: uuid!
+    $key: String
+    $categoryKey: String
+    $tag: String
+    $locale: String
+  ) {
+    result: websiteGetContent(
+      website_id: $websiteId
+      key: $key
+      category_key: $categoryKey
+      tag: $tag
+      locale: $locale
+    ) {
+      success
+      errors
+      entries {
+        ${CONTENT_ENTRY_FIELDS}
+      }
+    }
+  }
+`
+);
+var WEBSITE_GET_PRODUCT_CONTENT = (
+  /* GraphQL */
+  `
+  mutation WebsiteGetProductContent(
+    $websiteId: uuid!
+    $productId: uuid!
+    $locale: String
+  ) {
+    result: websiteGetProductContent(
+      website_id: $websiteId
+      product_id: $productId
+      locale: $locale
+    ) {
+      success
+      errors
+      blocks {
+        id
+        product_id
+        locale
+        content_json
+        resolved_fields
+        sort_order
+        updated_at
+        content_type {
+          id
+          key
+          name
+          kind
+        }
+      }
+    }
+  }
+`
+);
+var CHECK_AVAILABILITY = (
+  /* GraphQL */
+  `
+  query CheckAvailability($variantIds: [uuid!]!, $chainId: uuid!) {
+    websiteProductAvailability(
+      product_variant_ids: $variantIds
+      chain_id: $chainId
+    ) {
+      product_variant_id
+      in_stock
+      label
+    }
+  }
+`
+);
+var CREATE_CART = (
+  /* GraphQL */
+  `
+  mutation CreateCart(
+    $websiteId: uuid!
+    $cartToken: String
+    $contact: WebsiteGuestContactInput
+    $fulfillmentFamily: String
+  ) {
+    websiteCreateCart(
+      website_id: $websiteId
+      cart_token: $cartToken
+      contact: $contact
+      fulfillment_family: $fulfillmentFamily
+    ) {
+      success
+      order_id
+      cart_token
+      cart {
+        id
+        status
+        discount
+        tax
+        total_without_tax
+        total_with_tax
+        total_with_discount
+        created_at
+        updated_at
+        items {
+          id
+          product_variant_id
+          quantity
+          product_variant {
+            id
+            sku
+            product {
+              id
+              name
+            }
+            prices {
+              id
+              price
+              price_type
+              chain_id
+            }
+          }
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var GET_CART = (
+  /* GraphQL */
+  `
+  mutation GetCart($orderId: uuid!, $cartToken: String!) {
+    websiteGetCart(order_id: $orderId, cart_token: $cartToken) {
+      success
+      order_id
+      cart_token
+      cart {
+        id
+        status
+        discount
+        tax
+        total_without_tax
+        total_with_tax
+        total_with_discount
+        created_at
+        updated_at
+        items {
+          id
+          product_variant_id
+          quantity
+          product_variant {
+            id
+            sku
+            product {
+              id
+              name
+            }
+            prices {
+              id
+              price
+              price_type
+              chain_id
+            }
+          }
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var START_GUEST_CHECKOUT = (
+  /* GraphQL */
+  `
+  mutation StartGuestCheckout(
+    $websiteId: uuid!
+    $cartToken: String
+    $contact: WebsiteGuestContactInput!
+    $items: [WebsiteCheckoutItemInput!]!
+    $fulfillmentFamily: String
+  ) {
+    websiteStartGuestCheckout(
+      website_id: $websiteId
+      cart_token: $cartToken
+      contact: $contact
+      items: $items
+      fulfillment_family: $fulfillmentFamily
+    ) {
+      success
+      order_id
+      cart_token
+      cart {
+        id
+        status
+        discount
+        tax
+        total_without_tax
+        total_with_tax
+        total_with_discount
+        created_at
+        updated_at
+        items {
+          id
+          product_variant_id
+          quantity
+          product_variant {
+            id
+            sku
+            product {
+              id
+              name
+            }
+            prices {
+              id
+              price
+              price_type
+              chain_id
+            }
+          }
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var SET_CART_ITEM = (
+  /* GraphQL */
+  `
+  mutation SetCartItem(
+    $orderId: uuid!
+    $cartToken: String!
+    $variantId: uuid!
+    $quantity: numeric!
+  ) {
+    websiteSetCartItem(
+      order_id: $orderId
+      cart_token: $cartToken
+      product_variant_id: $variantId
+      quantity: $quantity
+    ) {
+      success
+      order_id
+      cart_token
+      cart {
+        id
+        status
+        discount
+        tax
+        total_without_tax
+        total_with_tax
+        total_with_discount
+        created_at
+        updated_at
+        items {
+          id
+          product_variant_id
+          quantity
+          product_variant {
+            id
+            sku
+            product {
+              id
+              name
+            }
+            prices {
+              id
+              price
+              price_type
+              chain_id
+            }
+          }
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var REMOVE_CART_ITEM = (
+  /* GraphQL */
+  `
+  mutation RemoveCartItem(
+    $orderId: uuid!
+    $cartToken: String!
+    $itemId: uuid!
+  ) {
+    websiteRemoveCartItem(
+      order_id: $orderId
+      cart_token: $cartToken
+      item_id: $itemId
+    ) {
+      success
+      order_id
+      cart_token
+      cart {
+        id
+        status
+        discount
+        tax
+        total_without_tax
+        total_with_tax
+        total_with_discount
+        created_at
+        updated_at
+        items {
+          id
+          product_variant_id
+          quantity
+          product_variant {
+            id
+            sku
+            product {
+              id
+              name
+            }
+            prices {
+              id
+              price
+              price_type
+              chain_id
+            }
+          }
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var CHECKOUT = (
+  /* GraphQL */
+  `
+  mutation Checkout(
+    $orderId: uuid!
+    $cartToken: String!
+    $contact: WebsiteGuestContactInput!
+    $fulfillmentFamily: String
+    $address: WebsiteAddressInput
+    $shippingQuoteId: uuid
+    $paymentMode: String
+    $paymentMethodId: uuid
+    $buyerAccountOptIn: Boolean
+    $initialPayment: WebsiteInitialPaymentInput
+  ) {
+    websiteCheckout(
+      order_id: $orderId
+      cart_token: $cartToken
+      contact: $contact
+      fulfillment_family: $fulfillmentFamily
+      address: $address
+      shipping_quote_id: $shippingQuoteId
+      payment_mode: $paymentMode
+      payment_method_id: $paymentMethodId
+      buyer_account_opt_in: $buyerAccountOptIn
+      initial_payment: $initialPayment
+    ) {
+      success
+      order_id
+      order_number
+      payment_method_id
+      public_order_token
+      requires_payment_session
+      buyer_account_invitation_requested
+      errors
+    }
+  }
+`
+);
+var GET_LOCATION_OPTIONS = (
+  /* GraphQL */
+  `
+  mutation GetLocationOptions($websiteId: uuid!) {
+    websiteGetLocationOptions(website_id: $websiteId) {
+      success
+      country_code
+      departments {
+        department_id
+        department_name
+        department_code
+        municipalities {
+          municipality_id
+          municipality_name
+          municipality_code
+          department_id
+          department_code
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var GET_DELIVERY_OPTIONS = (
+  /* GraphQL */
+  `
+  mutation GetDeliveryOptions($websiteId: uuid!) {
+    websiteGetDeliveryOptions(website_id: $websiteId) {
+      success
+      delivery_options {
+        id
+        fulfillment_family
+        label
+        description
+        is_enabled
+        pickup_info {
+          label
+          address
+          schedule
+          notes
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var GET_SHIPPING_QUOTES = (
+  /* GraphQL */
+  `
+  mutation GetShippingQuotes(
+    $websiteId: uuid!
+    $orderId: uuid
+    $cartToken: String
+    $items: [WebsiteCheckoutItemInput!]
+    $address: WebsiteAddressInput!
+  ) {
+    websiteGetShippingQuotes(
+      website_id: $websiteId
+      order_id: $orderId
+      cart_token: $cartToken
+      items: $items
+      address: $address
+    ) {
+      success
+      quotes {
+        quote_id
+        shipping_service_id
+        label
+        service_name
+        base_amount
+        amount
+        currency
+        collection_mode
+        total_policy
+        estimated_delivery
+        free_shipping_eligible
+        free_shipping_applied
+        free_shipping_threshold
+        free_shipping_remaining
+        free_shipping_eligible_subtotal
+      }
+      errors
+    }
+  }
+`
+);
+var GET_SHIPPING_POLICY = (
+  /* GraphQL */
+  `
+  mutation GetShippingPolicy($websiteId: uuid!) {
+    websiteGetShippingPolicy(website_id: $websiteId) {
+      success
+      policy {
+        free_shipping_enabled
+        free_shipping_threshold
+        currency
+      }
+      errors
+    }
+  }
+`
+);
+var GET_FREE_SHIPPING_PROGRESS = (
+  /* GraphQL */
+  `
+  mutation GetFreeShippingProgress(
+    $websiteId: uuid!
+    $items: [WebsiteCheckoutItemInput!]!
+  ) {
+    websiteGetFreeShippingProgress(website_id: $websiteId, items: $items) {
+      success
+      progress {
+        enabled
+        threshold
+        remaining
+        eligible_subtotal
+        threshold_reached
+        currency
+      }
+      errors
+    }
+  }
+`
+);
+var GET_PAYMENT_METHODS = (
+  /* GraphQL */
+  `
+  mutation GetPaymentMethods($websiteId: uuid!) {
+    websiteGetPaymentMethods(website_id: $websiteId) {
+      success
+      payment_methods {
+        id
+        code
+        label
+        payment_method_type
+        gateway_code
+        description
+        is_enabled
+        sort_order
+        requires_payment_session
+        public_config
+      }
+      errors
+    }
+  }
+`
+);
+var GET_PAYMENT_OPTIONS = (
+  /* GraphQL */
+  `
+  mutation GetPaymentOptions($websiteId: uuid!, $fulfillmentFamily: String!) {
+    websiteGetPaymentOptions(
+      website_id: $websiteId
+      fulfillment_family: $fulfillmentFamily
+    ) {
+      success
+      payment_options {
+        id
+        mode
+        fulfillment_family
+        label
+        description
+        requires_payment_method
+        allows_initial_payment
+        initial_payment_policy
+        requires_initial_payment
+        min_initial_amount
+        suggested_initial_amount
+        sort_order
+        methods {
+          id
+          payment_method_id
+          code
+          label
+          payment_method_type
+          gateway_code
+          description
+          instructions
+          qr_file_id
+          requires_payment_session
+          public_config
+          sort_order
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var VALIDATE_COUPON = (
+  /* GraphQL */
+  `
+  mutation ValidateCoupon(
+    $orderId: uuid!
+    $cartToken: String!
+    $code: String!
+  ) {
+    websiteValidateCoupon(
+      order_id: $orderId
+      cart_token: $cartToken
+      code: $code
+    ) {
+      success
+      order_id
+      coupon_id
+      code
+      name
+      coupon_type
+      discount_amount
+      eligible_subtotal
+      message
+      cart {
+        id
+        status
+        discount
+        total_without_tax
+        tax
+        total_with_tax
+        total_with_discount
+        created_at
+        updated_at
+        items {
+          id
+          product_variant_id
+          quantity
+          product_variant {
+            id
+            sku
+            product {
+              id
+              name
+            }
+            prices {
+              id
+              price
+              price_type
+              chain_id
+            }
+          }
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var APPLY_COUPON = (
+  /* GraphQL */
+  `
+  mutation ApplyCoupon($orderId: uuid!, $cartToken: String!, $code: String!) {
+    websiteApplyCoupon(
+      order_id: $orderId
+      cart_token: $cartToken
+      code: $code
+    ) {
+      success
+      order_id
+      coupon_id
+      code
+      name
+      coupon_type
+      discount_amount
+      eligible_subtotal
+      message
+      cart {
+        id
+        status
+        discount
+        total_without_tax
+        tax
+        total_with_tax
+        total_with_discount
+        created_at
+        updated_at
+        items {
+          id
+          product_variant_id
+          quantity
+          product_variant {
+            id
+            sku
+            product {
+              id
+              name
+            }
+            prices {
+              id
+              price
+              price_type
+              chain_id
+            }
+          }
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var REMOVE_COUPON = (
+  /* GraphQL */
+  `
+  mutation RemoveCoupon(
+    $orderId: uuid!
+    $cartToken: String!
+    $couponId: uuid!
+  ) {
+    websiteRemoveCoupon(
+      order_id: $orderId
+      cart_token: $cartToken
+      coupon_id: $couponId
+    ) {
+      success
+      order_id
+      coupon_id
+      code
+      name
+      coupon_type
+      discount_amount
+      eligible_subtotal
+      message
+      cart {
+        id
+        status
+        discount
+        total_without_tax
+        tax
+        total_with_tax
+        total_with_discount
+        created_at
+        updated_at
+        items {
+          id
+          product_variant_id
+          quantity
+          product_variant {
+            id
+            sku
+            product {
+              id
+              name
+            }
+            prices {
+              id
+              price
+              price_type
+              chain_id
+            }
+          }
+        }
+      }
+      errors
+    }
+  }
+`
+);
+var CREATE_PAYMENT_SESSION = (
+  /* GraphQL */
+  `
+  mutation CreatePaymentSession(
+    $orderId: uuid!
+    $cartToken: String
+    $publicOrderToken: String
+    $paymentMethodId: uuid!
+    $returnUrl: String!
+  ) {
+    websiteCreatePaymentSession(
+      order_id: $orderId
+      cart_token: $cartToken
+      public_order_token: $publicOrderToken
+      payment_method_id: $paymentMethodId
+      return_url: $returnUrl
+    ) {
+      success
+      order_id
+      payment_method_id
+      payment_session_id
+      gateway_code
+      integration_mode
+      status
+      redirect_url
+      public_payload
+      errors
+    }
+  }
+`
+);
+var RECONCILE_PAYMENT_SESSION = (
+  /* GraphQL */
+  `
+  mutation ReconcilePaymentSession(
+    $orderId: uuid!
+    $publicOrderToken: String!
+    $paymentSessionId: uuid!
+    $gatewayTransactionId: String!
+  ) {
+    websiteReconcilePaymentSession(
+      order_id: $orderId
+      public_order_token: $publicOrderToken
+      payment_session_id: $paymentSessionId
+      gateway_transaction_id: $gatewayTransactionId
+    ) {
+      success
+      order_id
+      payment_method_id
+      payment_session_id
+      gateway_code
+      integration_mode
+      status
+      redirect_url
+      public_payload
+      errors
+    }
+  }
+`
+);
+var GET_ORDERS = (
+  /* GraphQL */
+  `
+  query GetOrders($limit: Int = 20, $offset: Int = 0) {
+    orders(
+      where: { order_number: { _is_null: false } }
+      order_by: { created_at: desc }
+      limit: $limit
+      offset: $offset
+    ) {
+      id
+      order_number
+      status
+      fulfillment_family
+      discount
+      tax
+      total_without_tax
+      total_with_tax
+      total_with_discount
+      created_at
+      updated_at
+      order_product_variants {
+        id
+        product_variant_id
+        quantity
+        product_variant {
+          sku
+          product {
+            id
+            name
+          }
+        }
+      }
+    }
+  }
+`
+);
+var GET_ORDER_BY_PK = (
+  /* GraphQL */
+  `
+  query GetOrderByPk($orderId: uuid!) {
+    orders(where: { id: { _eq: $orderId } }) {
+      id
+      order_number
+      status
+      fulfillment_family
+      discount
+      tax
+      total_without_tax
+      total_with_tax
+      total_with_discount
+      created_at
+      updated_at
+      order_product_variants {
+        id
+        product_variant_id
+        quantity
+        product_variant {
+          sku
+          product {
+            id
+            name
+          }
+        }
+      }
+    }
+  }
+`
+);
+var GET_PUBLIC_ORDER = (
+  /* GraphQL */
+  `
+  mutation GetPublicOrder($websiteId: uuid!, $orderId: uuid!, $token: String!) {
+    websiteGetPublicOrder(
+      website_id: $websiteId
+      order_id: $orderId
+      token: $token
+    ) {
+      success
+      order {
+        order_id
+        order_number
+        status
+        payment_status
+        fulfillment_family
+        delivery {
+          fulfillment_family
+          shipping {
+            label
+            amount
+            method_type
+            collection_mode
+            total_policy
+            address
+          }
+          pickup {
+            label
+          }
+        }
+        payment {
+          mode
+          label
+          method {
+            id
+            label
+            payment_method_type
+            gateway_code
+            requires_payment_session
+          }
+          initial_payment {
+            amount
+            payment_method_id
+            method_label
+            payment_method_type
+            gateway_code
+            requires_payment_session
+          }
+          requires_payment_session
+          next_action
+          session {
+            id
+            gateway_code
+            integration_mode
+            status
+            reference
+            amount
+            currency
+            gateway_transaction_id
+            error_message
+            expires_at
+            created_at
+            updated_at
+          }
+        }
+        totals {
+          subtotal
+          tax
+          discount
+          total
+          total_with_discount
+        }
+        items {
+          id
+          product_variant_id
+          sku
+          name
+          image_file_id
+          quantity
+          unit_price
+          line_total
+        }
+        next_steps
+        created_at
+        updated_at
+      }
+      errors
+    }
+  }
+`
+);
+var GET_PROFILE = (
+  /* GraphQL */
+  `
+  query GetProfile {
+    clients {
+      id
+      party_id
+      party {
+        first_name
+        last_name
+        email
+        phone_e164
+        phone_national_number
+        address
+        address_complement
+        birthdate
+        legal_name
+        commercial_name
+        country_code
+        department_code
+        municipality_code
+        geo_country {
+          name
+        }
+        geo_department {
+          name
+        }
+        geo_municipality {
+          name
+        }
+        shipping_addresses(
+          where: { is_primary: { _eq: true } }
+          order_by: { created_at: asc }
+          limit: 1
+        ) {
+          address
+          address_complement
+          country_code
+          department_code
+          municipality_code
+          geo_country {
+            name
+          }
+          geo_department {
+            name
+          }
+          geo_municipality {
+            name
+          }
+        }
+      }
+    }
+  }
+`
+);
+var GET_PROFILE_ADDRESSES = (
+  /* GraphQL */
+  `
+  query GetProfileAddresses {
+    clients {
+      party_id
+      party {
+        first_name
+        last_name
+        display_name
+        phone_e164
+        phone_national_number
+        address
+        address_complement
+        country_code
+        department_code
+        municipality_code
+        geo_country {
+          name
+        }
+        geo_department {
+          name
+        }
+        geo_municipality {
+          name
+        }
+        shipping_addresses(
+          order_by: [{ is_primary: desc }, { created_at: asc }]
+        ) {
+          id
+          label
+          recipient_name
+          phone_e164
+          address
+          address_complement
+          notes
+          is_primary
+          country_code
+          department_code
+          municipality_code
+          geo_country {
+            name
+          }
+          geo_department {
+            name
+          }
+          geo_municipality {
+            name
+          }
+        }
+      }
+    }
+  }
+`
+);
+var UPDATE_PROFILE = (
+  /* GraphQL */
+  `
+  mutation UpdateProfile($partyId: uuid!, $data: business_parties_set_input!) {
+    update_business_parties_by_pk(pk_columns: { id: $partyId }, _set: $data) {
+      email
+      first_name
+      last_name
+      phone_e164
+      phone_national_number
+      address
+      address_complement
+      birthdate
+      legal_name
+      commercial_name
+      country_code
+      department_code
+      municipality_code
+      geo_country {
+        name
+      }
+      geo_department {
+        name
+      }
+      geo_municipality {
+        name
+      }
+      shipping_addresses(
+        where: { is_primary: { _eq: true } }
+        order_by: { created_at: asc }
+        limit: 1
+      ) {
+        address
+        address_complement
+        country_code
+        department_code
+        municipality_code
+        geo_country {
+          name
+        }
+        geo_department {
+          name
+        }
+        geo_municipality {
+          name
+        }
+      }
+    }
+  }
+`
+);
+var GET_PRODUCT_FILTERS = (
+  /* GraphQL */
+  `
+  query GetProductFilters(
+    $companyId: uuid!
+    $chainId: uuid!
+    $where: products_bool_exp = {}
+    $attributeListKey: String!
+  ) {
+    products(
+      where: {
+        _and: [
+          { company_id: { _eq: $companyId } }
+          {
+            chain_products: {
+              chain_id: { _eq: $chainId }
+              is_enabled: { _eq: true }
+              status: { _eq: active }
+            }
+          }
+          $where
+        ]
+      }
+    ) {
+      id
+      category
+      subcategory
+      color
+      brand {
+        id
+        name
+      }
+      product_attributes {
+        id
+        value
+        attribute_value {
+          id
+          code
+          sort_order
+          metadata
+        }
+        attribute {
+          id
+          name
+        }
+      }
+      product_variants(where: { is_disabled: { _eq: false } }) {
+        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
+        }
+        product_variant_attributes(order_by: { order: asc }) {
+          id
+          value
+          order
+          attribute_value {
+            id
+            code
+            sort_order
+            metadata
+          }
+          attribute {
+            id
+            name
+          }
+        }
+      }
+    }
+    catalog_attribute_lists(
+      where: {
+        company_id: { _eq: $companyId }
+        key: { _eq: $attributeListKey }
+        status: { _eq: published }
+      }
+      limit: 1
+    ) {
+      id
+      key
+      name
+      description
+      status
+      items(
+        where: { is_visible: { _eq: true } }
+        order_by: [{ sort_order: asc }, { public_label: asc }]
+      ) {
+        id
+        attribute_id
+        public_label
+        public_slug
+        sort_order
+        attribute {
+          id
+          name
+          type
+        }
+        values(
+          where: { is_visible: { _eq: true } }
+          order_by: [{ sort_order: asc }, { public_label: asc }]
+        ) {
+          id
+          attribute_value_id
+          public_label
+          public_slug
+          sort_order
+          attribute_value {
+            id
+            code
+            metadata
+          }
+        }
+      }
+    }
+  }
+`
+);
+var GET_SEARCH_SUGGESTIONS = (
+  /* GraphQL */
+  `
+  query GetSearchSuggestions(
+    $companyId: uuid!
+    $chainId: uuid!
+    $term: String!
+    $productLimit: Int = 5
+    $brandLimit: Int = 3
+  ) {
+    products(
+      where: {
+        company_id: { _eq: $companyId }
+        chain_products: {
+          chain_id: { _eq: $chainId }
+          is_enabled: { _eq: true }
+          status: { _eq: active }
+        }
+        name: { _ilike: $term }
+      }
+      limit: $productLimit
+      order_by: { name: asc }
+    ) {
+      id
+      name
+    }
+    brands(
+      where: {
+        company_id: { _eq: $companyId }
+        name: { _ilike: $term }
+        products: {
+          chain_products: {
+            chain_id: { _eq: $chainId }
+            is_enabled: { _eq: true }
+            status: { _eq: active }
+          }
+        }
+      }
+      limit: $brandLimit
+      order_by: { name: asc }
+    ) {
+      id
+      name
+    }
+  }
+`
+);
+
+// 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
+  };
+}
+function chunkArray(items, chunkSize) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += chunkSize) {
+    chunks.push(items.slice(index, index + chunkSize));
+  }
+  return chunks;
+}
+function uniqueValues(values) {
+  return Array.from(new Set(values));
+}
+function createAvailabilityModule(graphqlUrl, getHeaders, getContext) {
+  return {
+    async checkAvailability(productVariantIds) {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Stock availability requires a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      if (productVariantIds.length === 0) return [];
+      const variantIds = uniqueValues(productVariantIds);
+      const results = [];
+      for (const chunk of chunkArray(variantIds, MAX_AVAILABILITY_VARIANT_IDS)) {
+        const data = await executeGraphQL(
+          graphqlUrl,
+          CHECK_AVAILABILITY,
+          {
+            variantIds: chunk,
+            chainId: ctx.chainId
+          },
+          getHeaders
+        );
+        results.push(
+          ...(data.websiteProductAvailability ?? []).map(mapAvailability)
+        );
+      }
+      return results;
+    }
+  };
+}
+
+// libs/sdk/src/modules/cart.ts
+function mapCartItem(raw) {
+  return {
+    id: raw.id,
+    productVariantId: raw.product_variant_id,
+    quantity: raw.quantity,
+    productVariant: {
+      sku: raw.product_variant.sku,
+      product: raw.product_variant.product,
+      prices: raw.product_variant.prices.map((p) => ({
+        id: p.id,
+        price: p.price,
+        priceType: p.price_type,
+        chainId: p.chain_id
+      }))
+    }
+  };
+}
+function mapCart(raw, cartToken) {
+  return {
+    id: raw.id,
+    cartToken,
+    items: raw.items.map(mapCartItem),
+    totals: {
+      subtotal: raw.total_without_tax,
+      tax: raw.tax,
+      discount: raw.discount,
+      total: raw.total_with_tax
+    },
+    status: raw.status,
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at
+  };
+}
+function assertActionSuccess(result, fallbackCode) {
+  if (!result.success || !result.order_id || !result.cart_token || !result.cart) {
+    const message = result.errors?.join("; ") || "Cart action failed";
+    throw new WebsiteError(message, fallbackCode);
+  }
+}
+function requireCartSession(storage) {
+  const session = storage.get();
+  if (!session) {
+    throw new WebsiteError(
+      "No guest cart session found",
+      "CART_SESSION_MISSING"
+    );
+  }
+  return session;
+}
+function createCartModule(graphqlUrl, getHeaders, getContext, cartSessionStorage) {
+  async function fetchCart(orderId, cartToken) {
+    const data = await executeGraphQL(graphqlUrl, GET_CART, { orderId, cartToken }, getHeaders);
+    const result = data.websiteGetCart;
+    if (!result.success) {
+      if (result.errors?.includes("CART_NOT_FOUND")) {
+        cartSessionStorage.clear();
+        return null;
+      }
+      throw new WebsiteError(
+        result.errors?.join("; ") || "Cart could not be retrieved",
+        "CART_FETCH_ERROR"
+      );
+    }
+    assertActionSuccess(result, "CART_FETCH_ERROR");
+    cartSessionStorage.set({
+      orderId: result.order_id,
+      cartToken: result.cart_token
+    });
+    return mapCart(result.cart, result.cart_token);
+  }
+  return {
+    async getOrCreate(contact, fulfillmentFamily) {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Cart requires a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const existing = cartSessionStorage.get();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        CREATE_CART,
+        {
+          websiteId: ctx.websiteId,
+          cartToken: existing?.cartToken,
+          contact,
+          fulfillmentFamily
+        },
+        getHeaders
+      );
+      const result = data.websiteCreateCart;
+      assertActionSuccess(result, "CART_CREATE_ERROR");
+      cartSessionStorage.set({
+        orderId: result.order_id,
+        cartToken: result.cart_token
+      });
+      return mapCart(result.cart, result.cart_token);
+    },
+    async startCheckout(input) {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Checkout requires a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const existing = cartSessionStorage.get();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        START_GUEST_CHECKOUT,
+        {
+          websiteId: ctx.websiteId,
+          cartToken: existing?.cartToken,
+          contact: input.contact,
+          fulfillmentFamily: input.fulfillmentFamily,
+          items: input.items.map((item) => ({
+            product_variant_id: item.productVariantId,
+            quantity: item.quantity
+          }))
+        },
+        getHeaders
+      );
+      const result = data.websiteStartGuestCheckout;
+      assertActionSuccess(result, "CHECKOUT_START_ERROR");
+      cartSessionStorage.set({
+        orderId: result.order_id,
+        cartToken: result.cart_token
+      });
+      return mapCart(result.cart, result.cart_token);
+    },
+    async get() {
+      const session = cartSessionStorage.get();
+      if (!session) return null;
+      return fetchCart(session.orderId, session.cartToken);
+    },
+    async setItem(productVariantId, quantity) {
+      if (quantity <= 0) {
+        throw new WebsiteError(
+          "Quantity must be greater than zero",
+          "INVALID_QUANTITY"
+        );
+      }
+      const session = cartSessionStorage.get();
+      if (!session) {
+        throw new WebsiteError(
+          "Start checkout with contact before syncing cart items to Bacano",
+          "CART_SESSION_MISSING"
+        );
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        SET_CART_ITEM,
+        {
+          orderId: session.orderId,
+          cartToken: session.cartToken,
+          variantId: productVariantId,
+          quantity
+        },
+        getHeaders
+      );
+      const result = data.websiteSetCartItem;
+      assertActionSuccess(result, "CART_ITEM_ERROR");
+      cartSessionStorage.set({
+        orderId: result.order_id,
+        cartToken: result.cart_token
+      });
+      return mapCart(result.cart, result.cart_token);
+    },
+    async addItem(productVariantId, quantity) {
+      const cart = await this.setItem(productVariantId, quantity);
+      const item = cart.items.find(
+        (entry) => entry.productVariantId === productVariantId
+      );
+      if (!item) {
+        throw new WebsiteError(
+          "Cart item was not returned by the server",
+          "CART_ITEM_ERROR"
+        );
+      }
+      return item;
+    },
+    async updateItem(cartItemId, quantity) {
+      const cart = await this.get();
+      const item = cart?.items.find((entry) => entry.id === cartItemId);
+      if (!item) {
+        throw new WebsiteError(
+          "Cart item was not found",
+          "CART_ITEM_NOT_FOUND"
+        );
+      }
+      const updatedCart = await this.setItem(item.productVariantId, quantity);
+      const updatedItem = updatedCart.items.find(
+        (entry) => entry.id === cartItemId
+      );
+      return {
+        id: cartItemId,
+        quantity: updatedItem?.quantity ?? quantity
+      };
+    },
+    async removeItem(cartItemId) {
+      const session = requireCartSession(cartSessionStorage);
+      const data = await executeGraphQL(
+        graphqlUrl,
+        REMOVE_CART_ITEM,
+        {
+          orderId: session.orderId,
+          cartToken: session.cartToken,
+          itemId: cartItemId
+        },
+        getHeaders
+      );
+      const result = data.websiteRemoveCartItem;
+      assertActionSuccess(result, "CART_ITEM_ERROR");
+      cartSessionStorage.set({
+        orderId: result.order_id,
+        cartToken: result.cart_token
+      });
+      return mapCart(result.cart, result.cart_token);
+    }
+  };
+}
+
+// libs/sdk/src/modules/cart-session.ts
+function getStorageKey(slug) {
+  return `@bacano/sdk:cart:${slug}`;
+}
+function createCartSessionStorage(kind, getSlug) {
+  let memorySession = null;
+  function readKey() {
+    return getStorageKey(getSlug());
+  }
+  return {
+    get() {
+      if (kind === "memory") return memorySession;
+      if (kind === "cookie") {
+        if (typeof document === "undefined") return null;
+        try {
+          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("=")));
+        } catch {
+          return null;
+        }
+      }
+      if (typeof localStorage === "undefined") return null;
+      try {
+        const raw = localStorage.getItem(readKey());
+        return raw ? JSON.parse(raw) : null;
+      } catch {
+        return null;
+      }
+    },
+    set(session) {
+      memorySession = session;
+      if (kind === "memory") return;
+      if (kind === "cookie") {
+        if (typeof document === "undefined") return;
+        const maxAge = 30 * 24 * 60 * 60;
+        const value = encodeURIComponent(JSON.stringify(session));
+        document.cookie = `${readKey()}=${value}; max-age=${maxAge}; path=/; SameSite=Lax`;
+        return;
+      }
+      if (typeof localStorage === "undefined") return;
+      localStorage.setItem(readKey(), JSON.stringify(session));
+    },
+    clear() {
+      memorySession = null;
+      if (kind === "memory") return;
+      if (kind === "cookie") {
+        if (typeof document === "undefined") return;
+        document.cookie = `${readKey()}=; max-age=0; path=/; SameSite=Lax`;
+        return;
+      }
+      if (typeof localStorage === "undefined") return;
+      localStorage.removeItem(readKey());
+    }
+  };
+}
+
+// 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/catalog.ts
+var MAX_AVAILABILITY_VARIANT_IDS2 = 100;
+var DEFAULT_FILTER_ATTRIBUTE_LIST_KEY = "atributos";
+function mapPrice(raw) {
+  return {
+    id: raw.id,
+    price: raw.price,
+    priceType: raw.price_type,
+    chainId: raw.chain_id
+  };
+}
+function parseActionJson(value, fallback) {
+  if (value == null) return fallback;
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function getProductMediaKind(mimeType) {
+  if (mimeType?.startsWith("image/")) return "image";
+  if (mimeType?.startsWith("video/")) return "video";
+  if (mimeType?.startsWith("application/")) return "document";
+  return "file";
+}
+function getProductMediaByKind(media, kind) {
+  return (media ?? []).filter((item) => item.mediaKind === kind);
+}
+function getProductImages(media) {
+  return getProductMediaByKind(media, "image");
+}
+function getProductVideos(media) {
+  return getProductMediaByKind(media, "video");
+}
+function getPrimaryProductImage(media) {
+  return getProductImages(media)[0] ?? null;
+}
+function mapMedia(raw, storageUrl) {
+  const mimeType = raw.file?.mimeType ?? null;
+  const fileName = raw.file?.name ?? null;
+  const urls = buildStorageMediaUrls(storageUrl, raw.file_id);
+  return {
+    id: raw.id,
+    fileId: raw.file_id,
+    order: raw.order ?? 0,
+    url: urls.originalUrl,
+    ...urls,
+    mediaKind: getProductMediaKind(mimeType),
+    mimeType,
+    fileName,
+    alt: fileName
+  };
+}
+function mapProductRecommendation(raw, storageUrl) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    slug: raw.slug,
+    category: raw.category,
+    subcategory: raw.subcategory,
+    brand: raw.brand,
+    primaryImage: raw.primary_media ? mapMedia(raw.primary_media, storageUrl) : null,
+    pricing: {
+      currentPriceMin: Number(raw.pricing.current_price_min),
+      currentPriceMax: Number(raw.pricing.current_price_max),
+      regularPriceMin: Number(raw.pricing.regular_price_min),
+      regularPriceMax: Number(raw.pricing.regular_price_max),
+      hasDiscount: raw.pricing.has_discount
+    },
+    source: raw.recommendation_source
+  };
+}
+function mapSeoMedia(raw, storageUrl) {
+  if (!raw.seo_image_file_id) return null;
+  return mapMedia(
+    {
+      id: `seo:${raw.seo_image_file_id}`,
+      file_id: raw.seo_image_file_id,
+      order: 0,
+      file: raw.seo_image_file ?? null
+    },
+    storageUrl
+  );
+}
+function attributeValueCode(raw) {
+  return raw.attribute_value?.code ?? raw.value;
+}
+function attributeValueLabelKey(attributeId, valueCode) {
+  return `${attributeId}:${valueCode}`;
+}
+function buildPublicAttributeLabels(lists) {
+  const attributeLabelsById = /* @__PURE__ */ new Map();
+  const valueLabelsById = /* @__PURE__ */ new Map();
+  const valueLabelsByAttributeAndCode = /* @__PURE__ */ new Map();
+  for (const list of lists ?? []) {
+    for (const item of list.items ?? []) {
+      if (!attributeLabelsById.has(item.attribute_id)) {
+        attributeLabelsById.set(item.attribute_id, item.public_label);
+      }
+      for (const value of item.values ?? []) {
+        if (!valueLabelsById.has(value.attribute_value_id)) {
+          valueLabelsById.set(value.attribute_value_id, value.public_label);
+        }
+        const valueCode = value.attribute_value.code;
+        const key = attributeValueLabelKey(item.attribute_id, valueCode);
+        if (!valueLabelsByAttributeAndCode.has(key)) {
+          valueLabelsByAttributeAndCode.set(key, value.public_label);
+        }
+      }
+    }
+  }
+  return {
+    attributeLabelsById,
+    valueLabelsById,
+    valueLabelsByAttributeAndCode
+  };
+}
+function resolvePublicAttributeValueLabel(raw, labels) {
+  const valueCode = attributeValueCode(raw);
+  if (raw.attribute_value?.public_label) {
+    return raw.attribute_value.public_label;
+  }
+  const byId = raw.attribute_value?.id ? labels.valueLabelsById.get(raw.attribute_value.id) : null;
+  const byAttributeAndCode = labels.valueLabelsByAttributeAndCode.get(
+    attributeValueLabelKey(raw.attribute.id, valueCode)
+  );
+  return byId ?? byAttributeAndCode ?? valueCode;
+}
+function mapProductAttribute(raw, labels) {
+  const valueCode = attributeValueCode(raw);
+  return {
+    id: raw.id,
+    name: raw.attribute.public_label ?? labels.attributeLabelsById.get(raw.attribute.id) ?? raw.attribute.name,
+    value: resolvePublicAttributeValueLabel(raw, labels),
+    attributeValueId: raw.attribute_value?.id ?? null,
+    code: raw.attribute.name,
+    valueCode,
+    metadata: raw.attribute_value?.metadata ?? null,
+    sortOrder: raw.attribute_value?.sort_order ?? null
+  };
+}
+function mapVariantAttribute(raw, labels) {
+  const valueCode = attributeValueCode(raw);
+  return {
+    id: raw.id,
+    name: raw.attribute.public_label ?? labels.attributeLabelsById.get(raw.attribute.id) ?? raw.attribute.name,
+    value: resolvePublicAttributeValueLabel(raw, labels),
+    order: raw.order,
+    attributeValueId: raw.attribute_value?.id ?? null,
+    code: raw.attribute.name,
+    valueCode,
+    metadata: raw.attribute_value?.metadata ?? null,
+    sortOrder: raw.attribute_value?.sort_order ?? null
+  };
+}
+function mapVariant(raw, labels, chainId) {
+  const prices = selectPublicPrices(
+    raw.product_variant_prices.map(mapPrice),
+    chainId
+  );
+  return {
+    id: raw.id,
+    sku: raw.sku,
+    barcode: raw.barcode,
+    order: raw.order,
+    weight: raw.weight,
+    depth: raw.depth,
+    height: raw.height,
+    length: raw.length,
+    prices,
+    pricing: resolveProductPricing(prices),
+    attributes: raw.product_variant_attributes.map(
+      (attribute) => mapVariantAttribute(attribute, labels)
+    )
+  };
+}
+function mapRelatedProduct(raw, storageUrl) {
+  return {
+    id: raw.id,
+    productId: raw.related_product_id,
+    slug: raw.related_product.slug,
+    name: raw.related_product.name,
+    sku: raw.related_product.sku,
+    displayLabel: raw.display_label,
+    sortOrder: raw.sort_order ?? 0,
+    media: raw.related_product.product_media.map(
+      (m) => mapMedia(m, storageUrl)
+    )
+  };
+}
+function mapProduct(raw, storageUrl, labels, chainId) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    description: raw.description,
+    longDescription: raw.long_description ?? null,
+    slug: raw.slug ?? null,
+    seoTitle: raw.seo_title ?? null,
+    seoDescription: raw.seo_description ?? null,
+    seoImage: mapSeoMedia(raw, storageUrl),
+    color: raw.color,
+    category: raw.category,
+    subcategory: raw.subcategory,
+    brand: raw.brand,
+    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)
+    ),
+    media: raw.product_media.map((m) => mapMedia(m, storageUrl)),
+    attributes: raw.product_attributes.map(
+      (attribute) => mapProductAttribute(attribute, labels)
+    ),
+    relatedProducts: (raw.product_related_products ?? []).map(
+      (relation) => mapRelatedProduct(relation, storageUrl)
+    )
+  };
+}
+function mapCategory(raw) {
+  return {
+    name: raw.name,
+    description: raw.description,
+    subcategories: raw.product_subcategories.map((sub) => ({
+      id: sub.id,
+      name: sub.name,
+      description: sub.description
+    }))
+  };
+}
+function mapCategoryListItem(raw, categoriesByName) {
+  const parentCategory = raw.subcategory_ref?.category ?? null;
+  const parent = parentCategory ? categoriesByName?.get(parentCategory) ?? null : null;
+  return {
+    id: raw.id,
+    sourceType: raw.source_type,
+    productCategory: raw.product_category,
+    productSubcategoryId: raw.product_subcategory_id,
+    label: raw.public_label,
+    slug: raw.public_slug,
+    sortOrder: raw.sort_order,
+    category: raw.category_ref,
+    subcategory: raw.subcategory_ref,
+    parentCategory,
+    parentId: parent?.id ?? null,
+    parentSlug: parent?.slug ?? null
+  };
+}
+function mapCategoryList(raw) {
+  const categoryItems = raw.items.filter((item) => item.source_type === "category" && item.product_category).map((item) => mapCategoryListItem(item));
+  const categoriesByName = new Map(
+    categoryItems.filter((item) => item.productCategory).map((item) => [item.productCategory, item])
+  );
+  const items = raw.items.map(
+    (item) => mapCategoryListItem(item, categoriesByName)
+  );
+  return {
+    id: raw.id,
+    key: raw.key,
+    name: raw.name,
+    description: raw.description,
+    status: raw.status,
+    items,
+    categories: categoryItems.map((category) => ({
+      id: category.id,
+      productCategory: category.productCategory,
+      label: category.label,
+      slug: category.slug,
+      sortOrder: category.sortOrder,
+      category: category.category,
+      subcategories: items.filter(
+        (item) => item.sourceType === "subcategory" && item.parentCategory === category.productCategory
+      ).sort(
+        (a, b) => a.sortOrder === b.sortOrder ? a.label.localeCompare(b.label) : a.sortOrder - b.sortOrder
+      )
+    }))
+  };
+}
+function filterCategoryListByApplicability(raw, applicableCategories, applicableSubcategoryIds) {
+  const categoryNamesWithApplicableSubcategories = new Set(
+    raw.items.filter(
+      (item) => item.source_type === "subcategory" && item.product_subcategory_id && applicableSubcategoryIds.has(item.product_subcategory_id)
+    ).map((item) => item.subcategory_ref?.category).filter((category) => Boolean(category))
+  );
+  const filteredItems = raw.items.filter((item) => {
+    if (item.source_type === "category") {
+      const category = item.product_category;
+      return Boolean(
+        category && (applicableCategories.has(category) || categoryNamesWithApplicableSubcategories.has(category))
+      );
+    }
+    const subcategoryId = item.product_subcategory_id;
+    return Boolean(
+      subcategoryId && applicableSubcategoryIds.has(subcategoryId)
+    );
+  });
+  return mapCategoryList({
+    ...raw,
+    items: filteredItems
+  });
+}
+function mapAttributeListValue(raw) {
+  return {
+    id: raw.id,
+    attributeValueId: raw.attribute_value_id,
+    code: raw.attribute_value.code,
+    label: raw.public_label,
+    slug: raw.public_slug,
+    sortOrder: raw.sort_order,
+    metadata: raw.attribute_value.metadata
+  };
+}
+function mapAttributeListItem(raw) {
+  return {
+    id: raw.id,
+    attributeId: raw.attribute_id,
+    attributeName: raw.attribute.name,
+    attributeType: raw.attribute.type,
+    label: raw.public_label,
+    slug: raw.public_slug,
+    sortOrder: raw.sort_order,
+    values: raw.values.map(mapAttributeListValue)
+  };
+}
+function mapAttributeList(raw) {
+  return {
+    id: raw.id,
+    key: raw.key,
+    name: raw.name,
+    description: raw.description,
+    status: raw.status,
+    items: raw.items.map(mapAttributeListItem)
+  };
+}
+function mapContextualAttributeListValue(raw) {
+  return {
+    id: raw.id,
+    attributeValueId: raw.attribute_value_id,
+    code: raw.code,
+    label: raw.public_label,
+    slug: raw.public_slug,
+    sortOrder: raw.sort_order,
+    metadata: raw.metadata
+  };
+}
+function mapContextualAttributeListItem(raw) {
+  return {
+    id: raw.id,
+    attributeId: raw.attribute_id,
+    attributeName: raw.attribute_name,
+    attributeType: raw.attribute_type,
+    label: raw.public_label,
+    slug: raw.public_slug,
+    sortOrder: raw.sort_order,
+    values: raw.values.map(mapContextualAttributeListValue)
+  };
+}
+function mapContextualAttributeList(raw) {
+  return {
+    id: raw.id,
+    key: raw.key,
+    name: raw.name,
+    description: raw.description,
+    status: raw.status,
+    items: raw.items.map(mapContextualAttributeListItem)
+  };
+}
+function buildOrderBy(sortBy) {
+  switch (sortBy) {
+    case "name_asc":
+      return [{ name: "asc" }];
+    case "name_desc":
+      return [{ name: "desc" }];
+    case "newest":
+      return [{ created_at: "desc" }];
+    case "price_asc":
+    case "price_desc":
+      return void 0;
+    // Client-side sort after fetch
+    default:
+      return void 0;
+  }
+}
+function scoreSearchRelevance(product, search) {
+  const term = search.toLowerCase();
+  const name = product.name.toLowerCase();
+  if (name.startsWith(term)) return 100;
+  if (name.includes(term)) return 80;
+  if (product.brand?.name.toLowerCase().includes(term)) return 60;
+  if (product.attributes.some((a) => a.value.toLowerCase().includes(term)))
+    return 40;
+  if (product.description?.toLowerCase().includes(term)) return 20;
+  return 0;
+}
+function getMinVariantPrice(product) {
+  let min = Infinity;
+  for (const v of product.variants) {
+    if (v.pricing.currentPrice != null && v.pricing.currentPrice < min) {
+      min = v.pricing.currentPrice;
+    }
+  }
+  return min === Infinity ? 0 : min;
+}
+function resolveProductPricing(prices) {
+  const positivePrice = (priceType) => {
+    const price = prices.find((item) => item.priceType === priceType)?.price;
+    return price != null && Number.isFinite(price) && price > 0 ? price : null;
+  };
+  const regularPrice = positivePrice("CLIENT");
+  const candidateSalePrice = positivePrice("SALE");
+  const salePrice = regularPrice != null && candidateSalePrice != null && candidateSalePrice < regularPrice ? candidateSalePrice : null;
+  const hasDiscount = salePrice != null;
+  const discountPercentage = salePrice != null && regularPrice != null ? Math.round((regularPrice - salePrice) / regularPrice * 1e4) / 100 : null;
+  return {
+    currentPrice: salePrice ?? regularPrice,
+    regularPrice,
+    salePrice,
+    hasDiscount,
+    discountPercentage,
+    wholesalePrice: positivePrice("WHOLESALE"),
+    wholesale2Price: positivePrice("WHOLESALE_2")
+  };
+}
+function selectPublicPrices(prices, chainId) {
+  const selected = [];
+  for (const priceType of [
+    "SALE",
+    "CLIENT",
+    "WHOLESALE",
+    "WHOLESALE_2"
+  ]) {
+    const chainPrice = prices.find(
+      (price2) => price2.priceType === priceType && price2.chainId === chainId
+    );
+    const globalPrice = prices.find(
+      (price2) => price2.priceType === priceType && price2.chainId === null
+    );
+    const price = chainPrice ?? globalPrice;
+    if (price) selected.push(price);
+  }
+  return selected;
+}
+function hasMeaningfulAttributeListFilters(filters) {
+  if (!filters) return false;
+  return Boolean(
+    filters.categoryName || filters.subcategoryId || filters.brandId || filters.search || filters.minPrice !== void 0 || filters.maxPrice !== void 0 || (filters.tags?.some((tag) => tag.trim().length > 0) ?? false)
+  );
+}
+function chunkArray2(items, chunkSize) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += chunkSize) {
+    chunks.push(items.slice(index, index + chunkSize));
+  }
+  return chunks;
+}
+function uniqueValues2(values) {
+  return Array.from(new Set(values));
+}
+function buildProductWhere(filters, chainId) {
+  const whereConditions = [];
+  if (filters.categoryName) {
+    whereConditions.push({ category: { _eq: filters.categoryName } });
+  }
+  if (filters.subcategoryId) {
+    whereConditions.push({ subcategory: { _eq: filters.subcategoryId } });
+  }
+  if (filters.brandId) {
+    whereConditions.push({ brand_id: { _eq: filters.brandId } });
+  }
+  if (filters.search) {
+    const term = `%${filters.search}%`;
+    whereConditions.push({
+      _or: [
+        { name: { _ilike: term } },
+        { description: { _ilike: term } },
+        { brand: { name: { _ilike: term } } },
+        { product_attributes: { value: { _ilike: term } } }
+      ]
+    });
+  }
+  if (filters.colors && filters.colors.length > 0) {
+    whereConditions.push({ color: { _in: filters.colors } });
+  }
+  if (filters.tags && filters.tags.length > 0) {
+    const tags = filters.tags.map((tag) => tag.trim()).filter(Boolean);
+    if (tags.length > 0) {
+      whereConditions.push({
+        product_tag_assignments: {
+          tag: {
+            key: { _in: tags },
+            is_active: { _eq: true }
+          }
+        }
+      });
+    }
+  }
+  if (filters.minPrice !== void 0 || filters.maxPrice !== void 0) {
+    const priceCondition = {};
+    if (filters.minPrice !== void 0) priceCondition._gte = filters.minPrice;
+    if (filters.maxPrice !== void 0) priceCondition._lte = filters.maxPrice;
+    whereConditions.push({
+      product_variants: {
+        product_variant_prices: {
+          price: priceCondition,
+          price_type: { _in: ["CLIENT", "SALE"] },
+          _or: [
+            { chain_id: { _eq: chainId } },
+            { chain_id: { _is_null: true } }
+          ]
+        }
+      }
+    });
+  }
+  if (filters.attributes) {
+    for (const [attrName, values] of Object.entries(filters.attributes)) {
+      if (values.length > 0) {
+        whereConditions.push({
+          _or: [
+            {
+              product_attributes: {
+                attribute: { name: { _eq: attrName } },
+                value: { _in: values }
+              }
+            },
+            {
+              product_variants: {
+                product_variant_attributes: {
+                  attribute: { name: { _eq: attrName } },
+                  value: { _in: values }
+                }
+              }
+            }
+          ]
+        });
+      }
+    }
+  }
+  return whereConditions.length > 0 ? { _and: whereConditions } : {};
+}
+function hasMeaningfulCategoryListFilters(filters) {
+  if (!filters) return false;
+  return Boolean(
+    filters.search || filters.brandId || filters.minPrice !== void 0 || filters.maxPrice !== void 0 || (filters.tags?.some((tag) => tag.trim().length > 0) ?? false) || Object.values(filters.attributes ?? {}).some(
+      (values) => values.length > 0
+    )
+  );
+}
+async function getWebsiteAvailabilityByVariantId(graphqlUrl, getHeaders, variantIds, chainId) {
+  const uniqueVariantIds = uniqueValues2(variantIds);
+  const availabilityByVariantId = /* @__PURE__ */ new Map();
+  for (const chunk of chunkArray2(
+    uniqueVariantIds,
+    MAX_AVAILABILITY_VARIANT_IDS2
+  )) {
+    const data = await executeGraphQL(
+      graphqlUrl,
+      CHECK_AVAILABILITY,
+      { variantIds: chunk, chainId },
+      getHeaders
+    );
+    for (const item of data.websiteProductAvailability ?? []) {
+      availabilityByVariantId.set(item.product_variant_id, {
+        inStock: item.in_stock
+      });
+    }
+  }
+  return availabilityByVariantId;
+}
+async function filterProductsForWebsiteStock(graphqlUrl, getHeaders, products, chainId) {
+  const variantIds = products.flatMap(
+    (product) => product.variants.map((variant) => variant.id)
+  );
+  if (variantIds.length === 0) return [];
+  const inStockVariantIds = new Set(
+    Array.from(
+      (await getWebsiteAvailabilityByVariantId(
+        graphqlUrl,
+        getHeaders,
+        variantIds,
+        chainId
+      )).entries()
+    ).filter(([, item]) => item.inStock).map(([variantId]) => variantId)
+  );
+  return products.map((product) => ({
+    ...product,
+    variants: product.variants.map((variant) => {
+      const prices = selectPublicPrices(variant.prices, chainId);
+      return {
+        ...variant,
+        prices,
+        pricing: resolveProductPricing(prices)
+      };
+    }).filter(
+      (variant) => inStockVariantIds.has(variant.id) && variant.pricing.currentPrice != null
+    )
+  })).filter((product) => product.variants.length > 0);
+}
+async function filterSeoProductsForWebsiteStock(graphqlUrl, getHeaders, products, chainId) {
+  const variantIds = products.flatMap(
+    (product) => product.product_variants.map((variant) => variant.id)
+  );
+  if (variantIds.length === 0) return [];
+  const inStockVariantIds = new Set(
+    Array.from(
+      (await getWebsiteAvailabilityByVariantId(
+        graphqlUrl,
+        getHeaders,
+        variantIds,
+        chainId
+      )).entries()
+    ).filter(([, item]) => item.inStock).map(([variantId]) => variantId)
+  );
+  return products.filter(
+    (product) => product.product_variants.some((variant) => {
+      const prices = variant.product_variant_prices.map(mapPrice);
+      const pricing = resolveProductPricing(
+        selectPublicPrices(prices, chainId)
+      );
+      return inStockVariantIds.has(variant.id) && pricing.currentPrice != null;
+    })
+  );
+}
+function mapProductSeoEntry(raw, storageUrl) {
+  if (!raw.slug) return null;
+  return {
+    id: raw.id,
+    name: raw.name,
+    slug: raw.slug,
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at,
+    seoTitle: raw.seo_title ?? null,
+    seoDescription: raw.seo_description ?? null,
+    seoImage: mapSeoMedia(raw, storageUrl),
+    primaryImage: raw.product_media[0] ? mapMedia(raw.product_media[0], storageUrl) : null,
+    category: raw.category,
+    subcategory: raw.subcategory
+  };
+}
+function createCatalogModule(graphqlUrl, getHeaders, getContext, storageUrl) {
+  const mapSingleProductResult = async (data) => {
+    const ctx = getContext();
+    if (!ctx.chainId) {
+      throw new WebsiteError(
+        "This website has no chain configured. Catalog requires a chain_id.",
+        "NO_CHAIN"
+      );
+    }
+    const product = data.products?.[0];
+    if (!product) return null;
+    const publicAttributeLabels = buildPublicAttributeLabels(
+      data.catalog_attribute_lists
+    );
+    const filteredProducts = await filterProductsForWebsiteStock(
+      graphqlUrl,
+      getHeaders,
+      [mapProduct(product, storageUrl, publicAttributeLabels, ctx.chainId)],
+      ctx.chainId
+    );
+    return filteredProducts[0] ?? null;
+  };
+  return {
+    async getProductRecommendations(opts) {
+      const ctx = getContext();
+      const limit = opts.limit ?? 16;
+      if (!Number.isInteger(limit) || limit < 1 || limit > 32) {
+        throw new WebsiteError(
+          "Recommendation limit must be an integer between 1 and 32.",
+          "INVALID_RECOMMENDATION_LIMIT"
+        );
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        WEBSITE_GET_PRODUCT_RECOMMENDATIONS,
+        {
+          websiteId: ctx.websiteId,
+          productId: opts.productId,
+          limit
+        },
+        getHeaders
+      );
+      if (!data.result.success) {
+        throw new WebsiteError(
+          data.result.errors.join("; ") || "Unable to resolve product recommendations",
+          "PRODUCT_RECOMMENDATIONS_ERROR"
+        );
+      }
+      const products = parseActionJson(
+        data.result.products,
+        []
+      );
+      return {
+        products: products.map(
+          (product) => mapProductRecommendation(product, storageUrl)
+        ),
+        strategy: data.result.strategy
+      };
+    },
+    async getProductSeoEntries(opts) {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Catalog requires a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const limit = opts?.limit ?? 100;
+      const offset = opts?.offset ?? 0;
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PRODUCT_SEO_ENTRIES,
+        {
+          companyId: ctx.companyId,
+          chainId: ctx.chainId,
+          websiteId: ctx.websiteId,
+          limit: limit + 1,
+          offset
+        },
+        getHeaders
+      );
+      const availableProducts = await filterSeoProductsForWebsiteStock(
+        graphqlUrl,
+        getHeaders,
+        data.products ?? [],
+        ctx.chainId
+      );
+      const entries = availableProducts.slice(0, limit).map((product) => mapProductSeoEntry(product, storageUrl)).filter((entry) => Boolean(entry));
+      return {
+        entries,
+        pagination: {
+          limit,
+          offset,
+          hasMore: (data.products ?? []).length > limit
+        }
+      };
+    },
+    async getCatalogPage(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
+        },
+        getHeaders
+      );
+      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
+      };
+    },
+    async getProducts(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 where = buildProductWhere(opts ?? {}, chainId);
+      const orderBy = buildOrderBy(opts?.sortBy);
+      const variables = {
+        companyId: ctx.companyId,
+        chainId,
+        websiteId: ctx.websiteId,
+        limit: opts?.limit ?? 20,
+        offset: opts?.offset ?? 0,
+        where
+      };
+      if (orderBy) {
+        variables.orderBy = orderBy;
+      }
+      const data = await executeGraphQL(graphqlUrl, GET_PRODUCTS, variables, getHeaders);
+      const publicAttributeLabels = buildPublicAttributeLabels(
+        data.catalog_attribute_lists
+      );
+      let products = await filterProductsForWebsiteStock(
+        graphqlUrl,
+        getHeaders,
+        (data.products ?? []).map(
+          (p) => mapProduct(p, storageUrl, publicAttributeLabels, chainId)
+        ),
+        chainId
+      );
+      if (opts?.minPrice !== void 0 || opts?.maxPrice !== void 0) {
+        products = products.filter(
+          (product) => product.variants.some((variant) => {
+            const currentPrice = variant.pricing.currentPrice;
+            if (currentPrice == null) return false;
+            if (opts.minPrice !== void 0 && currentPrice < opts.minPrice) {
+              return false;
+            }
+            return !(opts.maxPrice !== void 0 && currentPrice > opts.maxPrice);
+          })
+        );
+      }
+      if (opts?.sortBy === "price_asc") {
+        products.sort((a, b) => getMinVariantPrice(a) - getMinVariantPrice(b));
+      } else if (opts?.sortBy === "price_desc") {
+        products.sort((a, b) => getMinVariantPrice(b) - getMinVariantPrice(a));
+      } else if (opts?.search && !opts?.sortBy) {
+        const search = opts.search;
+        products.sort((a, b) => {
+          const diff = scoreSearchRelevance(b, search) - scoreSearchRelevance(a, search);
+          return diff !== 0 ? diff : a.name.localeCompare(b.name);
+        });
+      }
+      return products;
+    },
+    async getProduct(productId) {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Catalog requires a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PRODUCT_BY_PK,
+        {
+          productId,
+          companyId: ctx.companyId,
+          chainId: ctx.chainId,
+          websiteId: ctx.websiteId
+        },
+        getHeaders
+      );
+      return mapSingleProductResult(data);
+    },
+    async getProductBySlug(slug) {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Catalog requires a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PRODUCT_BY_SLUG,
+        {
+          slug,
+          companyId: ctx.companyId,
+          chainId: ctx.chainId,
+          websiteId: ctx.websiteId
+        },
+        getHeaders
+      );
+      return mapSingleProductResult(data);
+    },
+    async getCategories() {
+      const data = await executeGraphQL(graphqlUrl, GET_CATEGORIES, {}, getHeaders);
+      return (data.product_categories ?? []).map(mapCategory);
+    },
+    async getCategoryList(opts) {
+      const ctx = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_CATALOG_CATEGORY_LIST,
+        {
+          companyId: ctx.companyId,
+          key: opts.key
+        },
+        getHeaders
+      );
+      const list = data.list?.[0] ?? null;
+      if (!list) return null;
+      if (opts.onlyApplicable || hasMeaningfulCategoryListFilters(opts.filters)) {
+        if (!ctx.chainId) {
+          throw new WebsiteError(
+            "This website has no chain configured. Applicable category lists require a chain_id.",
+            "NO_CHAIN"
+          );
+        }
+        const chainId = ctx.chainId;
+        const applicableProductsData = await executeGraphQL(
+          graphqlUrl,
+          GET_PRODUCT_FILTERS,
+          {
+            companyId: ctx.companyId,
+            chainId,
+            attributeListKey: DEFAULT_FILTER_ATTRIBUTE_LIST_KEY,
+            where: buildProductWhere(opts.filters ?? {}, chainId)
+          },
+          getHeaders
+        );
+        const variantIds = (applicableProductsData.products ?? []).flatMap(
+          (product) => product.product_variants.map((variant) => variant.id)
+        );
+        const availabilityByVariantId = await getWebsiteAvailabilityByVariantId(
+          graphqlUrl,
+          getHeaders,
+          variantIds,
+          chainId
+        );
+        const applicableCategories = /* @__PURE__ */ new Set();
+        const applicableSubcategoryIds = /* @__PURE__ */ new Set();
+        for (const product of applicableProductsData.products ?? []) {
+          const hasVisibleVariant = product.product_variants.some((variant) => {
+            const prices = selectPublicPrices(
+              variant.product_variant_prices.map(mapPrice),
+              chainId
+            );
+            return prices.length > 0 && (availabilityByVariantId.get(variant.id)?.inStock ?? false);
+          });
+          if (!hasVisibleVariant) continue;
+          applicableCategories.add(product.category);
+          if (product.subcategory) {
+            applicableSubcategoryIds.add(product.subcategory);
+          }
+        }
+        return filterCategoryListByApplicability(
+          list,
+          applicableCategories,
+          applicableSubcategoryIds
+        );
+      }
+      return mapCategoryList(list);
+    },
+    async getAttributeList(opts) {
+      const ctx = getContext();
+      if (opts.onlyApplicable || hasMeaningfulAttributeListFilters(opts.filters)) {
+        if (!ctx.websiteId) {
+          throw new WebsiteError(
+            "This client has no website configured. Contextual attribute lists require a website_id.",
+            "NO_WEBSITE"
+          );
+        }
+        const data2 = await executeGraphQL(
+          graphqlUrl,
+          GET_CONTEXTUAL_CATALOG_ATTRIBUTE_LIST,
+          {
+            websiteId: ctx.websiteId,
+            key: opts.key,
+            onlyApplicable: opts.onlyApplicable ? true : void 0,
+            filters: opts.filters
+          },
+          getHeaders
+        );
+        const result = data2.websiteGetAttributeList;
+        if (!result.success) {
+          throw new WebsiteError(
+            result.errors?.join("; ") || "Unable to resolve attribute list",
+            "ATTRIBUTE_LIST_ERROR"
+          );
+        }
+        return result.list ? mapContextualAttributeList(result.list) : null;
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_CATALOG_ATTRIBUTE_LIST,
+        {
+          companyId: ctx.companyId,
+          key: opts.key
+        },
+        getHeaders
+      );
+      const list = data.list?.[0] ?? null;
+      return list ? mapAttributeList(list) : null;
+    },
+    async getBrands() {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Brands require a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_BRANDS,
+        { companyId: ctx.companyId, chainId: ctx.chainId },
+        getHeaders
+      );
+      return data.brands ?? [];
+    },
+    async getProductFilters(opts) {
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Catalog filters require a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const chainId = ctx.chainId;
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PRODUCT_FILTERS,
+        {
+          companyId: ctx.companyId,
+          chainId,
+          attributeListKey: opts?.attributeListKey ?? DEFAULT_FILTER_ATTRIBUTE_LIST_KEY,
+          where: {
+            ...opts?.categoryName ? { category: { _eq: opts.categoryName } } : {},
+            ...opts?.subcategoryId ? { subcategory: { _eq: opts.subcategoryId } } : {}
+          }
+        },
+        getHeaders
+      );
+      const categoryCounts = /* @__PURE__ */ new Map();
+      const colorCounts = /* @__PURE__ */ new Map();
+      const brandCounts = /* @__PURE__ */ new Map();
+      const publicPrices = [];
+      const attributeValueCounts = /* @__PURE__ */ new Map();
+      const variantIds = (data.products ?? []).flatMap(
+        (product) => product.product_variants.map((variant) => variant.id)
+      );
+      const availabilityByVariantId = await getWebsiteAvailabilityByVariantId(
+        graphqlUrl,
+        getHeaders,
+        variantIds,
+        chainId
+      );
+      const publicAttributeLabels = buildPublicAttributeLabels(
+        data.catalog_attribute_lists
+      );
+      const configuredAttributeIds = new Set(
+        (data.catalog_attribute_lists?.[0]?.items ?? []).map(
+          (item) => item.attribute_id
+        )
+      );
+      const registerAttributeValue = (raw) => {
+        if (!configuredAttributeIds.has(raw.attribute.id)) return;
+        const valueCode = attributeValueCode(raw);
+        const value = raw.attribute_value ?? null;
+        const counts = attributeValueCounts.get(raw.attribute.id) ?? /* @__PURE__ */ new Map();
+        const current = counts.get(valueCode);
+        counts.set(valueCode, {
+          count: (current?.count ?? 0) + 1,
+          value: value ?? current?.value ?? null
+        });
+        attributeValueCounts.set(raw.attribute.id, counts);
+      };
+      for (const product of data.products ?? []) {
+        if (opts?.categoryName && product.category !== opts.categoryName) {
+          continue;
+        }
+        const visibleVariants = product.product_variants.map((variant) => ({
+          ...variant,
+          prices: selectPublicPrices(
+            variant.product_variant_prices.map(mapPrice),
+            chainId
+          ),
+          inStock: availabilityByVariantId.get(variant.id)?.inStock ?? false
+        })).filter((variant) => variant.inStock && variant.prices.length > 0);
+        if (visibleVariants.length === 0) continue;
+        categoryCounts.set(
+          product.category,
+          (categoryCounts.get(product.category) ?? 0) + 1
+        );
+        if (product.color) {
+          colorCounts.set(
+            product.color,
+            (colorCounts.get(product.color) ?? 0) + 1
+          );
+        }
+        if (product.brand) {
+          const current = brandCounts.get(product.brand.id);
+          brandCounts.set(product.brand.id, {
+            id: product.brand.id,
+            name: product.brand.name,
+            count: (current?.count ?? 0) + 1
+          });
+        }
+        for (const variant of visibleVariants) {
+          for (const price of variant.prices) {
+            publicPrices.push(price.price);
+          }
+          if (opts?.categoryName) {
+            for (const attribute of variant.product_variant_attributes) {
+              registerAttributeValue(attribute);
+            }
+          }
+        }
+        if (opts?.categoryName) {
+          for (const attribute of product.product_attributes) {
+            registerAttributeValue(attribute);
+          }
+        }
+      }
+      const attributes = opts?.categoryName ? (data.catalog_attribute_lists?.[0]?.items ?? []).map((item) => {
+        const counts = attributeValueCounts.get(item.attribute_id);
+        if (!counts || counts.size === 0) return null;
+        return {
+          id: item.attribute_id,
+          name: item.public_label,
+          values: Array.from(counts.entries()).map(([valueCode, countItem]) => ({
+            value: publicAttributeLabels.valueLabelsById.get(
+              countItem.value?.id ?? ""
+            ) ?? publicAttributeLabels.valueLabelsByAttributeAndCode.get(
+              attributeValueLabelKey(item.attribute_id, valueCode)
+            ) ?? valueCode,
+            count: countItem.count,
+            attributeValueId: countItem.value?.id ?? null,
+            code: countItem.value?.code ?? valueCode,
+            metadata: countItem.value?.metadata ?? null,
+            sortOrder: countItem.value?.sort_order ?? null
+          })).sort((a, b) => {
+            const orderA = a.sortOrder ?? Number.MAX_SAFE_INTEGER;
+            const orderB = b.sortOrder ?? Number.MAX_SAFE_INTEGER;
+            return orderA === orderB ? a.value.localeCompare(b.value) : orderA - orderB;
+          })
+        };
+      }).filter((item) => Boolean(item)) : [];
+      const minPrice = publicPrices.length > 0 ? Math.min(...publicPrices) : 0;
+      const maxPrice = publicPrices.length > 0 ? Math.max(...publicPrices) : 0;
+      return {
+        categories: Array.from(categoryCounts.entries()).map(([name, count]) => ({ name, count })).sort((a, b) => a.name.localeCompare(b.name)),
+        brands: Array.from(brandCounts.values()).sort(
+          (a, b) => a.name.localeCompare(b.name)
+        ),
+        colors: Array.from(colorCounts.entries()).map(([value, count]) => ({ value, count })).sort((a, b) => a.value.localeCompare(b.value)),
+        priceRange: {
+          min: minPrice,
+          max: maxPrice
+        },
+        attributes
+      };
+    },
+    async getSearchSuggestions(opts) {
+      if (!opts.query || opts.query.trim().length === 0) return [];
+      const ctx = getContext();
+      if (!ctx.chainId) {
+        throw new WebsiteError(
+          "This website has no chain configured. Search suggestions require a chain_id.",
+          "NO_CHAIN"
+        );
+      }
+      const term = `%${opts.query}%`;
+      const limit = opts.limit ?? 8;
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_SEARCH_SUGGESTIONS,
+        {
+          companyId: ctx.companyId,
+          chainId: ctx.chainId,
+          term,
+          productLimit: Math.min(limit, 5),
+          brandLimit: Math.max(limit - 5, 3)
+        },
+        getHeaders
+      );
+      const suggestions = [];
+      for (const p of data.products ?? []) {
+        suggestions.push({ type: "product", text: p.name, id: p.id });
+      }
+      for (const b of data.brands ?? []) {
+        suggestions.push({ type: "brand", text: b.name, id: b.id });
+      }
+      return suggestions.slice(0, limit);
+    }
+  };
+}
+
+// libs/sdk/src/modules/checkout.ts
+function requireCartSession2(storage) {
+  const session = storage.get();
+  if (!session) {
+    throw new WebsiteError(
+      "No guest cart session found",
+      "CART_SESSION_MISSING"
+    );
+  }
+  return session;
+}
+function mapCartItem2(raw) {
+  return {
+    id: raw.id,
+    productVariantId: raw.product_variant_id,
+    quantity: raw.quantity,
+    productVariant: {
+      sku: raw.product_variant.sku,
+      product: raw.product_variant.product,
+      prices: raw.product_variant.prices.map((price) => ({
+        id: price.id,
+        price: price.price,
+        priceType: price.price_type,
+        chainId: price.chain_id
+      }))
+    }
+  };
+}
+function mapCart2(raw) {
+  return {
+    id: raw.id,
+    items: raw.items.map(mapCartItem2),
+    totals: {
+      subtotal: raw.total_without_tax,
+      tax: raw.tax,
+      discount: raw.discount,
+      total: raw.total_with_tax
+    },
+    status: raw.status,
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at
+  };
+}
+function mapCouponResult(raw) {
+  return {
+    success: raw.success,
+    orderId: raw.order_id,
+    couponId: raw.coupon_id,
+    code: raw.code,
+    name: raw.name,
+    couponType: raw.coupon_type,
+    discountAmount: Number(raw.discount_amount ?? 0),
+    eligibleSubtotal: Number(raw.eligible_subtotal ?? 0),
+    message: raw.message,
+    cart: raw.cart ? mapCart2(raw.cart) : null,
+    errors: raw.errors
+  };
+}
+function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionStorage) {
+  return {
+    async getLocationOptions() {
+      const context = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_LOCATION_OPTIONS,
+        { websiteId: context.websiteId },
+        getHeaders
+      );
+      const result = data.websiteGetLocationOptions;
+      if (!result.success) {
+        throw new CheckoutError(result.errors ?? ["LOCATION_OPTIONS_FAILED"]);
+      }
+      return {
+        countryCode: result.country_code,
+        departments: result.departments.map((department) => ({
+          departmentId: department.department_id,
+          departmentName: department.department_name,
+          departmentCode: department.department_code,
+          municipalities: department.municipalities.map((municipality) => ({
+            municipalityId: municipality.municipality_id,
+            municipalityName: municipality.municipality_name,
+            municipalityCode: municipality.municipality_code,
+            departmentId: municipality.department_id,
+            departmentCode: municipality.department_code
+          }))
+        }))
+      };
+    },
+    async getDeliveryOptions() {
+      const context = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_DELIVERY_OPTIONS,
+        { websiteId: context.websiteId },
+        getHeaders
+      );
+      const result = data.websiteGetDeliveryOptions;
+      if (!result.success) {
+        throw new CheckoutError(result.errors ?? ["DELIVERY_OPTIONS_FAILED"]);
+      }
+      return result.delivery_options.map((option) => ({
+        id: option.id,
+        fulfillmentFamily: option.fulfillment_family,
+        label: option.label,
+        description: option.description,
+        isEnabled: option.is_enabled,
+        pickupInfo: option.pickup_info ? {
+          label: option.pickup_info.label,
+          address: option.pickup_info.address,
+          schedule: option.pickup_info.schedule,
+          notes: option.pickup_info.notes
+        } : null
+      }));
+    },
+    async getShippingQuotes(input) {
+      const context = getContext();
+      const session = cartSessionStorage.get();
+      const items = session ? null : input.items?.length ? input.items : null;
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_SHIPPING_QUOTES,
+        {
+          websiteId: context.websiteId,
+          orderId: session?.orderId ?? null,
+          cartToken: session?.cartToken ?? null,
+          items: items?.map((item) => ({
+            product_variant_id: item.productVariantId,
+            quantity: item.quantity
+          })),
+          address: input.address
+        },
+        getHeaders
+      );
+      const result = data.websiteGetShippingQuotes;
+      if (!result.success) {
+        throw new CheckoutError(result.errors ?? ["SHIPPING_QUOTES_FAILED"]);
+      }
+      return result.quotes.map((quote) => ({
+        quoteId: quote.quote_id,
+        shippingServiceId: quote.shipping_service_id,
+        label: quote.label,
+        serviceName: quote.service_name,
+        baseAmount: quote.base_amount,
+        amount: quote.amount,
+        currency: quote.currency,
+        collectionMode: quote.collection_mode,
+        totalPolicy: quote.total_policy,
+        estimatedDelivery: quote.estimated_delivery,
+        freeShippingEligible: quote.free_shipping_eligible,
+        freeShippingApplied: quote.free_shipping_applied,
+        freeShippingThreshold: quote.free_shipping_threshold,
+        freeShippingRemaining: quote.free_shipping_remaining,
+        freeShippingEligibleSubtotal: quote.free_shipping_eligible_subtotal
+      }));
+    },
+    async getShippingPolicy() {
+      const context = getContext();
+      const data = await 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
+      };
+    },
+    async getFreeShippingProgress(input) {
+      if (input.items.length === 0) {
+        throw new WebsiteError(
+          "At least one cart item is required",
+          "CART_ITEMS_REQUIRED"
+        );
+      }
+      const context = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_FREE_SHIPPING_PROGRESS,
+        {
+          websiteId: context.websiteId,
+          items: input.items.map((item) => ({
+            product_variant_id: item.productVariantId,
+            quantity: item.quantity
+          }))
+        },
+        getHeaders
+      );
+      const result = data.websiteGetFreeShippingProgress;
+      if (!result.success || !result.progress) {
+        throw new CheckoutError(
+          result.errors ?? ["FREE_SHIPPING_PROGRESS_FAILED"]
+        );
+      }
+      return {
+        enabled: result.progress.enabled,
+        threshold: result.progress.threshold,
+        remaining: result.progress.remaining,
+        eligibleSubtotal: result.progress.eligible_subtotal,
+        thresholdReached: result.progress.threshold_reached,
+        currency: result.progress.currency
+      };
+    },
+    async getPaymentMethods() {
+      const context = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PAYMENT_METHODS,
+        { websiteId: context.websiteId },
+        getHeaders
+      );
+      const result = data.websiteGetPaymentMethods;
+      if (!result.success) {
+        throw new CheckoutError(result.errors ?? ["PAYMENT_METHODS_FAILED"]);
+      }
+      return result.payment_methods.map((method) => ({
+        id: method.id,
+        code: method.code,
+        label: method.label,
+        paymentMethodType: method.payment_method_type,
+        gatewayCode: method.gateway_code,
+        description: method.description,
+        isEnabled: method.is_enabled,
+        sortOrder: method.sort_order,
+        requiresPaymentSession: method.requires_payment_session,
+        publicConfig: method.public_config
+      }));
+    },
+    async getPaymentOptions(input) {
+      const context = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PAYMENT_OPTIONS,
+        {
+          websiteId: context.websiteId,
+          fulfillmentFamily: input.fulfillmentFamily
+        },
+        getHeaders
+      );
+      const result = data.websiteGetPaymentOptions;
+      if (!result.success) {
+        throw new CheckoutError(result.errors ?? ["PAYMENT_OPTIONS_FAILED"]);
+      }
+      return result.payment_options.map((option) => ({
+        id: option.id,
+        mode: option.mode,
+        fulfillmentFamily: option.fulfillment_family,
+        label: option.label,
+        description: option.description,
+        requiresPaymentMethod: option.requires_payment_method,
+        allowsInitialPayment: option.allows_initial_payment,
+        initialPaymentPolicy: option.initial_payment_policy,
+        requiresInitialPayment: option.requires_initial_payment,
+        minInitialAmount: option.min_initial_amount,
+        suggestedInitialAmount: option.suggested_initial_amount,
+        sortOrder: option.sort_order,
+        methods: option.methods.map((method) => ({
+          id: method.id,
+          paymentMethodId: method.payment_method_id,
+          code: method.code,
+          label: method.label,
+          paymentMethodType: method.payment_method_type,
+          gatewayCode: method.gateway_code,
+          description: method.description,
+          instructions: method.instructions,
+          qrFileId: method.qr_file_id,
+          requiresPaymentSession: method.requires_payment_session,
+          publicConfig: method.public_config ?? {},
+          sortOrder: method.sort_order
+        }))
+      }));
+    },
+    async validateCoupon(input) {
+      const session = requireCartSession2(cartSessionStorage);
+      const data = await executeGraphQL(
+        graphqlUrl,
+        VALIDATE_COUPON,
+        {
+          orderId: session.orderId,
+          cartToken: session.cartToken,
+          code: input.code
+        },
+        getHeaders
+      );
+      return mapCouponResult(data.websiteValidateCoupon);
+    },
+    async applyCoupon(input) {
+      const session = requireCartSession2(cartSessionStorage);
+      const data = await executeGraphQL(
+        graphqlUrl,
+        APPLY_COUPON,
+        {
+          orderId: session.orderId,
+          cartToken: session.cartToken,
+          code: input.code
+        },
+        getHeaders
+      );
+      return mapCouponResult(data.websiteApplyCoupon);
+    },
+    async removeCoupon(input) {
+      const session = requireCartSession2(cartSessionStorage);
+      const data = await executeGraphQL(
+        graphqlUrl,
+        REMOVE_COUPON,
+        {
+          orderId: session.orderId,
+          cartToken: session.cartToken,
+          couponId: input.couponId
+        },
+        getHeaders
+      );
+      return mapCouponResult(data.websiteRemoveCoupon);
+    },
+    async submit(input) {
+      const session = requireCartSession2(cartSessionStorage);
+      const data = await executeGraphQL(
+        graphqlUrl,
+        CHECKOUT,
+        {
+          orderId: session.orderId,
+          cartToken: session.cartToken,
+          contact: input.contact,
+          fulfillmentFamily: input.fulfillmentFamily,
+          address: input.address,
+          shippingQuoteId: input.shippingQuoteId,
+          paymentMode: input.paymentMode,
+          paymentMethodId: input.paymentMethodId,
+          buyerAccountOptIn: input.buyerAccountOptIn,
+          initialPayment: input.initialPayment ? {
+            amount: input.initialPayment.amount,
+            payment_method_id: input.initialPayment.paymentMethodId
+          } : void 0
+        },
+        getHeaders
+      );
+      const result = data.websiteCheckout;
+      if (!result.success && result.errors && result.errors.length > 0) {
+        throw new CheckoutError(result.errors);
+      }
+      if (result.success && !result.requires_payment_session) {
+        cartSessionStorage.clear();
+      }
+      return {
+        success: result.success,
+        orderId: result.order_id,
+        orderNumber: result.order_number,
+        paymentMethodId: result.payment_method_id,
+        publicOrderToken: result.public_order_token,
+        requiresPaymentSession: Boolean(result.requires_payment_session),
+        buyerAccountInvitationRequested: Boolean(
+          result.buyer_account_invitation_requested
+        ),
+        errors: result.errors
+      };
+    },
+    async createPaymentSession(input) {
+      const session = cartSessionStorage.get();
+      const orderId = input.orderId ?? session?.orderId;
+      if (!orderId || !input.publicOrderToken && !session?.cartToken) {
+        throw new WebsiteError(
+          "Payment retry requires an order and public order token",
+          "PAYMENT_SESSION_CONTEXT_MISSING"
+        );
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        CREATE_PAYMENT_SESSION,
+        {
+          orderId,
+          cartToken: input.publicOrderToken ? null : session?.cartToken,
+          publicOrderToken: input.publicOrderToken ?? null,
+          paymentMethodId: input.paymentMethodId,
+          returnUrl: input.returnUrl
+        },
+        getHeaders
+      );
+      const result = data.websiteCreatePaymentSession;
+      if (result.success && result.payment_session_id && (result.integration_mode !== "redirect" || !result.redirect_url)) {
+        throw new WebsiteError(
+          "Payment gateway did not provide a redirect URL",
+          "PAYMENT_GATEWAY_REDIRECT_NOT_AVAILABLE"
+        );
+      }
+      if (result.success) {
+        cartSessionStorage.clear();
+      }
+      return {
+        success: result.success,
+        orderId: result.order_id,
+        paymentMethodId: result.payment_method_id,
+        paymentSessionId: result.payment_session_id,
+        gatewayCode: result.gateway_code,
+        integrationMode: result.integration_mode === "redirect" ? "redirect" : null,
+        status: result.status,
+        redirectUrl: result.redirect_url,
+        publicPayload: result.public_payload,
+        errors: result.errors
+      };
+    },
+    async reconcilePaymentSession(input) {
+      const data = await executeGraphQL(
+        graphqlUrl,
+        RECONCILE_PAYMENT_SESSION,
+        {
+          orderId: input.orderId,
+          publicOrderToken: input.publicOrderToken,
+          paymentSessionId: input.paymentSessionId,
+          gatewayTransactionId: input.gatewayTransactionId
+        },
+        getHeaders
+      );
+      const result = data.websiteReconcilePaymentSession;
+      return {
+        success: result.success,
+        orderId: result.order_id,
+        paymentMethodId: result.payment_method_id,
+        paymentSessionId: result.payment_session_id,
+        gatewayCode: result.gateway_code,
+        integrationMode: result.integration_mode === "redirect" ? "redirect" : null,
+        status: result.status,
+        redirectUrl: result.redirect_url,
+        publicPayload: result.public_payload,
+        errors: result.errors
+      };
+    }
+  };
+}
+
+// libs/sdk/src/modules/content.ts
+var DEFAULT_LOCALE = "es-CO";
+function mapEntry(raw) {
+  return {
+    id: raw.id,
+    key: raw.key,
+    categoryKey: raw.category_key,
+    name: raw.name,
+    locale: raw.locale,
+    status: raw.status,
+    tags: raw.tags ?? [],
+    contentJson: raw.content_json ?? {},
+    resolvedFields: raw.resolved_fields ?? {},
+    publishedAt: raw.published_at,
+    updatedAt: raw.updated_at,
+    contentType: {
+      id: raw.content_type.id,
+      key: raw.content_type.key,
+      name: raw.content_type.name,
+      kind: raw.content_type.kind
+    }
+  };
+}
+function baseVariables(ctx, opts) {
+  return {
+    websiteId: ctx.websiteId,
+    locale: opts?.locale ?? DEFAULT_LOCALE
+  };
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalText(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+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);
+  return {
+    ...value,
+    ...urls,
+    url: 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 altText = readOptionalText(attrs.altText) ?? readOptionalText(attrs.alt);
+    const caption = readOptionalText(attrs.caption);
+    const showCaption = Boolean(caption) && attrs.showCaption !== false;
+    return {
+      ...value,
+      attrs: {
+        ...attrs,
+        ...urls,
+        alt: altText,
+        altText,
+        caption,
+        showCaption,
+        src: type === "bacanoImage" ? urls.detailUrl : urls.originalUrl
+      }
+    };
+  }
+  return value;
+}
+function normalizeContentMedia(value, storageUrl) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeContentMedia(item, storageUrl));
+  }
+  if (!isRecord(value)) return value;
+  const normalized = normalizeRichTextNode(value, storageUrl);
+  const enriched = typeof normalized.fileId === "string" && typeof normalized.mediaKind === "string" ? enrichMediaValue(normalized, storageUrl) : normalized;
+  return Object.fromEntries(
+    Object.entries(enriched).map(([key, entryValue]) => [
+      key,
+      normalizeContentMedia(entryValue, storageUrl)
+    ])
+  );
+}
+function getEntries(data) {
+  if (!data.result?.success) return [];
+  return data.result.entries ?? [];
+}
+function chooseOne(data, storageUrl) {
+  const entry = getEntries(data)[0] ?? null;
+  return entry ? mapEntryWithMedia(entry, storageUrl) : null;
+}
+function chooseMany(data, storageUrl) {
+  return getEntries(data).map((entry) => mapEntryWithMedia(entry, storageUrl));
+}
+function mapEntryWithMedia(raw, storageUrl) {
+  return {
+    ...mapEntry(raw),
+    contentJson: normalizeContentMedia(
+      raw.content_json ?? {},
+      storageUrl
+    ),
+    resolvedFields: normalizeContentMedia(
+      raw.resolved_fields ?? {},
+      storageUrl
+    )
+  };
+}
+function mapProductContentBlock(raw, storageUrl) {
+  return {
+    id: raw.id,
+    productId: raw.product_id,
+    locale: raw.locale,
+    contentJson: normalizeContentMedia(
+      raw.content_json ?? {},
+      storageUrl
+    ),
+    resolvedFields: normalizeContentMedia(
+      raw.resolved_fields ?? {},
+      storageUrl
+    ),
+    sortOrder: raw.sort_order,
+    updatedAt: raw.updated_at,
+    contentType: {
+      id: raw.content_type.id,
+      key: raw.content_type.key,
+      name: raw.content_type.name,
+      kind: raw.content_type.kind
+    }
+  };
+}
+function createContentModule(graphqlUrl, getHeaders, getContext, storageUrl) {
+  return {
+    async getByKey(key, opts) {
+      const ctx = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        WEBSITE_GET_CONTENT,
+        { ...baseVariables(ctx, opts), key },
+        getHeaders
+      );
+      return chooseOne(data, storageUrl);
+    },
+    async getByCategory(categoryKey, opts) {
+      const ctx = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        WEBSITE_GET_CONTENT,
+        { ...baseVariables(ctx, opts), categoryKey },
+        getHeaders
+      );
+      return chooseMany(data, storageUrl);
+    },
+    async getByTag(tag, opts) {
+      const ctx = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        WEBSITE_GET_CONTENT,
+        { ...baseVariables(ctx, opts), tag },
+        getHeaders
+      );
+      return chooseMany(data, storageUrl);
+    },
+    async getForProduct(productId, opts) {
+      const ctx = getContext();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        WEBSITE_GET_PRODUCT_CONTENT,
+        {
+          websiteId: ctx.websiteId,
+          productId,
+          locale: opts?.locale ?? DEFAULT_LOCALE
+        },
+        getHeaders
+      );
+      if (!data.result?.success) return [];
+      return (data.result.blocks ?? []).map(
+        (block) => mapProductContentBlock(block, storageUrl)
+      );
+    }
+  };
+}
+
+// libs/sdk/src/modules/orders.ts
+function mapOrderItem(raw) {
+  return {
+    id: raw.id,
+    productVariantId: raw.product_variant_id,
+    quantity: raw.quantity,
+    productVariant: {
+      sku: raw.product_variant.sku,
+      product: raw.product_variant.product
+    }
+  };
+}
+function mapOrder(raw) {
+  return {
+    id: raw.id,
+    orderNumber: raw.order_number,
+    status: raw.status,
+    fulfillmentFamily: raw.fulfillment_family,
+    discount: raw.discount,
+    tax: raw.tax,
+    subtotal: raw.total_without_tax,
+    total: raw.total_with_tax,
+    totalWithDiscount: raw.total_with_discount,
+    items: raw.order_product_variants.map(mapOrderItem),
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at
+  };
+}
+function mapPublicOrder(raw) {
+  return {
+    orderId: raw.order_id,
+    orderNumber: raw.order_number,
+    status: raw.status,
+    paymentStatus: raw.payment_status,
+    fulfillmentFamily: raw.fulfillment_family,
+    delivery: {
+      fulfillmentFamily: raw.delivery.fulfillment_family,
+      shipping: raw.delivery.shipping ? {
+        label: raw.delivery.shipping.label,
+        amount: raw.delivery.shipping.amount,
+        methodType: raw.delivery.shipping.method_type,
+        collectionMode: raw.delivery.shipping.collection_mode,
+        totalPolicy: raw.delivery.shipping.total_policy,
+        address: raw.delivery.shipping.address
+      } : null,
+      pickup: raw.delivery.pickup
+    },
+    payment: {
+      mode: raw.payment.mode,
+      label: raw.payment.label,
+      method: raw.payment.method ? {
+        id: raw.payment.method.id,
+        label: raw.payment.method.label,
+        paymentMethodType: raw.payment.method.payment_method_type,
+        gatewayCode: raw.payment.method.gateway_code,
+        requiresPaymentSession: raw.payment.method.requires_payment_session
+      } : null,
+      initialPayment: raw.payment.initial_payment ? {
+        amount: raw.payment.initial_payment.amount,
+        paymentMethodId: raw.payment.initial_payment.payment_method_id,
+        methodLabel: raw.payment.initial_payment.method_label,
+        paymentMethodType: raw.payment.initial_payment.payment_method_type,
+        gatewayCode: raw.payment.initial_payment.gateway_code,
+        requiresPaymentSession: raw.payment.initial_payment.requires_payment_session
+      } : null,
+      requiresPaymentSession: raw.payment.requires_payment_session,
+      nextAction: raw.payment.next_action,
+      session: raw.payment.session ? {
+        id: raw.payment.session.id,
+        gatewayCode: raw.payment.session.gateway_code,
+        integrationMode: raw.payment.session.integration_mode,
+        status: raw.payment.session.status,
+        reference: raw.payment.session.reference,
+        amount: raw.payment.session.amount,
+        currency: raw.payment.session.currency,
+        gatewayTransactionId: raw.payment.session.gateway_transaction_id,
+        errorMessage: raw.payment.session.error_message,
+        expiresAt: raw.payment.session.expires_at,
+        createdAt: raw.payment.session.created_at,
+        updatedAt: raw.payment.session.updated_at
+      } : null
+    },
+    totals: {
+      subtotal: raw.totals.subtotal,
+      tax: raw.totals.tax,
+      discount: raw.totals.discount,
+      total: raw.totals.total,
+      totalWithDiscount: raw.totals.total_with_discount
+    },
+    items: raw.items.map((item) => ({
+      id: item.id,
+      productVariantId: item.product_variant_id,
+      sku: item.sku,
+      name: item.name,
+      imageFileId: item.image_file_id,
+      quantity: item.quantity,
+      unitPrice: item.unit_price,
+      lineTotal: item.line_total
+    })),
+    nextSteps: raw.next_steps,
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at
+  };
+}
+function createOrdersModule(graphqlUrl, getHeaders, getContext) {
+  async function requireAuth() {
+    const headers = await getHeaders();
+    if (!headers.Authorization) {
+      throw new AuthError("You must be logged in to view orders");
+    }
+    return headers;
+  }
+  async function fetchPublicOrder(input) {
+    const context = getContext();
+    const data = await executeGraphQL(
+      graphqlUrl,
+      GET_PUBLIC_ORDER,
+      {
+        websiteId: context.websiteId,
+        orderId: input.orderId,
+        token: input.token
+      },
+      getHeaders
+    );
+    const result = data.websiteGetPublicOrder;
+    if (!result.success) {
+      if (result.errors?.includes("ORDER_NOT_FOUND")) return null;
+      throw new CheckoutError(result.errors ?? ["PUBLIC_ORDER_FAILED"]);
+    }
+    return result.order ? mapPublicOrder(result.order) : null;
+  }
+  return {
+    async list(opts) {
+      const headers = await requireAuth();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_ORDERS,
+        {
+          limit: opts?.limit ?? 20,
+          offset: opts?.offset ?? 0
+        },
+        headers
+      );
+      return (data.orders ?? []).map(mapOrder);
+    },
+    async get(orderId) {
+      const headers = await requireAuth();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_ORDER_BY_PK,
+        { orderId },
+        headers
+      );
+      const order = data.orders?.[0];
+      return order ? mapOrder(order) : null;
+    },
+    async getPublicOrder(input) {
+      return fetchPublicOrder(input);
+    },
+    async waitForPayment(input) {
+      const intervalMs = Math.max(500, input.intervalMs ?? 1500);
+      const timeoutMs = Math.max(intervalMs, input.timeoutMs ?? 12e4);
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() <= deadline) {
+        const order = await fetchPublicOrder(input);
+        if (!order) {
+          throw new CheckoutError(["ORDER_NOT_FOUND"]);
+        }
+        const sessionStatus = order.payment.session?.status ?? null;
+        if (order.paymentStatus === "PAID" || sessionStatus === "approved" || ["declined", "error", "expired", "cancelled"].includes(
+          sessionStatus ?? ""
+        )) {
+          return order;
+        }
+        await wait(intervalMs);
+      }
+      throw new CheckoutError(["PAYMENT_STATUS_TIMEOUT"]);
+    }
+  };
+}
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// libs/sdk/src/modules/profile.ts
+function hasCanonicalLocation(address) {
+  return Boolean(
+    address.department_code && address.municipality_code && address.geo_department?.name && address.geo_municipality?.name
+  );
+}
+function mapProfile(raw) {
+  const primaryAddress = raw.party.shipping_addresses?.[0];
+  return {
+    id: raw.id,
+    name: raw.party.first_name,
+    lastname: raw.party.last_name,
+    email: raw.party.email,
+    cellphone: raw.party.phone_e164,
+    phone: raw.party.phone_national_number,
+    address: primaryAddress?.address ?? raw.party.address,
+    city: primaryAddress?.geo_municipality?.name ?? raw.party.geo_municipality?.name ?? null,
+    state: primaryAddress?.geo_department?.name ?? raw.party.geo_department?.name ?? null,
+    country: primaryAddress?.geo_country?.name ?? raw.party.geo_country?.name ?? raw.party.country_code ?? null,
+    birthday: raw.party.birthdate,
+    companyName: raw.party.legal_name ?? raw.party.commercial_name
+  };
+}
+function mapProfileAddresses(raw) {
+  const party = raw.party;
+  const recipientName = [party.first_name, party.last_name].filter(Boolean).join(" ") || party.display_name;
+  const addresses = [];
+  const shippingAddresses = party.shipping_addresses.filter(hasCanonicalLocation);
+  const preferredShippingAddress = shippingAddresses.find((address) => address.is_primary) ?? shippingAddresses[0];
+  if (party.address?.trim() && hasCanonicalLocation(party)) {
+    addresses.push({
+      id: raw.party_id,
+      type: "PRIMARY",
+      label: "Direcci\xF3n principal",
+      isPrimary: !preferredShippingAddress,
+      recipientName,
+      cellphone: party.phone_e164 ?? party.phone_national_number,
+      line1: party.address,
+      line2: party.address_complement,
+      notes: null,
+      countryCode: party.country_code ?? "CO",
+      countryName: party.geo_country?.name ?? party.country_code ?? "CO",
+      departmentId: party.department_code,
+      departmentCode: party.department_code,
+      departmentName: party.geo_department.name,
+      municipalityId: party.municipality_code,
+      municipalityCode: party.municipality_code,
+      municipalityName: party.geo_municipality.name
+    });
+  }
+  addresses.push(
+    ...shippingAddresses.map((address) => ({
+      id: address.id,
+      type: "SHIPPING",
+      label: address.label,
+      isPrimary: address.id === preferredShippingAddress?.id,
+      recipientName: address.recipient_name,
+      cellphone: address.phone_e164,
+      line1: address.address,
+      line2: address.address_complement,
+      notes: address.notes,
+      countryCode: address.country_code,
+      countryName: address.geo_country?.name ?? address.country_code,
+      departmentId: address.department_code,
+      departmentCode: address.department_code,
+      departmentName: address.geo_department.name,
+      municipalityId: address.municipality_code,
+      municipalityCode: address.municipality_code,
+      municipalityName: address.geo_municipality.name
+    }))
+  );
+  return addresses;
+}
+function mapProfileUpdate(data) {
+  return {
+    display_name: [data.name, data.lastname].filter(Boolean).join(" ") || void 0,
+    first_name: data.name,
+    last_name: data.lastname,
+    phone_e164: data.cellphone,
+    phone_national_number: data.phone,
+    address: data.address,
+    address_complement: data.addressComplement,
+    country_code: data.countryCode,
+    department_code: data.departmentId,
+    municipality_code: data.municipalityId,
+    birthdate: data.birthday
+  };
+}
+function createProfileModule(graphqlUrl, getHeaders) {
+  async function requireAuth() {
+    const headers = await getHeaders();
+    if (!headers.Authorization) {
+      throw new AuthError("You must be logged in to access your profile");
+    }
+    return headers;
+  }
+  return {
+    async get() {
+      const headers = await requireAuth();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PROFILE,
+        {},
+        headers
+      );
+      const client = data.clients?.[0];
+      if (!client) {
+        throw new AuthError("Customer profile not found");
+      }
+      return mapProfile(client);
+    },
+    async getAddresses() {
+      const headers = await requireAuth();
+      const data = await executeGraphQL(
+        graphqlUrl,
+        GET_PROFILE_ADDRESSES,
+        {},
+        headers
+      );
+      const client = data.clients?.[0];
+      if (!client) {
+        throw new AuthError("Customer profile not found");
+      }
+      return mapProfileAddresses(client);
+    },
+    async update(updateData) {
+      const headers = await requireAuth();
+      const profileData = await executeGraphQL(
+        graphqlUrl,
+        GET_PROFILE,
+        {},
+        headers
+      );
+      const client = profileData.clients?.[0];
+      if (!client) {
+        throw new AuthError("Customer profile not found");
+      }
+      const data = await executeGraphQL(
+        graphqlUrl,
+        UPDATE_PROFILE,
+        { partyId: client.party_id, data: mapProfileUpdate(updateData) },
+        headers
+      );
+      return mapProfile({
+        id: client.id,
+        party_id: client.party_id,
+        party: data.update_business_parties_by_pk
+      });
+    }
+  };
+}
+
+// libs/sdk/src/modules/website.ts
+function mapWebsite(raw) {
+  return {
+    websiteId: raw.id,
+    companyId: raw.company_id,
+    chainId: raw.chain_id,
+    name: raw.name,
+    slug: raw.slug,
+    domain: raw.domain,
+    config: raw.config
+  };
+}
+async function resolveWebsite(graphqlUrl, slug, headers) {
+  if (!slug.trim()) {
+    throw new WebsiteError(
+      "websiteSlug is required",
+      "INVALID_CONFIG"
+    );
+  }
+  const data = await executeGraphQL(
+    graphqlUrl,
+    RESOLVE_WEBSITE_BY_SLUG,
+    { slug },
+    headers
+  );
+  if (!data.websites || data.websites.length === 0) {
+    throw new WebsiteError(
+      `No active website found with slug "${slug}"`,
+      "WEBSITE_NOT_FOUND"
+    );
+  }
+  return mapWebsite(data.websites[0]);
+}
+
+// libs/sdk/src/client.ts
+function normalizeApiUrl(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+function createBacanoClient(config) {
+  if (!config.apiUrl)
+    throw new WebsiteError("apiUrl is required", "INVALID_CONFIG");
+  if (!config.websiteSlug?.trim())
+    throw new WebsiteError("websiteSlug is required", "INVALID_CONFIG");
+  const apiUrl = normalizeApiUrl(config.apiUrl);
+  const graphqlUrl = `${apiUrl}/api/v1/website/graphql`;
+  const storageUrl = `${apiUrl}/storage/v1`;
+  let context = null;
+  function getContext() {
+    if (!context) throw new NotInitializedError();
+    return context;
+  }
+  const getHeaders = createRequestHeadersProvider(
+    config.websiteSlug,
+    config.getAccessToken
+  );
+  const getWebsiteHeaders = createRequestHeadersProvider(config.websiteSlug);
+  const catalogModule = createCatalogModule(
+    graphqlUrl,
+    getHeaders,
+    getContext,
+    storageUrl
+  );
+  const availabilityModule = createAvailabilityModule(
+    graphqlUrl,
+    getHeaders,
+    getContext
+  );
+  const cartSessionStorage = createCartSessionStorage(
+    config.tokenStorage ?? "localStorage",
+    () => getContext().slug
+  );
+  const cartModule = createCartModule(
+    graphqlUrl,
+    getHeaders,
+    getContext,
+    cartSessionStorage
+  );
+  const checkoutModule = createCheckoutModule(
+    graphqlUrl,
+    getHeaders,
+    getContext,
+    cartSessionStorage
+  );
+  const ordersModule = createOrdersModule(graphqlUrl, getHeaders, getContext);
+  const profileModule = createProfileModule(graphqlUrl, getHeaders);
+  const contentModule = createContentModule(
+    graphqlUrl,
+    getHeaders,
+    getContext,
+    storageUrl
+  );
+  return {
+    async init() {
+      context = await resolveWebsite(
+        graphqlUrl,
+        config.websiteSlug,
+        getWebsiteHeaders
+      );
+    },
+    getContext,
+    auth: {
+      async getAccessToken() {
+        return config.getAccessToken ? await config.getAccessToken() : null;
+      },
+      async isAuthenticated() {
+        return Boolean(
+          config.getAccessToken ? await config.getAccessToken() : null
+        );
+      }
+    },
+    catalog: {
+      getCatalogPage: catalogModule.getCatalogPage.bind(catalogModule),
+      getProductSeoEntries: catalogModule.getProductSeoEntries.bind(catalogModule),
+      getProductRecommendations: catalogModule.getProductRecommendations.bind(catalogModule),
+      getProducts: catalogModule.getProducts.bind(catalogModule),
+      getProduct: catalogModule.getProduct.bind(catalogModule),
+      getProductBySlug: catalogModule.getProductBySlug.bind(catalogModule),
+      getCategories: catalogModule.getCategories.bind(catalogModule),
+      getCategoryList: catalogModule.getCategoryList.bind(catalogModule),
+      getAttributeList: catalogModule.getAttributeList.bind(catalogModule),
+      getBrands: catalogModule.getBrands.bind(catalogModule),
+      getProductFilters: catalogModule.getProductFilters.bind(catalogModule),
+      getSearchSuggestions: catalogModule.getSearchSuggestions.bind(catalogModule),
+      checkAvailability: availabilityModule.checkAvailability.bind(availabilityModule)
+    },
+    content: {
+      getByKey: contentModule.getByKey.bind(contentModule),
+      getByCategory: contentModule.getByCategory.bind(contentModule),
+      getByTag: contentModule.getByTag.bind(contentModule),
+      getForProduct: contentModule.getForProduct.bind(contentModule)
+    },
+    cart: {
+      getOrCreate: cartModule.getOrCreate.bind(cartModule),
+      startCheckout: cartModule.startCheckout.bind(cartModule),
+      get: cartModule.get.bind(cartModule),
+      setItem: cartModule.setItem.bind(cartModule),
+      addItem: cartModule.addItem.bind(cartModule),
+      updateItem: cartModule.updateItem.bind(cartModule),
+      removeItem: cartModule.removeItem.bind(cartModule)
+    },
+    checkout: {
+      getLocationOptions: checkoutModule.getLocationOptions.bind(checkoutModule),
+      getDeliveryOptions: checkoutModule.getDeliveryOptions.bind(checkoutModule),
+      getShippingQuotes: checkoutModule.getShippingQuotes.bind(checkoutModule),
+      getShippingPolicy: checkoutModule.getShippingPolicy.bind(checkoutModule),
+      getFreeShippingProgress: checkoutModule.getFreeShippingProgress.bind(checkoutModule),
+      getPaymentMethods: checkoutModule.getPaymentMethods.bind(checkoutModule),
+      getPaymentOptions: checkoutModule.getPaymentOptions.bind(checkoutModule),
+      validateCoupon: checkoutModule.validateCoupon.bind(checkoutModule),
+      applyCoupon: checkoutModule.applyCoupon.bind(checkoutModule),
+      removeCoupon: checkoutModule.removeCoupon.bind(checkoutModule),
+      submit: checkoutModule.submit.bind(checkoutModule),
+      createPaymentSession: checkoutModule.createPaymentSession.bind(checkoutModule),
+      reconcilePaymentSession: checkoutModule.reconcilePaymentSession.bind(checkoutModule)
+    },
+    orders: {
+      list: ordersModule.list.bind(ordersModule),
+      get: ordersModule.get.bind(ordersModule),
+      getPublicOrder: ordersModule.getPublicOrder.bind(ordersModule),
+      waitForPayment: ordersModule.waitForPayment.bind(ordersModule)
+    },
+    profile: {
+      get: profileModule.get.bind(profileModule),
+      getAddresses: profileModule.getAddresses.bind(profileModule),
+      update: profileModule.update.bind(profileModule)
+    }
+  };
+}
+export {
+  AuthError,
+  CheckoutError,
+  GraphQLRequestError,
+  NotInitializedError,
+  WebsiteError,
+  buildStorageFileUrl,
+  buildStorageMediaUrls,
+  createBacanoClient,
+  getPrimaryProductImage,
+  getProductImages,
+  getProductMediaByKind,
+  getProductMediaKind,
+  getProductVideos,
+  getWebsitePublicConfig,
+  resolveProductPricing
+};