@tagadapay/plugin-sdk 3.0.3 → 3.0.12

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

@@ -1,12 +1,29 @@
+/**
+ * Get cookie value by name
+ */
+function getCookie(name) {
+    if (typeof document === 'undefined')
+        return null;
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2)
+        return parts.pop()?.split(';').shift() || null;
+    return null;
+}
 /**
  * ⚠️ IMPORTANT: Runtime Environment Detection
  *
  * This SDK uses RUNTIME hostname detection, NOT build-time environment variables.
  * This ensures the SDK always connects to the correct API based on where it's deployed.
  *
- * - Production domains → production API
- * - Dev/staging domains → development API
- * - Localhost/local IPs → local API (with optional override via window.__TAGADA_ENV__)
+ * Environment detection priority (highest to lowest):
+ * 1. **tagadaClientEnv** - Explicit override via URL param, localStorage, or cookie
+ *    Example: ?tagadaClientEnv=production
+ * 2. **Production domains** → production API (app.tagadapay.com)
+ * 3. **Dev/staging domains** → development API (app.tagadapay.dev, vercel.app, etc.)
+ * 4. **Localhost/local IPs** → local API (localhost, 127.0.0.1, etc.)
+ *    - Can be overridden via window.__TAGADA_ENV__.TAGADA_ENVIRONMENT
+ * 5. **Default fallback** → production API (safest for unknown domains)
  *
  * Build-time .env variables (VITE_*, REACT_APP_*, NEXT_PUBLIC_*) are IGNORED
  * to prevent incorrect API connections when plugins are deployed to different environments.
@@ -66,6 +83,8 @@ export const ENVIRONMENT_CONFIGS = {
 };
 /**
  * Get the environment configuration based on the current environment
+ *
+ * Checks for custom base URL override via tagadaClientBaseUrl parameter
  */
 export function getEnvironmentConfig(environment = 'local') {
     const apiConfig = ENVIRONMENT_CONFIGS[environment];
@@ -76,6 +95,31 @@ export function getEnvironmentConfig(environment = 'local') {
             apiConfig: ENVIRONMENT_CONFIGS.local,
         };
     }
