@tagadapay/plugin-sdk 3.0.9 → 3.0.14

package/dist/react/types.d.ts

@@ -7,7 +7,9 @@ export interface ApiConfig {
     endpoints: {
         checkout: {
             sessionInit: string;
+            sessionInitAsync: string;
             sessionStatus: string;
+            asyncStatus: string;
         };
         customer: {
             profile: string;

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

@@ -101,6 +101,10 @@ export declare class TagadaClient {
      * Initialize token and session
      */
     private initializeToken;
+    /**
+     * Normal token initialization flow (no cross-domain handoff)
+     */
+    private fallbackToNormalFlow;
     /**
      * Set token and resolve waiting requests
      */

package/dist/v2/core/client.js

@@ -8,6 +8,7 @@ import { decodeJWTClient, isTokenExpired } from './utils/jwtDecoder';
 import { loadPluginConfig } from './utils/pluginConfig';
 import { handlePreviewMode, isDraftMode, setDraftMode } from './utils/previewMode';
 import { getClientToken, setClientToken } from './utils/tokenStorage';
+import { shouldResolveAuthCode, resolveAuthHandoff } from './utils/authHandoff';
 export class TagadaClient {
     constructor(config = {}) {
         /**
@@ -25,9 +26,13 @@ export class TagadaClient {
         this.config = config;
         this.instanceId = Math.random().toString(36).substr(2, 9);
         this.boundHandleStorageChange = this.handleStorageChange.bind(this);
-        if (this.config.debugMode) {
-            console.log(`[TagadaClient ${this.instanceId}] Initializing...`);
-        }
+        console.log(`[TagadaClient ${this.instanceId}] Initializing...`);
+        console.log(`[TagadaClient ${this.instanceId}] Config:`, {
+            debugMode: config.debugMode,
+            hasRawPluginConfig: !!config.rawPluginConfig,
+            rawPluginConfig: config.rawPluginConfig,
+            features: config.features,
+        });
         // Handle preview mode FIRST - clears state if needed
         // This ensures clean state when CRM previews pages
         const previewModeActive = handlePreviewMode(this.config.debugMode);
@@ -77,10 +82,14 @@ export class TagadaClient {
             isInitialized: false,
             isSessionInitialized: false,
             pluginConfig: { basePath: '/', config: {} },
-            pluginConfigLoading: !config.rawPluginConfig,
+            pluginConfigLoading: true, // Always true - loadPluginConfig will process rawPluginConfig
             debugMode: config.debugMode ?? env !== 'production',
             token: null,
         };
+        console.log(`[TagadaClient ${this.instanceId}] Initial state:`, {
+            pluginConfigLoading: this.state.pluginConfigLoading,
+            hasRawPluginConfig: !!config.rawPluginConfig,
+        });
         // Initialize API Client
         this.apiClient = new ApiClient({
             baseURL: envConfig.apiConfig.baseUrl,
@@ -96,6 +105,9 @@ export class TagadaClient {
                 pluginConfig: this.state.pluginConfig,
                 environment: this.state.environment,
                 autoRedirect: funnelConfig.autoRedirect,
+                // Pass funnelId and stepId from rawPluginConfig to enable config-based initialization
+                funnelId: config.rawPluginConfig?.funnelId,
+                stepId: config.rawPluginConfig?.stepId,
             });
         }
         // Setup token waiting mechanism
@@ -206,11 +218,19 @@ export class TagadaClient {
      * Load plugin configuration
      */
     async initializePluginConfig() {
-        if (!this.state.pluginConfigLoading)
+        console.log(`[TagadaClient ${this.instanceId}] initializePluginConfig called`, {
+            pluginConfigLoading: this.state.pluginConfigLoading,
+            hasRawPluginConfig: !!this.config.rawPluginConfig,
+        });
+        if (!this.state.pluginConfigLoading) {
+            console.log(`[TagadaClient ${this.instanceId}] Plugin config already loading or loaded, skipping...`);
             return;
+        }
         try {
             const configVariant = this.config.localConfig || 'default';
+            console.log(`[TagadaClient ${this.instanceId}] Loading plugin config with variant: ${configVariant}`);
             const config = await loadPluginConfig(configVariant, this.config.rawPluginConfig);
+            console.log(`[TagadaClient ${this.instanceId}] Plugin config loaded:`, config);
             this.updateState({
                 pluginConfig: config,
                 pluginConfigLoading: false,
@@ -222,9 +242,6 @@ export class TagadaClient {
                     environment: this.state.environment,
                 });
             }
-            if (this.state.debugMode) {
-                console.log('[TagadaClient] Plugin config loaded:', config);
-            }
         }
         catch (error) {
             console.error('[TagadaClient] Failed to load plugin config:', error);
@@ -238,16 +255,69 @@ export class TagadaClient {
      * Initialize token and session
      */
     async initializeToken() {
+        // 🔐 PRIORITY 1: Check for authCode (cross-domain handoff)
+        // This ALWAYS takes precedence over existing tokens
+        if (shouldResolveAuthCode()) {
+            const storeId = this.state.pluginConfig.storeId;
+            if (!storeId) {
+                console.error('[TagadaClient] Cannot resolve authCode: storeId not found in config');
+                return this.fallbackToNormalFlow();
+            }
+            console.log(`[TagadaClient ${this.instanceId}] 🔐 Cross-domain auth detected, resolving...`);
+            try {
+                const authCode = new URLSearchParams(window.location.search).get('authCode');
+                if (!authCode) {
+                    return this.fallbackToNormalFlow();
+                }
+                // Resolve the handoff
+                const handoffData = await resolveAuthHandoff(authCode, storeId, this.state.environment.apiConfig.baseUrl, this.state.debugMode);
+                console.log(`[TagadaClient ${this.instanceId}] ✅ Auth handoff resolved:`, {
+                    customerId: handoffData.customer.id,
+                    role: handoffData.customer.role,
+                    hasContext: Object.keys(handoffData.context).length > 0,
+                });
+                // Set the new token (already stored by resolveAuthHandoff)
+                this.setToken(handoffData.token);
+                // Decode session from token
+                const decodedSession = decodeJWTClient(handoffData.token);
+                if (decodedSession) {
+                    this.updateState({ session: decodedSession });
+                    await this.initializeSession(decodedSession);
+                    // If context has funnelSessionId, restore it
+                    if (handoffData.context?.funnelSessionId && this.funnel) {
+                        if (this.state.debugMode) {
+                            console.log(`[TagadaClient ${this.instanceId}] Restoring funnel session from handoff context:`, handoffData.context.funnelSessionId);
+                        }
+                        // The funnel client will pick this up during auto-initialization
+                    }
+                }
+                else {
+                    console.error('[TagadaClient] Failed to decode token from handoff');
+                    this.updateState({ isInitialized: true, isLoading: false });
+                }
+                return; // ✅ Auth handoff resolved successfully, exit early
+            }
+            catch (error) {
+                console.error(`[TagadaClient ${this.instanceId}] ❌ Auth handoff failed, falling back to normal flow:`, error);
+                // Fall through to normal initialization
+            }
+        }
+        // Continue with normal flow if no authCode or resolution failed
+        await this.fallbackToNormalFlow();
+    }
+    /**
+     * Normal token initialization flow (no cross-domain handoff)
+     */
+    async fallbackToNormalFlow() {
         // Check for existing token in URL or storage
         const existingToken = getClientToken();
         const urlParams = new URLSearchParams(typeof window !== 'undefined' ? window.location.search : '');
         const queryToken = urlParams.get('token');
-        if (this.state.debugMode) {
-            console.log(`[TagadaClient ${this.instanceId}] Initializing token...`, {
-                hasExistingToken: !!existingToken,
-                hasQueryToken: !!queryToken
-            });
-        }
+        console.log(`[TagadaClient ${this.instanceId}] Initializing token (normal flow)...`, {
+            hasExistingToken: !!existingToken,
+            hasQueryToken: !!queryToken,
+            storeId: this.state.pluginConfig.storeId,
+        });
         let tokenToUse = null;
         let shouldPersist = false;
         if (queryToken) {
@@ -280,13 +350,15 @@ export class TagadaClient {
         else {
             // Create anonymous token
             const storeId = this.state.pluginConfig.storeId;
+            console.log(`[TagadaClient ${this.instanceId}] No existing token, creating anonymous token...`, {
+                hasStoreId: !!storeId,
+                storeId,
+            });
             if (storeId) {
-                if (this.state.debugMode) {
-                    console.log(`[TagadaClient ${this.instanceId}] Creating anonymous token for store:`, storeId);
-                }
                 await this.createAnonymousToken(storeId);
             }
             else {
+                console.warn(`[TagadaClient ${this.instanceId}] No storeId in plugin config, skipping anonymous token creation`);
                 this.updateState({ isInitialized: true, isLoading: false });
             }
         }
@@ -404,12 +476,22 @@ export class TagadaClient {
                 osVersion: deviceInfo.userAgent.os.version,
                 deviceType: deviceInfo.userAgent.device?.type,
                 deviceModel: deviceInfo.userAgent.device?.model,
+                deviceVendor: deviceInfo.userAgent.device?.vendor,
+                userAgent: deviceInfo.userAgent.name,
+                engineName: deviceInfo.userAgent.engine.name,
+                engineVersion: deviceInfo.userAgent.engine.version,
+                cpuArchitecture: deviceInfo.userAgent.cpu.architecture,
+                isBot: deviceInfo.flags?.isBot ?? false,
+                isChromeFamily: deviceInfo.flags?.isChromeFamily ?? false,
+                isStandalonePWA: deviceInfo.flags?.isStandalonePWA ?? false,
+                isAppleSilicon: deviceInfo.flags?.isAppleSilicon ?? false,
                 screenWidth: deviceInfo.screenResolution.width,
                 screenHeight: deviceInfo.screenResolution.height,
                 timeZone: deviceInfo.timeZone,
                 draft, // 🎯 Pass draft mode to session init
+                fetchMessages: false,
             };
-            const response = await this.apiClient.post('/api/v1/cms/session/init', sessionInitData);
+            const response = await this.apiClient.post('/api/v1/cms/session/v2/init', sessionInitData);
             // Success - reset error tracking
             this.lastSessionInitError = null;
             this.sessionInitRetryCount = 0;
@@ -451,14 +533,16 @@ export class TagadaClient {
             };
             this.updateState({ store: storeConfig });
         }
-        // Update Locale
-        const localeConfig = {
-            locale: response.locale,
-            language: response.locale.split('-')[0],
-            region: response.locale.split('-')[1] ?? 'US',
-            messages: response.messages ?? {},
-        };
-        this.updateState({ locale: localeConfig });
+        // Update Locale (only if provided - V2 endpoint doesn't return locale)
+        if (response.locale) {
+            const localeConfig = {
+                locale: response.locale,
+                language: response.locale.split('-')[0],
+                region: response.locale.split('-')[1] ?? 'US',
+                messages: response.messages ?? {},
+            };
+            this.updateState({ locale: localeConfig });
+        }
         // Update Currency
         if (response.store) {
             const currencyConfig = {
@@ -588,113 +672,220 @@ export class TagadaClient {
     applyStylesToElement(elementId, styles) {
         if (typeof document === 'undefined')
             return;
-        // Support multiple IDs in editor-id attribute (space-separated)
-        // Use ~= selector to match elementId as a space-separated value
-        const element = document.querySelector(`[editor-id~="${elementId}"]`);
-        if (!element) {
-            if (this.state.debugMode) {
-                console.warn(`[TagadaClient] Element with editor-id containing "${elementId}" not found`);
-            }
-            return;
+        // Always remove any existing highlight, even if the target element is not found
+        const staticHighlightId = 'tagada-editor-highlight';
+        const existingHighlight = document.getElementById(staticHighlightId);
+        if (existingHighlight) {
+            existingHighlight.remove();
         }
-        // List of void/self-closing elements that don't accept children
-        const voidElements = new Set([
-            'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-            'link', 'meta', 'param', 'source', 'track', 'wbr'
-        ]);
-        const isVoidElement = voidElements.has(element.tagName.toLowerCase());
-        // For void elements, wrap them in a container div
-        let targetElement = element;
-        let wrapper = null;
-        if (isVoidElement) {
-            // Check if element is already wrapped (from a previous highlight)
-            const parent = element.parentElement;
-            const existingWrapper = parent?.getAttribute('data-tagada-highlight-wrapper');
-            if (existingWrapper === 'true') {
-                // Reuse existing wrapper
-                targetElement = parent;
+        const applyToElement = (element) => {
+            // List of void/self-closing elements that don't accept children
+            const voidElements = new Set([
+                'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+                'link', 'meta', 'param', 'source', 'track', 'wbr'
+            ]);
+            const isVoidElement = voidElements.has(element.tagName.toLowerCase());
+            // For void elements, wrap them in a container div
+            let targetElement = element;
+            if (isVoidElement) {
+                // Check if element is already wrapped (from a previous highlight)
+                const parent = element.parentElement;
+                const existingWrapper = parent?.getAttribute('data-tagada-highlight-wrapper');
+                if (existingWrapper === 'true' && parent instanceof HTMLElement) {
+                    // Reuse existing wrapper
+                    targetElement = parent;
+                }
+                else {
+                    // Create a new wrapper
+                    const newWrapper = document.createElement('div');
+                    newWrapper.setAttribute('data-tagada-highlight-wrapper', 'true');
+                    // Preserve the element's layout behavior by matching its display style
+                    // This minimizes the visual impact of the wrapper
+                    const computedStyle = window.getComputedStyle(element);
+                    const elementDisplay = computedStyle.display;
+                    // Match the display type to preserve layout
+                    // For inline elements, use inline-block (to support position: relative)
+                    // For all others, use the same display value
+                    if (elementDisplay === 'inline') {
+                        newWrapper.style.display = 'inline-block';
+                    }
+                    else {
+                        newWrapper.style.display = elementDisplay;
+                    }
+                    newWrapper.style.position = 'relative';
+                    // Preserve vertical alignment for inline elements
+                    if (elementDisplay === 'inline' || elementDisplay.includes('inline')) {
+                        const verticalAlign = computedStyle.verticalAlign;
+                        if (verticalAlign && verticalAlign !== 'baseline') {
+                            newWrapper.style.verticalAlign = verticalAlign;
+                        }
+                    }
+                    // Preserve spacing and layout properties from the original element
+                    // List of CSS properties that affect spacing and layout
+                    const spacingProperties = [
+                        // Width and height
+                        'width', 'height', 'minWidth', 'minHeight', 'maxWidth', 'maxHeight',
+                        // Flex properties
+                        'flex', 'flexGrow', 'flexShrink', 'flexBasis',
+                        // Grid properties
+                        'gridColumn', 'gridRow', 'gridColumnStart', 'gridColumnEnd',
+                        'gridRowStart', 'gridRowEnd', 'gridArea',
+                        // Alignment properties
+                        'alignSelf', 'justifySelf',
+                        // Box sizing
+                        'boxSizing',
+                        // Gap (for grid/flex)
+                        'gap', 'rowGap', 'columnGap',
+                        // Order (for flex/grid)
+                        'order',
+                        // Aspect ratio
+                        'aspectRatio',
+                    ];
+                    spacingProperties.forEach(prop => {
+                        const camelProp = prop.replace(/([A-Z])/g, '-$1').toLowerCase();
+                        const value = computedStyle.getPropertyValue(camelProp);
+                        // Only copy if the value is not empty
+                        // For most properties, we want to preserve the value even if it's 'auto' or '0px'
+                        // as these might be intentional layout choices
+                        if (value && value.trim() !== '') {
+                            // Handle special cases
+                            if (prop === 'flex' && value !== 'none' && value !== '0 1 auto') {
+                                newWrapper.style.flex = value;
+                            }
+                            else if (prop === 'boxSizing') {
+                                newWrapper.style.boxSizing = value;
+                            }
+                            else {
+                                // Use setProperty for kebab-case properties
+                                // Preserve all values including percentages, auto, etc.
+                                newWrapper.style.setProperty(camelProp, value);
+                            }
+                        }
+                    });
+                    // Also check inline styles for spacing properties
+                    // This handles cases where styles are set directly on the element
+                    if (element.style) {
+                        const inlineSpacingProps = [
+                            'width', 'height', 'min-width', 'min-height', 'max-width', 'max-height',
+                            'flex', 'flex-grow', 'flex-shrink', 'flex-basis',
+                            'grid-column', 'grid-row', 'grid-column-start', 'grid-column-end',
+                            'grid-row-start', 'grid-row-end', 'grid-area',
+                            'align-self', 'justify-self',
+                            'box-sizing', 'gap', 'row-gap', 'column-gap', 'order', 'aspect-ratio'
+                        ];
+                        inlineSpacingProps.forEach(prop => {
+                            const inlineValue = element.style.getPropertyValue(prop);
+                            if (inlineValue) {
+                                newWrapper.style.setProperty(prop, inlineValue);
+                            }
+                        });
+                    }
+                    // Insert wrapper before element
+                    element.parentNode?.insertBefore(newWrapper, element);
+                    // Move element into wrapper
+                    newWrapper.appendChild(element);
+                    targetElement = newWrapper;
+                }
             }
-            else {
-                // Create a new wrapper
-                wrapper = document.createElement('div');
-                wrapper.setAttribute('data-tagada-highlight-wrapper', 'true');
-                // Preserve the element's layout behavior by matching its display style
-                // This minimizes the visual impact of the wrapper
-                const computedStyle = window.getComputedStyle(element);
-                const elementDisplay = computedStyle.display;
-                // Match the display type to preserve layout
-                // For inline elements, use inline-block (to support position: relative)
-                // For all others, use the same display value
-                if (elementDisplay === 'inline') {
-                    wrapper.style.display = 'inline-block';
+            // Ensure element has position relative for absolute child positioning
+            const computedStyle = getComputedStyle(isVoidElement ? element : targetElement);
+            if (targetElement.style.position === 'static' || !targetElement.style.position) {
+                targetElement.style.position = 'relative';
+            }
+            // Create new highlight div with static ID
+            const highlightDiv = document.createElement('div');
+            highlightDiv.id = staticHighlightId;
+            highlightDiv.style.position = 'absolute';
+            highlightDiv.style.inset = '0';
+            highlightDiv.style.pointerEvents = 'none';
+            highlightDiv.style.zIndex = '9999';
+            highlightDiv.style.boxSizing = 'border-box';
+            highlightDiv.style.background = 'none';
+            highlightDiv.style.border = 'none';
+            highlightDiv.style.outline = 'none';
+            highlightDiv.style.margin = '0';
+            highlightDiv.style.padding = '0';
+            // Inherit border radius from parent
+            const borderRadius = computedStyle.borderRadius;
+            if (borderRadius) {
+                highlightDiv.style.borderRadius = borderRadius;
+            }
+            // Append the new highlight div to the target element
+            targetElement.appendChild(highlightDiv);
+            // Apply CSS properties to the highlight div
+            const stylesToApply = styles || { boxShadow: '0 0 0 2px rgb(239 68 68)' }; // Default red ring
+            Object.entries(stylesToApply).forEach(([property, value]) => {
+                // Convert kebab-case to camelCase for style object
+                const camelProperty = property.includes('-')
+                    ? property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
+                    : property;
+                // Use setProperty for kebab-case or direct assignment for camelCase
+                if (property.includes('-')) {
+                    highlightDiv.style.setProperty(property, value);
                 }
                 else {
-                    wrapper.style.display = elementDisplay;
+                    highlightDiv.style[camelProperty] = value;
                 }
-                wrapper.style.position = 'relative';
-                // Preserve vertical alignment for inline elements
-                if (elementDisplay === 'inline' || elementDisplay.includes('inline')) {
-                    const verticalAlign = computedStyle.verticalAlign;
-                    if (verticalAlign && verticalAlign !== 'baseline') {
-                        wrapper.style.verticalAlign = verticalAlign;
+            });
+            // Scroll element into view
+            element.scrollIntoView({ behavior: 'smooth', block: 'center' });
+            if (this.state.debugMode) {
+                const appliedStyles = Object.entries(stylesToApply).map(([k, v]) => `${k}: ${v}`).join('; ');
+                console.log(`[TagadaClient] Applied styles to highlight div of element #${elementId}:`, appliedStyles);
+            }
+        };
+        // Support multiple IDs in editor-id attribute (space-separated)
+        // Use ~= selector to match elementId as a space-separated value
+        const maxAttempts = 5;
+        const intervalMs = 1000;
+        let attempts = 0;
+        const isElementHidden = (element) => {
+            const style = window.getComputedStyle(element);
+            return (style.display === 'none' ||
+                style.visibility === 'hidden' ||
+                style.opacity === '0' ||
+                element.hidden ||
+                element.offsetWidth === 0 ||
+                element.offsetHeight === 0);
+        };
+        const findAndApply = () => {
+            const elements = document.querySelectorAll(`[editor-id~="${elementId}"]`);
+            if (elements.length === 0) {
+                attempts += 1;
+                if (attempts >= maxAttempts) {
+                    if (this.state.debugMode) {
+                        console.warn(`[TagadaClient] Element with editor-id containing "${elementId}" not found after ${maxAttempts} attempts`);
                     }
+                    return;
                 }
-                // Insert wrapper before element
-                element.parentNode?.insertBefore(wrapper, element);
-                // Move element into wrapper
-                wrapper.appendChild(element);
-                targetElement = wrapper;
+                if (this.state.debugMode) {
+                    console.warn(`[TagadaClient] Element with editor-id containing "${elementId}" not found (attempt ${attempts}/${maxAttempts}), retrying in ${intervalMs / 1000}s`);
+                }
+                setTimeout(findAndApply, intervalMs);
+                return;
             }
-        }
-        // Ensure element has position relative for absolute child positioning
-        const computedStyle = getComputedStyle(isVoidElement ? element : targetElement);
-        if (targetElement.style.position === 'static' || !targetElement.style.position) {
-            targetElement.style.position = 'relative';
-        }
-        // Remove any existing highlight div before creating a new one
-        const staticHighlightId = 'tagada-editor-highlight';
-        const existingHighlight = document.getElementById(staticHighlightId);
-        if (existingHighlight) {
-            existingHighlight.remove();
-        }
-        // Create new highlight div with static ID
-        const highlightDiv = document.createElement('div');
-        highlightDiv.id = staticHighlightId;
-        highlightDiv.style.position = 'absolute';
-        highlightDiv.style.inset = '0';
-        highlightDiv.style.pointerEvents = 'none';
-        highlightDiv.style.zIndex = '9999';
-        highlightDiv.style.boxSizing = 'border-box';
-        highlightDiv.style.background = 'none';
-        highlightDiv.style.border = 'none';
-        highlightDiv.style.outline = 'none';
-        // Inherit border radius from parent
-        const borderRadius = computedStyle.borderRadius;
-        if (borderRadius) {
-            highlightDiv.style.borderRadius = borderRadius;
-        }
-        // Append the new highlight div to the target element
-        targetElement.appendChild(highlightDiv);
-        // Apply CSS properties to the highlight div
-        const stylesToApply = styles || { boxShadow: '0 0 0 2px rgb(239 68 68)' }; // Default red ring
-        Object.entries(stylesToApply).forEach(([property, value]) => {
-            // Convert kebab-case to camelCase for style object
-            const camelProperty = property.includes('-')
-                ? property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
-                : property;
-            // Use setProperty for kebab-case or direct assignment for camelCase
-            if (property.includes('-')) {
-                highlightDiv.style.setProperty(property, value);
+            // If multiple elements found, prioritize the one that is not hidden
+            let element = null;
+            if (elements.length === 1) {
+                element = elements[0];
             }
             else {
-                highlightDiv.style[camelProperty] = value;
+                // Find the first non-hidden element
+                for (let i = 0; i < elements.length; i++) {
+                    if (!isElementHidden(elements[i])) {
+                        element = elements[i];
+                        break;
+                    }
+                }
+                // If all are hidden, use the first one
+                if (!element) {
+                    element = elements[0];
+                }
             }
-        });
-        // Scroll element into view
-        element.scrollIntoView({ behavior: 'smooth', block: 'center' });
-        if (this.state.debugMode) {
-            const appliedStyles = Object.entries(stylesToApply).map(([k, v]) => `${k}: ${v}`).join('; ');
-            console.log(`[TagadaClient] Applied styles to highlight div of element #${elementId}:`, appliedStyles);
-        }
+            if (element) {
+                applyToElement(element);
+            }
+        };
+        findAndApply();
     }
 }

package/dist/v2/core/config/environment.js

@@ -37,7 +37,9 @@ export const ENVIRONMENT_CONFIGS = {
         endpoints: {
             checkout: {
                 sessionInit: '/api/v1/checkout/session/init',
+                sessionInitAsync: '/api/v1/checkout/session/init-async',
                 sessionStatus: '/api/v1/checkout/session/status',
+                asyncStatus: '/api/public/v1/checkout/async-status',
             },
             customer: {
                 profile: '/api/v1/customer/profile',
@@ -53,7 +55,9 @@ export const ENVIRONMENT_CONFIGS = {
         endpoints: {
             checkout: {
                 sessionInit: '/api/v1/checkout/session/init',
+                sessionInitAsync: '/api/v1/checkout/session/init-async',
                 sessionStatus: '/api/v1/checkout/session/status',
+                asyncStatus: '/api/public/v1/checkout/async-status',
             },
             customer: {
                 profile: '/api/v1/customer/profile',
@@ -69,7 +73,9 @@ export const ENVIRONMENT_CONFIGS = {
         endpoints: {
             checkout: {
                 sessionInit: '/api/v1/checkout/session/init',
+                sessionInitAsync: '/api/v1/checkout/session/init-async',
                 sessionStatus: '/api/v1/checkout/session/status',
+                asyncStatus: '/api/public/v1/checkout/async-status',
             },
             customer: {
                 profile: '/api/v1/customer/profile',

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

@@ -13,6 +13,14 @@ export interface FunnelClientConfig {
      * Set to false if you want to handle navigation manually
      */
     autoRedirect?: boolean;
+    /**
+     * Override funnelId from rawPluginConfig
+     */
+    funnelId?: string;
+    /**
+     * Override stepId from rawPluginConfig
+     */
+    stepId?: string;
 }
 export interface FunnelState {
     context: SimpleFunnelContext | null;
@@ -64,8 +72,17 @@ export declare class FunnelClient {
     }, funnelId?: string, entryStepId?: string): Promise<SimpleFunnelContext<{}>>;
     /**
      * Navigate
+     * @param event - Navigation event/action
+     * @param options - Navigation options
+     * @param options.fireAndForget - If true, queues navigation to QStash and returns immediately without waiting for result
+     * @param options.customerTags - Customer tags to set (merged with existing customer tags)
+     * @param options.deviceId - Device ID for geo/device tag enrichment (optional, rarely needed)
      */
-    navigate(event: FunnelAction): Promise<FunnelNavigationResult>;
+    navigate(event: FunnelAction, options?: {
+        fireAndForget?: boolean;
+        customerTags?: string[];
+        deviceId?: string;
+    }): Promise<FunnelNavigationResult>;
     /**
      * Go to a specific step (direct navigation)
      */