@tagadapay/headless-sdk 1.8.0-rc.0 → 1.9.0

package/dist/tagada-headless.js

@@ -0,0 +1,2423 @@
+/**
+ * @tagadapay/headless-sdk v1.9.0
+ * Headless checkout, payments, offers, and CRM
+ * @license MIT
+ */
+"use strict";
+var TagadaHeadlessBundle = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/core/index.ts
+  var core_exports = {};
+  __export(core_exports, {
+    AVAILABLE_LANGUAGES: () => AVAILABLE_LANGUAGES,
+    CatalogModule: () => CatalogModule,
+    CheckoutModule: () => CheckoutModule,
+    CurrencyUtils: () => CurrencyUtils,
+    CustomerModule: () => CustomerModule,
+    FunnelModule: () => FunnelModule,
+    GoogleAutocompleteCore: () => GoogleAutocompleteCore,
+    HeadlessClient: () => HeadlessClient,
+    HttpClient: () => HttpClient,
+    ISODataCore: () => ISODataCore,
+    OffersModule: () => OffersModule,
+    PaymentModule: () => PaymentModule,
+    RxModule: () => RxModule,
+    TagadaAuthError: () => TagadaAuthError,
+    TagadaError: () => TagadaError,
+    TagadaNetworkError: () => TagadaNetworkError,
+    TagadaNotFoundError: () => TagadaNotFoundError,
+    TagadaPaymentError: () => TagadaPaymentError,
+    TagadaRateLimitError: () => TagadaRateLimitError,
+    TagadaValidationError: () => TagadaValidationError,
+    createHeadlessClient: () => createHeadlessClient,
+    ensureGeoDataLoaded: () => ensureGeoDataLoaded,
+    formatMoney: () => formatMoney,
+    getCountries: () => getCountries,
+    getStatesForCountry: () => getStatesForCountry,
+    isLanguageLoaded: () => isLanguageLoaded,
+    loadGoogleMapsScript: () => loadGoogleMapsScript
+  });
+
+  // src/core/errors.ts
+  var TagadaError = class extends Error {
+    constructor(message, code, statusCode, details) {
+      super(message);
+      this.name = "TagadaError";
+      this.code = code;
+      this.statusCode = statusCode;
+      this.details = details;
+    }
+  };
+  var TagadaAuthError = class extends TagadaError {
+    constructor(message = "Authentication failed. Check your API key or checkout token.") {
+      super(message, "auth_error", 401);
+      this.name = "TagadaAuthError";
+    }
+  };
+  var TagadaValidationError = class extends TagadaError {
+    constructor(message, errors = [], appCode, details) {
+      super(message, "validation_error", 422, { errors, ...details });
+      this.name = "TagadaValidationError";
+      this.errors = errors;
+      this.appCode = appCode;
+    }
+  };
+  var TagadaNotFoundError = class extends TagadaError {
+    constructor(resource, id) {
+      super(`${resource} "${id}" not found.`, "not_found", 404);
+      this.name = "TagadaNotFoundError";
+    }
+  };
+  var TagadaRateLimitError = class extends TagadaError {
+    constructor(retryAfterMs = 1e3) {
+      super(`Rate limited. Retry after ${retryAfterMs}ms.`, "rate_limit", 429);
+      this.name = "TagadaRateLimitError";
+      this.retryAfterMs = retryAfterMs;
+    }
+  };
+  var TagadaPaymentError = class extends TagadaError {
+    constructor(message, opts) {
+      super(message, "payment_error", void 0, opts == null ? void 0 : opts.details);
+      this.name = "TagadaPaymentError";
+      this.paymentId = opts == null ? void 0 : opts.paymentId;
+      this.requireAction = opts == null ? void 0 : opts.requireAction;
+    }
+  };
+  var TagadaNetworkError = class extends TagadaError {
+    constructor(message = "Network request failed. Check your connection.") {
+      super(message, "network_error");
+      this.name = "TagadaNetworkError";
+    }
+  };
+
+  // src/core/http.ts
+  var BASE_URLS = {
+    production: "https://api.tagada.io",
+    development: "https://api.tagada.dev",
+    local: "http://localhost:3000"
+  };
+  var HttpClient = class {
+    constructor(config) {
+      this.baseUrl = config.baseUrl.replace(/\/$/, "");
+      this.timeout = config.timeout;
+      this.apiKey = config.apiKey;
+      this.getToken = config.getToken;
+    }
+    static resolveBaseUrl(environment, override) {
+      return override ?? BASE_URLS[environment] ?? BASE_URLS.production;
+    }
+    async request(path, options = {}) {
+      var _a;
+      const { method = "GET", body, headers = {}, params, token, signal } = options;
+      let url = `${this.baseUrl}${path}`;
+      if (params) {
+        const qs = new URLSearchParams();
+        for (const [k, v] of Object.entries(params)) {
+          if (v !== void 0)
+            qs.set(k, String(v));
+        }
+        const str = qs.toString();
+        if (str)
+          url += `?${str}`;
+      }
+      const reqHeaders = {
+        "Content-Type": "application/json",
+        ...headers
+      };
+      const authToken = token ?? this.apiKey ?? ((_a = this.getToken) == null ? void 0 : _a.call(this));
+      if (authToken) {
+        reqHeaders["x-cms-token"] = authToken;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const res = await fetch(url, {
+          method,
+          headers: reqHeaders,
+          body: body != null ? JSON.stringify(body) : void 0,
+          signal: signal ?? controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (res.ok) {
+          const text = await res.text();
+          return text ? JSON.parse(text) : {};
+        }
+        await this.handleErrorResponse(res, path);
+        throw new TagadaError("Unexpected error", "unknown", res.status);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof TagadaError)
+          throw err;
+        if (err instanceof DOMException && err.name === "AbortError") {
+          throw new TagadaNetworkError(`Request to ${path} timed out after ${this.timeout}ms.`);
+        }
+        throw new TagadaNetworkError(
+          err instanceof Error ? err.message : "Network request failed."
+        );
+      }
+    }
+    get(path, options) {
+      return this.request(path, { ...options, method: "GET" });
+    }
+    post(path, body, options) {
+      return this.request(path, { ...options, method: "POST", body });
+    }
+    patch(path, body, options) {
+      return this.request(path, { ...options, method: "PATCH", body });
+    }
+    put(path, body, options) {
+      return this.request(path, { ...options, method: "PUT", body });
+    }
+    delete(path, options) {
+      return this.request(path, { ...options, method: "DELETE" });
+    }
+    async handleErrorResponse(res, path) {
+      let parsed = {};
+      try {
+        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 appCode = typeof data.code === "string" ? data.code : void 0;
+      switch (res.status) {
+        case 401:
+        case 403:
+          throw new TagadaAuthError(msg);
+        case 404:
+          throw new TagadaNotFoundError(path, "");
+        case 422: {
+          const fieldErrors = Array.isArray(parsed.errors) ? parsed.errors : [];
+          throw new TagadaValidationError(msg, fieldErrors, appCode, parsed);
+        }
+        case 429: {
+          const retryAfter = Number(res.headers.get("Retry-After") ?? "1") * 1e3;
+          throw new TagadaRateLimitError(retryAfter);
+        }
+        default:
+          throw new TagadaError(msg, "api_error", res.status, parsed);
+      }
+    }
+  };
+
+  // src/core/modules/checkout.ts
+  var CheckoutModule = class {
+    constructor(http, storeId, onTokenChange) {
+      this.http = http;
+      this.storeId = storeId;
+      this.onTokenChange = onTokenChange;
+    }
+    /**
+     * Returns the most recently loaded `CheckoutSession`, if any.
+     *
+     * Populated by `loadSession()`. Returns `undefined` if the SDK has not
+     * loaded a session yet. Used by `funnel.navigate()` to source the cart.
+     */
+    getCurrentSession() {
+      return this._currentSession;
+    }
+    /**
+     * Load an existing checkout session by its checkout token.
+     *
+     * @param checkoutToken The checkout token (from URL param `checkoutToken`).
+     * @param sessionToken The JWT session token (from URL param `token`). Required for auth.
+     * @param opts.currency Optional presentment currency override (e.g. 'EUR').
+     *   Only applied when the session has no currency set yet (first load).
+     *   Once set, currency is locked to the session and this param is ignored.
+     *
+     * Both `checkoutToken` and `sessionToken` come from the redirect URL returned by `createSession()`.
+     * Example URL: `/checkout?checkoutToken=abc123&token=eyJ...`
+     */
+    async loadSession(checkoutToken, sessionToken, opts) {
+      var _a;
+      if (sessionToken) {
+        this.sessionToken = sessionToken;
+        (_a = this.onTokenChange) == null ? void 0 : _a.call(this, sessionToken);
+      }
+      const params = { skipAsyncWait: "false" };
+      if (opts == null ? void 0 : opts.currency) {
+        params.currency = opts.currency;
+      }
+      const raw = await this.http.get(
+        `/api/v1/checkout-sessions/${checkoutToken}/v2`,
+        {
+          params,
+          token: this.sessionToken
+        }
+      );
+      const session = this.normalizeSession(raw);
+      this._currentSession = session;
+      return session;
+    }
+    /**
+     * Create a new checkout session.
+     *
+     * Returns a `checkoutToken` and `sessionToken` (JWT) needed for all subsequent calls.
+     * Also returns a `checkoutUrl` (the full Tagada-hosted checkout URL, for reference).
+     */
+    async createSession(opts) {
+      var _a;
+      const lineItems = opts.items.map((i) => ({
+        variantId: i.variantId,
+        priceId: i.priceId,
+        quantity: i.quantity
+      }));
+      const body = {
+        storeId: this.storeId,
+        lineItems
+      };
+      if (opts.returnUrl)
+        body.returnUrl = opts.returnUrl;
+      const customerData = {};
+      if (opts.currency)
+        customerData.currency = opts.currency;
+      if (opts.customerEmail) {
+        customerData.email = opts.customerEmail;
+        customerData.firstName = opts.customerFirstName;
+        customerData.lastName = opts.customerLastName;
+      }
+      if (Object.keys(customerData).length > 0) {
+        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") ?? "";
+      this.sessionToken = sessionToken;
+      if (sessionToken)
+        (_a = this.onTokenChange) == null ? void 0 : _a.call(this, sessionToken);
+      return {
+        checkoutUrl: res.checkoutUrl,
+        checkoutToken: res.checkoutToken,
+        sessionToken,
+        customerId: res.customerId
+      };
+    }
+    /**
+     * Create a session and produce a self-hosted redirect URL.
+     *
+     * Convenience wrapper around `createSession()`. Builds a URL of the
+     * form `${origin}${checkoutPath}?checkoutToken=...&sessionToken=...`
+     * that you can navigate to from a Cart page. The receiving page reads
+     * the params via {@link CheckoutModule.parseTokensFromUrl} and calls
+     * {@link CheckoutModule.loadSession}.
+     *
+     * For Tagada-hosted checkouts use the `checkoutUrl` returned by
+     * `createSession()` directly — this helper is for **self-hosted**
+     * checkout pages.
+     *
+     * @example
+     * ```ts
+     * const { url } = await tagada.checkout.createSessionUrl({
+     *   items: [{ variantId, quantity: 1 }],
+     *   checkoutPath: '/checkout',
+     * });
+     * window.location.href = url;
+     * ```
+     */
+    async createSessionUrl(opts) {
+      const session = await this.createSession({
+        items: opts.items,
+        currency: opts.currency,
+        returnUrl: opts.returnUrl,
+        customerEmail: opts.customerEmail,
+        customerFirstName: opts.customerFirstName,
+        customerLastName: opts.customerLastName
+      });
+      const origin = opts.origin ?? (typeof window !== "undefined" ? window.location.origin : "");
+      const checkoutPath = opts.checkoutPath ?? "/checkout";
+      const params = new URLSearchParams({
+        checkoutToken: session.checkoutToken,
+        sessionToken: session.sessionToken
+      });
+      const url = `${origin}${checkoutPath}?${params.toString()}`;
+      return { ...session, url };
+    }
+    /**
+     * Read `checkoutToken` and session token from a URL.
+     *
+     * Recognizes both the SDK convention (`?sessionToken=`) and the
+     * Tagada-hosted convention (`?token=`), so the same checkout page
+     * works whether the user came from `createSessionUrl()` or directly
+     * from a Tagada-hosted redirect.
+     *
+     * Returns `null` if `checkoutToken` is missing.
+     *
+     * @example
+     * ```ts
+     * const tokens = CheckoutModule.parseTokensFromUrl();
+     * if (!tokens) {
+     *   window.location.href = '/cart';
+     *   return;
+     * }
+     * const session = await tagada.checkout.loadSession(
+     *   tokens.checkoutToken,
+     *   tokens.sessionToken,
+     * );
+     * ```
+     */
+    static parseTokensFromUrl(url) {
+      if (typeof url === "undefined" && typeof window === "undefined")
+        return null;
+      const href = url ?? window.location.href;
+      let parsed;
+      try {
+        parsed = new URL(href);
+      } catch {
+        return null;
+      }
+      const checkoutToken = parsed.searchParams.get("checkoutToken");
+      if (!checkoutToken)
+        return null;
+      const sessionToken = parsed.searchParams.get("sessionToken") ?? parsed.searchParams.get("token") ?? "";
+      return { checkoutToken, sessionToken };
+    }
+    /**
+     * Add or update cart items on an existing session (upsert by product).
+     *
+     * Sends each item as `lineItems` to `POST /checkout-sessions/:id/line-items`.
+     * The endpoint UPSERTs by product: it adds new products and updates the
+     * variant/quantity of products already in the cart, but it does NOT remove
+     * products omitted from `items`, and an empty array is a no-op (it does not
+     * clear the cart). Each `quantity` must be >= 1 — removal is not supported by
+     * this endpoint.
+     *
+     * Returns a server-side mutation summary (counts of created/updated rows).
+     * It does NOT return the updated `CheckoutSession` — the underlying endpoint
+     * never has and the previous typing was a lie that quietly assigned
+     * `{ success, updated, ... }` into a `CheckoutSession` slot in `useCheckout`.
+     *
+     * Call `loadSession()` after this if you need the refreshed session
+     * (the React `useCheckout` hook does this for you).
+     */
+    async updateCart(sessionId, items) {
+      const lineItems = items.map((i) => ({
+        variantId: i.variantId,
+        priceId: i.priceId,
+        quantity: i.quantity
+      }));
+      return this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/line-items`,
+        { lineItems },
+        { token: this.sessionToken }
+      );
+    }
+    /**
+     * Update customer identity (email, name, phone).
+     *
+     * Call this before `updateAddress()` — the SDK remembers the values and
+     * includes them automatically when addresses are submitted.
+     *
+     * If you prefer a single call, use `updateCustomerAndAddress()` instead.
+     */
+    async updateCustomer(sessionId, customer) {
+      if (customer.email)
+        this.customerEmail = customer.email;
+      if (customer.firstName)
+        this.customerFirstName = customer.firstName;
+      if (customer.lastName)
+        this.customerLastName = customer.lastName;
+      if (customer.phone)
+        this.customerPhone = customer.phone;
+    }
+    /**
+     * Update shipping and/or billing address on the session.
+     *
+     * Automatically includes customer name/phone stored from `updateCustomer()`.
+     * Uses the same atomic API call as the production checkout, so email,
+     * customer name, and addresses are all persisted together.
+     *
+     * **Shipped products**: pass `shippingAddress`. If `billingAddress` is omitted,
+     * the shipping address is automatically used as billing.
+     *
+     * **Digital products**: pass only `billingAddress` (no shipping needed).
+     *
+     * @example
+     * // Shipped product — billing = shipping automatically
+     * await checkout.updateAddress(sessionId, {
+     *   shippingAddress: { line1: '10 Rue de la Paix', city: 'Paris', postalCode: '75002', country: 'FR' },
+     * });
+     *
+     * @example
+     * // Digital product — billing only
+     * await checkout.updateAddress(sessionId, {
+     *   billingAddress: { country: 'FR' },
+     * });
+     */
+    async updateAddress(sessionId, addresses) {
+      const shipping = this.mapAddress(addresses.shippingAddress);
+      const billing = this.mapAddress(addresses.billingAddress);
+      const effectiveShipping = shipping ?? billing ?? {};
+      const effectiveBilling = billing ?? shipping;
+      const differentBilling = !!(addresses.billingAddress && addresses.shippingAddress);
+      await this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/customer-and-session-info`,
+        {
+          checkoutSessionId: sessionId,
+          customerData: {
+            email: this.customerEmail
+          },
+          shippingAddress: effectiveShipping,
+          billingAddress: effectiveBilling ?? {},
+          differentBillingAddress: differentBilling
+        },
+        { token: this.sessionToken }
+      );
+    }
+    /**
+     * Set customer info + addresses in one call (mirrors production checkout).
+     *
+     * Equivalent to calling `updateCustomer()` then `updateAddress()`, but
+     * in a single network request.
+     */
+    async updateCustomerAndAddress(sessionId, data) {
+      if (data.customer.email)
+        this.customerEmail = data.customer.email;
+      if (data.customer.firstName)
+        this.customerFirstName = data.customer.firstName;
+      if (data.customer.lastName)
+        this.customerLastName = data.customer.lastName;
+      if (data.customer.phone)
+        this.customerPhone = data.customer.phone;
+      const shipping = this.mapAddress(data.shippingAddress);
+      const billing = this.mapAddress(data.billingAddress);
+      const effectiveShipping = shipping ?? billing ?? {};
+      const effectiveBilling = billing ?? shipping;
+      const differentBilling = !!(data.billingAddress && data.shippingAddress);
+      await this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/customer-and-session-info`,
+        {
+          checkoutSessionId: sessionId,
+          customerData: {
+            email: this.customerEmail
+          },
+          shippingAddress: effectiveShipping,
+          billingAddress: effectiveBilling ?? {},
+          differentBillingAddress: differentBilling
+        },
+        { token: this.sessionToken }
+      );
+    }
+    /** Map an SDK Address to the API shape, injecting stored customer fields. */
+    mapAddress(a) {
+      if (!a)
+        return void 0;
+      return stripEmpty({
+        firstName: a.firstName ?? this.customerFirstName,
+        lastName: a.lastName ?? this.customerLastName,
+        phone: a.phone ?? this.customerPhone,
+        address1: a.line1,
+        address2: a.line2,
+        city: a.city,
+        state: a.state,
+        postal: a.postalCode,
+        country: a.country
+      });
+    }
+    /** Apply a promotion code to the session. */
+    async applyPromoCode(sessionId, code) {
+      await this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/promotions/apply`,
+        { checkoutSessionId: sessionId, code },
+        { token: this.sessionToken }
+      );
+    }
+    /** Remove a promotion from the session by promotion ID. */
+    async removePromoCode(sessionId, promotionId) {
+      const promoId = promotionId ?? "default";
+      await this.http.delete(
+        `/api/v1/checkout-sessions/${sessionId}/promotions/${promoId}`,
+        { token: this.sessionToken }
+      );
+    }
+    /**
+     * Fetch available shipping rates for the session's address.
+     * Only relevant for **shipped products** — digital products can skip this step.
+     *
+     * Requires a shipping address to be set first via `updateAddress()`.
+     * Returns an empty array if no rates are configured or address is missing.
+     */
+    async getShippingRates(sessionId) {
+      const res = await this.http.get(
+        `/api/v1/checkout-sessions/${sessionId}/shipping-rates`,
+        { token: this.sessionToken }
+      );
+      return (res.rates ?? []).map((r) => this.normalizeShippingRate(r));
+    }
+    /**
+     * Normalize the v1 rates payload (`shippingRateName`, `estimatedDeliveryTime`)
+     * to the SDK's `ShippingRate` shape (`name`, `estimatedDays`). Without
+     * this the consumer's UI shows blank rate names — the demo's "Delivery"
+     * radios were rendering only the price, no label.
+     */
+    normalizeShippingRate(r) {
+      return {
+        id: r.id,
+        name: r.name ?? r.shippingRateName ?? "",
+        description: r.description ?? void 0,
+        amount: r.amount ?? 0,
+        currency: r.currency ?? "USD",
+        estimatedDays: r.estimatedDays ?? r.estimatedDeliveryTime ?? void 0
+      };
+    }
+    /**
+     * Select a shipping rate for the session.
+     * Only relevant for **shipped products** — digital products can skip this step.
+     */
+    async selectShippingRate(sessionId, rateId) {
+      await this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/shipping-rate`,
+        { checkoutSessionId: sessionId, shippingRateId: rateId },
+        { token: this.sessionToken }
+      );
+    }
+    /**
+     * Normalize the raw v2 API response into a cleaner CheckoutSession shape.
+     * The raw response has nested `checkoutSession` + `summary` -- we flatten it.
+     */
+    normalizeSession(raw) {
+      var _a;
+      const cs = raw.checkoutSession;
+      const orderSummaries = cs.orderSummaries ?? [];
+      const summary = raw.summary ?? cs.summary ?? orderSummaries[0] ?? {};
+      const lineItems = cs.sessionLineItems ?? [];
+      const customer = cs.customer;
+      const sessionCurrency = (_a = summary.currency ?? cs.selectedPresentmentCurrency) == null ? void 0 : _a.toUpperCase();
+      const items = lineItems.map((li) => {
+        const price = li.price;
+        const variant = li.variant ?? (price == null ? void 0 : price.variant) ?? {};
+        const product = li.product ?? variant.product ?? {};
+        const currencyOpts = (price == null ? void 0 : price.currencyOptions) ?? {};
+        const priceEntry = (sessionCurrency ? currencyOpts[sessionCurrency] : void 0) ?? currencyOpts[Object.keys(currencyOpts)[0]];
+        const amount = (priceEntry == null ? void 0 : priceEntry.amount) ?? 0;
+        return {
+          id: li.id,
+          variantId: li.variantId,
+          priceId: li.priceId,
+          productName: product.name ?? "",
+          variantName: variant.name ?? "",
+          quantity: li.quantity ?? 1,
+          unitAmount: amount,
+          totalAmount: amount * (li.quantity ?? 1),
+          currency: sessionCurrency ?? "USD",
+          imageUrl: variant.imageUrl ?? product.imageUrl ?? ""
+        };
+      });
+      const summaryItems = summary.items ?? [];
+      return {
+        id: cs.id,
+        storeId: cs.storeId,
+        checkoutToken: cs.checkoutToken,
+        currency: sessionCurrency ?? "USD",
+        items,
+        totals: {
+          subtotal: summary.subtotalAmount ?? 0,
+          discount: summary.totalPromotionAmount ?? 0,
+          shipping: summary.shippingCost ?? 0,
+          tax: summary.totalTaxAmount ?? 0,
+          total: summary.totalAmount ?? summaryItems.reduce((s, i) => s + (i.amount ?? 0), 0),
+          currency: sessionCurrency ?? "USD"
+        },
+        customer: customer ? {
+          id: customer.id,
+          email: customer.email,
+          firstName: customer.firstName,
+          lastName: customer.lastName,
+          phone: customer.phone
+        } : void 0,
+        shippingAddress: this.normalizeAddress(cs.shippingAddress),
+        billingAddress: this.normalizeAddress(cs.billingAddress),
+        selectedShippingRateId: cs.shippingRateId ?? null,
+        metadata: cs.metadata
+      };
+    }
+    /**
+     * Map the raw API address shape (`address1`, `address2`, `postal`) onto
+     * the SDK's `Address` shape (`line1`, `line2`, `postalCode`). Without
+     * this, `session.shippingAddress.line1` is silently undefined after a
+     * reload — the type was lying about the actual key names — which is
+     * what makes the demo lose form state on refresh.
+     */
+    normalizeAddress(raw) {
+      if (!raw || typeof raw !== "object")
+        return void 0;
+      const a = raw;
+      const out = {
+        firstName: a.firstName,
+        lastName: a.lastName,
+        line1: a.line1 ?? a.address1,
+        line2: a.line2 ?? a.address2,
+        city: a.city,
+        state: a.state,
+        postalCode: a.postalCode ?? a.postal,
+        country: a.country,
+        phone: a.phone
+      };
+      return Object.values(out).some((v) => v !== void 0 && v !== "") ? out : void 0;
+    }
+  };
+  function stripEmpty(obj) {
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (v !== void 0 && v !== null && v !== "") {
+        result[k] = v;
+      }
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+
+  // src/core/helpers/walletContact.ts
+  function applePayContactToAddress(contact) {
+    var _a, _b;
+    if (!contact)
+      return void 0;
+    const address = {
+      firstName: contact.givenName,
+      lastName: contact.familyName,
+      line1: (_a = contact.addressLines) == null ? void 0 : _a[0],
+      line2: (_b = contact.addressLines) == null ? void 0 : _b[1],
+      city: contact.locality,
+      state: contact.administrativeArea,
+      postalCode: contact.postalCode,
+      country: contact.countryCode,
+      phone: contact.phoneNumber
+    };
+    return isUsable(address) ? address : void 0;
+  }
+  function googlePayContactToAddress(contact) {
+    if (!contact)
+      return void 0;
+    const [firstName, ...rest] = (contact.name ?? "").trim().split(/\s+/);
+    const address = {
+      firstName: firstName || void 0,
+      lastName: rest.length ? rest.join(" ") : void 0,
+      line1: contact.address1,
+      line2: [contact.address2, contact.address3].filter(Boolean).join(" ") || void 0,
+      city: contact.locality,
+      state: contact.administrativeArea,
+      postalCode: contact.postalCode,
+      country: contact.countryCode,
+      phone: contact.phoneNumber
+    };
+    return isUsable(address) ? address : void 0;
+  }
+  function isUsable(address) {
+    var _a, _b;
+    return Boolean(((_a = address.line1) == null ? void 0 : _a.trim()) && ((_b = address.country) == null ? void 0 : _b.trim()));
+  }
+
+  // src/core/modules/payment.ts
+  var PaymentModule = class {
+    constructor(http, storeId, environment, checkout) {
+      this.http = http;
+      this.storeId = storeId;
+      this.environment = environment;
+      this.checkout = checkout;
+    }
+    // ---------------------------------------------------------------------------
+    // Discovery: what payment methods are available?
+    // ---------------------------------------------------------------------------
+    /**
+     * Get the full payment setup config for a checkout session.
+     * Returns a map of payment methods with their configuration
+     * (card, apple_pay, google_pay, klarna, etc.).
+     *
+     * Priority chain:
+     * 1. Explicit `paymentSetupConfig` parameter (developer override)
+     * 2. `window.__TGD_STEP_CONFIG__` injection (Tagada routing infra)
+     * 3. API fallback (`GET /api/v1/payment-methods`)
+     */
+    async getPaymentSetup(checkoutSessionId, opts) {
+      if (opts == null ? void 0 : opts.paymentSetupConfig) {
+        return opts.paymentSetupConfig;
+      }
+      const injected = this.readInjectedStepConfig();
+      if (injected) {
+        return injected;
+      }
+      const methods = await this.http.get(
+        "/api/v1/payment-methods",
+        { params: { checkoutSessionId } }
+      );
+      const config = {};
+      for (const m of methods.methods ?? []) {
+        const key = m.provider ? `${m.method}:${m.provider}` : m.method;
+        config[key] = m;
+      }
+      return config;
+    }
+    /**
+     * Get express payment methods (Apple Pay, Google Pay, PayPal, etc.)
+     * filtered to only those available in the current browser.
+     */
+    async getExpressMethods(checkoutSessionId, opts) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const setup = await this.getPaymentSetup(checkoutSessionId, opts);
+      const result = {};
+      for (const [key, config] of Object.entries(setup)) {
+        if (!config.enabled)
+          continue;
+        if (key.startsWith("express_checkout:") && config.methods) {
+          const base2 = {
+            available: true,
+            processorId: config.processorId,
+            publishableKey: config.publishableKey,
+            metadata: config.metadata
+          };
+          if ((_a = config.methods.apple_pay) == null ? void 0 : _a.enabled) {
+            const hasApplePay = typeof window !== "undefined" && "ApplePaySession" in window && ((_c = (_b = window.ApplePaySession) == null ? void 0 : _b.canMakePayments) == null ? void 0 : _c.call(_b));
+            result.applePay = { ...base2, type: "apple_pay", available: !!hasApplePay };
+          }
+          if ((_d = config.methods.google_pay) == null ? void 0 : _d.enabled) {
+            result.googlePay = { ...base2, type: "google_pay" };
+          }
+          if ((_e = config.methods.link) == null ? void 0 : _e.enabled) {
+            result.link = { ...base2, type: "link" };
+          }
+          if ((_f = config.methods.klarna_express) == null ? void 0 : _f.enabled) {
+            result.klarna = { ...base2, type: "klarna_express" };
+          }
+          continue;
+        }
+        if (!config.express)
+          continue;
+        const method = config.method;
+        const base = {
+          type: method,
+          available: true,
+          processorId: config.processorId,
+          publishableKey: config.publishableKey,
+          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));
+          result.applePay = { ...base, available: !!hasApplePay };
+        } else if (method === "google_pay" || config.type === "google_pay") {
+          result.googlePay = base;
+        } else if (method === "paypal") {
+          result.paypal = base;
+        } else if (method === "klarna" || method === "klarna_express") {
+          result.klarna = base;
+        } else if (method === "link") {
+          result.link = base;
+        }
+      }
+      return result;
+    }
+    /**
+     * Get store-level payment config (3DS flags, default flow ID, etc.).
+     */
+    async getStoreConfig() {
+      const res = await this.http.get(
+        "/api/v1/checkout/config",
+        { params: { storeId: this.storeId } }
+      );
+      return res.config ?? res;
+    }
+    /**
+     * Convenience: return only enabled payment method keys.
+     */
+    async getEnabledMethods(checkoutSessionId, opts) {
+      const setup = await this.getPaymentSetup(checkoutSessionId, opts);
+      return Object.entries(setup).filter(([, c]) => c.enabled).map(([key]) => key);
+    }
+    // ---------------------------------------------------------------------------
+    // Tokenization (delegates to @tagadapay/core-js if available)
+    // ---------------------------------------------------------------------------
+    /**
+     * Tokenize a card using @tagadapay/core-js.
+     * Requires `@tagadapay/core-js` to be installed as a peer dependency.
+     *
+     * Card data is sent directly to Basis Theory for tokenization and never
+     * reaches TagadaPay servers. The returned `tagadaToken` is safe to pass
+     * to the TagadaPay API.
+     *
+     * **PCI note:** Using this method means card data passes through your
+     * JavaScript environment. You are responsible for PCI DSS SAQ-A-EP
+     * compliance. See https://docs.tagada.io/developer-tools/headless-sdk/pci-compliance
+     *
+     * @returns tagadaToken (base64 string) and rawToken with SCA metadata.
+     */
+    async tokenizeCard(card) {
+      const coreJs = await this.loadCoreJs();
+      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
+      await tokenizer.initialize();
+      const sanitized = {
+        cardNumber: card.cardNumber,
+        expiryDate: card.expiryDate,
+        cvc: card.cvc
+      };
+      if (card.cardholderName)
+        sanitized.cardholderName = card.cardholderName;
+      const rawToken = await tokenizer.tokenizeCardRaw(sanitized);
+      const tagadaToken = coreJs.createTagadaToken(
+        rawToken,
+        tokenizer.getProvider().getProviderName()
+      );
+      return { tagadaToken, rawToken };
+    }
+    // ---------------------------------------------------------------------------
+    // Instrument creation
+    // ---------------------------------------------------------------------------
+    /**
+     * Create a reusable payment instrument from a TagadaToken.
+     * Session-authenticated (uses the checkout session JWT).
+     */
+    async createInstrument(opts) {
+      return this.http.post("/api/v1/payment/create-instrument-from-token", {
+        tagadaToken: opts.tagadaToken
+      });
+    }
+    // ---------------------------------------------------------------------------
+    // 3DS
+    // ---------------------------------------------------------------------------
+    /**
+     * Create a 3DS session on the TagadaPay backend.
+     * This persists the session so the processor can use it during payment.
+     */
+    async create3dsSession(opts) {
+      return this.http.post("/api/public/v1/threeds/create-session", {
+        provider: opts.provider ?? "basis_theory",
+        storeId: this.storeId,
+        paymentInstrumentId: opts.paymentInstrumentId,
+        sessionData: opts.sessionData
+      });
+    }
+    // ---------------------------------------------------------------------------
+    // Payment processing
+    // ---------------------------------------------------------------------------
+    /**
+     * High-level pay: single API call that decodes tagadaToken server-side,
+     * creates the payment instrument, and processes payment.
+     *
+     * Also accepts `paymentInstrumentId` directly for pre-created instruments.
+     */
+    async pay(opts) {
+      if (opts.tagadaToken && !opts.paymentInstrumentId) {
+        return this.http.post("/api/v1/payment/pay-with-token", {
+          tagadaToken: opts.tagadaToken,
+          checkoutSessionId: opts.checkoutSessionId,
+          returnUrl: opts.returnUrl,
+          paymentFlowId: opts.paymentFlowId,
+          processorId: opts.processorId,
+          paymentMethod: opts.paymentMethod,
+          isExpress: opts.isExpress,
+          metadata: opts.metadata
+        });
+      }
+      return this.http.post("/api/public/v1/checkout/pay-v2", {
+        checkoutSessionId: opts.checkoutSessionId,
+        paymentInstrumentId: opts.paymentInstrumentId,
+        storeId: this.storeId,
+        paymentFlowId: opts.paymentFlowId,
+        threedsSessionId: opts.threedsSessionId,
+        processorId: opts.processorId,
+        paymentMethod: opts.paymentMethod,
+        isExpress: opts.isExpress,
+        metadata: opts.metadata,
+        returnUrl: opts.returnUrl
+      });
+    }
+    /**
+     * Low-level pay: process payment with an existing instrument or for APM/express flows
+     * where no instrument is needed (redirect-based methods).
+     */
+    async payDirect(opts) {
+      return this.http.post("/api/public/v1/checkout/pay-v2", {
+        checkoutSessionId: opts.checkoutSessionId,
+        paymentInstrumentId: opts.paymentInstrumentId ?? "",
+        storeId: this.storeId,
+        paymentFlowId: opts.paymentFlowId,
+        processorId: opts.processorId,
+        paymentMethod: opts.paymentMethod,
+        isExpress: opts.isExpress,
+        threedsSessionId: opts.threedsSessionId,
+        returnUrl: opts.returnUrl
+      });
+    }
+    /**
+     * Persist a wallet contact onto the session before the charge.
+     *
+     * Express wallets are the one checkout where the buyer never fills an address
+     * form: they approve one inside the sheet, and it comes back on the
+     * authorization event. Studio's `ExpressPaymentWidget` writes it to the
+     * session; the headless path used to drop it, which is how a year of orders
+     * reached merchants with NULL shipping, billing and customer addresses
+     * (#TAG-1989).
+     *
+     * Never invents data: a contact with no street line or no country maps to
+     * `undefined` and the session is left exactly as it was. Failures are NOT
+     * swallowed — if we hold an address and cannot store it, the charge must not
+     * proceed, or we are back to the bug this fixes.
+     */
+    async syncWalletContact(checkoutSessionId, contact) {
+      const { shippingAddress, billingAddress } = contact;
+      if (!shippingAddress && !billingAddress)
+        return;
+      if (!this.checkout) {
+        throw new Error(
+          "PaymentModule cannot persist the wallet contact: no CheckoutModule was provided. Build the SDK through createTagadaClient() rather than constructing PaymentModule directly."
+        );
+      }
+      const customer = {};
+      if (contact.email)
+        customer.email = contact.email;
+      if (contact.phone)
+        customer.phone = contact.phone;
+      if (contact.firstName)
+        customer.firstName = contact.firstName;
+      if (contact.lastName)
+        customer.lastName = contact.lastName;
+      await this.checkout.updateCustomerAndAddress(checkoutSessionId, {
+        customer,
+        shippingAddress,
+        billingAddress
+      });
+    }
+    /**
+     * Process an Apple Pay payment.
+     * Tokenizes the Apple Pay token and processes payment in one call.
+     *
+     * Pass the contacts from `onpaymentauthorized` — `event.payment.billingContact`
+     * and `event.payment.shippingContact` — and they are written to the session
+     * before the charge, so the address the buyer approved in the wallet sheet
+     * lands on the order (#TAG-1989).
+     *
+     * Apple only returns them when the payment request asked for them, so the
+     * `ApplePaySession` request needs:
+     *
+     * ```js
+     * requiredBillingContactFields: ['postalAddress'],
+     * requiredShippingContactFields: ['name', 'phone', 'email', 'postalAddress'],
+     * ```
+     *
+     * @example
+     * session.onpaymentauthorized = async (event) => {
+     *   await tagada.payment.processApplePay({
+     *     checkoutSessionId,
+     *     applePayToken: event.payment.token,
+     *     billingContact: event.payment.billingContact,
+     *     shippingContact: event.payment.shippingContact,
+     *   });
+     * };
+     */
+    async processApplePay(opts) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      await this.syncWalletContact(opts.checkoutSessionId, {
+        shippingAddress: applePayContactToAddress(opts.shippingContact),
+        billingAddress: applePayContactToAddress(opts.billingContact),
+        email: ((_a = opts.shippingContact) == null ? void 0 : _a.emailAddress) ?? ((_b = opts.billingContact) == null ? void 0 : _b.emailAddress),
+        phone: ((_c = opts.shippingContact) == null ? void 0 : _c.phoneNumber) ?? ((_d = opts.billingContact) == null ? void 0 : _d.phoneNumber),
+        firstName: ((_e = opts.shippingContact) == null ? void 0 : _e.givenName) ?? ((_f = opts.billingContact) == null ? void 0 : _f.givenName),
+        lastName: ((_g = opts.shippingContact) == null ? void 0 : _g.familyName) ?? ((_h = opts.billingContact) == null ? void 0 : _h.familyName)
+      });
+      const coreJs = await this.loadCoreJs();
+      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
+      await tokenizer.initialize();
+      const { tagadaToken } = await tokenizer.tokenizeApplePay(opts.applePayToken);
+      return this.pay({
+        checkoutSessionId: opts.checkoutSessionId,
+        tagadaToken,
+        paymentFlowId: opts.paymentFlowId,
+        processorId: opts.processorId,
+        paymentMethod: "apple_pay",
+        isExpress: true
+      });
+    }
+    /**
+     * Process a Google Pay payment.
+     * Tokenizes the Google Pay token and processes payment in one call.
+     *
+     * Pass `paymentData.shippingAddress` / the billing address off
+     * `paymentMethodData.info.billingAddress` and they are persisted to the
+     * session before the charge (#TAG-1989). Google only returns them when the
+     * request sets `shippingAddressRequired` / `billingAddressRequired`.
+     */
+    async processGooglePay(opts) {
+      var _a, _b, _c, _d;
+      await this.syncWalletContact(opts.checkoutSessionId, {
+        shippingAddress: googlePayContactToAddress(opts.shippingAddress),
+        billingAddress: googlePayContactToAddress(opts.billingAddress),
+        email: opts.email ?? ((_a = opts.shippingAddress) == null ? void 0 : _a.emailAddress) ?? ((_b = opts.billingAddress) == null ? void 0 : _b.emailAddress),
+        phone: ((_c = opts.shippingAddress) == null ? void 0 : _c.phoneNumber) ?? ((_d = opts.billingAddress) == null ? void 0 : _d.phoneNumber)
+      });
+      const coreJs = await this.loadCoreJs();
+      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
+      await tokenizer.initialize();
+      const { tagadaToken } = await tokenizer.tokenizeGooglePay(opts.googlePayToken);
+      return this.pay({
+        checkoutSessionId: opts.checkoutSessionId,
+        tagadaToken,
+        paymentFlowId: opts.paymentFlowId,
+        processorId: opts.processorId,
+        paymentMethod: "google_pay",
+        isExpress: true
+      });
+    }
+    /**
+     * Process an APM payment (Klarna, iDEAL, etc.) via redirect.
+     * These typically don't require a payment instrument -- the processor handles the redirect.
+     */
+    async processApm(opts) {
+      return this.payDirect({
+        checkoutSessionId: opts.checkoutSessionId,
+        paymentMethod: opts.paymentMethod,
+        processorId: opts.processorId,
+        paymentFlowId: opts.paymentFlowId
+      });
+    }
+    /**
+     * Initiate a Stripe Express Checkout payment (Apple Pay, Google Pay, Link, etc.).
+     *
+     * Calls `pay-v2` with `isExpress: true`, which returns a `clientSecret` in
+     * `payment.requireActionData.metadata.stripeExpressCheckout.clientSecret`.
+     * The caller must then call `stripe.confirmPayment()` with that secret.
+     *
+     * Used by the `StripeExpressCheckout` class and `useStripeExpress` hook.
+     * Not typically called directly — use the Stripe integration classes instead.
+     */
+    async processStripeExpress(opts) {
+      return this.payDirect({
+        checkoutSessionId: opts.checkoutSessionId,
+        processorId: opts.processorId,
+        paymentMethod: opts.paymentMethod,
+        isExpress: true
+      });
+    }
+    // ---------------------------------------------------------------------------
+    // High-level orchestrator — the ONE function beginners should call
+    // ---------------------------------------------------------------------------
+    /**
+     * Process a payment end-to-end: pay, handle 3DS / redirects, poll until done.
+     *
+     * This is the **recommended** way to process payments. It wraps `pay()`, detects
+     * `requireAction`, runs 3DS challenges (if `@tagadapay/core-js` is installed),
+     * and polls until a terminal status.
+     *
+     * Returns a discriminated union so you can pattern-match on `result.status`:
+     *
+     * @example
+     * ```ts
+     * const result = await payment.processPayment({
+     *   checkoutSessionId: session.id,
+     *   tagadaToken,
+     * });
+     *
+     * switch (result.status) {
+     *   case 'succeeded':
+     *     console.log('Paid!', result.payment.id);
+     *     break;
+     *   case 'requires_redirect':
+     *     // In browser: window.location.href = result.redirectUrl
+     *     // The React hook handles this automatically.
+     *     break;
+     *   case 'failed':
+     *     console.error(result.error);
+     *     break;
+     * }
+     * ```
+     */
+    async processPayment(opts) {
+      if (!opts.returnUrl && typeof window !== "undefined") {
+        opts = { ...opts, returnUrl: window.location.href };
+      }
+      const payResult = await this.pay(opts);
+      return this.finalize(payResult, { returnUrl: opts.returnUrl });
+    }
+    /**
+     * Resolve a raw `PayResult` (from any pay endpoint — `pay()`, `payDirect()`,
+     * `processApplePay()`, `offers.payPreviewedOffer()`, …) into a typed
+     * `ProcessPaymentResult` (`succeeded` / `requires_redirect` / `failed`
+     * / `pending`).
+     *
+     * Handles 3DS routing (modal challenge via core-js, or bank redirect)
+     * and async polling until the payment reaches a terminal status.
+     *
+     * This is the same logic `processPayment()` runs after `pay()` — exposed
+     * so callers (and the offers module) that already have a raw `PayResult`
+     * don't need to re-pay.
+     */
+    async finalize(input, opts) {
+      var _a, _b;
+      const payment = input.payment;
+      const returnUrl = (opts == null ? void 0 : opts.returnUrl) ?? (typeof window !== "undefined" ? window.location.href : void 0);
+      if (payment.status === "succeeded") {
+        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}`;
+        return { status: "failed", error: msg, payment };
+      }
+      if (payment.requireAction && payment.requireAction !== "none" && payment.requireActionData) {
+        return this.handlePaymentAction(payment, { returnUrl });
+      }
+      return this.pollUntilDone(payment.id);
+    }
+    /**
+     * Resume a payment after the user returns from a redirect (3DS, processor auth, APM).
+     *
+     * Called automatically by `usePayment()` in React when it detects return-URL params.
+     * You can also call it manually in non-React apps.
+     */
+    async resumeAfterRedirect(paymentId) {
+      return this.pollUntilDone(paymentId);
+    }
+    /**
+     * Detect a return from a 3DS / processor redirect by inspecting the
+     * current page URL, then poll the payment to completion.
+     *
+     * The post-3DS URL convention used by Tagada-routed processors is
+     * `?paymentAction=requireAction&paymentActionStatus=completed&paymentId=pay_xxx`.
+     * If those params are present, this method polls the payment, cleans the
+     * URL (so a refresh doesn't re-trigger), and returns the resolved
+     * `ProcessPaymentResult`. Otherwise it returns `null`.
+     *
+     * Use this in vanilla apps as the first thing on page load. The React
+     * `usePayment` hook does the same automatically — don't call this when
+     * also using `usePayment`, you'll double-poll.
+     *
+     * @example
+     * ```ts
+     * const tagada = createHeadlessClient({ storeId, environment });
+     *
+     * const resumed = await tagada.payment.maybeResumeFromUrl();
+     * if (resumed?.status === 'succeeded') {
+     *   window.location.href = `/thank-you?orderId=${resumed.order?.id}`;
+     *   return;
+     * }
+     * if (resumed?.status === 'failed') {
+     *   showError(resumed.error);
+     *   return;
+     * }
+     * // No 3DS return — render the normal page.
+     * ```
+     */
+    async maybeResumeFromUrl(opts) {
+      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;
+      try {
+        url = new URL(href);
+      } catch {
+        return null;
+      }
+      const action = url.searchParams.get("paymentAction");
+      const actionStatus = url.searchParams.get("paymentActionStatus");
+      const paymentId = url.searchParams.get("paymentId");
+      if (action !== "requireAction" || actionStatus !== "completed" || !paymentId) {
+        return null;
+      }
+      const result = await this.resumeAfterRedirect(paymentId);
+      if ((opts == null ? void 0 : opts.cleanUrl) !== false && typeof window !== "undefined" && !(opts == null ? void 0 : opts.url)) {
+        const cleanParams = new URLSearchParams(window.location.search);
+        [
+          "paymentAction",
+          "paymentActionStatus",
+          "paymentId",
+          "payment_intent",
+          "payment_intent_client_secret",
+          "source_type",
+          "redirect_status",
+          "sessionId"
+        ].forEach((k) => cleanParams.delete(k));
+        const search = cleanParams.toString();
+        try {
+          window.history.replaceState(
+            {},
+            document.title,
+            window.location.pathname + (search ? "?" + search : "")
+          );
+        } catch {
+        }
+      }
+      return result;
+    }
+    // ---------------------------------------------------------------------------
+    // Status polling
+    // ---------------------------------------------------------------------------
+    /** Get current status of a payment. */
+    async getPaymentStatus(paymentId) {
+      return this.http.get(`/api/v1/payments/${paymentId}`);
+    }
+    /**
+     * Poll a payment until it reaches a terminal status.
+     * Returns the final status or throws on timeout.
+     */
+    async pollPaymentStatus(paymentId, opts) {
+      const interval = (opts == null ? void 0 : opts.intervalMs) ?? 1500;
+      const timeout = (opts == null ? void 0 : opts.timeoutMs) ?? 6e4;
+      const start = Date.now();
+      while (Date.now() - start < timeout) {
+        const status = await this.getPaymentStatus(paymentId);
+        if (status.status === "succeeded" || status.status === "failed" || status.status === "declined") {
+          return status;
+        }
+        await new Promise((r) => setTimeout(r, interval));
+      }
+      throw new Error(`Payment ${paymentId} did not reach terminal status within ${timeout}ms.`);
+    }
+    /** Finalize a payment after a 3DS challenge completes. */
+    async completeAfter3ds(paymentId) {
+      return this.http.post("/api/v1/payments/complete-after-3ds", {
+        paymentId
+      });
+    }
+    /** Tell the server this action has been seen / is being processed. */
+    async markActionProcessed(paymentId) {
+      try {
+        await this.http.post("/api/v1/payments/require-action/processed", {
+          paymentId
+        });
+      } catch {
+      }
+    }
+    // ---------------------------------------------------------------------------
+    // Internal: action routing
+    // ---------------------------------------------------------------------------
+    /**
+     * Route a payment action to the appropriate handler.
+     * Returns `requires_redirect` for browser-level redirects,
+     * or attempts 3DS inline and polls to completion.
+     */
+    async handlePaymentAction(payment, opts) {
+      const actionData = payment.requireActionData;
+      await this.markActionProcessed(payment.id);
+      const actionType = actionData.type;
+      switch (actionType) {
+        case "threeds_auth":
+          return this.handleThreedsAuth(payment, opts);
+        case "processor_auth":
+        case "redirect_to_payment":
+          return this.extractRedirect(payment, actionData);
+        case "redirect":
+          return this.extractRedirect(payment, actionData);
+        case "error":
+          return {
+            status: "failed",
+            error: actionData.message || actionData.errorCode || "Payment failed",
+            payment
+          };
+        default:
+          return this.extractRedirect(payment, actionData);
+      }
+    }
+    /**
+     * Extract redirect info from actionData.
+     * Works for processor_auth (GET or POST), redirect, and any unknown type with a URL.
+     */
+    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) {
+        return {
+          status: "failed",
+          error: `Payment requires action (${actionData.type}) but no redirect URL was provided`,
+          payment
+        };
+      }
+      return {
+        status: "requires_redirect",
+        redirectUrl: url,
+        method: ((_b = redirect == null ? void 0 : redirect.method) == null ? void 0 : _b.toUpperCase()) || "GET",
+        postData: redirect == null ? void 0 : redirect.data,
+        paymentId: payment.id
+      };
+    }
+    /**
+     * Run a 3DS challenge using @tagadapay/core-js.
+     * If core-js is not installed, falls back to redirect.
+     */
+    async handleThreedsAuth(payment, opts) {
+      var _a, _b;
+      const session = (_b = (_a = payment.requireActionData) == null ? void 0 : _a.metadata) == null ? void 0 : _b.threedsSession;
+      if (!(session == null ? void 0 : session.externalSessionId)) {
+        return this.extractRedirect(payment, payment.requireActionData);
+      }
+      let coreJs;
+      try {
+        coreJs = await import("@tagadapay/core-js");
+      } catch {
+        if (session.acsChallengeUrl) {
+          return {
+            status: "requires_redirect",
+            redirectUrl: session.acsChallengeUrl,
+            paymentId: payment.id
+          };
+        }
+        return this.extractRedirect(payment, payment.requireActionData);
+      }
+      try {
+        const manager = new coreJs.ThreedsManager({ provider: "basis_theory" });
+        await manager.initialize({ apiKey: void 0 });
+        await manager.startChallenge({
+          sessionId: session.externalSessionId,
+          acsChallengeUrl: session.acsChallengeUrl,
+          acsTransactionId: session.acsTransID,
+          threeDSVersion: session.messageVersion
+        });
+        await this.completeAfter3ds(payment.id);
+        return this.pollUntilDone(payment.id);
+      } catch {
+        if (session.acsChallengeUrl) {
+          return {
+            status: "requires_redirect",
+            redirectUrl: session.acsChallengeUrl,
+            paymentId: payment.id
+          };
+        }
+        return {
+          status: "failed",
+          error: "3D Secure authentication failed",
+          payment
+        };
+      }
+    }
+    /**
+     * Poll until the payment reaches a terminal status, then return a ProcessPaymentResult.
+     * Also handles new requireAction that may appear during polling.
+     */
+    async pollUntilDone(paymentId, opts) {
+      const interval = (opts == null ? void 0 : opts.intervalMs) ?? 1500;
+      const timeout = (opts == null ? void 0 : opts.timeoutMs) ?? 6e4;
+      const start = Date.now();
+      let consecutiveErrors = 0;
+      while (Date.now() - start < timeout) {
+        let status;
+        try {
+          status = await this.getPaymentStatus(paymentId);
+          consecutiveErrors = 0;
+        } catch {
+          consecutiveErrors++;
+          if (consecutiveErrors >= 3) {
+            return { status: "failed", error: "Payment verification failed due to network errors" };
+          }
+          await new Promise((r) => setTimeout(r, interval));
+          continue;
+        }
+        if (status.status === "succeeded" || status.status === "pending" && status.subStatus === "authorized") {
+          return { status: "succeeded", payment: status, order: status.order };
+        }
+        if (status.status === "failed" || status.status === "declined") {
+          return { status: "failed", error: status.status, payment: status };
+        }
+        if (status.requireAction && status.requireAction !== "none" && status.requireActionData && !status.requireActionData.processed) {
+          return this.handlePaymentAction(
+            status,
+            {}
+          );
+        }
+        await new Promise((r) => setTimeout(r, interval));
+      }
+      return { status: "pending", paymentId };
+    }
+    // ---------------------------------------------------------------------------
+    // Internal helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Read paymentSetupConfig from the Tagada routing injection.
+     * Only available when running on Tagada infra (not on external hosting like Vercel).
+     */
+    readInjectedStepConfig() {
+      if (typeof window === "undefined")
+        return null;
+      const raw = window.__TGD_STEP_CONFIG__;
+      if (!raw)
+        return null;
+      try {
+        const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+        return (parsed == null ? void 0 : parsed.paymentSetupConfig) ?? null;
+      } catch {
+        return null;
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async loadCoreJs() {
+      try {
+        return await import("@tagadapay/core-js");
+      } catch {
+        throw new Error(
+          "This method requires @tagadapay/core-js. Install it: npm install @tagadapay/core-js"
+        );
+      }
+    }
+  };
+
+  // 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}`);
+    }
+    /** 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`
+      );
+    }
+  };
+
+  // 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. */
+    async getOrder(orderId) {
+      const res = await this.http.get(`/api/v1/orders/${orderId}`, {
+        params: { storeId: this.storeId }
+      });
+      return res.order;
+    }
+    /** 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;
+    }
+    /** 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;
+    }
+  };
+
+  // src/core/modules/catalog.ts
+  var CatalogModule = class {
+    constructor(http, storeId) {
+      this.http = http;
+      this.storeId = storeId;
+    }
+    /**
+     * List all active products for the store, including variants and prices.
+     *
+     * @param opts.productIds  Optional filter to specific product IDs.
+     * @param opts.variantIds  Optional filter to products containing these variant IDs.
+     */
+    async getProducts(opts) {
+      var _a, _b;
+      const body = {
+        storeId: this.storeId,
+        includeVariants: true,
+        includePrices: true
+      };
+      if ((_a = opts == null ? void 0 : opts.productIds) == null ? void 0 : _a.length)
+        body.productIds = opts.productIds;
+      if ((_b = opts == null ? void 0 : opts.variantIds) == null ? void 0 : _b.length)
+        body.variantIds = opts.variantIds;
+      const res = await this.http.post(
+        "/api/v1/products",
+        body
+      );
+      return res.items ?? [];
+    }
+    /**
+     * Get a single product by ID.
+     */
+    async getProduct(productId) {
+      const items = await this.getProducts({ productIds: [productId] });
+      return items[0] ?? null;
+    }
+  };
+
+  // src/core/modules/funnel.ts
+  var FunnelModule = class {
+    constructor(http, storeId, checkout, accountId) {
+      this.http = http;
+      this.storeId = storeId;
+      this.checkout = checkout;
+      this.accountId = accountId;
+    }
+    async navigate(input) {
+      var _a;
+      const session = this.checkout.getCurrentSession();
+      if (!session) {
+        throw new TagadaError(
+          "No checkout session loaded. Call sdk.checkout.loadSession(...) before sdk.funnel.navigate(...).",
+          "no_cart_loaded"
+        );
+      }
+      const accountId = input.accountId ?? this.accountId;
+      if (!accountId) {
+        throw new TagadaError(
+          "accountId is required for funnel.navigate(). Set it on createHeadlessClient({ accountId }) or pass it per call.",
+          "missing_account_id"
+        );
+      }
+      const currentUrl = input.currentUrl ?? (typeof globalThis !== "undefined" ? (_a = globalThis.location) == null ? void 0 : _a.href : void 0);
+      await this.ensureCmsSession(session, accountId, input);
+      const funnelSessionId = await this.initializeFunnel({
+        funnelId: input.funnelId,
+        stepId: input.stepId,
+        accountId,
+        currentUrl
+      });
+      const url = await this.runNavigate({
+        funnelSessionId,
+        stepId: input.stepId,
+        session,
+        input,
+        currentUrl
+      });
+      return { url, funnelSessionId };
+    }
+    // -------------------------------------------------------------------------
+    // Internals
+    // -------------------------------------------------------------------------
+    async ensureCmsSession(session, accountId, input) {
+      var _a, _b, _c;
+      if (this._cmsToken && this._cmsSessionId && this._cmsCustomerId)
+        return;
+      const anon = await this.http.post(
+        "/api/v1/cms/session/anonymous",
+        { storeId: this.storeId, role: "anonymous", draft: false }
+      );
+      this._cmsToken = anon.token;
+      this._cmsSessionId = anon.sessionId;
+      const init = await this.http.post(
+        "/api/v1/cms/session/v2/init",
+        {
+          storeId: this.storeId,
+          accountId,
+          customerId: "anon_placeholder",
+          browserLocale: ((_a = input.customer) == null ? void 0 : _a.locale) ?? defaultLocale(),
+          userAgent: defaultUserAgent(),
+          queryCurrency: ((_b = input.customer) == null ? void 0 : _b.currency) ?? session.currency,
+          queryLocale: (_c = input.customer) == null ? void 0 : _c.locale
+        },
+        { token: this._cmsToken }
+      );
+      this._cmsCustomerId = init.customer.id;
+    }
+    async initializeFunnel(args) {
+      const res = await this.http.post(
+        "/api/v1/funnel/initialize",
+        {
+          cmsSession: {
+            customerId: this._cmsCustomerId,
+            sessionId: this._cmsSessionId,
+            storeId: this.storeId,
+            accountId: args.accountId
+          },
+          funnelId: args.funnelId,
+          entryStepId: args.stepId,
+          funnelStepId: args.stepId,
+          currentUrl: args.currentUrl,
+          draft: false
+        },
+        { token: this._cmsToken }
+      );
+      return res.context.sessionId;
+    }
+    async runNavigate(args) {
+      var _a, _b, _c, _d;
+      const { funnelSessionId, stepId, session, input, currentUrl } = args;
+      const lineItems = session.items.map((i) => ({
+        variantId: i.variantId,
+        priceId: i.priceId,
+        quantity: i.quantity
+      }));
+      const discountCodes = input.discountCodes ?? (session.promotionCode ? [session.promotionCode] : void 0);
+      const customer = {
+        email: ((_a = input.customer) == null ? void 0 : _a.email) ?? ((_b = session.customer) == null ? void 0 : _b.email),
+        currency: ((_c = input.customer) == null ? void 0 : _c.currency) ?? session.currency,
+        locale: (_d = input.customer) == null ? void 0 : _d.locale
+      };
+      const res = await this.http.post(
+        "/api/v1/funnel/navigate",
+        {
+          sessionId: funnelSessionId,
+          currentUrl,
+          funnelStepId: stepId,
+          fireAndForget: false,
+          event: {
+            type: "INIT_CHECKOUT",
+            data: {
+              checkoutInit: {
+                cartToken: session.id,
+                lineItems,
+                customer,
+                returnUrl: input.returnUrl,
+                storeId: this.storeId,
+                metadata: input.metadata,
+                discountCodes,
+                // Pins the session to this exact shipping amount when the caller's
+                // storefront already settled one (#TAG-1785). Left undefined when
+                // absent, so it is omitted from the JSON body and the platform
+                // auto-selects a rate exactly as before.
+                externalShipping: input.externalShipping
+              }
+            }
+          }
+        },
+        { token: this._cmsToken }
+      );
+      return res.result.url;
+    }
+  };
+  function defaultLocale() {
+    if (typeof navigator !== "undefined" && navigator.language)
+      return navigator.language;
+    return "en-US";
+  }
+  function defaultUserAgent() {
+    if (typeof navigator !== "undefined" && navigator.userAgent)
+      return navigator.userAgent;
+    return "tagadapay-headless-sdk";
+  }
+
+  // src/core/modules/rx.ts
+  var RxModule = class {
+    constructor(http) {
+      this.http = http;
+    }
+    /**
+     * Check whether a product requires an Rx case. Storefronts call this
+     * before rendering the intake form so they only ask the patient
+     * questions when really necessary.
+     *
+     * Read-only / public — does not require any ownership proof.
+     */
+    async isRequiredForProduct(productId, opts) {
+      return this.http.get("/api/public/v1/rx/required-for-product", {
+        params: {
+          productId,
+          clinicalNetworkId: opts == null ? void 0 : opts.clinicalNetworkId
+        }
+      });
+    }
+    /**
+     * Look up the Rx cases attached to an order. Storefronts poll this
+     * on the thank-you page to render "Your prescription is being
+     * reviewed" → "Shipped" transitions.
+     */
+    async getCasesForOrder(input) {
+      return this.http.post(
+        "/api/public/v1/rx/cases/lookup",
+        input
+      );
+    }
+    /**
+     * Submit a fresh clinical case for a freshly-paid order. PHI is
+     * forwarded to the clinical network and never persisted on
+     * Tagada-side rows.
+     */
+    async submitCase(input) {
+      return this.http.post("/api/public/v1/rx/cases/submit", input);
+    }
+    /**
+     * Fetch the network-authored intake questions for a product.
+     * Empty `questions` means the storefront should use its local quiz.
+     */
+    async getQuestionsForProduct(productId) {
+      return this.http.get("/api/public/v1/rx/questions-for-product", {
+        params: { productId }
+      });
+    }
+  };
+
+  // src/core/client.ts
+  var HeadlessClient = class {
+    constructor(config) {
+      const environment = config.environment ?? "production";
+      const baseUrl = HttpClient.resolveBaseUrl(environment, config.baseUrl);
+      this.config = {
+        ...config,
+        environment,
+        baseUrl,
+        timeout: config.timeout ?? 3e4
+      };
+      this.http = new HttpClient({
+        baseUrl,
+        timeout: this.config.timeout,
+        apiKey: config.apiKey,
+        getToken: () => this._sessionToken
+      });
+      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.offers = new OffersModule(this.http, this.config.storeId, this.payment);
+      this.customer = new CustomerModule(this.http, this.config.storeId);
+      this.catalog = new CatalogModule(this.http, this.config.storeId);
+      this.funnel = new FunnelModule(
+        this.http,
+        this.config.storeId,
+        this.checkout,
+        this.config.accountId
+      );
+      this.rx = new RxModule(this.http);
+    }
+    /** Manually set the session token (e.g. from URL params on page load). */
+    setSessionToken(token) {
+      this._sessionToken = token;
+    }
+  };
+  function createHeadlessClient(config) {
+    return new HeadlessClient(config);
+  }
+
+  // src/core/helpers/autocomplete.ts
+  var scriptInjected = false;
+  var scriptReady = false;
+  var readyCallbacks = [];
+  function onScriptReady() {
+    scriptReady = true;
+    for (const cb of readyCallbacks)
+      cb();
+    readyCallbacks.length = 0;
+  }
+  function loadGoogleMapsScript(apiKey, opts = {}) {
+    var _a, _b;
+    if (scriptReady || ((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places)) {
+      onScriptReady();
+      return Promise.resolve();
+    }
+    if (scriptInjected) {
+      return new Promise((resolve) => readyCallbacks.push(resolve));
+    }
+    scriptInjected = true;
+    return new Promise((resolve, reject) => {
+      readyCallbacks.push(resolve);
+      const existing = document.querySelector('script[src*="maps.googleapis.com"]');
+      if (existing) {
+        const poll = () => {
+          var _a2, _b2;
+          if ((_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) {
+            onScriptReady();
+          } else {
+            setTimeout(poll, 100);
+          }
+        };
+        poll();
+        return;
+      }
+      const params = new URLSearchParams({
+        key: apiKey,
+        libraries: "places",
+        v: opts.version ?? "weekly"
+      });
+      if (opts.language)
+        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);
+    });
+  }
+  var GoogleAutocompleteCore = class _GoogleAutocompleteCore {
+    /** Search for address predictions. */
+    static async searchPlaces(input, options = {}) {
+      var _a, _b;
+      if (!((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places) || !input.trim())
+        return [];
+      const service = new window.google.maps.places.AutocompleteService();
+      return new Promise((resolve) => {
+        service.getPlacePredictions(
+          { input, types: options.types ?? ["address"], componentRestrictions: options.componentRestrictions },
+          (predictions, status) => {
+            var _a2, _b2, _c;
+            resolve(status === ((_c = (_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && predictions ? predictions : []);
+          }
+        );
+      });
+    }
+    /** Get full place details by place_id. */
+    static async getPlaceDetails(placeId) {
+      var _a, _b;
+      if (!((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places))
+        return null;
+      const svc = new window.google.maps.places.PlacesService(document.createElement("div"));
+      return new Promise((resolve) => {
+        svc.getDetails(
+          { placeId, fields: ["place_id", "formatted_address", "address_components", "geometry"] },
+          (place, status) => {
+            var _a2, _b2, _c;
+            resolve(status === ((_c = (_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && place ? place : null);
+          }
+        );
+      });
+    }
+    /** Extract structured address fields from a Google PlaceDetails result. */
+    static extractAddressComponents(place) {
+      const out = {
+        subpremise: "",
+        streetNumber: "",
+        route: "",
+        locality: "",
+        administrativeAreaLevel1: "",
+        administrativeAreaLevel1Long: "",
+        administrativeAreaLevel2: "",
+        administrativeAreaLevel2Long: "",
+        country: "",
+        postalCode: "",
+        fullStreetAddress: ""
+      };
+      let premise = "";
+      let neighborhood = "";
+      let sublocality5 = "", sublocality4 = "", sublocality3 = "", sublocality2 = "", sublocality1 = "";
+      let postalTown = "";
+      for (const c of place.address_components ?? []) {
+        const t = c.types;
+        if (t.includes("subpremise"))
+          out.subpremise = c.long_name;
+        if (t.includes("street_number"))
+          out.streetNumber = c.long_name;
+        if (t.includes("premise"))
+          premise = c.long_name;
+        if (t.includes("route"))
+          out.route = c.long_name;
+        if (t.includes("neighborhood"))
+          neighborhood = c.long_name;
+        if (t.includes("sublocality_level_5"))
+          sublocality5 = c.long_name;
+        if (t.includes("sublocality_level_4"))
+          sublocality4 = c.long_name;
+        if (t.includes("sublocality_level_3"))
+          sublocality3 = c.long_name;
+        if (t.includes("sublocality_level_2"))
+          sublocality2 = c.long_name;
+        if (t.includes("sublocality_level_1"))
+          sublocality1 = c.long_name;
+        if (t.includes("locality"))
+          out.locality = c.long_name;
+        if (t.includes("postal_town"))
+          postalTown = c.long_name;
+        if (t.includes("administrative_area_level_2")) {
+          out.administrativeAreaLevel2 = c.short_name;
+          out.administrativeAreaLevel2Long = c.long_name;
+        }
+        if (t.includes("administrative_area_level_1")) {
+          out.administrativeAreaLevel1 = c.short_name;
+          out.administrativeAreaLevel1Long = c.long_name;
+        }
+        if (t.includes("country"))
+          out.country = c.short_name;
+        if (t.includes("postal_code"))
+          out.postalCode = c.long_name;
+      }
+      if (!out.locality)
+        out.locality = postalTown || sublocality2 || sublocality1 || "";
+      if (!out.administrativeAreaLevel1 && out.administrativeAreaLevel2) {
+        out.administrativeAreaLevel1 = out.administrativeAreaLevel2Long || out.administrativeAreaLevel2;
+        out.administrativeAreaLevel1Long = out.administrativeAreaLevel2Long;
+      }
+      const buildingNumber = out.streetNumber || premise;
+      const streetName = out.route || sublocality5 || sublocality4 || sublocality3 || neighborhood;
+      if (out.subpremise && buildingNumber && streetName) {
+        out.fullStreetAddress = `${out.subpremise}/${buildingNumber} ${streetName}`;
+      } else if (buildingNumber && streetName) {
+        if (premise && sublocality4 && sublocality3) {
+          let addr = `${sublocality3}-${sublocality4}-${premise}`;
+          if (sublocality2)
+            addr = `${addr} ${sublocality2}`;
+          out.fullStreetAddress = addr;
+        } else {
+          out.fullStreetAddress = `${buildingNumber} ${streetName}`;
+        }
+      } else if (streetName) {
+        out.fullStreetAddress = streetName;
+      } else if (buildingNumber) {
+        out.fullStreetAddress = buildingNumber;
+      }
+      out.fullStreetAddress = out.fullStreetAddress.trim();
+      return out;
+    }
+    /** Shorthand: extract into the flat shape used by address forms. */
+    static extractFormattedAddress(place) {
+      const a = _GoogleAutocompleteCore.extractAddressComponents(place);
+      return {
+        address1: a.fullStreetAddress,
+        city: a.locality,
+        country: a.country,
+        state: a.administrativeAreaLevel1,
+        postal: a.postalCode
+      };
+    }
+  };
+
+  // src/core/helpers/iso3166.ts
+  var GEODATA_CDN_BASE = "https://cvwnizdbugpz6jwk.public.blob.vercel-storage.com/geodata/v1";
+  var AVAILABLE_LANGUAGES = ["en", "ru", "de", "da", "fr", "es", "zh", "hi", "pt", "ja", "ar", "it", "he"];
+  var countriesCache = /* @__PURE__ */ new Map();
+  var regionsCache = /* @__PURE__ */ new Map();
+  var inflightCountries = /* @__PURE__ */ new Map();
+  var inflightRegions = /* @__PURE__ */ new Map();
+  async function fetchCountriesRaw(language) {
+    const cached = countriesCache.get(language);
+    if (cached)
+      return cached;
+    let inflight = inflightCountries.get(language);
+    if (inflight)
+      return inflight;
+    inflight = (async () => {
+      const url = `${GEODATA_CDN_BASE}/${language}/countries.json`;
+      const res = await fetch(url);
+      if (!res.ok)
+        throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
+      const data = await res.json();
+      countriesCache.set(language, data);
+      inflightCountries.delete(language);
+      return data;
+    })();
+    inflightCountries.set(language, inflight);
+    return inflight;
+  }
+  async function fetchRegionsRaw(language) {
+    const cached = regionsCache.get(language);
+    if (cached)
+      return cached;
+    let inflight = inflightRegions.get(language);
+    if (inflight)
+      return inflight;
+    inflight = (async () => {
+      const url = `${GEODATA_CDN_BASE}/${language}/regions.json`;
+      const res = await fetch(url);
+      if (!res.ok)
+        throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
+      const data = await res.json();
+      regionsCache.set(language, data);
+      inflightRegions.delete(language);
+      return data;
+    })();
+    inflightRegions.set(language, inflight);
+    return inflight;
+  }
+  function getCountriesCached(language) {
+    return countriesCache.get(language) || countriesCache.get("en") || {};
+  }
+  function getRegionsCached(language) {
+    return regionsCache.get(language) || regionsCache.get("en") || {};
+  }
+  async function ensureGeoDataLoaded(language = "en") {
+    await Promise.all([fetchCountriesRaw(language), fetchRegionsRaw(language)]);
+  }
+  var getCountries = (language = "en") => {
+    const raw = getCountriesCached(language);
+    return Object.entries(raw).map(([code, c]) => ({ code, name: c.n, iso3: c.i3, numeric: c.nu })).sort((a, b) => a.name.localeCompare(b.name));
+  };
+  var getStatesForCountry = (countryCode, language = "en") => {
+    const raw = getRegionsCached(language);
+    const tuples = raw[countryCode];
+    if (!tuples)
+      return [];
+    return tuples.map(([iso, name]) => ({ code: iso, name, countryCode })).sort((a, b) => a.name.localeCompare(b.name));
+  };
+  function isLanguageLoaded(language) {
+    return countriesCache.has(language);
+  }
+
+  // src/core/helpers/countries.ts
+  var ISODataCore = class _ISODataCore {
+    /** Fetch countries + regions from CDN for a language. Call before sync getters. */
+    static ensureLoaded(language = "en") {
+      return ensureGeoDataLoaded(language);
+    }
+    /** Get all countries as a Record keyed by ISO code. */
+    static getCountries(language = "en") {
+      const arr = getCountries(language);
+      const result = {};
+      for (const c of arr) {
+        result[c.code] = { iso: c.code, iso3: c.iso3 ?? "", numeric: c.numeric ?? 0, name: c.name };
+      }
+      return result;
+    }
+    /** Get all countries as a sorted array of { value, label } for select inputs. */
+    static getCountryOptions(language = "en") {
+      return getCountries(language).map((c) => ({ value: c.code, label: c.name }));
+    }
+    /** Get regions/states for a country. */
+    static getRegions(countryCode, language = "en") {
+      return getStatesForCountry(countryCode, language).map((s) => ({ iso: s.code, name: s.name }));
+    }
+    /** Get regions as a sorted array of { value, label } for select inputs. */
+    static getRegionOptions(countryCode, language = "en") {
+      return _ISODataCore.getRegions(countryCode, language).map((r) => ({ value: r.iso, label: r.name }));
+    }
+    /** Find a specific region by ISO code. */
+    static findRegion(countryCode, regionCode, language = "en") {
+      return _ISODataCore.getRegions(countryCode, language).find((r) => r.iso === regionCode) ?? null;
+    }
+    /**
+     * Map a Google Places administrative_area to an ISO region.
+     * Tries exact ISO match, then name match, then partial match.
+     */
+    static mapGoogleToISO(googleState, googleStateLong, countryCode, language = "en") {
+      const regions = _ISODataCore.getRegions(countryCode, language);
+      if (regions.length === 0)
+        return null;
+      let match = regions.find((r) => r.iso === googleState);
+      if (match)
+        return match;
+      match = regions.find((r) => r.name.toLowerCase() === googleState.toLowerCase());
+      if (match)
+        return match;
+      match = regions.find((r) => r.name.toLowerCase() === googleStateLong.toLowerCase());
+      if (match)
+        return match;
+      match = regions.find(
+        (r) => r.name.toLowerCase().includes(googleStateLong.toLowerCase()) || googleStateLong.toLowerCase().includes(r.name.toLowerCase())
+      );
+      return match ?? null;
+    }
+    static isLanguageLoaded(language) {
+      return isLanguageLoaded(language);
+    }
+    static getAvailableLanguages() {
+      return AVAILABLE_LANGUAGES;
+    }
+  };
+
+  // src/core/helpers/currency.ts
+  var SYMBOLS = {
+    USD: "$",
+    EUR: "\u20AC",
+    GBP: "\xA3",
+    JPY: "\xA5",
+    CAD: "C$",
+    AUD: "A$",
+    CHF: "CHF",
+    CNY: "\xA5",
+    SEK: "kr",
+    NOK: "kr",
+    DKK: "kr",
+    PLN: "z\u0142",
+    CZK: "K\u010D",
+    HUF: "Ft",
+    RON: "lei",
+    BGN: "\u043B\u0432",
+    HRK: "kn",
+    RUB: "\u20BD",
+    UAH: "\u20B4",
+    TRY: "\u20BA",
+    BRL: "R$",
+    MXN: "$",
+    ZAR: "R",
+    INR: "\u20B9",
+    KRW: "\u20A9",
+    THB: "\u0E3F",
+    VND: "\u20AB",
+    IDR: "Rp",
+    MYR: "RM",
+    SGD: "S$",
+    PHP: "\u20B1",
+    TWD: "NT$",
+    HKD: "HK$",
+    ILS: "\u20AA",
+    AED: "\u062F.\u0625",
+    SAR: "\u0631.\u0633",
+    QAR: "\u0631.\u0642",
+    KWD: "\u062F.\u0643",
+    BHD: "\u062F.\u0628",
+    OMR: "\u0631.\u0639.",
+    EGP: "\xA3",
+    NGN: "\u20A6",
+    KES: "KSh",
+    GHS: "\u20B5",
+    COP: "$",
+    ARS: "$",
+    CLP: "$",
+    PEN: "S/",
+    CRC: "\u20A1",
+    DOP: "RD$",
+    JMD: "J$",
+    BOB: "Bs",
+    PYG: "\u20B2",
+    GTQ: "Q",
+    NIO: "C$",
+    PAB: "B/.",
+    PKR: "\u20A8",
+    BDT: "\u09F3",
+    LKR: "\u20A8",
+    NPR: "\u20A8",
+    GEL: "\u20BE",
+    AMD: "\u058F",
+    AZN: "\u20BC",
+    KZT: "\u20B8"
+  };
+  var NAMES = {
+    USD: "US Dollar",
+    EUR: "Euro",
+    GBP: "British Pound",
+    JPY: "Japanese Yen",
+    CAD: "Canadian Dollar",
+    AUD: "Australian Dollar",
+    CHF: "Swiss Franc",
+    CNY: "Chinese Yuan",
+    SEK: "Swedish Krona",
+    NOK: "Norwegian Krone",
+    DKK: "Danish Krone",
+    PLN: "Polish Zloty",
+    CZK: "Czech Koruna",
+    HUF: "Hungarian Forint",
+    BRL: "Brazilian Real",
+    MXN: "Mexican Peso",
+    INR: "Indian Rupee",
+    KRW: "South Korean Won",
+    THB: "Thai Baht",
+    SGD: "Singapore Dollar",
+    HKD: "Hong Kong Dollar",
+    TWD: "Taiwan Dollar",
+    ILS: "Israeli Shekel",
+    AED: "UAE Dirham",
+    SAR: "Saudi Riyal",
+    ZAR: "South African Rand",
+    TRY: "Turkish Lira",
+    RUB: "Russian Ruble",
+    NGN: "Nigerian Naira"
+  };
+  var ZERO_DECIMAL = /* @__PURE__ */ new Set([
+    "JPY",
+    "KRW",
+    "VND",
+    "IDR",
+    "LAK",
+    "KHR",
+    "MMK",
+    "PYG"
+  ]);
+  var CurrencyUtils = class _CurrencyUtils {
+    static getSymbol(code) {
+      return SYMBOLS[code] ?? code;
+    }
+    static getName(code) {
+      return NAMES[code] ?? code;
+    }
+    static getDecimalPlaces(code) {
+      return ZERO_DECIMAL.has(code) ? 0 : 2;
+    }
+    static getCurrency(code) {
+      return {
+        code,
+        symbol: _CurrencyUtils.getSymbol(code),
+        name: _CurrencyUtils.getName(code),
+        decimalPlaces: _CurrencyUtils.getDecimalPlaces(code)
+      };
+    }
+  };
+  function formatMoney(amountMinorUnits, currencyCode = "USD", locale = "en-US") {
+    const decimals = CurrencyUtils.getDecimalPlaces(currencyCode);
+    const value = amountMinorUnits / (decimals === 0 ? 100 : Math.pow(10, decimals));
+    try {
+      return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: currencyCode,
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals
+      }).format(value);
+    } catch {
+      return `${CurrencyUtils.getSymbol(currencyCode)}${value.toFixed(decimals)}`;
+    }
+  }
+  return __toCommonJS(core_exports);
+})();
+if(typeof window!=="undefined"&&TagadaHeadlessBundle){  window.TagadaHeadless=TagadaHeadlessBundle;  window.TagadaHeadless.create=TagadaHeadlessBundle.createHeadlessClient;}