cdp-edge 1.2.0

package/extracted-skill/tracking-events-generator/models/scenarios/behavior-engine.js

@@ -0,0 +1,425 @@
+/**
+ * CDP Edge Human-Behavior Engine (Quantum Tier)
+ * Responsável por capturar micro-interações e intenção real.
+ */
+
+const BehaviorEngine = {
+  config: {
+    rageClickThreshold: 3,
+    rageClickTime: 700, // ms
+    idleThreshold: 60000, // 60s
+    scoreThresholds: {
+      engaged: 40,
+      highIntent: 80
+    }
+  },
+
+  state: {
+    clickHistory: [],
+    startTime: Date.now(),
+    lastActivity: Date.now(),
+    lastPulse: Date.now(),
+    isIdle: false,
+    formStartTime: {},
+    userScore: 0,
+    firedScoreEvents: new Set(),
+    abVariant: null,
+  },
+
+  init() {
+    this.setupRageClicks();
+    this.setupVisibility();
+    this.setupHeartbeat();
+    this.setupScroll();
+    this.setupVideoTracking();
+    this.setupFormAnalytics();
+    this.setupFormAbandonment();
+    this.setupCopyPaste();
+    this.setupExitIntent();
+    this.setupOutboundLinks();
+    this.setupErrorTracking();
+    this.setupIdleDetection();
+    this.setupScoring();
+    this.setupABTesting();
+    console.log('[CDP Edge] Enterprise Behavior Engine Initialized');
+  },
+
+  // 0.1 A/B Testing (Mode 1 - Edge Sync)
+  setupABTesting() {
+    // Busca variante no Cookie ou URL (Modo 1)
+    const getCookie = (name) => {
+      const value = `; ${document.cookie}`;
+      const parts = value.split(`; ${name}=`);
+      if (parts.length === 2) return parts.pop().split(';').shift();
+    };
+
+    const urlParams = new URLSearchParams(window.location.search);
+    this.state.abVariant = urlParams.get('cdp_variant') || getCookie('cdp_ab_variant') || 'original';
+    
+    console.log(`[CDP Edge] A/B Variant Detected: ${this.state.abVariant}`);
+    
+    // Intercepta o cdpTrack.track para injetar a variante globalmente
+    const originalTrack = cdpTrack.track;
+    cdpTrack.track = (eventName, eventParams = {}) => {
+      const enrichedParams = {
+        ...eventParams,
+        ab_test_variant: this.state.abVariant,
+        user_score: this.state.userScore
+      };
+      return originalTrack.apply(cdpTrack, [eventName, enrichedParams]);
+    };
+  },
+
+  // 0. Scoring Engine (Internal)
+  setupScoring() {
+    console.log('[CDP Edge] Scoring Engine Online');
+  },
+
+  addScore(points, reason) {
+    this.state.userScore = Math.min(100, Math.max(0, this.state.userScore + points));
+    console.log(`[CDP Edge] Score Update: +${points} (${reason}) | Total: ${this.state.userScore}`);
+
+    // Gatilhos de Plataforma
+    if (this.state.userScore >= this.config.scoreThresholds.highIntent && !this.state.firedScoreEvents.has('highIntent')) {
+      this.state.firedScoreEvents.add('highIntent');
+      cdpTrack.track('High_Intent_Lead', { score: this.state.userScore, meta_intensity: 'high' });
+    } else if (this.state.userScore >= this.config.scoreThresholds.engaged && !this.state.firedScoreEvents.has('engaged')) {
+      this.state.firedScoreEvents.add('engaged');
+      cdpTrack.track('Engaged_User', { score: this.state.userScore, meta_intensity: 'medium' });
+    }
+  },
+
+  // 1. Rage Click Detector
+  setupRageClicks() {
+    document.addEventListener('click', (e) => {
+      const now = Date.now();
+      this.state.clickHistory.push(now);
+      
+      // Limpa histórico antigo
+      this.state.clickHistory = this.state.clickHistory.filter(t => now - t < this.config.rageClickTime);
+      
+      if (this.state.clickHistory.length >= this.config.rageClickThreshold) {
+        cdpTrack.track('rage_click', {
+          element_id: e.target.id || '',
+          element_class: e.target.className || '',
+          x: e.pageX,
+          y: e.pageY,
+          meta_intensity: 'low' // Envia sinal leve para Meta
+        });
+        this.addScore(-10, 'rage_click');
+        this.state.clickHistory = []; // Reseta após detecção
+      }
+    });
+  },
+
+  // 1.2 Scroll Depth (Quantum Tier)
+  setupScroll() {
+    const markers = [25, 50, 75, 90];
+    const fired = new Set();
+    
+    window.addEventListener('scroll', () => {
+      const scrollPct = Math.round((window.scrollY / (document.documentElement.scrollHeight - window.innerHeight)) * 100);
+      
+      markers.forEach(m => {
+        if (scrollPct >= m && !fired.has(m)) {
+          fired.add(m);
+          this.addScore(m === 25 ? 5 : (m === 50 ? 5 : 10), `scroll_${m}%`);
+          cdpTrack.track('scroll_depth', {
+            percent: m,
+            meta_intensity: m >= 50 ? 'medium' : 'low' // Envia como sinal mais forte após 50%
+          });
+        }
+      });
+    }, { passive: true });
+  },
+
+  // 2. Tab Visibility (VSL Focus)
+  setupVisibility() {
+    document.addEventListener('visibilitychange', () => {
+      const status = document.visibilityState; // 'visible' ou 'hidden'
+      cdpTrack.track('tab_visibility_change', {
+        status: status,
+        time_since_start: Math.floor((Date.now() - this.state.startTime) / 1000),
+        meta_intensity: status === 'visible' ? 'high' : 'low'
+      });
+    });
+  },
+
+  // 3. Click Heatmap (D1 Only)
+  setupHeatmap() {
+    document.addEventListener('click', (e) => {
+      // Enviamos apenas para o servidor/D1 para não poluir o pixel do cliente
+      // sendServerEvent é o método interno que pula o despacho para Meta/TikTok
+      if (typeof cdpTrack.sendServerEvent === 'function') {
+        cdpTrack.sendServerEvent('click_heatmap', null, {
+          x: e.pageX,
+          y: e.pageY,
+          element: e.target.tagName.toLowerCase(),
+          id: e.target.id || '',
+          classes: e.target.className || ''
+        });
+      }
+    });
+  },
+
+  // 4. Retention Pulse (Heartbeat)
+  setupHeartbeat() {
+    setInterval(() => {
+      const activeTime = Math.floor((Date.now() - this.state.startTime) / 1000);
+      cdpTrack.track('pulse_heartbeat', {
+        duration_seconds: activeTime,
+        is_visible: document.visibilityState === 'visible'
+      });
+    }, this.config.heartbeatInterval);
+  },
+
+  // 5. VSL / Video Tracking (YouTube & Vimeo)
+  setupVideoTracking() {
+    const iframes = document.querySelectorAll('iframe');
+    const fired = new Set();
+
+    iframes.forEach(iframe => {
+      const src = iframe.src || '';
+      const isYT = src.includes('youtube.com/embed');
+      const isVimeo = src.includes('vimeo.com/video');
+
+      if (isYT || isVimeo) {
+        // Observer de progresso (via postMessage para evitar dependência de SDK pesado)
+        window.addEventListener('message', (event) => {
+          try {
+            const data = typeof event.data === 'string' ? JSON.parse(event.data) : event.data;
+            
+            // Lógica YouTube
+            if (isYT && data.event === 'infoDelivery' && data.info && data.info.currentTime) {
+              this.handleVideoProgress(iframe, data.info.currentTime, data.info.duration, fired, 'YouTube');
+            }
+            
+            // Lógica Vimeo
+            if (isVimeo && data.event === 'timeupdate') {
+              this.handleVideoProgress(iframe, data.data.seconds, data.data.duration, fired, 'Vimeo');
+            }
+          } catch (e) { /* ignore non-json messages */ }
+        });
+        
+        // Ativa o JS API se for YouTube
+        if (isYT && !src.includes('enablejsapi=1')) {
+          const url = new URL(src);
+          url.searchParams.set('enablejsapi', '1');
+          iframe.src = url.toString();
+        }
+      }
+    });
+  },
+
+  handleVideoProgress(iframe, current, total, firedSet, platform) {
+    if (!total) return;
+    const pct = Math.floor((current / total) * 100);
+    const milestones = [25, 50, 75, 100];
+    const videoId = iframe.id || iframe.src.split('/').pop().split('?')[0];
+
+    milestones.forEach(m => {
+      const key = `${videoId}_${m}`;
+      if (pct >= m && !firedSet.has(key)) {
+        firedSet.add(key);
+        this.addScore(m === 25 ? 10 : (m === 50 ? 15 : 25), `vsl_${m}%`);
+        cdpTrack.track('video_milestone', {
+          video_id: videoId,
+          platform: platform,
+          percent: m,
+          meta_intensity: m >= 50 ? 'high' : 'medium'
+        });
+      }
+    });
+  },
+
+  // 6. Form Analytics (Friction & Abandonment)
+  setupFormAnalytics() {
+    const inputs = document.querySelectorAll('input, select, textarea');
+    inputs.forEach(input => {
+      input.addEventListener('focus', () => {
+        const name = input.name || input.id;
+        if (!this.state.formStartTime[name]) {
+          this.state.formStartTime[name] = Date.now();
+          this.addScore(10, `form_interaction_${name}`);
+          cdpTrack.track('form_field_focus', { field: name });
+        }
+      });
+
+      input.addEventListener('blur', () => {
+        const name = input.name || input.id;
+        const duration = Math.round((Date.now() - this.state.formStartTime[name]) / 1000);
+        if (duration > 0) {
+          cdpTrack.track('form_field_blur', { field: name, duration_sec: duration });
+        }
+      });
+    });
+  },
+
+  // 6.1 Form Abandonment — saiu da página após interagir com formulário sem submeter
+  setupFormAbandonment() {
+    const formInteracted = new Set(); // campos que receberam foco
+    let formSubmitted = false;
+
+    // Marcar campo como interagido no focus
+    document.addEventListener('focusin', (e) => {
+      const el = e.target;
+      if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.tagName === 'SELECT') {
+        const name = el.name || el.id || el.type;
+        if (name) formInteracted.add(name);
+      }
+    }, true);
+
+    // Marcar submit realizado (qualquer formulário)
+    document.addEventListener('submit', () => {
+      formSubmitted = true;
+    }, true);
+
+    // Detectar abandono via visibilitychange (tab hidden / fechando)
+    document.addEventListener('visibilitychange', () => {
+      if (document.visibilityState === 'hidden' && formInteracted.size > 0 && !formSubmitted) {
+        this.addScore(-5, 'form_abandonment');
+        cdpTrack.track('form_abandonment', {
+          fields_interacted: Array.from(formInteracted),
+          fields_count: formInteracted.size,
+          meta_intensity: 'medium',
+          time_on_page: Math.floor((Date.now() - this.state.startTime) / 1000),
+        });
+      }
+    });
+
+    // Fallback: beforeunload
+    window.addEventListener('beforeunload', () => {
+      if (formInteracted.size > 0 && !formSubmitted) {
+        // Usar sendBeacon para garantir entrega mesmo na saída
+        if (navigator.sendBeacon && typeof cdpTrack !== 'undefined') {
+          const data = JSON.stringify({
+            eventName: 'form_abandonment',
+            behavioral_data: { user_score: this.state.userScore },
+            fields_interacted: Array.from(formInteracted),
+            fields_count: formInteracted.size,
+            meta_intensity: 'medium',
+          });
+          navigator.sendBeacon('/api/tracking', new Blob([data], { type: 'application/json' }));
+        }
+      }
+    });
+  },
+
+  // 6.2 Exit Intent — mouse saindo pelo topo da viewport
+  setupExitIntent() {
+    let exitFired = false; // disparar apenas uma vez por sessão
+
+    document.addEventListener('mousemove', (e) => {
+      // Threshold: mouse a menos de 20px do topo da viewport
+      if (e.clientY < 20 && !exitFired) {
+        exitFired = true;
+        this.addScore(15, 'exit_intent'); // sinal positivo: ainda está aqui
+        cdpTrack.track('exit_intent', {
+          mouse_y: e.clientY,
+          time_on_page: Math.floor((Date.now() - this.state.startTime) / 1000),
+          user_score: this.state.userScore,
+          meta_intensity: 'high', // Alta intenção — usuário está prestes a sair
+        });
+
+        // Resetar após 30s para redetectar se usuário continuar
+        setTimeout(() => { exitFired = false; }, 30000);
+      }
+    }, { passive: true });
+
+    // Mobile: detectar via visibilitychange (sem mouse)
+    let mobileExitFired = false;
+    document.addEventListener('visibilitychange', () => {
+      if (document.visibilityState === 'hidden' && !mobileExitFired) {
+        const timeOnPage = Math.floor((Date.now() - this.state.startTime) / 1000);
+        // Só dispara se usuário ficou tempo suficiente (não é bounce imediato)
+        if (timeOnPage > 5) {
+          mobileExitFired = true;
+          cdpTrack.track('exit_intent_mobile', {
+            time_on_page: timeOnPage,
+            user_score: this.state.userScore,
+            meta_intensity: 'medium',
+          });
+        }
+      }
+    });
+  },
+
+  // 7. Copy-Paste Intent (High Conv.)
+  setupCopyPaste() {
+    document.addEventListener('copy', () => {
+      const selectedText = window.getSelection().toString();
+      if (selectedText.length > 0) {
+        this.addScore(20, 'text_copy');
+        cdpTrack.track('content_copy', { 
+          text_length: selectedText.length,
+          meta_intensity: 'medium' 
+        });
+      }
+    });
+  },
+
+  // 8. Outbound Link Tracking (Whitelist: WhatsApp/Checkouts)
+  setupOutboundLinks() {
+    document.addEventListener('click', (e) => {
+      const link = e.target.closest('a');
+      if (link && link.href) {
+        const url = link.href;
+        const isExternal = !url.includes(window.location.hostname);
+        const isWhitelisted = url.includes('wa.me') || 
+                             url.includes('hotmart.com') || 
+                             url.includes('kiwify.com') || 
+                             url.includes('checkout');
+        
+        if (isExternal && isWhitelisted) {
+          this.addScore(100, 'outbound_conversion_intent');
+          cdpTrack.track('outbound_click', { 
+            destination: url,
+            meta_intensity: 'high' 
+          });
+        }
+      }
+    });
+  },
+
+  // 9. JS Error Tracking (D1 Only)
+  setupErrorTracking() {
+    window.addEventListener('error', (event) => {
+      if (typeof cdpTrack.sendServerEvent === 'function') {
+        cdpTrack.sendServerEvent('js_error', null, {
+          message: event.message,
+          source: event.filename,
+          lineno: event.lineno,
+          colno: event.colno
+        });
+      }
+    });
+  },
+
+  // 10. Idle Detection (Active Time)
+  setupIdleDetection() {
+    const activityEvents = ['mousedown', 'mousemove', 'keydown', 'scroll', 'touchstart'];
+    activityEvents.forEach(evt => {
+      document.addEventListener(evt, () => {
+        this.state.lastActivity = Date.now();
+        if (this.state.isIdle) {
+          this.state.isIdle = false;
+          cdpTrack.track('user_active', { status: 'back_online' });
+        }
+      }, { passive: true });
+    });
+
+    setInterval(() => {
+      if (Date.now() - this.state.lastActivity > this.config.idleThreshold && !this.state.isIdle) {
+        this.state.isIdle = true;
+        cdpTrack.track('user_idle', { idle_duration: this.config.idleThreshold / 1000 });
+      }
+    }, 10000);
+  }
+};
+
+// Auto-inicialização se o cdpTrack estiver presente
+if (typeof cdpTrack !== 'undefined') {
+  BehaviorEngine.init();
+}
+
+export default BehaviorEngine;

