@tagadapay/plugin-sdk 4.0.0 → 4.0.2

package/dist/v2/core/funnelClient.d.ts

@@ -164,6 +164,13 @@ export interface RuntimeStepConfig {
         mode: 'inherit' | 'custom';
         enabledUpsellIds?: string[];
     };
+    /** In-step tiered offer selector (swaps cart line items on customer pick).
+     * Backed by the `offers` table; ids reference `offers.id` rows. */
+    checkoutOffers?: {
+        mode: 'inherit' | 'custom';
+        enabledOfferIds?: string[];
+        defaultOfferId?: string;
+    };
     /** @deprecated Use `resources` instead */
     staticResources?: Record<string, string>;
     /** Typed resource bindings (replaces staticResources) */
@@ -175,6 +182,21 @@ export interface RuntimeStepConfig {
         position?: 'head-start' | 'head-end' | 'body-start' | 'body-end';
     }>;
     pixels?: PixelsConfig;
+    /** Per-step shipping rate hide-list. Listed IDs are hidden; everything else visible. */
+    shippingRateSettings?: {
+        hiddenShippingRateIds?: string[];
+    };
+    /** Per-step address form config. */
+    addressSettings?: {
+        /** ISO-3166-1 alpha-2 codes. Empty/missing = all countries allowed. */
+        countryAllowlist?: string[];
+        /** ISO-3166-1 alpha-2. Applied on initial load only, overrides geolocation. */
+        forcedCountry?: string;
+    };
+    /** Payment initiator for upsell/offer charges. MIT = merchant initiated
+     * (off-session, no 3DS). CIT = customer initiated (may trigger 3DS).
+     * Default = 'merchant' (MIT). */
+    paymentInitiator?: 'merchant' | 'customer';
 }
 /**
  * Local funnel configuration for development
@@ -199,6 +221,8 @@ export interface LocalFunnelConfig {
     orderBumps?: RuntimeStepConfig['orderBumps'];
     /** Upsell offer filtering config for local testing */
     upsellOffers?: RuntimeStepConfig['upsellOffers'];
+    /** Checkout offer selector config for local testing */
+    checkoutOffers?: RuntimeStepConfig['checkoutOffers'];
 }
 /**
  * Load local funnel config from /config/funnel.local.json (for local dev only)
@@ -243,6 +267,11 @@ export declare function getAssignedStepConfig(): RuntimeStepConfig | undefined;
  *   4. meta[name="x-payment-flow-id"]          (legacy meta tag)
  */
 export declare function getAssignedPaymentFlowId(): string | undefined;
+/**
+ * Get the payment initiator override from step config.
+ * Returns 'merchant' (MIT) or 'customer' (CIT) — undefined means "use default".
+ */
+export declare function getAssignedPaymentInitiator(): 'merchant' | 'customer' | undefined;
 /**
  * Get resource bindings from step config.
  * Reads from `resources` (new) with `staticResources` (legacy) as fallback, merged.
@@ -271,6 +300,17 @@ export declare function getAssignedOrderBumpOfferIds(): string[] | undefined;
  * Returns the explicit list when mode is 'custom'.
  */
 export declare function getAssignedUpsellOfferIds(): string[] | undefined;
