@vio-live/web-sdk 0.2.0 → 0.4.0

package/dist/chunk-NP2KCM7X.js

@@ -0,0 +1,3859 @@
+import { GraphQLClient } from 'graphql-request';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/core/configuration.ts
+var DEFAULT_URLS = {
+  development: {
+    apiBase: "https://api-dev.vio.live",
+    graphQLBase: "https://graph-ql-dev.vio.live"
+  },
+  // No separate staging GraphQL deployment yet — shares dev's.
+  testing: {
+    apiBase: "https://api-staging.vio.live",
+    graphQLBase: "https://graph-ql-dev.vio.live"
+  },
+  production: {
+    apiBase: "https://api.vio.live",
+    graphQLBase: "https://graph-ql.vio.live"
+  }
+};
+var ConfigurationSingleton = class {
+  constructor() {
+    this.resolved = null;
+    this.readyWaiters = [];
+  }
+  init(input) {
+    if (!input.apiKey || typeof input.apiKey !== "string") {
+      throw new Error("[Vio] apiKey is required in Vio.init({ apiKey })");
+    }
+    const env = input.environment ?? "development";
+    const defaults = DEFAULT_URLS[env];
+    this.resolved = {
+      apiKey: input.apiKey,
+      environment: env,
+      apiBase: input.apiBase ?? defaults.apiBase,
+      graphQLBase: input.graphQLBase ?? defaults.graphQLBase,
+      stripePublishableKey: input.stripePublishableKey,
+      klarnaClientId: input.klarnaClientId,
+      // Sandbox by default — live Klarna must be opted into explicitly.
+      klarnaEnvironment: input.klarnaEnvironment ?? "playground"
+    };
+    if (typeof console !== "undefined") {
+      const masked = input.apiKey.length > 4 ? "*".repeat(Math.max(0, input.apiKey.length - 4)) + input.apiKey.slice(-4) : "****";
+      console.info("[Vio] Initialized", {
+        environment: env,
+        apiBase: this.resolved.apiBase,
+        apiKey: masked,
+        stripeConfigured: !!input.stripePublishableKey,
+        klarnaConfigured: !!input.klarnaClientId,
+        klarnaEnvironment: this.resolved.klarnaEnvironment
+      });
+    }
+    const waiters = this.readyWaiters;
+    this.readyWaiters = [];
+    for (const waiter of waiters) waiter();
+  }
+  get() {
+    if (!this.resolved) {
+      throw new Error(
+        "[Vio] Not initialized. Call Vio.init({ apiKey }) before using the SDK."
+      );
+    }
+    return this.resolved;
+  }
+  get isInitialized() {
+    return this.resolved !== null;
+  }
+  /**
+   * Resolves once `Vio.init()` has run, or after `timeoutMs` — whichever
+   * comes first. Hosts that mount several independent components (e.g. Vev
+   * blocks, which mount in no guaranteed order) may have one fire a GraphQL
+   * call before another has called `Vio.init()`. Awaiting this briefly lets
+   * that race resolve instead of silently sending an unauthenticated
+   * request. Resolves `true` if init happened in time, `false` on timeout —
+   * callers should still degrade gracefully either way.
+   */
+  whenReady(timeoutMs = 2e3) {
+    if (this.resolved) return Promise.resolve(true);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(false), timeoutMs);
+      this.readyWaiters.push(() => {
+        clearTimeout(timer);
+        resolve(true);
+      });
+    });
+  }
+  /** For tests only. */
+  reset() {
+    this.resolved = null;
+    this.readyWaiters = [];
+  }
+};
+var Configuration = /* @__PURE__ */ new ConfigurationSingleton();
+
+// src/core/api/vio.ts
+var VioApi = class {
+  constructor(options) {
+    if (!options.apiBase) throw new Error("[VioApi] apiBase is required");
+    if (!options.apiKey) throw new Error("[VioApi] apiKey is required");
+    this.apiBase = options.apiBase.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+  }
+  /**
+   * Bootstrap — fetches client app config (sponsors with commerce keys,
+   * default market, campaign id). Called once at SDK init.
+   */
+  async bootstrap() {
+    return this.get("/v2/mobile/config");
+  }
+  /**
+   * Get placement components for a campaign. Used by the carousel auto-fetch
+   * mode (`<vio-product-carousel campaign-id="36" location="news-favorites">`).
+   */
+  async getComponents(campaignId) {
+    const path = `/v2/mobile/campaigns/${encodeURIComponent(String(campaignId))}/components`;
+    const res = await this.get(path);
+    return Array.isArray(res) ? res : res?.components ?? [];
+  }
+  // MARK: - HTTP plumbing
+  async get(path) {
+    const url = `${this.apiBase}${path}`;
+    const res = await fetch(url, {
+      method: "GET",
+      headers: {
+        "X-API-Key": this.apiKey,
+        Accept: "application/json"
+      }
+    });
+    if (!res.ok) {
+      throw new VioApiError(res.status, await safeText(res), `GET ${path}`);
+    }
+    return await res.json();
+  }
+};
+var VioApiError = class extends Error {
+  constructor(status, body, endpoint) {
+    super(`[VioApi] ${endpoint} \u2192 HTTP ${status}: ${body.slice(0, 200)}`);
+    this.status = status;
+    this.body = body;
+    this.endpoint = endpoint;
+    this.name = "VioApiError";
+  }
+};
+async function safeText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+function createVioApi(options) {
+  return new VioApi(options);
+}
+
+// src/core/types.ts
+function displayPrice(product) {
+  const p = product.price;
+  const amount = p.amount_incl_taxes ?? p.amount;
+  return formatPrice(amount, p.currency_code);
+}
+function getGlobalCountryCode() {
+  const g = globalThis;
+  if (g.__VIO_COUNTRY__) return g.__VIO_COUNTRY__;
+  if (typeof localStorage !== "undefined") {
+    try {
+      const v = localStorage.getItem("vio.country");
+      if (v) return v;
+    } catch {
+    }
+  }
+  return "NO";
+}
+function getGlobalLocale() {
+  const g = globalThis;
+  if (g.__VIO_LOCALE__) return g.__VIO_LOCALE__;
+  if (typeof localStorage !== "undefined") {
+    try {
+      const v = localStorage.getItem("vio.locale");
+      if (v) return v;
+    } catch {
+    }
+  }
+  return "nb-NO";
+}
+function getGlobalSymbol(currency) {
+  const activeCurrency = currency || getGlobalCurrency();
+  const g = globalThis;
+  if (!currency && g.__VIO_SYMBOL__) return g.__VIO_SYMBOL__;
+  if (!currency && typeof localStorage !== "undefined") {
+    try {
+      const v = localStorage.getItem("vio.symbol");
+      if (v) return v;
+    } catch {
+    }
+  }
+  const curr = String(activeCurrency).toUpperCase();
+  if (curr === "NOK" || curr === "DKK") return "Kr";
+  if (curr === "SEK") return "SEK";
+  if (curr === "EUR") return "\u20AC";
+  if (curr === "USD" || curr === "CAD") return "$";
+  if (curr === "GBP") return "\xA3";
+  if (curr === "CHF") return "CHF";
+  return activeCurrency;
+}
+function getGlobalCurrency() {
+  const g = globalThis;
+  if (g.__VIO_CURRENCY__) return g.__VIO_CURRENCY__;
+  if (typeof localStorage !== "undefined") {
+    try {
+      const v = localStorage.getItem("vio.currency");
+      if (v) return v;
+    } catch {
+    }
+  }
+  return "NOK";
+}
+var validatedLocales = /* @__PURE__ */ new Map();
+function safeLocale(locale) {
+  const cached = validatedLocales.get(locale);
+  if (cached) return cached;
+  let resolved = "nb-NO";
+  try {
+    if (Intl.NumberFormat.supportedLocalesOf([locale]).length > 0) resolved = locale;
+  } catch {
+  }
+  validatedLocales.set(locale, resolved);
+  return resolved;
+}
+function formatPrice(amount, currency) {
+  const activeCurrency = currency || getGlobalCurrency();
+  const activeLocale = safeLocale(getGlobalLocale());
+  const activeSymbol = getGlobalSymbol(activeCurrency);
+  const formatted = amount.toLocaleString(activeLocale, { minimumFractionDigits: 0, maximumFractionDigits: 2 }).replace(/ /g, " ");
+  return `${formatted} ${activeSymbol}`;
+}
+function primaryImageUrl(product) {
+  const p = product;
+  if (!p || typeof p !== "object") return void 0;
+  if (Array.isArray(p.variants) && p.variants.length > 0) {
+    const vImages = p.variants[0]?.images;
+    if (Array.isArray(vImages) && vImages.length > 0) {
+      const vUrl = typeof vImages[0] === "string" ? vImages[0] : vImages[0]?.url;
+      if (vUrl) return vUrl;
+    }
+  }
+  if (Array.isArray(p.images) && p.images.length > 0) {
+    const img0 = p.images[0];
+    const url = typeof img0 === "string" ? img0 : img0?.url;
+    if (url) return url;
+  }
+  if (typeof p.image === "string" && p.image) return p.image;
+  if (p.image && typeof p.image === "object" && p.image.url) return p.image.url;
+  if (typeof p.imageUrl === "string" && p.imageUrl) return p.imageUrl;
+  if (typeof p.image_url === "string" && p.image_url) return p.image_url;
+  if (typeof p.primaryImage === "string" && p.primaryImage) return p.primaryImage;
+  if (p.primaryImage && typeof p.primaryImage === "object" && p.primaryImage.url) {
+    return p.primaryImage.url;
+  }
+  return void 0;
+}
+var GET_PRODUCTS_BY_IDS = (
+  /* GraphQL */
+  `
+  query GetProductsByIds(
+    $currency: String
+    $imageSize: ImageSize
+    $productIds: [Int!]
+    $useCache: Boolean!
+    $shippingCountryCode: String
+  ) {
+    Channel {
+      GetProductsByIds(
+        currency: $currency
+        image_size: $imageSize
+        product_ids: $productIds
+        useCache: $useCache
+        shipping_country_code: $shippingCountryCode
+      ) {
+        id
+        brand
+        title
+        description
+        tags
+        sku
+        quantity
+        price {
+          amount
+          currency_code
+          compare_at
+          amount_incl_taxes
+          compare_at_incl_taxes
+          tax_amount
+          tax_rate
+        }
+        variants {
+          id
+          barcode
+          quantity
+          sku
+          title
+          price {
+            amount
+            currency_code
+            compare_at
+            amount_incl_taxes
+            compare_at_incl_taxes
+            tax_amount
+            tax_rate
+          }
+          images {
+            id
+            url
+            width
+            height
+            order
+          }
+        }
+        barcode
+        options {
+          id
+          name
+          order
+          values
+        }
+        categories {
+          id
+          name
+        }
+        images {
+          id
+          url
+          width
+          height
+          order
+        }
+      }
+    }
+  }
+`
+);
+var ChannelProduct = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Fetch a batch of products by their numeric ids.
+   * Returns an empty array if no ids are provided.
+   */
+  async getByIds(options) {
+    if (!options.product_ids || options.product_ids.length === 0) return [];
+    const variables = {
+      productIds: options.product_ids,
+      // Page-level currency/country defaults (multi-market support).
+      currency: options.currency ?? getGlobalCurrency(),
+      imageSize: options.image_size ?? "large",
+      useCache: options.useCache ?? true,
+      shippingCountryCode: options.shipping_country_code ?? getGlobalCountryCode()
+    };
+    const data = await this.client.request(GET_PRODUCTS_BY_IDS, variables);
+    return data.Channel?.GetProductsByIds ?? [];
+  }
+};
+var Channel = class {
+  constructor(client) {
+    this.product = new ChannelProduct(client);
+  }
+};
+var CommerceClient = class {
+  constructor(options) {
+    if (!options.endpoint) throw new Error("[VioCommerce] endpoint is required");
+    if (!options.apiKey) throw new Error("[VioCommerce] apiKey is required");
+    this.raw = new GraphQLClient(options.endpoint, {
+      headers: { Authorization: options.apiKey }
+    });
+    this.channel = new Channel(this.raw);
+  }
+};
+function createCommerceClient(options) {
+  return new CommerceClient(options);
+}
+
+// src/core/api/cart-queries.ts
+var CREATE_CART_MUTATION = `
+mutation CreateCart($customerSessionId: String!, $currency: String!, $shippingCountry: String) {
+  Cart {
+    CreateCart(customer_session_id: $customerSessionId, currency: $currency, shipping_country: $shippingCountry) {
+      cart_id
+      customer_session_id
+      shipping_country
+      line_items {
+        id
+        supplier
+        image {
+          id
+          url
+          width
+          height
+        }
+        sku
+        barcode
+        brand
+        product_id
+        title
+        variant_id
+        variant_title
+        variant {
+          option
+          value
+        }
+        quantity
+        price {
+          amount
+          currency_code
+          discount
+          compare_at
+          compare_at_incl_taxes
+          amount_incl_taxes
+          tax_amount
+          tax_rate
+        }
+        shipping {
+          id
+          name
+          description
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+        available_shippings {
+          id
+          name
+          description
+          country_code
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+      }
+      subtotal
+      shipping
+      currency
+      available_shipping_countries
+    }
+  }
+}
+`;
+var ADD_ITEM_MUTATION = `
+mutation AddItem($cartId: String!, $lineItems: [LineItemInput!]!) {
+  Cart {
+    AddItem(cart_id: $cartId, line_items: $lineItems) {
+      cart_id
+      customer_session_id
+      shipping_country
+      line_items {
+        id
+        supplier
+        image {
+          id
+          url
+          width
+          height
+        }
+        sku
+        barcode
+        brand
+        product_id
+        title
+        variant_id
+        variant_title
+        variant {
+          option
+          value
+        }
+        quantity
+        price {
+          amount
+          currency_code
+          discount
+          compare_at
+          compare_at_incl_taxes
+          amount_incl_taxes
+          tax_amount
+          tax_rate
+        }
+        shipping {
+          id
+          name
+          description
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+        available_shippings {
+          id
+          name
+          description
+          country_code
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+      }
+      subtotal
+      shipping
+      currency
+      available_shipping_countries
+    }
+  }
+}
+`;
+var DELETE_ITEM_MUTATION = `
+mutation DeleteItem($cartId: String!, $cartItemId: String!) {
+  Cart {
+    DeleteItem(cart_id: $cartId, cart_item_id: $cartItemId) {
+      cart_id
+      customer_session_id
+      shipping_country
+      line_items {
+        id
+        supplier
+        image {
+          id
+          url
+          width
+          height
+        }
+        sku
+        barcode
+        brand
+        product_id
+        title
+        variant_id
+        variant_title
+        variant {
+          option
+          value
+        }
+        quantity
+        price {
+          amount
+          currency_code
+          discount
+          compare_at
+          compare_at_incl_taxes
+          amount_incl_taxes
+          tax_amount
+          tax_rate
+        }
+        shipping {
+          id
+          name
+          description
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+        available_shippings {
+          id
+          name
+          description
+          country_code
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+      }
+      subtotal
+      shipping
+      currency
+      available_shipping_countries
+    }
+  }
+}
+`;
+var UPDATE_ITEM_MUTATION = `
+mutation UpdateItem($cartId: String!, $cartItemId: String!, $shippingId: String, $qty: Int) {
+  Cart {
+    UpdateItem(cart_id: $cartId, cart_item_id: $cartItemId, shipping_id: $shippingId, qty: $qty) {
+      cart_id
+      customer_session_id
+      shipping_country
+      line_items {
+        id
+        supplier
+        image {
+          id
+          url
+          width
+          height
+        }
+        sku
+        barcode
+        brand
+        product_id
+        title
+        variant_id
+        variant_title
+        variant {
+          option
+          value
+        }
+        quantity
+        price {
+          amount
+          currency_code
+          discount
+          compare_at
+          compare_at_incl_taxes
+          amount_incl_taxes
+          tax_amount
+          tax_rate
+        }
+        shipping {
+          id
+          name
+          description
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+        available_shippings {
+          id
+          name
+          description
+          country_code
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+      }
+      subtotal
+      shipping
+      currency
+      available_shipping_countries
+    }
+  }
+}
+`;
+var GET_CART_QUERY = `
+query GetCart($cartId: String!) {
+  Cart {
+    GetCart(cart_id: $cartId) {
+      cart_id
+      customer_session_id
+      shipping_country
+      line_items {
+        id
+        supplier
+        image {
+          id
+          url
+          width
+          height
+        }
+        sku
+        barcode
+        brand
+        product_id
+        title
+        variant_id
+        variant_title
+        variant {
+          option
+          value
+        }
+        quantity
+        price {
+          amount
+          currency_code
+          discount
+          compare_at
+          compare_at_incl_taxes
+          amount_incl_taxes
+          tax_amount
+          tax_rate
+        }
+        shipping {
+          id
+          name
+          description
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+        available_shippings {
+          id
+          name
+          description
+          country_code
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+      }
+      subtotal
+      shipping
+      currency
+      available_shipping_countries
+    }
+  }
+}
+`;
+var GET_LINE_ITEMS_BY_SUPPLIER_QUERY = `
+query GetLineItemsBySupplier($cartId: String!) {
+  Cart {
+    GetLineItemsBySupplier(cart_id: $cartId) {
+      supplier {
+        id
+        name
+      }
+      available_shippings {
+        id
+        name
+        description
+        country_code
+        price {
+          amount
+          currency_code
+          amount_incl_taxes
+          tax_amount
+          tax_rate
+        }
+      }
+      line_items {
+        id
+        supplier
+        image {
+          id
+          url
+          width
+          height
+        }
+        sku
+        barcode
+        brand
+        product_id
+        title
+        variant_id
+        variant_title
+        variant {
+          option
+          value
+        }
+        quantity
+        price {
+          amount
+          currency_code
+          discount
+          compare_at
+          compare_at_incl_taxes
+          amount_incl_taxes
+          tax_amount
+          tax_rate
+        }
+        shipping {
+          id
+          name
+          description
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+      }
+    }
+  }
+}
+`;
+var UPDATE_SHIPPINGS_BY_SUPPLIER_MUTATION = `
+mutation UpdateShippingsBySupplier($cartId: String!, $data: [DataUpdateShippingsBySupplier!]!) {
+  Cart {
+    UpdateShippingsBySupplier(cart_id: $cartId, data: $data) {
+      cart_id
+      customer_session_id
+      shipping_country
+      line_items {
+        id
+        supplier
+        image {
+          id
+          url
+          width
+          height
+        }
+        sku
+        barcode
+        brand
+        product_id
+        title
+        variant_id
+        variant_title
+        variant {
+          option
+          value
+        }
+        quantity
+        price {
+          amount
+          currency_code
+          discount
+          compare_at
+          compare_at_incl_taxes
+          amount_incl_taxes
+          tax_amount
+          tax_rate
+        }
+        shipping {
+          id
+          name
+          description
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+        available_shippings {
+          id
+          name
+          description
+          country_code
+          price {
+            amount
+            currency_code
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+        }
+      }
+      subtotal
+      shipping
+      currency
+      available_shipping_countries
+    }
+  }
+}
+`;
+var CREATE_CHECKOUT_MUTATION = `
+mutation CreateCheckout($cartId: String!) {
+  Checkout {
+    CreateCheckout(cart_id: $cartId) {
+      buyer_accepts_purchase_conditions
+      buyer_accepts_terms_conditions
+      created_at
+      updated_at
+      id
+      deleted_at
+      success_url
+      cancel_url
+      payment_method
+      email
+      status
+      checkout_url
+      origin_payment_id
+      billing_address {
+        id
+        first_name
+        last_name
+        phone_code
+        phone
+        company
+        address1
+        address2
+        city
+        province
+        province_code
+        country
+        country_code
+        zip
+      }
+      shipping_address {
+        id
+        first_name
+        last_name
+        phone_code
+        phone
+        company
+        address1
+        address2
+        city
+        province
+        province_code
+        country
+        country_code
+        zip
+      }
+      available_payment_methods {
+        name
+      }
+      discount_code
+      cart {
+        cart_id
+        customer_session_id
+        shipping_country
+        line_items {
+          id
+          supplier
+          image {
+            id
+            url
+            width
+            height
+          }
+          sku
+          barcode
+          brand
+          product_id
+          title
+          variant_id
+          variant_title
+          variant {
+            option
+            value
+          }
+          quantity
+          price {
+            amount
+            currency_code
+            discount
+            compare_at
+            compare_at_incl_taxes
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+          shipping {
+            id
+            name
+            description
+            price {
+              amount
+              currency_code
+              amount_incl_taxes
+              tax_amount
+              tax_rate
+            }
+          }
+          available_shippings {
+            id
+            name
+            description
+            country_code
+            price {
+              amount
+              currency_code
+              amount_incl_taxes
+              tax_amount
+              tax_rate
+            }
+          }
+        }
+        subtotal
+        shipping
+        currency
+        available_shipping_countries
+      }
+      totals {
+        currency_code
+        subtotal
+        shipping
+        total
+        taxes
+        tax_rate
+        discounts
+      }
+    }
+  }
+}
+`;
+var UPDATE_CHECKOUT_MUTATION = `
+mutation UpdateCheckout($checkoutId: String!, $status: String, $successUrl: String, $email: String, $cancelUrl: String, $paymentMethod: String, $shippingAddress: AddressArgs, $billingAddress: AddressArgs, $buyerAcceptsPurchaseConditions: Boolean, $buyerAcceptsTermsConditions: Boolean) {
+  Checkout {
+    UpdateCheckout(checkout_id: $checkoutId, status: $status, success_url: $successUrl, email: $email, cancel_url: $cancelUrl, payment_method: $paymentMethod, shipping_address: $shippingAddress, billing_address: $billingAddress, buyer_accepts_purchase_conditions: $buyerAcceptsPurchaseConditions, buyer_accepts_terms_conditions: $buyerAcceptsTermsConditions) {
+      buyer_accepts_purchase_conditions
+      buyer_accepts_terms_conditions
+      created_at
+      updated_at
+      id
+      deleted_at
+      success_url
+      cancel_url
+      payment_method
+      email
+      status
+      checkout_url
+      origin_payment_id
+      billing_address {
+        id
+        first_name
+        last_name
+        phone_code
+        phone
+        company
+        address1
+        address2
+        city
+        province
+        province_code
+        country
+        country_code
+        zip
+      }
+      shipping_address {
+        id
+        first_name
+        last_name
+        phone_code
+        phone
+        company
+        address1
+        address2
+        city
+        province
+        province_code
+        country
+        country_code
+        zip
+      }
+      available_payment_methods {
+        name
+      }
+      discount_code
+      cart {
+        cart_id
+        customer_session_id
+        shipping_country
+        line_items {
+          id
+          supplier
+          image {
+            id
+            url
+            width
+            height
+          }
+          sku
+          barcode
+          brand
+          product_id
+          title
+          variant_id
+          variant_title
+          variant {
+            option
+            value
+          }
+          quantity
+          price {
+            amount
+            currency_code
+            discount
+            compare_at
+            compare_at_incl_taxes
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+          shipping {
+            id
+            name
+            description
+            price {
+              amount
+              currency_code
+              amount_incl_taxes
+              tax_amount
+              tax_rate
+            }
+          }
+          available_shippings {
+            id
+            name
+            description
+            country_code
+            price {
+              amount
+              currency_code
+              amount_incl_taxes
+              tax_amount
+              tax_rate
+            }
+          }
+        }
+        subtotal
+        shipping
+        currency
+        available_shipping_countries
+      }
+      totals {
+        currency_code
+        subtotal
+        shipping
+        total
+        taxes
+        tax_rate
+        discounts
+      }
+    }
+  }
+}
+`;
+var GET_CHECKOUT_QUERY = `
+query GetCheckout($checkoutId: String!) {
+  Checkout {
+    GetCheckout(checkout_id: $checkoutId) {
+      buyer_accepts_purchase_conditions
+      buyer_accepts_terms_conditions
+      created_at
+      updated_at
+      id
+      deleted_at
+      success_url
+      cancel_url
+      payment_method
+      email
+      status
+      checkout_url
+      origin_payment_id
+      billing_address {
+        id
+        first_name
+        last_name
+        phone_code
+        phone
+        company
+        address1
+        address2
+        city
+        province
+        province_code
+        country
+        country_code
+        zip
+      }
+      shipping_address {
+        id
+        first_name
+        last_name
+        phone_code
+        phone
+        company
+        address1
+        address2
+        city
+        province
+        province_code
+        country
+        country_code
+        zip
+      }
+      available_payment_methods {
+        name
+      }
+      discount_code
+      cart {
+        cart_id
+        customer_session_id
+        shipping_country
+        line_items {
+          id
+          supplier
+          image {
+            id
+            url
+            width
+            height
+          }
+          sku
+          barcode
+          brand
+          product_id
+          title
+          variant_id
+          variant_title
+          variant {
+            option
+            value
+          }
+          quantity
+          price {
+            amount
+            currency_code
+            discount
+            compare_at
+            compare_at_incl_taxes
+            amount_incl_taxes
+            tax_amount
+            tax_rate
+          }
+          shipping {
+            id
+            name
+            description
+            price {
+              amount
+              currency_code
+              amount_incl_taxes
+              tax_amount
+              tax_rate
+            }
+          }
+          available_shippings {
+            id
+            name
+            description
+            country_code
+            price {
+              amount
+              currency_code
+              amount_incl_taxes
+              tax_amount
+              tax_rate
+            }
+          }
+        }
+        subtotal
+        shipping
+        currency
+        available_shipping_countries
+      }
+      totals {
+        currency_code
+        subtotal
+        shipping
+        total
+        taxes
+        tax_rate
+        discounts
+      }
+    }
+  }
+}
+`;
+var GET_AVAILABLE_PAYMENT_METHODS_QUERY = `
+query Config {
+  Payment {
+    GetAvailablePaymentMethods {
+      config {
+        name
+        type
+        value
+      }
+      name
+    }
+  }
+}
+`;
+async function getCartGraphQLOptions(sponsorId) {
+  const facade = globalThis.__VIO_FACADE__;
+  if (facade && typeof facade.bootstrap === "function" && !facade.bootstrapCache) {
+    try {
+      await facade.bootstrap();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[Vio] getCartGraphQLOptions bootstrap await failed:", err);
+      }
+    }
+  }
+  if (!Configuration.isInitialized) {
+    await Configuration.whenReady();
+  }
+  const cfg = Configuration.isInitialized ? Configuration.get() : { apiKey: void 0, graphQLBase: "https://graph-ql-dev.vio.live" };
+  const anyCfg = cfg;
+  let commerceKey = anyCfg.apiKey;
+  let sponsorResolved = false;
+  if (sponsorId && typeof facade?.findSponsor === "function") {
+    const sponsor = facade.findSponsor(sponsorId);
+    if (sponsor?.commerce?.apiKey) {
+      commerceKey = sponsor.commerce.apiKey;
+      sponsorResolved = true;
+    }
+  }
+  return {
+    endpoint: anyCfg.graphQLBase || "https://graph-ql-dev.vio.live",
+    apiKey: anyCfg.apiKey,
+    commerceKey,
+    sponsorResolved
+  };
+}
+var CUSTOMER_SESSION_KEY = "vio.customer_session_id.v1";
+function getCustomerSessionId() {
+  if (typeof localStorage === "undefined") return "cs_session_default";
+  let id = localStorage.getItem(CUSTOMER_SESSION_KEY);
+  if (!id) {
+    id = "cs_" + Math.random().toString(36).slice(2, 11) + Date.now().toString(36);
+    localStorage.setItem(CUSTOMER_SESSION_KEY, id);
+  }
+  return id;
+}
+async function executeCartGraphQL(query, variables, options = {}) {
+  const resolvedOptions = typeof options === "number" ? await getCartGraphQLOptions(options) : !options.apiKey && !options.commerceKey ? { ...await getCartGraphQLOptions(), ...options } : options;
+  const { endpoint = "https://graph-ql-dev.vio.live", apiKey, commerceKey } = resolvedOptions;
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["X-API-Key"] = apiKey;
+  if (commerceKey || apiKey) headers["Authorization"] = commerceKey || apiKey;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ query, variables })
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok || json.errors) {
+    const errMsg = json.errors?.[0]?.message || `GraphQL request failed (HTTP ${res.status})`;
+    throw new Error(errMsg);
+  }
+  return json;
+}
+async function createCart(customerSessionId, currency, shippingCountry, options) {
+  const json = await executeCartGraphQL(
+    CREATE_CART_MUTATION,
+    {
+      customerSessionId,
+      currency: currency || getGlobalCurrency(),
+      shippingCountry: shippingCountry || getGlobalCountryCode()
+    },
+    options
+  );
+  return json?.data?.Cart?.CreateCart;
+}
+async function addItem(cartId, lineItems, options) {
+  const json = await executeCartGraphQL(ADD_ITEM_MUTATION, { cartId, lineItems }, options);
+  return json?.data?.Cart?.AddItem;
+}
+async function deleteItem(cartId, cartItemId, options) {
+  const json = await executeCartGraphQL(DELETE_ITEM_MUTATION, { cartId, cartItemId }, options);
+  return json?.data?.Cart?.DeleteItem;
+}
+async function updateItem(cartId, cartItemId, shippingId, qty, options) {
+  const json = await executeCartGraphQL(
+    UPDATE_ITEM_MUTATION,
+    { cartId, cartItemId, shippingId: shippingId || null, qty: qty != null ? qty : null },
+    options
+  );
+  return json?.data?.Cart?.UpdateItem;
+}
+async function getCart(cartId, options) {
+  const json = await executeCartGraphQL(GET_CART_QUERY, { cartId }, options);
+  return json?.data?.Cart?.GetCart;
+}
+async function getLineItemsBySupplier(cartId, options) {
+  const json = await executeCartGraphQL(GET_LINE_ITEMS_BY_SUPPLIER_QUERY, { cartId }, options);
+  return json?.data?.Cart?.GetLineItemsBySupplier;
+}
+async function updateShippingsBySupplier(cartId, data, options) {
+  const json = await executeCartGraphQL(
+    UPDATE_SHIPPINGS_BY_SUPPLIER_MUTATION,
+    { cartId, data },
+    options
+  );
+  return json?.data?.Cart?.UpdateShippingsBySupplier;
+}
+async function createCheckout(cartId, options) {
+  const json = await executeCartGraphQL(CREATE_CHECKOUT_MUTATION, { cartId }, options);
+  return json?.data?.Checkout?.CreateCheckout;
+}
+async function updateCheckout(variables, options) {
+  const json = await executeCartGraphQL(UPDATE_CHECKOUT_MUTATION, variables, options);
+  return json?.data?.Checkout?.UpdateCheckout;
+}
+async function getCheckout(checkoutId, options) {
+  const json = await executeCartGraphQL(GET_CHECKOUT_QUERY, { checkoutId }, options);
+  return json?.data?.Checkout?.GetCheckout;
+}
+async function getAvailablePaymentMethods(options) {
+  const json = await executeCartGraphQL(GET_AVAILABLE_PAYMENT_METHODS_QUERY, {}, options);
+  return json?.data?.Payment?.GetAvailablePaymentMethods;
+}
+var CREATE_PAYMENT_STRIPE_MUTATION = `
+mutation CreatePaymentStripe($checkoutId: String!, $successUrl: String!, $paymentMethod: String!, $email: String!) {
+  Payment {
+    CreatePaymentStripe(checkout_id: $checkoutId, success_url: $successUrl, payment_method: $paymentMethod, email: $email) {
+      order_id
+      checkout_url
+    }
+  }
+}
+`;
+async function createPaymentStripe(variables, options) {
+  const json = await executeCartGraphQL(CREATE_PAYMENT_STRIPE_MUTATION, variables, options);
+  return json?.data?.Payment?.CreatePaymentStripe;
+}
+var CREATE_PAYMENT_APPLE_PAY_MUTATION = `
+mutation CreatePaymentApplePay($checkoutId: String!) {
+  Payment {
+    CreatePaymentApplePay(checkout_id: $checkoutId) {
+      gateway
+      gateway_merchant_id
+    }
+  }
+}
+`;
+async function createPaymentApplePay(variables, options) {
+  const json = await executeCartGraphQL(CREATE_PAYMENT_APPLE_PAY_MUTATION, variables, options);
+  return json?.data?.Payment?.CreatePaymentApplePay;
+}
+var CONFIRM_PAYMENT_APPLE_PAY_MUTATION = `
+mutation ConfirmPaymentApplePay($checkoutId: String!, $applePayToken: String!, $email: String, $shippingAddress: ApplePayAddressInput) {
+  Payment {
+    ConfirmPaymentApplePay(checkout_id: $checkoutId, apple_pay_token: $applePayToken, email: $email, shipping_address: $shippingAddress) {
+      order_id
+      status
+    }
+  }
+}
+`;
+async function confirmPaymentApplePay(variables, options) {
+  const json = await executeCartGraphQL(CONFIRM_PAYMENT_APPLE_PAY_MUTATION, variables, options);
+  return json?.data?.Payment?.ConfirmPaymentApplePay;
+}
+
+// src/core/checkout/payments/vipps.ts
+var CREATE_PAYMENT_VIPPS_MUTATION = `
+mutation CreatePaymentVipps($checkoutId: String!, $email: String!, $returnUrl: String!) {
+  Payment {
+    CreatePaymentVipps(checkout_id: $checkoutId, email: $email, return_url: $returnUrl) {
+      payment_url
+    }
+  }
+}
+`;
+var GET_VIPPS_STATUS_QUERY = `
+query GetVippsStatus($checkoutId: String!) {
+  Payment {
+    GetVippsStatus(checkout_id: $checkoutId) {
+      state
+    }
+  }
+}
+`;
+async function createPaymentVipps(variables, options) {
+  const json = await executeCartGraphQL(CREATE_PAYMENT_VIPPS_MUTATION, variables, options);
+  return json?.data?.Payment?.CreatePaymentVipps ?? null;
+}
+async function getVippsStatus(variables, options) {
+  const json = await executeCartGraphQL(GET_VIPPS_STATUS_QUERY, variables, options);
+  return json?.data?.Payment?.GetVippsStatus ?? null;
+}
+
+// src/core/cart/cart-manager.ts
+var STORAGE_KEY = "vio.cart.v1";
+function lineId() {
+  return "li_" + Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+}
+function normId(val) {
+  if (val === null || val === void 0 || val === 0 || val === "0" || val === "null" || val === "undefined") {
+    return "";
+  }
+  return String(val).trim();
+}
+var CartManager = class extends EventTarget {
+  constructor() {
+    super();
+    /** In-flight CreateCart per sponsor — two quick adds must share ONE backend
+     * cart (two CreateCarts split the items and one silently disappears). */
+    this.cartIdPromises = /* @__PURE__ */ new Map();
+    /** Monotonic mutation counter per sponsor + last applied response, so a
+     * slow response can't overwrite the state of a newer one. */
+    this.mutationSeq = /* @__PURE__ */ new Map();
+    this.appliedSeq = /* @__PURE__ */ new Map();
+    /** Quantity intents for lines whose backend id hasn't arrived yet — replayed
+     * when the AddItem response reconciles (keyed by product::variant). */
+    this.pendingQtyIntents = /* @__PURE__ */ new Map();
+    this.cartsBySponsor = this.loadFromStorage();
+  }
+  nextSeq(sponsorId) {
+    const n = (this.mutationSeq.get(sponsorId) ?? 0) + 1;
+    this.mutationSeq.set(sponsorId, n);
+    return n;
+  }
+  /** Apply a backend response only if no newer response was applied already. */
+  applyBackendCart(sponsorId, backendCart, seq) {
+    if (seq < (this.appliedSeq.get(sponsorId) ?? 0)) return;
+    this.appliedSeq.set(sponsorId, seq);
+    this.updateFromBackendCart(sponsorId, backendCart);
+  }
+  /** Surface a cart sync problem to hosts/UI (and the console). */
+  emitError(message, err) {
+    if (typeof console !== "undefined") console.warn("[CartManager]", message, err ?? "");
+    this.dispatchEvent(new CustomEvent("error", { detail: { message } }));
+    if (typeof document !== "undefined") {
+      document.dispatchEvent(
+        new CustomEvent("vio:cart-error", { bubbles: true, detail: { message } })
+      );
+    }
+  }
+  // MARK: - Backend cart sync (Vio Commerce GraphQL)
+  /** Ensure the sponsor cart exists server-side; returns its backend cart id. */
+  async ensureCartId(sponsorId, currency, shippingCountry) {
+    const activeCurrency = currency || getGlobalCurrency();
+    const activeCountry = shippingCountry || getGlobalCountryCode();
+    let cart = this.cartsBySponsor.get(sponsorId);
+    if (!cart) {
+      cart = { sponsorId, items: [], currency: activeCurrency, shippingCountry: activeCountry };
+      this.cartsBySponsor.set(sponsorId, cart);
+    } else {
+      cart.shippingCountry = activeCountry;
+    }
+    if (cart.cartId) return cart.cartId;
+    const inFlight = this.cartIdPromises.get(sponsorId);
+    if (inFlight) return inFlight;
+    const creation = (async () => {
+      const opts = await getCartGraphQLOptions(sponsorId);
+      if (!opts.sponsorResolved) {
+        this.emitError(`no commerce key resolved for sponsor ${sponsorId} \u2014 cart not synced`);
+        return void 0;
+      }
+      const customerSessionId = getCustomerSessionId();
+      try {
+        const backendCart = await createCart(
+          customerSessionId,
+          activeCurrency,
+          activeCountry,
+          opts
+        );
+        if (backendCart?.cart_id) {
+          cart.cartId = backendCart.cart_id;
+          if (Array.isArray(backendCart.line_items) && backendCart.line_items.length > 0) {
+            this.updateFromBackendCart(sponsorId, backendCart);
+          } else {
+            if (backendCart.currency) cart.currency = backendCart.currency;
+            if (backendCart.shipping_country) cart.shippingCountry = backendCart.shipping_country;
+            if (backendCart.subtotal != null) cart.subtotal = backendCart.subtotal;
+            if (backendCart.shipping != null) cart.shipping = backendCart.shipping;
+            if (backendCart.available_shipping_countries) {
+              cart.availableShippingCountries = backendCart.available_shipping_countries;
+            }
+            this.persist();
+            this.emit();
+          }
+        }
+      } catch (err) {
+        this.emitError("createCart failed", err);
+      }
+      return cart.cartId;
+    })().finally(() => {
+      this.cartIdPromises.delete(sponsorId);
+    });
+    this.cartIdPromises.set(sponsorId, creation);
+    return creation;
+  }
+  /** Overwrite local cart state with the backend cart response (source of truth). */
+  updateFromBackendCart(sponsorId, backendCart) {
+    const cart = this.cartsBySponsor.get(sponsorId);
+    if (!cart) return;
+    if (backendCart.cart_id) cart.cartId = backendCart.cart_id;
+    if (backendCart.currency) cart.currency = backendCart.currency;
+    if (backendCart.shipping_country) cart.shippingCountry = backendCart.shipping_country;
+    if (backendCart.subtotal != null) cart.subtotal = backendCart.subtotal;
+    if (backendCart.shipping != null) cart.shipping = backendCart.shipping;
+    if (backendCart.available_shipping_countries) {
+      cart.availableShippingCountries = backendCart.available_shipping_countries;
+    }
+    if (Array.isArray(backendCart.line_items)) {
+      const existingItems = cart.items || [];
+      if (backendCart.line_items.length === 0 && existingItems.length > 0) {
+        this.persist();
+        this.emit();
+        return;
+      }
+      cart.items = backendCart.line_items.map((li) => {
+        const urlFromBackend = (typeof li.image === "string" ? li.image : li.image?.url) || li.imageUrl || li.image_url || "";
+        const matchedLocal = existingItems.find((existing) => {
+          const p1 = normId(existing.productId);
+          const p2 = normId(li.product_id);
+          const v1 = normId(existing.variantId);
+          const v2 = normId(li.variant_id);
+          if (p1 && p2 && p1 === p2 && v1 === v2) return true;
+          if (v1 && v2 && v1 === v2) return true;
+          if (p1 && p2 && p1 === p2 && !v1 && !v2) return true;
+          const n1 = (existing.name || "").trim().toLowerCase();
+          const n2 = (li.title || "").trim().toLowerCase();
+          if (n1 && n2 && n1 === n2 && v1 === v2) return true;
+          return false;
+        });
+        const imageUrl = urlFromBackend || matchedLocal?.imageUrl || "";
+        return {
+          id: li.id,
+          cartItemId: li.id,
+          productId: li.product_id,
+          sponsorId,
+          variantId: li.variant_id != null ? Number(li.variant_id) : void 0,
+          brand: li.brand || matchedLocal?.brand || "",
+          name: li.title ? li.variant_title ? `${li.title} \u2014 ${li.variant_title}` : li.title : matchedLocal?.name || "",
+          unitPrice: li.price?.amount_incl_taxes ?? li.price?.amount ?? matchedLocal?.unitPrice ?? 0,
+          currency: li.price?.currency_code || backendCart.currency || matchedLocal?.currency || "NOK",
+          imageUrl,
+          quantity: li.quantity,
+          shipping: li.shipping,
+          availableShippings: li.available_shippings
+        };
+      });
+    }
+    this.persist();
+    this.emit();
+    if (this.pendingQtyIntents.size > 0) {
+      const currentCart = this.cartsBySponsor.get(sponsorId);
+      for (const [key, qty] of [...this.pendingQtyIntents]) {
+        const line = currentCart?.items.find(
+          (i) => this.intentKey(i.productId, i.variantId) === key && i.cartItemId
+        );
+        if (line) {
+          this.pendingQtyIntents.delete(key);
+          if (line.quantity !== qty) {
+            this.updateQuantity(line.cartItemId, sponsorId, qty);
+          }
+        }
+      }
+    }
+  }
+  // MARK: - Mutations
+  /** Add a Product DTO to a sponsor's cart. Bumps quantity if already present.
+   * When a variantId is given, the line uses the VARIANT's price / image / title
+   * (not the product base), so different combinations are priced correctly. */
+  addProduct(opts) {
+    const variant = opts.variantId != null ? opts.product.variants?.find((v) => v.id === opts.variantId) : void 0;
+    const price = variant?.price ?? opts.product.price;
+    const unitPrice = price.amount_incl_taxes ?? price.amount ?? 0;
+    const imageUrl = variant?.images?.[0]?.url || primaryImageUrl(opts.product) || "";
+    const name = variant?.title ? `${opts.product.title} \u2014 ${variant.title}` : opts.product.title;
+    return this.addManual({
+      productId: opts.product.id,
+      sponsorId: opts.sponsorId,
+      sponsorName: opts.sponsorName,
+      brand: opts.product.brand ?? "",
+      name,
+      unitPrice,
+      currency: price.currency_code,
+      imageUrl,
+      quantity: opts.quantity,
+      variantId: opts.variantId
+    });
+  }
+  /** Add a manually-specified line item (no Product DTO). */
+  addManual(opts) {
+    const qty = Math.max(1, opts.quantity ?? 1);
+    let cart = this.cartsBySponsor.get(opts.sponsorId);
+    if (!cart) {
+      cart = {
+        sponsorId: opts.sponsorId,
+        sponsorName: opts.sponsorName,
+        items: [],
+        currency: opts.currency
+      };
+      this.cartsBySponsor.set(opts.sponsorId, cart);
+    } else if (opts.sponsorName && !cart.sponsorName) {
+      cart.sponsorName = opts.sponsorName;
+    }
+    const existing = cart.items.find((i) => {
+      const p1 = normId(i.productId);
+      const p2 = normId(opts.productId);
+      const v1 = normId(i.variantId);
+      const v2 = normId(opts.variantId);
+      if (p1 && p2 && p1 === p2 && v1 === v2) return true;
+      if (v1 && v2 && v1 === v2) return true;
+      if (p1 && p2 && p1 === p2 && !v1 && !v2) return true;
+      const n1 = (i.name || "").trim().toLowerCase();
+      const n2 = (opts.name || "").trim().toLowerCase();
+      if (n1 && n2 && n1 === n2 && v1 === v2) return true;
+      return false;
+    });
+    if (existing) {
+      existing.quantity += qty;
+    } else {
+      const item = {
+        id: lineId(),
+        productId: opts.productId,
+        sponsorId: opts.sponsorId,
+        variantId: opts.variantId,
+        brand: opts.brand,
+        name: opts.name,
+        unitPrice: opts.unitPrice,
+        currency: opts.currency,
+        imageUrl: opts.imageUrl,
+        quantity: qty
+      };
+      cart.items.push(item);
+    }
+    this.persist();
+    this.emit();
+    const addedItem = existing ?? cart.items[cart.items.length - 1];
+    const addedLineId = addedItem.id;
+    const seq = this.nextSeq(opts.sponsorId);
+    void (async () => {
+      try {
+        const cartId = await this.ensureCartId(opts.sponsorId, opts.currency || void 0);
+        if (cartId) {
+          const gqlOpts = await getCartGraphQLOptions(opts.sponsorId);
+          const lineItemsInput = [
+            {
+              product_id: Number(opts.productId || 0),
+              quantity: qty,
+              variant_id: opts.variantId != null ? Number(opts.variantId) : null
+            }
+          ];
+          const resCart = await addItem(cartId, lineItemsInput, gqlOpts);
+          if (resCart && Array.isArray(resCart.line_items)) {
+            this.applyBackendCart(opts.sponsorId, resCart, seq);
+          }
+        }
+      } catch (err) {
+        const c = this.cartsBySponsor.get(opts.sponsorId);
+        const line = c?.items.find((i) => i.id === addedLineId);
+        if (c && line) {
+          line.quantity -= qty;
+          if (line.quantity <= 0) c.items = c.items.filter((i) => i !== line);
+          if (c.items.length === 0) this.cartsBySponsor.delete(opts.sponsorId);
+          this.persist();
+          this.emit();
+        }
+        this.emitError("AddItem rejected by the backend \u2014 item removed from the cart", err);
+      }
+    })();
+    return addedItem;
+  }
+  intentKey(productId, variantId) {
+    return `${normId(productId)}::${normId(variantId)}`;
+  }
+  updateQuantity(lineItemId, sponsorId, quantity) {
+    const cart = this.cartsBySponsor.get(sponsorId);
+    if (!cart) return;
+    const item = cart.items.find((i) => i.id === lineItemId || i.cartItemId === lineItemId);
+    if (!item) return;
+    const targetItemId = item.cartItemId;
+    if (quantity <= 0) {
+      cart.items = cart.items.filter((i) => i !== item);
+    } else {
+      item.quantity = quantity;
+    }
+    if (cart.items.length === 0) this.cartsBySponsor.delete(sponsorId);
+    this.persist();
+    this.emit();
+    if (!cart.cartId) return;
+    if (!targetItemId) {
+      this.pendingQtyIntents.set(this.intentKey(item.productId, item.variantId), quantity);
+      return;
+    }
+    const backendCartId = cart.cartId;
+    const seq = this.nextSeq(sponsorId);
+    void (async () => {
+      try {
+        const gqlOpts = await getCartGraphQLOptions(sponsorId);
+        const resCart = quantity <= 0 ? await deleteItem(backendCartId, targetItemId, gqlOpts) : await updateItem(backendCartId, targetItemId, null, quantity, gqlOpts);
+        if (resCart && Array.isArray(resCart.line_items)) {
+          this.applyBackendCart(sponsorId, resCart, seq);
+        }
+      } catch (err) {
+        this.emitError("Update/DeleteItem failed \u2014 cart re-synced from backend", err);
+        void this.fetchCartFromBackend(sponsorId);
+      }
+    })();
+  }
+  removeItem(lineItemId, sponsorId) {
+    this.updateQuantity(lineItemId, sponsorId, 0);
+  }
+  clearSponsorCart(sponsorId) {
+    if (this.cartsBySponsor.delete(sponsorId)) {
+      this.persist();
+      this.emit();
+    }
+  }
+  clearAllCarts() {
+    if (this.cartsBySponsor.size === 0) return;
+    this.cartsBySponsor.clear();
+    this.persist();
+    this.emit();
+  }
+  /** Refresh the local cart from the backend (source of truth). */
+  async fetchCartFromBackend(sponsorId) {
+    const cart = this.cartsBySponsor.get(sponsorId);
+    if (!cart?.cartId) return null;
+    const gqlOpts = await getCartGraphQLOptions(sponsorId);
+    const resCart = await getCart(cart.cartId, gqlOpts);
+    if (resCart) this.updateFromBackendCart(sponsorId, resCart);
+    return resCart;
+  }
+  /** Line items grouped by supplier (shipping is per-supplier server-side). */
+  async fetchLineItemsBySupplier(sponsorId) {
+    const cart = this.cartsBySponsor.get(sponsorId);
+    if (!cart?.cartId) return null;
+    const gqlOpts = await getCartGraphQLOptions(sponsorId);
+    return getLineItemsBySupplier(cart.cartId, gqlOpts);
+  }
+  /** Set the chosen shipping option per supplier on the backend cart. */
+  async updateShippingsBySupplier(sponsorId, data) {
+    const cart = this.cartsBySponsor.get(sponsorId);
+    if (!cart?.cartId) return null;
+    const gqlOpts = await getCartGraphQLOptions(sponsorId);
+    const resCart = await updateShippingsBySupplier(cart.cartId, data, gqlOpts);
+    if (resCart && Array.isArray(resCart.line_items)) {
+      this.updateFromBackendCart(sponsorId, resCart);
+    }
+    return resCart;
+  }
+  // MARK: - Read accessors
+  getAllCarts() {
+    return new Map(this.cartsBySponsor);
+  }
+  getCart(sponsorId) {
+    return this.cartsBySponsor.get(sponsorId);
+  }
+  get itemCount() {
+    let count = 0;
+    for (const cart of this.cartsBySponsor.values()) {
+      for (const item of cart.items) count += item.quantity;
+    }
+    return count;
+  }
+  subtotalForSponsor(sponsorId) {
+    const cart = this.cartsBySponsor.get(sponsorId);
+    if (!cart) return 0;
+    return cart.items.reduce((sum, i) => sum + i.unitPrice * i.quantity, 0);
+  }
+  get totalAcrossSponsors() {
+    let sum = 0;
+    for (const cart of this.cartsBySponsor.values()) {
+      for (const item of cart.items) sum += item.unitPrice * item.quantity;
+    }
+    return sum;
+  }
+  get primaryCurrency() {
+    for (const cart of this.cartsBySponsor.values()) return cart.currency;
+    return "NOK";
+  }
+  formatTotal() {
+    return formatPrice(this.totalAcrossSponsors, this.primaryCurrency);
+  }
+  // MARK: - Persistence
+  persist() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const obj = {};
+      for (const [k, v] of this.cartsBySponsor) obj[String(k)] = v;
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(obj));
+    } catch {
+    }
+  }
+  loadFromStorage() {
+    if (typeof localStorage === "undefined") return /* @__PURE__ */ new Map();
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (!raw) return /* @__PURE__ */ new Map();
+      const obj = JSON.parse(raw);
+      const map = /* @__PURE__ */ new Map();
+      for (const [k, v] of Object.entries(obj)) {
+        const id = parseInt(k, 10);
+        if (!Number.isNaN(id) && v && Array.isArray(v.items)) map.set(id, v);
+      }
+      return map;
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  emit() {
+    const detail = {
+      cartsBySponsor: this.getAllCarts(),
+      itemCount: this.itemCount
+    };
+    this.dispatchEvent(new CustomEvent("change", { detail }));
+  }
+};
+
+// src/core/checkout/payments/apple-pay.ts
+var STRIPE_JS_URL = "https://js.stripe.com/v3";
+var stripeJsPromise = null;
+function preloadStripeJs() {
+  if (typeof window === "undefined") return;
+  void loadStripeJs().catch(() => {
+  });
+}
+function loadStripeJs() {
+  if (stripeJsPromise) return stripeJsPromise;
+  if (typeof document === "undefined") {
+    return Promise.reject(new Error("[VioApplePay] Stripe.js requires a browser environment"));
+  }
+  stripeJsPromise = new Promise((resolve, reject) => {
+    const w = window;
+    if (w.Stripe) {
+      resolve(w.Stripe);
+      return;
+    }
+    const existing = document.querySelector(
+      `script[src^="${STRIPE_JS_URL}"]`
+    );
+    if (existing) {
+      existing.addEventListener("load", () => resolve(w.Stripe));
+      existing.addEventListener(
+        "error",
+        () => reject(new Error("[VioApplePay] Failed to load Stripe.js"))
+      );
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = STRIPE_JS_URL;
+    script.async = true;
+    script.addEventListener("load", () => resolve(w.Stripe));
+    script.addEventListener(
+      "error",
+      () => reject(new Error("[VioApplePay] Failed to load Stripe.js"))
+    );
+    document.head.appendChild(script);
+  });
+  return stripeJsPromise;
+}
+async function getStripe(config) {
+  const Stripe = await loadStripeJs();
+  return Stripe(
+    config.publishableKey,
+    config.connectedAccount ? { stripeAccount: config.connectedAccount } : void 0
+  );
+}
+function buildRequestOptions(config) {
+  const ship = config.shippingOptions;
+  const preselectedShipping = ship && ship.length > 0 ? ship[0].amount : 0;
+  return {
+    country: config.country,
+    currency: config.currency.toLowerCase(),
+    total: { label: config.label, amount: config.amount + preselectedShipping },
+    requestPayerName: config.requestPayerName ?? true,
+    requestPayerEmail: config.requestPayerEmail ?? true,
+    requestShipping: ship && ship.length > 0 ? true : config.requestShipping ?? false,
+    ...ship && ship.length > 0 ? { shippingOptions: ship } : {},
+    disableWallets: ["link", "googlePay"]
+  };
+}
+async function checkApplePayAvailability(config) {
+  if (typeof window === "undefined") return false;
+  if (typeof window.ApplePaySession === "undefined") {
+    return false;
+  }
+  if (!config.publishableKey) return false;
+  try {
+    const stripe = await getStripe(config);
+    const pr = stripe.paymentRequest(buildRequestOptions(config));
+    const result = await pr.canMakePayment();
+    return !!result?.applePay;
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[VioApplePay] availability check failed:", err);
+    }
+    return false;
+  }
+}
+async function showApplePaySheet(config) {
+  if (!config.publishableKey) {
+    throw new Error("[VioApplePay] publishableKey is required");
+  }
+  const stripe = await getStripe(config);
+  const pr = stripe.paymentRequest(buildRequestOptions(config));
+  const canMake = await pr.canMakePayment();
+  if (!canMake?.applePay) {
+    throw new Error("[VioApplePay] Apple Pay is not available on this device");
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    pr.on("shippingaddresschange", (raw) => {
+      const ev = raw;
+      ev.updateWith({ status: "success" });
+    });
+    pr.on("paymentmethod", (raw) => {
+      const ev = raw;
+      settled = true;
+      const result = {
+        paymentMethodId: ev.paymentMethod.id,
+        payerName: ev.payerName,
+        payerEmail: ev.payerEmail,
+        payerPhone: ev.payerPhone,
+        shippingAddress: ev.shippingAddress
+      };
+      void (async () => {
+        try {
+          const confirmation = config.onAuthorize ? await config.onAuthorize(result) : void 0;
+          ev.complete("success");
+          resolve({ ...result, confirmation });
+        } catch (err) {
+          ev.complete("fail");
+          reject(err);
+        }
+      })();
+    });
+    pr.on("cancel", () => {
+      if (!settled) resolve(null);
+    });
+    pr.show();
+  });
+}
+async function prepareApplePay(config) {
+  const unavailable = (msg) => ({
+    available: false,
+    show: () => Promise.reject(new Error(msg))
+  });
+  if (typeof window === "undefined" || !config.publishableKey) {
+    return unavailable("[VioApplePay] unavailable");
+  }
+  if (typeof window.ApplePaySession === "undefined") {
+    return unavailable("[VioApplePay] ApplePaySession not available");
+  }
+  try {
+    const stripe = await getStripe(config);
+    const pr = stripe.paymentRequest(buildRequestOptions(config));
+    if (config.shippingOptions && config.shippingOptions.length > 0) {
+      pr.on("shippingoptionchange", (raw) => {
+        const ev = raw;
+        const opt = config.shippingOptions?.find((o) => o.id === ev.shippingOption?.id);
+        ev.updateWith({
+          status: "success",
+          total: { label: config.label, amount: config.amount + (opt?.amount ?? 0) }
+        });
+      });
+    }
+    pr.on("shippingaddresschange", (raw) => {
+      const ev = raw;
+      ev.updateWith({ status: "success" });
+    });
+    const result = await pr.canMakePayment();
+    if (!result?.applePay) return unavailable("[VioApplePay] Apple Pay not available");
+    return {
+      available: true,
+      show() {
+        return new Promise((resolve, reject) => {
+          let settled = false;
+          pr.on("paymentmethod", (raw) => {
+            const ev = raw;
+            settled = true;
+            const res = {
+              paymentMethodId: ev.paymentMethod.id,
+              payerName: ev.payerName,
+              payerEmail: ev.payerEmail,
+              payerPhone: ev.payerPhone,
+              shippingAddress: ev.shippingAddress
+            };
+            void (async () => {
+              try {
+                const confirmation = config.onAuthorize ? await config.onAuthorize(res) : void 0;
+                ev.complete("success");
+                resolve({ ...res, confirmation });
+              } catch (err) {
+                ev.complete("fail");
+                reject(err);
+              }
+            })();
+          });
+          pr.on("cancel", () => {
+            if (!settled) reject(new Error("[VioApplePay] User cancelled Apple Pay"));
+          });
+          pr.show();
+        });
+      }
+    };
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[VioApplePay] prepare failed:", err);
+    }
+    return unavailable("[VioApplePay] prepare failed");
+  }
+}
+
+// src/core/checkout/payments/klarna.ts
+var KLARNA_SDK_URL = "https://js.klarna.com/web-sdk/v2/klarna.mjs";
+var sdkCache = /* @__PURE__ */ new Map();
+function loadKlarnaSdk(config) {
+  if (typeof window === "undefined") {
+    return Promise.reject(new Error("[VioKlarna] requires a browser environment"));
+  }
+  if (!config.clientId) {
+    return Promise.reject(new Error("[VioKlarna] clientId is required"));
+  }
+  const cacheKey = `${config.clientId}:${config.environment ?? "default"}`;
+  const cached = sdkCache.get(cacheKey);
+  if (cached) return cached;
+  const url = KLARNA_SDK_URL;
+  const promise = import(
+    /* @vite-ignore */
+    url
+  ).then((mod) => {
+    const factory = mod.KlarnaSDK ?? mod.default;
+    if (typeof factory !== "function") {
+      throw new Error("[VioKlarna] KlarnaSDK factory not found in module");
+    }
+    return factory({
+      clientId: config.clientId,
+      products: ["PAYMENT"],
+      ...config.locale ? { locale: config.locale } : {},
+      ...config.environment ? { environment: config.environment } : {}
+    });
+  }).catch((err) => {
+    sdkCache.delete(cacheKey);
+    throw err;
+  });
+  sdkCache.set(cacheKey, promise);
+  return promise;
+}
+async function isKlarnaAvailable(config) {
+  if (typeof window === "undefined" || !config.clientId) return false;
+  try {
+    await loadKlarnaSdk(config);
+    return true;
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[VioKlarna] availability check failed:", err);
+    }
+    return false;
+  }
+}
+function findAuthToken(value, depth = 0) {
+  if (!value || depth > 4 || typeof value !== "object") return void 0;
+  const o = value;
+  for (const key of ["authorizationToken", "authorization_token", "authToken"]) {
+    if (typeof o[key] === "string" && o[key].length > 0) return o[key];
+  }
+  for (const k of Object.keys(o)) {
+    const found = findAuthToken(o[k], depth + 1);
+    if (found) return found;
+  }
+  return void 0;
+}
+async function mountKlarnaExpressButton(opts) {
+  const sdk = await loadKlarnaSdk(opts.config);
+  const button = sdk.Payment.button({
+    id: "vio-klarna-express",
+    // `PAY` = one-time purchase (vs BUY/SUBSCRIBE). Must be an array.
+    intents: ["PAY"],
+    // initiationMode belongs on the BUTTON config (per Klarna Web SDK docs),
+    // NOT inside the initiate() data — when set only in initiate() the SDK
+    // falls back to its default (DEVICE_BEST → desktop popup), which opened
+    // and closed without completing. Forcing REDIRECT here makes the click do
+    // a full-page navigation to Klarna's hosted journey, returning via
+    // `returnUrl` (recovered by resumeKlarnaReturn()).
+    initiationMode: "REDIRECT"
+  });
+  const returnUrl = opts.returnUrl ?? (typeof window !== "undefined" ? window.location.origin + window.location.pathname : "");
+  let settled = false;
+  button.on("click", () => {
+    if (opts.pendingKey && opts.pendingContext && typeof sessionStorage !== "undefined") {
+      try {
+        sessionStorage.setItem(opts.pendingKey, JSON.stringify(opts.pendingContext));
+      } catch {
+      }
+    }
+    const promise = sdk.Payment.initiate(() => ({
+      currency: opts.paymentRequest.currency,
+      paymentAmount: opts.paymentRequest.amount,
+      intents: ["PAY"],
+      locale: getGlobalLocale(),
+      // REDIRECT = full-page navigation to Klarna's hosted journey, then back
+      // to `returnUrl` with the result. We force this (vs DEVICE_BEST's desktop
+      // popup) because the popup proved unreliable here — it opened and closed
+      // without completing. The redirect flow has no popup-blocker / window-
+      // messaging failure modes; the return is recovered via resumeKlarnaReturn().
+      initiationMode: "REDIRECT",
+      returnUrl,
+      ...opts.paymentRequest.supplementaryPurchaseData ? { supplementaryPurchaseData: opts.paymentRequest.supplementaryPurchaseData } : {}
+    }));
+    Promise.resolve(promise).then((result) => {
+      if (settled) return;
+      const token = findAuthToken(result);
+      if (token) {
+        settled = true;
+        opts.onAuthorize({ authorizationToken: token, raw: result });
+      } else if (typeof console !== "undefined") {
+        console.warn("[VioKlarna] authorize resolved without a token:", result);
+      }
+    }).catch((err) => {
+      opts.onError?.(err);
+    });
+    return promise;
+  });
+  button.mount(opts.container);
+  return {
+    unmount: () => {
+      try {
+        button.unmount();
+      } catch {
+      }
+    }
+  };
+}
+function readKlarnaTokenFromUrl() {
+  if (typeof window === "undefined") return null;
+  const params = new URLSearchParams(window.location.search);
+  for (const name of [
+    "authorization_token",
+    "authorizationToken",
+    "klarna_authorization_token",
+    "vio_klarna_token"
+  ]) {
+    const v = params.get(name);
+    if (v && v.length > 0 && v !== "{klarna.authorization_token}") {
+      return { token: v, param: name };
+    }
+  }
+  return null;
+}
+function cleanUrlParams(params) {
+  if (typeof window === "undefined" || !window.history?.replaceState) return;
+  const url = new URL(window.location.href);
+  let changed = false;
+  for (const p of params) {
+    if (url.searchParams.has(p)) {
+      url.searchParams.delete(p);
+      changed = true;
+    }
+  }
+  if (changed) window.history.replaceState({}, "", url.toString());
+}
+async function listenForKlarnaCompletion(opts) {
+  let sdk;
+  try {
+    sdk = await loadKlarnaSdk(opts.config);
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[VioKlarna] resume: SDK load failed:", err);
+    }
+    return;
+  }
+  let settled = false;
+  const onComplete = (...args) => {
+    if (settled) return;
+    for (const a of args) {
+      const token = findAuthToken(a);
+      if (token) {
+        settled = true;
+        opts.onComplete({ authorizationToken: token, raw: a });
+        return;
+      }
+    }
+  };
+  try {
+    sdk.Payment.on?.("complete", onComplete);
+  } catch {
+  }
+  try {
+    sdk.Payment.on?.("error", (...a) => opts.onError?.(a[0]));
+  } catch {
+  }
+}
+
+// src/core/checkout/payments/klarna-payments.ts
+var KLARNA_KP_LIB_URL = "https://x.klarnacdn.net/kp/lib/v1/api.js";
+var kpLoad = null;
+function loadKpLib() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return Promise.reject(new Error("[VioKlarnaKP] requires a browser environment"));
+  }
+  if (window.Klarna?.Payments) return Promise.resolve(window.Klarna);
+  if (kpLoad) return kpLoad;
+  kpLoad = new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error("[VioKlarnaKP] kp/lib/v1/api.js load timed out")),
+      12e3
+    );
+    const ready = () => {
+      clearTimeout(timer);
+      if (window.Klarna?.Payments) resolve(window.Klarna);
+      else reject(new Error("[VioKlarnaKP] Klarna global missing after ready"));
+    };
+    const prev = window.klarnaAsyncCallback;
+    window.klarnaAsyncCallback = () => {
+      if (typeof prev === "function") {
+        try {
+          prev();
+        } catch {
+        }
+      }
+      ready();
+    };
+    const existing = document.querySelector(
+      `script[src="${KLARNA_KP_LIB_URL}"]`
+    );
+    if (existing) {
+      if (window.Klarna?.Payments) ready();
+    } else {
+      const s = document.createElement("script");
+      s.src = KLARNA_KP_LIB_URL;
+      s.async = true;
+      s.onerror = () => {
+        clearTimeout(timer);
+        kpLoad = null;
+        reject(new Error("[VioKlarnaKP] failed to load kp/lib/v1/api.js"));
+      };
+      document.head.appendChild(s);
+    }
+  }).catch((err) => {
+    kpLoad = null;
+    throw err;
+  });
+  return kpLoad;
+}
+async function isKlarnaPaymentsAvailable() {
+  if (typeof window === "undefined") return false;
+  try {
+    await loadKpLib();
+    return true;
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[VioKlarnaKP] availability check failed:", err);
+    }
+    return false;
+  }
+}
+function findPayNowCategory(categories) {
+  if (!Array.isArray(categories) || categories.length === 0) return null;
+  const byId = (re) => categories.find((c) => c?.identifier && re.test(c.identifier));
+  const byName = (re) => categories.find((c) => c?.name && re.test(c.name));
+  const cat = categories.find((c) => c?.identifier === "pay_now") ?? byName(/betal\s*n[åa]|pay\s*now/i) ?? byId(/pay_now|direct_debit|direct_bank_transfer|pay_in_full|klarna_pay_now/i) ?? byName(/direkte|bank|kort|straks|sofort/i) ?? categories.find((c) => c?.identifier && !/pay_later|pay_over_time|slice_it/.test(c.identifier));
+  return cat?.identifier ?? null;
+}
+async function createKlarnaPaymentsWidget(input) {
+  const Klarna = await loadKpLib();
+  Klarna.Payments.init({ client_token: input.clientToken });
+  let selected = input.category ?? findPayNowCategory(input.categories) ?? input.categories[0]?.identifier ?? "pay_now";
+  return {
+    categories: input.categories,
+    get selected() {
+      return selected;
+    },
+    load(category) {
+      if (category) selected = category;
+      return new Promise((resolve, reject) => {
+        try {
+          Klarna.Payments.load(
+            { container: input.container, payment_method_category: selected },
+            {},
+            (res) => {
+              if (res?.error) reject(res.error);
+              else resolve({ showForm: res?.show_form !== false });
+            }
+          );
+        } catch (err) {
+          reject(err);
+        }
+      });
+    },
+    authorize(data) {
+      return new Promise((resolve, reject) => {
+        try {
+          Klarna.Payments.authorize(
+            { payment_method_category: selected, auto_finalize: true },
+            data ?? {},
+            (res) => {
+              if (res?.approved && res.authorization_token) {
+                resolve(res.authorization_token);
+              } else if (res?.error) {
+                reject(res.error);
+              } else if (res?.finalize_required) {
+                reject(new Error("Klarna requires a finalize step (multistep)"));
+              } else {
+                reject(new Error("Klarna authorization was not approved"));
+              }
+            }
+          );
+        } catch (err) {
+          reject(err);
+        }
+      });
+    }
+  };
+}
+
+// src/core/checkout/checkout-manager.ts
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (err && typeof err === "object") {
+    const o = err;
+    for (const k of ["message", "error", "reason", "description"]) {
+      if (typeof o[k] === "string" && o[k]) return o[k];
+    }
+    try {
+      return JSON.stringify(err);
+    } catch {
+      return String(err);
+    }
+  }
+  return String(err);
+}
+var KLARNA_PENDING_KEY = "vio.klarna.pending.v1";
+var KLARNA_SHIPPING_OPTIONS = [
+  {
+    id: "standard",
+    method: "Standard",
+    description: "3\u20135 virkedager",
+    price: 4900,
+    tax_amount: 0,
+    tax_rate: 0,
+    preselected: true
+  },
+  {
+    id: "express",
+    method: "Express",
+    description: "1\u20132 virkedager",
+    price: 9900,
+    tax_amount: 0,
+    tax_rate: 0,
+    preselected: false
+  }
+];
+var CREATE_PAYMENT_KLARNA_NATIVE_MUTATION = `
+mutation CreatePaymentKlarnaNative($checkoutId: String!, $countryCode: String, $currency: String, $locale: String, $returnUrl: String, $intent: String, $customer: KlarnaNativeCustomerInput, $billingAddress: KlarnaNativeAddressInput, $shippingAddress: KlarnaNativeAddressInput, $autoCapture: Boolean) {
+  Payment {
+    CreatePaymentKlarnaNative(checkout_id: $checkoutId, country_code: $countryCode, currency: $currency, locale: $locale, return_url: $returnUrl, intent: $intent, customer: $customer, billing_address: $billingAddress, shipping_address: $shippingAddress, auto_capture: $autoCapture) {
+      client_token
+      session_id
+      purchase_country
+      purchase_currency
+      cart_id
+      checkout_id
+      payment_method_categories {
+        identifier
+        name
+        asset_urls {
+          descriptive
+          standard
+        }
+      }
+    }
+  }
+}
+`;
+var CONFIRM_PAYMENT_KLARNA_NATIVE_MUTATION = `
+mutation ConfirmPaymentKlarnaNative($checkoutId: String!, $authorizationToken: String!, $autoCapture: Boolean, $billingAddress: KlarnaNativeAddressInput, $shippingAddress: KlarnaNativeAddressInput, $customer: KlarnaNativeCustomerInput) {
+  Payment {
+    ConfirmPaymentKlarnaNative(checkout_id: $checkoutId, authorization_token: $authorizationToken, auto_capture: $autoCapture, billing_address: $billingAddress, shipping_address: $shippingAddress, customer: $customer) {
+      order_id
+      checkout_id
+      fraud_status
+      order {
+        order_id
+        status
+        purchase_country
+        purchase_currency
+        locale
+        billing_address {
+          given_name
+          family_name
+          email
+          street_address
+          postal_code
+          city
+          country
+        }
+        shipping_address {
+          given_name
+          family_name
+          email
+          street_address
+          postal_code
+          city
+          country
+        }
+        order_amount
+        order_tax_amount
+        total_line_items_price
+        order_lines {
+          type
+          name
+          quantity
+          unit_price
+          tax_rate
+          total_amount
+          total_discount_amount
+          total_tax_amount
+          merchant_data
+        }
+        merchant_urls {
+          terms
+          checkout
+          confirmation
+          push
+        }
+        html_snippet
+        started_at
+        last_modified_at
+        options {
+          allow_separate_shipping_address
+          date_of_birth_mandatory
+          require_validate_callback_success
+          phone_mandatory
+          auto_capture
+        }
+        shipping_options {
+          id
+          name
+          price
+          tax_amount
+          tax_rate
+          preselected
+        }
+        merchant_data
+        selected_shipping_option {
+          id
+          name
+          price
+          tax_amount
+          tax_rate
+          preselected
+        }
+      }
+    }
+  }
+}
+`;
+function buildKlarnaCustomer(address) {
+  if (!address) return null;
+  return {
+    dob: address.dob || address.date_of_birth || null,
+    email: address.email || null,
+    organization_registration_id: address.organization_registration_id || address.org_id || null,
+    phone: address.phone || address.telephone || null,
+    type: address.type || "person"
+  };
+}
+function buildKlarnaAddress(address) {
+  if (!address) return null;
+  return {
+    city: address.city || null,
+    country: address.country || address.countryCode || getGlobalCountryCode(),
+    email: address.email || null,
+    family_name: address.familyName || address.family_name || address.last_name || address.lastName || null,
+    given_name: address.givenName || address.given_name || address.first_name || address.firstName || null,
+    phone: address.phone || null,
+    postal_code: address.postalCode || address.postal_code || address.zip || null,
+    region: address.region || address.state || null,
+    street_address: address.streetAddress || address.street_address || address.address1 || address.street || address.address || // CheckoutAddress uses plain `address` for the street
+    null
+    // street_address2 intentionally omitted — the KlarnaNativeAddressInput
+    // backend type rejects it.
+  };
+}
+function buildCheckoutAddress(address) {
+  if (!address) return null;
+  const firstName = address.firstName || address.first_name || address.givenName || address.given_name || null;
+  const lastName = address.lastName || address.last_name || address.familyName || address.family_name || null;
+  const address1 = address.address || address.address1 || address.street || address.street_address || null;
+  const city = address.city || null;
+  const zip = address.postalCode || address.postal_code || address.zip || null;
+  const country_code = address.countryCode || address.country_code || address.country || getGlobalCountryCode();
+  if (!firstName && !lastName && !address1 && !city && !zip) return null;
+  return {
+    first_name: firstName,
+    last_name: lastName,
+    address1,
+    city,
+    zip,
+    country_code
+  };
+}
+function resolveHttpsReturnUrl(overrideUrl, params = null) {
+  let url = void 0;
+  if (!url && typeof window !== "undefined" && window.location) {
+    url = window.location.href;
+  }
+  if (!url || typeof url !== "string" || url.startsWith("about:") || url.startsWith("file:")) {
+    url = "https://vev.design/checkout/confirmation";
+  }
+  if (url.startsWith("http://")) {
+    url = "https://" + url.slice(7);
+  } else if (!url.startsWith("https://")) {
+    url = "https://" + url.replace(/^[a-zA-Z]+:\/\//, "");
+  }
+  if (params && typeof params === "object") {
+    try {
+      const parsed = new URL(url);
+      Object.keys(params).forEach((k) => {
+        if (params[k] !== void 0 && params[k] !== null) {
+          parsed.searchParams.set(k, String(params[k]));
+        }
+      });
+      return parsed.toString();
+    } catch {
+      const queryStr = Object.keys(params).filter((k) => params[k] !== void 0 && params[k] !== null).map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(String(params[k]))}`).join("&");
+      if (queryStr) {
+        url += (url.includes("?") ? "&" : "?") + queryStr;
+      }
+    }
+  }
+  return url;
+}
+async function executeKlarnaGraphQL(query, variables, sponsorId) {
+  return executeCartGraphQL(query, variables, await getCartGraphQLOptions(sponsorId));
+}
+var CheckoutManager = class _CheckoutManager extends EventTarget {
+  constructor(cartManager) {
+    super();
+    this.cartManager = cartManager;
+    this.state = null;
+    this.applePayAvailableCache = null;
+    /** Gateway hints learned from CreatePaymentApplePay (per session). The
+     * backend's gateway_merchant_id may be a publishable key (pk_…) or a Stripe
+     * Connect account (acct_…) — stored defensively by prefix. */
+    this.applePayPublishableKey = null;
+    this.applePayConnectedAccount = null;
+    this.klarnaAvailableCache = null;
+    this.klarnaOrderInFlight = false;
+    /** Last backend shippings fetched (per-supplier), for UI reuse. */
+    this.lastFetchedShippings = [];
+    /** Per-sponsor payment methods cache + in-flight dedupe. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.paymentMethodsCache = /* @__PURE__ */ new Map();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.paymentMethodsPromises = /* @__PURE__ */ new Map();
+    preloadStripeJs();
+  }
+  open(sponsorId) {
+    const cart = this.cartManager.getCart(sponsorId);
+    if (!cart || cart.items.length === 0) {
+      throw new Error(`[VioCheckout] sponsor ${sponsorId} has no cart items`);
+    }
+    this.state = {
+      sponsorId,
+      subtotal: this.cartManager.subtotalForSponsor(sponsorId),
+      // Page-level currency wins over whatever the persisted cart carries —
+      // the host may have switched currency since the cart was created.
+      currency: getGlobalCurrency()
+    };
+    this.emit();
+    return this.state;
+  }
+  close() {
+    this.state = null;
+    this.applePayAvailableCache = null;
+    this.klarnaAvailableCache = null;
+    this.emit();
+  }
+  // MARK: - Backend checkout (Vio Commerce GraphQL)
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  /** Create the backend checkout for the sponsor's cart (auto-accepts terms). */
+  async createCheckout(sponsorId) {
+    const cart = this.cartManager.getCart(sponsorId);
+    let cartId = cart?.cartId;
+    if (!cartId) {
+      cartId = await this.cartManager.ensureCartId(sponsorId, cart?.currency);
+      if (!cartId) {
+        throw new Error(`[CheckoutManager] Failed to obtain cart_id for sponsor ${sponsorId}`);
+      }
+    }
+    const opts = await getCartGraphQLOptions(sponsorId);
+    const checkout = await createCheckout(cartId, opts);
+    if (checkout?.id) {
+      this.state = {
+        ...this.state ?? { sponsorId, subtotal: 0, currency: getGlobalCurrency() },
+        sponsorId,
+        checkoutId: checkout.id,
+        checkout
+      };
+      this.emit();
+      try {
+        const updated = await updateCheckout(
+          {
+            checkoutId: checkout.id,
+            buyerAcceptsPurchaseConditions: true,
+            buyerAcceptsTermsConditions: true
+          },
+          opts
+        );
+        if (updated?.id) {
+          this.state = { ...this.state, checkout: updated };
+          this.emit();
+          return updated;
+        }
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[CheckoutManager] Failed to auto-accept terms & purchase conditions:", err);
+        }
+      }
+    }
+    return checkout;
+  }
+  /** Update the backend checkout (terms are re-asserted unless overridden). */
+  async updateCheckout(variables, sponsorId) {
+    const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
+    const fullVars = {
+      buyerAcceptsPurchaseConditions: true,
+      buyerAcceptsTermsConditions: true,
+      ...variables
+    };
+    const updated = await updateCheckout(fullVars, opts);
+    if (updated?.id && this.state) {
+      this.state = { ...this.state, checkoutId: updated.id, checkout: updated };
+      this.emit();
+    }
+    return updated;
+  }
+  async getCheckout(checkoutId, sponsorId) {
+    const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
+    return getCheckout(checkoutId, opts);
+  }
+  /**
+   * Payment methods enabled for the sponsor (backend-configured). Memoised per
+   * sponsor with in-flight dedupe — several UI components ask on every open.
+   */
+  async getAvailablePaymentMethods(sponsorId) {
+    const spId = sponsorId ?? this.state?.sponsorId;
+    if (!spId) return null;
+    if (this.paymentMethodsCache.has(spId)) {
+      return this.paymentMethodsCache.get(spId);
+    }
+    const inFlight = this.paymentMethodsPromises.get(spId);
+    if (inFlight) return inFlight;
+    const promise = (async () => {
+      try {
+        const opts = await getCartGraphQLOptions(spId);
+        const res = await getAvailablePaymentMethods(opts);
+        if (res) this.paymentMethodsCache.set(spId, res);
+        return res;
+      } finally {
+        this.paymentMethodsPromises.delete(spId);
+      }
+    })();
+    this.paymentMethodsPromises.set(spId, promise);
+    return promise;
+  }
+  clearPaymentMethodsCache() {
+    this.paymentMethodsCache.clear();
+    this.paymentMethodsPromises.clear();
+  }
+  /**
+   * Real shipping options from the backend cart (per supplier), mapped to the
+   * KlarnaShippingOption shape (minor units). Empty array on failure — callers
+   * fall back to the static KLARNA_SHIPPING_OPTIONS.
+   */
+  async fetchAvailableShippings(sponsorId) {
+    try {
+      const spId = sponsorId ?? this.state?.sponsorId;
+      if (!spId) return [];
+      const cart = this.cartManager.getCart(spId);
+      let cartId = cart?.cartId;
+      if (!cartId) {
+        cartId = await this.cartManager.ensureCartId(spId);
+      }
+      if (!cartId) return [];
+      const opts = await getCartGraphQLOptions(spId);
+      const supplierGroups = await getLineItemsBySupplier(cartId, opts);
+      const firstGroup = Array.isArray(supplierGroups) ? supplierGroups[0] : null;
+      const shippings = firstGroup?.available_shippings ?? [];
+      if (Array.isArray(shippings) && shippings.length > 0) {
+        const supplierId = firstGroup?.supplier?.id;
+        const mapped = shippings.map((s, idx) => {
+          const priceObj = s.price ?? {};
+          const amount = typeof priceObj.amount_incl_taxes === "number" ? priceObj.amount_incl_taxes : typeof priceObj.amount === "number" ? priceObj.amount : 0;
+          return {
+            id: String(s.id),
+            supplierId: supplierId != null ? String(supplierId) : void 0,
+            method: s.name || "Default Shipping",
+            name: s.name || "Default Shipping",
+            description: s.description || "",
+            country_code: s.country_code || "NO",
+            price: Math.round(amount * 100),
+            priceMajor: amount,
+            currency: priceObj.currency_code || getGlobalCurrency(),
+            tax_amount: Math.round((priceObj.tax_amount ?? 0) * 100),
+            tax_rate: Math.round((priceObj.tax_rate ?? 0) * 100),
+            preselected: idx === 0
+          };
+        });
+        this.lastFetchedShippings = mapped;
+        return mapped;
+      }
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[CheckoutManager] fetchAvailableShippings failed:", err);
+      }
+    }
+    return [];
+  }
+  /** Set the chosen shipping per supplier on the backend cart. */
+  async updateShippingsBySupplier(data, sponsorId) {
+    const spId = sponsorId ?? this.state?.sponsorId;
+    if (!spId) return null;
+    const cart = this.cartManager.getCart(spId);
+    if (!cart?.cartId) return null;
+    const opts = await getCartGraphQLOptions(spId);
+    const updated = await updateShippingsBySupplier(cart.cartId, data, opts);
+    if (updated) {
+      this.cartManager.updateFromBackendCart(spId, updated);
+    }
+    return updated;
+  }
+  /**
+   * Shared setup for the redirect payment links (Stripe / Vipps): ensure the
+   * backend cart + checkout exist, push email/address onto the checkout, and
+   * return everything the payment mutation needs.
+   */
+  async prepareRedirectPayment(sponsorId, formData, extraUpdateVars = {}) {
+    const spId = sponsorId ?? this.state?.sponsorId;
+    if (!spId) throw new Error("[CheckoutManager] no sponsor for payment");
+    const cart = this.cartManager.getCart(spId);
+    let cartId = cart?.cartId;
+    if (!cartId) {
+      cartId = await this.cartManager.ensureCartId(spId);
+    }
+    if (!cartId) {
+      throw new Error(`[CheckoutManager] Failed to obtain cart_id for sponsor ${spId}`);
+    }
+    const opts = await getCartGraphQLOptions(spId);
+    let checkoutId = this.state?.checkoutId;
+    if (!checkoutId) {
+      const checkoutRes = await createCheckout(cartId, opts);
+      checkoutId = checkoutRes?.id;
+    }
+    if (!checkoutId) {
+      throw new Error("[CheckoutManager] no backend checkout \u2014 cannot start the payment");
+    }
+    const isVipps = extraUpdateVars?.paymentMethod === "Vipps";
+    const addr = typeof formData === "object" && formData !== null ? formData : this.state?.address;
+    const addressObj = !isVipps ? buildCheckoutAddress(addr) : null;
+    const emailVal = (typeof formData === "string" ? formData : formData?.email) || this.state?.address?.email || "";
+    if (!emailVal || !emailVal.includes("@")) {
+      throw new Error("[CheckoutManager] email is required to start the payment");
+    }
+    const updateVars = {
+      checkoutId,
+      email: emailVal,
+      buyerAcceptsPurchaseConditions: true,
+      buyerAcceptsTermsConditions: true,
+      ...extraUpdateVars
+    };
+    if (addressObj) {
+      updateVars.shippingAddress = addressObj;
+      updateVars.billingAddress = addressObj;
+    }
+    try {
+      const updated = await updateCheckout(updateVars, opts);
+      if (updated?.id) {
+        this.state = {
+          ...this.state ?? { sponsorId: spId, subtotal: 0, currency: getGlobalCurrency() },
+          sponsorId: spId,
+          checkoutId: updated.id,
+          checkout: updated
+        };
+        this.emit();
+        checkoutId = updated.id;
+      }
+    } catch (err) {
+      throw new Error(
+        `[CheckoutManager] could not persist checkout details: ${describeError(err)}`
+      );
+    }
+    if (!checkoutId) {
+      throw new Error("[CheckoutManager] no backend checkout \u2014 cannot start the payment");
+    }
+    return { spId, checkoutId, emailVal, opts };
+  }
+  /** Redirect the top window to a payment provider URL. */
+  static redirectTo(url) {
+    if (typeof window === "undefined") return;
+    try {
+      if (window.top && window.top !== window) {
+        window.top.location.href = url;
+      } else {
+        window.location.href = url;
+      }
+    } catch {
+      window.open(url, "_top") || window.open(url, "_blank");
+    }
+  }
+  /**
+   * Stripe payment link: create/refresh the backend checkout, mint the Stripe
+   * Checkout URL (CreatePaymentStripe) and redirect. The return URL carries
+   * vio_payment/vio_method/checkout_id so the page can show the confirmation.
+   */
+  async startStripePayment(sponsorId, formData) {
+    const { spId, checkoutId, emailVal, opts } = await this.prepareRedirectPayment(
+      sponsorId,
+      formData,
+      { paymentMethod: "Stripe" }
+    );
+    const successUrl = resolveHttpsReturnUrl(null, {
+      vio_payment: "success",
+      vio_method: "stripe",
+      vio_sponsor: spId,
+      checkout_id: checkoutId
+    });
+    const stripeRes = await createPaymentStripe(
+      { checkoutId, successUrl, paymentMethod: "Stripe", email: emailVal },
+      opts
+    );
+    if (stripeRes?.checkout_url) {
+      _CheckoutManager.redirectTo(stripeRes.checkout_url);
+      return stripeRes;
+    }
+    throw new Error("Stripe payment link generation failed: missing checkout_url");
+  }
+  /**
+   * Vipps payment link: same flow as Stripe — CreatePaymentVipps → redirect to
+   * payment_url.
+   */
+  async startVippsPayment(sponsorId, formData) {
+    const { spId, checkoutId, emailVal, opts } = await this.prepareRedirectPayment(
+      sponsorId,
+      formData,
+      { paymentMethod: "Vipps" }
+    );
+    const returnUrl = resolveHttpsReturnUrl(null, {
+      vio_payment: "success",
+      vio_method: "vipps",
+      vio_sponsor: spId,
+      checkout_id: checkoutId
+    });
+    const vippsRes = await createPaymentVipps(
+      { checkoutId, email: emailVal, returnUrl },
+      opts
+    );
+    if (vippsRes?.payment_url) {
+      _CheckoutManager.redirectTo(vippsRes.payment_url);
+      return vippsRes;
+    }
+    throw new Error("Vipps payment link generation failed: missing payment_url");
+  }
+  /** Vipps' own payment state for the checkout — see getVippsStatus in
+   * cart-queries.ts for why this exists instead of trusting GetCheckout. */
+  async getVippsStatus(checkoutId, sponsorId) {
+    const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
+    return getVippsStatus({ checkoutId }, opts);
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+  setAddress(address) {
+    if (!this.state) return;
+    this.state = { ...this.state, address };
+    this.emit();
+  }
+  selectPaymentMethod(method) {
+    if (!this.state) return;
+    this.state = { ...this.state, paymentMethod: method };
+    this.emit();
+    this.dispatchEvent(
+      new CustomEvent("payment-select", {
+        detail: { method, state: this.state }
+      })
+    );
+  }
+  // MARK: - Apple Pay (Stripe Payment Request)
+  /**
+   * Returns true if Apple Pay can be shown on this device + Stripe config.
+   * Result is memoised — call `clearApplePayCache()` if config changes.
+   */
+  async isApplePayAvailable(country = "NO") {
+    if (this.applePayAvailableCache !== null) return this.applePayAvailableCache;
+    const cfg = Configuration.isInitialized ? Configuration.get() : null;
+    const publishableKey = cfg?.stripePublishableKey ?? "";
+    if (!publishableKey || !this.state) {
+      this.applePayAvailableCache = false;
+      return false;
+    }
+    const amount = toSmallestUnit(this.state.subtotal, this.state.currency);
+    const available = await checkApplePayAvailability({
+      publishableKey,
+      connectedAccount: this.findStripeConnectAccount() ?? void 0,
+      amount,
+      currency: this.state.currency,
+      country,
+      label: "Vio"
+    });
+    this.applePayAvailableCache = available;
+    return available;
+  }
+  clearApplePayCache() {
+    this.applePayAvailableCache = null;
+  }
+  /**
+   * Prepare Apple Pay for the product-page express button (no active checkout
+   * needed). Pre-creates the Stripe PaymentRequest + resolves canMakePayment so
+   * the returned `show()` can fire synchronously inside the tap (Apple blocks
+   * the sheet if `show()` is reached after an await). `show()` resolves the
+   * sheet, then dispatches `payment-complete` (→ confirmation) or
+   * `payment-error`. `available` is true only when Apple Pay will actually work.
+   */
+  async prepareApplePayFor(amount, currency, country = "NO") {
+    const cfg = Configuration.isInitialized ? Configuration.get() : null;
+    const publishableKey = this.applePayPublishableKey || cfg?.stripePublishableKey || "";
+    if (!publishableKey) return { available: false, show: async () => {
+    } };
+    const prepared = await prepareApplePay({
+      publishableKey,
+      connectedAccount: this.applePayConnectedAccount ?? this.findStripeConnectAccount() ?? void 0,
+      amount: toSmallestUnit(amount, currency),
+      currency,
+      country,
+      label: "Vio",
+      // Native Apple Pay shipping — same Standard/Express options as Klarna.
+      shippingOptions: KLARNA_SHIPPING_OPTIONS.map((o) => ({
+        id: o.id,
+        label: o.method,
+        detail: o.description,
+        amount: o.price
+      })),
+      // The real backend charge — sponsor resolved at authorize-time (the
+      // product-detail button calls checkout.open() before show()).
+      onAuthorize: (raw) => {
+        const spId = this.state?.sponsorId ?? [...this.cartManager.getAllCarts().keys()][0];
+        if (spId == null) {
+          return Promise.reject(new Error("[VioCheckout] no sponsor for Apple Pay"));
+        }
+        return this.buildApplePayAuthorize(spId)(raw);
+      }
+    });
+    return {
+      available: prepared.available,
+      show: async () => {
+        try {
+          const result = await prepared.show();
+          this.selectPaymentMethod("apple-pay");
+          const state = this.state ?? { sponsorId: 0, subtotal: amount, currency };
+          this.dispatchEvent(
+            new CustomEvent("payment-complete", {
+              detail: { method: "apple-pay", state, result }
+            })
+          );
+        } catch (err) {
+          if (typeof console !== "undefined") {
+            console.warn("[VioCheckout] Apple Pay express failed:", err);
+          }
+          this.dispatchEvent(
+            new CustomEvent("payment-error", {
+              detail: { method: "apple-pay", error: describeError(err) }
+            })
+          );
+        }
+      }
+    };
+  }
+  /**
+   * Prepare an Apple Pay express charge for an arbitrary amount (e.g. the whole
+   * cart) with NO active checkout. Unlike `prepareApplePayFor`, the returned
+   * `show()` RESOLVES with the result (or `null` on cancel/failure) and does
+   * NOT dispatch the global `payment-complete` — so no checkout overlay appears.
+   * The caller (the cart drawer) renders its own confirmation. `show()` must be
+   * called synchronously inside the tap (Apple's user-gesture rule).
+   */
+  async prepareApplePayExpress(amount, currency, country = "NO", sponsorId) {
+    const cfg = Configuration.isInitialized ? Configuration.get() : null;
+    const publishableKey = this.applePayPublishableKey || cfg?.stripePublishableKey || "";
+    if (!publishableKey) return { available: false, show: async () => null };
+    const spId = sponsorId ?? this.state?.sponsorId ?? [...this.cartManager.getAllCarts().keys()][0];
+    const prepared = await prepareApplePay({
+      publishableKey,
+      connectedAccount: this.applePayConnectedAccount ?? this.findStripeConnectAccount() ?? void 0,
+      amount: toSmallestUnit(amount, currency),
+      currency,
+      country,
+      label: "Vio",
+      // Native Apple Pay shipping (same Standard/Express options as Klarna) —
+      // selected inside the sheet, so it's not a separate checkout step.
+      shippingOptions: KLARNA_SHIPPING_OPTIONS.map((o) => ({
+        id: o.id,
+        label: o.method,
+        detail: o.description,
+        amount: o.price
+      })),
+      // The real backend charge, run inside the sheet's authorize event.
+      ...spId != null ? { onAuthorize: this.buildApplePayAuthorize(spId) } : {}
+    });
+    return {
+      available: prepared.available,
+      show: async () => {
+        try {
+          return await prepared.show();
+        } catch (err) {
+          if (typeof console !== "undefined") {
+            console.warn("[VioCheckout] cart Apple Pay express failed:", err);
+          }
+          return null;
+        }
+      }
+    };
+  }
+  /** The charge closure run inside the Apple Pay sheet's authorize event —
+   * shared by the checkout button and the cart's express button. Fail-closed:
+   * any failure throws and the sheet closes with failure, nothing confirmed. */
+  buildApplePayAuthorize(spId) {
+    return async (raw) => {
+      let checkoutId = this.state?.checkoutId;
+      if (!checkoutId) {
+        const created = await this.createCheckout(spId);
+        checkoutId = created?.id ?? this.state?.checkoutId;
+      }
+      if (!checkoutId) {
+        throw new Error("[VioCheckout] could not obtain a checkout for Apple Pay");
+      }
+      const email = raw.payerEmail || this.state?.address?.email || "";
+      try {
+        await this.updateCheckout(
+          { checkoutId, paymentMethod: "Apple Pay", ...email ? { email } : {} },
+          spId
+        );
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[VioCheckout] updateCheckout before Apple Pay confirm failed:", err);
+        }
+      }
+      const gqlOpts = await getCartGraphQLOptions(spId);
+      const createRes = await createPaymentApplePay({ checkoutId }, gqlOpts);
+      const gatewayId = String(createRes?.gateway_merchant_id ?? "");
+      if (gatewayId.startsWith("pk_")) this.applePayPublishableKey = gatewayId;
+      else if (gatewayId.startsWith("acct_")) this.applePayConnectedAccount = gatewayId;
+      const addr = raw.shippingAddress ?? {};
+      const str = (v) => typeof v === "string" ? v : "";
+      const lines = Array.isArray(addr.addressLine) ? addr.addressLine : [];
+      const fullName = str(addr.name) || raw.payerName || "";
+      const shippingAddress = {
+        address1: lines[0] || str(addr.line1) || "",
+        address2: lines[1] || str(addr.line2) || "",
+        city: str(addr.locality) || str(addr.city) || "",
+        company: "",
+        country: str(addr.country) || "",
+        country_code: str(addr.countryCode) || getGlobalCountryCode(),
+        first_name: str(addr.givenName) || fullName.split(" ")[0] || "",
+        last_name: str(addr.familyName) || fullName.split(" ").slice(1).join(" ") || "",
+        phone: str(addr.phone) || str(addr.phoneNumber) || raw.payerPhone || "",
+        phone_code: "",
+        province: str(addr.administrativeArea) || str(addr.state) || "",
+        province_code: "",
+        zip: str(addr.postalCode) || str(addr.postal_code) || ""
+      };
+      const confirmRes = await confirmPaymentApplePay(
+        { checkoutId, applePayToken: raw.paymentMethodId, email, shippingAddress },
+        gqlOpts
+      );
+      const status = String(confirmRes?.status ?? "").toLowerCase();
+      if (!confirmRes || _CheckoutManager.APPLE_PAY_FAILED_STATUSES.has(status)) {
+        throw new Error(
+          `[VioCheckout] Apple Pay confirmation failed (status: ${confirmRes?.status ?? "none"})`
+        );
+      }
+      return { orderId: confirmRes?.order_id, status: confirmRes?.status };
+    };
+  }
+  static {
+    /** Backend statuses from ConfirmPaymentApplePay that mean the charge did
+     * NOT go through — anything here fails the sheet (fail-closed). */
+    this.APPLE_PAY_FAILED_STATUSES = /* @__PURE__ */ new Set([
+      "failed",
+      "declined",
+      "rejected",
+      "cancelled",
+      "canceled",
+      "error",
+      "expired"
+    ]);
+  }
+  /**
+   * Launches the Apple Pay sheet and charges server-side INSIDE the sheet's
+   * authorize event (round-5 wiring, contract from the commerce backend):
+   *   1. ensure a backend checkout exists (create if missing)
+   *   2. UpdateCheckout(paymentMethod: "Apple Pay" + payer email)
+   *   3. CreatePaymentApplePay → gateway hints (pk_/acct_ stored by prefix)
+   *   4. ConfirmPaymentApplePay(token, email, shipping) → the REAL charge;
+   *      a failed/absent confirmation throws → the sheet closes with failure
+   * Resolves null if the user closes the sheet. On success, dispatches
+   * `payment-complete` with the backend order id in `result.confirmation`.
+   */
+  async startApplePay(options = {}) {
+    if (!this.state) throw new Error("[VioCheckout] no active checkout \u2014 call open() first");
+    const spId = options.sponsorId ?? this.state.sponsorId;
+    const cfg = Configuration.isInitialized ? Configuration.get() : null;
+    const publishableKey = this.applePayPublishableKey || cfg?.stripePublishableKey || "";
+    if (!publishableKey) {
+      throw new Error(
+        "[VioCheckout] No Stripe publishable key configured. Pass `stripePublishableKey` to Vio.init({ ... })."
+      );
+    }
+    const amount = toSmallestUnit(this.state.subtotal, this.state.currency);
+    const onAuthorize = this.buildApplePayAuthorize(spId);
+    const result = await showApplePaySheet({
+      publishableKey,
+      connectedAccount: this.applePayConnectedAccount ?? this.findStripeConnectAccount() ?? void 0,
+      amount,
+      currency: this.state.currency,
+      country: options.country ?? "NO",
+      label: options.label ?? "Vio",
+      onAuthorize
+    });
+    if (!result) return null;
+    this.selectPaymentMethod("apple-pay");
+    this.dispatchEvent(
+      new CustomEvent("payment-complete", {
+        detail: { method: "apple-pay", state: this.state, result }
+      })
+    );
+    return result;
+  }
+  // MARK: - Klarna Express Checkout (Klarna Web SDK v2)
+  /**
+   * True if the Klarna Express button can be offered (clientId configured +
+   * SDK loads). Memoised per active checkout. Never throws.
+   */
+  async isKlarnaExpressAvailable() {
+    if (this.klarnaAvailableCache !== null) return this.klarnaAvailableCache;
+    const cfg = Configuration.isInitialized ? Configuration.get() : null;
+    const clientId = cfg?.klarnaClientId ?? "";
+    if (!clientId || !this.state) {
+      this.klarnaAvailableCache = false;
+      return false;
+    }
+    const available = await isKlarnaAvailable({
+      clientId,
+      locale: getGlobalLocale(),
+      environment: cfg?.klarnaEnvironment
+    });
+    this.klarnaAvailableCache = available;
+    return available;
+  }
+  clearKlarnaCache() {
+    this.klarnaAvailableCache = null;
+  }
+  /**
+   * Build the Klarna payment request from the active cart — amounts in the
+   * currency's minor unit (øre/cents), one line item per cart line.
+   */
+  buildKlarnaPaymentRequest() {
+    if (!this.state) throw new Error("[VioCheckout] no active checkout \u2014 call open() first");
+    const currency = this.state.currency;
+    const lineItems = this.items.map((item) => {
+      const unitPrice = toSmallestUnit(item.unitPrice, currency);
+      return {
+        name: item.name || item.brand || "Produkt",
+        quantity: item.quantity,
+        unitPrice,
+        totalAmount: unitPrice * item.quantity,
+        reference: String(item.productId),
+        ...item.imageUrl ? { imageUrl: item.imageUrl } : {}
+      };
+    });
+    return {
+      currency,
+      amount: toSmallestUnit(this.state.subtotal, currency),
+      supplementaryPurchaseData: { lineItems }
+    };
+  }
+  /**
+   * Mount the Klarna Express button into `container`. On a successful
+   * authorization, fires `payment-complete` with the authorization token —
+   * the host (or vio-backend) then creates the Klarna order server-side.
+   *
+   * Returns the button handle so the UI can unmount on teardown.
+   */
+  async mountKlarnaExpress(container) {
+    if (!this.state) throw new Error("[VioCheckout] no active checkout \u2014 call open() first");
+    const cfg = Configuration.get();
+    if (!cfg.klarnaClientId) {
+      throw new Error(
+        "[VioCheckout] No Klarna client id configured. Pass `klarnaClientId` to Vio.init({ ... })."
+      );
+    }
+    const pendingContext = this.buildKlarnaPendingContext();
+    return mountKlarnaExpressButton({
+      config: {
+        clientId: cfg.klarnaClientId,
+        locale: getGlobalLocale(),
+        environment: cfg.klarnaEnvironment
+      },
+      container,
+      paymentRequest: this.buildKlarnaPaymentRequest(),
+      pendingKey: KLARNA_PENDING_KEY,
+      pendingContext,
+      // POPUP path: the initiate() promise resolves in-page with the token.
+      onAuthorize: (result) => {
+        void this.completeKlarnaOrder(result.authorizationToken, pendingContext, result);
+      },
+      onError: (err) => {
+        if (typeof console !== "undefined") {
+          console.warn("[VioCheckout] Klarna Express cancelled/error:", err);
+        }
+        this.dispatchEvent(
+          new CustomEvent("payment-error", {
+            detail: { method: "klarna", error: describeError(err) }
+          })
+        );
+      }
+    });
+  }
+  /**
+   * Klarna Payments — classic widget flow (server client_token). Creates a
+   * session on vio-backend, then mounts Klarna's inline widget into
+   * `container`. Returns a handle to switch category and to authorize → which
+   * on approval creates the order via the same backend /orders route as KEC.
+   *
+   * Unlike `mountKlarnaExpress`, this needs no public `klarnaClientId` and no
+   * origin handshake — auth is the server-side API key.
+   */
+  async mountKlarnaPayments(container, opts) {
+    if (!this.state) throw new Error("[VioCheckout] no active checkout \u2014 call open() first");
+    const sponsorId = this.state.sponsorId;
+    const fetchedShippings = await this.fetchAvailableShippings(sponsorId);
+    const shippings = fetchedShippings.length > 0 ? fetchedShippings : KLARNA_SHIPPING_OPTIONS;
+    const { ctx } = opts?.withShipping ? this.buildKlarnaInstantContext(opts.shippingId, shippings) : { ctx: this.buildKlarnaPendingContext() };
+    const selectedOpt = shippings.find((s) => s.id === opts?.shippingId) ?? shippings[0];
+    if (selectedOpt?.id && selectedOpt?.supplierId) {
+      try {
+        await this.updateShippingsBySupplier(
+          [{ shipping_id: selectedOpt.id, supplier_id: Number(selectedOpt.supplierId) }],
+          sponsorId
+        );
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[CheckoutManager] updateShippingsBySupplier failed during mount:", err);
+        }
+      }
+    }
+    let checkoutId = ctx.checkoutId ?? this.state.checkoutId;
+    try {
+      const checkoutRes = await this.createCheckout(sponsorId);
+      if (checkoutRes?.id) {
+        checkoutId = checkoutRes.id;
+        ctx.checkoutId = checkoutRes.id;
+      }
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[CheckoutManager] CreateCheckout before Klarna init failed:", err);
+      }
+    }
+    if (!checkoutId) {
+      throw new Error("[CheckoutManager] no backend checkout for the Klarna session");
+    }
+    const address = this.state.address;
+    const activeCurrency = getGlobalCurrency();
+    if (this.state) this.state = { ...this.state, currency: activeCurrency };
+    ctx.currency = activeCurrency;
+    const variables = {
+      checkoutId,
+      countryCode: getGlobalCountryCode(),
+      currency: activeCurrency,
+      locale: getGlobalLocale(),
+      returnUrl: resolveHttpsReturnUrl(null, {
+        vio_payment: "success",
+        vio_method: "klarna",
+        vio_sponsor: sponsorId,
+        checkout_id: checkoutId
+      }),
+      intent: "buy",
+      customer: buildKlarnaCustomer(address),
+      billingAddress: buildKlarnaAddress(address),
+      shippingAddress: buildKlarnaAddress(address),
+      autoCapture: true
+    };
+    const json = await executeKlarnaGraphQL(
+      CREATE_PAYMENT_KLARNA_NATIVE_MUTATION,
+      variables,
+      sponsorId
+    );
+    const nativeRes = json?.data?.Payment?.CreatePaymentKlarnaNative;
+    if (!nativeRes || !nativeRes.client_token) {
+      throw new Error("Klarna session creation failed: missing client_token");
+    }
+    if (nativeRes.checkout_id) {
+      ctx.checkoutId = nativeRes.checkout_id;
+      this.state = { ...this.state, checkoutId: nativeRes.checkout_id };
+    }
+    if (nativeRes.session_id) {
+      ctx.sessionId = nativeRes.session_id;
+      this.state = { ...this.state, sessionId: nativeRes.session_id };
+    }
+    ctx.clientToken = nativeRes.client_token;
+    this.state = { ...this.state, clientToken: nativeRes.client_token };
+    const widget = await createKlarnaPaymentsWidget({
+      clientToken: nativeRes.client_token,
+      sessionId: nativeRes.session_id,
+      categories: nativeRes.payment_method_categories ?? [],
+      category: opts?.category,
+      container
+    });
+    await widget.load();
+    return {
+      categories: widget.categories,
+      shippings,
+      get selected() {
+        return widget.selected;
+      },
+      load: (category) => widget.load(category),
+      authorize: async () => {
+        try {
+          const token = await widget.authorize();
+          await this.completeKlarnaOrder(token, ctx, { authorizationToken: token });
+        } catch (err) {
+          if (typeof console !== "undefined") {
+            console.warn("[VioCheckout] Klarna Payments authorize failed:", err);
+          }
+          this.dispatchEvent(
+            new CustomEvent("payment-error", {
+              detail: { method: "klarna", error: describeError(err) }
+            })
+          );
+        }
+      },
+      unmount: () => {
+        try {
+          container.innerHTML = "";
+        } catch {
+        }
+      }
+    };
+  }
+  /** True if the Klarna Payments widget lib can load (UI gate). */
+  async klarnaPaymentsAvailable() {
+    return isKlarnaPaymentsAvailable();
+  }
+  /** Cart snapshot + chosen shipping line/amount, for express purchases. */
+  buildKlarnaInstantContext(shippingId, availableShippings = []) {
+    const base = this.buildKlarnaPendingContext();
+    const options = availableShippings.length > 0 ? availableShippings : KLARNA_SHIPPING_OPTIONS;
+    const shipping = (shippingId ? options.find((o) => o.id === shippingId) : void 0) ?? options.find((o) => o.preselected) ?? options[0];
+    const orderLines = [...base.orderLines];
+    if (shipping) {
+      orderLines.push({
+        name: `Frakt \u2013 ${shipping.method || shipping.name}`,
+        quantity: 1,
+        unit_price: shipping.price,
+        total_amount: shipping.price,
+        reference: `shipping:${shipping.id}`,
+        type: "shipping_fee"
+      });
+    }
+    return {
+      ctx: {
+        ...base,
+        orderLines,
+        orderAmount: base.orderAmount + (shipping?.price ?? 0)
+      },
+      shippingOptions: options
+    };
+  }
+  /**
+   * Express instant purchase — go straight to Klarna's own modal, no checkout
+   * overlay. Creates a session (with shipping options), loads the widget into a
+   * hidden container, then authorizes (which opens Klarna's confirm modal). On
+   * approval creates the order → `payment-complete` (host shows confirmation);
+   * on failure → `payment-error`. Call `open(sponsorId)` first.
+   */
+  async startKlarnaInstant() {
+    if (!this.state) throw new Error("[VioCheckout] no active checkout \u2014 call open() first");
+    const sponsorId = this.state.sponsorId;
+    const fetchedShippings = await this.fetchAvailableShippings(sponsorId);
+    const shippings = fetchedShippings.length > 0 ? fetchedShippings : KLARNA_SHIPPING_OPTIONS;
+    const { ctx } = this.buildKlarnaInstantContext(void 0, shippings);
+    let clientToken;
+    let categories;
+    try {
+      let checkoutId = ctx.checkoutId ?? this.state.checkoutId;
+      try {
+        const checkoutRes = await this.createCheckout(sponsorId);
+        if (checkoutRes?.id) {
+          checkoutId = checkoutRes.id;
+          ctx.checkoutId = checkoutRes.id;
+        }
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[CheckoutManager] CreateCheckout before Klarna instant failed:", err);
+        }
+      }
+      if (!checkoutId) {
+        throw new Error("[CheckoutManager] no backend checkout for the Klarna session");
+      }
+      const address = this.state.address;
+      const activeCurrency = getGlobalCurrency();
+      this.state = { ...this.state, currency: activeCurrency };
+      ctx.currency = activeCurrency;
+      const variables = {
+        checkoutId,
+        countryCode: getGlobalCountryCode(),
+        currency: activeCurrency,
+        locale: getGlobalLocale(),
+        returnUrl: resolveHttpsReturnUrl(null, {
+          vio_payment: "success",
+          vio_method: "klarna",
+          vio_sponsor: sponsorId,
+          checkout_id: checkoutId
+        }),
+        intent: "buy",
+        customer: buildKlarnaCustomer(address),
+        billingAddress: buildKlarnaAddress(address),
+        shippingAddress: buildKlarnaAddress(address),
+        autoCapture: true
+      };
+      const json = await executeKlarnaGraphQL(
+        CREATE_PAYMENT_KLARNA_NATIVE_MUTATION,
+        variables,
+        sponsorId
+      );
+      const nativeRes = json?.data?.Payment?.CreatePaymentKlarnaNative;
+      if (!nativeRes || !nativeRes.client_token) {
+        throw new Error("Klarna instant session failed: missing client_token");
+      }
+      if (nativeRes.checkout_id) {
+        ctx.checkoutId = nativeRes.checkout_id;
+        this.state = { ...this.state, checkoutId: nativeRes.checkout_id };
+      }
+      if (nativeRes.session_id) {
+        ctx.sessionId = nativeRes.session_id;
+        this.state = { ...this.state, sessionId: nativeRes.session_id };
+      }
+      ctx.clientToken = nativeRes.client_token;
+      this.state = { ...this.state, clientToken: nativeRes.client_token };
+      clientToken = nativeRes.client_token;
+      categories = nativeRes.payment_method_categories ?? [];
+    } catch (err) {
+      this.dispatchEvent(
+        new CustomEvent("payment-error", {
+          detail: { method: "klarna", error: describeError(err) }
+        })
+      );
+      return;
+    }
+    const container = document.createElement("div");
+    container.setAttribute("aria-hidden", "true");
+    container.style.cssText = "position:fixed;left:-9999px;top:0;width:1px;height:1px;overflow:hidden;";
+    document.body.appendChild(container);
+    try {
+      const widget = await createKlarnaPaymentsWidget({
+        clientToken,
+        sessionId: ctx.sessionId,
+        categories,
+        container
+      });
+      await widget.load();
+      const token = await widget.authorize();
+      await this.completeKlarnaOrder(token, ctx, { authorizationToken: token });
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[VioCheckout] Klarna instant failed:", err);
+      }
+      this.dispatchEvent(
+        new CustomEvent("payment-error", {
+          detail: { method: "klarna", error: describeError(err) }
+        })
+      );
+    } finally {
+      try {
+        container.remove();
+      } catch {
+      }
+    }
+  }
+  /**
+   * REDIRECT path: call once on app load. If a Klarna purchase was launched
+   * (pending context persisted) and we're back with a token — from the URL or
+   * the SDK's resumed `complete` event — finish creating the order + confirm.
+   */
+  async resumeKlarnaReturn() {
+    if (typeof sessionStorage === "undefined") return;
+    const raw = sessionStorage.getItem(KLARNA_PENDING_KEY);
+    if (!raw) return;
+    let pending;
+    try {
+      pending = JSON.parse(raw);
+    } catch {
+      sessionStorage.removeItem(KLARNA_PENDING_KEY);
+      return;
+    }
+    const fromUrl = readKlarnaTokenFromUrl();
+    if (fromUrl) {
+      cleanUrlParams([fromUrl.param]);
+      await this.completeKlarnaOrder(fromUrl.token, pending, { authorizationToken: fromUrl.token });
+      return;
+    }
+    if (typeof window !== "undefined" && typeof console !== "undefined" && window.location.search) {
+      console.warn(
+        "[VioCheckout] Klarna return: no known token param. URL was:",
+        window.location.search
+      );
+    }
+    const cfg = Configuration.isInitialized ? Configuration.get() : null;
+    if (!cfg?.klarnaClientId) return;
+    await listenForKlarnaCompletion({
+      config: { clientId: cfg.klarnaClientId, locale: getGlobalLocale(), environment: cfg.klarnaEnvironment },
+      onComplete: (result) => {
+        void this.completeKlarnaOrder(result.authorizationToken, pending, result);
+      },
+      onError: (err) => {
+        if (typeof console !== "undefined") {
+          console.warn("[VioCheckout] Klarna resume error:", err);
+        }
+      }
+    });
+  }
+  /** Snapshot of the active cart for redirect recovery (minor units). */
+  buildKlarnaPendingContext() {
+    if (!this.state) throw new Error("[VioCheckout] no active checkout");
+    const currency = this.state.currency;
+    return {
+      sponsorId: this.state.sponsorId,
+      currency,
+      orderAmount: toSmallestUnit(this.state.subtotal, currency),
+      orderLines: this.items.map((item) => {
+        const unitPrice = toSmallestUnit(item.unitPrice, currency);
+        return {
+          name: item.name || item.brand || "Produkt",
+          quantity: item.quantity,
+          unit_price: unitPrice,
+          total_amount: unitPrice * item.quantity,
+          reference: String(item.productId)
+        };
+      })
+    };
+  }
+  /**
+   * POST the token + order lines to vio-backend (it holds the secret API key
+   * and creates the real Klarna order). On success → `payment-complete`; on
+   * failure → `payment-error`. Idempotent: clears the pending key so the
+   * popup and redirect paths can't double-fire.
+   */
+  async completeKlarnaOrder(authorizationToken, ctx, result) {
+    if (this.klarnaOrderInFlight) return;
+    this.klarnaOrderInFlight = true;
+    if (typeof sessionStorage !== "undefined" && sessionStorage.getItem("vio.klarna.confirmed.v1") === authorizationToken) {
+      this.klarnaOrderInFlight = false;
+      return;
+    }
+    try {
+      const checkoutId = ctx?.checkoutId ?? this.state?.checkoutId ?? String(ctx?.sponsorId ?? this.state?.sponsorId ?? "");
+      const address = this.state?.address;
+      const variables = {
+        checkoutId,
+        authorizationToken,
+        autoCapture: true,
+        billingAddress: buildKlarnaAddress(address),
+        shippingAddress: buildKlarnaAddress(address),
+        customer: buildKlarnaCustomer(address)
+      };
+      const json = await executeKlarnaGraphQL(
+        CONFIRM_PAYMENT_KLARNA_NATIVE_MUTATION,
+        variables,
+        ctx?.sponsorId ?? this.state?.sponsorId
+      );
+      const confirmRes = json?.data?.Payment?.ConfirmPaymentKlarnaNative;
+      if (!confirmRes) {
+        throw new Error("Klarna order confirmation failed: missing response data");
+      }
+      const orderData = confirmRes.order || confirmRes;
+      if (typeof sessionStorage !== "undefined") {
+        sessionStorage.setItem("vio.klarna.confirmed.v1", authorizationToken);
+        sessionStorage.removeItem(KLARNA_PENDING_KEY);
+      }
+      const state = this.state ?? { sponsorId: ctx.sponsorId, subtotal: ctx.orderAmount, currency: ctx.currency };
+      this.dispatchEvent(
+        new CustomEvent("payment-complete", {
+          detail: {
+            method: "klarna",
+            state,
+            // chargedTotal in MAJOR units (incl. shipping for express) for the
+            // confirmation screen. ctx.orderAmount is minor (øre) → /100.
+            // Prefer the amount Klarna actually charged (includes shipping in
+            // every flow); the local ctx misses shipping outside express.
+            result: {
+              ...result,
+              order: orderData,
+              chargedTotal: typeof orderData?.order_amount === "number" ? orderData.order_amount / 100 : ctx.orderAmount / 100
+            }
+          }
+        })
+      );
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.error("[VioCheckout] Klarna order creation failed:", err);
+      }
+      this.dispatchEvent(
+        new CustomEvent("payment-error", {
+          detail: { method: "klarna", error: err instanceof Error ? err.message : String(err) }
+        })
+      );
+    } finally {
+      this.klarnaOrderInFlight = false;
+    }
+  }
+  // MARK: - Accessors
+  get currentState() {
+    return this.state;
+  }
+  get items() {
+    if (!this.state) return [];
+    return this.cartManager.getCart(this.state.sponsorId)?.items ?? [];
+  }
+  // MARK: - Internals
+  /**
+   * Resolve the Stripe Connect account for the active sponsor — for now
+   * pulled from bootstrap cache if present. Returns undefined if not set
+   * (Stripe will route to the platform account in that case).
+   */
+  findStripeConnectAccount() {
+    return void 0;
+  }
+  emit() {
+    this.dispatchEvent(
+      new CustomEvent("change", { detail: { state: this.state } })
+    );
+  }
+};
+function toSmallestUnit(amount, currency) {
+  const zeroDecimal = /* @__PURE__ */ new Set(["JPY", "KRW", "VND"]);
+  if (zeroDecimal.has(currency.toUpperCase())) return Math.round(amount);
+  return Math.round(amount * 100);
+}
+
+// src/core/client.ts
+var VioFacade = class {
+  constructor() {
+    this.apiInstance = null;
+    this.commerceClients = /* @__PURE__ */ new Map();
+    this.bootstrapPromise = null;
+    this.cachedBootstrap = null;
+    /** Last bootstrap failure — short backoff so cart mutations don't hammer a
+     * dead endpoint on every call. */
+    this.bootstrapFailedAt = 0;
+    // Client-side managers — created lazily on first access. They don't
+    // need Vio.init() to work (state is purely local).
+    this.cartManager = null;
+    this.checkoutManager = null;
+  }
+  init(config) {
+    Configuration.init(config);
+    this.apiInstance = null;
+    this.commerceClients.clear();
+    this.bootstrapPromise = null;
+    this.cachedBootstrap = null;
+    this.bootstrapFailedAt = 0;
+    this.checkoutManager?.clearPaymentMethodsCache();
+  }
+  get isInitialized() {
+    return Configuration.isInitialized;
+  }
+  get config() {
+    return Configuration.get();
+  }
+  // MARK: - Client-side managers (no init required)
+  /** Multi-sponsor cart manager. Reactive — listen via addEventListener('change', ...). */
+  get cart() {
+    if (!this.cartManager) this.cartManager = new CartManager();
+    return this.cartManager;
+  }
+  /** Checkout flow manager. Subscribes to cart state via the CartManager. */
+  get checkout() {
+    if (!this.checkoutManager) this.checkoutManager = new CheckoutManager(this.cart);
+    return this.checkoutManager;
+  }
+  // MARK: - Backend-bound
+  /** Lazy VioApi for REST endpoints on `api-dev.vio.live`. */
+  get api() {
+    if (!this.apiInstance) {
+      const cfg = Configuration.get();
+      this.apiInstance = createVioApi({ apiBase: cfg.apiBase, apiKey: cfg.apiKey });
+    }
+    return this.apiInstance;
+  }
+  /**
+   * Bootstrap — fetches client config and caches it. Dedupes in-flight
+   * concurrent requests.
+   */
+  async bootstrap() {
+    if (this.cachedBootstrap) return this.cachedBootstrap;
+    if (this.bootstrapPromise) return this.bootstrapPromise;
+    if (this.bootstrapFailedAt && Date.now() - this.bootstrapFailedAt < 5e3) {
+      throw new Error("[Vio] bootstrap recently failed \u2014 backing off");
+    }
+    this.bootstrapPromise = this.api.bootstrap().then((res) => {
+      this.cachedBootstrap = res;
+      this.bootstrapFailedAt = 0;
+      return res;
+    }).catch((err) => {
+      this.bootstrapFailedAt = Date.now();
+      throw err;
+    }).finally(() => {
+      this.bootstrapPromise = null;
+    });
+    return this.bootstrapPromise;
+  }
+  get bootstrapCache() {
+    return this.cachedBootstrap;
+  }
+  /**
+   * Get a CommerceClient scoped to a specific sponsor (via bootstrap).
+   * Throws if bootstrap hasn't been called or the sponsor is unknown.
+   */
+  commerceFor(sponsorId) {
+    sponsorId = Number(sponsorId);
+    const existing = this.commerceClients.get(sponsorId);
+    if (existing) return existing;
+    const sponsor = this.findSponsor(sponsorId);
+    if (!sponsor) {
+      throw new Error(
+        `[Vio] Sponsor ${sponsorId} not found in bootstrap. Call Vio.bootstrap() first or pass commerce-key directly.`
+      );
+    }
+    const cfg = Configuration.get();
+    const client = createCommerceClient({ endpoint: cfg.graphQLBase, apiKey: sponsor.commerce.apiKey });
+    this.commerceClients.set(sponsorId, client);
+    return client;
+  }
+  /** Get a CommerceClient using an explicit commerce apiKey (skip bootstrap). */
+  commerceWithKey(commerceApiKey) {
+    const cfg = Configuration.get();
+    return createCommerceClient({ endpoint: cfg.graphQLBase, apiKey: commerceApiKey });
+  }
+  findSponsor(sponsorId) {
+    const boot = this.cachedBootstrap;
+    if (!boot) return void 0;
+    const id = Number(sponsorId);
+    if (Number(boot.primarySponsor?.id) === id) return boot.primarySponsor;
+    return boot.secondarySponsors?.find((s) => Number(s.id) === id);
+  }
+};
+var _vioGlobal = globalThis;
+var Vio = _vioGlobal.__VIO_FACADE__ ?? (_vioGlobal.__VIO_FACADE__ = new VioFacade());
+
+export { ADD_ITEM_MUTATION, CREATE_CART_MUTATION, CREATE_CHECKOUT_MUTATION, CREATE_PAYMENT_STRIPE_MUTATION, CREATE_PAYMENT_VIPPS_MUTATION, CartManager, CheckoutManager, CommerceClient, Configuration, DELETE_ITEM_MUTATION, GET_AVAILABLE_PAYMENT_METHODS_QUERY, GET_CART_QUERY, GET_CHECKOUT_QUERY, GET_LINE_ITEMS_BY_SUPPLIER_QUERY, GET_VIPPS_STATUS_QUERY, KLARNA_SHIPPING_OPTIONS, UPDATE_CHECKOUT_MUTATION, UPDATE_ITEM_MUTATION, UPDATE_SHIPPINGS_BY_SUPPLIER_MUTATION, Vio, VioApi, VioApiError, __decorateClass, addItem, checkApplePayAvailability, createCart, createCheckout, createCommerceClient, createPaymentStripe, createPaymentVipps, createVioApi, deleteItem, displayPrice, executeCartGraphQL, formatPrice, getAvailablePaymentMethods, getCart, getCartGraphQLOptions, getCheckout, getCustomerSessionId, getGlobalCurrency, getLineItemsBySupplier, getVippsStatus, primaryImageUrl, showApplePaySheet, updateCheckout, updateItem, updateShippingsBySupplier };
+//# sourceMappingURL=chunk-NP2KCM7X.js.map
+//# sourceMappingURL=chunk-NP2KCM7X.js.map