@keak/sdk 2.1.1 → 2.1.3

package/dist/index.js

@@ -1616,138 +1616,15 @@ var KeakToolbar$1 = /*#__PURE__*/Object.freeze({
   KeakToolbar: KeakToolbar
 });
 
-const Conversion = ({ children, type = 'custom', category, label, value, metadata = {}, disabled = false }) => {
-    // In production, render children without tracking
-    const isProduction = typeof process !== 'undefined' && process.env.NODE_ENV === 'production';
-    const elementRef = useRef(null);
-    const conversionId = useRef(`conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`);
-    useEffect(() => {
-        // Skip tracking in production
-        if (isProduction || disabled)
-            return;
-        // Track conversion element exposure (event tracking is disabled in SDK, this is a no-op)
-        keak.track('conversion_exposure', {
-            conversionId: conversionId.current,
-            type,
-            category,
-            label,
-            metadata: {
-                ...metadata,
-                timestamp: new Date().toISOString(),
-                url: window.location.href,
-                referrer: document.referrer
-            }
-        });
-    }, [isProduction, type, category, label, metadata, disabled]);
-    const handleClick = (event) => {
-        if (disabled || isProduction)
-            return;
-        // Extract additional context from the clicked element
-        event.currentTarget;
-        const clickedElement = event.target;
-        // Determine the actual clicked element type and content
-        let elementType = type;
-        let elementText = '';
-        let elementTag = '';
-        let href = '';
-        if (clickedElement) {
-            elementTag = clickedElement.tagName.toLowerCase();
-            elementText = clickedElement.textContent?.trim() || clickedElement.getAttribute('value') || clickedElement.getAttribute('alt') || '';
-            // Auto-detect element type if not specified
-            if (type === 'custom') {
-                if (elementTag === 'button' || clickedElement.getAttribute('role') === 'button') {
-                    elementType = 'button';
-                }
-                else if (elementTag === 'a') {
-                    elementType = 'link';
-                    href = clickedElement.getAttribute('href') || '';
-                }
-                else if (elementTag === 'input' && (clickedElement.getAttribute('type') === 'submit' || clickedElement.getAttribute('type') === 'button')) {
-                    elementType = 'button';
-                }
-            }
-            // Auto-detect category based on text content if not specified
-            if (!category && elementText) {
-                const text = elementText.toLowerCase();
-                if (/buy|purchase|checkout|order|cart/.test(text)) {
-                    category = 'purchase';
-                }
-                else if (/sign.?up|register|join/.test(text)) {
-                    category = 'signup';
-                }
-                else if (/download|get.?app/.test(text)) {
-                    category = 'download';
-                }
-                else if (/demo|trial|preview/.test(text)) {
-                    category = 'demo';
-                }
-                else if (/contact|call|phone/.test(text)) {
-                    category = 'contact';
-                }
-                else if (/learn.?more|read.?more/.test(text)) {
-                    category = 'engagement';
-                }
-            }
-        }
-        // Track the conversion with variant snapshot
-        const conversionName = `${category || 'uncategorized'}_${elementType}`;
-        const conversionValue = value || 1;
-        const additionalData = {
-            conversionId: conversionId.current,
-            type: elementType,
-            category: category || 'uncategorized',
-            label: label || elementText || 'unlabeled',
-            elementDetails: {
-                tag: elementTag,
-                text: elementText,
-                href,
-                className: clickedElement.className,
-                id: clickedElement.id
-            },
-            ...metadata,
-            viewport: {
-                width: window.innerWidth,
-                height: window.innerHeight
-            },
-            scroll: {
-                x: window.scrollX,
-                y: window.scrollY
-            },
-            referrer: document.referrer
-        };
-        // Use the new snapshot-based conversion tracking
-        keak.trackConversion(conversionName, conversionValue, additionalData);
-        // Optional: Add visual feedback for debugging in development
-        if (process.env.NODE_ENV === 'development') {
-            console.log('🎯 Conversion snapshot tracked:', {
-                id: conversionId.current,
-                conversionName,
-                conversionValue,
-                type: elementType,
-                category: category || 'uncategorized',
-                label: label || elementText || 'unlabeled',
-                element: elementTag,
-                snapshotApproach: true
-            });
-            // Show brief visual feedback
-            const element = elementRef.current;
-            if (element) {
-                const originalTransition = element.style.transition;
-                element.style.transition = 'all 0.2s ease';
-                element.style.transform = 'scale(0.98)';
-                setTimeout(() => {
-                    element.style.transform = 'scale(1)';
-                    setTimeout(() => {
-                        element.style.transition = originalTransition;
-                    }, 200);
-                }, 100);
-            }
-        }
-    };
-    return (jsx("div", { ref: elementRef, onClick: handleClick, style: {
+/**
+ * Conversion component - renders children without tracking
+ * Tracking is handled by the embedded script, not the SDK
+ */
+const Conversion = ({ children, type = 'custom', category, disabled = false }) => {
+    return (jsx("div", { style: {
             display: 'contents', // This makes the wrapper invisible to CSS layout
             pointerEvents: disabled ? 'none' : 'auto'
-        }, "data-keak-conversion-id": conversionId.current, "data-keak-conversion-type": type, "data-keak-conversion-category": category, children: children }));
+        }, "data-keak-conversion-type": type, "data-keak-conversion-category": category, children: children }));
 };
 
 function sourcePathInjectionRuntime(sourceMapping) {
@@ -2192,29 +2069,58 @@ function buildSourcePathInjection(mapping) {
     return `(${sourcePathInjectionRuntime.toString()})(${mappingJson});`;
 }
 
+// Hook to wait for embedded script to load (desktop projects only)
+function useWaitForEmbeddedScript() {
+    const [ready, setReady] = useState(false);
+    const [isDesktopProject, setIsDesktopProject] = useState(false);
+    useEffect(() => {
+        // Check if embedded data already exists
+        if (typeof window !== 'undefined' && window.KEAK_EMBEDDED_DATA) {
+            const hasProjectUuid = !!window.KEAK_EMBEDDED_DATA.projectUuid;
+            setIsDesktopProject(hasProjectUuid);
+            setReady(true);
+            return;
+        }
+        // Poll for embedded data (max 500ms, check every 50ms)
+        let attempts = 0;
+        const maxAttempts = 10; // 10 * 50ms = 500ms
+        const interval = setInterval(() => {
+            attempts++;
+            if (typeof window !== 'undefined' && window.KEAK_EMBEDDED_DATA) {
+                const hasProjectUuid = !!window.KEAK_EMBEDDED_DATA.projectUuid;
+                setIsDesktopProject(hasProjectUuid);
+                setReady(true);
+                clearInterval(interval);
+            }
+            else if (attempts >= maxAttempts) {
+                // Timeout - not a desktop project or script failed to load
+                setReady(true);
+                setIsDesktopProject(false);
+                clearInterval(interval);
+            }
+        }, 50);
+        return () => clearInterval(interval);
+    }, []);
+    return { ready, isDesktopProject };
+}
 // Global Keak instance
 let keakInstance = null;
 let toolbarInitialized = false;
 class KeakSDK {
     constructor(config) {
         this.assignments = {};
-        this.eventQueue = [];
         this.initialized = false;
         this.liveExperiments = new Map();
-        this.impressions = new Map(); // experimentId -> variantName -> count
         this.config = config;
         this.userId = config.userId || this.generateUserId();
         this.sessionId = config.sessionId || this.generateSessionId();
         this.deviceId = this.generateDeviceId();
-        this.loadImpressions();
     }
     async init() {
         try {
             // Use empty assignments - no backend integration
             this.assignments = {};
             this.initialized = true;
-            // Setup automatic event tracking
-            this.setupAutoTracking();
             if (this.config.debug) {
                 console.log('Keak SDK initialized successfully', {
                     assignments: this.assignments,
@@ -2227,99 +2133,6 @@ class KeakSDK {
             this.initialized = true; // Continue with empty assignments
         }
     }
-    getVariant(experimentKey, availableVariants) {
-        // Use local assignment only
-        if (availableVariants && availableVariants.length > 0) {
-            const localAssignment = this.assignVariant(experimentKey, availableVariants);
-            return localAssignment;
-        }
-        // Fallback to control
-        return 'control';
-    }
-    trackEvent(eventName, properties = {}) {
-        // Event tracking disabled - dashboard only receives impression data
-        if (this.config.debug) {
-            console.log(`🔇 [Keak SDK] Event tracking disabled: ${eventName}`, properties);
-        }
-    }
-    trackClick(elementId, text) {
-        // Click tracking disabled - dashboard only receives impression data
-        if (this.config.debug) {
-            console.log(`🔇 [Keak SDK] Click tracking disabled: ${elementId}`, text);
-        }
-    }
-    trackConversion(conversionName, value, additionalData) {
-        const snapshot = this.takeVariantSnapshot(conversionName, value, additionalData);
-        if (this.config.debug) {
-            console.log(`🎯 [Keak SDK] Conversion tracked: ${conversionName}`, {
-                value,
-                snapshot: snapshot.activeVariants,
-                totalExperiments: Object.keys(snapshot.activeVariants).length
-            });
-        }
-    }
-    // Take a snapshot of all currently active variants when conversion happens
-    takeVariantSnapshot(conversionName, value, additionalData) {
-        const activeVariants = {};
-        const experimentMetadata = {};
-        // Capture all live experiments and their current variant assignments
-        this.liveExperiments.forEach((experiment, experimentId) => {
-            const currentVariant = this.getVariant(experimentId, experiment.variants?.map((v) => v.name));
-            activeVariants[experimentId] = currentVariant;
-            experimentMetadata[experimentId] = {
-                name: experiment.name,
-                totalVariants: experiment.totalVariants,
-                variants: experiment.variants,
-                pageUrl: experiment.pageUrl
-            };
-        });
-        // Capture visitor metadata at conversion time
-        const visitorMetadata = this.captureVisitorMetadata();
-        const snapshot = {
-            conversionId: `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            conversionName,
-            conversionValue: value,
-            userId: this.userId,
-            sessionId: this.sessionId,
-            timestamp: new Date().toISOString(),
-            activeVariants,
-            experimentMetadata,
-            pageUrl: window.location.href,
-            visitorMetadata, // NEW: Include visitor metadata
-            additionalData: additionalData || {}
-        };
-        // Store conversion locally as backup
-        this.storeConversionLocally(snapshot);
-        return snapshot;
-    }
-    // Store conversion snapshot locally
-    storeConversionLocally(snapshot) {
-        try {
-            const stored = localStorage.getItem('keak_conversions') || '[]';
-            const conversions = JSON.parse(stored);
-            conversions.push(snapshot);
-            // Keep only last 100 conversions to prevent storage bloat
-            if (conversions.length > 100) {
-                conversions.splice(0, conversions.length - 100);
-            }
-            localStorage.setItem('keak_conversions', JSON.stringify(conversions));
-        }
-        catch (error) {
-            if (this.config.debug) {
-                console.warn('Failed to store conversion locally:', error);
-            }
-        }
-    }
-    setupAutoTracking() {
-        // Auto-tracking disabled
-        if (this.config.debug) {
-            console.log('🔇 [Keak SDK] Auto-tracking disabled');
-        }
-    }
-    flushEvents() {
-        // No event queue to flush - events are disabled
-        this.eventQueue = [];
-    }
     generateUserId() {
         // Try to get existing user ID from localStorage
         const existing = localStorage.getItem('keak_user_id');
@@ -2342,194 +2155,16 @@ class KeakSDK {
         localStorage.setItem('keak_device_id', deviceId.toString());
         return deviceId.toString();
     }
-    // Capture visitor metadata at the moment of event
-    captureVisitorMetadata() {
-        const ua = navigator.userAgent;
-        const platform = navigator.platform;
-        // Detect OS
-        let os = 'Unknown';
-        if (/iPhone/.test(ua))
-            os = 'iPhone';
-        else if (/iPad/.test(ua))
-            os = 'iPad';
-        else if (/Android/.test(ua))
-            os = 'Android';
-        else if (platform.includes('Win'))
-            os = 'Windows';
-        else if (platform.includes('Mac'))
-            os = 'macOS';
-        else if (platform.includes('Linux'))
-            os = 'Linux';
-        else
-            os = platform || 'Unknown';
-        // Detect browser
-        let browser = 'Unknown';
-        if (ua.includes('Edg/'))
-            browser = 'Edge';
-        else if (ua.includes('Chrome') && !ua.includes('Edg'))
-            browser = 'Chrome';
-        else if (ua.includes('Safari') && !ua.includes('Chrome'))
-            browser = 'Safari';
-        else if (ua.includes('Firefox'))
-            browser = 'Firefox';
-        // Get location from localStorage cache (updated by MetricsPanel)
-        let country = 'Unknown';
-        let ipAddress = 'Unknown';
-        try {
-            const locationCache = localStorage.getItem('keak_location_cache');
-            if (locationCache) {
-                const location = JSON.parse(locationCache);
-                country = location.country || 'Unknown';
-                ipAddress = location.ipAddress || 'Unknown';
-            }
-        }
-        catch (error) {
-            // Ignore parsing errors
-        }
-        return {
-            location: {
-                country,
-                ipAddress
-            },
-            device: {
-                os,
-                browser,
-                screenSize: `${window.screen.width} × ${window.screen.height}`,
-                viewport: `${window.innerWidth} × ${window.innerHeight}`,
-                userAgent: ua
-            },
-            session: {
-                userId: this.userId,
-                deviceId: this.deviceId,
-                sessionId: this.sessionId,
-                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'Unknown',
-                language: navigator.language || 'Unknown'
-            }
-        };
-    }
-    // Simple hash function for deterministic randomization
-    simpleHash(str) {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            hash = ((hash << 5) - hash + str.charCodeAt(i)) & 0xffffffff;
-        }
-        return Math.abs(hash);
-    }
-    // Get or create variant assignment for user
-    assignVariant(experimentId, variants) {
-        const storageKey = `keak_assignment_${experimentId}`;
-        const stored = localStorage.getItem(storageKey);
-        if (stored && variants.includes(stored)) {
-            return stored;
-        }
-        // Deterministic randomization based on userId + experimentId
-        const hash = this.simpleHash(`${this.userId}_${experimentId}`);
-        const selectedVariant = variants[hash % variants.length];
-        try {
-            localStorage.setItem(storageKey, selectedVariant);
-        }
-        catch (error) {
-            if (this.config.debug) {
-                console.warn('Failed to store variant assignment:', error);
-            }
-        }
-        if (this.config.debug) {
-            console.log(`🎯 [Keak SDK] Assigned variant "${selectedVariant}" for experiment "${experimentId}" to user ${this.userId}`);
-        }
-        return selectedVariant;
-    }
-    // Impression tracking methods
-    loadImpressions() {
-        try {
-            const stored = localStorage.getItem('keak_impressions');
-            if (stored) {
-                const data = JSON.parse(stored);
-                this.impressions = new Map(Object.entries(data).map(([experimentId, variants]) => [
-                    experimentId,
-                    new Map(Object.entries(variants))
-                ]));
-            }
-        }
-        catch (error) {
-            if (this.config.debug) {
-                console.warn('Failed to load impressions from localStorage:', error);
-            }
-        }
-    }
-    saveImpressions() {
-        try {
-            const data = {};
-            this.impressions.forEach((variants, experimentId) => {
-                data[experimentId] = Object.fromEntries(variants);
-            });
-            localStorage.setItem('keak_impressions', JSON.stringify(data));
-        }
-        catch (error) {
-            if (this.config.debug) {
-                console.warn('Failed to save impressions to localStorage:', error);
-            }
-        }
-    }
-    trackImpression(experimentId, variantName) {
-        if (!this.impressions.has(experimentId)) {
-            this.impressions.set(experimentId, new Map());
-        }
-        const variants = this.impressions.get(experimentId);
-        const currentCount = variants.get(variantName) || 0;
-        variants.set(variantName, currentCount + 1);
-        this.saveImpressions();
-        // Store impression with visitor metadata
-        this.storeImpressionWithMetadata(experimentId, variantName);
-    }
-    storeImpressionWithMetadata(experimentId, variantName) {
-        try {
-            const visitorMetadata = this.captureVisitorMetadata();
-            const impressionEvent = {
-                experimentId,
-                variantName,
-                timestamp: new Date().toISOString(),
-                pageUrl: window.location.href,
-                visitorMetadata
-            };
-            // Store in separate detailed impressions log
-            const stored = localStorage.getItem('keak_impressions_detailed') || '[]';
-            const impressions = JSON.parse(stored);
-            impressions.push(impressionEvent);
-            // Keep only last 1000 impressions to prevent storage bloat
-            if (impressions.length > 1000) {
-                impressions.splice(0, impressions.length - 1000);
-            }
-            localStorage.setItem('keak_impressions_detailed', JSON.stringify(impressions));
-        }
-        catch (error) {
-            if (this.config.debug) {
-                console.warn('Failed to store impression metadata:', error);
-            }
-        }
-    }
-    getImpressions(experimentId) {
-        const variants = this.impressions.get(experimentId);
-        return variants ? Object.fromEntries(variants) : {};
-    }
-    getAllImpressions() {
-        const data = {};
-        this.impressions.forEach((variants, experimentId) => {
-            data[experimentId] = Object.fromEntries(variants);
-        });
-        return data;
-    }
     // Register live experiment
     registerLiveExperiment(experimentData) {
-        const impressions = this.getImpressions(experimentData.experimentId);
         this.liveExperiments.set(experimentData.experimentId, {
             ...experimentData,
             isActive: true,
             registeredAt: new Date().toISOString(),
-            currentVariant: this.assignments[experimentData.experimentId] || experimentData.variants[0]?.name || 'control',
-            impressions: impressions
+            currentVariant: this.assignments[experimentData.experimentId] || experimentData.variants[0]?.name || 'control'
         });
         if (this.config.debug) {
-            console.log('📋 [Keak SDK] Live experiment registered:', experimentData.experimentId, 'Impressions:', impressions);
+            console.log('📋 [Keak SDK] Live experiment registered:', experimentData.experimentId);
         }
     }
     // Get all live experiments for management panel
@@ -2543,7 +2178,6 @@ class KeakSDK {
         const experiment = this.liveExperiments.get(experimentId);
         if (experiment) {
             experiment.currentVariant = variant;
-            experiment.impressions = this.getImpressions(experimentId); // Update impressions
             this.liveExperiments.set(experimentId, experiment);
         }
         if (this.config.debug) {
@@ -2760,10 +2394,20 @@ const Experiment = ({ name, children, active = true }) => {
     if (typeof process !== 'undefined' && process.env.NODE_ENV === 'production') {
         return jsx(Fragment, { children: children });
     }
-    // Access global SDK instance directly (no context needed)
-    const assignments = keakInstance?.assignments || {};
     // Use enhanced variant detection
     const variantElements = detectVariantElements(children);
+    // CRITICAL: Wait for embedded script to load (desktop projects only)
+    const { ready, isDesktopProject } = useWaitForEmbeddedScript();
+    // BLOCKING LOGIC: If desktop project and script not ready yet, return null
+    // This prevents both variants from rendering and causing flicker
+    if (isDesktopProject && !ready) {
+        if (keakInstance?.config.debug) {
+            console.log(`[Keak SDK] Waiting for embedded script for "${name}"...`);
+        }
+        return null; // Don't render anything until script loads
+    }
+    // Access global SDK instance directly (no context needed)
+    const assignments = keakInstance?.assignments || {};
     // Extract comprehensive variant metadata
     const variantMetadata = variantElements.map(variant => {
         const variantContent = extractVariantContent(variant.props.children);
@@ -2784,7 +2428,7 @@ const Experiment = ({ name, children, active = true }) => {
         window.location.hostname === '127.0.0.1' ||
         window.location.port !== '' ||
         keakInstance?.config.debug);
-    // Register experiment with SDK for live management
+    // Register experiment with SDK for live management (for toolbar)
     useEffect(() => {
         if (keakInstance && variantElements.length > 0) {
             // Register experiment with enhanced metadata
@@ -2805,39 +2449,10 @@ const Experiment = ({ name, children, active = true }) => {
             };
             // Register live experiment for management panel
             keakInstance.registerLiveExperiment(experimentData);
-            // Only track impressions if experiment is active
-            if (active) {
-                const variantNames = variantMetadata.map(v => v.name);
-                // In dev mode, don't call getVariant (which stores in localStorage)
-                // Instead, use "treatment" for tracking purposes
-                let assignedVariant;
-                if (isDevMode) {
-                    assignedVariant = variantNames.includes('treatment') ? 'treatment' : variantNames[0];
-                    if (keakInstance.config.debug) {
-                        console.log(`🎯 [Keak SDK] Experiment "${name}" in dev mode, using "${assignedVariant}" for tracking (not stored)`);
-                    }
-                }
-                else {
-                    // Production mode: use normal assignment (stores in localStorage)
-                    assignedVariant = keakInstance.getVariant(name, variantNames);
-                    if (keakInstance.config.debug) {
-                        console.log(`🎯 [Keak SDK] Split test assignment for "${name}": → Variant "${assignedVariant}"`);
-                    }
-                }
-                // Track impression immediately when variant is determined
-                if (assignedVariant) {
-                    keakInstance.trackImpression(name, assignedVariant);
-                }
-            }
-            else {
-                if (keakInstance.config.debug) {
-                    console.log(`🔇 [Keak SDK] Experiment "${name}" is inactive, not tracking impressions`);
-                }
-            }
         }
-    }, [name, variantElements.length, variantMetadata, active, isDevMode]);
+    }, [name, variantElements.length, variantMetadata, active]);
     // Get variant assignment from SDK (with proper split testing)
-    const variantNames = variantMetadata.map(v => v.name);
+    variantMetadata.map(v => v.name);
     let selectedIndex;
     // Priority 1: Check for forced variant from setExperimentVariant (highest priority)
     const forcedVariant = keakInstance?.assignments[name] || assignments[name];
@@ -2850,7 +2465,37 @@ const Experiment = ({ name, children, active = true }) => {
             }
         }
     }
-    // If no forced variant, use normal logic
+    // Priority 2: Check for embedded script assignment (Keak Code desktop projects)
+    // This prevents flicker by using the script's computed assignment immediately
+    if (selectedIndex === undefined && typeof window !== 'undefined') {
+        try {
+            const embeddedData = window.KEAK_EMBEDDED_DATA;
+            const assignments = window.KeakAssign?.computeAssignments?.(embeddedData);
+            if (assignments && embeddedData?.variants) {
+                // Find test by matching selector (data-keak-id)
+                const testDataKeakId = `data-keak-id="${name.replace('cro-', 'the-')}"`;
+                const matchingTest = embeddedData.variants.find((v) => v.selector?.includes(testDataKeakId) || v.selector?.includes(name));
+                if (matchingTest && assignments[matchingTest.testId]) {
+                    const embeddedVariant = assignments[matchingTest.testId]; // 'A' or 'B'
+                    const embeddedVariantName = embeddedVariant === 'A' ? 'control' : 'treatment';
+                    const embeddedIndex = variantElements.findIndex((variant) => variant.props.name === embeddedVariantName);
+                    if (embeddedIndex !== -1) {
+                        selectedIndex = embeddedIndex;
+                        if (keakInstance?.config.debug) {
+                            console.log(`📱 [Keak SDK] Using embedded script assignment for "${name}": ${embeddedVariantName} (${embeddedVariant})`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Silently fail - fallback to normal logic below
+            if (keakInstance?.config.debug) {
+                console.log(`⚠️ [Keak SDK] Could not read embedded script assignment:`, error);
+            }
+        }
+    }
+    // If no forced variant or embedded assignment, use normal logic
     if (selectedIndex === undefined) {
         if (!active) {
             // Inactive: Always show control variant (original)
@@ -2874,16 +2519,14 @@ const Experiment = ({ name, children, active = true }) => {
             }
         }
         else {
-            // Active in production: Normal A/B split testing
-            const assignedVariantName = keakInstance?.getVariant(name, variantNames) || variantNames[0];
-            // Find the index of the assigned variant
-            selectedIndex = variantElements.findIndex((variant) => variant.props.name === assignedVariantName);
-            // Safety fallback - if assigned variant not found, use first variant
-            if (selectedIndex === -1 && variantElements.length > 0) {
-                selectedIndex = 0;
-                if (keakInstance?.config.debug) {
-                    console.warn(`⚠️ [Keak SDK] Assigned variant "${assignedVariantName}" not found, using first variant`);
-                }
+            // Active in production: Show control (original) by default
+            // Embedded script will handle A/B assignment if present
+            selectedIndex = variantElements.findIndex((variant) => variant.props.name === 'control');
+            if (selectedIndex === -1) {
+                selectedIndex = 0; // Fallback to first variant if no "control" named variant
+            }
+            if (keakInstance?.config.debug) {
+                console.log(`🎯 [Keak SDK] Experiment "${name}" in production, showing control (embedded script handles A/B)`);
             }
         }
     }
@@ -2906,6 +2549,40 @@ const Experiment = ({ name, children, active = true }) => {
     // Get selected variant metadata
     variantMetadata[currentIndex];
     // Clean up unused variables - toolbar positioning removed
+    // Notify embedded script when variant has rendered (for Keak Code desktop projects)
+    // This allows the script to skip DOM manipulation and only track impressions
+    useEffect(() => {
+        if (typeof window !== 'undefined' && selectedIndex !== undefined) {
+            try {
+                const selectedVariant = variantElements[selectedIndex];
+                const variantName = selectedVariant?.props.name;
+                // Check if embedded script is present
+                if (window.KEAK_EMBEDDED_DATA && variantName) {
+                    // Notify after a brief delay to ensure React has fully rendered
+                    setTimeout(() => {
+                        // Dispatch custom event that embedded script can listen for
+                        window.dispatchEvent(new CustomEvent('keak-sdk-variant-rendered', {
+                            detail: {
+                                experimentId: name,
+                                variantName: variantName, // 'control' or 'treatment'
+                                variant: variantName === 'control' ? 'A' : 'B', // Map to A/B
+                                element: experimentRef.current
+                            }
+                        }));
+                        if (keakInstance?.config.debug) {
+                            console.log(`📢 [Keak SDK] Notified embedded script: "${name}" rendered as "${variantName}"`);
+                        }
+                    }, 0);
+                }
+            }
+            catch (error) {
+                // Silently fail - not critical
+                if (keakInstance?.config.debug) {
+                    console.log(`⚠️ [Keak SDK] Could not notify embedded script:`, error);
+                }
+            }
+        }
+    }, [selectedIndex, name, variantElements]);
     if (variantElements.length === 0) {
         return null;
     }
@@ -2928,33 +2605,7 @@ const keak = {
         }
         return Promise.resolve();
     },
-    getVariant: (experimentKey, availableVariants) => {
-        if (!keakInstance) {
-            console.warn('Keak SDK not initialized. Call keak.init() first.');
-            return 'control';
-        }
-        return keakInstance.getVariant(experimentKey, availableVariants);
-    },
-    track: (eventName, properties) => {
-        // Event tracking disabled - dashboard only receives impression data
-        if (keakInstance?.config.debug) {
-            console.log(`🔇 [Keak SDK] Global event tracking disabled: ${eventName}`, properties);
-        }
-    },
-    trackClick: (elementId, text) => {
-        // Click tracking disabled - dashboard only receives impression data
-        if (keakInstance?.config.debug) {
-            console.log(`🔇 [Keak SDK] Global click tracking disabled: ${elementId}`, text);
-        }
-    },
-    trackConversion: (conversionName, value, additionalData) => {
-        if (!keakInstance) {
-            console.warn('Keak SDK not initialized. Call keak.init() first.');
-            return;
-        }
-        keakInstance.trackConversion(conversionName, value, additionalData);
-    },
-    // Live experiment management functions
+    // Live experiment management functions (for toolbar)
     getAllLiveExperiments: () => {
         if (!keakInstance) {
             console.warn('Keak SDK not initialized. Call keak.init() first.');
@@ -2965,24 +2616,6 @@ const keak = {
     setExperimentVariant: (experimentId, variant) => {
         keakInstance?.setExperimentVariant(experimentId, variant);
     },
-    // Impression tracking methods
-    trackImpression: (experimentId, variantName) => {
-        keakInstance?.trackImpression(experimentId, variantName);
-    },
-    getImpressions: (experimentId) => {
-        if (!keakInstance) {
-            console.warn('Keak SDK not initialized. Call keak.init() first.');
-            return {};
-        }
-        return keakInstance.getImpressions(experimentId);
-    },
-    getAllImpressions: () => {
-        if (!keakInstance) {
-            console.warn('Keak SDK not initialized. Call keak.init() first.');
-            return {};
-        }
-        return keakInstance.getAllImpressions();
-    },
 };
 // Initialize toolbar (called by useKeak hook)
 function initializeToolbar(config) {