@zaplier/sdk 1.4.2 → 1.6.2

package/dist/sdk.js

@@ -19018,14 +19018,20 @@
      * Based on official rrweb example for maximum compatibility
      */
     class SessionReplayEngine {
-        constructor(sessionId, config = {}) {
+        constructor(sessionId, visitorId, config = {}) {
             this.events = [];
             this.isActive = false;
+            this.isPaused = false;
+            this.lastActivityTime = Date.now();
+            this.sessionStartTime = Date.now();
             this.sessionId = sessionId;
+            this.visitorId = visitorId;
             this.config = {
                 enabled: true,
                 sampleRate: 1.0,
                 batchInterval: 10000, // 10 seconds like official example
+                inactivityTimeout: 30000, // 30 seconds of inactivity
+                pauseOnInactive: true, // Pause recording during inactivity
                 ...config,
             };
         }
@@ -19044,13 +19050,18 @@
                 // Simple rrweb recording configuration like official example
                 this.rrwebStopRecord = record({
                     emit: (event) => {
-                        // Simple event capture
-                        this.events.push(event);
+                        // Update activity time on any event
+                        this.onActivity();
+                        // Only capture events if not paused
+                        if (!this.isPaused) {
+                            this.events.push(event);
+                        }
                     },
                 });
                 this.isActive = true;
                 this.startBatchTimer();
-                console.log("[Zaplier] Session replay started - simple mode");
+                this.startInactivityTracking();
+                console.log("[Zaplier] Session replay started - with inactivity detection");
                 return true;
             }
             catch (error) {
@@ -19074,6 +19085,10 @@
                 clearInterval(this.batchTimer);
                 this.batchTimer = undefined;
             }
+            if (this.inactivityTimer) {
+                clearTimeout(this.inactivityTimer);
+                this.inactivityTimer = undefined;
+            }
             // Send final batch
             this.sendBatch();
         }
@@ -19092,17 +19107,21 @@
             if (this.events.length === 0) {
                 return;
             }
-            // Simple payload structure like official example
+            // Enhanced payload structure with visitor linking
             const payload = {
                 sessionId: this.sessionId,
+                visitorId: this.visitorId,
                 events: [...this.events], // Copy events array
                 metadata: {
                     userAgent: navigator.userAgent,
                     timestamp: Date.now(),
                     startUrl: window.location.href,
-                    duration: Date.now() - (performance.timeOrigin || Date.now()),
+                    duration: Date.now() - this.sessionStartTime,
+                    activeTime: this.getActiveTime(),
                     funnelSteps: [],
                     hasConversion: false,
+                    eventsCount: this.events.length,
+                    isPaused: this.isPaused,
                 },
             };
             // Reset events array like official example
@@ -19151,6 +19170,714 @@
         isRecording() {
             return this.isActive;
         }
