cdp-edge 1.2.0

package/extracted-skill/tracking-events-generator/micro-events.js

@@ -0,0 +1,992 @@
+/**
+ * MICRO-EVENTS - CDP Edge (Quantum Tier)
+ *
+ * Módulo de captura de micro-eventos de engajamento para tracking premium.
+ * Implementa: Scroll, Time on Page, Video, Click Heatmap, Rapid Clicks, CTA Hover
+ *
+ * @version 1.0.0
+ */
+
+// ── Guards — segurança em SSR e SDK não carregado ──
+const isBrowser = typeof window !== 'undefined';
+const has = (fn) => isBrowser && typeof window[fn] === 'function';
+
+// ── Configuração de Scroll ─────────────────────────────────────────────
+const SCROLL_CONFIG = {
+  thresholds: [25, 50, 75, 100],
+  signalStrength: {
+    '25%': 1.5,
+    '50%': 2.0,
+    '75%': 3.0,
+    '100%': 4.0
+  }
+};
+
+// ── Configuração de Time on Page ───────────────────────────────────────────
+const TIME_CONFIG = {
+  thresholds: {
+    curioso: 10000,      // 10 segundos
+    interessado: 60000,  // 60 segundos
+    comprador: 180000    // 180 segundos (3 minutos)
+    profundao: 60
+  },
+  signalStrength: {
+    curioso: 1.0,
+    interessado: 2.5,
+    comprador: 4.0,
+    profundao: 3.5
+  },
+  intentionLevels: {
+    curioso: 'curioso',
+    interessado: 'interessado',
+    comprador: 'comprador',
+    profundao: 'profundo'
+  }
+};
+
+// ── Configuração de Vídeo ─────────────────────────────────────────────────────
+const VIDEO_CONFIG = {
+  progressThresholds: [25, 50, 75, 100],
+  // Dropout: captura o segundo exato em que o usuário parou de assistir
+  dropoutEnabled: true,
+  signalStrength: {
+    play: 2.0,
+    progress25: 3.0,
+    progress50: 4.0,
+    progress75: 5.0,
+    complete: 5.0,
+    pause: 1.0,
+    resume: 1.5,
+    seek: 0.5,
+    dropout: 2.5  // pausa final — não retomou até sair da página
+  }
+};
+
+// ── Configuração de Click Heatmap ───────────────────────────────────────────────
+const CLICK_CONFIG = {
+  maxRapidClicks: 3,
+  rapidClickWindow: 1000, // 1 segundo
+  clickCategories: ['button', 'link', 'input', 'cta', 'price', 'generic'],
+  signalStrength: {
+    button: 2.0,
+    link: 1.5,
+    cta: 2.5,
+    input: 1.0,
+    price: 2.0,
+    generic: 0.5
+  }
+};
+
+// ── Configuração de CTA Hover ───────────────────────────────────────────────────
+const CTA_HOVER_CONFIG = {
+  minHoverTimeForSignal: 3000, // 3 segundos
+  maxHoverTime: 30000, // 30 segundos (para evitar overflow)
+  signalStrength: 3.0
+};
+
+// ── Estado Global ──────────────────────────────────────────────────────────────
+const state = {
+  pageLoadTime: Date.now(),
+  scrollTracking: {
+    lastScrollPercent: 0,
+    trackedThresholds: new Set()
+  },
+  timeTracking: {
+    lastCheckTime: Date.now(),
+    currentLevel: 'curioso',
+    timeOnPage: 0
+  },
+  // videoTracking: { [videoId]: { playTime, totalWatchTime, lastProgress, started, paused, dropoutPercent, dropoutSecond } }
+  videoTracking: {},
+  // Resumo agregado de todos os vídeos na página (para páginas VSL com múltiplos vídeos)
+  videoSummary: {
+    totalVideos: 0,
+    startedCount: 0,
+    completedCount: 0,
+    maxProgress: 0, // maior % atingida entre todos os vídeos
+  },
+  clickTracking: {
+    clicks: [],
+    lastClickTime: 0,
+    rapidClickDetected: false
+  },
+  ctaHoverTracking: {
+    hoverStartTime: null,
+    hoveredElement: null
+  }
+};
+
+// ── Scroll Tracking ──────────────────────────────────────────────────────────────
+
+/**
+ * Inicializa tracking de scroll
+ */
+function initScrollTracking() {
+  if (!isBrowser) return;
+
+  const observer = new IntersectionObserver((entries) => {
+    entries.forEach(entry => {
+      if (!entry.isIntersecting) return;
+
+      const scrollPercent = Math.round(
+        (window.scrollY + window.innerHeight) / document.body.scrollHeight * 100
+      );
+
+      // Track cada threshold apenas uma vez
+      SCROLL_CONFIG.thresholds.forEach(threshold => {
+        const key = `scroll_${threshold}`;
+        if (scrollPercent >= threshold && !state.scrollTracking.trackedThresholds.has(key)) {
+          const signal = SCROLL_CONFIG.signalStrength[`${threshold}%`] || 0;
+
+          dispatchEvent('Scroll', {
+            scroll_depth: threshold,
+            scroll_percent: scrollPercent,
+            signal_strength: signal,
+            engagement_type: 'scroll',
+            time_on_page: Math.round((Date.now() - state.pageLoadTime) / 1000)
+          });
+
+          state.scrollTracking.trackedThresholds.add(key);
+        }
+      });
+    });
+  }, { threshold: SCROLL_CONFIG.thresholds.map(t => t / 100) });
+
+  observer.observe(document.body);
+}
+
+/**
+ * Track evento de scroll
+ */
+function trackScroll(threshold, additionalData = {}) {
+  if (!isBrowser) return;
+
+  const scrollPercent = Math.round(
+    (window.scrollY + window.innerHeight) / document.body.scrollHeight * 100
+  );
+
+  const signal = SCROLL_CONFIG.signalStrength[`${threshold}%`] || 0;
+
+  dispatchEvent('Scroll', {
+    scroll_depth: threshold,
+    scroll_percent: scrollPercent,
+    signal_strength: signal,
+    engagement_type: 'scroll',
+    time_on_page: Math.round((Date.now() - state.pageLoadTime) / 1000),
+    ...additionalData
+  });
+}
+
+// ── Time on Page Tracking ───────────────────────────────────────────────────────
+
+/**
+ * Inicializa tracking de tempo na página
+ */
+function initTimeOnPageTracking() {
+  if (!isBrowser) return;
+
+  // Check a cada 5 segundos
+  setInterval(() => {
+    const elapsed = Date.now() - state.pageLoadTime;
+    const timeOnPage = Math.round(elapsed / 1000);
+
+    // Verificar thresholds de intenção
+    let currentLevel = state.timeTracking.currentLevel;
+    let signal = state.timeTracking.currentLevel;
+
+    if (timeOnPage >= TIME_CONFIG.thresholds.comprador) {
+      currentLevel = 'comprador';
+      signal = TIME_CONFIG.signalStrength.comprador;
+    } else if (timeOnPage >= TIME_CONFIG.thresholds.interessado) {
+      currentLevel = 'interessado';
+      signal = TIME_CONFIG.signalStrength.interessado;
+    } else if (timeOnPage >= TIME_CONFIG.thresholds.curioso) {
+      currentLevel = 'curioso';
+      signal = TIME_CONFIG.signalStrength.curioso;
+    }
+
+    // Se mudou de nível, disparar evento
+    if (currentLevel !== state.timeTracking.currentLevel) {
+      state.timeTracking.currentLevel = currentLevel;
+
+      dispatchEvent('TimeOnPage', {
+        time_on_page: timeOnPage,
+        intention_level: currentLevel,
+        signal_strength: signal,
+        engagement_type: 'time',
+        previous_level: state.timeTracking.previousLevel
+      });
+
+      state.timeTracking.previousLevel = currentLevel;
+    }
+  }, 5000);
+}
+
+/**
+ * Track evento de tempo na página
+ */
+function trackTimeOnPage(additionalData = {}) {
+  if (!isBrowser) return;
+
+  const elapsed = Date.now() - state.pageLoadTime;
+  const timeOnPage = Math.round(elapsed / 1000);
+
+  // Determinar nível de intenção
+  let intentionLevel;
+  let signal;
+
+  if (timeOnPage >= TIME_CONFIG.thresholds.comprador) {
+    intentionLevel = 'comprador';
+    signal = TIME_CONFIG.signalStrength.comprador;
+  } else if (timeOnPage >= TIME_CONFIG.thresholds.interessado) {
+    intentionLevel = 'interessado';
+    signal = TIME_CONFIG.signalStrength.interessado;
+  } else if (timeOnPage >= TIME_CONFIG.thresholds.curioso) {
+    intentionLevel = 'curioso';
+    signal = TIME_CONFIG.signalStrength.curioso;
+  } else {
+    intentionLevel = 'curioso';
+    signal = TIME_CONFIG.signalStrength.curioso;
+  }
+
+  dispatchEvent('TimeOnPage', {
+    time_on_page: timeOnPage,
+    intention_level: intentionLevel,
+    signal_strength: signal,
+    engagement_type: 'time',
+    ...additionalData
+  });
+}
+
+// ── Video Tracking ───────────────────────────────────────────────────────────────
+
+/**
+ * Cria o estado inicial de um vídeo
+ */
+function _createVideoState() {
+  return {
+    playTime: 0,
+    totalWatchTime: 0,
+    lastProgress: -1,      // -1 = nenhum threshold disparado ainda (fix do bug original)
+    lastSecond: 0,          // segundo exato do último timeupdate (para dropout heatmap)
+    started: false,
+    paused: false,
+    completed: false,
+    dropoutPercent: null,   // % onde parou definitivamente
+    dropoutSecond: null,    // segundo onde parou definitivamente
+  };
+}
+
+/**
+ * Atualiza o resumo agregado de vídeos (VSL com múltiplos vídeos)
+ */
+function _updateVideoSummary(videoId) {
+  const s = state.videoTracking[videoId];
+  const sum = state.videoSummary;
+
+  sum.totalVideos = Object.keys(state.videoTracking).length;
+  sum.startedCount = Object.values(state.videoTracking).filter(v => v.started).length;
+  sum.completedCount = Object.values(state.videoTracking).filter(v => v.completed).length;
+  sum.maxProgress = Math.max(...Object.values(state.videoTracking).map(v => v.lastProgress < 0 ? 0 : v.lastProgress));
+}
+
+/**
+ * Registra dropout: momento exato em que o usuário parou de assistir
+ * Chamado no pause e no unload da página
+ */
+function _recordDropout(videoId, percent, second) {
+  const v = state.videoTracking[videoId];
+  if (!v || v.completed) return; // não registra dropout para vídeos completos
+
+  v.dropoutPercent = percent;
+  v.dropoutSecond = second;
+
+  if (VIDEO_CONFIG.dropoutEnabled) {
+    dispatchEvent('VideoDropout', {
+      video_id: videoId,
+      dropout_percent: percent,
+      dropout_second: second,
+      engagement_score: VIDEO_CONFIG.signalStrength.dropout,
+      engagement_type: 'video',
+      video_summary: { ...state.videoSummary }
+    });
+  }
+}
+
+/**
+ * Inicializa tracking de vídeo
+ */
+function initVideoTracking() {
+  if (!isBrowser) return;
+
+  // Detectar vídeos na página
+  const videos = document.querySelectorAll('video, iframe[src*="youtube"], iframe[src*="vimeo"]');
+
+  videos.forEach((video, index) => {
+    const videoId = video.id || video.getAttribute('data-video-id') || `video_${index}`;
+
+    state.videoTracking[videoId] = _createVideoState();
+    _updateVideoSummary(videoId);
+
+    // YouTube tracking (iframe)
+    if (video.tagName === 'IFRAME' && video.src.includes('youtube')) {
+      initYouTubeTracking(video, videoId);
+      return;
+    }
+
+    // Vimeo tracking (iframe)
+    if (video.tagName === 'IFRAME' && video.src.includes('vimeo')) {
+      initVimeoTracking(video, videoId);
+      return;
+    }
+
+    // Video nativo HTML5
+    _attachHtml5Tracking(video, videoId);
+  });
+
+  // Dropout no unload: registra onde cada vídeo estava quando o usuário saiu da página
+  window.addEventListener('beforeunload', () => {
+    Object.entries(state.videoTracking).forEach(([videoId, v]) => {
+      if (v.started && !v.completed) {
+        _recordDropout(videoId, v.lastProgress < 0 ? 0 : v.lastProgress, v.lastSecond);
+      }
+    });
+  });
+}
+
+/**
+ * Tracking HTML5 nativo
+ */
+function _attachHtml5Tracking(video, videoId) {
+  const v = () => state.videoTracking[videoId];
+
+  video.addEventListener('play', () => {
+    v().started = true;
+    v().paused = false;
+    if (!v().playTime) v().playTime = Date.now();
+    _updateVideoSummary(videoId);
+
+    dispatchEvent('VideoPlay', {
+      video_id: videoId,
+      video_platform: 'html5',
+      progress_percent: calculateVideoProgress(video),
+      engagement_score: VIDEO_CONFIG.signalStrength.play,
+      engagement_type: 'video'
+    });
+  });
+
+  video.addEventListener('pause', () => {
+    v().paused = true;
+    const progress = calculateVideoProgress(video);
+    const second = Math.round(video.currentTime);
+
+    dispatchEvent('VideoPause', {
+      video_id: videoId,
+      video_platform: 'html5',
+      progress_percent: progress,
+      pause_second: second,
+      engagement_score: VIDEO_CONFIG.signalStrength.pause,
+      engagement_type: 'video'
+    });
+
+    // Registra como dropout provisório — se o usuário retomar, será sobrescrito pelo próximo play
+    _recordDropout(videoId, progress, second);
+  });
+
+  video.addEventListener('play', () => {
+    // Retomou — cancela o dropout provisório registrado no pause anterior
+    v().dropoutPercent = null;
+    v().dropoutSecond = null;
+  });
+
+  video.addEventListener('seeked', () => {
+    dispatchEvent('VideoSeek', {
+      video_id: videoId,
+      video_platform: 'html5',
+      progress_percent: calculateVideoProgress(video),
+      seek_to_second: Math.round(video.currentTime),
+      engagement_score: VIDEO_CONFIG.signalStrength.seek,
+      engagement_type: 'video'
+    });
+  });
+
+  // Monitorar progresso — BUG CORRIGIDO: lastProgress verificado antes de ser sobrescrito
+  video.addEventListener('timeupdate', () => {
+    if (video.paused || video.ended) return;
+
+    const progress = calculateVideoProgress(video);
+    const second = Math.round(video.currentTime);
+    v().lastSecond = second;
+
+    VIDEO_CONFIG.progressThresholds.forEach(threshold => {
+      // Verificação correta: comparar ANTES de sobrescrever lastProgress
+      if (progress >= threshold && v().lastProgress < threshold) {
+        v().lastProgress = threshold; // atualiza DEPOIS da comparação
+
+        dispatchEvent('VideoProgress', {
+          video_id: videoId,
+          video_platform: 'html5',
+          progress_percent: threshold,
+          progress_second: second,
+          engagement_score: VIDEO_CONFIG.signalStrength[`progress${threshold}`] || 0,
+          engagement_type: 'video',
+          video_summary: { ...state.videoSummary }
+        });
+
+        _updateVideoSummary(videoId);
+      }
+    });
+  });
+
+  video.addEventListener('ended', () => {
+    v().paused = false;
+    v().completed = true;
+    v().dropoutPercent = null;
+    v().dropoutSecond = null;
+    const totalTime = v().playTime ? Math.round((Date.now() - v().playTime) / 1000) : 0;
+    _updateVideoSummary(videoId);
+
+    dispatchEvent('VideoComplete', {
+      video_id: videoId,
+      video_platform: 'html5',
+      progress_percent: 100,
+      total_watch_time: totalTime,
+      engagement_score: VIDEO_CONFIG.signalStrength.complete,
+      engagement_type: 'video',
+      video_summary: { ...state.videoSummary }
+    });
+  });
+}
+
+/**
+ * Calcular progresso do vídeo (%)
+ */
+function calculateVideoProgress(video) {
+  if (!video.duration || video.duration === 0) return 0;
+  return Math.round((video.currentTime / video.duration) * 100);
+}
+
+/**
+ * YouTube IFrame API — tracking real via postMessage
+ * Suporta: play, pause, progress (25/50/75/100), complete, dropout
+ */
+function initYouTubeTracking(iframe, videoId) {
+  // Garante que o iframe tenha enablejsapi=1 na URL
+  try {
+    const url = new URL(iframe.src);
+    if (!url.searchParams.get('enablejsapi')) {
+      url.searchParams.set('enablejsapi', '1');
+      iframe.src = url.toString();
+    }
+  } catch { /* URL inválida */ }
+
+  // Carrega a YouTube IFrame API uma vez
+  if (!window._ytApiLoading) {
+    window._ytApiLoading = true;
+    const tag = document.createElement('script');
+    tag.src = 'https://www.youtube.com/iframe_api';
+    document.head.appendChild(tag);
+  }
+
+  // Aguarda a API estar pronta e inicializa o player
+  const initPlayer = () => {
+    if (typeof YT === 'undefined' || !YT.Player) {
+      setTimeout(initPlayer, 300);
+      return;
+    }
+
+    const v = () => state.videoTracking[videoId];
+    let progressInterval = null;
+
+    new YT.Player(iframe, {
+      events: {
+        onStateChange: (event) => {
+          const YTState = YT.PlayerState;
+          const player = event.target;
+          const duration = player.getDuration() || 0;
+          const currentTime = player.getCurrentTime() || 0;
+          const progress = duration > 0 ? Math.round((currentTime / duration) * 100) : 0;
+          const second = Math.round(currentTime);
+
+          if (event.data === YTState.PLAYING) {
+            v().started = true;
+            v().paused = false;
+            if (!v().playTime) v().playTime = Date.now();
+            v().dropoutPercent = null;
+            v().dropoutSecond = null;
+            _updateVideoSummary(videoId);
+
+            dispatchEvent('VideoPlay', {
+              video_id: videoId,
+              video_platform: 'youtube',
+              progress_percent: progress,
+              engagement_score: VIDEO_CONFIG.signalStrength.play,
+              engagement_type: 'video'
+            });
+
+            // Polling de progresso a cada 2s (YT não tem timeupdate)
+            clearInterval(progressInterval);
+            progressInterval = setInterval(() => {
+              if (!player || typeof player.getPlayerState !== 'function') return;
+              if (player.getPlayerState() !== YTState.PLAYING) return;
+
+              const ct = player.getCurrentTime() || 0;
+              const dur = player.getDuration() || 0;
+              const pct = dur > 0 ? Math.round((ct / dur) * 100) : 0;
+              v().lastSecond = Math.round(ct);
+
+              VIDEO_CONFIG.progressThresholds.forEach(threshold => {
+                if (pct >= threshold && v().lastProgress < threshold) {
+                  v().lastProgress = threshold;
+
+                  dispatchEvent('VideoProgress', {
+                    video_id: videoId,
+                    video_platform: 'youtube',
+                    progress_percent: threshold,
+                    progress_second: Math.round(ct),
+                    engagement_score: VIDEO_CONFIG.signalStrength[`progress${threshold}`] || 0,
+                    engagement_type: 'video',
+                    video_summary: { ...state.videoSummary }
+                  });
+
+                  _updateVideoSummary(videoId);
+                }
+              });
+            }, 2000);
+
+          } else if (event.data === YTState.PAUSED) {
+            clearInterval(progressInterval);
+            v().paused = true;
+
+            dispatchEvent('VideoPause', {
+              video_id: videoId,
+              video_platform: 'youtube',
+              progress_percent: progress,
+              pause_second: second,
+              engagement_score: VIDEO_CONFIG.signalStrength.pause,
+              engagement_type: 'video'
+            });
+
+            _recordDropout(videoId, progress, second);
+
+          } else if (event.data === YTState.ENDED) {
+            clearInterval(progressInterval);
+            v().completed = true;
+            v().dropoutPercent = null;
+            v().dropoutSecond = null;
+            const totalTime = v().playTime ? Math.round((Date.now() - v().playTime) / 1000) : 0;
+            _updateVideoSummary(videoId);
+
+            dispatchEvent('VideoComplete', {
+              video_id: videoId,
+              video_platform: 'youtube',
+              progress_percent: 100,
+              total_watch_time: totalTime,
+              engagement_score: VIDEO_CONFIG.signalStrength.complete,
+              engagement_type: 'video',
+              video_summary: { ...state.videoSummary }
+            });
+          }
+        }
+      }
+    });
+  };
+
+  // YT.onYouTubeIframeAPIReady pode já ter disparado
+  if (typeof YT !== 'undefined' && YT.Player) {
+    initPlayer();
+  } else {
+    const prev = window.onYouTubeIframeAPIReady;
+    window.onYouTubeIframeAPIReady = () => {
+      if (prev) prev();
+      initPlayer();
+    };
+  }
+}
+
+/**
+ * Vimeo Player API — tracking via postMessage
+ * Suporta: play, pause, progress (25/50/75/100), complete, dropout
+ */
+function initVimeoTracking(iframe, videoId) {
+  const v = () => state.videoTracking[videoId];
+  let duration = 0;
+
+  const send = (method, value) => {
+    iframe.contentWindow.postMessage(JSON.stringify({ method, value }), 'https://player.vimeo.com');
+  };
+
+  // Habilita listeners via postMessage
+  const enableListeners = () => {
+    ['play', 'pause', 'ended', 'timeupdate', 'seeked'].forEach(evt => {
+      send('addEventListener', evt);
+    });
+    // Obtém duração
+    send('getDuration');
+  };
+
+  window.addEventListener('message', (event) => {
+    if (!event.origin.includes('vimeo.com')) return;
+    let data;
+    try { data = JSON.parse(event.data); } catch { return; }
+    if (!data || data.player_id !== iframe.id) return;
+
+    if (data.event === 'ready') {
+      enableListeners();
+      return;
+    }
+
+    if (data.method === 'getDuration') {
+      duration = data.value || 0;
+      return;
+    }
+
+    const currentTime = data.data?.seconds || 0;
+    const progress = duration > 0 ? Math.round((currentTime / duration) * 100) : 0;
+    const second = Math.round(currentTime);
+
+    if (data.event === 'play') {
+      v().started = true;
+      v().paused = false;
+      if (!v().playTime) v().playTime = Date.now();
+      v().dropoutPercent = null;
+      v().dropoutSecond = null;
+      _updateVideoSummary(videoId);
+
+      dispatchEvent('VideoPlay', {
+        video_id: videoId,
+        video_platform: 'vimeo',
+        progress_percent: progress,
+        engagement_score: VIDEO_CONFIG.signalStrength.play,
+        engagement_type: 'video'
+      });
+
+    } else if (data.event === 'pause') {
+      v().paused = true;
+      v().lastSecond = second;
+
+      dispatchEvent('VideoPause', {
+        video_id: videoId,
+        video_platform: 'vimeo',
+        progress_percent: progress,
+        pause_second: second,
+        engagement_score: VIDEO_CONFIG.signalStrength.pause,
+        engagement_type: 'video'
+      });
+
+      _recordDropout(videoId, progress, second);
+
+    } else if (data.event === 'timeupdate') {
+      v().lastSecond = second;
+
+      VIDEO_CONFIG.progressThresholds.forEach(threshold => {
+        if (progress >= threshold && v().lastProgress < threshold) {
+          v().lastProgress = threshold;
+
+          dispatchEvent('VideoProgress', {
+            video_id: videoId,
+            video_platform: 'vimeo',
+            progress_percent: threshold,
+            progress_second: second,
+            engagement_score: VIDEO_CONFIG.signalStrength[`progress${threshold}`] || 0,
+            engagement_type: 'video',
+            video_summary: { ...state.videoSummary }
+          });
+
+          _updateVideoSummary(videoId);
+        }
+      });
+
+    } else if (data.event === 'ended') {
+      v().completed = true;
+      v().dropoutPercent = null;
+      v().dropoutSecond = null;
+      const totalTime = v().playTime ? Math.round((Date.now() - v().playTime) / 1000) : 0;
+      _updateVideoSummary(videoId);
+
+      dispatchEvent('VideoComplete', {
+        video_id: videoId,
+        video_platform: 'vimeo',
+        progress_percent: 100,
+        total_watch_time: totalTime,
+        engagement_score: VIDEO_CONFIG.signalStrength.complete,
+        engagement_type: 'video',
+        video_summary: { ...state.videoSummary }
+      });
+
+    } else if (data.event === 'seeked') {
+      dispatchEvent('VideoSeek', {
+        video_id: videoId,
+        video_platform: 'vimeo',
+        progress_percent: progress,
+        seek_to_second: second,
+        engagement_score: VIDEO_CONFIG.signalStrength.seek,
+        engagement_type: 'video'
+      });
+    }
+  });
+
+  // Inicializa o player Vimeo — postMessage após load
+  if (iframe.contentDocument) {
+    enableListeners();
+  } else {
+    iframe.addEventListener('load', enableListeners);
+  }
+}
+
+/**
+ * Track evento de vídeo manual (chamada externa)
+ */
+function trackVideo(event, additionalData = {}) {
+  if (!isBrowser) return;
+
+  dispatchEvent(event, {
+    ...additionalData,
+    engagement_type: 'video'
+  });
+}
+
+/**
+ * Retorna o resumo agregado de todos os vídeos na página
+ * Útil para páginas VSL com múltiplos vídeos
+ */
+function getVideoSummary() {
+  return { ...state.videoSummary };
+}
+
+// ── Click Heatmap Tracking ─────────────────────────────────────────────────────
+
+/**
+ * Inicializa tracking de clique
+ */
+function initClickHeatmapTracking() {
+  if (!isBrowser) return;
+
+  document.addEventListener('click', (e) => {
+    const target = e.target;
+    const clickCategory = categorizeClick(target);
+    const position = calculateClickPosition(e);
+    const timeOnPage = Math.round((Date.now() - state.pageLoadTime) / 1000);
+
+    // Track rapid clicks
+    const now = Date.now();
+    const timeSinceLastClick = now - state.clickTracking.lastClickTime;
+
+    if (timeSinceLastClick < CLICK_CONFIG.rapidClickWindow) {
+      state.clickTracking.clicks.push({
+        time: now,
+        target: target
+      });
+    }
+
+    // Reset rapid clicks após window
+    setTimeout(() => {
+      const recentClicks = state.clickTracking.clicks.filter(
+        c => now - c.time < CLICK_CONFIG.rapidClickWindow
+      );
+
+      if (recentClicks.length >= CLICK_CONFIG.maxRapidClicks) {
+        state.clickTracking.rapidClickDetected = true;
+
+        dispatchEvent('RapidClicks', {
+          click_count: recentClicks.length,
+          time_window: CLICK_CONFIG.rapidClickWindow,
+          behavior: 'nervous',
+          engagement_score: 3.0,
+          engagement_type: 'clicks',
+          time_on_page: timeOnPage,
+          description: `Usuário clicou ${recentClicks.length} vezes em ${CLICK_CONFIG.rapidClickWindow / 1000} segundos`
+        });
+      } else {
+        state.clickTracking.rapidClickDetected = false;
+        state.clickTracking.clicks = [];
+      }
+    }, CLICK_CONFIG.rapidClickWindow);
+
+    state.clickTracking.lastClickTime = now;
+
+    dispatchEvent('Click', {
+      click_category: clickCategory,
+      target_info: extractTargetInfo(target),
+      position: position,
+      time_on_page: timeOnPage,
+      click_heatmap: true,
+      engagement_score: calculateClickEngagementScore(clickCategory, position),
+      engagement_type: 'clicks'
+    });
+  }, true); // Capture para elementos dinâmicos
+}
+
+/**
+ * Categorizar o clique
+ */
+function categorizeClick(target) {
+  const closest = (selector) => target.closest(selector);
+  const className = target.className || '';
+
+  if (closest('button') || className.includes('btn')) return 'button';
+  if (closest('a')) return 'link';
+  if (closest('input')) return 'input';
+  if (closest('.cta') || className.includes('cta')) return 'cta';
+  if (closest('.price') || className.includes('price')) return 'price';
+  if (closest('.whatsapp') || className.includes('whatsapp')) return 'whatsapp';
+  if (closest('.email') || className.includes('email')) return 'email';
+  if (closest('.phone') || className.includes('phone')) return 'phone';
+
+  return 'generic';
+}
+
+/**
+ * Calcular posição do clique
+ */
+function calculateClickPosition(e) {
+  return {
+    x: Math.round(e.clientX),
+    y: Math.round(e.clientY),
+    relativeX: Math.round(e.clientX / window.innerWidth * 100),
+    relativeY: Math.round(e.clientY / window.innerHeight * 100),
+    viewportWidth: window.innerWidth,
+    viewportHeight: window.innerHeight
+  };
+}
+
+/**
+ * Extrair informações do elemento alvo
+ */
+function extractTargetInfo(target) {
+  return {
+    tag: target.tagName,
+    class: target.className,
+    id: target.id,
+    text: target.textContent?.substring(0, 30) || '',
+    attributes: Array.from(target.attributes).map(a => `${a.name}="${a.value}"`).join(' ')
+  };
+}
+
+/**
+ * Calcular score de engajamento para clique
+ */
+function calculateClickEngagementScore(clickCategory, position) {
+  const baseScore = CLICK_CONFIG.signalStrength[clickCategory] || 0.5;
+  const timeScore = Math.min(position.timeOnPage / 60, 2.0); // Até 2 minutos aumenta score
+  const depthBonus = Math.min(position.scrollDepth / 100, 0.5); // Até 100% scroll aumenta score
+
+  return baseScore + timeScore + depthBonus;
+}
+
+// ── CTA Hover Tracking ─────────────────────────────────────────────────────────
+
+/**
+ * Inicializa tracking de hover no CTA
+ */
+function initCTAHoverTracking() {
+  if (!isBrowser) return;
+
+  const ctaSelectors = [
+    'a[href*="checkout"]',
+    'a[href*="comprar"]',
+    'button.cta',
+    '.btn-comprar',
+    '.btn-checkout',
+    '.cta-button',
+    '[data-cta="true"]',
+    'button[type="submit"]'
+  ];
+
+  ctaSelectors.forEach(selector => {
+    document.querySelectorAll(selector).forEach(element => {
+      element.addEventListener('mouseenter', (e) => {
+        const ctaElement = e.target.closest(selector);
+        if (!ctaElement) return;
+
+        state.ctaHoverTracking.hoverStartTime = Date.now();
+        state.ctaHoverTracking.hoveredElement = selector;
+      });
+
+      element.addEventListener('mouseleave', () => {
+        if (state.ctaHoverTracking.hoverStartTime) {
+          const hoverTime = Date.now() - state.ctaHoverTracking.hoverStartTime;
+
+          if (hoverTime >= CTA_HOVER_CONFIG.minHoverTimeForSignal) {
+            dispatchEvent('CTAHover', {
+              cta_selector: selector,
+              hover_time_seconds: Math.round(hoverTime / 1000),
+              engagement_score: CTA_HOVER_CONFIG.signalStrength,
+              engagement_type: 'hover',
+              time_on_page: Math.round((Date.now() - state.pageLoadTime) / 1000)
+            });
+          }
+        }
+
+        state.ctaHoverTracking.hoverStartTime = null;
+        state.ctaHoverTracking.hoveredElement = null;
+      });
+    });
+  });
+}
+
+/**
+ * Track evento de hover no CTA
+ */
+function trackCTAHover(selector, additionalData = {}) {
+  if (!isBrowser) return;
+
+  dispatchEvent('CTAHover', {
+    cta_selector: selector,
+    engagement_type: 'hover',
+    ...additionalData
+  });
+}
+
+// ── Dispatcher Geral ─────────────────────────────────────────────────────────────
+
+/**
+ * Dispatch evento para o tracking principal (cdpTrack)
+ */
+function dispatchEvent(eventName, data = {}) {
+  // Verifica se cdpTrack existe
+  if (typeof cdpTrack !== 'undefined' && cdpTrack.track) {
+    cdpTrack.track(eventName, data);
+  } else {
+    console.warn('cdpTrack não disponível - evento não enviado:', eventName, data);
+  }
+}
+
+// ── Inicialização Principal ─────────────────────────────────────────────────────
+
+/**
+ * Inicializa todos os micro-events
+ */
+function initMicroEvents() {
+  if (!isBrowser) return;
+
+  state.pageLoadTime = Date.now();
+
+  // Inicializar tracking de scroll
+  initScrollTracking();
+
+  // Inicializar tracking de tempo na página
+  initTimeOnPageTracking();
+
+  // Inicializar tracking de vídeo
+  initVideoTracking();
+
+  // Inicializar tracking de clique
+  initClickHeatmapTracking();
+
+  // Inicializar tracking de hover no CTA
+  initCTAHoverTracking();
+
+  console.log('✅ Micro-Events inicializados');
+}
+
+// ── Exportações ─────────────────────────────────────────────────────────────────
+
+export {
+  initMicroEvents,
+  trackScroll,
+  trackTimeOnPage,
+  trackVideo,
+  trackCTAHover,
+  getVideoSummary
+};