cdp-edge 1.0.0

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

@@ -0,0 +1,640 @@
+/**
+ * CDP EDGE TRACKING SDK (Quantum Tier)
+ * @version 1.0.0
+ *
+ * SDK principal de tracking do CDP Edge.
+ * Comunica diretamente com o Cloudflare Worker.
+ * Suporta micro-events, engagement scoring e tracking premium.
+ */
+
+// ── Imports ────────────────────────────────────────────────
+import CONFIG from './tracking.config.js';
+import { initMicroEvents, trackScroll, trackTimeOnPage, trackVideo, trackCTAHover } from './micro-events.js';
+import {
+  calculateEngagementScore,
+  updateEngagementState,
+  engagementState
+} from './engagement-scoring.js';
+import {
+  extractFormPII,
+  capturePII,
+  isValidPII
+} from './advanced-matching.js';
+import {
+  sendWithRetry,
+  initAntiBlocking,
+  ANTI_BLOCKING_CONFIG
+} from './anti-blocking.js';
+import { initRouteIntentCapture } from './route-intent-capture.js';
+
+// ── Guards — segurança em SSR e SDK não carregado ──
+const isBrowser = typeof window !== 'undefined';
+const has = (fn) => isBrowser && typeof window[fn] === 'function';
+
+// ── Google Consent Mode v2 ────────────────────────────────────────────────────
+// Inicializa com todos os sinais negados por padrão (LGPD/GDPR compliance).
+// Sites devem chamar cdpTrack.updateConsent({ analytics: true, ads: true })
+// após o usuário aceitar o banner de cookies.
+const CONSENT_KEY = '_cdp_consent';
+
+const _defaultConsent = {
+  ad_storage:           'denied',
+  analytics_storage:    'denied',
+  ad_user_data:         'denied',
+  ad_personalization:   'denied',
+};
+
+// Lê consentimento salvo (boolean → objeto de sinais)
+function _readStoredConsent() {
+  if (!isBrowser) return null;
+  try {
+    const raw = localStorage.getItem(CONSENT_KEY);
+    return raw ? JSON.parse(raw) : null;
+  } catch { return null; }
+}
+
+/**
+ * Inicializa o Google Consent Mode v2 com defaults negados.
+ * Chamado automaticamente em init() ANTES de qualquer gtag disparo.
+ * Também aplica consentimento salvo previamente (sessões recorrentes).
+ */
+function initConsentMode() {
+  if (!isBrowser) return;
+
+  // Se consent mode desabilitado na config, não inicializa
+  if (CONFIG.consent?.defaultDenied === false) return;
+
+  // gtag helper — funciona mesmo que gtag não tenha sido carregado ainda
+  window.dataLayer = window.dataLayer || [];
+  function gtag() { window.dataLayer.push(arguments); }
+
+  const waitForUpdate = CONFIG.consent?.waitForUpdate ?? 500;
+
+  // Consent padrão: tudo negado + url_passthrough para preservar atribuição
+  gtag('consent', 'default', {
+    ..._defaultConsent,
+    wait_for_update: waitForUpdate,
+  });
+
+  // url_passthrough: preserva gclid/fbclid na URL mesmo sem consent
+  if (CONFIG.consent?.urlPassthrough !== false) {
+    gtag('set', 'url_passthrough', true);
+  }
+
+  // Aplicar consentimento salvo (usuário que já aceitou anteriormente)
+  const stored = _readStoredConsent();
+  if (stored) {
+    gtag('consent', 'update', stored);
+    if (CONFIG.debug) console.log('✅ Consent Mode: consentimento anterior restaurado');
+  }
+}
+
+/**
+ * Atualiza o Consent Mode quando o usuário aceita/rejeita o banner.
+ *
+ * @param {object} params - { analytics?: boolean, ads?: boolean }
+ * @example
+ *   // Usuário aceitou tudo
+ *   cdpTrack.updateConsent({ analytics: true, ads: true });
+ *
+ *   // Usuário aceitou só analytics, rejeitou anúncios
+ *   cdpTrack.updateConsent({ analytics: true, ads: false });
+ */
+export function updateConsent(params = {}) {
+  if (!isBrowser) return;
+
+  window.dataLayer = window.dataLayer || [];
+  function gtag() { window.dataLayer.push(arguments); }
+
+  const analyticsGranted = params.analytics === true ? 'granted' : 'denied';
+  const adsGranted       = params.ads       === true ? 'granted' : 'denied';
+
+  const consentUpdate = {
+    analytics_storage:  analyticsGranted,
+    ad_storage:         adsGranted,
+    ad_user_data:       adsGranted,
+    ad_personalization: adsGranted,
+  };
+
+  gtag('consent', 'update', consentUpdate);
+
+  // Persiste para sessões futuras
+  try {
+    localStorage.setItem(CONSENT_KEY, JSON.stringify(consentUpdate));
+  } catch { /* storage bloqueado (incognito, etc.) */ }
+
+  console.log('✅ Consent Mode atualizado:', consentUpdate);
+}
+
+// ── Captura de parâmetros de URL no carregamento da página ──
+// Cada plataforma injeta seu próprio Click ID na URL quando o usuário clica em um anúncio.
+// Guardamos todos em memória para enviar ao servidor e garantir atribuição correta.
+const _urlParams = isBrowser ? new URLSearchParams(window.location.search) : new URLSearchParams();
+
+// Meta
+const _fbclid = _urlParams.get('fbclid') || ''; // Meta Ads click ID → gera cookie _fbc
+
+// Google Ads (três variantes por tipo de match/privacy)
+const _gclid = _urlParams.get('gclid') || ''; // Google Ads standard click ID → gera cookie _gcl_aw
+const _wbraid = _urlParams.get('wbraid') || ''; // Google Ads (iOS, web-to-app, privacy preserving)
+const _gbraid = _urlParams.get('gbraid') || ''; // Google Ads (app campaigns, privacy preserving)
+
+// TikTok
+const _ttclid = _urlParams.get('ttclid') || ''; // TikTok Ads click ID → complementa cookie _ttp
+
+// UTMs — rastreamento interno de origem de tráfego (independente da atribuição das plataformas)
+const _utms = {
+  utm_source: _urlParams.get('utm_source') || '',
+  utm_medium: _urlParams.get('utm_medium') || '',
+  utm_campaign: _urlParams.get('utm_campaign') || '',
+  utm_content: _urlParams.get('utm_content') || '',
+  utm_term: _urlParams.get('utm_term') || '',
+};
+
+// ── User ID persistente (first-party cookie) ──────────────────
+// Identifica o mesmo usuário entre sessões diferentes, mesmo sem login.
+// Resolve o problema de cookies de terceiros bloqueados por ad-blockers.
+const _getUserId = () => {
+  if (!isBrowser) return '';
+  const KEY = '_cdp_uid';
+  let uid = document.cookie.match(new RegExp(`${KEY}=([^;]+)`))?.[1];
+  if (!uid) {
+    uid = `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+    // Cookie first-party de 365 dias — não bloqueado por navegadores
+    document.cookie = `${KEY}=${uid}; max-age=${60*60*24*365}; path=/; SameSite=Lax`;
+  }
+  return uid;
+};
+const _userId = isBrowser ? _getUserId() : '';
+
+// ── Session ID (cross-tab) ─────────────────────────────────────
+const _getSessionId = () => {
+  if (!isBrowser) return '';
+  const sessionId = 'cdp_session';
+  let sid = sessionStorage.getItem(sessionId);
+  if (!sid) {
+    sid = `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+    sessionStorage.setItem(sessionId, sid);
+  }
+  return sid;
+};
+const _sessionId = isBrowser ? _getSessionId() : '';
+
+/**
+ * getUTMs() — retorna os UTMs capturados na chegada do usuário
+ * Útil para: salvar no CRM, incluir no payload do servidor, rastreamento interno.
+ * Atribuição própria independente da janela das plataformas (último clique registrado).
+ */
+export const getUTMs = () => ({ ..._utms });
+
+/**
+ * getUserId() — retorna o User ID persistente gerado como cookie first-party.
+ * Identificador de usuário persistente nativo.
+ */
+export const getUserId = () => _userId;
+
+/**
+ * getSessionId() — retorna o Session ID (cross-tab).
+ */
+export const getSessionId = () => _sessionId;
+
+/**
+ * generateId() — gera um ID único de evento
+ * Baseado em timestamp + random
+ */
+export const generateId = () => {
+  return `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+};
+
+// ── Captura de Click IDs das plataformas ──────────────────────
+const _getClickIDs = () => {
+  return {
+    fbp:    document.cookie.match(/_fbp=([^;]+)/)?.[1] || undefined,
+    fbc:    document.cookie.match(/_fbc=([^;]+)/)?.[1] || undefined,
+    fbclid: _fbclid || undefined,  // click ID Meta → Worker gera fbc se cookie _fbc ausente
+    gclid:  _gclid  || undefined,
+    gbraid: _gbraid || undefined,
+    wbraid: _wbraid || undefined,
+    ttclid: _ttclid || undefined,
+    ttp:    document.cookie.match(/_ttp=([^;]+)/)?.[1] || undefined,  // TikTok Pixel cookie — EMQ TikTok
+    rclid:  _urlParams.get('rclid') || undefined,
+  };
+};
+
+/**
+ * passCheckoutParams(options?) — adiciona UTMs + User ID nos links de checkout externo.
+ *
+ * Problema: quando o usuário clica em um link de Hotmart, Kiwify, Eduzz etc., os UTMs e
+ * o user ID são perdidos — a plataforma não sabe de onde veio o comprador.
+ *
+ * Solução: interceptar os links de checkout e adicionar os parâmetros de rastreamento
+ * na URL antes do clique, para que a plataforma receba e registre a origem.
+ *
+ * Plataformas suportadas e seus parâmetros:
+ *   hotmart → xcod (user ID) + sck (UTMs pipe-separados: src|med|camp|con|term)
+ *   kiwify → src (utm_source)
+ *   eduzz → src (utm_source)
+ *   monetizze → src (utm_source)
+ *   cartpanda → utm_* passthrough direto
+ *   custom → qualquer domínio via opção `domains`
+ *
+ * Uso:
+ *   passCheckoutParams()                              // detecta automaticamente
+ *   passCheckoutParams({ platforms: ['hotmart'] })   // só Hotmart
+ *   passCheckoutParams({ domains: ['meusite.com/checkout'] }) // domínio customizado
+ */
+export const passCheckoutParams = (options = {}) => {
+  if (!isBrowser) return;
+
+  const {
+    platforms = ['hotmart', 'kiwify', 'eduzz', 'monetizze', 'cartpanda', 'ticto'],
+    domains = []
+  } = options;
+
+  const utms = getUTMs();
+  const userId = getUserId();
+
+  // Mapa de domínios por plataforma
+  const PLATFORM_DOMAINS = {
+    hotmart: ['hotmart.com', 'pay.hotmart.com', 'payment.hotmart.com'],
+    kiwify: ['kiwify.com.br', 'checkout.kiwify.com.br'],
+    eduzz: ['eduzz.com', 'sun.eduzz.com'],
+    monetizze: ['monetizze.com.br'],
+    cartpanda: ['cartpanda.com', 'pay.cartpanda.com'],
+    ticto: ['ticto.app', 'pay.ticto.app', 'checkout.ticto.app']
+  };
+
+  // Constrói o `sck` do Hotmart: utm_source|utm_medium|utm_campaign|utm_content|utm_term
+  const buildSck = () =>
+    [utms.utm_source, utms.utm_medium, utms.utm_campaign, utms.utm_content, utms.utm_term]
+      .map(v => v || 'direto')
+      .join('|');
+
+  // Parâmetros por plataforma
+  const getParamsForUrl = (href) => {
+    const params = { ...domains };
+    const url = href.toLowerCase();
+
+    const isMatch = (list) => list.some(d => url.includes(d));
+
+    if (platforms.includes('hotmart') && isMatch(PLATFORM_DOMAINS.hotmart)) {
+      if (userId) params.xcod = userId;
+      if (utms.utm_source) params.sck = buildSck();
+    } else if (platforms.includes('kiwify') && isMatch(PLATFORM_DOMAINS.kiwify)) {
+      if (utms.utm_source) params.src = utms.utm_source;
+      if (utms.utm_medium) params.utm_medium = utms.utm_medium;
+      if (utms.utm_campaign) params.utm_campaign = utms.utm_campaign;
+    } else if (platforms.includes('eduzz') && isMatch(PLATFORM_DOMAINS.eduzz)) {
+      if (utms.utm_source) params.src = utms.utm_source;
+    } else if (platforms.includes('monetizze') && isMatch(PLATFORM_DOMAINS.monetizze)) {
+      if (utms.utm_source) params.src = utms.utm_source;
+    } else if (platforms.includes('cartpanda') && isMatch(PLATFORM_DOMAINS.cartpanda)) {
+      Object.entries(utms).forEach(([k, v]) => { if (v) params[k] = v; });
+    } else if (platforms.includes('ticto') && isMatch(PLATFORM_DOMAINS.ticto)) {
+      // Ticto captura UTMs em wh.tracking e parâmetros extras em wh.url_params
+      Object.entries(utms).forEach(([k, v]) => { if (v) params[k] = v; });
+      if (userId) params.user_id = userId; // recuperado no webhook via D1 cross-check
+    } else {
+      // Domínios customizados: repassa utm_* e userId
+      const allDomains = Object.values(PLATFORM_DOMAINS).flat().concat(domains);
+      if (!isMatch(allDomains)) return null;
+      Object.entries(utms).forEach(([k, v]) => { if (v) params[k] = v; });
+      if (userId) params.user_id = userId;
+    }
+
+    return Object.keys(params).length ? params : null;
+  };
+
+  const applyParams = (link) => {
+    if (!link.href || link.href.startsWith('javascript')) return;
+    const p = getParamsForUrl(link);
+    if (!p) return;
+
+    try {
+      const url = new URL(link.href);
+      Object.entries(p).forEach(([k, v]) => url.searchParams.set(k, v));
+      link.href = url.toString();
+    } catch { /* URL inválida — ignora */ }
+  };
+
+  // Aplica em todos os links existentes
+  document.querySelectorAll('a[href]').forEach(applyParams);
+
+  // Aplica em links adicionados dinamicamente (ex: botões de checkout lazy loaded)
+  // BUG CORRIGIDO: .observe() estava faltando — links dinâmicos nunca eram rastreados
+  new MutationObserver((mutations) => {
+    mutations.forEach(m => m.addedNodes.forEach(node => {
+      if (node.nodeType !== 1) return;
+      if (node.tagName === 'A') applyParams(node);
+      // Também verifica <a> aninhados dentro do nó adicionado
+      node.querySelectorAll?.('a[href]').forEach(applyParams);
+    }));
+  }).observe(document.body, { childList: true, subtree: true });
+
+  console.log('✅ PassCheckoutParams inicializado');
+};
+
+// ── Fingerprint Fallback para Links de Afiliado ───────────────────────────────
+// Problema: quando o cookie _cdp_uid ou os UTMs são perdidos antes do clique
+// (ex: usuário abre em nova aba, troca de navegador), o checkout chega sem cdp_uid.
+//
+// Solução: salvar uid + UTMs no localStorage ao carregar. passCheckoutParams()
+// usa este backup quando os parâmetros de URL estiverem vazios.
+
+const _AFFILIATE_STORAGE_KEY = '_cdp_aff';
+
+function _saveAffiliateContext() {
+  if (!isBrowser) return;
+  try {
+    const hasUtms = Object.values(_utms).some(v => !!v);
+    const existing = _loadAffiliateContext();
+    // Só sobrescreve se esta visita tem UTMs — não apaga atribuição melhor anterior
+    if (hasUtms || !existing) {
+      localStorage.setItem(_AFFILIATE_STORAGE_KEY, JSON.stringify({
+        uid: _userId,
+        utms: _utms,
+        ts: Date.now(),
+      }));
+    }
+  } catch { /* localStorage bloqueado */ }
+}
+
+function _loadAffiliateContext() {
+  if (!isBrowser) return null;
+  try {
+    const raw = localStorage.getItem(_AFFILIATE_STORAGE_KEY);
+    if (!raw) return null;
+    const ctx = JSON.parse(raw);
+    if (Date.now() - ctx.ts > 30 * 24 * 60 * 60 * 1000) {
+      localStorage.removeItem(_AFFILIATE_STORAGE_KEY);
+      return null;
+    }
+    return ctx;
+  } catch { return null; }
+}
+
+/**
+ * Retorna UTMs ativos: da URL (prioridade) ou do localStorage (fallback de 30 dias).
+ * Uso principal: links de afiliado onde o usuário pode chegar sem parâmetros na URL.
+ */
+export function getUTMsWithFallback() {
+  const live = getUTMs();
+  if (Object.values(live).some(v => !!v)) return live;
+  const stored = _loadAffiliateContext();
+  if (stored?.utms && Object.values(stored.utms).some(v => !!v)) {
+    if (CONFIG.debug) console.log('ℹ️ UTMs restaurados do localStorage (affiliate fallback)');
+    return stored.utms;
+  }
+  return live;
+}
+
+/**
+ * Retorna o userId com fallback para o armazenado no localStorage.
+ */
+export function getUserIdWithFallback() {
+  return _userId || _loadAffiliateContext()?.uid || '';
+}
+
+// ── Tracking Events (Principal) ─────────────────────────────────
+
+/**
+ * track() — Função principal de tracking
+ *
+ * @param {string} eventName - Nome do evento
+ * @param {object} data - Dados do evento
+ * @param {object} options - Opções adicionais
+ * @returns {Promise} - Promise com resultado
+ *
+ * Dispara evento para:
+ *   - Worker (server-side)
+ *   - Meta CAPI v22.0 (se configurado)
+ *   - Google GA4 Measurement Protocol (se configurado)
+ *   - TikTok Events API v1.3 (se configurado)
+ *
+ * Processo:
+ *   1. Gera event_id único
+ *   2. Coleta UTMs e Click IDs
+ *   3. Envia para Worker via fetch (same-domain)
+ *   4. Worker processa e despacha para plataformas
+ */
+export async function track(eventName, data = {}, options = {}) {
+  if (!isBrowser) {
+    console.warn('⚠️ cdpTrack.track() deve ser chamado no browser');
+    return { success: false, error: 'Not in browser' };
+  }
+
+  const event_id = generateId();
+  const utms = getUTMs();
+  const clickIds = _getClickIDs();
+  const userId = getUserId();
+  const sessionId = getSessionId();
+  const timestamp = Date.now();
+
+  // Calcular engajamento preliminar (browser-side)
+  const engagementScore = calculateEngagementScore();
+  const { totalScore, timeLevel, scrollScore, clickScore, videoScore, hoverScore, intentionLevel } = engagementScore;
+
+  // Payload completo
+  const payload = {
+    event_id,
+    event_name: eventName,
+    user_id: userId,
+    session_id: sessionId,
+    utms,
+    click_ids: clickIds,
+    timestamp,
+    page_url: window.location.href,
+    referrer: document.referrer,
+    user_agent: navigator.userAgent,
+    behavioral_data: {
+      ...data,
+      engagement_score: totalScore,
+      time_level: timeLevel,
+      scroll_score: scrollScore,
+      click_score: clickScore,
+      video_score: videoScore,
+      hover_score: hoverScore,
+      intention_level: intentionLevel
+    },
+    ...options
+  };
+
+  try {
+    // Enviar para Worker com retry automático (anti-blocking)
+    const result = await sendWithRetry(payload, '/track');
+
+    if (result.success) {
+      console.log(`✅ Evento ${eventName} enviado com sucesso:`, event_id, result);
+
+      // Atualizar estado de engajamento
+      updateEngagementState('timeOnPage', Math.round((Date.now() - timestamp) / 1000));
+      updateEngagementState('totalScore', totalScore);
+
+      return { success: true, event_id, result };
+    } else {
+      throw new Error(result.error || 'Envio falhou após todas as tentativas');
+    }
+  } catch (error) {
+    console.error(`❌ Erro ao enviar evento ${eventName}:`, error);
+    return { success: false, error: error.message, event_id, attempts: ANTI_BLOCKING_CONFIG.maxRetries };
+  }
+}
+
+// ── Conveniência: Track Direct ──────────────────────────────────────
+
+/**
+ * trackLead() — Captura de lead com dados PII crus
+ *
+ * @param {object} userData - Dados do usuário (email, phone, name, etc.)
+ * @param {HTMLFormElement} form - Formulário HTML (opcional, para captura automática)
+ * @returns {Promise} - Promise com resultado
+ */
+export async function trackLead(userData, form = null) {
+  // Se formulário fornecido, extrair dados PII automaticamente
+  let piiData = { ...userData };
+
+  if (form) {
+    const formPII = extractFormPII(form);
+    piiData = { ...piiData, ...formPII };
+  }
+
+  // Passa dados crus para Worker fazer hashing
+  // Worker fará SHA256 para máximo performance e segurança
+  return track('Lead', piiData);
+}
+
+/**
+ * trackPurchase() — Captura de compra
+ *
+ * @param {object} orderData - Dados da compra (order_id, value, currency, etc.)
+ * @param {HTMLFormElement} form - Formulário HTML (opcional, para captura automática)
+ * @returns {Promise} - Promise com resultado
+ */
+export async function trackPurchase(orderData, form = null) {
+  let purchaseData = { ...orderData };
+
+  if (form) {
+    const formPII = extractFormPII(form);
+    purchaseData = { ...purchaseData, ...formPII };
+  }
+
+  return track('Purchase', purchaseData);
+}
+
+/**
+ * Auto-captura formulários de lead na página
+ * Intercepta submit de formulários e captura PII automaticamente
+ */
+export function setupAutoFormCapture() {
+  if (!isBrowser) return;
+
+  // Interceptar todos os formulários
+  document.addEventListener('submit', async (e) => {
+    const form = e.target;
+
+    // Verificar se é um formulário de lead (baseado em campos)
+    const hasEmailField = form.querySelector('[name*="email"]');
+    const hasPhoneField = form.querySelector('[name*="phone"], [name*="telefone"], [name*="celular"]');
+
+    if (hasEmailField || hasPhoneField) {
+      e.preventDefault();
+
+      const piiData = extractFormPII(form);
+
+      if (isValidPII(piiData)) {
+        await trackLead(piiData, form);
+        console.log('✅ Lead capturado automaticamente com Advanced Matching:', piiData);
+      }
+
+      // Continuar com submit do formulário
+      setTimeout(() => form.submit(), 100);
+    }
+  }, true); // Capture para formulários dinâmicos
+}
+
+/**
+ * trackViewContent() — Captura de visualização de conteúdo
+ *
+ * @param {object} contentData - Dados do conteúdo (content_id, content_name, value, currency)
+ * @returns {Promise} - Promise com resultado
+ */
+export async function trackViewContent(contentData) {
+  return track('ViewContent', contentData);
+}
+
+/**
+ * trackAddToCart() — Captura de adição ao carrinho
+ *
+ * @param {object} cartData - Dados do carrinho (content_id, value, currency)
+ * @returns {Promise} - Promise com resultado
+ */
+export async function trackAddToCart(cartData) {
+  return track('AddToCart', cartData);
+}
+
+// ── Inicialização ──────────────────────────────────────────────────────
+
+/**
+ * Inicializa o cdpTrack SDK
+ * Deve ser chamado após carregar tracking.config.js
+ */
+export async function init() {
+  if (!isBrowser) return;
+
+  if (CONFIG.debug) console.log('🚀 Inicializando cdpTrack SDK...');
+
+  // 0. Google Consent Mode v2 — DEVE ser o primeiro passo, antes de qualquer gtag
+  initConsentMode();
+
+  // 1. Inicializar anti-blocking
+  initAntiBlocking();
+
+  // 1-B. Salvar contexto de afiliado no localStorage (fallback para UTM resurrection)
+  _saveAffiliateContext();
+
+  // 2. Inicializar micro-events
+  initMicroEvents();
+
+  // 3. Inicializar auto-captura de formulários (respeitando CONFIG)
+  if (CONFIG.autoCaptureForms !== false) {
+    setupAutoFormCapture();
+  }
+
+  // 4. Expõe cdpTrack globalmente ANTES do BehaviorEngine (ele referencia window.cdpTrack)
+  window.cdpTrack = { track, trackLead, trackPurchase, trackViewContent, trackAddToCart, getUserId, getUserIdWithFallback, getSessionId, getUTMs, getUTMsWithFallback, updateConsent };
+
+  // 5. Carregar BehaviorEngine (respeitando CONFIG)
+  if (CONFIG.initBehaviorEngine !== false) {
+    try {
+      const behaviorModule = await import('./models/scenarios/behavior-engine.js');
+      const BehaviorEngine = behaviorModule.default;
+
+      if (BehaviorEngine && typeof BehaviorEngine.init === 'function') {
+        BehaviorEngine.init();
+        if (CONFIG.debug) console.log('✅ Behavior Engine inicializado');
+      }
+    } catch (error) {
+      // Não bloqueia o SDK — continua sem funcionalidades avançadas
+      if (CONFIG.debug) console.info('ℹ️ Behavior Engine não disponível:', error.message);
+    }
+  }
+
+  // 6. passCheckoutParams — controlado por CONFIG.passCheckoutParams + CONFIG.platforms
+  if (CONFIG.passCheckoutParams !== false && CONFIG.platforms?.length > 0) {
+    passCheckoutParams({ platforms: CONFIG.platforms });
+  }
+
+  // 7. Route Intent Capture — widget pós-clique de rota para imóveis
+  // Ativa quando CONFIG.routeIntent.whatsappNumber estiver configurado.
+  if (CONFIG.routeIntent?.whatsappNumber) {
+    initRouteIntentCapture(CONFIG.routeIntent);
+  }
+
+  if (CONFIG.debug) console.log('✅ cdpTrack SDK inicializado (Quantum Tier)');
+}
+
+// Auto-inicialização
+if (isBrowser) {
+  // Inicializa após carregamento da página
+  window.addEventListener('DOMContentLoaded', init);
+}