+        /**
+         * Check if recording is paused
+         */
+        isPausedState() {
+            return this.isPaused;
+        }
+        /**
+         * Start inactivity tracking
+         */
+        startInactivityTracking() {
+            if (!this.config.pauseOnInactive)
+                return;
+            // Listen for user activity events
+            const activityEvents = ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart', 'click'];
+            activityEvents.forEach(event => {
+                document.addEventListener(event, this.onActivity.bind(this), true);
+            });
+            this.resetInactivityTimer();
+        }
+        /**
+         * Handle activity event
+         */
+        onActivity() {
+            this.lastActivityTime = Date.now();
+            // Resume if paused
+            if (this.isPaused) {
+                this.resume();
+            }
+            this.resetInactivityTimer();
+        }
+        /**
+         * Reset inactivity timer
+         */
+        resetInactivityTimer() {
+            if (this.inactivityTimer) {
+                clearTimeout(this.inactivityTimer);
+            }
+            this.inactivityTimer = window.setTimeout(() => {
+                this.pauseForInactivity();
+            }, this.config.inactivityTimeout);
+        }
+        /**
+         * Pause recording due to inactivity
+         */
+        pauseForInactivity() {
+            if (this.isPaused)
+                return;
+            this.isPaused = true;
+            console.log("[Zaplier] Session replay paused due to inactivity");
+        }
+        /**
+         * Resume recording after activity
+         */
+        resume() {
+            if (!this.isPaused)
+                return;
+            this.isPaused = false;
+            console.log("[Zaplier] Session replay resumed after activity");
+        }
+        /**
+         * Get total active time (excluding paused periods)
+         */
+        getActiveTime() {
+            const totalTime = Date.now() - this.sessionStartTime;
+            // For now, return total time. In production, track pause periods accurately
+            return totalTime;
+        }
+        /**
+         * Get visitor ID
+         */
+        getVisitorId() {
+            return this.visitorId;
+        }
+    }
+
+    /**
+     * Auto Tracker - Sistema de tracking automático via data-* attributes
+     *
+     * Suporta:
+     * - data-track-click="event-name"
+     * - data-track-scroll="event-name"
+     * - data-track-view="event-name"
+     * - data-track-hover="event-name"
+     * - data-track-form="event-name"
+     */
+    class AutoTracker {
+        constructor(sdkInstance, config = {}) {
+            this.observedElements = new Set();
+            /**
+             * Event handlers (bound to this)
+             */
+            this.handleClick = (event) => {
+                const target = event.target;
+                if (target.hasAttribute("data-track-click")) ;
+            };
+            this.handleScroll = () => {
+                // Scroll is handled by element-specific listeners
+            };
+            this.handleHover = (event) => {
+                // Hover is handled by element-specific listeners
+            };
+            this.handleForm = (event) => {
+                // Form is handled by element-specific listeners
+            };
+            this.sdkInstance = sdkInstance;
+            this.config = {
+                enabled: true,
+                trackClicks: true,
+                trackScrolls: true,
+                trackViews: true,
+                trackHovers: true,
+                trackForms: true,
+                debug: false,
+                ...config,
+            };
+        }
+        /**
+         * Inicializar auto tracking
+         */
+        start() {
+            if (!this.config.enabled)
+                return;
+            if (this.config.debug) {
+                console.log("[Zaplier AutoTracker] Iniciando auto tracking");
+            }
+            // Observer para novos elementos no DOM
+            this.observeDOM();
+            // Processar elementos já existentes
+            this.processExistingElements();
+            // Setup intersection observer para views
+            if (this.config.trackViews) {
+                this.setupViewTracking();
+            }
+        }
+        /**
+         * Parar auto tracking
+         */
+        stop() {
+            document.removeEventListener("click", this.handleClick);
+            document.removeEventListener("scroll", this.handleScroll);
+            document.removeEventListener("mouseover", this.handleHover);
+            document.removeEventListener("submit", this.handleForm);
+            if (this.intersectionObserver) {
+                this.intersectionObserver.disconnect();
+            }
+            this.observedElements.clear();
+        }
+        /**
+         * Observar mudanças no DOM para novos elementos
+         */
+        observeDOM() {
+            const observer = new MutationObserver((mutations) => {
+                mutations.forEach((mutation) => {
+                    mutation.addedNodes.forEach((node) => {
+                        if (node.nodeType === Node.ELEMENT_NODE) {
+                            this.processElement(node);
+                        }
+                    });
+                });
+            });
+            observer.observe(document.body, {
+                childList: true,
+                subtree: true,
+            });
+        }
+        /**
+         * Processar elementos já existentes no DOM
+         */
+        processExistingElements() {
+            // Buscar todos os elementos com data-track-*
+            const trackElements = document.querySelectorAll("[data-track-click], [data-track-scroll], [data-track-view], [data-track-hover], [data-track-form]");
+            trackElements.forEach((element) => {
+                this.processElement(element);
+            });
+        }
+        /**
+         * Processar um elemento específico
+         */
+        processElement(element) {
+            // Click tracking
+            if (this.config.trackClicks && element.hasAttribute("data-track-click")) {
+                this.setupClickTracking(element);
+            }
+            // Scroll tracking
+            if (this.config.trackScrolls && element.hasAttribute("data-track-scroll")) {
+                this.setupScrollTracking(element);
+            }
+            // View tracking
+            if (this.config.trackViews && element.hasAttribute("data-track-view")) {
+                this.setupElementViewTracking(element);
+            }
+            // Hover tracking
+            if (this.config.trackHovers && element.hasAttribute("data-track-hover")) {
+                this.setupHoverTracking(element);
+            }
+            // Form tracking
+            if (this.config.trackForms && element.hasAttribute("data-track-form")) {
+                this.setupFormTracking(element);
+            }
+        }
+        /**
+         * Setup click tracking
+         */
+        setupClickTracking(element) {
+            element.addEventListener("click", (event) => {
+                const eventName = element.getAttribute("data-track-click");
+                if (!eventName)
+                    return;
+                const metadata = this.extractMetadata(element);
+                this.trackEvent(eventName, {
+                    type: "click",
+                    element: element.tagName.toLowerCase(),
+                    ...metadata,
+                });
+                if (this.config.debug) {
+                    console.log(`[AutoTracker] Click tracked: ${eventName}`, metadata);
+                }
+            });
+        }
+        /**
+         * Setup scroll tracking
+         */
+        setupScrollTracking(element) {
+            let hasTriggered = false;
+            const threshold = parseFloat(element.getAttribute("data-scroll-threshold") || "0.5");
+            const handleScroll = () => {
+                if (hasTriggered)
+                    return;
+                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 (visibilityRatio >= threshold) {
+                    hasTriggered = 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,
+                        ...metadata,
+                    });
+                    if (this.config.debug) {
+                        console.log(`[AutoTracker] Scroll tracked: ${eventName}`, metadata);
+                    }
+                }
+            };
+            document.addEventListener("scroll", handleScroll, { passive: true });
+            // Check immediately in case element is already in view
+            setTimeout(handleScroll, 100);
+        }
+        /**
+         * Setup view tracking usando Intersection Observer
+         */
+        setupViewTracking() {
+            this.intersectionObserver = new IntersectionObserver((entries) => {
+                entries.forEach((entry) => {
+                    if (entry.isIntersecting) {
+                        const element = entry.target;
+                        const eventName = element.getAttribute("data-track-view");
+                        if (!eventName)
+                            return;
+                        const metadata = this.extractMetadata(element);
+                        this.trackEvent(eventName, {
+                            type: "view",
+                            element: element.tagName.toLowerCase(),
+                            intersectionRatio: entry.intersectionRatio,
+                            ...metadata,
+                        });
+                        if (this.config.debug) {
+                            console.log(`[AutoTracker] View tracked: ${eventName}`, metadata);
+                        }
+                        // Remove from observation after first trigger
+                        this.intersectionObserver?.unobserve(element);
+                    }
+                });
+            }, {
+                threshold: 0.5, // 50% visible
+                rootMargin: "0px",
+            });
+        }
+        /**
+         * Setup view tracking para elemento específico
+         */
+        setupElementViewTracking(element) {
+            if (!this.intersectionObserver)
+                return;
+            if (!this.observedElements.has(element)) {
+                this.intersectionObserver.observe(element);
+                this.observedElements.add(element);
+            }
+        }
+        /**
+         * Setup hover tracking
+         */
+        setupHoverTracking(element) {
+            let hoverStartTime;
+            const minHoverTime = parseInt(element.getAttribute("data-hover-time") || "1000");
+            element.addEventListener("mouseenter", () => {
+                hoverStartTime = Date.now();
+            });
+            element.addEventListener("mouseleave", () => {
+                const hoverDuration = Date.now() - hoverStartTime;
+                if (hoverDuration >= minHoverTime) {
+                    const eventName = element.getAttribute("data-track-hover");
+                    if (!eventName)
+                        return;
+                    const metadata = this.extractMetadata(element);
+                    this.trackEvent(eventName, {
+                        type: "hover",
+                        element: element.tagName.toLowerCase(),
+                        hoverDuration,
+                        minHoverTime,
+                        ...metadata,
+                    });
+                    if (this.config.debug) {
+                        console.log(`[AutoTracker] Hover tracked: ${eventName}`, metadata);
+                    }
+                }
+            });
+        }
+        /**
+         * Setup form tracking
+         */
+        setupFormTracking(element) {
+            if (element.tagName.toLowerCase() !== "form")
+                return;
+            element.addEventListener("submit", (event) => {
+                const eventName = element.getAttribute("data-track-form");
+                if (!eventName)
+                    return;
+                const formData = new FormData(element);
+                const metadata = this.extractMetadata(element);
+                // Extract form fields (without sensitive data)
+                const fields = {};
+                for (const [key, value] of formData.entries()) {
+                    // Skip sensitive fields
+                    if (!this.isSensitiveField(key)) {
+                        fields[key] =
+                            typeof value === "string" ? value.substring(0, 100) : "file";
+                    }
+                }
+                this.trackEvent(eventName, {
+                    type: "form_submit",
+                    element: "form",
+                    fieldCount: Array.from(formData.entries()).length,
+                    fields,
+                    ...metadata,
+                });
+                if (this.config.debug) {
+                    console.log(`[AutoTracker] Form submit tracked: ${eventName}`, metadata);
+                }
+            });
+        }
+        /**
+         * Extrair metadata do elemento
+         */
+        extractMetadata(element) {
+            const metadata = {};
+            // Extrair todos os data-meta-* attributes
+            Array.from(element.attributes).forEach((attr) => {
+                if (attr.name.startsWith("data-meta-")) {
+                    const key = attr.name.replace("data-meta-", "");
+                    metadata[key] = attr.value;
+                }
+            });
+            // Adicionar informações básicas
+            if (element.id)
+                metadata.elementId = element.id;
+            if (element.className)
+                metadata.elementClass = element.className;
+            // Text content (limitado)
+            const textContent = element.textContent?.trim();
+            if (textContent && textContent.length > 0) {
+                metadata.textContent = textContent.substring(0, 50);
+            }
+            // Position info
+            const rect = element.getBoundingClientRect();
+            metadata.elementPosition = {
+                x: Math.round(rect.left),
+                y: Math.round(rect.top),
+                width: Math.round(rect.width),
+                height: Math.round(rect.height),
+            };
+            return metadata;
+        }
+        /**
+         * Verificar se um campo é sensível
+         */
+        isSensitiveField(fieldName) {
+            const sensitivePatterns = [
+                /password/i,
+                /pass/i,
+                /pwd/i,
+                /secret/i,
+                /token/i,
+                /api[_-]?key/i,
+                /credit[_-]?card/i,
+                /ssn/i,
+                /social/i,
+                /tax/i,
+            ];
+            return sensitivePatterns.some((pattern) => pattern.test(fieldName));
+        }
+        /**
+         * Enviar evento para o SDK
+         */
+        trackEvent(eventName, metadata) {
+            if (!this.sdkInstance)
+                return;
+            try {
+                this.sdkInstance.trackCustomEvent(eventName, {
+                    autoTracked: true,
+                    timestamp: Date.now(),
+                    url: window.location.href,
+                    ...metadata,
+                });
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error("[AutoTracker] Error sending event:", error);
+                }
+            }
+        }
+        /**
+         * Configurar tracking
+         */
+        configure(config) {
+            this.config = { ...this.config, ...config };
+        }
+        /**
+         * Obter estatísticas
+         */
+        getStats() {
+            return {
+                observedElements: this.observedElements.size,
+                config: this.config,
+            };
+        }
+    }
+
+    /**
+     * Visitor Persistence Manager for SDK
+     * Implements client-side visitor identification with localStorage camouflage
+     */
+    // Camuflaged storage keys to avoid detection/blocking
+    const STORAGE_KEYS = {
+        session: "__zp_s", // Session identifier
+        visitor: "__zp_v", // Visitor identifier (camuflado)
+        device: "__zp_d", // Device fingerprint cache
+        prefs: "__zp_p", // User preferences (decoy storage)
+        analytics: "__zp_a", // Analytics preferences (additional decoy)
+    };
+    /**
+     * Multi-layer persistence manager with fallbacks
+     */
+    class PersistenceManager {
+        // 1. LocalStorage (primary) - Most persistent
+        static setLocal(key, value) {
+            try {
+                if (typeof window !== "undefined" && window.localStorage) {
+                    localStorage.setItem(key, value);
+                    return true;
+                }
+            }
+            catch (e) {
+                // Storage disabled/private mode
+            }
+            return false;
+        }
+        static getLocal(key) {
+            try {
+                if (typeof window !== "undefined" && window.localStorage) {
+                    return localStorage.getItem(key);
+                }
+            }
+            catch (e) {
+                // Storage disabled/private mode
+            }
+            return null;
+        }
+        // 2. SessionStorage (secondary) - Session-only
+        static setSession(key, value) {
+            try {
+                if (typeof window !== "undefined" && window.sessionStorage) {
+                    sessionStorage.setItem(key, value);
+                    return true;
+                }
+            }
+            catch (e) {
+                // Storage disabled/private mode
+            }
+            return false;
+        }
+        static getSession(key) {
+            try {
+                if (typeof window !== "undefined" && window.sessionStorage) {
+                    return sessionStorage.getItem(key);
+                }
+            }
+            catch (e) {
+                // Storage disabled/private mode
+            }
+            return null;
+        }
+        // 3. Cookie (tertiary) - Cross-session with expiration
+        static setCookie(key, value, days = 365) {
+            try {
+                if (typeof document !== "undefined") {
+                    const expires = new Date(Date.now() + days * 24 * 60 * 60 * 1000).toUTCString();
+                    document.cookie = `${key}=${value}; expires=${expires}; path=/; SameSite=Lax`;
+                    return true;
+                }
+            }
+            catch (e) {
+                // Cookies disabled
+            }
+            return false;
+        }
+        static getCookie(key) {
+            try {
+                if (typeof document !== "undefined") {
+                    const name = key + "=";
+                    const decodedCookie = decodeURIComponent(document.cookie);
+                    const ca = decodedCookie.split(";");
+                    for (let i = 0; i < ca.length; i++) {
+                        let c = ca[i];
+                        if (c) {
+                            while (c.charAt(0) === " ") {
+                                c = c.substring(1);
+                            }
+                            if (c.indexOf(name) === 0) {
+                                return c.substring(name.length, c.length);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // Cookies disabled
+            }
+            return null;
+        }
+        // 4. Memory (fallback) - Current session only
+        static setMemory(key, value) {
+            this.memoryStore.set(key, value);
+            return true;
+        }
+        static getMemory(key) {
+            return this.memoryStore.get(key) || null;
+        }
+        // Multi-layer get with fallbacks
+        static get(key) {
+            // Try localStorage first (most persistent)
+            let value = this.getLocal(key);
+            if (value)
+                return { value, method: "localStorage" };
+            // Try sessionStorage (session-only)
+            value = this.getSession(key);
+            if (value)
+                return { value, method: "sessionStorage" };
+            // Try cookies (cross-session)
+            value = this.getCookie(key);
+            if (value)
+                return { value, method: "cookie" };
+            // Try memory (current session)
+            value = this.getMemory(key);
+            if (value)
+                return { value, method: "memory" };
+            return { value: null, method: "none" };
+        }
+        // Multi-layer set with fallbacks
+        static set(key, value) {
+            // Try localStorage first (most persistent)
+            if (this.setLocal(key, value)) {
+                return { success: true, method: "localStorage" };
+            }
+            // Try sessionStorage (session-only)
+            if (this.setSession(key, value)) {
+                return { success: true, method: "sessionStorage" };
+            }
+            // Try cookies (cross-session)
+            if (this.setCookie(key, value)) {
+                return { success: true, method: "cookie" };
+            }
+            // Fallback to memory (current session)
+            this.setMemory(key, value);
+            return { success: true, method: "memory" };
+        }
+    }
+    PersistenceManager.memoryStore = new Map();
+    /**
+     * Advanced Visitor Identity Manager with Camouflaged Storage
+     */
+    class VisitorIdentityManager {
+        generateVisitorId() {
+            return "vis_" + Array.from(crypto.getRandomValues(new Uint8Array(16)))
+                .map(b => b.toString(16).padStart(2, '0'))
+                .join('');
+        }
+        generateSessionId() {
+            return "ses_" + Array.from(crypto.getRandomValues(new Uint8Array(8)))
+                .map(b => b.toString(16).padStart(2, '0'))
+                .join('') + "_" + Date.now().toString(36);
+        }
+        createCamouflageData(visitorId, sessionId, stableCoreHash) {
+            return {
+                theme: "auto",
+                lang: (navigator.language || "en-US").substring(0, 2),
+                tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                analytics: true,
+                cookies: true,
+                _v: visitorId, // Hidden visitor ID
+                _s: sessionId, // Hidden session ID  
+                _sc: stableCoreHash, // Hidden stable core
+                ts: Date.now(),
+            };
+        }
+        extractFromCamouflage(data) {
+            try {
+                const parsed = JSON.parse(data);
+                if (parsed._v && parsed._s && parsed._sc) {
+                    return {
+                        visitorId: parsed._v,
+                        sessionId: parsed._s,
+                        stableCoreHash: parsed._sc,
+                        persistenceMethod: "localStorage",
+                        confidence: 0.95,
+                        createdAt: parsed.ts || Date.now(),
+                        lastSeen: Date.now(),
+                        reused: true,
+                    };
+                }
+            }
+            catch (e) {
+                // Invalid data
+            }
+            return null;
+        }
+        async getOrCreateVisitorIdentity(params) {
+            const { stableCoreHash } = params;
+            // Try to recover existing identity from camouflaged storage
+            const { value: storedData, method } = PersistenceManager.get(STORAGE_KEYS.prefs);
+            if (storedData) {
+                const existingIdentity = this.extractFromCamouflage(storedData);
+                if (existingIdentity && existingIdentity.stableCoreHash === stableCoreHash) {
+                    // Update last seen time
+                    const updatedCamouflage = this.createCamouflageData(existingIdentity.visitorId, existingIdentity.sessionId, stableCoreHash);
+                    PersistenceManager.set(STORAGE_KEYS.prefs, JSON.stringify(updatedCamouflage));
+                    return {
+                        ...existingIdentity,
+                        persistenceMethod: method,
+                        lastSeen: Date.now(),
+                        reused: true,
+                    };
+                }
+            }
+            // Create new visitor identity
+            const newVisitorId = this.generateVisitorId();
+            const newSessionId = params.sessionId || this.generateSessionId();
+            const newIdentity = {
+                visitorId: newVisitorId,
+                sessionId: newSessionId,
+                stableCoreHash,
+                deviceFingerprint: params.deviceFingerprint,
+                persistenceMethod: "localStorage",
+                confidence: 0.90,
+                createdAt: Date.now(),
+                lastSeen: Date.now(),
+                reused: false,
+            };
+            // Store in camouflaged format
+            const camouflageData = this.createCamouflageData(newVisitorId, newSessionId, stableCoreHash);
+            const { method: storageMethod } = PersistenceManager.set(STORAGE_KEYS.prefs, JSON.stringify(camouflageData));
+            newIdentity.persistenceMethod = storageMethod;
+            // Also store device fingerprint cache for faster lookups
+            PersistenceManager.set(STORAGE_KEYS.device, params.deviceFingerprint);
+            return newIdentity;
+        }
+        // Get current visitor ID without creating new one
+        getCurrentVisitorId() {
+            const { value: storedData } = PersistenceManager.get(STORAGE_KEYS.prefs);
+            if (storedData) {
+                const identity = this.extractFromCamouflage(storedData);
+                return identity?.visitorId || null;
+            }
+            return null;
+        }
+        // Clear all stored identity data
+        clearIdentity() {
+            // Remove from all storage layers
+            try {
+                PersistenceManager.setLocal(STORAGE_KEYS.prefs, "");
+                PersistenceManager.setLocal(STORAGE_KEYS.device, "");
+                PersistenceManager.setSession(STORAGE_KEYS.prefs, "");
+                PersistenceManager.setSession(STORAGE_KEYS.device, "");
+                PersistenceManager.setCookie(STORAGE_KEYS.prefs, "", -1); // Expire immediately
+                PersistenceManager.setCookie(STORAGE_KEYS.device, "", -1);
+                PersistenceManager.setMemory(STORAGE_KEYS.prefs, "");
+                PersistenceManager.setMemory(STORAGE_KEYS.device, "");
+            }
+            catch (e) {
+                // Silent fail
+            }
+        }
     }
 
     /**
@@ -19184,7 +19911,7 @@
      */
     class ZaplierSDK {
         constructor(userConfig) {
-            this.version = "1.3.7";
+            this.version = "1.6.0";
             this.isInitialized = false;
             this.eventQueue = [];
             /**
@@ -19255,8 +19982,10 @@
                         }
                         const sessionId = this.sessionId;
                         // When explicitly enabled, use 100% sample rate
-                        this.replayEngine = new SessionReplayEngine(sessionId, {
+                        this.replayEngine = new SessionReplayEngine(sessionId, this.backendVisitorId || 'unknown', {
                             sampleRate: 1.0, // Force 100% when explicitly enabled
+                            inactivityTimeout: 30000,
+                            pauseOnInactive: true,
                         });
                         // Connect to anti-adblock manager
                         if (this.antiAdblockManager) {
@@ -19281,8 +20010,10 @@
                                 this.sessionId = this.generateSessionId();
                             }
                             const sessionId = this.sessionId;
-                            this.replayEngine = new SessionReplayEngine(sessionId, {
+                            this.replayEngine = new SessionReplayEngine(sessionId, this.backendVisitorId || 'unknown', {
                                 sampleRate: 1.0, // Force 100% when explicitly enabled
+                                inactivityTimeout: 30000,
+                                pauseOnInactive: true,
                             });
                             // Connect to anti-adblock manager
                             if (this.antiAdblockManager) {
@@ -19321,8 +20052,10 @@
                             this.sessionId = this.generateSessionId();
                         }
                         const sessionId = this.sessionId;
-                        this.replayEngine = new SessionReplayEngine(sessionId, {
+                        this.replayEngine = new SessionReplayEngine(sessionId, this.backendVisitorId || 'unknown', {
                             sampleRate: 1.0, // Force recording when manually started
+                            inactivityTimeout: 30000,
+                            pauseOnInactive: true,
                         });
                         // Connect to anti-adblock manager
                         if (this.antiAdblockManager) {
@@ -19354,6 +20087,45 @@
                     this.trackConversion("funnel_conversion", data.value, data.currency, data);
                 },
             };
+            /**
+             * Auto Tracker API
+             */
+            this.autoTrack = {
+                enable: () => {
+                    if (!this.autoTracker) {
+                        this.initializeAutoTracker();
+                    }
+                    else {
+                        this.autoTracker.configure({ enabled: true });
+                    }
+                    if (this.config.debug) {
+                        console.log("[Zaplier] Auto tracking enabled");
+                    }
+                },
+                disable: () => {
+                    if (this.autoTracker) {
+                        this.autoTracker.stop();
+                        this.autoTracker = undefined;
+                    }
+                    if (this.config.debug) {
+                        console.log("[Zaplier] Auto tracking disabled");
+                    }
+                },
+                configure: (config) => {
+                    if (this.autoTracker) {
+                        this.autoTracker.configure(config);
+                    }
+                    if (this.config.debug) {
+                        console.log("[Zaplier] Auto tracking configured:", config);
+                    }
+                },
+                getStats: () => {
+                    return this.autoTracker ? this.autoTracker.getStats() : null;
+                },
+                isEnabled: () => {
+                    return !!this.autoTracker;
+                },
+            };
             // Validate required config
             if (!userConfig.token) {
                 throw new Error("Zaplier: token is required");
@@ -19395,6 +20167,8 @@
                 this.initializeAntiAdblock();
                 // Then initialize tracking engines (they'll connect to anti-adblock)
                 this.initializeTrackingEngines();
+                // Initialize auto tracker
+                this.initializeAutoTracker();
                 // Process queued events
                 this.processEventQueue();
                 if (this.config.debug) {
@@ -19425,8 +20199,10 @@
                     // When replay is explicitly enabled, use 100% sample rate to ensure recording
                     // The default replaySampling (0.1) is only for automatic/production sampling
                     const sampleRate = this.config.replay === true ? 1.0 : this.config.replaySampling;
-                    this.replayEngine = new SessionReplayEngine(this.sessionId, {
+                    this.replayEngine = new SessionReplayEngine(this.sessionId, this.backendVisitorId || 'unknown', {
                         sampleRate: sampleRate,
+                        inactivityTimeout: 30000,
+                        pauseOnInactive: true,
                     });
                     // Connect SDK instance for transport
                     this.replayEngine.setSDKInstance(this);
@@ -19461,6 +20237,29 @@
                 console.error("[Zaplier] Failed to initialize tracking engines:", error);
             }
         }
+        /**
+         * Initialize Auto Tracker for data-* attributes
+         */
+        initializeAutoTracker() {
+            try {
+                this.autoTracker = new AutoTracker(this, {
+                    enabled: true,
+                    trackClicks: true,
+                    trackScrolls: true,
+                    trackViews: true,
+                    trackHovers: true,
+                    trackForms: true,
+                    debug: this.config.debug,
+                });
+                this.autoTracker.start();
+                if (this.config.debug) {
+                    console.log("[Zaplier] Auto Tracker initialized and started");
+                }
+            }
+            catch (error) {
+                console.error("[Zaplier] Failed to initialize Auto Tracker:", error);
+            }
+        }
         /**
          * Generate session ID
          */
@@ -19516,10 +20315,12 @@
         }
         /**
          * Collect fingerprint and generate visitor ID (IMPROVED - 2024)
-         * Enhanced with better incognito detection
+         * Enhanced with better incognito detection and localStorage persistence
          */
         async collectFingerprint() {
             try {
+                // Initialize visitor identity manager
+                this.visitorIdentityManager = new VisitorIdentityManager();
                 // Use appropriate fingerprinting based on GDPR mode
                 const result = this.config.gdprMode
                     ? await getLightweightFingerprint()
@@ -19537,6 +20338,26 @@
                             sdkVersion: this.version,
                         };
                     }
+                    // Generate or retrieve visitor identity using persistent storage
+                    const visitorIdentity = await this.visitorIdentityManager.getOrCreateVisitorIdentity({
+                        fingerprintHash: result.data.hash,
+                        stableCoreHash: result.data.stableCoreHash,
+                        deviceFingerprint: result.data.hash,
+                        sessionId: this.sessionId,
+                        userAgent: navigator.userAgent,
+                        ipAddress: undefined, // Will be determined server-side
+                    });
+                    // Set the persistent visitor ID
+                    this.visitorId = visitorIdentity.visitorId;
+                    if (this.config.debug) {
+                        console.log("[Zaplier] Visitor identity resolved:", {
+                            visitorId: this.visitorId,
+                            sessionId: this.sessionId,
+                            persistenceMethod: visitorIdentity.persistenceMethod,
+                            confidence: visitorIdentity.confidence,
+                            isNewVisitor: !visitorIdentity.reused,
+                        });
+                    }
                     if (this.config.debug) {
                         console.log("[Zaplier] Fingerprint collected:", {
                             components: result.collectedComponents,
@@ -19643,6 +20464,10 @@
             try {
                 const payload = {
                     // workspaceId moved to query parameter
+                    // Visitor ID (persistido via localStorage camuflado)
+                    visitorId: this.visitorId,
+                    // Session ID (gerado por sessão)
+                    sessionId: this.sessionId,
                     fingerprintHash: this.fingerprint?.hash,
                     stableCoreHash: this.fingerprint?.stableCoreHash,
                     stableCoreVector: this.fingerprint?.stableCoreVector,
@@ -20403,6 +21228,44 @@
                 globalInstance.replay.markConversion(data);
             }
         },
+        /**
+         * Auto Tracker API
+         */
+        autoTrack: {
+            enable: () => {
+                if (!globalInstance) {
+                    console.warn('[Zaplier] SDK not initialized. Call Zaplier.init() first');
+                    return;
+                }
+                globalInstance.autoTrack.enable();
+            },
+            disable: () => {
+                if (!globalInstance) {
+                    console.warn('[Zaplier] SDK not initialized. Call Zaplier.init() first');
+                    return;
+                }
+                globalInstance.autoTrack.disable();
+            },
+            configure: (config) => {
+                if (!globalInstance) {
+                    console.warn('[Zaplier] SDK not initialized. Call Zaplier.init() first');
+                    return;
+                }
+                globalInstance.autoTrack.configure(config);
+            },
+            getStats: () => {
+                if (!globalInstance) {
+                    return null;
+                }
+                return globalInstance.autoTrack.getStats();
+            },
+            isEnabled: () => {
+                if (!globalInstance) {
+                    return false;
+                }
+                return globalInstance.autoTrack.isEnabled();
+            }
+        },
         /**
          * Debug and utility functions
          */
@@ -20429,7 +21292,7 @@
         /**
          * Version info
          */
-        version: '3.0.0'
+        version: '1.6.0'
     };
     /**
      * Auto-initialization from script tag data attributes