+    // 🎯 Check for custom base URL override (URL > localStorage > cookie)
+    let customBaseUrl = null;
+    if (typeof window !== 'undefined') {
+        const urlParams = new URLSearchParams(window.location.search);
+        customBaseUrl = urlParams.get('tagadaClientBaseUrl');
+        if (!customBaseUrl) {
+            try {
+                customBaseUrl = localStorage.getItem('tgd_client_base_url') || getCookie('tgd_client_base_url');
+            }
+            catch {
+                // Storage not available
+            }
+        }
+    }
+    // If custom base URL is set, override the apiConfig.baseUrl
+    if (customBaseUrl) {
+        console.log(`[SDK] Using custom API base URL override: ${customBaseUrl}`);
+        return {
+            environment,
+            apiConfig: {
+                ...apiConfig,
+                baseUrl: customBaseUrl,
+            },
+        };
+    }
     return {
         environment,
         apiConfig,
@@ -102,12 +146,37 @@ export function getEndpointUrl(config, category, endpoint) {
  * Auto-detect environment based on hostname and URL patterns at RUNTIME
  * ⚠️ IMPORTANT: Ignores build-time .env variables to ensure correct detection in all environments
  * .env variables are ONLY used for local development via window.__TAGADA_ENV__
+ *
+ * Priority (highest to lowest):
+ * 1. tagadaClientEnv - Explicit override via URL/localStorage/cookie
+ * 2. __TAGADA_ENV__ - Local development override
+ * 3. Hostname-based detection - Production/staging domains
+ * 4. Default fallback - Production (safest)
  */
 export function detectEnvironment() {
     // Check if we're in browser
     if (typeof window === 'undefined') {
         return 'local'; // SSR fallback
     }
+    // 🎯 PRIORITY 1: Check for explicit tagadaClientEnv override (URL > localStorage > cookie)
+    // This allows forcing environment regardless of hostname
+    const urlParams = new URLSearchParams(window.location.search);
+    const urlEnv = urlParams.get('tagadaClientEnv');
+    if (urlEnv && (urlEnv === 'production' || urlEnv === 'development' || urlEnv === 'local')) {
+        console.log(`[SDK] Using explicit environment override: ${urlEnv}`);
+        return urlEnv;
+    }
+    // Check localStorage/cookie for persisted override
+    try {
+        const storageEnv = localStorage.getItem('tgd_client_env') || getCookie('tgd_client_env');
+        if (storageEnv && (storageEnv === 'production' || storageEnv === 'development' || storageEnv === 'local')) {
+            console.log(`[SDK] Using persisted environment override: ${storageEnv}`);
+            return storageEnv;
+        }
+    }
+    catch {
+        // Storage not available
+    }
     const hostname = window.location.hostname;
     const href = window.location.href;
     // 1. Check for LOCAL environment first (highest priority for dev)

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

@@ -66,6 +66,10 @@ export declare class FunnelClient {
      * Navigate
      */
     navigate(event: FunnelAction): Promise<FunnelNavigationResult>;
+    /**
+     * Go to a specific step (direct navigation)
+     */
+    goToStep(stepId: string): Promise<FunnelNavigationResult>;
     /**
      * Refresh session data
      */

package/dist/v2/core/funnelClient.js

@@ -1,7 +1,62 @@
-import { FunnelResource } from './resources/funnel';
+import { FunnelResource, FunnelActionType } from './resources/funnel';
 import { EventDispatcher } from './utils/eventDispatcher';
 import { getFunnelSessionCookie, setFunnelSessionCookie } from './utils/sessionStorage';
 import { detectEnvironment } from './config/environment';
+import { getSDKParams } from './utils/previewMode';
+/**
+ * Get the funnel ID from the injected HTML
+ * Returns undefined if not available
+ */
+function getAssignedFunnelId() {
+    if (typeof window === 'undefined')
+        return undefined;
+    // Method 1: Window variable (preferred - synchronous, fast)
+    if (window.__TGD_FUNNEL_ID__) {
+        return window.__TGD_FUNNEL_ID__;
+    }
+    // Method 2: Meta tag fallback
+    if (typeof document !== 'undefined') {
+        const meta = document.querySelector('meta[name="x-funnel-id"]');
+        return meta?.getAttribute('content') || undefined;
+    }
+    return undefined;
+}
+/**
+ * Get the assigned A/B test variant ID from the injected HTML
+ * Returns undefined if not in an A/B test
+ */
+function getAssignedFunnelVariant() {
+    if (typeof window === 'undefined')
+        return undefined;
+    // Method 1: Window variable (preferred - synchronous, fast)
+    if (window.__TGD_FUNNEL_VARIANT_ID__) {
+        return window.__TGD_FUNNEL_VARIANT_ID__;
+    }
+    // Method 2: Meta tag fallback
+    if (typeof document !== 'undefined') {
+        const meta = document.querySelector('meta[name="x-funnel-variant-id"]');
+        return meta?.getAttribute('content') || undefined;
+    }
+    return undefined;
+}
+/**
+ * Get the funnel step ID from the injected HTML
+ * Returns undefined if not available
+ */
+function getAssignedFunnelStep() {
+    if (typeof window === 'undefined')
+        return undefined;
+    // Method 1: Window variable (preferred - synchronous, fast)
+    if (window.__TGD_FUNNEL_STEP_ID__) {
+        return window.__TGD_FUNNEL_STEP_ID__;
+    }
+    // Method 2: Meta tag fallback
+    if (typeof document !== 'undefined') {
+        const meta = document.querySelector('meta[name="x-funnel-step-id"]');
+        return meta?.getAttribute('content') || undefined;
+    }
+    return undefined;
+}
 export class FunnelClient {
     constructor(config) {
         this.eventDispatcher = new EventDispatcher();
@@ -60,8 +115,23 @@ export class FunnelClient {
             if (!existingSessionId) {
                 existingSessionId = getFunnelSessionCookie() || null;
             }
+            // 🎯 Read funnel tracking data from injected HTML
+            const injectedFunnelId = getAssignedFunnelId(); // Funnel ID from server
+            const funnelVariantId = getAssignedFunnelVariant(); // A/B test variant ID
+            const funnelStepId = getAssignedFunnelStep(); // Current step ID
+            // 🎯 Get SDK override parameters (draft, funnelTracking, etc.)
+            const sdkParams = getSDKParams();
+            // Prefer injected funnelId over URL/prop funnelId (more reliable)
+            const finalFunnelId = injectedFunnelId || effectiveFunnelId;
             if (this.config.debugMode) {
-                console.log('🚀 [FunnelClient] Auto-initializing...', { existingSessionId, effectiveFunnelId });
+                console.log('🚀 [FunnelClient] Auto-initializing...', {
+                    existingSessionId,
+                    effectiveFunnelId: finalFunnelId,
+                    funnelVariantId, // 🎯 Log variant ID for debugging
+                    funnelStepId, // 🎯 Log step ID for debugging
+                    draft: sdkParams.draft, // 🎯 Log draft mode
+                    funnelTracking: sdkParams.funnelTracking, // 🎯 Log tracking flag
+                });
             }
             // Note: We proceed even without funnelId/sessionId - the backend will create a new anonymous session if needed
             const response = await this.resource.initialize({
@@ -71,9 +141,13 @@ export class FunnelClient {
                     storeId: store.id,
                     accountId: store.accountId,
                 },
-                funnelId: effectiveFunnelId,
+                funnelId: finalFunnelId,
                 existingSessionId: existingSessionId || undefined,
                 currentUrl: typeof window !== 'undefined' ? window.location.href : undefined,
+                funnelVariantId, // 🎯 Pass A/B test variant ID to backend
+                funnelStepId, // 🎯 Pass step ID to backend
+                draft: sdkParams.draft, // 🎯 Pass draft mode explicitly (more robust than URL parsing)
+                funnelTracking: sdkParams.funnelTracking, // 🎯 Pass funnel tracking flag explicitly
             });
             if (response.success && response.context) {
                 const enriched = this.enrichContext(response.context);
@@ -102,6 +176,15 @@ export class FunnelClient {
     async initialize(authSession, store, funnelId, entryStepId) {
         this.updateState({ isLoading: true, error: null });
         try {
+            // 🎯 Read A/B test variant ID and step ID from injected HTML
+            const funnelVariantId = getAssignedFunnelVariant();
+            const funnelStepId = getAssignedFunnelStep();
+            if (this.config.debugMode) {
+                if (funnelVariantId)
+                    console.log('🎯 [FunnelClient] Detected A/B test variant:', funnelVariantId);
+                if (funnelStepId)
+                    console.log('🎯 [FunnelClient] Detected step ID:', funnelStepId);
+            }
             const response = await this.resource.initialize({
                 cmsSession: {
                     customerId: authSession.customerId,
@@ -112,6 +195,8 @@ export class FunnelClient {
                 funnelId: funnelId,
                 entryStepId,
                 currentUrl: typeof window !== 'undefined' ? window.location.href : undefined,
+                funnelVariantId, // 🎯 Pass A/B test variant ID to backend
+                funnelStepId, // 🎯 Pass step ID to backend
             });
             if (response.success && response.context) {
                 const enriched = this.enrichContext(response.context);
@@ -163,6 +248,15 @@ export class FunnelClient {
             throw err;
         }
     }
+    /**
+     * Go to a specific step (direct navigation)
+     */
+    async goToStep(stepId) {
+        return this.navigate({
+            type: FunnelActionType.DIRECT_NAVIGATION,
+            data: { targetStepId: stepId },
+        });
+    }
     /**
      * Refresh session data
      */
@@ -241,11 +335,19 @@ export class FunnelClient {
         const localResources = this.config.pluginConfig?.staticResources || {};
         if (Object.keys(localResources).length === 0)
             return ctx;
+        // 🎯 Check if context already has the same static resources
+        // This prevents creating new objects unnecessarily, which would trigger React re-renders
+        const existingStatic = ctx.static || {};
+        const hasAllResources = Object.keys(localResources).every(key => existingStatic[key] === localResources[key]);
+        // If context already has all static resources with same references, don't recreate
+        if (hasAllResources && Object.keys(existingStatic).length === Object.keys(localResources).length) {
+            return ctx;
+        }
         return {
             ...ctx,
             static: {
                 ...localResources,
-                ...(ctx.static || {})
+                ...existingStatic
             }
         };
     }

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

@@ -438,6 +438,28 @@ export interface FunnelInitializeRequest {
      * @example '/checkout', 'https://store.com/payment'
      */
     currentUrl?: string;
+    /**
+     * A/B test variant ID extracted from injected HTML
+     * Used to track which variant the user is seeing in an A/B test
+     * @example 'step_1765015842897_variant_1'
+     */
+    funnelVariantId?: string;
+    /**
+     * Funnel step ID extracted from injected HTML
+     * Used to track which step the user is on
+     * @example 'step_1765015842897'
+     */
+    funnelStepId?: string;
+    /**
+     * 🎯 Draft/preview mode flag (explicit from SDK, more robust than URL parsing)
+     * When true, uses draft/staging data instead of production data
+     */
+    draft?: boolean;
+    /**
+     * 🎯 Funnel tracking enable/disable flag (explicit from SDK, more robust than URL parsing)
+     * When false, disables all funnel tracking events (useful for iframed previews in config editor)
+     */
+    funnelTracking?: boolean;
 }
 export interface FunnelInitializeResponse {
     success: boolean;

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

@@ -204,16 +204,77 @@ export declare class OffersResource {
     getOfferById(offerId: string): Promise<Offer>;
     /**
      * Get offers for a store
+     * @param storeId - Store ID
+     * @param offerIds - Optional array of offer IDs to filter by
      */
-    getOffers(storeId: string): Promise<Offer[]>;
+    getOffers(storeId: string, offerIds?: string[]): Promise<Offer[]>;
     /**
-     * Get offers by IDs
+     * Get offers by IDs (now uses backend filtering for better performance)
      */
     getOffersByIds(storeId: string, offerIds: string[]): Promise<Offer[]>;
+    /**
+     * Preview an offer with calculated summary (no checkout session creation)
+     * @param offerId - Offer ID
+     * @param currency - Currency code
+     * @param lineItems - Optional line items with variant/quantity selections
+     *   - Use lineItemId for precise updates (same product, different variants)
+     *   - Use productId for simple updates (all items with this product)
+     */
+    previewOffer(offerId: string, currency?: string, lineItems?: Array<{
+        lineItemId?: string;
+        productId?: string;
+        variantId: string;
+        quantity: number;
+    }>): Promise<any>;
+    /**
+     * Preview and pay for an offer with variant selections
+     * Combines preview + checkout session creation in one call
+     * @param offerId - Offer ID
+     * @param currency - Currency code
+     * @param lineItems - Line items with variant/quantity selections
+     * @param returnUrl - Optional return URL for checkout
+     * @param mainOrderId - Optional main order ID (for upsells)
+     */
+    payPreviewedOffer(offerId: string, currency?: string, lineItems?: Array<{
+        lineItemId?: string;
+        productId?: string;
+        variantId: string;
+        quantity: number;
+    }>, returnUrl?: string, mainOrderId?: string): Promise<{
+        preview: any;
+        checkout: {
+            checkoutUrl: string;
+            customerId?: string;
+            checkoutSessionId?: string;
+        };
+    }>;
+    /**
+     * Create checkout session from previewed offer WITHOUT paying
+     * Used for landing pages to prepare checkout before actual payment
+     * @param offerId - Offer ID
+     * @param currency - Currency code
+     * @param lineItems - Line items with variant/quantity selections
+     * @param returnUrl - Optional return URL for checkout
+     * @param mainOrderId - Optional main order ID
+     */
+    toCheckout(offerId: string, currency?: string, lineItems?: Array<{
+        lineItemId?: string;
+        productId?: string;
+        variantId: string;
+        quantity: number;
+    }>, returnUrl?: string, mainOrderId?: string): Promise<{
+        checkoutSessionId?: string;
+        checkoutToken?: string;
+        customerId?: string;
+        checkoutUrl: string;
+    }>;
     /**
      * Initialize checkout session for an offer
+     * @param offerId - Offer ID (required)
+     * @param orderId - Order ID (optional - used for post-purchase upsells)
+     * @param customerId - Customer ID (optional)
      */
-    initCheckoutSession(offerId: string, orderId: string, customerId?: string): Promise<{
+    initCheckoutSession(offerId: string, orderId?: string, customerId?: string): Promise<{
         checkoutSessionId: string;
     }>;
     /**

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

@@ -2,6 +2,7 @@
  * Offers Resource Client
  * Axios-based API client for offers endpoints
  */
+import { isDraftMode } from '../utils/previewMode';
 export class OffersResource {
     constructor(apiClient) {
         this.apiClient = apiClient;
@@ -15,28 +16,125 @@ export class OffersResource {
     }
     /**
      * Get offers for a store
+     * @param storeId - Store ID
+     * @param offerIds - Optional array of offer IDs to filter by
      */
-    async getOffers(storeId) {
-        const response = await this.apiClient.get(`/api/v1/stores/${storeId}/offers`);
+    async getOffers(storeId, offerIds) {
+        let url = `/api/v1/stores/${storeId}/offers`;
+        // Add ids query parameter if provided (backend filtering for performance)
+        if (offerIds && offerIds.length > 0) {
+            const idsParam = offerIds.map(id => `ids=${encodeURIComponent(id)}`).join('&');
+            url += `?${idsParam}`;
+        }
+        const response = await this.apiClient.get(url);
         return response.offers || [];
     }
     /**
-     * Get offers by IDs
+     * Get offers by IDs (now uses backend filtering for better performance)
      */
     async getOffersByIds(storeId, offerIds) {
-        const allOffers = await this.getOffers(storeId);
-        return allOffers.filter(offer => offerIds.includes(offer.id));
+        // Use backend filtering instead of fetching all and filtering client-side
+        return await this.getOffers(storeId, offerIds);
+    }
+    /**
+     * Preview an offer with calculated summary (no checkout session creation)
+     * @param offerId - Offer ID
+     * @param currency - Currency code
+     * @param lineItems - Optional line items with variant/quantity selections
+     *   - Use lineItemId for precise updates (same product, different variants)
+     *   - Use productId for simple updates (all items with this product)
+     */
+    async previewOffer(offerId, currency = 'USD', lineItems) {
+        console.log('📡 [OffersResource] Calling preview API:', {
+            offerId,
+            currency,
+            lineItems,
+            endpoint: `/api/v1/offers/${offerId}/preview`,
+        });
+        const response = await this.apiClient.post(`/api/v1/offers/${offerId}/preview`, {
+            offerId,
+            currency,
+            lineItems,
+        });
+        console.log('📥 [OffersResource] Preview API response:', response);
+        return response;
+    }
+    /**
+     * Preview and pay for an offer with variant selections
+     * Combines preview + checkout session creation in one call
+     * @param offerId - Offer ID
+     * @param currency - Currency code
+     * @param lineItems - Line items with variant/quantity selections
+     * @param returnUrl - Optional return URL for checkout
+     * @param mainOrderId - Optional main order ID (for upsells)
+     */
+    async payPreviewedOffer(offerId, currency = 'USD', lineItems, returnUrl, mainOrderId) {
+        console.log('💳 [OffersResource] Calling pay-preview API:', {
+            offerId,
+            currency,
+            lineItems,
+            returnUrl,
+            mainOrderId,
+            endpoint: `/api/v1/offers/${offerId}/pay-preview`,
+        });
+        const response = await this.apiClient.post(`/api/v1/offers/${offerId}/pay-preview`, {
+            offerId,
+            currency,
+            lineItems,
+            returnUrl: returnUrl || (typeof window !== 'undefined' ? window.location.href : ''),
+            mainOrderId,
+        });
+        console.log('📥 [OffersResource] Pay-preview API response:', response);
+        return response;
+    }
+    /**
+     * Create checkout session from previewed offer WITHOUT paying
+     * Used for landing pages to prepare checkout before actual payment
+     * @param offerId - Offer ID
+     * @param currency - Currency code
+     * @param lineItems - Line items with variant/quantity selections
+     * @param returnUrl - Optional return URL for checkout
+     * @param mainOrderId - Optional main order ID
+     */
+    async toCheckout(offerId, currency = 'USD', lineItems, returnUrl, mainOrderId) {
+        console.log('🛒 [OffersResource] Calling to-checkout API:', {
+            offerId,
+            currency,
+            lineItems,
+            returnUrl,
+            mainOrderId,
+            endpoint: `/api/v1/offers/${offerId}/to-checkout`,
+        });
+        const response = await this.apiClient.post(`/api/v1/offers/${offerId}/to-checkout`, {
+            offerId,
+            currency,
+            lineItems,
+            returnUrl: returnUrl || (typeof window !== 'undefined' ? window.location.href : ''),
+            mainOrderId,
+        });
+        console.log('📥 [OffersResource] To-checkout API response:', response);
+        return response;
     }
     /**
      * Initialize checkout session for an offer
+     * @param offerId - Offer ID (required)
+     * @param orderId - Order ID (optional - used for post-purchase upsells)
+     * @param customerId - Customer ID (optional)
      */
     async initCheckoutSession(offerId, orderId, customerId) {
-        const response = await this.apiClient.post('/api/v1/checkout/offer/init', {
+        // 🎯 Check draft mode from URL, localStorage, or cookie
+        const draft = isDraftMode();
+        const payload = {
             offerId,
             returnUrl: typeof window !== 'undefined' ? window.location.href : '',
             customerId: customerId || '',
-            orderId,
-        });
+            draft, // 🎯 Pass draft mode
+        };
+        // Only include orderId if provided (used for post-purchase upsells)
+        if (orderId) {
+            payload.orderId = orderId;
+        }
+        const response = await this.apiClient.post('/api/v1/checkout/offer/init', payload);
         return { checkoutSessionId: response.checkoutSessionId };
     }
     /**
@@ -52,9 +150,11 @@ export class OffersResource {
      * Pay with checkout session
      */
     async payWithCheckoutSession(checkoutSessionId, orderId) {
+        // 🎯 Check draft mode from URL, localStorage, or cookie
+        const draft = isDraftMode();
         await this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/pay`, {
             checkoutSessionId,
-            draft: false,
+            draft, // 🎯 Use dynamic draft mode instead of hardcoded false
             returnUrl: typeof window !== 'undefined' ? window.location.href : '',
             metadata: {
                 comingFromPostPurchase: true,
@@ -68,9 +168,11 @@ export class OffersResource {
      * Pay for an offer directly
      */
     async payOffer(offerId, orderId) {
+        // 🎯 Check draft mode from URL, localStorage, or cookie
+        const draft = isDraftMode();
         return this.apiClient.post(`/api/v1/offers/${offerId}/pay`, {
             offerId,
-            draft: false,
+            draft, // 🎯 Use dynamic draft mode instead of hardcoded false
             returnUrl: typeof window !== 'undefined' ? window.location.href : '',
             metadata: orderId ? {
                 comingFromPostPurchase: true,

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

@@ -2,6 +2,7 @@
  * Post Purchases Resource Client
  * Axios-based API client for post-purchase endpoints
  */
+import { isDraftMode } from '../utils/previewMode';
 export class PostPurchasesResource {
     constructor(apiClient) {
         this.apiClient = apiClient;
@@ -85,9 +86,11 @@ export class PostPurchasesResource {
      * Pay with a checkout session for a post-purchase offer
      */
     async payWithCheckoutSession(checkoutSessionId, orderId) {
+        // 🎯 Check draft mode from URL, localStorage, or cookie
+        const draft = isDraftMode();
         await this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/pay`, {
             checkoutSessionId,
-            draft: false,
+            draft, // 🎯 Use dynamic draft mode instead of hardcoded false
             returnUrl: typeof window !== 'undefined' ? window.location.href : '',
             metadata: {
                 comingFromPostPurchase: true,

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

@@ -0,0 +1,39 @@
+/**
+ * Config Hot Reload Utilities
+ *
+ * Enables live config editing without page reload.
+ * Used by the config editor to push updates to preview iframes.
+ */
+export interface ConfigUpdateMessage {
+    type: 'TAGADAPAY_CONFIG_UPDATE';
+    config: Record<string, any>;
+    timestamp?: number;
+}
+/**
+ * Send config update to target window (iframe, popup, etc.)
+ *
+ * @param targetWindow - Window to send update to (e.g., iframe.contentWindow)
+ * @param config - Updated config object
+ * @param targetOrigin - Target origin (default: '*' for same-origin)
+ */
+export declare function sendConfigUpdate(targetWindow: Window, config: Record<string, any>, targetOrigin?: string): void;
+/**
+ * Send config update to all iframes on the page
+ * Useful for config editor with multiple preview panes
+ *
+ * @param config - Updated config object
+ * @param selector - CSS selector for iframes (default: 'iframe')
+ */
+export declare function broadcastConfigUpdate(config: Record<string, any>, selector?: string): void;
+/**
+ * Setup a listener for config updates
+ * Returns cleanup function
+ *
+ * @param callback - Function to call when config is updated
+ */
+export declare function onConfigUpdate(callback: (config: Record<string, any>) => void): () => void;
+/**
+ * Debounce helper for config updates
+ * Prevents too many updates in quick succession
+ */
+export declare function debounceConfigUpdate(fn: (config: Record<string, any>) => void, delay?: number): (config: Record<string, any>) => void;