package/extracted-skill/tracking-events-generator/models/scenarios/real-estate-logic.md

@@ -0,0 +1,50 @@
+# Blueprint: Real Estate (Lançamento Imobiliário) - Quantum Tier
+
+Este blueprint define a inteligência técnica para capturar e atribuir leads do mercado imobiliário com alta fidelidade.
+
+---
+
+## 🏗️ ARQUITETURA TÉCNICA
+
+### 1. Geolocalização Nativa (Edge Sync)
+Para negócios locais, a geolocalização é o sinal mais rico para a Meta encontrar compradores próximos ao empreendimento.
+*   **Captura**: Ativar via `getCidade()` no browser.
+*   **Envio**: Incluir campos `ct` (city) e `st` (state) no Advanced Matching da Meta (CAPI).
+
+### 2. WhatsApp Lead Lock (D1 Persistence)
+O maior vazamento de dados no mercado imobiliário é o clique no botão de WhatsApp sem que o lead seja salvo no CRM.
+*   **Ação**: No momento do clique (`Contact`), o CDP Edge salva o `fbclid`, `gclid` e `ttclid` no D1 vinculado ao contexto da página.
+*   **Offline Match**: Quando a venda ocorre (offline), os IDs de rastro são recuperados do D1 para disparo do evento `Purchase`.
+
+### 3. CTWA Support (Click-to-WhatsApp)
+Anúncios de mensagem são o padrão. O parâmetro `ctwa_clid` é monitorado e persistido para o Worker.
+
+---
+
+## 🛠️ MAPEAMENTO DO PAGE ANALYZER
+
+O Page Analyzer deve buscar os seguintes sinais:
+*   **Seletores**: `a[href*='wa.me']`, `a[href*='api.whatsapp.com']`, `#form-visita`.
+*   **Sinais Gráficos**: Palavras-chave como "Plantão", "Decorado", "Financiamento", "Quartos", "Suítes".
+
+---
+
+## 📜 EXEMPLO DE INJEÇÃO (cdpTrack)
+
+```javascript
+// Exemplo de captura de visita a imóvel com geolocalização ativa
+cdpTrack.track('ViewContent', {
+  content_category: 'imovel',
+  content_name: 'Residencial Aurora', // Capturado do H1
+  city: await cdpTrack.getCidade(),    // Capturado nativamente
+  meta_intensity: 'high'
+});
+
+// Lead Lock no clique do WhatsApp
+document.querySelector('.btn-whatsapp').addEventListener('click', () => {
+  cdpTrack.track('Contact', {
+    method: 'whatsapp',
+    lead_lock: true // Sinaliza para o D1 persistir os IDs de clique e a geolocalização
+  });
+});
+```

