@tagadapay/headless-sdk 1.14.1 → 1.17.0

package/dist/tagada-headless.js

@@ -1,5 +1,5 @@
 /**
- * @tagadapay/headless-sdk v1.14.1
+ * @tagadapay/headless-sdk v1.17.0
  * Headless checkout, payments, offers, and CRM
  * @license MIT
  */
@@ -48,6 +48,8 @@ var TagadaHeadlessBundle = (() => {
     CheckoutModule: () => CheckoutModule,
     CurrencyUtils: () => CurrencyUtils,
     CustomerModule: () => CustomerModule,
+    CustomerPortalModule: () => CustomerPortalModule,
+    ExperimentsModule: () => ExperimentsModule,
     FunnelModule: () => FunnelModule,
     GoogleAutocompleteCore: () => GoogleAutocompleteCore,
     HeadlessClient: () => HeadlessClient,
@@ -63,6 +65,7 @@ var TagadaHeadlessBundle = (() => {
     TagadaPaymentError: () => TagadaPaymentError,
     TagadaRateLimitError: () => TagadaRateLimitError,
     TagadaValidationError: () => TagadaValidationError,
+    TrackModule: () => TrackModule,
     createHeadlessClient: () => createHeadlessClient,
     ensureGeoDataLoaded: () => ensureGeoDataLoaded,
     formatMoney: () => formatMoney,
@@ -137,6 +140,7 @@ var TagadaHeadlessBundle = (() => {
       this.timeout = config.timeout;
       this.apiKey = config.apiKey;
       this.getToken = config.getToken;
+      this.redirect = config.redirect;
     }
     static resolveBaseUrl(environment, override) {
       return override ?? BASE_URLS[environment] ?? BASE_URLS.production;
@@ -144,7 +148,7 @@ var TagadaHeadlessBundle = (() => {
     async request(path, options = {}) {
       var _a;
       const { method = "GET", body, headers = {}, params, token, signal } = options;
-      let url = `${this.baseUrl}${path}`;
+      let url2 = `${this.baseUrl}${path}`;
       if (params) {
         const qs = new URLSearchParams();
         for (const [k, v] of Object.entries(params)) {
@@ -153,7 +157,7 @@ var TagadaHeadlessBundle = (() => {
         }
         const str = qs.toString();
         if (str)
-          url += `?${str}`;
+          url2 += `?${str}`;
       }
       const reqHeaders = {
         "Content-Type": "application/json",
@@ -166,11 +170,12 @@ var TagadaHeadlessBundle = (() => {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), this.timeout);
       try {
-        const res = await fetch(url, {
+        const res = await fetch(url2, {
           method,
           headers: reqHeaders,
           body: body != null ? JSON.stringify(body) : void 0,
-          signal: signal ?? controller.signal
+          signal: signal ?? controller.signal,
+          ...this.redirect && { redirect: this.redirect }
         });
         clearTimeout(timeoutId);
         if (res.ok) {
@@ -212,8 +217,8 @@ var TagadaHeadlessBundle = (() => {
         parsed = await res.json();
       } catch {
       }
-      const data = parsed.data ?? {};
-      const msg = parsed.message ?? parsed.error ?? (typeof data.message === "string" ? data.message : void 0) ?? (typeof parsed.data === "string" ? parsed.data : void 0) ?? `Request failed: ${res.status} ${res.statusText} on ${path}`;
+      const data = parseErrorData(parsed.data);
+      const msg = parsed.message || parsed.error || (typeof data.message === "string" ? data.message : void 0) || (typeof parsed.data === "string" && Object.keys(data).length === 0 ? parsed.data : void 0) || `Request failed: ${res.status} ${res.statusText} on ${path}`;
       const appCode = typeof data.code === "string" ? data.code : void 0;
       switch (res.status) {
         case 401:
@@ -234,13 +239,26 @@ var TagadaHeadlessBundle = (() => {
       }
     }
   };
+  function parseErrorData(value) {
+    if (value && typeof value === "object")
+      return value;
+    if (typeof value !== "string")
+      return {};
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
 
   // src/core/modules/checkout.ts
   var CheckoutModule = class _CheckoutModule {
-    constructor(http, storeId, onTokenChange) {
+    constructor(http, storeId, onTokenChange, onSession) {
       this.http = http;
       this.storeId = storeId;
       this.onTokenChange = onTokenChange;
+      this.onSession = onSession;
     }
     /**
      * Returns the most recently loaded `CheckoutSession`, if any.
@@ -264,7 +282,7 @@ var TagadaHeadlessBundle = (() => {
      * Example URL: `/checkout?checkoutToken=abc123&token=eyJ...`
      */
     async loadSession(checkoutToken, sessionToken, opts) {
-      var _a;
+      var _a, _b;
       if (sessionToken) {
         this.sessionToken = sessionToken;
         (_a = this.onTokenChange) == null ? void 0 : _a.call(this, sessionToken);
@@ -282,6 +300,10 @@ var TagadaHeadlessBundle = (() => {
       );
       const session = this.normalizeSession(raw);
       this._currentSession = session;
+      try {
+        (_b = this.onSession) == null ? void 0 : _b.call(this, session);
+      } catch {
+      }
       return session;
     }
     /**
@@ -295,6 +317,9 @@ var TagadaHeadlessBundle = (() => {
       const lineItems = opts.items.map((i) => ({
         variantId: i.variantId,
         priceId: i.priceId,
+        ...i.sellingPlanId !== void 0 ? { sellingPlanId: i.sellingPlanId } : {},
+        ...i.trialDays !== void 0 ? { trialDays: i.trialDays } : {},
+        ...i.trialPrice !== void 0 ? { trialPrice: i.trialPrice } : {},
         quantity: i.quantity
       }));
       const body = {
@@ -303,6 +328,8 @@ var TagadaHeadlessBundle = (() => {
       };
       if (opts.returnUrl)
         body.returnUrl = opts.returnUrl;
+      if (opts.funnelSessionId)
+        body.funnelSessionId = opts.funnelSessionId;
       if ((_a = opts.discountCodes) == null ? void 0 : _a.length)
         body.discountCodes = opts.discountCodes;
       if (opts.metadata && Object.keys(opts.metadata).length > 0)
@@ -324,8 +351,8 @@ var TagadaHeadlessBundle = (() => {
         body.customer = customerData;
       }
       const res = await this.http.post("/api/v1/checkout/session/init", body);
-      const url = new URL(res.checkoutUrl);
-      const sessionToken = url.searchParams.get("token") ?? "";
+      const url2 = new URL(res.checkoutUrl);
+      const sessionToken = url2.searchParams.get("token") ?? "";
       this.sessionToken = sessionToken;
       if (sessionToken)
         (_c = this.onTokenChange) == null ? void 0 : _c.call(this, sessionToken);
@@ -366,8 +393,8 @@ var TagadaHeadlessBundle = (() => {
         checkoutToken: session.checkoutToken,
         sessionToken: session.sessionToken
       });
-      const url = `${origin}${checkoutPath}?${params.toString()}`;
-      return { ...session, url };
+      const url2 = `${origin}${checkoutPath}?${params.toString()}`;
+      return { ...session, url: url2 };
     }
     /**
      * Read `checkoutToken` and session token from a URL.
@@ -392,10 +419,10 @@ var TagadaHeadlessBundle = (() => {
      * );
      * ```
      */
-    static parseTokensFromUrl(url) {
-      if (typeof url === "undefined" && typeof window === "undefined")
+    static parseTokensFromUrl(url2) {
+      if (typeof url2 === "undefined" && typeof window === "undefined")
         return null;
-      const href = url ?? window.location.href;
+      const href = url2 ?? window.location.href;
       let parsed;
       try {
         parsed = new URL(href);
@@ -409,8 +436,8 @@ var TagadaHeadlessBundle = (() => {
       return { checkoutToken, sessionToken };
     }
     /** Instance alias of {@link CheckoutModule.parseTokensFromUrl}. */
-    parseTokensFromUrl(url) {
-      return _CheckoutModule.parseTokensFromUrl(url);
+    parseTokensFromUrl(url2) {
+      return _CheckoutModule.parseTokensFromUrl(url2);
     }
     /**
      * Add or update cart items on an existing session (upsert by product).
@@ -434,6 +461,7 @@ var TagadaHeadlessBundle = (() => {
       const lineItems = items.map((i) => ({
         variantId: i.variantId,
         priceId: i.priceId,
+        ...i.sellingPlanId !== void 0 ? { sellingPlanId: i.sellingPlanId } : {},
         quantity: i.quantity
       }));
       return this.http.post(
@@ -640,7 +668,13 @@ var TagadaHeadlessBundle = (() => {
           unitAmount: amount,
           totalAmount: amount * (li.quantity ?? 1),
           currency: sessionCurrency ?? "USD",
-          imageUrl: variant.imageUrl ?? product.imageUrl ?? ""
+          imageUrl: variant.imageUrl ?? product.imageUrl ?? "",
+          ...(price == null ? void 0 : price.recurring) ? {
+            recurring: {
+              interval: price.interval ?? "month",
+              intervalCount: price.intervalCount ?? 1
+            }
+          } : {}
         };
       });
       const summaryItems = summary.items ?? [];
@@ -751,6 +785,407 @@ var TagadaHeadlessBundle = (() => {
     return Boolean(((_a = address.line1) == null ? void 0 : _a.trim()) && ((_b = address.country) == null ? void 0 : _b.trim()));
   }
 
+  // src/core/version.ts
+  var SDK_NAME = "headless";
+  var SDK_VERSION = "1.17.0";
+
+  // src/core/modules/track.ts
+  var CDN_URL = false ? "" : "https://cdn.jsdelivr.net/npm/@tagadapay/headless-sdk@1.17.0/dist/tagada-pixels.min.js";
+  function loadScript(src, isReady) {
+    if (isReady())
+      return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const script2 = document.createElement("script");
+      script2.src = src;
+      script2.async = true;
+      script2.onload = () => resolve();
+      script2.onerror = () => reject(new Error("runtime script failed to load"));
+      document.head.appendChild(script2);
+    });
+  }
+  async function loadPixels() {
+    if (typeof window === "undefined")
+      return null;
+    if (CDN_URL) {
+      const w = window;
+      if (w.TagadaPixels)
+        return w.TagadaPixels;
+      await loadScript(CDN_URL, () => Boolean(w.TagadaPixels));
+      return w.TagadaPixels ?? null;
+    }
+    return await import("../../pixels/index.js");
+  }
+  var FLAG_KEY = "__tgd_track";
+  var ANON_KEY = "__tgd_aid";
+  var SESSION_KEY = "__tgd_sid";
+  var QUEUE_LIMIT = 50;
+  var FLUSH_MS = 2e3;
+  var DEDUP_MS = 1e3;
+  var STEP_MEMORY = 64;
+  function toContents(items) {
+    if (!Array.isArray(items) || items.length === 0)
+      return void 0;
+    return items.map((item) => ({ id: item.variantId, quantity: item.quantity, item_price: item.unitAmount }));
+  }
+  function scalars(data) {
+    if (!data)
+      return void 0;
+    const out = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        out[key] = value;
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+  }
+  var STANDARD_EVENTS = {
+    lead: "Lead",
+    product_viewed: "ViewContent",
+    added_to_cart: "AddToCart"
+  };
+  function uuid() {
+    try {
+      return crypto.randomUUID();
+    } catch {
+      return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+  }
+  function toPixelsConfig(pixels) {
+    const out = {};
+    for (const pixel of pixels) {
+      const { provider, id, idKey, ...rest } = pixel;
+      (out[provider] ?? (out[provider] = [])).push({ ...rest, enabled: true, [idKey]: id, events: pixel.events ?? {} });
+    }
+    return out;
+  }
+  var TrackModule = class {
+    constructor(baseUrl, storeId, funnelKey) {
+      this.baseUrl = baseUrl;
+      this.storeId = storeId;
+      this.funnelKey = funnelKey;
+      this.records = [];
+      this.lastStep = /* @__PURE__ */ new Map();
+      this.signals = [];
+      this.currentStepId = null;
+      this.manifestHash = null;
+      this.loadedProviders = [];
+      this.configPromise = null;
+      this.corePromise = null;
+      this.enginePromise = null;
+      this.flushTimer = null;
+      this.listening = false;
+    }
+    // -- opt-in flag ----------------------------------------------------------
+    /**
+     * The flag is `<storeId>:<funnelKey>`. Only the storeId half arms it; the funnel half is DATA,
+     * read back by `flagFunnelKey()` so automatic events report the funnel the last `step()` named.
+     * A funnel-key mismatch never disarms tracking; only another tenant's storeId reads as disabled.
+     */
+    flag() {
+      try {
+        return (localStorage.getItem(FLAG_KEY) ?? "").split(":");
+      } catch {
+        return [];
+      }
+    }
+    enabled() {
+      return this.flag()[0] === this.storeId;
+    }
+    flagFunnelKey() {
+      return this.flag()[1] || this.funnelKey;
+    }
+    /** Every automatic path is off under SSR and off without the flag. */
+    off() {
+      return typeof window === "undefined" || !this.enabled();
+    }
+    arm() {
+      try {
+        localStorage.setItem(FLAG_KEY, `${this.storeId}:${this.funnelKey}`);
+      } catch {
+      }
+    }
+    // -- public API -----------------------------------------------------------
+    step(stepId, data) {
+      if (typeof window === "undefined")
+        return;
+      this.arm();
+      const path = (data == null ? void 0 : data.path) ?? window.location.pathname;
+      const key = `${stepId}|${path}`;
+      const at = Date.now();
+      const previous = this.lastStep.get(key);
+      if (previous !== void 0 && at - previous < DEDUP_MS)
+        return;
+      this.remember(key, at);
+      this.currentStepId = stepId;
+      this.listen();
+      this.push({ kind: "step", stepId, at, path });
+      void this.pixels().then((engine) => engine == null ? void 0 : engine.pageView(path, { stepId }));
+      void this.core().then((t) => t == null ? void 0 : t.page({ step_id: stepId })).catch(() => void 0);
+    }
+    event(name, data) {
+      if (this.off())
+        return;
+      const stepId = this.currentStepId;
+      if (stepId === null)
+        return;
+      const standard = STANDARD_EVENTS[name];
+      const eventId = `${standard ?? name}_${uuid()}`;
+      this.push({ kind: "event", stepId, name, at: Date.now(), eventId, props: scalars(data) });
+      void this.pixels().then(
+        (engine) => standard ? engine == null ? void 0 : engine.track(standard, data, { stepId, eventId }) : engine == null ? void 0 : engine.trackCustom(name, data, { stepId })
+      );
+      void this.core().then((t) => t == null ? void 0 : t.track(name, { ...scalars(data) ?? {}, step_id: stepId, pixel_event_id: eventId })).catch(() => void 0);
+    }
+    /** Keep the dedup map to entries still inside the window, and never past `STEP_MEMORY`. */
+    remember(key, at) {
+      for (const [seen, when] of this.lastStep) {
+        if (at - when >= DEDUP_MS)
+          this.lastStep.delete(seen);
+      }
+      while (this.lastStep.size >= STEP_MEMORY) {
+        const oldest = this.lastStep.keys().next();
+        if (oldest.done === true)
+          break;
+        this.lastStep.delete(oldest.value);
+      }
+      this.lastStep.set(key, at);
+    }
+    identify(who) {
+      if (this.off())
+        return;
+      void this.pixels().then(
+        (engine) => engine == null ? void 0 : engine.identify({ email: who.email, phone: who.phone, externalId: who.customerId })
+      );
+      void this.core().then((t) => t == null ? void 0 : t.identify(who.customerId ?? null, { email: who.email, phone: who.phone, customerId: who.customerId })).catch(() => void 0);
+    }
+    consent(state) {
+      if (this.off())
+        return;
+      void this.pixels().then((engine) => engine == null ? void 0 : engine.consent(state));
+    }
+    async health() {
+      if (typeof window === "undefined")
+        return this.snapshot();
+      if (this.enabled())
+        await this.config();
+      return this.snapshot();
+    }
+    // -- internal hooks, called by the checkout and payment modules -----------
+    /** @internal */
+    noteCheckout(input) {
+      this.notePixel("InitiateCheckout", input.checkoutSessionId, input);
+    }
+    /** @internal */
+    notePaid(input) {
+      this.notePixel("Purchase", input.orderId, input);
+    }
+    /** The `eventId` formula is the server's `makeMetaEventId`, so Meta and TikTok dedup. */
+    notePixel(event, id, input) {
+      if (this.off())
+        return;
+      void this.pixels().then(
+        (engine) => {
+          var _a;
+          return engine == null ? void 0 : engine.track(
+            event,
+            { value: input.amount, currency: input.currency, contents: input.items, num_items: (_a = input.items) == null ? void 0 : _a.length },
+            { eventId: `${event}_${id}` }
+          );
+        }
+      );
+    }
+    /** @internal */
+    noteSignal(signal, value, detail) {
+      if (this.off())
+        return;
+      this.signals.push({ signal, value, detail });
+      this.listen();
+      this.push({ kind: "signal", signal, value, detail });
+    }
+    // -- config, engine -------------------------------------------------------
+    snapshot() {
+      return {
+        enabled: typeof window === "undefined" ? false : this.enabled(),
+        storeId: this.storeId,
+        funnelKey: this.flagFunnelKey(),
+        sdk: { name: SDK_NAME, version: SDK_VERSION },
+        manifestHash: this.manifestHash,
+        pixels: { loaded: this.loadedProviders.length > 0, providers: [...this.loadedProviders] },
+        signals: [...this.signals]
+      };
+    }
+    /**
+     * R4, once per page. Plain `fetch`, no header, no credentials — never `HttpClient`,
+     * which adds `Content-Type` and `x-cms-token` and so preflights against a fixed allow-list.
+     */
+    config() {
+      if (this.configPromise !== null)
+        return this.configPromise;
+      const url2 = `${this.baseUrl}/api/public/v1/sdk/config?storeId=${encodeURIComponent(this.storeId)}&funnel=${encodeURIComponent(this.flagFunnelKey())}`;
+      this.configPromise = (async () => {
+        try {
+          const response = await fetch(url2);
+          if (!response.ok)
+            return null;
+          const config = await response.json();
+          this.manifestHash = config.manifestHash || null;
+          return config;
+        } catch {
+          return null;
+        }
+      })();
+      return this.configPromise;
+    }
+    /** @internal R4 is reused; loading is allowed only when it opts this store in. */
+    core() {
+      if (typeof window === "undefined")
+        return Promise.resolve(null);
+      this.corePromise ?? (this.corePromise = (async () => {
+        var _a, _b;
+        try {
+          const config = await this.config();
+          if (!config || !config.collect && !config.experiments)
+            return null;
+          const base = this.baseUrl.replace(/\/+$/, "");
+          const w = window;
+          if (typeof ((_a = w.tgd) == null ? void 0 : _a.init) !== "function") {
+            await loadScript(base + "/assets/js/tgd.js", () => {
+              var _a2;
+              return typeof ((_a2 = w.tgd) == null ? void 0 : _a2.init) === "function";
+            });
+          }
+          if (typeof ((_b = w.tgd) == null ? void 0 : _b.init) !== "function")
+            return null;
+          w.tgd.init({
+            storeId: this.storeId,
+            apiHost: config.collect ? new URL(config.collect.url).origin : base,
+            bootstrap: this.bootstrap,
+            _source: "headless",
+            _manualPages: true
+          });
+          return w.tgd;
+        } catch {
+          return null;
+        }
+      })());
+      return this.corePromise;
+    }
+    /** @internal Funnel navigation alone must not opt a site into tracking. */
+    noteFunnelSession(funnelSessionId) {
+      if (this.off())
+        return;
+      void this.core().then((t) => t == null ? void 0 : t._link(funnelSessionId)).catch(() => void 0);
+    }
+    pixels() {
+      if (!this.enabled())
+        return Promise.resolve(null);
+      this.enginePromise ?? (this.enginePromise = this.startEngine());
+      return this.enginePromise;
+    }
+    async startEngine() {
+      var _a;
+      try {
+        const config = await this.config();
+        if (config === null)
+          return null;
+        const module = await loadPixels();
+        if (module === null)
+          return null;
+        const engine = module.createPixelEngine({
+          pixels: toPixelsConfig(config.pixels ?? []),
+          steps: config.steps,
+          checkout: config.checkout,
+          requireConsent: ((_a = config.consent) == null ? void 0 : _a.required) === true,
+          onSignal: (signal) => this.onPixelSignal(signal)
+        });
+        await engine.init();
+        this.loadedProviders = [...new Set((config.pixels ?? []).map((pixel) => pixel.provider))];
+        return engine;
+      } catch {
+        return null;
+      }
+    }
+    onPixelSignal(signal) {
+      const detail = signal.detail ?? {};
+      this.signals.push({ signal: signal.kind, value: signal.provider, detail });
+      this.push({ kind: "signal", signal: signal.kind, value: signal.provider, detail });
+    }
+    // -- R5 queue -------------------------------------------------------------
+    listen() {
+      if (this.listening || typeof window === "undefined")
+        return;
+      this.listening = true;
+      const onLeave = (event) => {
+        if (event.type === "visibilitychange" && document.visibilityState !== "hidden")
+          return;
+        this.flush();
+      };
+      window.addEventListener("pagehide", onLeave);
+      window.addEventListener("visibilitychange", onLeave);
+    }
+    push(record) {
+      if (!this.enabled())
+        return;
+      this.records.push(record);
+      if (this.records.length >= QUEUE_LIMIT) {
+        this.flush();
+        return;
+      }
+      if (this.flushTimer === null)
+        this.flushTimer = setTimeout(() => this.flush(), FLUSH_MS);
+    }
+    /** `localStorage` is an undeclared identifier in Node, so it is read inside the try. */
+    identifier(scope, key) {
+      try {
+        const store = scope === "local" ? localStorage : sessionStorage;
+        const existing = store.getItem(key);
+        if (existing)
+          return existing;
+        const fresh = uuid();
+        store.setItem(key, fresh);
+        return fresh;
+      } catch {
+        return uuid();
+      }
+    }
+    flush() {
+      if (this.flushTimer !== null) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      if (this.records.length === 0)
+        return;
+      const records = this.records.splice(0, QUEUE_LIMIT);
+      const payload = {
+        storeId: this.storeId,
+        funnelKey: this.flagFunnelKey(),
+        sdk: { name: SDK_NAME, version: SDK_VERSION },
+        anonymousId: this.identifier("local", ANON_KEY),
+        sessionId: this.identifier("session", SESSION_KEY),
+        records
+      };
+      if (this.manifestHash !== null)
+        payload.manifestHash = this.manifestHash;
+      const body = JSON.stringify(payload);
+      const url2 = `${this.baseUrl}/api/public/v1/sdk/events`;
+      try {
+        if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+          if (navigator.sendBeacon(url2, new Blob([body], { type: "text/plain;charset=UTF-8" })))
+            return;
+        }
+      } catch {
+      }
+      try {
+        void fetch(url2, {
+          method: "POST",
+          body,
+          keepalive: true,
+          headers: { "content-type": "text/plain;charset=UTF-8" }
+        }).catch(() => void 0);
+      } catch {
+      }
+    }
+  };
+
   // src/core/modules/payment.ts
   var EXPRESS_METHOD_TYPES = /* @__PURE__ */ new Set(["apple_pay", "google_pay", "paypal", "klarna", "klarna_express", "link"]);
   function paymentMethodListEntryToConfig(entry) {
@@ -775,11 +1210,13 @@ var TagadaHeadlessBundle = (() => {
     };
   }
   var PaymentModule = class {
-    constructor(http, storeId, environment, checkout) {
+    constructor(http, storeId, environment, checkout, onPaid, onSignal) {
       this.http = http;
       this.storeId = storeId;
       this.environment = environment;
       this.checkout = checkout;
+      this.onPaid = onPaid;
+      this.onSignal = onSignal;
       /**
        * Last payment setup seen by `getPaymentSetup` — lets `processApplePay`
        * resolve the domain's Apple Pay registration (BYOK / platform-integrator)
@@ -847,7 +1284,7 @@ var TagadaHeadlessBundle = (() => {
      * filtered to only those available in the current browser.
      */
     async getExpressMethods(checkoutSessionId, opts) {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
       const setup = await this.getPaymentSetup(checkoutSessionId, opts);
       const result = {};
       for (const [key, config] of Object.entries(setup)) {
@@ -865,12 +1302,15 @@ var TagadaHeadlessBundle = (() => {
             result.applePay = { ...base2, type: "apple_pay", available: !!hasApplePay };
           }
           if ((_d = config.methods.google_pay) == null ? void 0 : _d.enabled) {
+            if (typeof window !== "undefined" && !("PaymentRequest" in window)) {
+              (_e = this.onSignal) == null ? void 0 : _e.call(this, "googlePay", { reason: "no-payment-request-api" });
+            }
             result.googlePay = { ...base2, type: "google_pay" };
           }
-          if ((_e = config.methods.link) == null ? void 0 : _e.enabled) {
+          if ((_f = config.methods.link) == null ? void 0 : _f.enabled) {
             result.link = { ...base2, type: "link" };
           }
-          if ((_f = config.methods.klarna_express) == null ? void 0 : _f.enabled) {
+          if ((_g = config.methods.klarna_express) == null ? void 0 : _g.enabled) {
             result.klarna = { ...base2, type: "klarna_express" };
           }
           continue;
@@ -886,9 +1326,12 @@ var TagadaHeadlessBundle = (() => {
           metadata: config.metadata
         };
         if (method === "apple_pay" || config.type === "apple_pay") {
-          const hasApplePay = typeof window !== "undefined" && "ApplePaySession" in window && ((_h = (_g = window.ApplePaySession) == null ? void 0 : _g.canMakePayments) == null ? void 0 : _h.call(_g));
+          const hasApplePay = typeof window !== "undefined" && "ApplePaySession" in window && ((_i = (_h = window.ApplePaySession) == null ? void 0 : _h.canMakePayments) == null ? void 0 : _i.call(_h));
           result.applePay = { ...base, available: !!hasApplePay };
         } else if (method === "google_pay" || config.type === "google_pay") {
+          if (typeof window !== "undefined" && !("PaymentRequest" in window)) {
+            (_j = this.onSignal) == null ? void 0 : _j.call(this, "googlePay", { reason: "no-payment-request-api" });
+          }
           result.googlePay = base;
         } else if (method === "paypal") {
           result.paypal = base;
@@ -1287,14 +1730,15 @@ var TagadaHeadlessBundle = (() => {
      * don't need to re-pay.
      */
     async finalize(input, opts) {
-      var _a, _b;
+      var _a, _b, _c;
       const payment = input.payment;
       const returnUrl = (opts == null ? void 0 : opts.returnUrl) ?? (typeof window !== "undefined" ? window.location.href : void 0);
       if (payment.status === "succeeded") {
+        this.emitPaid((_a = input.order) == null ? void 0 : _a.id, payment);
         return { status: "succeeded", payment, order: input.order };
       }
       if (payment.status === "failed" || payment.status === "declined") {
-        const msg = ((_a = payment.requireActionData) == null ? void 0 : _a.message) || ((_b = payment.requireActionData) == null ? void 0 : _b.errorCode) || `Payment ${payment.status}`;
+        const msg = ((_b = payment.requireActionData) == null ? void 0 : _b.message) || ((_c = payment.requireActionData) == null ? void 0 : _c.errorCode) || `Payment ${payment.status}`;
         return { status: "failed", error: msg, payment };
       }
       if (payment.requireAction && payment.requireAction !== "none" && payment.requireActionData) {
@@ -1345,15 +1789,15 @@ var TagadaHeadlessBundle = (() => {
       if (typeof window === "undefined" && !(opts == null ? void 0 : opts.url))
         return null;
       const href = (opts == null ? void 0 : opts.url) ?? window.location.href;
-      let url;
+      let url2;
       try {
-        url = new URL(href);
+        url2 = new URL(href);
       } catch {
         return null;
       }
-      const action = url.searchParams.get("paymentAction");
-      const actionStatus = url.searchParams.get("paymentActionStatus");
-      const paymentId = url.searchParams.get("paymentId");
+      const action = url2.searchParams.get("paymentAction");
+      const actionStatus = url2.searchParams.get("paymentActionStatus");
+      const paymentId = url2.searchParams.get("paymentId");
       if (action !== "requireAction" || actionStatus !== "completed" || !paymentId) {
         return null;
       }
@@ -1458,8 +1902,8 @@ var TagadaHeadlessBundle = (() => {
     extractRedirect(payment, actionData) {
       var _a, _b;
       const redirect = (_a = actionData.metadata) == null ? void 0 : _a.redirect;
-      const url = (redirect == null ? void 0 : redirect.redirectUrl) || actionData.redirectUrl;
-      if (!url) {
+      const url2 = (redirect == null ? void 0 : redirect.redirectUrl) || actionData.redirectUrl;
+      if (!url2) {
         return {
           status: "failed",
           error: `Payment requires action (${actionData.type}) but no redirect URL was provided`,
@@ -1468,7 +1912,7 @@ var TagadaHeadlessBundle = (() => {
       }
       return {
         status: "requires_redirect",
-        redirectUrl: url,
+        redirectUrl: url2,
         method: ((_b = redirect == null ? void 0 : redirect.method) == null ? void 0 : _b.toUpperCase()) || "GET",
         postData: redirect == null ? void 0 : redirect.data,
         paymentId: payment.id
@@ -1528,6 +1972,7 @@ var TagadaHeadlessBundle = (() => {
      * Also handles new requireAction that may appear during polling.
      */
     async pollUntilDone(paymentId, opts) {
+      var _a;
       const interval = (opts == null ? void 0 : opts.intervalMs) ?? 1500;
       const timeout = (opts == null ? void 0 : opts.timeoutMs) ?? 6e4;
       const start = Date.now();
@@ -1546,6 +1991,9 @@ var TagadaHeadlessBundle = (() => {
           continue;
         }
         if (status.status === "succeeded" || status.status === "pending" && status.subStatus === "authorized") {
+          if (status.status === "succeeded") {
+            this.emitPaid((_a = status.order) == null ? void 0 : _a.id, status);
+          }
           return { status: "succeeded", payment: status, order: status.order };
         }
         if (status.status === "failed" || status.status === "declined") {
@@ -1581,260 +2029,113 @@ var TagadaHeadlessBundle = (() => {
         return null;
       }
     }
+    /** Tracking hook. Never throws, never awaits: a pixel must not be able to break a payment. */
+    emitPaid(orderId, payment) {
+      var _a;
+      if (!orderId || !this.onPaid)
+        return;
+      try {
+        const session = (_a = this.checkout) == null ? void 0 : _a.getCurrentSession();
+        this.onPaid({
+          orderId,
+          amount: payment.amount,
+          currency: payment.currency,
+          items: toContents(session == null ? void 0 : session.items)
+        });
+      } catch {
+      }
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async loadCoreJs() {
       try {
         return await import("@tagadapay/core-js");
-      } catch {
-        throw new Error(
+      } catch (cause) {
+        const error = new Error(
           "This method requires @tagadapay/core-js. Install it: npm install @tagadapay/core-js"
         );
+        error.cause = cause;
+        throw error;
       }
     }
   };
 
+  // src/core/modules/lazyCommerce.ts
+  var script = typeof document === "undefined" ? null : document.currentScript;
+  var url = (script == null ? void 0 : script.src) ? new URL("tagada-headless-commerce.min.js", script.src).href : "https://cdn.jsdelivr.net/npm/@tagadapay/headless-sdk@1.17.0/dist/tagada-headless-commerce.min.js";
+  var loading;
+  function loadCommerce() {
+    if (window.TagadaHeadlessCommerce)
+      return Promise.resolve(window.TagadaHeadlessCommerce);
+    if (!loading)
+      loading = new Promise((resolve, reject) => {
+        const element = document.createElement("script");
+        element.src = url;
+        element.async = true;
+        if (script == null ? void 0 : script.nonce)
+          element.nonce = script.nonce;
+        element.addEventListener("load", () => window.TagadaHeadlessCommerce ? resolve(window.TagadaHeadlessCommerce) : reject(new Error("Commerce bundle did not initialize")));
+        element.addEventListener("error", () => {
+          element.remove();
+          reject(new Error("Unable to load commerce bundle"));
+        });
+        document.head.appendChild(element);
+      }).catch((error) => {
+        loading = void 0;
+        throw error;
+      });
+    return loading;
+  }
+
   // src/core/modules/offers.ts
   var OffersModule = class {
-    constructor(http, storeId, payment) {
-      this.http = http;
-      this.storeId = storeId;
-      this.payment = payment;
-    }
-    // ---------------------------------------------------------------------------
-    // Offer loading
-    // ---------------------------------------------------------------------------
-    /** Get a single offer by ID. */
-    async getOffer(offerId) {
-      return this.http.get(`/api/v1/offers/${offerId}`);
+    constructor(...args) {
+      this.args = args;
     }
-    /** List offers for the current store. Optionally filter by type or a set of IDs. */
-    async listOffers(opts) {
-      var _a;
-      let url = `/api/v1/stores/${this.storeId}/offers`;
-      const queryParts = [];
-      if (opts == null ? void 0 : opts.type)
-        queryParts.push(`type=${encodeURIComponent(opts.type)}`);
-      if ((_a = opts == null ? void 0 : opts.ids) == null ? void 0 : _a.length) {
-        for (const id of opts.ids)
-          queryParts.push(`ids=${encodeURIComponent(id)}`);
-      }
-      if (queryParts.length)
-        url += `?${queryParts.join("&")}`;
-      const res = await this.http.get(url);
-      return res.offers ?? [];
-    }
-    // ---------------------------------------------------------------------------
-    // Preview & pay (one-click upsell flow from plugin-sdk)
-    // ---------------------------------------------------------------------------
-    /** Preview offer pricing. Returns line items with amounts and totals. */
-    async previewOffer(opts) {
-      return this.http.post(`/api/v1/offers/${opts.offerId}/preview`, {
-        offerId: opts.offerId,
-        currency: opts.currency ?? "",
-        lineItems: opts.lineItems
-      });
-    }
-    /**
-     * Pay a previously previewed offer (one-click charge).
-     * Used after a main order so the stored payment instrument is reused.
-     *
-     * **Low-level API.** Returns the raw `OfferPayResult` — `requireAction`,
-     * polling, and 3DS redirects are NOT handled. For most cases, use
-     * {@link processOfferPayment} which orchestrates the full lifecycle.
-     */
-    async payPreviewedOffer(opts) {
-      return this.http.post(`/api/v1/offers/${opts.offerId}/pay-preview`, {
-        offerId: opts.offerId,
-        currency: opts.currency ?? "",
-        lineItems: opts.lineItems,
-        returnUrl: opts.returnUrl ?? (typeof window !== "undefined" ? window.location.href : ""),
-        mainOrderId: opts.mainOrderId,
-        paymentInstrumentId: opts.paymentInstrumentId
-      });
-    }
-    /**
-     * One-click upsell with full lifecycle handling.
-     *
-     * Like `payment.processPayment()` but for previewed offers: charges the
-     * stored instrument from `mainOrderId`, runs any 3DS challenge or bank
-     * redirect, polls until terminal, and returns a typed
-     * `ProcessPaymentResult` (`succeeded` / `requires_redirect` /
-     * `failed` / `pending`).
-     *
-     * Use this instead of the lower-level `payPreviewedOffer()` whenever you
-     * don't need to inspect the raw `OfferPayResult` shape — which is most
-     * of the time.
-     *
-     * @example
-     * ```ts
-     * const result = await tagada.offers.processOfferPayment({
-     *   offerId: 'offer_xxx',
-     *   mainOrderId: order.id,
-     *   returnUrl: window.location.href,
-     * });
-     *
-     * switch (result.status) {
-     *   case 'succeeded':
-     *     window.location.href = '/upsell-2';
-     *     break;
-     *   case 'requires_redirect':
-     *     window.location.href = result.redirectUrl;
-     *     break;
-     *   case 'failed':
-     *     showError(result.error);
-     *     break;
-     * }
-     * ```
-     */
-    async processOfferPayment(opts) {
-      if (!this.payment) {
-        throw new Error(
-          "OffersModule: no PaymentModule injected. Use createHeadlessClient() instead of constructing OffersModule directly."
-        );
-      }
-      const returnUrl = opts.returnUrl ?? (typeof window !== "undefined" ? window.location.href : void 0);
-      const payResult = await this.payPreviewedOffer({ ...opts, returnUrl });
-      return this.payment.finalize(
-        { payment: payResult.payment, order: payResult.order },
-        { returnUrl }
-      );
-    }
-    // ---------------------------------------------------------------------------
-    // Order bumps (checkout-session scoped)
-    // ---------------------------------------------------------------------------
-    /** Toggle an order bump on/off within a checkout session. */
-    async toggleOrderBump(opts) {
-      return this.http.post(
-        `/api/v1/checkout-sessions/${opts.checkoutSessionId}/toggle-order-bump`,
-        {
-          orderBumpOfferId: opts.orderBumpOfferId,
-          selected: opts.selected
-        }
-      );
-    }
-    // ---------------------------------------------------------------------------
-    // Post-purchase offers (order-scoped)
-    // ---------------------------------------------------------------------------
-    /** List post-purchase offers for an order. */
-    async listPostPurchaseOffers(orderId) {
-      const res = await this.http.get(`/api/v1/post-purchase/${orderId}/offers`);
-      return Array.isArray(res) ? res : [];
-    }
-    /** Accept a post-purchase offer. */
-    async acceptPostPurchaseOffer(opts) {
-      return this.http.post(
-        `/api/v1/orders/${opts.orderId}/post-purchase-offers/${opts.offerId}/accept`,
-        { items: opts.items ?? [] }
-      );
-    }
-    /** Decline a post-purchase offer. */
-    async declinePostPurchaseOffer(opts) {
-      return this.http.post(
-        `/api/v1/orders/${opts.orderId}/post-purchase-offers/${opts.offerId}/decline`
-      );
+    load() {
+      return this.instance || (this.instance = loadCommerce().then((m) => new m.OffersModule(...this.args)).catch((e) => {
+        this.instance = void 0;
+        throw e;
+      }));
     }
   };
+  for (const method of ["getOffer", "listOffers", "previewOffer", "enterFunnelStep", "payPreviewedOffer", "processOfferPayment", "toggleOrderBump", "listPostPurchaseOffers", "acceptPostPurchaseOffer", "declinePostPurchaseOffer"])
+    OffersModule.prototype[method] = function(...args) {
+      return this.load().then((instance) => instance[method](...args));
+    };
 
   // src/core/modules/customer.ts
   var CustomerModule = class {
-    constructor(http, storeId) {
-      this.http = http;
-      this.storeId = storeId;
-    }
-    /** Get customer profile by ID. */
-    async getProfile(customerId) {
-      const res = await this.http.get(
-        `/api/v1/customers/${customerId}`,
-        { params: { storeId: this.storeId } }
-      );
-      return res.customer;
-    }
-    /** Get customer profile by email. */
-    async getByEmail(email) {
-      try {
-        const res = await this.http.get(
-          "/api/v1/customers/by-email",
-          { params: { email, storeId: this.storeId } }
-        );
-        return res.customer;
-      } catch {
-        return null;
-      }
-    }
-    /** Update customer profile fields. */
-    async updateProfile(customerId, data) {
-      const res = await this.http.patch(
-        `/api/v1/customers/${customerId}`,
-        { storeId: this.storeId, ...data }
-      );
-      return res.customer;
-    }
-    /** List orders for a customer. */
-    async getOrders(customerId, opts) {
-      return this.http.get(
-        `/api/v1/customers/${customerId}/orders`,
-        { params: { storeId: this.storeId, limit: opts == null ? void 0 : opts.limit, offset: opts == null ? void 0 : opts.offset } }
-      );
-    }
-    /**
-     * Get a single order by ID.
-     *
-     * **Thank-you pages:** accepted one-click upsells create *child orders*
-     * (`metadata.mainOrderId` = this order's id) that land asynchronously —
-     * the first fetch right after an accept usually misses them. Pass
-     * `waitForRelatedOrders: true` to poll until `order.relatedOrders` is
-     * non-empty or the timeout elapses. On timeout the latest snapshot is
-     * returned (never throws), so an order with no accepted upsell simply
-     * comes back with an empty `relatedOrders` after `timeoutMs`.
-     *
-     * @example
-     * ```ts
-     * // Thank-you page: show the main order AND the upsells
-     * const order = await tagada.customer.getOrder(orderId, {
-     *   waitForRelatedOrders: true,
-     * });
-     * renderOrders([order, ...(order.relatedOrders ?? [])]);
-     * ```
-     */
-    async getOrder(orderId, opts) {
-      var _a, _b;
-      const fetchOrder = async () => {
-        const res = await this.http.get(`/api/v1/orders/${orderId}`, {
-          params: { storeId: this.storeId }
-        });
-        return res.order;
-      };
-      let order = await fetchOrder();
-      if (!(opts == null ? void 0 : opts.waitForRelatedOrders) || ((_a = order.relatedOrders) == null ? void 0 : _a.length))
-        return order;
-      const timeoutMs = opts.timeoutMs ?? 8e3;
-      const intervalMs = opts.intervalMs ?? 2e3;
-      const deadline = Date.now() + timeoutMs;
-      while (Date.now() < deadline) {
-        await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs, Math.max(0, deadline - Date.now()))));
-        order = await fetchOrder();
-        if ((_b = order.relatedOrders) == null ? void 0 : _b.length)
-          return order;
-      }
-      return order;
+    constructor(...args) {
+      this.args = args;
     }
-    /** List subscriptions for a customer. */
-    async getSubscriptions(customerId) {
-      const res = await this.http.get(
-        `/api/v1/customers/${customerId}/subscriptions`,
-        { params: { storeId: this.storeId } }
-      );
-      return res.subscriptions;
+    load() {
+      return this.instance || (this.instance = loadCommerce().then((m) => new m.CustomerModule(...this.args)).catch((e) => {
+        this.instance = void 0;
+        throw e;
+      }));
     }
-    /** Get a single subscription by ID. */
-    async getSubscription(subscriptionId) {
-      const res = await this.http.get(
-        `/api/v1/subscriptions/${subscriptionId}`,
-        { params: { storeId: this.storeId } }
-      );
-      return res.subscription;
+  };
+  for (const method of ["getProfile", "getByEmail", "updateProfile", "getOrders", "getOrder", "getSubscriptions", "getSubscription", "pauseSubscription", "resumeSubscription", "skipSubscription", "rescheduleSubscription", "updateSubscriptionQuantity", "changeSubscriptionFrequency", "swapSubscriptionProduct", "updateSubscriptionPaymentMethod", "cancelSubscription"])
+    CustomerModule.prototype[method] = function(...args) {
+      return this.load().then((instance) => instance[method](...args));
+    };
+
+  // src/core/modules/portal/index.ts
+  var CustomerPortalModule = class {
+    constructor(...args) {
+      this.args = args;
+    }
+    load() {
+      return this.instance || (this.instance = loadCommerce().then((m) => new m.CustomerPortalModule(...this.args)).catch((e) => {
+        this.instance = void 0;
+        throw e;
+      }));
     }
   };
+  for (const method of ["requestCode", "verifyCode", "getConfig", "getMe", "cancelFlow", "acceptCancelOffer", "switchOption", "getOffer", "acceptOffer", "addToNextOrder", "getCredits", "redeemCredits", "buyCreditPack", "requestEmailChangeCode", "updateProfile", "saveAddress", "removeAddress", "setDefaultAddress", "addCard", "removeCard", "setDefaultPaymentMethod", "retryPayment", "buyAgain", "joinMembership", "buyNow", "sendNow", "reactivateSubscription", "setSubscriptionCard", "setSubscriptionAddress", "skipDate", "unskipDate"])
+    CustomerPortalModule.prototype[method] = function(...args) {
+      return this.load().then((instance) => instance[method](...args));
+    };
 
   // src/core/modules/catalog.ts
   var CatalogModule = class {
@@ -1876,14 +2177,15 @@ var TagadaHeadlessBundle = (() => {
 
   // src/core/modules/funnel.ts
   var FunnelModule = class {
-    constructor(http, storeId, checkout, accountId) {
+    constructor(http, storeId, checkout, accountId, onFunnelSession) {
       this.http = http;
       this.storeId = storeId;
       this.checkout = checkout;
       this.accountId = accountId;
+      this.onFunnelSession = onFunnelSession;
     }
     async navigate(input) {
-      var _a;
+      var _a, _b;
       const session = this.checkout.getCurrentSession();
       if (!session) {
         throw new TagadaError(
@@ -1906,14 +2208,18 @@ var TagadaHeadlessBundle = (() => {
         accountId,
         currentUrl
       });
-      const url = await this.runNavigate({
+      try {
+        (_b = this.onFunnelSession) == null ? void 0 : _b.call(this, funnelSessionId);
+      } catch {
+      }
+      const url2 = await this.runNavigate({
         funnelSessionId,
         stepId: input.stepId,
         session,
         input,
         currentUrl
       });
-      return { url, funnelSessionId };
+      return { url: url2, funnelSessionId };
     }
     // -------------------------------------------------------------------------
     // Internals
@@ -2022,8 +2328,24 @@ var TagadaHeadlessBundle = (() => {
 
   // src/core/modules/rx.ts
   var RxModule = class {
-    constructor(http) {
+    constructor(http, storeId) {
       this.http = http;
+      this.storeId = storeId;
+    }
+    /**
+     * Activation status of the store: steps, missing items and whether Rx
+     * payments are `setting_up` or `ready`. Storefronts use it to show
+     * "Payments are being set up" instead of letting a checkout fail.
+     *
+     * Read-only / public. Defaults to the client's `storeId`.
+     */
+    async getActivationStatus(storeId) {
+      const id = storeId ?? this.storeId;
+      if (!id)
+        throw new Error("rx.getActivationStatus: storeId is required");
+      return this.http.get("/api/public/v1/rx/activation-status", {
+        params: { storeId: id }
+      });
     }
     /**
      * Check whether a product requires an Rx case. Storefronts call this
@@ -2070,6 +2392,96 @@ var TagadaHeadlessBundle = (() => {
     }
   };
 
+  // src/core/modules/experiments.ts
+  var ExperimentsModule = class {
+    constructor(core, bootstrap) {
+      this.core = core;
+      this.bootstrap = bootstrap;
+      this.runtime = null;
+      this.loading = null;
+      this.settled = false;
+      this.reads = /* @__PURE__ */ new Set();
+      this.subscribers = [];
+    }
+    variant(key) {
+      var _a, _b, _c, _d;
+      return ((_b = (_a = this.bootstrap) == null ? void 0 : _a.experiments[key]) == null ? void 0 : _b.arm) ?? ((_d = (_c = this.bootstrap) == null ? void 0 : _c.flags[key]) == null ? void 0 : _d.variant) ?? null;
+    }
+    start() {
+      if (typeof window === "undefined")
+        return Promise.resolve();
+      this.loading ?? (this.loading = (async () => {
+        try {
+          this.runtime = await this.core();
+        } catch {
+        }
+        this.settled = true;
+        const runtime = this.runtime;
+        for (const key of this.reads) {
+          try {
+            runtime == null ? void 0 : runtime.getVariant(key);
+          } catch {
+          }
+        }
+        this.reads.clear();
+        for (const { key, cb } of this.subscribers.splice(0)) {
+          try {
+            if (runtime)
+              runtime.onVariant(key, cb);
+            else
+              cb(this.variant(key));
+          } catch {
+          }
+        }
+        try {
+          await (runtime == null ? void 0 : runtime.ready());
+        } catch {
+        }
+      })());
+      return this.loading;
+    }
+    read(key) {
+      if (!this.settled)
+        this.reads.add(key);
+      void this.start();
+    }
+    getVariant(key) {
+      if (this.runtime)
+        return this.runtime.getVariant(key);
+      this.read(key);
+      return this.variant(key);
+    }
+    getPayload(key) {
+      var _a, _b, _c, _d;
+      if (this.runtime)
+        return this.runtime.getPayload(key);
+      this.read(key);
+      return ((_b = (_a = this.bootstrap) == null ? void 0 : _a.experiments[key]) == null ? void 0 : _b.payload) ?? ((_d = (_c = this.bootstrap) == null ? void 0 : _c.flags[key]) == null ? void 0 : _d.payload) ?? null;
+    }
+    isEnabled(flagKey) {
+      var _a, _b;
+      if (this.runtime)
+        return this.runtime.isEnabled(flagKey);
+      this.read(flagKey);
+      return ((_b = (_a = this.bootstrap) == null ? void 0 : _a.flags[flagKey]) == null ? void 0 : _b.enabled) ?? false;
+    }
+    onVariant(key, cb) {
+      if (this.runtime) {
+        this.runtime.onVariant(key, cb);
+        return;
+      }
+      if (this.settled) {
+        cb(this.variant(key));
+        return;
+      }
+      this.subscribers.push({ key, cb });
+      void this.start();
+    }
+    ready() {
+      return this.start();
+    }
+  };
+
   // src/core/client.ts
   var HeadlessClient = class {
     constructor(config) {
@@ -2087,21 +2499,43 @@ var TagadaHeadlessBundle = (() => {
         apiKey: config.apiKey,
         getToken: () => this._sessionToken
       });
+      this.track = new TrackModule(baseUrl, this.config.storeId, this.config.funnel ?? "main");
+      this.track.bootstrap = this.config.bootstrap;
+      this.experiments = new ExperimentsModule(() => this.track.core(), this.config.bootstrap);
       const setToken = (token) => {
         this._sessionToken = token;
       };
-      this.checkout = new CheckoutModule(this.http, this.config.storeId, setToken);
-      this.payment = new PaymentModule(this.http, this.config.storeId, environment, this.checkout);
+      this.checkout = new CheckoutModule(
+        this.http,
+        this.config.storeId,
+        setToken,
+        (s) => this.track.noteCheckout({
+          checkoutSessionId: s.id,
+          amount: s.totals.total,
+          currency: s.totals.currency,
+          items: toContents(s.items)
+        })
+      );
+      this.payment = new PaymentModule(
+        this.http,
+        this.config.storeId,
+        environment,
+        this.checkout,
+        (p) => this.track.notePaid(p),
+        (v, d) => this.track.noteSignal("wallet_unavailable", v, d)
+      );
       this.offers = new OffersModule(this.http, this.config.storeId, this.payment);
       this.customer = new CustomerModule(this.http, this.config.storeId);
+      this.portal = new CustomerPortalModule(this.http, this.config.storeId, setToken);
       this.catalog = new CatalogModule(this.http, this.config.storeId);
       this.funnel = new FunnelModule(
         this.http,
         this.config.storeId,
         this.checkout,
-        this.config.accountId
+        this.config.accountId,
+        (id) => this.track.noteFunnelSession(id)
       );
-      this.rx = new RxModule(this.http);
+      this.rx = new RxModule(this.http, this.config.storeId);
     }
     /** Manually set the session token (e.g. from URL params on page load). */
     setSessionToken(token) {
@@ -2156,13 +2590,13 @@ var TagadaHeadlessBundle = (() => {
         params.set("language", opts.language);
       if (opts.region)
         params.set("region", opts.region);
-      const script = document.createElement("script");
-      script.src = `https://maps.googleapis.com/maps/api/js?${params}`;
-      script.async = true;
-      script.defer = true;
-      script.onload = () => onScriptReady();
-      script.onerror = () => reject(new Error("Failed to load Google Maps script"));
-      document.head.appendChild(script);
+      const script2 = document.createElement("script");
+      script2.src = `https://maps.googleapis.com/maps/api/js?${params}`;
+      script2.async = true;
+      script2.defer = true;
+      script2.onload = () => onScriptReady();
+      script2.onerror = () => reject(new Error("Failed to load Google Maps script"));
+      document.head.appendChild(script2);
     });
   }
   var GoogleAutocompleteCore = class _GoogleAutocompleteCore {
@@ -2311,10 +2745,10 @@ var TagadaHeadlessBundle = (() => {
     if (inflight)
       return inflight;
     inflight = (async () => {
-      const url = `${GEODATA_CDN_BASE}/${language}/countries.json`;
-      const res = await fetch(url);
+      const url2 = `${GEODATA_CDN_BASE}/${language}/countries.json`;
+      const res = await fetch(url2);
       if (!res.ok)
-        throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
+        throw new Error(`Geodata fetch failed: ${url2} (${res.status})`);
       const data = await res.json();
       countriesCache.set(language, data);
       inflightCountries.delete(language);
@@ -2331,10 +2765,10 @@ var TagadaHeadlessBundle = (() => {
     if (inflight)
       return inflight;
     inflight = (async () => {
-      const url = `${GEODATA_CDN_BASE}/${language}/regions.json`;
-      const res = await fetch(url);
+      const url2 = `${GEODATA_CDN_BASE}/${language}/regions.json`;
+      const res = await fetch(url2);
       if (!res.ok)
-        throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
+        throw new Error(`Geodata fetch failed: ${url2} (${res.status})`);
       const data = await res.json();
       regionsCache.set(language, data);
       inflightRegions.delete(language);