@vio-live/web-sdk 0.11.0 → 0.19.0

package/dist/{chunk-U2QG4IVJ.js → chunk-CMNTHF66.js}

@@ -13,10 +13,12 @@ var __decorateClass = (decorators, target, key, kind) => {
 
 // src/core/configuration.ts
 var DEFAULT_URLS = {
+  // The Vio Backend development environment was removed on 2026-09-16; its REST
+  // and events hosts now point at staging (Commerce GraphQL dev is unaffected).
   development: {
-    apiBase: "https://api-dev.vio.live",
+    apiBase: "https://api-staging.vio.live",
     graphQLBase: "https://graph-ql-dev.vio.live",
-    eventsBase: "https://events-dev.vio.live"
+    eventsBase: "https://events-staging.vio.live"
   },
   // No separate staging GraphQL deployment yet — shares dev's.
   testing: {
@@ -351,6 +353,19 @@ var GET_PRODUCTS_BY_IDS = (
   }
 `
 );
+var GET_PRODUCT_SELLER = (
+  /* GraphQL */
+  `
+  query GetProductSeller($productIds: [Int!], $useCache: Boolean!) {
+    Channel {
+      GetProductsByIds(product_ids: $productIds, useCache: $useCache) {
+        id
+        supplier_company
+      }
+    }
+  }
+`
+);
 var ChannelProduct = class {
   constructor(client) {
     this.client = client;
@@ -372,6 +387,24 @@ var ChannelProduct = class {
     const data = await this.client.request(GET_PRODUCTS_BY_IDS, variables);
     return data.Channel?.GetProductsByIds ?? [];
   }
+  /**
+   * The seller's Company name for one product, or null (none set, or an API
+   * that does not have the field yet). Never throws.
+   *
+   * Never from the cache, on purpose: graphql caches product answers by
+   * path whatever fields the query asked, so this narrow query, written to
+   * the cache, would hand the next full product query a product with no
+   * price and no images. `useCache: false` neither reads nor writes it.
+   */
+  async getSellerCompany(productId) {
+    try {
+      const data = await this.client.request(GET_PRODUCT_SELLER, { productIds: [productId], useCache: false });
+      const name = String(data.Channel?.GetProductsByIds?.[0]?.supplier_company ?? "").trim();
+      return name || null;
+    } catch {
+      return null;
+    }
+  }
 };
 var Channel = class {
   constructor(client) {
@@ -1306,18 +1339,18 @@ query Config {
 `;
 async function getCartGraphQLOptions(sponsorId) {
   const facade = globalThis.__VIO_FACADE__;
-  if (facade && typeof facade.bootstrap === "function" && !facade.bootstrapCache) {
+  if (!Configuration.isInitialized) {
+    await Configuration.whenReady();
+  }
+  if (Configuration.isInitialized && 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);
+        console.warn("[Vio] getCartGraphQLOptions bootstrap 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;
@@ -1329,6 +1362,11 @@ async function getCartGraphQLOptions(sponsorId) {
       sponsorResolved = true;
     }
   }
+  if (sponsorId && !sponsorResolved && typeof console !== "undefined") {
+    console.warn(
+      `[Vio] no commerce key for sponsor ${sponsorId} \u2014 falling back to the platform apiKey, which the commerce API will reject. Is the sponsor configured, and did Vio.init run before this call?`
+    );
+  }
   return {
     endpoint: anyCfg.graphQLBase || "https://graph-ql-dev.vio.live",
     apiKey: anyCfg.apiKey,
@@ -1420,6 +1458,21 @@ async function getCheckout(checkoutId, options) {
   const json = await executeCartGraphQL(GET_CHECKOUT_QUERY, { checkoutId }, options);
   return json?.data?.Checkout?.GetCheckout;
 }
+var GET_CHECKOUT_ORDER_NUMBER_QUERY = `
+query GetCheckoutOrderNumber($checkoutId: String!) {
+  Checkout {
+    GetCheckout(checkout_id: $checkoutId) {
+      id
+      order_id
+    }
+  }
+}
+`;
+async function getCheckoutOrderNumber(checkoutId, options) {
+  const json = await executeCartGraphQL(GET_CHECKOUT_ORDER_NUMBER_QUERY, { checkoutId }, options);
+  const n = Number(json?.data?.Checkout?.GetCheckout?.order_id);
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
 async function getAvailablePaymentMethods(options) {
   const json = await executeCartGraphQL(GET_AVAILABLE_PAYMENT_METHODS_QUERY, {}, options);
   return json?.data?.Payment?.GetAvailablePaymentMethods;
@@ -1469,10 +1522,13 @@ async function confirmPaymentApplePay(variables, options) {
 
 // src/core/checkout/payments/vipps.ts
 var CREATE_PAYMENT_VIPPS_MUTATION = `
-mutation CreatePaymentVipps($checkoutId: String!, $email: String!, $returnUrl: String!) {
+mutation CreatePaymentVipps($checkoutId: String!, $email: String, $returnUrl: String!, $express: Boolean) {
   Payment {
-    CreatePaymentVipps(checkout_id: $checkoutId, email: $email, return_url: $returnUrl) {
+    CreatePaymentVipps(checkout_id: $checkoutId, email: $email, return_url: $returnUrl, express: $express) {
       payment_url
+      reference
+      express
+      reason
     }
   }
 }
@@ -2159,6 +2215,97 @@ async function prepareApplePay(config) {
   }
 }
 
+// src/core/version.ts
+var SDK_VERSION = "0.19.0";
+
+// src/core/checkout/payments/stripe-embedded.ts
+var CREATE_PAYMENT_INTENT_STRIPE_MUTATION = `
+mutation CreatePaymentIntentStripe($checkoutId: String!) {
+  Payment {
+    CreatePaymentIntentStripe(checkout_id: $checkoutId) {
+      client_secret
+      publishable_key
+      customer
+    }
+  }
+}
+`;
+async function createStripeIntent(checkoutId, options) {
+  const json = await executeCartGraphQL(
+    CREATE_PAYMENT_INTENT_STRIPE_MUTATION,
+    { checkoutId },
+    options
+  );
+  return json?.data?.Payment?.CreatePaymentIntentStripe ?? null;
+}
+var SETTLED = /* @__PURE__ */ new Set(["succeeded"]);
+var IN_FLIGHT = /* @__PURE__ */ new Set(["processing", "requires_capture"]);
+async function mountStripeElement(container, intent, options) {
+  if (!intent?.client_secret || !intent.publishable_key) {
+    throw new Error("[Stripe] the payment is missing its client secret or publishable key");
+  }
+  await loadStripeJs();
+  const Stripe = globalThis.Stripe;
+  if (typeof Stripe !== "function") {
+    throw new Error("[Stripe] stripe.js loaded but window.Stripe is missing");
+  }
+  const stripe = intent.stripe_account ? Stripe(intent.publishable_key, { stripeAccount: intent.stripe_account }) : Stripe(intent.publishable_key);
+  const appearance = { theme: "stripe" };
+  const variables = {};
+  if (options.theme?.accent) variables.colorPrimary = options.theme.accent;
+  if (options.theme?.radiusMd) variables.borderRadius = options.theme.radiusMd;
+  if (Object.keys(variables).length > 0) appearance.variables = variables;
+  const elements = stripe.elements({
+    clientSecret: intent.client_secret,
+    appearance,
+    locale: options.locale ?? "nb"
+  });
+  const element = elements.create("payment", { layout: "tabs" });
+  if (options.onReady) element.on("ready", () => options.onReady?.());
+  if (options.onLoadError) {
+    element.on(
+      "loaderror",
+      (event) => options.onLoadError?.(String(event?.error?.message ?? "Stripe could not load the form"))
+    );
+  }
+  container.innerHTML = "";
+  element.mount(container);
+  let confirming = false;
+  return {
+    async confirm() {
+      if (confirming) return { status: "pending" };
+      confirming = true;
+      try {
+        const result = await stripe.confirmPayment({
+          elements,
+          confirmParams: { return_url: options.returnUrl },
+          redirect: "if_required"
+        });
+        if (result?.error) {
+          return {
+            status: "failed",
+            message: String(result.error.message ?? ""),
+            code: String(result.error.code ?? "")
+          };
+        }
+        const paymentIntent = result?.paymentIntent;
+        const status = String(paymentIntent?.status ?? "");
+        if (SETTLED.has(status)) return { status: "succeeded", paymentIntentId: paymentIntent?.id };
+        if (IN_FLIGHT.has(status)) return { status: "pending", paymentIntentId: paymentIntent?.id };
+        return { status: "failed", code: status };
+      } finally {
+        confirming = false;
+      }
+    },
+    unmount() {
+      try {
+        element.unmount();
+      } catch {
+      }
+    }
+  };
+}
+
 // src/core/checkout/payments/klarna.ts
 var KLARNA_SDK_URL = "https://js.klarna.com/web-sdk/v2/klarna.mjs";
 var sdkCache = /* @__PURE__ */ new Map();
@@ -2519,15 +2666,23 @@ async function createKlarnaPaymentsWidget(input) {
 }
 
 // src/core/checkout/payments/kustom.ts
-var CREATE_PAYMENT_KUSTOM_MUTATION = `
-mutation CreatePaymentKustom($checkoutId: String!, $countryCode: String!, $href: String!, $email: String) {
-  Payment {
-    CreatePaymentKustom(checkout_id: $checkoutId, country_code: $countryCode, href: $href, email: $email) {
+var KUSTOM_ORDER_FIELDS = `
       order_id
       status
       html_snippet
       purchase_country
       purchase_currency
+      checkout_id
+      environment
+      total_price
+      shipping_name
+      shipping_price
+      order_created
+      reference`;
+var CREATE_PAYMENT_KUSTOM_MUTATION = `
+mutation CreatePaymentKustom($checkoutId: String!, $countryCode: String!, $href: String!, $email: String, $client: String) {
+  Payment {
+    CreatePaymentKustom(checkout_id: $checkoutId, country_code: $countryCode, href: $href, email: $email, client: $client) {${KUSTOM_ORDER_FIELDS}
     }
   }
 }
@@ -2535,12 +2690,15 @@ mutation CreatePaymentKustom($checkoutId: String!, $countryCode: String!, $href:
 var GET_KUSTOM_ORDER_QUERY = `
 query GetKustomOrder($orderId: String!) {
   Payment {
-    GetKustomOrder(order_id: $orderId) {
-      order_id
-      status
-      html_snippet
-      purchase_country
-      purchase_currency
+    GetKustomOrder(order_id: $orderId) {${KUSTOM_ORDER_FIELDS}
+    }
+  }
+}
+`;
+var SYNC_PAYMENT_KUSTOM_MUTATION = `
+mutation SyncPaymentKustom($checkoutId: String!) {
+  Payment {
+    SyncPaymentKustom(checkout_id: $checkoutId) {${KUSTOM_ORDER_FIELDS}
     }
   }
 }
@@ -2553,6 +2711,10 @@ async function getKustomOrder(orderId, options) {
   const json = await executeCartGraphQL(GET_KUSTOM_ORDER_QUERY, { orderId }, options);
   return json?.data?.Payment?.GetKustomOrder ?? null;
 }
+async function syncPaymentKustom(checkoutId, options) {
+  const json = await executeCartGraphQL(SYNC_PAYMENT_KUSTOM_MUTATION, { checkoutId }, options);
+  return json?.data?.Payment?.SyncPaymentKustom ?? null;
+}
 function kustomCleanHref() {
   if (typeof window === "undefined" || !window.location) return "";
   return `${window.location.origin}${window.location.pathname}`;
@@ -2569,6 +2731,64 @@ function renderKustomSnippet(container, htmlSnippet) {
     oldScript.parentNode?.replaceChild(newScript, oldScript);
   }
 }
+function kustomApi() {
+  if (typeof window === "undefined") return null;
+  const fn = window._klarnaCheckout;
+  return typeof fn === "function" ? fn : null;
+}
+function suspendKustom() {
+  const api = kustomApi();
+  if (!api) return false;
+  api((a) => a.suspend());
+  return true;
+}
+function resumeKustom() {
+  const api = kustomApi();
+  if (!api) return false;
+  api((a) => a.resume());
+  return true;
+}
+function installKustomListeners(handlers) {
+  let alive = true;
+  const api = kustomApi();
+  if (api) {
+    api((a) => {
+      a.on({
+        load: (data) => alive && handlers.onLoad?.(data),
+        order_total_change: (data) => {
+          const total = Number(data?.order_total);
+          if (alive && Number.isFinite(total)) handlers.onOrderTotalChange?.(total);
+        },
+        shipping_option_change: (data) => alive && handlers.onShippingOptionChange?.(data ?? {}),
+        can_not_complete_order: () => alive && handlers.onCannotComplete?.(),
+        network_error: () => alive && handlers.onNetworkError?.(),
+        redirect_initiated: () => alive && handlers.onRedirectInitiated?.()
+      });
+    });
+  }
+  return {
+    destroy() {
+      alive = false;
+    }
+  };
+}
+var KUSTOM_RETURN_QUERY_KEYS = [
+  "order_id",
+  "payment_processor",
+  "checkout_id",
+  "vio_payment",
+  "vio_method"
+];
+function kustomReturnOutcome(params) {
+  const orderId = params.get("order_id") || "";
+  if (params.get("payment_processor") === "KUSTOM" && orderId) {
+    return { kind: "confirmation", orderId, checkoutId: params.get("checkout_id") || void 0 };
+  }
+  if (params.get("vio_payment") === "rejected" && params.get("vio_method") === "kustom") {
+    return { kind: "rejected", checkoutId: params.get("checkout_id") || void 0 };
+  }
+  return null;
+}
 
 // src/core/checkout/payments/qliro.ts
 function readVioTheme() {
@@ -2654,7 +2874,8 @@ function installQliroListeners(options) {
   const win = globalThis;
   let q1 = null;
   let destroyed = false;
-  let pending = null;
+  let orderUpdatedRegistered = false;
+  let pending2 = null;
   const emit = (event) => {
     try {
       onEvent?.(event);
@@ -2662,10 +2883,10 @@ function installQliroListeners(options) {
     }
   };
   const settle = () => {
-    if (!pending) return;
-    clearTimeout(pending.timer);
-    const { resolve } = pending;
-    pending = null;
+    if (!pending2) return;
+    clearTimeout(pending2.timer);
+    const { resolve } = pending2;
+    pending2 = null;
     try {
       q1?.unlock();
     } catch {
@@ -2677,8 +2898,8 @@ function installQliroListeners(options) {
     return !echo || echo === version;
   };
   const settleIfAcknowledged = () => {
-    if (!pending) return;
-    if (pending.echoes.some((echo) => acknowledges(echo, pending.version))) {
+    if (!pending2) return;
+    if (pending2.echoes.some((echo) => acknowledges(echo, pending2.version))) {
       settle();
     }
   };
@@ -2691,12 +2912,6 @@ function installQliroListeners(options) {
     if (destroyed) return;
     q1 = instance;
     instance.onCheckoutLoaded(() => emit({ type: "loaded" }));
-    instance.onOrderUpdated((order) => {
-      if (!pending) return;
-      const echoed = order?.merchantUpdateVersion ?? order?.MerchantUpdateVersion ?? null;
-      pending.echoes.push(echoed);
-      settleIfAcknowledged();
-    });
     instance.onShippingMethodChanged(
       (shipping) => emit({ type: "shipping-changed", shipping })
     );
@@ -2720,13 +2935,22 @@ function installQliroListeners(options) {
   const controller = {
     async sync() {
       if (destroyed) return null;
-      if (pending) settle();
+      if (pending2) settle();
       try {
         q1?.lock();
+        if (q1 && !orderUpdatedRegistered) {
+          orderUpdatedRegistered = true;
+          q1.onOrderUpdated((order) => {
+            if (!pending2) return;
+            const echoed = order?.merchantUpdateVersion ?? order?.MerchantUpdateVersion ?? null;
+            pending2.echoes.push(echoed);
+            settleIfAcknowledged();
+          });
+        }
       } catch {
       }
       const settled = new Promise((resolve) => {
-        pending = {
+        pending2 = {
           version: null,
           echoes: [],
           resolve,
@@ -2747,8 +2971,8 @@ function installQliroListeners(options) {
         await settled;
         return result;
       }
-      if (pending) {
-        pending.version = result.update_version;
+      if (pending2) {
+        pending2.version = result.update_version;
         settleIfAcknowledged();
       }
       await settled;
@@ -2805,6 +3029,441 @@ async function getWalleyOrder(checkoutId, options) {
 }
 var WALLEY_PURCHASE_COMPLETED_EVENT = "walleyCheckoutPurchaseCompleted";
 
+// src/core/checkout/payments/nexi.ts
+var NEXI_SHIPPING_FIELDS = `
+      ok
+      reason
+      order_id
+      total_price
+      shipping_name
+      shipping_price
+      shipping_id
+      options { id name price }
+      country
+      postal_code
+      address_source
+      changed`;
+var NEXI_ORDER_FIELDS = `
+      order_id
+      status
+      checkout_key
+      checkout_js_url
+      purchase_country
+      purchase_currency
+      total_price
+      payment_method
+      card_last4
+      email
+      shipping {${NEXI_SHIPPING_FIELDS}
+      }`;
+var CREATE_PAYMENT_NEXI_MUTATION = `
+mutation CreatePaymentNexi($checkoutId: String!, $countryCode: String!, $href: String!, $email: String) {
+  Payment {
+    CreatePaymentNexi(checkout_id: $checkoutId, country_code: $countryCode, href: $href, email: $email) {${NEXI_ORDER_FIELDS}
+    }
+  }
+}
+`;
+var GET_NEXI_ORDER_QUERY = `
+query GetNexiOrder($checkoutId: String!) {
+  Payment {
+    GetNexiOrder(checkout_id: $checkoutId) {${NEXI_ORDER_FIELDS}
+    }
+  }
+}
+`;
+var UPDATE_NEXI_SHIPPING_MUTATION = `
+mutation UpdateNexiShipping($checkoutId: String!, $countryCode: String!, $postalCode: String, $shippingId: String) {
+  Payment {
+    UpdateNexiShipping(checkout_id: $checkoutId, country_code: $countryCode, postal_code: $postalCode, shipping_id: $shippingId) {${NEXI_SHIPPING_FIELDS}
+    }
+  }
+}
+`;
+async function createPaymentNexi(variables, options) {
+  const json = await executeCartGraphQL(CREATE_PAYMENT_NEXI_MUTATION, variables, options);
+  return json?.data?.Payment?.CreatePaymentNexi ?? null;
+}
+async function getNexiOrder(checkoutId, options) {
+  const json = await executeCartGraphQL(GET_NEXI_ORDER_QUERY, { checkoutId }, options);
+  return json?.data?.Payment?.GetNexiOrder ?? null;
+}
+async function updateNexiShipping(variables, options) {
+  const json = await executeCartGraphQL(UPDATE_NEXI_SHIPPING_MUTATION, variables, options);
+  return json?.data?.Payment?.UpdateNexiShipping ?? null;
+}
+var NEXI_PAID_STATUSES = /* @__PURE__ */ new Set(["Reserved", "Charged"]);
+function isNexiPaid(status) {
+  return NEXI_PAID_STATUSES.has(String(status ?? ""));
+}
+var NEXI_LANGUAGES = {
+  NO: "nb-NO",
+  SE: "sv-SE",
+  DK: "da-DK",
+  FI: "fi-FI",
+  DE: "de-DE",
+  NL: "nl-NL",
+  PL: "pl-PL",
+  FR: "fr-FR",
+  ES: "es-ES",
+  IT: "it-IT",
+  EE: "ee-EE",
+  LV: "lv-LV",
+  LT: "lt-LT",
+  SK: "sk-SK"
+};
+function nexiLanguageFor(countryCode) {
+  return NEXI_LANGUAGES[String(countryCode ?? "").toUpperCase()] ?? "en-GB";
+}
+function nexiThemeFrom(theme) {
+  if (!theme) return void 0;
+  const out = {};
+  if (theme.accent) out.primaryColor = theme.accent;
+  if (theme.surface) out.panelColor = theme.surface;
+  if (theme.radiusMd && /^\d+(\.\d+)?px$/.test(theme.radiusMd)) out.buttonRadius = theme.radiusMd;
+  return Object.keys(out).length ? out : void 0;
+}
+var scriptLoads = /* @__PURE__ */ new Map();
+function loadNexiCheckoutJs(url) {
+  const g = globalThis;
+  if (g.Dibs?.Checkout && g.__vioNexiCheckoutJs === url) return Promise.resolve();
+  const inFlight = scriptLoads.get(url);
+  if (inFlight) return inFlight;
+  const load = new Promise((resolve, reject) => {
+    const doc = g.document;
+    if (!doc?.head) {
+      reject(new Error("[Nexi] no document to load checkout.js into"));
+      return;
+    }
+    const script = doc.createElement("script");
+    script.src = url;
+    script.async = true;
+    script.onload = () => {
+      if (g.Dibs?.Checkout) {
+        g.__vioNexiCheckoutJs = url;
+        resolve();
+      } else {
+        scriptLoads.delete(url);
+        reject(new Error("[Nexi] checkout.js loaded but Dibs.Checkout is missing"));
+      }
+    };
+    script.onerror = () => {
+      scriptLoads.delete(url);
+      reject(new Error(`[Nexi] could not load ${url}`));
+    };
+    doc.head.appendChild(script);
+  });
+  scriptLoads.set(url, load);
+  return load;
+}
+async function mountNexi(container, order, options = {}) {
+  if (!order?.order_id || !order.checkout_key || !order.checkout_js_url) {
+    throw new Error("[Nexi] order is missing paymentId, checkout_key or checkout_js_url");
+  }
+  await loadNexiCheckoutJs(order.checkout_js_url);
+  if (!container.id) container.id = "vio-nexi-checkout-container";
+  const Dibs = globalThis.Dibs;
+  const checkout = new Dibs.Checkout({
+    checkoutKey: order.checkout_key,
+    paymentId: order.order_id,
+    containerId: container.id,
+    language: options.language ?? "en-GB",
+    ...options.theme ? { theme: options.theme } : {}
+  });
+  return checkout;
+}
+var NEXI_PENDING_KEY = "vio.nexi.pending.v1";
+var NEXI_PENDING_TTL_MS = 48 * 60 * 60 * 1e3;
+function storage() {
+  try {
+    const s = globalThis.sessionStorage;
+    return s ?? null;
+  } catch {
+    return null;
+  }
+}
+function rememberNexiPending(pending2) {
+  try {
+    storage()?.setItem(NEXI_PENDING_KEY, JSON.stringify({ ...pending2, createdAt: Date.now() }));
+  } catch {
+  }
+}
+function readNexiPending() {
+  try {
+    const raw = storage()?.getItem(NEXI_PENDING_KEY);
+    if (!raw) return null;
+    const p = JSON.parse(raw);
+    if (!p?.checkoutId || !p?.paymentId) return null;
+    if (Date.now() - Number(p.createdAt ?? 0) > NEXI_PENDING_TTL_MS) {
+      clearNexiPending();
+      return null;
+    }
+    return {
+      checkoutId: String(p.checkoutId),
+      sponsorId: Number(p.sponsorId ?? 0),
+      paymentId: String(p.paymentId),
+      createdAt: Number(p.createdAt ?? 0)
+    };
+  } catch {
+    return null;
+  }
+}
+function clearNexiPending() {
+  try {
+    storage()?.removeItem(NEXI_PENDING_KEY);
+  } catch {
+  }
+}
+function nexiReturnPaymentId(search) {
+  try {
+    const s = search ?? globalThis.location?.search ?? "";
+    const id = new URLSearchParams(s).get("paymentId");
+    return id && /^[0-9a-f]{32}$/i.test(id) ? id : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/checkout/payments/adyen.ts
+var ADYEN_SESSION_FIELDS = `
+      order_id
+      session_id
+      session_data
+      client_key
+      environment
+      country_code
+      shopper_locale
+      purchase_currency
+      amount
+      total_price
+      shipping_name
+      shipping_price
+      expires_at`;
+var ADYEN_PAYMENT_FIELDS = `
+      order_id
+      status
+      result_code
+      psp_reference
+      payment_method
+      purchase_country
+      purchase_currency
+      total_price
+      shipping_name
+      shipping_price
+      email
+      order_created`;
+var CREATE_PAYMENT_ADYEN_MUTATION = `
+mutation CreatePaymentAdyen($checkoutId: String!, $returnUrl: String!, $countryCode: String, $channel: String, $email: String, $client: String) {
+  Payment {
+    CreatePaymentAdyen(checkout_id: $checkoutId, return_url: $returnUrl, country_code: $countryCode, channel: $channel, email: $email, client: $client) {${ADYEN_SESSION_FIELDS}
+    }
+  }
+}
+`;
+var GET_ADYEN_PAYMENT_QUERY = `
+query GetAdyenPayment($checkoutId: String!, $sessionResult: String, $redirectResult: String) {
+  Payment {
+    GetAdyenPayment(checkout_id: $checkoutId, session_result: $sessionResult, redirect_result: $redirectResult) {${ADYEN_PAYMENT_FIELDS}
+    }
+  }
+}
+`;
+var CONFIRM_ADYEN_PAYMENT_MUTATION = `
+mutation ConfirmAdyenPayment($checkoutId: String!, $sessionId: String!) {
+  Payment {
+    ConfirmAdyenPayment(checkout_id: $checkoutId, session_id: $sessionId) {
+      ok
+      reason
+    }
+  }
+}
+`;
+async function createPaymentAdyen(variables, options) {
+  const json = await executeCartGraphQL(CREATE_PAYMENT_ADYEN_MUTATION, variables, options);
+  return json?.data?.Payment?.CreatePaymentAdyen ?? null;
+}
+async function getAdyenPayment(variables, options) {
+  const json = await executeCartGraphQL(GET_ADYEN_PAYMENT_QUERY, variables, options);
+  return json?.data?.Payment?.GetAdyenPayment ?? null;
+}
+async function confirmAdyenPayment(variables, options) {
+  const json = await executeCartGraphQL(CONFIRM_ADYEN_PAYMENT_MUTATION, variables, options);
+  return json?.data?.Payment?.ConfirmAdyenPayment ?? null;
+}
+var ADYEN_WEB_VERSION = "6.45.0";
+var ADYEN_WEB_JS_SRI = "sha384-7KW64UN6T0xZoacpNpRg2KVxMMVwfqwUNTDmalkE1roPBtjOpWe8JuJoUU7OCMvF";
+var ADYEN_WEB_CSS_SRI = "sha384-A4V58Hp1NTZmMvKn29pBh7249tw4TmfdL2szCtpKvaYfR/ARbXlXRYU20SLp/1VW";
+var ADYEN_ENVIRONMENTS = ["test", "live", "live-us", "live-au", "live-apse", "live-in"];
+function adyenAssetUrls(environment) {
+  const env = ADYEN_ENVIRONMENTS.includes(environment) ? environment : "test";
+  const base = `https://checkoutshopper-${env}.cdn.adyen.com/checkoutshopper/sdk/${ADYEN_WEB_VERSION}`;
+  return { js: `${base}/adyen.js`, css: `${base}/adyen.css` };
+}
+var assetLoads = /* @__PURE__ */ new Map();
+function loadAdyenWeb(environment) {
+  const g = globalThis;
+  const { js, css } = adyenAssetUrls(environment);
+  if (g.AdyenWeb?.AdyenCheckout && g.__vioAdyenWeb === js) return Promise.resolve();
+  const inFlight = assetLoads.get(js);
+  if (inFlight) return inFlight;
+  const load = new Promise((resolve, reject) => {
+    const doc = g.document;
+    if (!doc?.head) {
+      reject(new Error("[Adyen] no document to load Adyen Web into"));
+      return;
+    }
+    if (!doc.head.querySelector(`link[data-vio-adyen="${ADYEN_WEB_VERSION}"]`)) {
+      const link = doc.createElement("link");
+      link.rel = "stylesheet";
+      link.href = css;
+      link.integrity = ADYEN_WEB_CSS_SRI;
+      link.crossOrigin = "anonymous";
+      link.setAttribute("data-vio-adyen", ADYEN_WEB_VERSION);
+      doc.head.appendChild(link);
+    }
+    const script = doc.createElement("script");
+    script.src = js;
+    script.async = true;
+    script.integrity = ADYEN_WEB_JS_SRI;
+    script.crossOrigin = "anonymous";
+    script.onload = () => {
+      if (g.AdyenWeb?.AdyenCheckout && g.AdyenWeb?.Dropin) {
+        g.__vioAdyenWeb = js;
+        resolve();
+      } else {
+        reject(new Error("[Adyen] adyen.js loaded but AdyenWeb.AdyenCheckout is missing"));
+      }
+    };
+    script.onerror = () => {
+      reject(new Error(`[Adyen] could not load ${js}`));
+    };
+    doc.head.appendChild(script);
+  }).finally(() => {
+    assetLoads.delete(js);
+  });
+  assetLoads.set(js, load);
+  return load;
+}
+var AdyenOriginError = class extends Error {
+  constructor(origin) {
+    super(
+      `[Adyen] ${origin} is not an allowed origin of this Adyen client key \u2014 add it under Developers > API credentials > Client settings > Allowed origins.`
+    );
+    this.origin = origin;
+    this.name = "AdyenOriginError";
+  }
+};
+var looksLikeOriginProblem = (err) => /origin|client\s?key|14_0381|401|403/i.test(String(err?.message ?? err ?? ""));
+async function mountAdyen(container, session, handlers, options = {}) {
+  if (!session?.session_id || !session.session_data || !session.client_key) {
+    throw new Error("[Adyen] session is missing session_id, session_data or client_key");
+  }
+  await loadAdyenWeb(session.environment);
+  const { AdyenCheckout, Dropin } = globalThis.AdyenWeb;
+  if (options.theme?.accent) {
+    container.style.setProperty("--adyen-sdk-color-background-always-dark", options.theme.accent);
+  }
+  if (options.theme?.radiusMd && /^\d+(\.\d+)?px$/.test(options.theme.radiusMd)) {
+    container.style.setProperty("--adyen-sdk-border-radius-m", options.theme.radiusMd);
+  }
+  let paying = false;
+  let checkout;
+  try {
+    checkout = await AdyenCheckout({
+      session: { id: session.session_id, sessionData: session.session_data },
+      clientKey: session.client_key,
+      environment: session.environment,
+      locale: session.shopper_locale,
+      countryCode: session.country_code,
+      amount: { value: session.amount, currency: session.purchase_currency },
+      beforeSubmit: async (data, _component, actions) => {
+        if (paying) {
+          actions.reject();
+          return;
+        }
+        paying = true;
+        let proceed = false;
+        try {
+          proceed = await handlers.onBeforePay();
+        } catch {
+          proceed = false;
+        }
+        if (proceed) {
+          actions.resolve(data);
+        } else {
+          paying = false;
+          actions.reject();
+        }
+      },
+      onPaymentCompleted: (result) => {
+        paying = false;
+        handlers.onCompleted(result ?? {});
+      },
+      onPaymentFailed: (result) => {
+        paying = false;
+        handlers.onFailed(result ?? {});
+      },
+      onError: (error) => {
+        paying = false;
+        handlers.onError?.(error);
+      }
+    });
+  } catch (err) {
+    if (looksLikeOriginProblem(err)) {
+      throw new AdyenOriginError(globalThis.location?.origin ?? "this page");
+    }
+    throw err;
+  }
+  const dropin = new Dropin(checkout, {
+    // Vio's own confirmation follows; Adyen's success animation would sit
+    // between the payment and it.
+    disableFinalAnimation: true,
+    instantPaymentTypes: ["applepay", "googlepay"]
+  }).mount(container);
+  return {
+    sessionId: session.session_id,
+    unmount: () => {
+      try {
+        dropin.unmount();
+      } catch {
+      }
+    }
+  };
+}
+var ADYEN_RETURN_METHOD = "adyen";
+function adyenReturnParams(search = globalThis?.location?.search ?? "") {
+  try {
+    const params = new URLSearchParams(search);
+    const redirectResult = params.get("redirectResult");
+    if (!redirectResult) return null;
+    return { redirectResult, sessionId: params.get("sessionId") };
+  } catch {
+    return null;
+  }
+}
+var ADYEN_RETURN_QUERY_KEYS = [
+  "vio_payment",
+  "vio_method",
+  "vio_sponsor",
+  "checkout_id",
+  "sessionId",
+  "redirectResult"
+];
+function adyenReturnOutcome(payment) {
+  switch (payment?.status) {
+    case "authorised":
+      return "paid";
+    case "refused":
+    case "cancelled":
+    case "error":
+      return "failed";
+    // pending (Swish, Trustly…) and anything unrecognised: the webhook
+    // decides, and offering to pay again is the one thing not to do.
+    default:
+      return "pending";
+  }
+}
+
 // src/core/checkout/checkout-manager.ts
 function describeError(err) {
   if (err instanceof Error) return err.message;
@@ -2993,8 +3652,33 @@ function buildCheckoutAddress(address) {
     country_code
   };
 }
+function adyenReturnUrl(params) {
+  let page = null;
+  if (typeof window !== "undefined" && window.location?.href) {
+    try {
+      page = new URL(window.location.href);
+      ADYEN_RETURN_QUERY_KEYS.forEach((k) => page?.searchParams.delete(k));
+    } catch {
+      page = null;
+    }
+  }
+  const local = page?.protocol === "http:" && /^(localhost|127\.0\.0\.1)$/.test(page.hostname);
+  const build = (base) => {
+    if (base && local) {
+      const url = new URL(base.toString());
+      Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, String(v)));
+      return url.toString();
+    }
+    return resolveHttpsReturnUrl(base ? base.toString() : null, params);
+  };
+  const full = build(page);
+  if (full.length <= 1024 || !page) return full;
+  const bare = new URL(page.toString());
+  bare.search = "";
+  return build(bare);
+}
 function resolveHttpsReturnUrl(overrideUrl, params = null) {
-  let url = void 0;
+  let url = overrideUrl ?? void 0;
   if (!url && typeof window !== "undefined" && window.location) {
     url = window.location.href;
   }
@@ -3032,23 +3716,45 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     super();
     this.cartManager = cartManager;
     this.state = null;
+    /** Counts `open()` calls — see CheckoutState.session. */
+    this.sessionSeq = 0;
     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;
+    /** Stripe Connect account of the channel, from its Stripe config. */
+    this.stripeConnectAccount = null;
     this.klarnaAvailableCache = null;
     /** Live q1 listeners while a Qliro widget is mounted. */
     this.qliroController = null;
+    /** Live Dibs.Checkout handle while a Nexi widget is mounted. */
+    this.nexiHandle = null;
+    /** Live Drop-in while an Adyen session is mounted. */
+    this.adyenHandle = null;
+    this.stripeHandle = null;
+    /**
+     * The rate the shopper wants. Before an address it is only remembered (the
+     * suggested one, or their pick); every re-pricing asks for it, and the
+     * backend charges it if it reaches the address.
+     */
+    this.nexiPreferredShipping = null;
+    /** The rates offered before an address was typed. */
+    this.nexiShippingPreview = null;
+    /** What the last `address-changed` was priced with — a picked rate re-prices the same address. */
+    this.nexiShippingContext = null;
     this.klarnaOrderInFlight = false;
     /** Last backend shippings fetched (per-supplier), for UI reuse. */
     this.lastFetchedShippings = [];
+    /** See `lastShippingsResolved`. */
+    this.shippingsResolved = false;
     /** 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();
+    this.kustomController = null;
     preloadStripeJs();
   }
   open(sponsorId) {
@@ -3058,6 +3764,7 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     }
     this.state = {
       sponsorId,
+      session: ++this.sessionSeq,
       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.
@@ -3135,6 +3842,20 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
     return getCheckout(checkoutId, opts);
   }
+  /**
+   * The Vio order number (#4497) a checkout became, or null: not born yet,
+   * or an API that does not say it. Never throws — it is a line on a
+   * receipt, and a receipt does not fail for it.
+   */
+  async getOrderNumber(checkoutId, sponsorId) {
+    if (!checkoutId) return null;
+    try {
+      const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
+      return await getCheckoutOrderNumber(checkoutId, opts);
+    } catch {
+      return null;
+    }
+  }
   /**
    * Payment methods enabled for the sponsor (backend-configured). Memoised per
    * sponsor with in-flight dedupe — several UI components ask on every open.
@@ -3174,6 +3895,7 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
    * this at all.
    */
   async fetchAvailableShippings(sponsorId) {
+    this.shippingsResolved = false;
     try {
       const spId = sponsorId ?? this.state?.sponsorId;
       if (!spId) return [];
@@ -3186,6 +3908,7 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
       if (!cartId) return [];
       const opts = await getCartGraphQLOptions(spId);
       const supplierGroups = await getLineItemsBySupplier(cartId, opts);
+      this.shippingsResolved = Array.isArray(supplierGroups);
       const firstGroup = Array.isArray(supplierGroups) ? supplierGroups[0] : null;
       const shippings = firstGroup?.available_shippings ?? [];
       if (Array.isArray(shippings) && shippings.length > 0) {
@@ -3208,6 +3931,10 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
             preselected: idx === 0
           };
         });
+        mapped.sort((a, b) => a.price - b.price);
+        mapped.forEach((m, idx) => {
+          m.preselected = idx === 0;
+        });
         this.lastFetchedShippings = mapped;
         return mapped;
       }
@@ -3218,6 +3945,15 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     }
     return [];
   }
+  /**
+   * Whether the last `fetchAvailableShippings` got an answer from the backend,
+   * possibly an empty one, rather than failing or finding no cart. The two
+   * return the same empty list, and only an answer means the cart has
+   * nothing it can ship with.
+   */
+  get lastShippingsResolved() {
+    return this.shippingsResolved;
+  }
   /** Set the chosen shipping per supplier on the backend cart. */
   async updateShippingsBySupplier(data, sponsorId) {
     const spId = sponsorId ?? this.state?.sponsorId;
@@ -3260,12 +3996,13 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     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("@")) {
+    const hasEmail = !!emailVal && emailVal.includes("@");
+    if (!hasEmail && !isVipps) {
       throw new Error("[CheckoutManager] email is required to start the payment");
     }
     const updateVars = {
       checkoutId,
-      email: emailVal,
+      ...hasEmail ? { email: emailVal } : {},
       buyerAcceptsPurchaseConditions: true,
       buyerAcceptsTermsConditions: true,
       ...extraUpdateVars
@@ -3337,10 +4074,21 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     throw new Error("Stripe payment link generation failed: missing checkout_url");
   }
   /**
-   * Vipps payment link: same flow as Stripe — CreatePaymentVipps → redirect to
-   * payment_url.
+   * Vipps: create the payment via Vio Commerce and redirect to Vipps'
+   * landing page (on a phone it opens the app; on a desktop it offers to
+   * send the payment to the phone).
+   *
+   * `express: true` asks for Vipps Express — address and delivery chosen
+   * inside the app, the email handed back with the payment — which is what
+   * the Vipps buttons on the product and the cart ask for. When the cart
+   * cannot have it (several suppliers, digital goods, no rate for the
+   * country) the backend creates NO payment and answers `express: false`
+   * with the reason; this resolves with that answer, without redirecting,
+   * so the caller can open the ordinary checkout instead. Without the flag
+   * the backend decides: Express while the cart has no delivery yet, a
+   * plain payment once the shopper chose one in our form.
    */
-  async startVippsPayment(sponsorId, formData) {
+  async startVippsPayment(sponsorId, formData, options = {}) {
     const { spId, checkoutId, emailVal, opts } = await this.prepareRedirectPayment(
       sponsorId,
       formData,
@@ -3353,15 +4101,31 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
       checkout_id: checkoutId
     });
     const vippsRes = await createPaymentVipps(
-      { checkoutId, email: emailVal, returnUrl },
+      {
+        checkoutId,
+        ...emailVal && emailVal.includes("@") ? { email: emailVal } : {},
+        returnUrl,
+        ...options.express !== void 0 ? { express: options.express } : {}
+      },
       opts
     );
     if (vippsRes?.payment_url) {
       _CheckoutManager.redirectTo(vippsRes.payment_url);
       return vippsRes;
     }
+    if (options.express === true && vippsRes?.express === false) {
+      return vippsRes;
+    }
     throw new Error("Vipps payment link generation failed: missing payment_url");
   }
+  /**
+   * The Vipps Express button: the shopper taps it and the app opens with
+   * address and delivery already there. Resolves with `{ express: false,
+   * reason }` — and nothing redirected — when this cart cannot have it.
+   */
+  async startVippsExpress(sponsorId) {
+    return this.startVippsPayment(sponsorId, void 0, { express: true });
+  }
   /** 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) {
@@ -3373,7 +4137,7 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
    * and render its html_snippet into `container`. The widget collects
    * address, shipping and payment by itself; the SDK renders nothing else.
    */
-  async mountKustomCheckout(container, sponsorId) {
+  async mountKustomCheckout(container, sponsorId, handlers = {}) {
     const spId = sponsorId ?? this.state?.sponsorId;
     if (!spId) throw new Error("[CheckoutManager] no sponsor for Kustom");
     const cart = this.cartManager.getCart(spId);
@@ -3400,16 +4164,42 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
         checkoutId,
         countryCode: getGlobalCountryCode(),
         href,
-        email: this.state?.address?.email || void 0
+        email: this.state?.address?.email || void 0,
+        client: `web-sdk ${SDK_VERSION}`
       },
       opts
     );
     if (!order?.html_snippet) {
       throw new Error("Kustom order creation failed: missing html_snippet");
     }
+    this.destroyKustomListeners();
     renderKustomSnippet(container, order.html_snippet);
+    this.kustomController = installKustomListeners(handlers);
     return order;
   }
+  /** Disarm the widget's listeners with the widget they belong to. */
+  destroyKustomListeners() {
+    this.kustomController?.destroy();
+    this.kustomController = null;
+  }
+  /**
+   * The cart changed under an open Kustom widget: lock it, push the cart
+   * into the SAME order, and let the widget refresh itself. Kustom's own
+   * rule — never a new order for a cart change. The widget auto-resumes
+   * after 10 s if the sync never comes back.
+   */
+  async syncKustomOrder(sponsorId) {
+    const spId = sponsorId ?? this.state?.sponsorId;
+    const checkoutId = this.state?.checkoutId;
+    if (!spId || !checkoutId) return null;
+    const opts = await getCartGraphQLOptions(spId);
+    suspendKustom();
+    try {
+      return await syncPaymentKustom(checkoutId, opts);
+    } finally {
+      resumeKustom();
+    }
+  }
   /** Re-read a Kustom order — used on the confirmation return trip. */
   async getKustomOrder(orderId, sponsorId) {
     const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
@@ -3560,6 +4350,344 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
     return getWalleyOrder(checkoutId, opts);
   }
+  /**
+   * Mount the Nexi embedded checkout — Nexi's own JS SDK, not a snippet.
+   *
+   * `onCompleted` fires on Nexi's `payment-completed` (no redirect: Nexi
+   * renders no receipt, the component shows Vio's confirmation). Shipping is
+   * Vio's: Nexi holds its pay button until `address-changed` has been
+   * re-priced through `UpdateNexiShipping` — the widget is frozen meanwhile
+   * and `onShipping` reports the outcome (NO_SHIPPING keeps it held).
+   *
+   * A session interrupted by a third-party redirect inside Nexi (Vipps,
+   * Swish, MobilePay) is remembered in sessionStorage and resumed on the
+   * same paymentId instead of creating a new payment — only when `resume`
+   * names it. Every other opening creates a payment for the cart as it is.
+   */
+  async mountNexiCheckout(container, sponsorId, handlers = {}, resume) {
+    const spId = sponsorId ?? this.state?.sponsorId;
+    if (!spId) throw new Error("[CheckoutManager] no sponsor for Nexi");
+    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);
+    const stored = resume ? readNexiPending() : null;
+    const pending2 = stored && stored.paymentId === resume?.paymentId ? stored : null;
+    let checkoutId = this.state?.checkoutId;
+    if (!checkoutId && pending2 && pending2.sponsorId === spId) {
+      checkoutId = pending2.checkoutId;
+      if (this.state) this.state = { ...this.state, checkoutId };
+    }
+    if (!checkoutId) {
+      const checkoutRes = await this.createCheckout(spId);
+      checkoutId = checkoutRes?.id;
+      if (checkoutId && this.state) {
+        this.state = { ...this.state, checkoutId };
+      }
+    }
+    if (!checkoutId) {
+      throw new Error("[CheckoutManager] no backend checkout for the Nexi payment");
+    }
+    const ownedCheckoutId = checkoutId;
+    let order = null;
+    if (pending2 && pending2.checkoutId === ownedCheckoutId) {
+      try {
+        order = await getNexiOrder(ownedCheckoutId, opts);
+      } catch {
+        order = null;
+      }
+      if (order && isNexiPaid(order.status)) {
+        clearNexiPending();
+        handlers.onCompleted?.(order);
+        return order;
+      }
+      if (order && (order.status !== "Created" || order.order_id !== pending2.paymentId)) {
+        order = null;
+      }
+    }
+    if (!order) {
+      const created = await createPaymentNexi(
+        {
+          checkoutId: ownedCheckoutId,
+          countryCode: getGlobalCountryCode(),
+          href: kustomCleanHref(),
+          email: this.state?.address?.email || void 0
+        },
+        opts
+      );
+      if (!created?.order_id || !created.checkout_key) {
+        throw new Error("Nexi payment creation failed: missing paymentId/checkout key");
+      }
+      order = created;
+      rememberNexiPending({ checkoutId: ownedCheckoutId, sponsorId: spId, paymentId: order.order_id });
+    }
+    this.destroyNexi();
+    const handle = await mountNexi(container, order, {
+      language: nexiLanguageFor(getGlobalCountryCode()),
+      theme: nexiThemeFrom(readVioTheme())
+    });
+    this.nexiHandle = handle;
+    const mounted = order;
+    const carried = order.shipping;
+    this.nexiPreferredShipping = carried?.shipping_id ?? null;
+    this.nexiShippingPreview = null;
+    if (carried?.ok && carried.country) {
+      this.nexiShippingContext = {
+        handle,
+        checkoutId: ownedCheckoutId,
+        address: { countryCode: carried.country, postalCode: carried.postal_code },
+        fromShopper: carried.address_source !== "market",
+        opts,
+        onShipping: handlers.onShipping
+      };
+      handlers.onShipping?.(carried);
+    } else if (carried?.reason === "AWAITING_ADDRESS") {
+      this.nexiShippingPreview = carried;
+      this.nexiShippingContext = {
+        handle,
+        checkoutId: ownedCheckoutId,
+        address: null,
+        opts,
+        onShipping: handlers.onShipping
+      };
+      handlers.onShipping?.(carried);
+    }
+    const onAddress = (address) => {
+      this.nexiShippingContext = {
+        handle,
+        checkoutId: ownedCheckoutId,
+        address,
+        fromShopper: true,
+        opts,
+        onShipping: handlers.onShipping
+      };
+      void this.repriceNexiShipping(
+        handle,
+        ownedCheckoutId,
+        address,
+        opts,
+        handlers.onShipping,
+        this.nexiPreferredShipping ?? void 0
+      );
+    };
+    handle.on("address-changed", onAddress);
+    handle.on("applepay-contact-updated", onAddress);
+    handle.on("pay-initialized", () => {
+      void this.finalizeNexiPayment(handle, ownedCheckoutId, opts, handlers.onShipping);
+    });
+    handle.on("payment-completed", (result) => {
+      clearNexiPending();
+      handlers.onCompleted?.({
+        ...mounted,
+        order_id: String(result?.paymentId ?? mounted.order_id),
+        status: "Reserved"
+      });
+    });
+    return order;
+  }
+  /**
+   * The shopper picked another rate from the `options` Nexi's last
+   * re-pricing returned: charge that one instead. Nexi has no shipping picker,
+   * so the checkout shows the rates and calls this. A no-op until an address
+   * has been typed in the widget.
+   */
+  async pickNexiShipping(shippingId) {
+    const ctx = this.nexiShippingContext;
+    if (!ctx || ctx.handle !== this.nexiHandle) return;
+    this.nexiPreferredShipping = shippingId;
+    if (!ctx.address) {
+      const preview = this.nexiShippingPreview;
+      const picked = preview?.options?.find((o) => o.id === shippingId);
+      if (preview && picked) {
+        this.nexiShippingPreview = {
+          ...preview,
+          shipping_id: picked.id,
+          shipping_name: picked.name,
+          shipping_price: picked.price
+        };
+        ctx.onShipping?.(this.nexiShippingPreview);
+      }
+      return;
+    }
+    await this.repriceNexiShipping(ctx.handle, ctx.checkoutId, ctx.address, ctx.opts, ctx.onShipping, shippingId);
+  }
+  /**
+   * `pay-initialized` → confirm the shipping for the address Nexi will ship
+   * to → `payment-order-finalized`.
+   *
+   * The payment already carries a shipping (set at creation, re-priced on
+   * every address and pick), so normally nothing changes and Nexi charges.
+   * When the shopper's address was never announced — Nexi fills it in for a
+   * shopper it recognises — the backend reads it from the payment. If that
+   * changes the amount, the payment is STOPPED and the widget reloaded: an
+   * amount that changes while Nexi charges is what failed on 2026-09-16/17
+   * (payments 085277846ae44f7498ae94e112435d63, f6116e6d68294a88927d35b05d907f10).
+   */
+  async finalizeNexiPayment(handle, checkoutId, opts, onShipping) {
+    const ctx = this.nexiShippingContext?.handle === handle ? this.nexiShippingContext : null;
+    const address = ctx?.fromShopper ? ctx.address : null;
+    let proceed = false;
+    let reload = false;
+    try {
+      const result = await updateNexiShipping(
+        {
+          checkoutId,
+          countryCode: String(address?.countryCode ?? address?.country ?? ""),
+          postalCode: address?.postalCode ? String(address.postalCode) : void 0,
+          shippingId: this.nexiPreferredShipping ?? void 0
+        },
+        opts
+      );
+      if (result?.ok) {
+        if (result.shipping_id) this.nexiPreferredShipping = result.shipping_id;
+        if (ctx && result.country) {
+          ctx.address = { countryCode: result.country, postalCode: result.postal_code };
+          ctx.fromShopper = true;
+        }
+        reload = result.changed === true;
+        proceed = !reload;
+      }
+      onShipping?.(result ? { ...result, ...reload ? { repriced_at_pay: true } : {} } : result);
+    } catch (err) {
+      onShipping?.(null, err);
+    }
+    try {
+      handle.send?.("payment-order-finalized", proceed);
+    } catch {
+    }
+    if (reload) {
+      try {
+        handle.thawCheckout();
+      } catch {
+      }
+    }
+  }
+  /** address-changed → freeze → UpdateNexiShipping → thaw. */
+  async repriceNexiShipping(handle, checkoutId, address, opts, onShipping, shippingId) {
+    const countryCode = String(address?.countryCode ?? address?.country ?? "");
+    if (!countryCode) return;
+    try {
+      handle.freezeCheckout();
+    } catch {
+    }
+    try {
+      const result = await updateNexiShipping(
+        {
+          checkoutId,
+          countryCode,
+          postalCode: address?.postalCode ? String(address.postalCode) : void 0,
+          shippingId
+        },
+        opts
+      );
+      if (result?.ok && result.shipping_id) this.nexiPreferredShipping = result.shipping_id;
+      onShipping?.(result);
+    } catch (err) {
+      onShipping?.(null, err);
+    } finally {
+      try {
+        handle.thawCheckout();
+      } catch {
+      }
+    }
+  }
+  /** Release the Dibs.Checkout listeners with the widget they belong to. */
+  destroyNexi() {
+    try {
+      this.nexiHandle?.cleanup();
+    } catch {
+    }
+    this.nexiHandle = null;
+    this.nexiShippingContext = null;
+    this.nexiPreferredShipping = null;
+    this.nexiShippingPreview = null;
+  }
+  /** Re-read the Nexi payment owned by a checkout. */
+  async getNexiOrder(checkoutId, sponsorId) {
+    const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
+    return getNexiOrder(checkoutId, opts);
+  }
+  /**
+   * Adyen: FORM-FIRST. Saves the shopper's form and shipping pick on the
+   * checkout (Adyen collects neither), creates a session with that final
+   * amount and mounts Adyen's Drop-in on it. A session is never updated —
+   * after ANY change the caller destroys this mount and calls again.
+   *
+   * At "Pay" the backend only confirms that the session still pays for the
+   * checkout; when it does not, Adyen is stopped and `onReplaced` tells the
+   * caller to remount. Completion is asked of Adyen through the backend
+   * (`GetAdyenPayment`) — the browser's own result is never the answer.
+   */
+  async mountAdyenCheckout(container, sponsorId, formData, callbacks) {
+    this.destroyAdyen();
+    const { spId, checkoutId, emailVal, opts } = await this.prepareRedirectPayment(
+      sponsorId,
+      formData,
+      { paymentMethod: "Adyen" }
+    );
+    const session = await createPaymentAdyen(
+      {
+        checkoutId,
+        returnUrl: adyenReturnUrl({
+          vio_payment: "return",
+          vio_method: ADYEN_RETURN_METHOD,
+          vio_sponsor: spId,
+          checkout_id: checkoutId
+        }),
+        countryCode: getGlobalCountryCode(),
+        channel: "Web",
+        email: emailVal,
+        client: `web-sdk ${SDK_VERSION}`
+      },
+      opts
+    );
+    if (!session?.session_id) {
+      throw new Error("[CheckoutManager] Adyen session was not created");
+    }
+    const theme = readVioTheme();
+    this.adyenHandle = await mountAdyen(
+      container,
+      session,
+      {
+        onBeforePay: async () => {
+          const verdict = await confirmAdyenPayment(
+            { checkoutId, sessionId: session.session_id },
+            opts
+          );
+          if (verdict?.ok === true) return true;
+          callbacks.onReplaced(String(verdict?.reason ?? "UNKNOWN"));
+          return false;
+        },
+        onCompleted: (result) => {
+          void getAdyenPayment({ checkoutId, sessionResult: result?.sessionResult }, opts).catch(() => null).then((payment) => callbacks.onCompleted(payment, session));
+        },
+        onFailed: (result) => callbacks.onFailed(result, session),
+        onError: (error) => callbacks.onError?.(error)
+      },
+      { theme: { accent: theme?.accent, radiusMd: theme?.radiusMd } }
+    );
+    return session;
+  }
+  /** Unmount Drop-in. Safe to call when nothing is mounted. */
+  destroyAdyen() {
+    try {
+      this.adyenHandle?.unmount();
+    } catch {
+    }
+    this.adyenHandle = null;
+  }
+  /**
+   * Outcome of the Adyen session a checkout owns. With `redirectResult` (the
+   * return from Vipps, Klarna, Trustly or a redirect-3DS) the redirect is
+   * finalised on the server.
+   */
+  async getAdyenPayment(checkoutId, proof = {}, sponsorId) {
+    const opts = await getCartGraphQLOptions(sponsorId ?? this.state?.sponsorId);
+    return getAdyenPayment({ checkoutId, ...proof }, opts);
+  }
   /* eslint-enable @typescript-eslint/no-explicit-any */
   setAddress(address) {
     if (!this.state) return;
@@ -3577,6 +4705,83 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     );
   }
   // MARK: - Apple Pay (Stripe Payment Request)
+  /**
+   * Which Stripe flow this channel offers: `native` pays on our own page,
+   * `link` sends the shopper to a page hosted by Stripe. The channel's two
+   * toggles decide it and the answer travels in the method's config
+   * (api-microservice, `stripe-offer.ts`). A channel that predates that
+   * field answers `link`, which is what every client did before.
+   */
+  /**
+   * Does this channel's Vipps offer Express — the buy-now buttons that open
+   * the app with address and delivery? Vio Commerce announces it as
+   * `config.express` on the Vipps method, the way Stripe announces `mode`;
+   * the seller switches it on its Vipps row. Unknown means yes: Express is
+   * the default, and the backend refuses it with a reason if it cannot.
+   */
+  async getVippsExpressEnabled(sponsorId) {
+    try {
+      const methods = await this.getAvailablePaymentMethods(sponsorId);
+      const vipps = methods?.find((m) => String(m?.name ?? "").toLowerCase() === "vipps");
+      const express = vipps?.config?.find((c) => c?.name === "express")?.value;
+      return express !== "false";
+    } catch {
+      return true;
+    }
+  }
+  async getStripeMode(sponsorId) {
+    try {
+      const methods = await this.getAvailablePaymentMethods(sponsorId);
+      const stripe = methods?.find((m) => String(m?.name ?? "").toLowerCase() === "stripe");
+      const mode = stripe?.config?.find((c) => c?.name === "mode")?.value;
+      return mode === "native" ? "native" : "link";
+    } catch {
+      return "link";
+    }
+  }
+  /**
+   * Stripe's Payment Element, mounted on our own page for a checkout that is
+   * ready to be paid. Creating it mints a PaymentIntent, so it happens when
+   * the shopper asks for the payment step, never while they type.
+   *
+   * The order is not born here: `confirm()` only says what Stripe told the
+   * browser. The `payment_intent.succeeded` webhook creates it server-side,
+   * and the caller then reads the checkout to see it land.
+   */
+  async mountStripeCheckout(container, sponsorId, formData, callbacks) {
+    this.destroyStripe();
+    const { spId, checkoutId, opts } = await this.prepareRedirectPayment(sponsorId, formData, {
+      paymentMethod: "Stripe"
+    });
+    const minted = await createStripeIntent(checkoutId, opts);
+    if (!minted?.client_secret) {
+      throw new Error("[CheckoutManager] Stripe payment was not created");
+    }
+    const account = minted.stripe_account ?? await this.resolveStripeConnectAccount(spId);
+    const intent = account ? { ...minted, stripe_account: account } : minted;
+    const theme = readVioTheme();
+    const handle = await mountStripeElement(container, intent, {
+      returnUrl: resolveHttpsReturnUrl(null, {
+        vio_payment: "success",
+        vio_method: "stripe",
+        vio_sponsor: spId,
+        checkout_id: checkoutId
+      }),
+      theme: { accent: theme?.accent, radiusMd: theme?.radiusMd },
+      onReady: callbacks?.onReady,
+      onLoadError: callbacks?.onLoadError
+    });
+    this.stripeHandle = handle;
+    return { handle, intent, checkoutId };
+  }
+  /** Unmount the Payment Element. Safe when nothing is mounted. */
+  destroyStripe() {
+    try {
+      this.stripeHandle?.unmount();
+    } catch {
+    }
+    this.stripeHandle = null;
+  }
   /**
    * The Stripe publishable key for a sponsor, taken from its own commerce
    * channel (`GetAvailablePaymentMethods` → Stripe → config.publishableKey).
@@ -3594,6 +4799,8 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
       const methods = await this.getAvailablePaymentMethods(sponsorId);
       const stripe = methods?.find((m) => String(m?.name ?? "").toLowerCase() === "stripe");
       const key = stripe?.config?.find((c) => c?.name === "publishableKey")?.value;
+      const account = stripe?.config?.find((c) => c?.name === "stripeAccount")?.value;
+      this.stripeConnectAccount = typeof account === "string" && account.startsWith("acct_") ? account : null;
       if (typeof key === "string" && key.startsWith("pk_")) {
         this.applePayPublishableKey = key;
         return key;
@@ -4217,9 +5424,9 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     if (typeof sessionStorage === "undefined") return;
     const raw = sessionStorage.getItem(KLARNA_PENDING_KEY);
     if (!raw) return;
-    let pending;
+    let pending2;
     try {
-      pending = JSON.parse(raw);
+      pending2 = JSON.parse(raw);
     } catch {
       sessionStorage.removeItem(KLARNA_PENDING_KEY);
       return;
@@ -4227,7 +5434,7 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     const fromUrl = readKlarnaTokenFromUrl();
     if (fromUrl) {
       cleanUrlParams([fromUrl.param]);
-      await this.completeKlarnaOrder(fromUrl.token, pending, { authorizationToken: fromUrl.token });
+      await this.completeKlarnaOrder(fromUrl.token, pending2, { authorizationToken: fromUrl.token });
       return;
     }
     if (typeof window !== "undefined" && typeof console !== "undefined" && window.location.search) {
@@ -4241,7 +5448,7 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
     await listenForKlarnaCompletion({
       config: { clientId: cfg.klarnaClientId, locale: getGlobalLocale(), environment: cfg.klarnaEnvironment },
       onComplete: (result) => {
-        void this.completeKlarnaOrder(result.authorizationToken, pending, result);
+        void this.completeKlarnaOrder(result.authorizationToken, pending2, result);
       },
       onError: (err) => {
         if (typeof console !== "undefined") {
@@ -4354,7 +5561,18 @@ var CheckoutManager = class _CheckoutManager extends EventTarget {
    * (Stripe will route to the platform account in that case).
    */
   findStripeConnectAccount() {
-    return void 0;
+    return this.stripeConnectAccount ?? void 0;
+  }
+  /** The sponsor's connected account, read fresh from its channel config. */
+  async resolveStripeConnectAccount(sponsorId) {
+    try {
+      const methods = await this.getAvailablePaymentMethods(sponsorId);
+      const stripe = methods?.find((m) => String(m?.name ?? "").toLowerCase() === "stripe");
+      const account = stripe?.config?.find((c) => c?.name === "stripeAccount")?.value;
+      return typeof account === "string" && account.startsWith("acct_") ? account : void 0;
+    } catch {
+      return void 0;
+    }
   }
   emit() {
     this.dispatchEvent(
@@ -4368,9 +5586,6 @@ function toSmallestUnit(amount, currency) {
   return Math.round(amount * 100);
 }
 
-// src/core/version.ts
-var SDK_VERSION = "0.11.0";
-
 // src/core/analytics/analytics-manager.ts
 var SESSION_TTL_MS = 30 * 60 * 1e3;
 var FLUSH_INTERVAL_MS = 5e3;
@@ -4997,7 +6212,7 @@ var VioFacade = class {
     return this.analyticsManager;
   }
   // MARK: - Backend-bound
-  /** Lazy VioApi for REST endpoints on `api-dev.vio.live`. */
+  /** Lazy VioApi for REST endpoints on `api-staging.vio.live`. */
   get api() {
     if (!this.apiInstance) {
       const cfg = Configuration.get();
@@ -5065,6 +6280,55 @@ var VioFacade = class {
 var _vioGlobal = globalThis;
 var Vio = _vioGlobal.__VIO_FACADE__ ?? (_vioGlobal.__VIO_FACADE__ = new VioFacade());
 
-export { ADD_ITEM_MUTATION, AnalyticsManager, 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, SDK_VERSION, 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-U2QG4IVJ.js.map
-//# sourceMappingURL=chunk-U2QG4IVJ.js.map
+// src/core/checkout/payments/vipps-button.ts
+var VIPPS_BUTTON_SCRIPT = "https://cdn.vippsmobilepay.com/js/button/button.js";
+var VIPPS_BUTTON_TAG = "vipps-mobilepay-button";
+var pending = null;
+function ensureVippsButton(timeoutMs = 0) {
+  if (typeof document === "undefined" || typeof customElements === "undefined") {
+    return Promise.resolve(false);
+  }
+  if (customElements.get(VIPPS_BUTTON_TAG)) return Promise.resolve(true);
+  if (!pending) {
+    pending = new Promise((resolve) => {
+      let settled = false;
+      const done = (ok) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        resolve(ok);
+      };
+      const timer = timeoutMs > 0 ? setTimeout(() => done(false), timeoutMs) : void 0;
+      customElements.whenDefined(VIPPS_BUTTON_TAG).then(
+        () => done(true),
+        () => done(false)
+      );
+      if (!document.querySelector(`script[src="${VIPPS_BUTTON_SCRIPT}"]`)) {
+        const script = document.createElement("script");
+        script.async = true;
+        script.src = VIPPS_BUTTON_SCRIPT;
+        script.onerror = () => done(false);
+        document.head.appendChild(script);
+      }
+    });
+    void pending.then((ok) => {
+      if (!ok) pending = null;
+    });
+  }
+  return pending;
+}
+function vippsButtonAttributes(verb = "buy", opts = {}) {
+  return {
+    brand: "vipps",
+    language: opts.language ?? "no",
+    verb,
+    variant: "primary",
+    rounded: "true",
+    stretched: opts.stretched === false ? "false" : "true",
+    ...opts.compact ? { compact: "true" } : {}
+  };
+}
+
+export { ADD_ITEM_MUTATION, ADYEN_RETURN_METHOD, ADYEN_RETURN_QUERY_KEYS, AdyenOriginError, AnalyticsManager, 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, KUSTOM_RETURN_QUERY_KEYS, SDK_VERSION, UPDATE_CHECKOUT_MUTATION, UPDATE_ITEM_MUTATION, UPDATE_SHIPPINGS_BY_SUPPLIER_MUTATION, VIPPS_BUTTON_SCRIPT, VIPPS_BUTTON_TAG, Vio, VioApi, VioApiError, __decorateClass, addItem, adyenReturnOutcome, adyenReturnParams, checkApplePayAvailability, createCart, createCheckout, createCommerceClient, createPaymentStripe, createPaymentVipps, createVioApi, deleteItem, displayPrice, ensureVippsButton, executeCartGraphQL, formatPrice, getAvailablePaymentMethods, getCart, getCartGraphQLOptions, getCheckout, getCustomerSessionId, getGlobalCurrency, getLineItemsBySupplier, getVippsStatus, kustomReturnOutcome, nexiReturnPaymentId, primaryImageUrl, readNexiPending, showApplePaySheet, updateCheckout, updateItem, updateShippingsBySupplier, vippsButtonAttributes };
+//# sourceMappingURL=chunk-CMNTHF66.js.map
+//# sourceMappingURL=chunk-CMNTHF66.js.map