+/**
+ * Get the enabled in-step checkout-offer IDs (offers.id rows) for this step.
+ * Returns undefined when mode is 'inherit' (surface all store offers).
+ * Returns the explicit ordered list when mode is 'custom'.
+ */
+export declare function getAssignedCheckoutOfferIds(): string[] | undefined;
+/**
+ * Get the default checkout-offer ID (offers.id) configured for this step.
+ * Returns undefined when no default is configured.
+ */
+export declare function getAssignedCheckoutOfferDefault(): string | undefined;
 export interface FunnelClientConfig {
     apiClient: ApiClient;
     debugMode?: boolean;

package/dist/v2/core/funnelClient.js

@@ -226,6 +226,7 @@ function localConfigToStepConfig(local) {
         pixels: local.pixels,
         orderBumps: local.orderBumps,
         upsellOffers: local.upsellOffers,
+        checkoutOffers: local.checkoutOffers,
     };
 }
 /**
@@ -300,6 +301,14 @@ export function getAssignedPaymentFlowId() {
     }
     return undefined;
 }
+/**
+ * Get the payment initiator override from step config.
+ * Returns 'merchant' (MIT) or 'customer' (CIT) — undefined means "use default".
+ */
+export function getAssignedPaymentInitiator() {
+    const stepConfig = getAssignedStepConfig();
+    return stepConfig?.paymentInitiator;
+}
 /**
  * Get resource bindings from step config.
  * Reads from `resources` (new) with `staticResources` (legacy) as fallback, merged.
@@ -401,6 +410,27 @@ export function getAssignedUpsellOfferIds() {
         return undefined;
     return stepConfig.upsellOffers.enabledUpsellIds;
 }
+/**
+ * Get the enabled in-step checkout-offer IDs (offers.id rows) for this step.
+ * Returns undefined when mode is 'inherit' (surface all store offers).
+ * Returns the explicit ordered list when mode is 'custom'.
+ */
+export function getAssignedCheckoutOfferIds() {
+    const stepConfig = getAssignedStepConfig();
+    if (!stepConfig?.checkoutOffers)
+        return undefined;
+    if (stepConfig.checkoutOffers.mode !== 'custom')
+        return undefined;
+    return stepConfig.checkoutOffers.enabledOfferIds;
+}
+/**
+ * Get the default checkout-offer ID (offers.id) configured for this step.
+ * Returns undefined when no default is configured.
+ */
+export function getAssignedCheckoutOfferDefault() {
+    const stepConfig = getAssignedStepConfig();
+    return stepConfig?.checkoutOffers?.defaultOfferId;
+}
 export class FunnelClient {
     constructor(config) {
         this.eventDispatcher = new EventDispatcher();

package/dist/v2/core/pixelTracker.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Framework-agnostic pixel tracker.
+ *
+ * Init / fire logic for Meta, TikTok, Snapchat, Pinterest, GTM/GA4 pixels —
+ * extracted from `react/hooks/usePixelTracking.tsx` so non-React entry points
+ * (Studio islands hydrator, full-SPA runtime) can fire pixel events from
+ * `window.__TGD_STEP_CONFIG__.pixels`.
+ *
+ * The React provider is a thin adapter on top of this module.
+ */
+import type { PixelsConfig } from './funnelClient';
+import { type StandardPixelEvent } from './pixelMapping';
+/**
+ * Optional per-event tracking metadata. `eventId` is the cross-channel dedup
+ * key that the SDK threads to `fbq` (Meta) and `ttq` (TikTok) so the same
+ * eventID/event_id can be matched against a server-side CAPI event. Use the
+ * `makeMetaEventId(eventName, entityId)` helper from `core/utils/metaEventId`
+ * to keep the formula in lockstep with the server.
+ */
+export interface TrackOptions {
+    eventId?: string;
+}
+export interface PixelTracker {
+    /** Resolves once all pixel scripts have loaded (or hit their load timeout). */
+    readonly initPromise: Promise<void>;
+    /** True after `initPromise` resolves. */
+    readonly pixelsInitialized: boolean;
+    /** Track a standard pixel event. No-ops until init resolves. */
+    track(eventName: StandardPixelEvent, parameters?: Record<string, unknown>, options?: TrackOptions): void;
+}
+/**
+ * Create a pixel tracker for a given pixels config.
+ * Kicks off pixel script init immediately, fires PageView once init resolves,
+ * and returns a `track()` function that no-ops until init completes.
+ */
+export declare function createPixelTracker(pixels: PixelsConfig | undefined): PixelTracker;
+declare global {
+    interface Window {
+        __TGD_PIXEL_TRACKER__?: PixelTracker;
+        __TGD_STEP_CONFIG__?: string | Record<string, unknown>;
+    }
+}
+/**
+ * One-shot bootstrap: reads `window.__TGD_STEP_CONFIG__.pixels`, creates a
+ * tracker, kicks off init, and stashes it on `window.__TGD_PIXEL_TRACKER__`.
+ *
+ * Idempotent — both the islands SDK and the full-SPA runtime may call this,
+ * but only the first call creates a tracker. Returns the active tracker
+ * (existing or newly created), or null if there's no window or no pixels.
+ */
+export declare function bootstrapPixelTrackerFromWindow(): PixelTracker | null;

package/dist/v2/core/pixelTracker.js

@@ -0,0 +1,425 @@
+/**
+ * Framework-agnostic pixel tracker.
+ *
+ * Init / fire logic for Meta, TikTok, Snapchat, Pinterest, GTM/GA4 pixels —
+ * extracted from `react/hooks/usePixelTracking.tsx` so non-React entry points
+ * (Studio islands hydrator, full-SPA runtime) can fire pixel events from
+ * `window.__TGD_STEP_CONFIG__.pixels`.
+ *
+ * The React provider is a thin adapter on top of this module.
+ */
+import { resolvePixelEvents, } from './pixelMapping';
+// ---------------------------------------------------------------------------
+// Duplicate guard (time-window based)
+// ---------------------------------------------------------------------------
+function createDuplicateGuard(windowMs) {
+    const lastEvents = new Map();
+    return (eventName, parameters, eventId) => {
+        try {
+            // Include eventId in the dedup key so two distinct logical events with the
+            // same name+params (e.g. two Purchases) are not collapsed by the guard.
+            const key = JSON.stringify({ eventName, parameters, eventId });
+            const now = Date.now();
+            const last = lastEvents.get(key);
+            if (last && now - last < windowMs)
+                return false;
+            lastEvents.set(key, now);
+            return true;
+        }
+        catch {
+            return true;
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Browser-specific: fire an event to the correct global pixel function
+// ---------------------------------------------------------------------------
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function fire(provider, name, params, pixel, options = {}) {
+    if (typeof window === 'undefined')
+        return;
+    const w = window;
+    const eventId = options.eventId;
+    switch (provider) {
+        case 'facebook':
+            // Meta dedup: pass eventID as the 4th-arg `eventID` option so this
+            // browser-pixel event matches a server-side CAPI event with the same id.
+            // See https://developers.facebook.com/docs/marketing-api/conversions-api/deduplicate-pixel-and-server-events
+            if (eventId)
+                w.fbq?.('track', name, params, { eventID: eventId });
+            else
+                w.fbq?.('track', name, params);
+            break;
+        case 'tiktok': {
+            // Use ttq.instance(pixelId) to target each pixel individually,
+            // since the global ttq.track() only fires for the sdkid pixel.
+            const pixelId = pixel && 'pixelId' in pixel ? pixel.pixelId : null;
+            const target = pixelId && w.ttq?.instance ? w.ttq.instance(pixelId) : w.ttq;
+            if (name === 'Pageview') {
+                target?.page?.();
+            }
+            else if (eventId) {
+                target?.track?.(name, params, { event_id: eventId });
+            }
+            else {
+                target?.track?.(name, params);
+            }
+            break;
+        }
+        case 'snapchat':
+            w.snaptr?.('track', name, params);
+            break;
+        case 'pinterest':
+            // Pinterest handles page views via pintrk('page'), not pintrk('track', 'pagevisit')
+            if (name === 'pagevisit') {
+                w.pintrk?.('page');
+            }
+            else {
+                w.pintrk?.('track', name, params);
+            }
+            break;
+        case 'gtm':
+            fireGTM(name, params);
+            break;
+    }
+}
+function fireGTM(event, params) {
+    try {
+        const w = window;
+        if (w.gtag) {
+            w.gtag('event', event, params);
+        }
+        else if (w.dataLayer) {
+            w.dataLayer.push({ event, ...params });
+        }
+    }
+    catch (error) {
+        console.error('[SDK GTM] Error:', error);
+    }
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+// ===========================================================================
+// Pixel initialization (browser-only)
+// All pixel globals are accessed via `win` typed as `any` to avoid
+// `declare global` augmentation issues across tsconfig scopes.
+// ===========================================================================
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const win = (typeof window !== 'undefined' ? window : undefined);
+const SCRIPT_LOAD_TIMEOUT_MS = 5000;
+function waitForScriptLoad(script) {
+    // If the script has already loaded, resolve immediately
+    if (script.dataset.loaded)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const done = () => { script.dataset.loaded = '1'; clearTimeout(timer); resolve(); };
+        const timer = setTimeout(done, SCRIPT_LOAD_TIMEOUT_MS);
+        script.addEventListener('load', done, { once: true });
+        script.addEventListener('error', done, { once: true });
+    });
+}
+let _metaScriptEl = null;
+function initMetaPixel(pixelId) {
+    if (!win)
+        return Promise.resolve();
+    // Initialize Meta base code once
+    if (!win.fbq) {
+        const n = function (...args) {
+            if (n.callMethod)
+                n.callMethod(...args);
+            else
+                n.queue.push(args);
+        };
+        n.queue = [];
+        n.loaded = true;
+        n.version = '2.0';
+        win.fbq = n;
+        if (!win._fbq)
+            win._fbq = n;
+        const t = document.createElement('script');
+        t.async = true;
+        t.src = 'https://connect.facebook.net/en_US/fbevents.js';
+        const s = document.getElementsByTagName('script')[0];
+        s?.parentNode?.insertBefore(t, s);
+        _metaScriptEl = t;
+    }
+    // Register each pixel ID (fbq supports multiple pixels via multiple init calls)
+    win.fbq('init', pixelId);
+    return _metaScriptEl ? waitForScriptLoad(_metaScriptEl) : Promise.resolve();
+}
+let _tiktokBaseInitialized = false;
+function initTikTokPixel(pixelId) {
+    if (!win)
+        return Promise.resolve();
+    // Initialize TikTok base code once
+    if (!_tiktokBaseInitialized) {
+        _tiktokBaseInitialized = true;
+        win.TiktokAnalyticsObject = 'ttq';
+        const ttq = (win.ttq = win.ttq || []);
+        ttq.methods = [
+            'page', 'track', 'identify', 'instances', 'debug', 'on', 'off',
+            'once', 'ready', 'alias', 'group', 'enableCookie', 'disableCookie',
+            'holdConsent', 'revokeConsent', 'grantConsent',
+        ];
+        ttq.setAndDefer = function (t, e) {
+            t[e] = function (...args) { t.push([e, ...args]); };
+        };
+        for (const method of ttq.methods) {
+            ttq.setAndDefer(ttq, method);
+        }
+        ttq.instance = function (t) {
+            const e = ttq._i[t] || [];
+            for (const method of ttq.methods) {
+                ttq.setAndDefer(e, method);
+            }
+            return e;
+        };
+        ttq.load = function (e, n) {
+            const r = 'https://analytics.tiktok.com/i18n/pixel/events.js';
+            ttq._i = ttq._i || {};
+            ttq._i[e] = [];
+            ttq._i[e]._u = r;
+            ttq._t = ttq._t || {};
+            ttq._t[e] = +new Date();
+            ttq._o = ttq._o || {};
+            ttq._o[e] = n || {};
+            const s = document.createElement('script');
+            s.type = 'text/javascript';
+            s.async = true;
+            s.src = r + '?sdkid=' + e + '&lib=ttq';
+            const p = document.getElementsByTagName('script')[0];
+            p?.parentNode?.insertBefore(s, p);
+        };
+    }
+    // Skip if this specific pixel ID is already registered
+    if (win.ttq._i?.[pixelId])
+        return Promise.resolve();
+    // Register pixel and load its script
+    win.ttq.load(pixelId);
+    // Find the script we just created and wait for it
+    const scripts = document.querySelectorAll('script[src*="analytics.tiktok.com/i18n/pixel/events.js"]');
+    const lastScript = scripts[scripts.length - 1];
+    return lastScript ? waitForScriptLoad(lastScript) : Promise.resolve();
+}
+let _snapchatScriptEl = null;
+function initSnapchatPixel(pixelId) {
+    if (!win)
+        return Promise.resolve();
+    // Initialize Snapchat base code once
+    if (!win.snaptr) {
+        const a = function (...args) {
+            if (a.handleRequest)
+                a.handleRequest(...args);
+            else
+                a.queue.push(args);
+        };
+        a.queue = [];
+        win.snaptr = a;
+        const r = document.createElement('script');
+        r.async = true;
+        r.src = 'https://sc-static.net/scevent.min.js';
+        const u = document.getElementsByTagName('script')[0];
+        u?.parentNode?.insertBefore(r, u);
+        _snapchatScriptEl = r;
+    }
+    // Register each pixel ID (snaptr supports multiple pixels via multiple init calls)
+    win.snaptr('init', pixelId);
+    return _snapchatScriptEl ? waitForScriptLoad(_snapchatScriptEl) : Promise.resolve();
+}
+let _pinterestScriptEl = null;
+function initPinterestPixel(pixelId) {
+    if (!win)
+        return Promise.resolve();
+    // Initialize Pinterest base code once
+    if (!win.pintrk) {
+        const a = function (...args) { a.queue.push(args); };
+        a.queue = [];
+        win.pintrk = a;
+        const s = document.createElement('script');
+        s.async = true;
+        s.src = 'https://s.pinimg.com/ct/core.js';
+        const u = document.getElementsByTagName('script')[0];
+        u?.parentNode?.insertBefore(s, u);
+        _pinterestScriptEl = s;
+    }
+    // Register each pixel ID (pintrk supports multiple pixels via multiple load calls)
+    win.pintrk('load', pixelId);
+    // Note: pintrk('page') is NOT called here — the auto page-view fires via fire().
+    return _pinterestScriptEl ? waitForScriptLoad(_pinterestScriptEl) : Promise.resolve();
+}
+function initGTM(containerId) {
+    if (!win || !containerId)
+        return Promise.resolve();
+    const isGtmContainer = containerId.startsWith('GTM-');
+    const scriptUrlPart = isGtmContainer
+        ? `googletagmanager.com/gtm.js?id=${containerId}`
+        : `googletagmanager.com/gtag/js?id=${containerId}`;
+    if (document.querySelector(`script[src*="${scriptUrlPart}"]`))
+        return Promise.resolve();
+    win.dataLayer = win.dataLayer || [];
+    // Push referrer domain context into dataLayer before GTM loads, so tags
+    // inside the container can use it for cross-domain tracking configuration.
+    try {
+        const ref = document.referrer && new URL(document.referrer).hostname;
+        if (ref && ref !== window.location.hostname) {
+            win.dataLayer.push({ tagada_referrer_domain: ref });
+        }
+    }
+    catch { /* ignore invalid referrer */ }
+    if (isGtmContainer) {
+        win.dataLayer.push({ 'gtm.start': new Date().getTime(), event: 'gtm.js' });
+        const f = document.getElementsByTagName('script')[0];
+        const j = document.createElement('script');
+        j.async = true;
+        j.src = 'https://www.googletagmanager.com/gtm.js?id=' + containerId;
+        if (f?.parentNode)
+            f.parentNode.insertBefore(j, f);
+        else
+            (document.head || document.getElementsByTagName('head')[0])?.appendChild(j);
+        const noscript = document.createElement('noscript');
+        const iframe = document.createElement('iframe');
+        iframe.src = `https://www.googletagmanager.com/ns.html?id=${containerId}`;
+        iframe.height = '0';
+        iframe.width = '0';
+        iframe.style.display = 'none';
+        iframe.style.visibility = 'hidden';
+        noscript.appendChild(iframe);
+        (document.body || document.getElementsByTagName('body')[0])?.insertBefore(noscript, document.body?.firstChild ?? null);
+        return waitForScriptLoad(j);
+    }
+    else {
+        if (!win.gtag) {
+            win.gtag = function (..._args) { win.dataLayer.push(arguments); };
+        }
+        win.gtag('js', new Date());
+        // Enable cross-domain tracking: accept incoming _gl parameter from referring
+        // domains (e.g. Shopify store → TagadaPay checkout) so Google preserves the
+        // client-id/session across the redirect.
+        const linkerConfig = { accept_incoming: true };
+        try {
+            const ref = document.referrer && new URL(document.referrer).hostname;
+            if (ref && ref !== window.location.hostname) {
+                linkerConfig.domains = [ref, window.location.hostname];
+            }
+        }
+        catch { /* ignore invalid referrer */ }
+        win.gtag('config', containerId, { linker: linkerConfig });
+        const script = document.createElement('script');
+        script.async = true;
+        script.src = 'https://www.googletagmanager.com/gtag/js?id=' + containerId;
+        const firstScript = document.getElementsByTagName('script')[0];
+        if (firstScript?.parentNode)
+            firstScript.parentNode.insertBefore(script, firstScript);
+        else
+            (document.head || document.getElementsByTagName('head')[0])?.appendChild(script);
+        return waitForScriptLoad(script);
+    }
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+// ---------------------------------------------------------------------------
+// Tracker factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a pixel tracker for a given pixels config.
+ * Kicks off pixel script init immediately, fires PageView once init resolves,
+ * and returns a `track()` function that no-ops until init completes.
+ */
+export function createPixelTracker(pixels) {
+    const shouldTrackEvent = createDuplicateGuard(5000);
+    let pixelsInitialized = false;
+    const initPromise = (async () => {
+        if (!pixels || typeof window === 'undefined')
+            return;
+        const loadPromises = [];
+        try {
+            pixels.facebook?.forEach((px) => { if (px.enabled && px.pixelId)
+                loadPromises.push(initMetaPixel(px.pixelId)); });
+            pixels.tiktok?.forEach((px) => { if (px.enabled && px.pixelId)
+                loadPromises.push(initTikTokPixel(px.pixelId)); });
+            pixels.snapchat?.forEach((px) => { if (px.enabled && px.pixelId)
+                loadPromises.push(initSnapchatPixel(px.pixelId)); });
+            pixels.pinterest?.forEach((px) => { if (px.enabled && px.pixelId)
+                loadPromises.push(initPinterestPixel(px.pixelId)); });
+            pixels.gtm?.forEach((px) => { if (px.enabled && px.containerId)
+                loadPromises.push(initGTM(px.containerId)); });
+            await Promise.all(loadPromises);
+        }
+        catch (error) {
+            console.error('[SDK Pixels] Initialization error:', error);
+        }
+        pixelsInitialized = true;
+    })();
+    const track = (eventName, parameters = {}, options = {}) => {
+        if (!pixels || !pixelsInitialized)
+            return;
+        if (!shouldTrackEvent(eventName, parameters, options.eventId))
+            return;
+        try {
+            const events = resolvePixelEvents(pixels, eventName, parameters);
+            // Deduplicate by provider: Meta/Snapchat/Pinterest SDKs broadcast
+            // to all registered pixel IDs internally, so we only need to fire once per
+            // provider. GTM and TikTok need per-pixel firing (GTM for Google Ads
+            // send_to targeting, TikTok because ttq.instance() targets a specific pixel).
+            const firedProviders = new Set();
+            for (const { provider, mapped, pixel } of events) {
+                if (provider === 'gtm' || provider === 'tiktok') {
+                    fire(provider, mapped.name, mapped.params, pixel, options);
+                }
+                else {
+                    if (!firedProviders.has(provider)) {
+                        fire(provider, mapped.name, mapped.params, undefined, options);
+                        firedProviders.add(provider);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('[SDK Pixels] Tracking error:', error);
+        }
+    };
+    // Auto page-view: fire once after init resolves.
+    initPromise.then(() => {
+        if (typeof window === 'undefined')
+            return;
+        track('PageView', { path: window.location.pathname });
+    });
+    return {
+        initPromise,
+        get pixelsInitialized() { return pixelsInitialized; },
+        track,
+    };
+}
+function readPixelsFromStepConfig() {
+    if (typeof window === 'undefined')
+        return undefined;
+    const raw = window.__TGD_STEP_CONFIG__;
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        const pixels = parsed?.pixels;
+        return pixels && typeof pixels === 'object' ? pixels : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * One-shot bootstrap: reads `window.__TGD_STEP_CONFIG__.pixels`, creates a
+ * tracker, kicks off init, and stashes it on `window.__TGD_PIXEL_TRACKER__`.
+ *
+ * Idempotent — both the islands SDK and the full-SPA runtime may call this,
+ * but only the first call creates a tracker. Returns the active tracker
+ * (existing or newly created), or null if there's no window or no pixels.
+ */
+export function bootstrapPixelTrackerFromWindow() {
+    if (typeof window === 'undefined')
+        return null;
+    if (window.__TGD_PIXEL_TRACKER__)
+        return window.__TGD_PIXEL_TRACKER__;
+    const pixels = readPixelsFromStepConfig();
+    if (!pixels)
+        return null;
+    const tracker = createPixelTracker(pixels);
+    window.__TGD_PIXEL_TRACKER__ = tracker;
+    return tracker;
+}

package/dist/v2/core/resources/checkout.d.ts

@@ -4,6 +4,7 @@
  */
 import type { OrderAddress } from '../types';
 import { ApiClient } from './apiClient';
+import { EventBus } from '../utils/eventBus';
 export type PaymentMethodName = 'card' | 'paypal' | 'klarna' | 'apple_pay' | 'google_pay' | 'link' | 'bridge' | 'whop' | 'zelle' | 'hipay' | 'crypto' | 'convesiopay' | 'oceanpayment' | 'afterpay' | 'ideal' | 'bancontact' | 'giropay' | 'sepa_debit' | (string & {});
 export interface CheckoutLineItem {
     externalProductId?: string | null;
@@ -86,6 +87,43 @@ export interface Upsell {
     triggers: UpsellTrigger[];
     orderBumpOffers: CheckoutOrderBumpOffer[];
 }
+export interface CheckoutOfferLineItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    priceId: string;
+    quantity: number;
+    variant?: {
+        id: string;
+        name?: string | null;
+        imageUrl?: string | null;
+    } | null;
+    product?: {
+        id: string;
+        name?: string | null;
+    } | null;
+    price?: {
+        id: string;
+        currencyOptions?: Record<string, {
+            amount: number;
+        }> | null;
+    } | null;
+}
+/** Tiered checkout offer (offers row, type='checkout_offer'), nested into the
+ * checkout session response alongside store.upsells so the same fetch path
+ * delivers both. The CheckoutOfferSelector chunk consumes these. */
+export interface CheckoutOfferRecord {
+    id: string;
+    type: string;
+    titleTrans: Record<string, string>;
+    summaries?: Array<{
+        currency?: string;
+        totalAmount?: number;
+        totalAdjustedAmount?: number;
+        [key: string]: unknown;
+    }> | null;
+    offerLineItems: CheckoutOfferLineItem[];
+}
 export interface Store {
     id: string;
     accountId: string;
@@ -93,6 +131,7 @@ export interface Store {
     presentmentCurrencies: string[];
     chargeCurrencies: string[];
     upsells: Upsell[];
+    offers?: CheckoutOfferRecord[];
     emailDomains: string[];
     integrations: unknown[];
 }
@@ -302,7 +341,8 @@ export interface CheckoutData {
 }
 export declare class CheckoutResource {
     private apiClient;
-    constructor(apiClient: ApiClient);
+    private bus?;
+    constructor(apiClient: ApiClient, bus?: EventBus | undefined);
     /**
      * Initialize a new checkout session (sync mode)
      * Response time: 2-5 seconds (full processing)
@@ -505,6 +545,10 @@ export declare class CheckoutResource {
         shippingAddress: Partial<OrderAddress>;
         billingAddress?: Partial<OrderAddress>;
         differentBillingAddress?: boolean;
+        cartCustomAttributes?: Array<{
+            name: string;
+            value: string;
+        }>;
     }): Promise<{
         success: boolean;
         errors?: Record<string, {