@zaplier/sdk 1.7.2 → 1.7.4

package/dist/index.cjs

@@ -19276,85 +19276,6 @@ class AutoTracker {
          */
         this.cachedScrollElements = null;
         this.lastScrollElementsCheck = 0;
-        this.handleScroll = () => {
-            if (!this.config.trackScrolls)
-                return;
-            // Throttle scroll events for performance
-            const now = Date.now();
-            if (now - this.scrollThrottle < 100)
-                return; // 100ms throttle
-            this.scrollThrottle = now;
-            const scrollElements = document.querySelectorAll('[data-track-scroll]');
-            if (this.config.debug && scrollElements.length > 0) {
-                console.log(`[AutoTracker] Checking ${scrollElements.length} scroll elements`, {
-                    scrollY: window.scrollY,
-                    innerHeight: window.innerHeight
-                });
-            }
-            scrollElements.forEach((element) => {
-                let hasTriggered = element.getAttribute('data-scroll-triggered') === 'true';
-                if (hasTriggered)
-                    return;
-                const threshold = parseFloat(element.getAttribute("data-scroll-threshold") || "0.5");
-                const rect = element.getBoundingClientRect();
-                const elementHeight = rect.height;
-                const visibleHeight = Math.min(rect.bottom, window.innerHeight) - Math.max(rect.top, 0);
-                const visibilityRatio = Math.max(0, visibleHeight) / elementHeight;
-                if (this.config.debug) {
-                    console.log(`[AutoTracker] Element check:`, {
-                        elementId: element.id || element.className,
-                        visibilityRatio: Math.round(visibilityRatio * 100) / 100,
-                        threshold,
-                        triggered: hasTriggered
-                    });
-                }
-                if (visibilityRatio >= threshold) {
-                    element.setAttribute('data-scroll-triggered', 'true');
-                    const eventName = element.getAttribute("data-track-scroll");
-                    if (!eventName)
-                        return;
-                    const metadata = this.extractMetadata(element);
-                    this.trackEvent(eventName, {
-                        type: "scroll",
-                        element: element.tagName.toLowerCase(),
-                        threshold,
-                        scrollDepth: window.scrollY,
-                        visibilityRatio: Math.round(visibilityRatio * 100) / 100,
-                        ...metadata,
-                    });
-                    if (this.config.debug) {
-                        console.log(`[AutoTracker] Scroll tracked: ${eventName}`, {
-                            threshold,
-                            visibilityRatio,
-                            scrollDepth: window.scrollY,
-                            ...metadata
-                        });
-                    }
-                }
-            });
-        };
-        this.handleClick = (event) => {
-            if (!this.config.trackClicks)
-                return;
-            const target = event.target;
-            if (!target || !target.hasAttribute("data-track-click"))
-                return;
-            const eventName = target.getAttribute("data-track-click");
-            if (!eventName)
-                return;
-            const metadata = this.extractMetadata(target);
-            this.trackEvent(eventName, {
-                type: "click",
-                element: target.tagName.toLowerCase(),
-                ...metadata,
-            });
-            if (this.config.debug) {
-                console.log(`[AutoTracker] Click tracked: ${eventName}`, {
-                    element: target.tagName.toLowerCase(),
-                    ...metadata
-                });
-            }
-        };
         this.sdkInstance = sdkInstance;
         this.config = {
             enabled: true,
@@ -19645,18 +19566,73 @@ class AutoTracker {
             const clickHandler = this.createReactCompatibleClickHandler();
             this.delegationHandlers.set('click', clickHandler);
             delegationTarget.addEventListener('click', clickHandler, this.getEventOptions('click'));
+            if (this.config.debug) {
+                console.log("[👆 AutoTracker] Click delegation handler added");
+            }
         }
-        // Scroll delegation with enhanced detection
+        // CRITICAL FIX: Scroll delegation with enhanced detection
         if (this.config.trackScrolls) {
             const scrollHandler = this.createEnhancedScrollHandler();
             this.delegationHandlers.set('scroll', scrollHandler);
+            // Always use document for scroll events (window doesn't work with removeEventListener)
             document.addEventListener('scroll', scrollHandler, this.getEventOptions('scroll'));
+            if (this.config.debug) {
+                console.log("[📜 AutoTracker] ✅ Scroll delegation handler added to document");
+                console.log("[📜 AutoTracker] 📋 Event listener details:", {
+                    target: 'document',
+                    eventType: 'scroll',
+                    handlerType: typeof scrollHandler,
+                    options: this.getEventOptions('scroll'),
+                    handlerStored: this.delegationHandlers.has('scroll')
+                });
+                // Test if handler is actually working
+                const testHandler = () => {
+                    console.log("[📜 AutoTracker] 🧪 MANUAL SCROLL TEST - Handler should trigger");
+                    scrollHandler(new Event('scroll'));
+                };
+                // Expose test function globally for manual testing
+                if (typeof window !== 'undefined') {
+                    window.testScrollHandler = testHandler;
+                    console.log("[📜 AutoTracker] 🧪 Manual test available: window.testScrollHandler()");
+                }
+                // Immediate test of element detection
+                setTimeout(() => {
+                    const scrollElements = this.getCachedScrollElements();
+                    console.log(`[📜 AutoTracker] 📍 Initial scroll elements check: ${scrollElements.length} found`);
+                    if (scrollElements.length > 0) {
+                        Array.from(scrollElements).forEach((element, index) => {
+                            console.log(`[📜 AutoTracker] Element ${index + 1}:`, {
+                                id: element.id || 'no-id',
+                                trackEvent: element.getAttribute('data-track-scroll'),
+                                threshold: element.getAttribute('data-scroll-threshold') || '0.5',
+                                tagName: element.tagName,
+                                rect: element.getBoundingClientRect(),
+                                isVisible: element.getBoundingClientRect().height > 0
+                            });
+                        });
+                    }
+                    // Also test manually trigger one element
+                    if (scrollElements.length > 0) {
+                        const firstElement = scrollElements[0];
+                        if (firstElement) {
+                            console.log(`[📜 AutoTracker] 🧪 Testing manual trigger on first element:`, firstElement.getAttribute('data-track-scroll'));
+                            setTimeout(() => {
+                                console.log("[📜 AutoTracker] 🧪 Manual trigger test executed");
+                            }, 500);
+                        }
+                    }
+                }, 100);
+            }
         }
         // Setup debounced mutation observer for dynamic content
         this.setupIntelligentMutationObserver();
         this.isInitialized = true;
         if (this.config.debug) {
-            console.log("[✅ AutoTracker] Event delegation setup complete");
+            console.log("[✅ AutoTracker] Event delegation setup complete", {
+                clickHandler: this.delegationHandlers.has('click'),
+                scrollHandler: this.delegationHandlers.has('scroll'),
+                totalHandlers: this.delegationHandlers.size
+            });
         }
     }
     /**
@@ -19784,44 +19760,98 @@ class AutoTracker {
     createEnhancedScrollHandler() {
         return () => {
             try {
-                if (!this.config.trackScrolls)
+                if (this.config.debug) {
+                    console.log(`[📜 AutoTracker] 🚀 SCROLL HANDLER CALLED`, {
+                        trackScrolls: this.config.trackScrolls,
+                        scrollY: window.scrollY,
+                        timestamp: Date.now()
+                    });
+                }
+                if (!this.config.trackScrolls) {
+                    if (this.config.debug) {
+                        console.log(`[📜 AutoTracker] ⏭️ Scroll tracking disabled, skipping`);
+                    }
                     return;
+                }
                 // Adaptive throttling based on scroll frequency
                 const now = Date.now();
                 const timeDelta = now - this.scrollThrottle;
                 const throttleDelay = this.diagnostics.environment?.isMobile ? 150 : 100;
-                if (timeDelta < throttleDelay)
+                if (this.config.debug) {
+                    console.log(`[📜 AutoTracker] ⏱️ Throttle check:`, {
+                        timeDelta,
+                        throttleDelay,
+                        willProcess: timeDelta >= throttleDelay,
+                        lastScrollThrottle: this.scrollThrottle
+                    });
+                }
+                if (timeDelta < throttleDelay) {
+                    if (this.config.debug) {
+                        console.log(`[📜 AutoTracker] ⏸️ Throttled - skipping (${timeDelta}ms < ${throttleDelay}ms)`);
+                    }
                     return;
+                }
                 this.scrollThrottle = now;
                 // Enhanced element finding with caching
                 const scrollElements = this.getCachedScrollElements();
-                if (this.config.debug && scrollElements.length > 0) {
-                    console.log(`[📜 AutoTracker] Processing ${scrollElements.length} scroll elements`, {
+                if (this.config.debug) {
+                    console.log(`[📜 AutoTracker] 🔍 Processing scroll elements:`, {
+                        scrollElementsFound: scrollElements.length,
+                        scrollY: window.scrollY,
+                        windowHeight: window.innerHeight,
                         throttleDelay,
-                        timeDelta,
-                        scrollY: window.scrollY
+                        timeDelta
                     });
                 }
                 // Process elements with enhanced visibility detection
-                scrollElements.forEach((element) => {
-                    this.processScrollElementEnhanced(element);
-                });
+                if (scrollElements.length > 0) {
+                    if (this.config.debug) {
+                        console.log(`[📜 AutoTracker] 🎯 Starting to process ${scrollElements.length} elements`);
+                    }
+                    scrollElements.forEach((element, index) => {
+                        if (this.config.debug) {
+                            console.log(`[📜 AutoTracker] 🔄 Processing element ${index + 1}/${scrollElements.length}:`, {
+                                elementId: element.id || 'no-id',
+                                trackEvent: element.getAttribute('data-track-scroll'),
+                                hasTriggered: element.getAttribute('data-scroll-triggered') === 'true'
+                            });
+                        }
+                        this.processScrollElementEnhanced(element);
+                    });
+                    if (this.config.debug) {
+                        console.log(`[📜 AutoTracker] ✅ Finished processing all ${scrollElements.length} elements`);
+                    }
+                }
+                else if (this.config.debug) {
+                    console.log(`[📜 AutoTracker] ⚠️ No scroll elements found to process - cache might be empty`);
+                }
             }
             catch (error) {
                 if (this.config.debug) {
-                    console.error('[❌ AutoTracker] Scroll handler error:', error);
+                    console.error('[❌ AutoTracker] CRITICAL: Enhanced scroll handler error:', error);
                 }
             }
         };
     }
     getCachedScrollElements() {
         const now = Date.now();
-        const cacheExpiry = 5000; // 5 seconds
+        const cacheExpiry = 2000; // Reduced to 2 seconds for faster detection
         if (!this.cachedScrollElements || (now - this.lastScrollElementsCheck) > cacheExpiry) {
             this.cachedScrollElements = document.querySelectorAll('[data-track-scroll]');
             this.lastScrollElementsCheck = now;
             if (this.config.debug) {
-                console.log(`[🔄 AutoTracker] Refreshed scroll elements cache: ${this.cachedScrollElements.length} elements`);
+                console.log(`[🔄 AutoTracker] Refreshed scroll elements cache: ${this.cachedScrollElements.length} elements found`);
+                // Log each element found for debugging
+                Array.from(this.cachedScrollElements).forEach((element, index) => {
+                    console.log(`[🔄 AutoTracker] Cached element ${index + 1}:`, {
+                        id: element.id || 'no-id',
+                        className: element.className || 'no-class',
+                        trackEvent: element.getAttribute('data-track-scroll'),
+                        threshold: element.getAttribute('data-scroll-threshold') || '0.5',
+                        tagName: element.tagName,
+                        triggered: element.getAttribute('data-scroll-triggered') === 'true'
+                    });
+                });
             }
         }
         return this.cachedScrollElements;
@@ -19832,43 +19862,71 @@ class AutoTracker {
     processScrollElementEnhanced(element) {
         try {
             const hasTriggered = element.getAttribute('data-scroll-triggered') === 'true';
-            if (hasTriggered)
+            if (hasTriggered) {
+                if (this.config.debug) {
+                    console.log(`[⏭️ AutoTracker] Element already triggered, skipping:`, element.id || element.className || 'no-id');
+                }
                 return;
+            }
             const threshold = parseFloat(element.getAttribute('data-scroll-threshold') || '0.5');
             // Enhanced visibility calculation
             const rect = element.getBoundingClientRect();
             const elementHeight = rect.height;
             const windowHeight = window.innerHeight;
             // Handle edge cases
-            if (elementHeight <= 0)
+            if (elementHeight <= 0) {
+                if (this.config.debug) {
+                    console.log(`[⚠️ AutoTracker] Element has no height, skipping:`, element.id || 'no-id');
+                }
                 return;
+            }
             const visibleTop = Math.max(rect.top, 0);
             const visibleBottom = Math.min(rect.bottom, windowHeight);
             const visibleHeight = Math.max(0, visibleBottom - visibleTop);
             const visibilityRatio = visibleHeight / elementHeight;
+            const eventName = element.getAttribute('data-track-scroll');
+            if (!eventName) {
+                if (this.config.debug) {
+                    console.log(`[⚠️ AutoTracker] Element missing data-track-scroll attribute:`, element.id || 'no-id');
+                }
+                return;
+            }
             if (this.config.debug) {
-                console.log(`[📊 AutoTracker] Enhanced scroll check:`, {
-                    elementId: element.id || element.className || 'no-id',
-                    rect: {
-                        top: Math.round(rect.top),
-                        bottom: Math.round(rect.bottom),
-                        height: Math.round(elementHeight)
+                const shouldTrigger = visibilityRatio >= threshold;
+                console.log(`[📊 AutoTracker] 🔍 DETAILED visibility check for "${eventName}":`, {
+                    elementInfo: {
+                        id: element.id || 'no-id',
+                        className: element.className || 'no-class',
+                        tagName: element.tagName,
+                        trackEvent: eventName,
+                        threshold: threshold
+                    },
+                    positioning: {
+                        rect_top: Math.round(rect.top),
+                        rect_bottom: Math.round(rect.bottom),
+                        rect_height: Math.round(elementHeight),
+                        window_height: windowHeight,
+                        scroll_y: window.scrollY
                     },
-                    visibility: {
-                        ratio: Math.round(visibilityRatio * 1000) / 1000,
-                        threshold,
-                        triggered: hasTriggered
+                    visibilityCalculation: {
+                        step1_visibleTop: `Math.max(${Math.round(rect.top)}, 0) = ${visibleTop}`,
+                        step2_visibleBottom: `Math.min(${Math.round(rect.bottom)}, ${windowHeight}) = ${visibleBottom}`,
+                        step3_visibleHeight: `Math.max(0, ${visibleBottom} - ${visibleTop}) = ${visibleHeight}`,
+                        step4_visibilityRatio: `${visibleHeight} / ${Math.round(elementHeight)} = ${Math.round(visibilityRatio * 1000) / 1000}`,
+                        step5_comparison: `${Math.round(visibilityRatio * 1000) / 1000} >= ${threshold} = ${shouldTrigger}`
                     },
-                    scroll: window.scrollY
+                    status: {
+                        hasTriggered: hasTriggered,
+                        willTrigger: shouldTrigger && !hasTriggered,
+                        skipReason: hasTriggered ? 'already_triggered' : (!shouldTrigger ? 'not_visible_enough' : 'none')
+                    }
                 });
             }
             if (visibilityRatio >= threshold) {
+                // Mark as triggered to prevent duplicate events
                 element.setAttribute('data-scroll-triggered', 'true');
-                const eventName = element.getAttribute('data-track-scroll');
-                if (!eventName)
-                    return;
                 const metadata = this.extractMetadata(element);
-                this.trackEvent(eventName, {
+                const eventData = {
                     type: 'scroll',
                     element: element.tagName.toLowerCase(),
                     threshold,
@@ -19876,20 +19934,22 @@ class AutoTracker {
                     visibilityRatio: Math.round(visibilityRatio * 1000) / 1000,
                     enhanced: true,
                     ...metadata,
-                });
+                };
                 if (this.config.debug) {
-                    console.log(`[🎯 AutoTracker] Scroll tracked (enhanced): ${eventName}`, {
-                        threshold,
-                        visibilityRatio: Math.round(visibilityRatio * 1000) / 1000,
-                        scrollDepth: window.scrollY,
-                        ...metadata
-                    });
+                    console.log(`[🎯 AutoTracker] TRIGGERING scroll event "${eventName}":`, eventData);
+                }
+                this.trackEvent(eventName, eventData);
+                if (this.config.debug) {
+                    console.log(`[✅ AutoTracker] Scroll event "${eventName}" sent successfully`);
                 }
             }
         }
         catch (error) {
             if (this.config.debug) {
-                console.error('[❌ AutoTracker] Scroll element processing error:', error);
+                console.error('[❌ AutoTracker] Scroll element processing error:', error, {
+                    element: element.id || element.className || 'no-id',
+                    tagName: element.tagName
+                });
             }
         }
     }
@@ -20195,17 +20255,18 @@ class AutoTracker {
     trackEvent(eventName, metadata) {
         const trackingStart = performance.now();
         if (this.config.debug) {
-            console.log("[🚀 AutoTracker] Enhanced trackEvent called:", {
+            console.log("[🚀 AutoTracker] 🎯 TRACK EVENT CALLED:", {
                 eventName,
                 metadata,
-                timestamp: new Date().toISOString()
+                timestamp: new Date().toISOString(),
+                stackTrace: new Error().stack?.split('\n').slice(1, 4) // Show call stack
             });
         }
         // Comprehensive validation
         const validation = this.validateTrackingCall(eventName, metadata);
         if (!validation.isValid) {
             if (this.config.debug) {
-                console.error("[❌ AutoTracker] Validation failed:", validation.errors);
+                console.error("[❌ AutoTracker] 🚫 VALIDATION FAILED:", validation.errors);
             }
             return;
         }
@@ -20226,12 +20287,29 @@ class AutoTracker {
                 ...metadata,
             };
             if (this.config.debug) {
-                console.log("[📡 AutoTracker] Sending enhanced event:", { eventName, eventData });
+                console.log("[📡 AutoTracker] 📤 SENDING EVENT TO SDK:", {
+                    eventName,
+                    eventData,
+                    sdkInstanceExists: !!this.sdkInstance,
+                    trackCustomEventExists: typeof this.sdkInstance?.trackCustomEvent === 'function'
+                });
+            }
+            if (!this.sdkInstance) {
+                if (this.config.debug) {
+                    console.error("[❌ AutoTracker] 🚫 SDK INSTANCE IS NULL - CANNOT SEND EVENT");
+                }
+                return;
+            }
+            if (typeof this.sdkInstance.trackCustomEvent !== 'function') {
+                if (this.config.debug) {
+                    console.error("[❌ AutoTracker] 🚫 trackCustomEvent IS NOT A FUNCTION:", typeof this.sdkInstance.trackCustomEvent);
+                }
+                return;
             }
             const result = this.sdkInstance.trackCustomEvent(eventName, eventData);
             if (this.config.debug) {
                 const trackingEnd = performance.now();
-                console.log("[✅ AutoTracker] Event sent successfully:", {
+                console.log("[✅ AutoTracker] 🎉 EVENT SENT SUCCESSFULLY:", {
                     eventName,
                     result,
                     totalLatency: Math.round((trackingEnd - trackingStart) * 100) / 100 + 'ms'
@@ -20240,11 +20318,13 @@ class AutoTracker {
         }
         catch (error) {
             if (this.config.debug) {
-                console.error("[💥 AutoTracker] Critical tracking error:", {
+                console.error("[💥 AutoTracker] 💀 CRITICAL TRACKING ERROR:", {
                     eventName,
                     error: error instanceof Error ? error.message : error,
                     stack: error instanceof Error ? error.stack : undefined,
-                    metadata
+                    metadata,
+                    sdkInstance: !!this.sdkInstance,
+                    sdkInstanceType: typeof this.sdkInstance
                 });
             }
         }
@@ -20271,6 +20351,8 @@ class AutoTracker {
             errors
         };
     }
+    // Legacy handlers removed - now using enhanced event delegation system
+    // All tracking is now handled by createEnhancedScrollHandler and createReactCompatibleClickHandler
     /**
      * Modern API: Refresh tracking for dynamic content (React/SPA support)
      * Industry best practice for SPA route changes
@@ -20303,6 +20385,50 @@ class AutoTracker {
      * Get comprehensive diagnostic information for debugging
      */
     getDiagnostics() {
+        // Create manual test functions
+        const manualTests = {
+            triggerScrollHandler: () => {
+                if (this.config.debug) {
+                    console.log("[🧪 AutoTracker] Manual scroll handler trigger");
+                }
+                const handler = this.delegationHandlers.get('scroll');
+                if (handler) {
+                    handler(new Event('scroll'));
+                }
+                else {
+                    console.error("[❌ AutoTracker] No scroll handler found");
+                }
+            },
+            forceScrollEvent: (elementSelector) => {
+                const element = document.querySelector(elementSelector);
+                if (!element) {
+                    console.error(`[❌ AutoTracker] Element not found: ${elementSelector}`);
+                    return;
+                }
+                const eventName = element.getAttribute('data-track-scroll');
+                if (!eventName) {
+                    console.error(`[❌ AutoTracker] Element has no data-track-scroll: ${elementSelector}`);
+                    return;
+                }
+                console.log(`[🧪 AutoTracker] Force triggering scroll event: ${eventName}`);
+                // Reset trigger state
+                element.removeAttribute('data-scroll-triggered');
+                // Force trigger
+                this.processScrollElementEnhanced(element);
+            },
+            testTrackEvent: (eventName = 'test_event') => {
+                console.log(`[🧪 AutoTracker] Testing trackEvent: ${eventName}`);
+                this.trackEvent(eventName, {
+                    type: 'test',
+                    source: 'manual_diagnostic',
+                    timestamp: Date.now()
+                });
+            }
+        };
+        // Expose tests globally for easy access
+        if (typeof window !== 'undefined') {
+            window.autoTrackerTests = manualTests;
+        }
         return {
             // Initialization status
             initialization: {
@@ -20344,7 +20470,17 @@ class AutoTracker {
             // Validation status
             validation: this.validateTrackingCall('test', {}),
             // Debug recommendations
-            recommendations: this.generateRecommendations()
+            recommendations: this.generateRecommendations(),
+            // Manual testing functions
+            manualTests: {
+                available: true,
+                usage: {
+                    triggerScrollHandler: 'window.autoTrackerTests.triggerScrollHandler()',
+                    forceScrollEvent: 'window.autoTrackerTests.forceScrollEvent("[data-track-scroll]")',
+                    testTrackEvent: 'window.autoTrackerTests.testTrackEvent("my_event")'
+                },
+                description: 'Use these functions in the browser console to manually test the AutoTracker'
+            }
         };
     }
     /**
@@ -20396,6 +20532,33 @@ class AutoTracker {
     }
 }
 
+/**
+ * Centralized Session Utilities
+ * Standardized session ID generation for consistency across SDK and backend
+ */
+/**
+ * Generate standardized session ID
+ * Format: visitorId_YYYYMMDD_HH
+ * Example: f697a6e1-1aae-48db-bc6a-afc1d2c01852_20251231_03
+ */
+function generateSessionId(visitorId, date) {
+    const sessionDate = date || new Date();
+    // Format: YYYYMMDD
+    const year = sessionDate.getFullYear();
+    const month = (sessionDate.getMonth() + 1).toString().padStart(2, '0');
+    const day = sessionDate.getDate().toString().padStart(2, '0');
+    const dateStr = `${year}${month}${day}`;
+    // Format: HH (24-hour format)
+    const hour = sessionDate.getHours().toString().padStart(2, '0');
+    return `${visitorId}_${dateStr}_${hour}`;
+}
+/**
+ * Generate session ID for current time
+ */
+function generateCurrentSessionId(visitorId) {
+    return generateSessionId(visitorId, new Date());
+}
+
 /**
  * Visitor Persistence Manager for SDK
  * Implements client-side visitor identification with localStorage camouflage
@@ -20555,9 +20718,23 @@ class VisitorIdentityManager {
     // REMOVED: generateVisitorId() and generateVisitorIdFromHash() methods
     // SDK no longer generates visitor IDs - only backend does
     generateSessionId() {
-        return "ses_" + Array.from(crypto.getRandomValues(new Uint8Array(8)))
-            .map(b => b.toString(16).padStart(2, '0'))
-            .join('') + "_" + Date.now().toString(36);
+        // Try to get existing visitor identity from storage
+        const { value: storedData } = PersistenceManager.get(STORAGE_KEYS.prefs);
+        if (storedData) {
+            try {
+                const parsed = JSON.parse(storedData);
+                if (parsed._v && parsed._vb === true) {
+                    // We have a valid visitor ID from backend
+                    return generateCurrentSessionId(parsed._v);
+                }
+            }
+            catch (e) {
+                // Invalid data, continue to fallback
+            }
+        }
+        // Fallback for cases where visitor ID is not available yet
+        const tempVisitorId = "temp-" + Date.now().toString(36);
+        return generateCurrentSessionId(tempVisitorId);
     }
     createCamouflageData(visitorId, sessionId, stableCoreHash, fromBackend = false) {
         return {
@@ -20567,7 +20744,7 @@ class VisitorIdentityManager {
             analytics: true,
             cookies: true,
             _v: visitorId, // Hidden visitor ID
-            _s: sessionId, // Hidden session ID  
+            _s: sessionId, // Hidden session ID
             _sc: stableCoreHash, // Hidden stable core
             _vb: fromBackend ? true : undefined, // Flag: visitor ID from backend (v1.7.0+)
             ts: Date.now(),
@@ -20611,7 +20788,9 @@ class VisitorIdentityManager {
         const { value: storedData, method } = PersistenceManager.get(STORAGE_KEYS.prefs);
         if (storedData) {
             const existingIdentity = this.extractFromCamouflage(storedData);
-            if (existingIdentity && existingIdentity.stableCoreHash === stableCoreHash && existingIdentity.visitorId) {
+            if (existingIdentity &&
+                existingIdentity.stableCoreHash === stableCoreHash &&
+                existingIdentity.visitorId) {
                 // Update last seen time only if we have a valid visitor ID from backend
                 const updatedCamouflage = this.createCamouflageData(existingIdentity.visitorId, existingIdentity.sessionId, stableCoreHash);
                 PersistenceManager.set(STORAGE_KEYS.prefs, JSON.stringify(updatedCamouflage));
@@ -20631,7 +20810,7 @@ class VisitorIdentityManager {
             stableCoreHash,
             deviceFingerprint: params.deviceFingerprint,
             persistenceMethod: "memory", // Start with memory, upgrade after backend response
-            confidence: 0.90,
+            confidence: 0.9,
             createdAt: Date.now(),
             lastSeen: Date.now(),
             reused: false,
@@ -20646,7 +20825,12 @@ class VisitorIdentityManager {
     async updateVisitorIdFromBackend(visitorId, stableCoreHash, sessionId) {
         try {
             // Create or update camouflaged data with backend visitor ID
-            const currentSessionId = sessionId || this.getCurrentSessionId() || this.generateSessionId();
+            // Regenerate session ID with proper visitor ID if needed
+            let currentSessionId = sessionId || this.getCurrentSessionId();
+            // If we have a temp session ID or no session ID, generate a new one with the proper visitor ID
+            if (!currentSessionId || currentSessionId.includes("temp-")) {
+                currentSessionId = generateCurrentSessionId(visitorId);
+            }
             const camouflageData = this.createCamouflageData(visitorId, currentSessionId, stableCoreHash, true // Mark as coming from backend
             );
             const { success, method } = PersistenceManager.set(STORAGE_KEYS.prefs, JSON.stringify(camouflageData));
@@ -20658,7 +20842,7 @@ class VisitorIdentityManager {
             return false;
         }
         catch (error) {
-            console.error('[VisitorIdentityManager] Failed to update visitor ID from backend:', error);
+            console.error("[VisitorIdentityManager] Failed to update visitor ID from backend:", error);
             return false;
         }
     }
@@ -21112,36 +21296,17 @@ class ZaplierSDK {
         }
     }
     /**
-     * Generate session ID
+     * Generate session ID using standardized format
      */
     generateSessionId() {
-        // Create deterministic session ID based on page load time and stable browser characteristics
-        const pageLoadTime = performance.timeOrigin || Date.now();
-        const browserFingerprint = this.getBrowserFingerprint();
-        // Use page load time + browser fingerprint for session uniqueness within same page load
-        return pageLoadTime.toString(36) + browserFingerprint.substring(0, 8);
-    }
-    /**
-     * Get stable browser characteristics for session ID generation
-     * Uses only stable, privacy-safe values that don't change during session
-     */
-    getBrowserFingerprint() {
-        const components = [
-            navigator.userAgent || "",
-            navigator.platform || "",
-            screen.width || 0,
-            screen.height || 0,
-            new Date(2024, 0, 1).getTimezoneOffset(),
-            navigator.language || "",
-            navigator.hardwareConcurrency || 0,
-        ];
-        const combined = components.join("|");
-        let hash = 0;
-        for (let i = 0; i < combined.length; i++) {
-            const char = combined.charCodeAt(i);
-            hash = ((hash << 5) - hash + char) & 0xffffffff;
+        // Use centralized session generation with current visitor ID
+        if (this.backendVisitorId) {
+            return generateCurrentSessionId(this.backendVisitorId);
         }
-        return Math.abs(hash).toString(36);
+        // Fallback for cases where backendVisitorId is not available yet
+        // This should be rare and will be updated when visitor ID is available
+        const tempVisitorId = this.visitorId || 'temp-' + Date.now().toString(36);
+        return generateCurrentSessionId(tempVisitorId);
     }
     /**
      * Initialize Anti-Adblock Manager
@@ -21400,6 +21565,10 @@ class ZaplierSDK {
             if (response.sessionId) {
                 this.sessionId = response.sessionId;
             }
+            else if (this.backendVisitorId && (!this.sessionId || this.sessionId.includes('temp-'))) {
+                // Generate new session ID now that we have the proper visitor ID
+                this.sessionId = generateCurrentSessionId(this.backendVisitorId);
+            }
             return response;
         }
         catch (error) {