@tagadapay/plugin-sdk 3.1.2 → 3.1.8

package/dist/v2/core/funnelClient.js

@@ -3,6 +3,7 @@ import { EventDispatcher } from './utils/eventDispatcher';
 import { getFunnelSessionCookie, setFunnelSessionCookie } from './utils/sessionStorage';
 import { detectEnvironment } from './config/environment';
 import { getSDKParams } from './utils/previewMode';
+import { injectPreviewModeIndicator } from './utils/previewModeIndicator';
 /**
  * Get the funnel ID from the injected HTML
  * Returns undefined if not available
@@ -57,6 +58,216 @@ 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;
+}
 export class FunnelClient {
     constructor(config) {
         this.eventDispatcher = new EventDispatcher();
@@ -152,6 +363,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 +374,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 +398,15 @@ 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
             });
             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 +456,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 +477,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 +563,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 +593,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,

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

@@ -26,11 +26,79 @@ export interface CheckoutInitParams {
         locale?: string;
     };
 }
+export interface UpsellTrigger {
+    id: string;
+    type: string;
+    productId: string | null;
+}
+export interface OrderBumpOfferVariant {
+    id: string;
+    name: string;
+    sku: string;
+    imageUrl: string;
+    active: boolean;
+    default: boolean;
+    createdAt: string;
+    updatedAt: string;
+    externalVariantId: string | null;
+    description: string;
+    currency: string | null;
+}
+export interface OrderBumpOfferProduct {
+    id: string;
+    name: string;
+}
+export interface PriceCurrencyOption {
+    rate: number;
+    amount: number;
+    lock: boolean;
+    date: string;
+}
+export interface OrderBumpOfferPrice {
+    id: string;
+    currencyOptions: Record<string, PriceCurrencyOption>;
+}
+export interface CheckoutOrderBumpOffer {
+    id: string;
+    type: string;
+    productId: string;
+    variantId: string;
+    priceId: string;
+    titleTrans: Record<string, string>;
+    descriptionTrans: Record<string, string>;
+    overrideImageUrl: string | null;
+    precheck: boolean;
+    displayPrice: boolean;
+    displayCompareAtPrice: boolean;
+    compareAtPriceDiscount: number;
+    quantity: number;
+    variant: OrderBumpOfferVariant;
+    product: OrderBumpOfferProduct;
+    price: OrderBumpOfferPrice;
+}
+export interface Upsell {
+    id: string;
+    type: string;
+    enabled: boolean;
+    triggers: UpsellTrigger[];
+    orderBumpOffers: CheckoutOrderBumpOffer[];
+}
+export interface Store {
+    id: string;
+    accountId: string;
+    name: string;
+    presentmentCurrencies: string[];
+    chargeCurrencies: string[];
+    upsells: Upsell[];
+    emailDomains: string[];
+    integrations: any[];
+}
 export interface CheckoutSession {
     id: string;
     checkoutToken: string;
     status: string;
     storeId: string;
+    store: Store;
     accountId: string;
     customerId: string;
     draft: boolean;

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

@@ -470,6 +470,21 @@ export interface FunnelInitializeRequest {
      * When false, disables all funnel tracking events (useful for iframed previews in config editor)
      */
     funnelTracking?: boolean;
