@tagadapay/plugin-sdk 3.1.5 → 3.1.9

package/dist/v2/core/client.js

@@ -334,10 +334,22 @@ export class TagadaClient {
      * Normal token initialization flow (no cross-domain handoff)
      */
     async fallbackToNormalFlow() {
-        // Check for existing token in URL or storage
-        const existingToken = getClientToken();
+        // 🔒 CRITICAL: Read URL token FIRST before any async operations
+        // This prevents race conditions where anonymous token creation overwrites URL token
         const urlParams = new URLSearchParams(typeof window !== 'undefined' ? window.location.search : '');
         const queryToken = urlParams.get('token');
+        // If URL has token, set it IMMEDIATELY to prevent any race condition
+        if (queryToken) {
+            if (this.state.debugMode) {
+                console.log(`[TagadaClient ${this.instanceId}] 🔒 URL token detected, setting immediately to prevent race condition`);
+            }
+            // Set token on API client immediately
+            this.apiClient.updateToken(queryToken);
+            // Also persist to localStorage
+            setClientToken(queryToken);
+        }
+        // Now check storage (which should have the URL token if we just set it)
+        const existingToken = getClientToken();
         console.log(`[TagadaClient ${this.instanceId}] Initializing token (normal flow)...`, {
             hasExistingToken: !!existingToken,
             hasQueryToken: !!queryToken,
@@ -425,6 +437,26 @@ export class TagadaClient {
      * Create anonymous token
      */
     async createAnonymousToken(storeId) {
+        // 🔒 CRITICAL: Never create anonymous token if URL has a token
+        // This prevents race conditions during forceReset
+        if (typeof window !== 'undefined') {
+            const urlParams = new URLSearchParams(window.location.search);
+            const urlToken = urlParams.get('token');
+            if (urlToken) {
+                if (this.state.debugMode) {
+                    console.log(`[TagadaClient ${this.instanceId}] 🔒 URL has token, skipping anonymous token creation`);
+                }
+                // Use the URL token instead
+                this.setToken(urlToken);
+                setClientToken(urlToken);
+                const decodedSession = decodeJWTClient(urlToken);
+                if (decodedSession) {
+                    this.updateState({ session: decodedSession });
+                    await this.initializeSession(decodedSession);
+                }
+                return;
+            }
+        }
         // Prevent concurrent anonymous token creation
         if (this.isInitializingSession) {
             if (this.state.debugMode) {

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

@@ -160,6 +160,7 @@ export function getEndpointUrl(config, category, endpoint) {
  * 4. Default fallback - Production (safest)
  */
 export function detectEnvironment() {
+    console.log('[SDK] detectEnvironment() called');
     // Check if we're in browser
     if (typeof window === 'undefined') {
         return 'local'; // SSR fallback
@@ -185,15 +186,21 @@ export function detectEnvironment() {
     }
     const hostname = window.location.hostname;
     const href = window.location.href;
+    console.log(`[SDK] detectEnvironment() - hostname: "${hostname}"`);
     // 1. Check for LOCAL environment first (highest priority for dev)
-    // Local: localhost, local IPs, or local domains
+    // Local: localhost, local IPs, local domains, or ngrok tunnels (used for local dev)
     if (hostname === 'localhost' ||
         hostname.startsWith('127.') ||
         hostname.startsWith('192.168.') ||
         hostname.startsWith('10.') ||
         hostname.includes('.local') ||
         hostname === '' ||
-        hostname === '0.0.0.0') {
+        hostname === '0.0.0.0' ||
+        hostname.includes('ngrok-free.dev') ||
+        hostname.includes('ngrok-free.app') ||
+        hostname.includes('ngrok.io') ||
+        hostname.includes('ngrok.app')) {
+        console.log('[SDK] detectEnvironment() - returning LOCAL');
         // For local development, allow override via window.__TAGADA_ENV__ (injected by dev server)
         if (typeof window !== 'undefined' && window?.__TAGADA_ENV__?.TAGADA_ENVIRONMENT) {
             const override = window.__TAGADA_ENV__.TAGADA_ENVIRONMENT.toLowerCase();

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

@@ -1,6 +1,177 @@
 import { ApiClient } from './resources/apiClient';
-import { SimpleFunnelContext, FunnelAction, FunnelNavigationResult } from './resources/funnel';
+import { FunnelAction, FunnelNavigationResult, SimpleFunnelContext } from './resources/funnel';
 import { PluginConfig } from './utils/pluginConfig';
+/**
+ * Tracking providers supported by the SDK.
+ * Mirrors `TrackingType` in `apps/crm-app/.../types/tracking.ts`.
+ */
+export declare enum TrackingProvider {
+    FACEBOOK = "facebook",
+    TIKTOK = "tiktok",
+    SNAPCHAT = "snapchat",
+    META_CONVERSION = "meta_conversion",
+    GTM = "gtm"
+}
+/**
+ * Base tracking config (all providers)
+ */
+export interface BaseTrackingConfig {
+    enabled: boolean;
+}
+/**
+ * Pixel-based providers (Facebook, TikTok)
+ */
+export interface PixelTrackingConfig extends BaseTrackingConfig {
+    pixelId: string;
+    events: {
+        PageView: boolean;
+        InitiateCheckout: boolean;
+        Purchase: boolean;
+    };
+}
+/**
+ * Snapchat pixel config (extends base pixel events)
+ */
+export interface SnapchatTrackingConfig extends BaseTrackingConfig {
+    pixelId: string;
+    events: {
+        PageView: boolean;
+        InitiateCheckout: boolean;
+        Purchase: boolean;
+        AddToCart: boolean;
+        ViewContent: boolean;
+        Search: boolean;
+        AddToWishlist: boolean;
+        CompleteRegistration: boolean;
+    };
+}
+/**
+ * Meta Conversion API config
+ */
+export interface MetaConversionTrackingConfig extends BaseTrackingConfig {
+    accessToken: string;
+    pixelId: string;
+    publishPurchaseIfNewCustomerOnly: boolean;
+}
+/**
+ * Google Tag Manager config
+ */
+export interface GTMTrackingConfig extends BaseTrackingConfig {
+    containerId: string;
+    events: {
+        PageView: boolean;
+        InitiateCheckout: boolean;
+        Purchase: boolean;
+        AddToCart: boolean;
+        ViewContent: boolean;
+    };
+}
+/**
+ * Union of all tracking configs.
+ * This mirrors `TrackingFormValues` from the CRM.
+ */
+export type PixelConfig = PixelTrackingConfig | SnapchatTrackingConfig | MetaConversionTrackingConfig | GTMTrackingConfig;
+/**
+ * Runtime step configuration injected from the CRM
+ * Contains payment flows, static resources, scripts, and tracking configs
+ */
+export interface RuntimeStepConfig {
+    payment?: {
+        paymentFlowId?: string;
+    };
+    staticResources?: Record<string, string>;
+    scripts?: Array<{
+        name: string;
+        enabled: boolean;
+        content: string;
+        position?: 'head-start' | 'head-end' | 'body-start' | 'body-end';
+    }>;
+    pixels?: {
+        [TrackingProvider.FACEBOOK]?: PixelTrackingConfig[];
+        [TrackingProvider.TIKTOK]?: PixelTrackingConfig[];
+        [TrackingProvider.SNAPCHAT]?: SnapchatTrackingConfig[];
+        [TrackingProvider.META_CONVERSION]?: MetaConversionTrackingConfig[];
+        [TrackingProvider.GTM]?: GTMTrackingConfig[];
+    };
+}
+/**
+ * Local funnel configuration for development
+ * Loaded from /config/funnel.local.json
+ */
+export interface LocalFunnelConfig {
+    /** Funnel ID to use in local dev */
+    funnelId?: string;
+    /** Step ID to simulate */
+    stepId?: string;
+    /** Static resources (offer ID, product ID, etc.) */
+    staticResources?: Record<string, string>;
+    /** Payment flow ID override */
+    paymentFlowId?: string;
+    /** Custom scripts for local testing */
+    scripts?: RuntimeStepConfig['scripts'];
+    /** Pixel tracking config */
+    pixels?: RuntimeStepConfig['pixels'];
+}
+/**
+ * Load local funnel config from /config/funnel.local.json (for local dev only)
+ * This replaces the old resources.static.json with a more complete structure
+ *
+ * Example funnel.local.json:
+ * {
+ *   "funnelId": "funnelv2_xxx",
+ *   "stepId": "step_checkout",
+ *   "staticResources": {
+ *     "offer": "offer_xxx",
+ *     "product": "product_xxx"
+ *   },
+ *   "paymentFlowId": "flow_xxx"
+ * }
+ */
+export declare function loadLocalFunnelConfig(): Promise<LocalFunnelConfig | null>;
+/**
+ * Get the cached local funnel config (sync access after loadLocalFunnelConfig)
+ */
+export declare function getLocalFunnelConfig(): LocalFunnelConfig | null;
+/**
+ * Get the runtime step configuration
+ * Contains payment flow, static resources, scripts, and pixel tracking
+ *
+ * Priority:
+ * 1. Local funnel config (local dev only - /config/funnel.local.json) - HIGHEST in local dev
+ * 2. Window variable (production - HTML injection)
+ * 3. Meta tag (production - HTML injection fallback)
+ *
+ * This allows local developers to override injected config for testing.
+ *
+ * Returns undefined if not available
+ */
+export declare function getAssignedStepConfig(): RuntimeStepConfig | undefined;
+/**
+ * Get the assigned payment flow ID from step config or legacy injection
+ * Returns undefined if not available
+ */
+export declare function getAssignedPaymentFlowId(): string | undefined;
+/**
+ * Get the assigned static resources from step config
+ * Returns undefined if not available
+ */
+export declare function getAssignedStaticResources(): Record<string, string> | undefined;
+/**
+ * Get the assigned scripts from step config
+ * Returns only enabled scripts, filtered by position if specified
+ */
+export declare function getAssignedScripts(position?: 'head-start' | 'head-end' | 'body-start' | 'body-end'): RuntimeStepConfig['scripts'];
+/**
+ * Get assigned pixel tracking configuration (normalized to arrays)
+ * Always returns arrays of PixelConfig for consistent consumption.
+ */
+export declare function getAssignedPixels(): {
+    [TrackingProvider.FACEBOOK]?: PixelTrackingConfig[];
+    [TrackingProvider.TIKTOK]?: PixelTrackingConfig[];
+    [TrackingProvider.SNAPCHAT]?: SnapchatTrackingConfig[];
+    [TrackingProvider.META_CONVERSION]?: MetaConversionTrackingConfig[];
+    [TrackingProvider.GTM]?: GTMTrackingConfig[];
+} | undefined;
 export interface FunnelClientConfig {
     apiClient: ApiClient;
     debugMode?: boolean;
@@ -86,16 +257,23 @@ export declare class FunnelClient {
      * @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)
+     * @param options.autoRedirect - Override global autoRedirect setting for this specific call (default: use config)
      */
     navigate(event: FunnelAction, options?: {
         fireAndForget?: boolean;
         customerTags?: string[];
         deviceId?: string;
+        autoRedirect?: boolean;
+        waitForSession?: boolean;
     }): Promise<FunnelNavigationResult>;
     /**
      * Go to a specific step (direct navigation)
+     * @param stepId - Target step ID
+     * @param options - Navigation options (autoRedirect, etc.)
      */
-    goToStep(stepId: string): Promise<FunnelNavigationResult>;
+    goToStep(stepId: string, options?: {
+        autoRedirect?: boolean;
+    }): Promise<FunnelNavigationResult>;
     /**
      * Refresh session data
      */

package/dist/v2/core/funnelClient.js

@@ -1,8 +1,21 @@
-import { FunnelResource, FunnelActionType } from './resources/funnel';
-import { EventDispatcher } from './utils/eventDispatcher';
-import { getFunnelSessionCookie, setFunnelSessionCookie } from './utils/sessionStorage';
 import { detectEnvironment } from './config/environment';
+import { FunnelActionType, FunnelResource } from './resources/funnel';
+import { EventDispatcher } from './utils/eventDispatcher';
 import { getSDKParams } from './utils/previewMode';
+import { injectPreviewModeIndicator } from './utils/previewModeIndicator';
+import { getFunnelSessionCookie, setFunnelSessionCookie } from './utils/sessionStorage';
+/**
+ * Tracking providers supported by the SDK.
+ * Mirrors `TrackingType` in `apps/crm-app/.../types/tracking.ts`.
+ */
+export var TrackingProvider;
+(function (TrackingProvider) {
+    TrackingProvider["FACEBOOK"] = "facebook";
+    TrackingProvider["TIKTOK"] = "tiktok";
+    TrackingProvider["SNAPCHAT"] = "snapchat";
+    TrackingProvider["META_CONVERSION"] = "meta_conversion";
+    TrackingProvider["GTM"] = "gtm";
+})(TrackingProvider || (TrackingProvider = {}));
 /**
  * Get the funnel ID from the injected HTML
  * Returns undefined if not available
@@ -57,6 +70,241 @@ function getAssignedFunnelStep() {
     }
     return undefined;
 }
+/**
+ * Parse step config from a string value (handles both JSON and URL-encoded formats)
+ * Robust parsing with multiple fallback strategies
+ */
+function parseStepConfig(value) {
+    if (!value || typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    // Try parsing strategies in order of likelihood
+    const strategies = [
+        // Strategy 1: Direct JSON parse (for properly escaped window variable)
+        () => JSON.parse(trimmed),
+        // Strategy 2: URL decode then JSON parse (for meta tag)
+        () => JSON.parse(decodeURIComponent(trimmed)),
+        // Strategy 3: Double URL decode (edge case: double-encoded)
+        () => JSON.parse(decodeURIComponent(decodeURIComponent(trimmed))),
+    ];
+    for (const strategy of strategies) {
+        try {
+            const result = strategy();
+            if (result && typeof result === 'object') {
+                return result;
+            }
+        }
+        catch {
+            // Try next strategy
+        }
+    }
+    // All strategies failed
+    if (typeof console !== 'undefined') {
+        console.warn('[SDK] Failed to parse stepConfig:', trimmed.substring(0, 100));
+    }
+    return undefined;
+}
+// Cache for local funnel config (loaded once)
+let localFunnelConfigCache = undefined;
+let localFunnelConfigLoading = false;
+/**
+ * Check if we're in true local development (not CDN deployment)
+ */
+function isLocalDevelopment() {
+    if (typeof window === 'undefined')
+        return false;
+    const hostname = window.location.hostname;
+    // True local: localhost without CDN subdomain pattern
+    return hostname === 'localhost' ||
+        hostname === '127.0.0.1' ||
+        (hostname.endsWith('.localhost') && !hostname.includes('.cdn.'));
+}
+/**
+ * Load local funnel config from /config/funnel.local.json (for local dev only)
+ * This replaces the old resources.static.json with a more complete structure
+ *
+ * Example funnel.local.json:
+ * {
+ *   "funnelId": "funnelv2_xxx",
+ *   "stepId": "step_checkout",
+ *   "staticResources": {
+ *     "offer": "offer_xxx",
+ *     "product": "product_xxx"
+ *   },
+ *   "paymentFlowId": "flow_xxx"
+ * }
+ */
+export async function loadLocalFunnelConfig() {
+    // Only in true local development
+    if (!isLocalDevelopment())
+        return null;
+    // Return cached value if already loaded
+    if (localFunnelConfigCache !== undefined) {
+        return localFunnelConfigCache;
+    }
+    // Prevent concurrent loads
+    if (localFunnelConfigLoading) {
+        // Wait for existing load
+        await new Promise(resolve => setTimeout(resolve, 100));
+        return localFunnelConfigCache ?? null;
+    }
+    localFunnelConfigLoading = true;
+    try {
+        console.log('🛠️ [SDK] Loading local funnel config from /config/funnel.local.json...');
+        const response = await fetch('/config/funnel.local.json');
+        if (!response.ok) {
+            console.log('🛠️ [SDK] funnel.local.json not found (this is fine in production)');
+            localFunnelConfigCache = null;
+            return null;
+        }
+        const config = await response.json();
+        console.log('🛠️ [SDK] ✅ Loaded local funnel config:', config);
+        localFunnelConfigCache = config;
+        return config;
+    }
+    catch (error) {
+        console.log('🛠️ [SDK] funnel.local.json not available:', error);
+        localFunnelConfigCache = null;
+        return null;
+    }
+    finally {
+        localFunnelConfigLoading = false;
+    }
+}
+/**
+ * Get the cached local funnel config (sync access after loadLocalFunnelConfig)
+ */
+export function getLocalFunnelConfig() {
+    return localFunnelConfigCache ?? null;
+}
+/**
+ * Convert LocalFunnelConfig to RuntimeStepConfig
+ */
+function localConfigToStepConfig(local) {
+    return {
+        payment: local.paymentFlowId ? { paymentFlowId: local.paymentFlowId } : undefined,
+        staticResources: local.staticResources,
+        scripts: local.scripts,
+        pixels: local.pixels,
+    };
+}
+/**
+ * Get the runtime step configuration
+ * Contains payment flow, static resources, scripts, and pixel tracking
+ *
+ * Priority:
+ * 1. Local funnel config (local dev only - /config/funnel.local.json) - HIGHEST in local dev
+ * 2. Window variable (production - HTML injection)
+ * 3. Meta tag (production - HTML injection fallback)
+ *
+ * This allows local developers to override injected config for testing.
+ *
+ * Returns undefined if not available
+ */
+export function getAssignedStepConfig() {
+    if (typeof window === 'undefined')
+        return undefined;
+    // Method 1: Local dev override (HIGHEST PRIORITY in local dev)
+    // Allows developers to test different configurations without redeploying
+    const localConfig = getLocalFunnelConfig();
+    if (localConfig) {
+        console.log('🛠️ [SDK] Using local funnel.local.json (overrides injected)');
+        return localConfigToStepConfig(localConfig);
+    }
+    // Method 2: Window variable (production - HTML injection)
+    const windowValue = window.__TGD_STEP_CONFIG__;
+    if (windowValue) {
+        const parsed = parseStepConfig(windowValue);
+        if (parsed)
+            return parsed;
+    }
+    // Method 3: Meta tag fallback (URL-encoded)
+    if (typeof document !== 'undefined') {
+        const meta = document.querySelector('meta[name="x-step-config"]');
+        const content = meta?.getAttribute('content');
+        if (content) {
+            const parsed = parseStepConfig(content);
+            if (parsed)
+                return parsed;
+        }
+    }
+    return undefined;
+}
+/**
+ * Get the assigned payment flow ID from step config or legacy injection
+ * Returns undefined if not available
+ */
+export function getAssignedPaymentFlowId() {
+    // Method 1: New stepConfig (preferred)
+    const stepConfig = getAssignedStepConfig();
+    if (stepConfig?.payment?.paymentFlowId) {
+        return stepConfig.payment.paymentFlowId;
+    }
+    // Method 2: Legacy direct injection (backward compatibility)
+    if (typeof window !== 'undefined') {
+        // Legacy window variable
+        if (window.__TGD_PAYMENT_FLOW_ID__) {
+            return window.__TGD_PAYMENT_FLOW_ID__;
+        }
+        // Legacy meta tag
+        if (typeof document !== 'undefined') {
+            const meta = document.querySelector('meta[name="x-payment-flow-id"]');
+            return meta?.getAttribute('content') || undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Get the assigned static resources from step config
+ * Returns undefined if not available
+ */
+export function getAssignedStaticResources() {
+    const stepConfig = getAssignedStepConfig();
+    return stepConfig?.staticResources;
+}
+/**
+ * Get the assigned scripts from step config
+ * Returns only enabled scripts, filtered by position if specified
+ */
+export function getAssignedScripts(position) {
+    const stepConfig = getAssignedStepConfig();
+    if (!stepConfig?.scripts)
+        return undefined;
+    // Filter enabled scripts
+    let scripts = stepConfig.scripts.filter(s => s.enabled);
+    // Filter by position if specified
+    if (position) {
+        scripts = scripts.filter(s => s.position === position || (!s.position && position === 'head-end'));
+    }
+    return scripts.length > 0 ? scripts : undefined;
+}
+/**
+ * Get assigned pixel tracking configuration (normalized to arrays)
+ * Always returns arrays of PixelConfig for consistent consumption.
+ */
+export function getAssignedPixels() {
+    const stepConfig = getAssignedStepConfig();
+    const rawPixels = stepConfig?.pixels;
+    if (!rawPixels || typeof rawPixels !== 'object')
+        return undefined;
+    const normalized = {};
+    for (const [key, value] of Object.entries(rawPixels)) {
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            // Already an array
+            normalized[key] = value;
+        }
+        else if (typeof value === 'object') {
+            // Single object - wrap in array
+            normalized[key] = [value];
+        }
+        // Skip invalid entries
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
 export class FunnelClient {
     constructor(config) {
         this.eventDispatcher = new EventDispatcher();
@@ -152,6 +400,9 @@ export class FunnelClient {
             // Priority: config override > injected > URL/prop
             const finalFunnelId = this.config.funnelId || injectedFunnelId || effectiveFunnelId;
             const finalStepId = this.config.stepId || injectedStepId;
+            // 🎯 Determine funnelEnv from URL params
+            const urlParams = typeof window !== 'undefined' ? new URLSearchParams(window.location.search) : null;
+            const funnelEnv = urlParams?.get('funnelEnv');
             if (this.config.debugMode) {
                 console.log('🚀 [FunnelClient] Auto-initializing...', {
                     existingSessionId,
@@ -160,6 +411,9 @@ export class FunnelClient {
                     funnelStepId: finalStepId, // 🎯 Log step ID for debugging
                     draft: sdkParams.draft, // 🎯 Log draft mode
                     funnelTracking: sdkParams.funnelTracking, // 🎯 Log tracking flag
+                    funnelEnv, // 🎯 Log funnel environment
+                    tagadaClientEnv: sdkParams.tagadaClientEnv, // 🎯 Log client environment
+                    tagadaClientBaseUrl: sdkParams.tagadaClientBaseUrl, // 🎯 Log custom API URL
                     source: {
                         funnelId: this.config.funnelId ? 'config' : injectedFunnelId ? 'injected' : effectiveFunnelId ? 'url/prop' : 'none',
                         stepId: this.config.stepId ? 'config' : injectedStepId ? 'injected' : 'none',
@@ -181,10 +435,17 @@ export class FunnelClient {
                 funnelStepId: finalStepId, // 🎯 Pass step ID to backend (with config override)
                 draft: sdkParams.draft, // 🎯 Pass draft mode explicitly (more robust than URL parsing)
                 funnelTracking: sdkParams.funnelTracking, // 🎯 Pass funnel tracking flag explicitly
+                funnelEnv: funnelEnv || undefined, // 🎯 Pass funnel environment (staging/production)
+                tagadaClientEnv: sdkParams.tagadaClientEnv, // 🎯 Pass client environment override
+                tagadaClientBaseUrl: sdkParams.tagadaClientBaseUrl, // 🎯 Pass custom API base URL
+                currency: sdkParams.currency, // 🌍 Pass display currency override
+                locale: sdkParams.locale, // 🌍 Pass display locale override
             });
             if (response.success && response.context) {
                 const enriched = this.enrichContext(response.context);
                 this.handleSessionSuccess(enriched);
+                // 🔍 Auto-inject preview mode indicator if in preview/dev mode
+                injectPreviewModeIndicator();
                 return enriched;
             }
             else {
@@ -234,6 +495,8 @@ export class FunnelClient {
             if (response.success && response.context) {
                 const enriched = this.enrichContext(response.context);
                 this.handleSessionSuccess(enriched);
+                // 🔍 Auto-inject preview mode indicator if in preview/dev mode
+                injectPreviewModeIndicator();
                 return enriched;
             }
             else {
@@ -253,8 +516,23 @@ export class FunnelClient {
      * @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)
+     * @param options.autoRedirect - Override global autoRedirect setting for this specific call (default: use config)
      */
     async navigate(event, options) {
+        // Wait for session if requested
+        if (options?.waitForSession && !this.state.context?.sessionId) {
+            if (this.config.debugMode) {
+                console.log('⏳ [FunnelClient] Waiting for session before navigation...');
+            }
+            const maxWaitTime = 5000;
+            const startTime = Date.now();
+            while (!this.state.context?.sessionId && (Date.now() - startTime < maxWaitTime)) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            if (this.state.context?.sessionId && this.config.debugMode) {
+                console.log('✅ [FunnelClient] Session ready, proceeding with navigation');
+            }
+        }
         if (!this.state.context?.sessionId)
             throw new Error('No active session');
         this.updateState({ isNavigating: true, isLoading: true });
@@ -324,7 +602,10 @@ export class FunnelClient {
                 return result;
             }
             // Normal navigation: handle redirect
-            const shouldAutoRedirect = this.config.autoRedirect !== false; // Default to true
+            // Per-call option takes precedence over global config
+            const shouldAutoRedirect = options?.autoRedirect !== undefined
+                ? options.autoRedirect
+                : this.config.autoRedirect !== false; // Default to true
             // Skip refreshSession if auto-redirecting (next page will initialize with fresh state)
             // Only refresh if staying on same page (autoRedirect: false)
             if (!shouldAutoRedirect) {
@@ -351,12 +632,14 @@ export class FunnelClient {
     }
     /**
      * Go to a specific step (direct navigation)
+     * @param stepId - Target step ID
+     * @param options - Navigation options (autoRedirect, etc.)
      */
-    async goToStep(stepId) {
+    async goToStep(stepId, options) {
         return this.navigate({
             type: FunnelActionType.DIRECT_NAVIGATION,
             data: { targetStepId: stepId },
-        });
+        }, options);
     }
     /**
      * Refresh session data

package/dist/v2/core/resources/apiClient.js

@@ -13,7 +13,7 @@ export class ApiClient {
         this.MAX_REQUESTS = 30; // Max 30 requests per endpoint in window
         this.axios = axios.create({
             baseURL: config.baseURL,
-            timeout: config.timeout || 30000,
+            timeout: config.timeout || 60000, // 60 seconds for payment operations
             headers: {
                 'Content-Type': 'application/json',
                 ...config.headers,