package/extracted-skill/tracking-events-generator/models/scenarios/sales-page-logic.md

@@ -0,0 +1,50 @@
+# Blueprint: Sales Page & Checkout (Páginas de Vendas) - Quantum Tier
+
+Este blueprint define a inteligência técnica para rastrear e atribuir vendas em infoprodutos com alta precisão e 100% de dedução de ROI.
+
+---
+
+## 🏗️ ARQUITETURA TÉCNICA
+
+### 1. Checkout Passthrough (UTM & UID Injection)
+Indispensável para Hotmart, Kiwify, Eduzz, CartPanda.
+*   **Captura**: O CDP Edge captura as UTMs no carregamento da página.
+*   **Injeção**: Ao clicar no botão de compra, o CDP Edge injeta automaticamente os parâmetros `xcod`, `sck` (Hotmart), `src` (Kiwify) ou parâmetros customizados no URL do checkout.
+*   **D1 Lock**: Salva o `_cdp_uid` persistente para atribuição server-side posterior (no recebimento do Webhook de venda).
+
+### 2. VSL Retention Engine (Video Milestone)
+Mede a eficácia do vídeo de vendas antes do botão de compra aparecer.
+*   **Milestones**: 25%, 50%, 75%, 100%.
+*   **Visibility Sync**: Pausa a contagem de retenção se a aba for escondida, mas registra o status do áudio separadamente.
+*   **Ação**: Disparar `ViewContent` (25/50/75) e `AddToCart` (100% ou clique no botão).
+
+### 3. Adblock Immunity (Stealth Tracking)
+Utiliza rotas no mesmo domínio (ex: `/api/tracking`) para garantir que o script de rastreamento não seja bloqueado por uBlock ou Ghostery.
+
+---
+
+## 🛠️ MAPEAMENTO DO PAGE ANALYZER
+
+O Page Analyzer deve buscar os seguintes sinais:
+*   **Checkouts**: Qualquer `<a>` com links contendo `pay.hotmart.com`, `kiwify.com.br`, `eduzz.com`, `monetizze.com.br`.
+*   **Vídeos**: Tags `<iframe>` de YouTube ou Vimeo, ou players customizados.
+*   **Sinais Gráficos**: Headlines de promessa, Garantia de X dias, Botão de "Quero Garantir Minha Vaga".
+
+---
+
+## 📜 EXEMPLO DE INJEÇÃO (cdpTrack)
+
+```javascript
+// Exemplo de injeção automática de Checkout
+cdpTrack.passCheckoutParams({ 
+  platforms: ['hotmart', 'kiwify'],
+  extra: { source: 'facebook_ads' }
+});
+
+// Exemplo de retenção de VSL
+cdpTrack.track('ViewContent', {
+  vsl_name: 'VSL_Lote_1',
+  watch_time: 120, // segundos
+  meta_intensity: 'high'
+});
+```