+    /**
+     * 🎯 Funnel environment override ('staging' | 'production')
+     * Determines which funnel config to use
+     */
+    funnelEnv?: 'staging' | 'production';
+    /**
+     * 🎯 Tagada client environment override ('production' | 'development' | 'local')
+     * Forces specific API environment
+     */
+    tagadaClientEnv?: 'production' | 'development' | 'local';
+    /**
+     * 🎯 Tagada client base URL override
+     * Forces custom API base URL (e.g., for local development with ngrok)
+     */
+    tagadaClientBaseUrl?: string;
 }
 export interface FunnelInitializeResponse {
     success: boolean;

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

@@ -7,14 +7,14 @@ export interface Payment {
     id: string;
     status: string;
     subStatus: string;
-    requireAction: 'none' | 'redirect' | 'error';
+    requireAction: 'none' | 'redirect' | 'error' | 'radar';
     requireActionData?: {
-        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error';
+        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar';
         url?: string;
         processed: boolean;
         processorId?: string;
         metadata?: {
-            type: 'redirect';
+            type: 'redirect' | 'stripe_radar' | 'finix_radar';
             redirect?: {
                 redirectUrl: string;
                 returnUrl: string;
@@ -25,6 +25,12 @@ export interface Payment {
                 acsTransID: string;
                 messageVersion: string;
             };
+            radar?: {
+                merchantId?: string;
+                environment?: 'sandbox' | 'live';
+                orderId?: string;
+                publishableKey?: string;
+            };
         };
         redirectUrl?: string;
         resumeToken?: string;
@@ -76,6 +82,12 @@ export interface PaymentOptions {
     threedsProvider?: 'basis_theory';
     initiatedBy?: 'customer' | 'merchant';
     source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+    /**
+     * Override the store's default payment flow
+     * If not provided, the SDK will auto-read from stepConfig.paymentFlowId (if available)
+     * If neither is set, the store's selectedPaymentFlowId will be used
+     */
+    paymentFlowId?: string;
     /** @deprecated Use onPaymentSuccess instead - this will be removed in v3 */
     onSuccess?: (response: PaymentResponse) => void;
     /** @deprecated Use onPaymentFailed instead - this will be removed in v3 */
@@ -147,6 +159,7 @@ export declare class PaymentsResource {
     processPaymentDirect(checkoutSessionId: string, paymentInstrumentId: string, threedsSessionId?: string, options?: {
         initiatedBy?: 'customer' | 'merchant';
         source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+        paymentFlowId?: string;
     }): Promise<PaymentResponse>;
     /**
      * Get card payment instruments for customer
@@ -160,4 +173,38 @@ export declare class PaymentsResource {
      * Get payment status
      */
     getPaymentStatus(paymentId: string): Promise<Payment>;
+    /**
+     * Retrieve payment status from processor
+     * Used for external payment flows that require server-side status checks
+     */
+    retrievePayment(paymentId: string): Promise<{
+        retrieveResult?: {
+            status?: string;
+            message?: string;
+            success?: boolean;
+        };
+        paymentId: string;
+        transactionCreated?: boolean;
+        status?: string;
+        transactionId?: string;
+        message?: string;
+        success?: boolean;
+        error?: any;
+    }>;
+    saveRadarSession(data: {
+        orderId?: string;
+        checkoutSessionId?: string;
+        finixRadarSessionId?: string;
+        finixRadarSessionData?: Record<string, unknown>;
+        stripeRadarSessionId?: string;
+        stripeRadarSessionData?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        radarSessionId: string;
+    }>;
+    /**
+     * Complete payment after an action (3DS, radar, etc.)
+     * This resumes the payment flow that was paused for additional authentication/verification
+     */
+    completePaymentAfterAction(paymentId: string): Promise<Payment>;
 }

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

@@ -95,13 +95,23 @@ export class PaymentsResource {
      * Process payment directly with checkout session
      */
     async processPaymentDirect(checkoutSessionId, paymentInstrumentId, threedsSessionId, options = {}) {
-        return this.apiClient.post('/api/public/v1/checkout/pay-v2', {
-            checkoutSessionId,
-            paymentInstrumentId,
-            ...(threedsSessionId && { threedsSessionId }),
-            ...(options.initiatedBy && { initiatedBy: options.initiatedBy }),
-            ...(options.source && { source: options.source }),
-        });
+        console.log('[PaymentsResource] processPaymentDirect START', options.paymentFlowId ? `(flow: ${options.paymentFlowId})` : '');
+        try {
+            const response = await this.apiClient.post('/api/public/v1/checkout/pay-v2', {
+                checkoutSessionId,
+                paymentInstrumentId,
+                ...(threedsSessionId && { threedsSessionId }),
+                ...(options.initiatedBy && { initiatedBy: options.initiatedBy }),
+                ...(options.source && { source: options.source }),
+                ...(options.paymentFlowId && { paymentFlowId: options.paymentFlowId }),
+            });
+            console.log('[PaymentsResource] processPaymentDirect SUCCESS:', response);
+            return response;
+        }
+        catch (error) {
+            console.error('[PaymentsResource] processPaymentDirect ERROR:', error);
+            throw error;
+        }
     }
     /**
      * Get card payment instruments for customer
@@ -123,4 +133,25 @@ export class PaymentsResource {
     async getPaymentStatus(paymentId) {
         return this.apiClient.get(`/api/v1/payments/${paymentId}`);
     }
+    /**
+     * Retrieve payment status from processor
+     * Used for external payment flows that require server-side status checks
+     */
+    async retrievePayment(paymentId) {
+        return this.apiClient.post('/api/v1/payments/retrieve', {
+            paymentId,
+        });
+    }
+    async saveRadarSession(data) {
+        return this.apiClient.post('/api/v1/radar-sessions', data);
+    }
+    /**
+     * Complete payment after an action (3DS, radar, etc.)
+     * This resumes the payment flow that was paused for additional authentication/verification
+     */
+    async completePaymentAfterAction(paymentId) {
+        return this.apiClient.post('/api/v1/payments/complete-after-3ds', {
+            paymentId,
+        });
+    }
 }

package/dist/v2/core/utils/pluginConfig.js

@@ -85,7 +85,10 @@ const loadLocalDevConfig = async (configVariant = 'default') => {
 };
 /**
  * Load static resources for local development
- * Loads /config/resources.static.json
+ *
+ * Priority:
+ * 1. /config/funnel.local.json (NEW - recommended)
+ * 2. /config/resources.static.json (OLD - deprecated, for backward compatibility)
  */
 const loadStaticResources = async () => {
     try {
@@ -99,15 +102,47 @@ const loadStaticResources = async () => {
         if (!isLocalEnvironment(true)) {
             return null;
         }
-        // Load static resources file
-        console.log('🛠️ [V2] Attempting to load /config/resources.static.json...');
+        // ============================================================
+        // PRIORITY 1: NEW format - funnel.local.json
+        // Also populates the stepConfig cache for getAssignedStepConfig()
+        // ============================================================
+        try {
+            console.log('🛠️ [V2] Attempting to load /config/funnel.local.json...');
+            const funnelResponse = await fetch('/config/funnel.local.json');
+            if (funnelResponse.ok) {
+                const funnelConfig = await funnelResponse.json();
+                console.log('🛠️ [V2] ✅ Loaded local funnel config (NEW format):', funnelConfig);
+                // Also trigger loadLocalFunnelConfig to populate the cache
+                // Import dynamically to avoid circular dependency
+                const { loadLocalFunnelConfig } = await import('../funnelClient');
+                await loadLocalFunnelConfig();
+                // Return staticResources in the old format for backward compatibility
+                // The new stepConfig system reads from funnel.local.json via getAssignedStepConfig()
+                if (funnelConfig.staticResources) {
+                    // Transform flat format to old nested format for legacy compatibility
+                    const transformed = {};
+                    for (const [key, value] of Object.entries(funnelConfig.staticResources)) {
+                        transformed[key] = { id: value };
+                    }
+                    return transformed;
+                }
+                return null;
+            }
+        }
+        catch (e) {
+            console.log('🛠️ [V2] funnel.local.json not found, trying legacy format...');
+        }
+        // ============================================================
+        // PRIORITY 2: OLD format - resources.static.json (deprecated)
+        // ============================================================
+        console.log('🛠️ [V2] Attempting to load /config/resources.static.json (legacy)...');
         const response = await fetch('/config/resources.static.json');
         if (!response.ok) {
-            console.log('🛠️ [V2] resources.static.json not found or failed to load');
+            console.log('🛠️ [V2] No local static resources found');
             return null;
         }
         const staticResources = await response.json();
-        console.log('🛠️ [V2] ✅ Loaded local static resources:', staticResources);
+        console.log('🛠️ [V2] ✅ Loaded legacy static resources:', staticResources);
         return staticResources;
     }
     catch (error) {

package/dist/v2/core/utils/previewMode.d.ts

@@ -42,6 +42,8 @@ export interface SDKOverrideParams {
     draft?: boolean;
     /** Enable/disable funnel tracking events (false in config editor iframe, true in funnel previews) */
     funnelTracking?: boolean;
+    /** Funnel environment (staging/production) - determines which funnel config to use */
+    funnelEnv?: 'staging' | 'production';
     /** Force specific environment (production/development/local) - overrides auto-detection */
     tagadaClientEnv?: 'production' | 'development' | 'local';
     /** Force custom API base URL - overrides environment-based URL */
@@ -68,6 +70,7 @@ export declare function getPreviewParams(): SDKOverrideParams;
 export declare function isDraftMode(): boolean;
 /**
  * Set draft mode in storage for persistence
+ * ⚠️ ONLY writes to localStorage (not cookies) to avoid resurrection issues
  */
 export declare function setDraftMode(draft: boolean): void;
 /**