cdp-edge 1.23.3 → 1.24.1

package/server-edge-tracker/modules/ml/{matchquality.js → matchquality.ts}

@@ -6,9 +6,43 @@
  */
 
 import { sendCallMeBot } from '../dispatch/whatsapp.js';
+import { Env, TrackPayload } from '../../types.js';
+import { D1Database } from '@cloudflare/workers-types';
+
+// ── Tipos ───────────────────────────────────────────────────────────────────────
+export interface MatchQualityThresholds {
+  email_rate_min: number;
+  fbp_rate_min: number;
+  composite_min: number;
+  min_events_alert: number;
+}
+
+export interface EnrichedPayloadResult {
+  payload: TrackPayload;
+  recovered: { email: boolean; utm: boolean };
+}
+
+export interface MatchQualityAlert {
+  type: string;
+  metric: string;
+  message: string;
+  severity?: 'critical' | 'warning';
+}
+
+export interface MatchQualityAnalysis {
+  total?: number;
+  email_rate?: number;
+  phone_rate?: number;
+  fbp_rate?: number;
+  fbc_rate?: number;
+  ext_id_rate?: number;
+  email_recovered_rate?: number;
+  composite_score?: number;
+  alerts: MatchQualityAlert[];
+}
 
 // ── Thresholds de alerta ──────────────────────────────────────────────────────
-const THRESHOLDS = {
+const THRESHOLDS: MatchQualityThresholds = {
   email_rate_min:   0.40,  // < 40% dos eventos com email → alerta
   fbp_rate_min:     0.30,  // < 30% com fbp cookie → alerta
   composite_min:    0.45,  // < 45% score composto → alerta crítico
@@ -20,7 +54,7 @@ const THRESHOLDS = {
 /**
  * Registra flags de qualidade de um evento no D1 (background, não bloqueia).
  */
-export async function logMatchQuality(DB, eventName, payload, recovered = {}) {
+export async function logMatchQuality(DB: D1Database, eventName: string, payload: TrackPayload, recovered: { email: boolean; utm: boolean } = { email: false, utm: false }): Promise<void> {
   if (!DB) return;
   try {
     await DB.prepare(`
@@ -47,7 +81,7 @@ export async function logMatchQuality(DB, eventName, payload, recovered = {}) {
  * Tenta enriquecer o payload com dados do Identity Graph antes do envio ao Meta.
  * Retorna { payload enriquecido, flags de recuperação }.
  */
-export async function autoEnrichPayload(env, payload) {
+export async function autoEnrichPayload(env: Env, payload: TrackPayload): Promise<EnrichedPayloadResult> {
   const recovered = { email: false, utm: false };
   if (!env.DB) return { payload, recovered };
 
@@ -60,12 +94,12 @@ export async function autoEnrichPayload(env, payload) {
 
       if (profile) {
         if (profile.email && !payload.email) {
-          payload.email   = profile.email;
+          payload.email   = profile.email as string;
           recovered.email = true;
         }
-        if (profile.fbp && !payload.fbp)  payload.fbp = profile.fbp;
-        if (profile.fbc && !payload.fbc)  payload.fbc = profile.fbc;
-        if (profile.phone && !payload.phone) payload.phone = profile.phone;
+        if (profile.fbp && !payload.fbp)  payload.fbp = profile.fbp as string;
+        if (profile.fbc && !payload.fbc)  payload.fbc = profile.fbc as string;
+        if (profile.phone && !payload.phone) payload.phone = profile.phone as string;
       }
     } catch {}
   }
@@ -81,7 +115,7 @@ export async function autoEnrichPayload(env, payload) {
 /**
  * Analisa a qualidade das últimas 2h e retorna métricas + alertas.
  */
-export async function analyzeMatchQuality(env) {
+export async function analyzeMatchQuality(env: Env): Promise<MatchQualityAnalysis | null> {
   if (!env.DB) return null;
 
   try {
@@ -99,45 +133,55 @@ export async function analyzeMatchQuality(env) {
       WHERE logged_at >= datetime('now', '-2 hours')
     `).first();
 
-    if (!row || row.total < THRESHOLDS.min_events_alert) return { total: row?.total || 0, alerts: [] };
+    if (!row || Number((row as any).total) < THRESHOLDS.min_events_alert) return { total: Number((row as any)?.total || 0), alerts: [] };
 
-    const alerts = [];
+    const alerts: MatchQualityAlert[] = [];
 
-    if ((row.email_rate || 0) < THRESHOLDS.email_rate_min * 100) {
+    if (Number((row as any).email_rate || 0) < THRESHOLDS.email_rate_min * 100) {
       alerts.push({
         type:    'email_low',
-        metric:  `email_rate: ${row.email_rate}%`,
-        message: `Taxa de email baixa: ${row.email_rate}% (mínimo: ${THRESHOLDS.email_rate_min * 100}%)`,
+        metric:  `email_rate: ${(row as any).email_rate}%`,
+        message: `Taxa de email baixa: ${(row as any).email_rate}% (mínimo: ${THRESHOLDS.email_rate_min * 100}%)`,
       });
     }
 
-    if ((row.fbp_rate || 0) < THRESHOLDS.fbp_rate_min * 100) {
+    if (Number((row as any).fbp_rate || 0) < THRESHOLDS.fbp_rate_min * 100) {
       alerts.push({
         type:    'fbp_low',
-        metric:  `fbp_rate: ${row.fbp_rate}%`,
-        message: `Cookie fbp ausente em ${100 - row.fbp_rate}% dos eventos — verificar cdpTrack.js`,
+        metric:  `fbp_rate: ${(row as any).fbp_rate}%`,
+        message: `Cookie fbp ausente em ${100 - Number((row as any).fbp_rate)}% dos eventos — verificar cdpTrack.js`,
       });
     }
 
-    if ((row.composite_score || 0) < THRESHOLDS.composite_min * 100) {
+    if (Number((row as any).composite_score || 0) < THRESHOLDS.composite_min * 100) {
       alerts.push({
         type:    'composite_critical',
-        metric:  `composite: ${row.composite_score}%`,
-        message: `Score composto de match quality crítico: ${row.composite_score}%`,
+        metric:  `composite: ${(row as any).composite_score}%`,
+        message: `Score composto de match quality crítico: ${(row as any).composite_score}%`,
         severity: 'critical',
       });
     }
 
-    return { ...row, alerts };
-  } catch (err) {
-    console.error('[MatchQuality] analyze error:', err.message);
+    return {
+      total: Number((row as any).total),
+      email_rate: Number((row as any).email_rate),
+      phone_rate: Number((row as any).phone_rate),
+      fbp_rate: Number((row as any).fbp_rate),
+      fbc_rate: Number((row as any).fbc_rate),
+      ext_id_rate: Number((row as any).ext_id_rate),
+      email_recovered_rate: Number((row as any).email_recovered_rate),
+      composite_score: Number((row as any).composite_score),
+      alerts,
+    };
+  } catch (err: any) {
+    console.error('[MatchQuality] analyze error:', err?.message || String(err));
     return null;
   }
 }
 
 // ── Alerta via CallMeBot ──────────────────────────────────────────────────────
 
-export async function alertMatchQuality(env, analysis) {
+export async function alertMatchQuality(env: Env, analysis: MatchQualityAnalysis): Promise<void> {
   if (!analysis || analysis.alerts.length === 0) return;
 
   const hasCritical = analysis.alerts.some(a => a.severity === 'critical');
@@ -146,9 +190,9 @@ export async function alertMatchQuality(env, analysis) {
   const lines = [
     `${icon} CDP Edge — Match Quality Alert`,
     ``,
-    `📊 Últimas 2h (${analysis.total} eventos):`,
+    `📊 Últimas 2h (${analysis.total || 0} eventos):`,
     `  Email:     ${analysis.email_rate ?? 0}% ${(analysis.email_rate ?? 0) < 40 ? '❌' : '✅'}`,
-    `  fbp:       ${analysis.fbp_rate   ?? 0}% ${(analysis.fbp_rate   ?? 0) < 30 ? '❌' : '✅'}`,
+    `  fbp:       ${analysis.fbp_rate ?? 0}% ${(analysis.fbp_rate ?? 0) < 30 ? '❌' : '✅'}`,
     `  Score:     ${analysis.composite_score ?? 0}%`,
     ``,
     `🔍 Problemas:`,
@@ -166,7 +210,7 @@ export async function alertMatchQuality(env, analysis) {
 
 // ── Purge periódico (mensal) ──────────────────────────────────────────────────
 
-export async function purgeOldMatchQualityLogs(DB) {
+export async function purgeOldMatchQualityLogs(DB: D1Database): Promise<void> {
   if (!DB) return;
   try {
     await DB.prepare(

package/server-edge-tracker/modules/ml/{segmentation.js → segmentation.ts}

@@ -4,16 +4,59 @@
  */
 
 import { tryParseJson } from '../utils.js';
+import { Env } from '../../types.js';
+
+// ── Tipos ───────────────────────────────────────────────────────────────────────
+interface KmeansResult {
+  assignments: number[];
+  centroids: number[][];
+}
+
+interface ClusterStats {
+  c: number;
+  size: number;
+  pct: number;
+  avgLtv: number;
+  avgEng: number;
+  avgDays: number;
+  topSource: string;
+  topState: string;
+  topIntent: string;
+}
+
+interface Cluster {
+  cluster_id: number;
+  name: string;
+  size: number;
+  percentage: number;
+  action_recommendation: string;
+  characteristics: {
+    avg_ltv_class: number;
+    avg_engagement_score: number;
+    avg_intention_level: number;
+    avg_days_since_lead: number;
+    dominant_countries: string[];
+    dominant_states: string[];
+    dominant_utm_sources: string[];
+    top_features: string[];
+  };
+}
+
+interface ClusterInfo {
+  cluster_id: number;
+  name: string;
+  action: string;
+}
 
 // ── Helpers K-means vetorial ──────────────────────────────────────────────────
 
-function _cosDist(a, b) {
+function _cosDist(a: number[], b: number[]): number {
   let dot = 0, na = 0, nb = 0;
   for (let i = 0; i < a.length; i++) { dot += a[i]*b[i]; na += a[i]*a[i]; nb += b[i]*b[i]; }
   return 1 - dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-10);
 }
 
-function _kmeansRun(vectors, k, maxIter = 25) {
+function _kmeansRun(vectors: number[][], k: number, maxIter = 25): KmeansResult {
   const n = vectors.length, dim = vectors[0].length;
   const centroids = [vectors[Math.floor(Math.random() * n)]];
   while (centroids.length < k) {
@@ -41,7 +84,7 @@ function _kmeansRun(vectors, k, maxIter = 25) {
   return { assignments, centroids };
 }
 
-function _silhouette(vectors, assignments, k) {
+function _silhouette(vectors: number[][], assignments: number[], k: number): number {
   const n = vectors.length;
   let total = 0;
   for (let i = 0; i < n; i++) {
@@ -59,7 +102,7 @@ function _silhouette(vectors, assignments, k) {
   return Math.round((total / n) * 1000) / 1000;
 }
 
-function _buildLeadProfile(l) {
+function _buildLeadProfile(l: any): string {
   return [
     `LTV: ${l.predicted_ltv_class || 'desconhecido'}`,
     `engajamento: ${Math.round(l.engagement_score || 0)}`,
@@ -76,7 +119,7 @@ function _buildLeadProfile(l) {
 
 // ── POST /api/segmentation/cluster ────────────────────────────────────────────
 // Clustering real: embeddinggemma-300m → K-means vetorial → Granite para nomear
-export async function handleSegmentationCluster(env, request, headers) {
+export async function handleSegmentationCluster(env: Env, request: Request, headers: Headers): Promise<Response> {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
   if (!env.AI) return new Response(JSON.stringify({ error: 'Workers AI não configurado' }), { status: 503, headers });
 
@@ -98,11 +141,11 @@ export async function handleSegmentationCluster(env, request, headers) {
         ORDER BY created_at DESC LIMIT 1
       `).bind(algorithm, clientVertical).first();
       if (existing) {
-        const ageDays = (Date.now() - new Date(existing.created_at).getTime()) / 864e5;
+        const ageDays = (Date.now() - new Date((existing as any).created_at).getTime()) / 864e5;
         if (ageDays < 7) {
           return new Response(JSON.stringify({
             success: true, message: 'Cluster existente ainda válido (< 7 dias). Use ?force=true para re-clustering.',
-            cluster_id: existing.id, cluster_name: existing.cluster_name,
+            cluster_id: (existing as any).id, cluster_name: (existing as any).cluster_name,
             age_days: Math.round(ageDays * 10) / 10, use_existing: true,
           }), { status: 200, headers });
         }
@@ -131,7 +174,7 @@ export async function handleSegmentationCluster(env, request, headers) {
 
     // Embeddings reais via embeddinggemma-300m
     const embRes = await env.AI.run('@cf/baai/bge-m3', { text: profiles });
-    const vectors = embRes.data;
+    const vectors = (embRes as any).data as number[][];
     if (!vectors || vectors.length < nClusters) throw new Error(`embeddinggemma retornou ${vectors?.length ?? 0} vetores`);
 
     // K-means vetorial real
@@ -139,40 +182,58 @@ export async function handleSegmentationCluster(env, request, headers) {
     const silhouetteScore = _silhouette(vectors, assignments, nClusters);
 
     // Agregação por cluster para nomear com Granite
-    const clusterStats = Array.from({ length: nClusters }, (_, c) => {
+    const clusterStats: (ClusterStats | null)[] = Array.from({ length: nClusters }, (_, c) => {
       const members = sample.filter((_, i) => assignments[i] === c);
       if (!members.length) return null;
-      const ltvMap = { High: 1, Medium: 0.5, Low: 0 };
-      const avgLtv  = members.reduce((s, l) => s + (ltvMap[l.predicted_ltv_class] ?? 0), 0) / members.length;
-      const avgEng  = members.reduce((s, l) => s + (l.engagement_score || 0), 0) / members.length;
-      const avgDays = members.reduce((s, l) => s + (l.days_since_lead || 0), 0) / members.length;
-      const freq = (arr) => arr.length ? [...arr.reduce((m,s) => m.set(s,(m.get(s)||0)+1), new Map())].sort((a,b)=>b[1]-a[1])[0]?.[0] : null;
+      const ltvMap: Record<string, number> = { High: 1, Medium: 0.5, Low: 0 };
+      const avgLtv  = members.reduce((s: number, l: any) => s + (ltvMap[l.predicted_ltv_class] ?? 0), 0) / members.length;
+      const avgEng  = members.reduce((s: number, l: any) => s + (l.engagement_score || 0), 0) / members.length;
+      const avgDays = members.reduce((s: number, l: any) => s + (l.days_since_lead || 0), 0) / members.length;
+      const freq = (arr: string[]) => arr.length ? [...arr.reduce((m,s) => m.set(s,(m.get(s)||0)+1), new Map())].sort((a,b)=>b[1]-a[1])[0]?.[0] : null;
       return {
         c, size: members.length, pct: Math.round(members.length / sample.length * 100),
         avgLtv, avgEng, avgDays,
-        topSource: freq(members.map(l => l.utm_source).filter(Boolean)) || 'direto',
-        topState:  freq(members.map(l => l.state).filter(Boolean))      || 'BR',
-        topIntent: freq(members.map(l => l.intention_level).filter(Boolean)) || 'desconhecida',
+        topSource: freq(members.map((l: any) => l.utm_source).filter(Boolean)) || 'direto',
+        topState:  freq(members.map((l: any) => l.state).filter(Boolean))      || 'BR',
+        topIntent: freq(members.map((l: any) => l.intention_level).filter(Boolean)) || 'desconhecida',
       };
-    }).filter(Boolean);
+    }).filter(Boolean) as ClusterStats[];
+
+    // Type guard function to filter null values
+    function isNotNull<T>(value: T | null): value is T {
+      return value !== null;
+    }
+
+    const validClusterStats = clusterStats.filter(isNotNull);
 
     // Granite apenas para nomear segmentos
     const namingPrompt =
 `Você é especialista em segmentação de clientes. Dê um nome descritivo em português e uma recomendação de campanha para cada segmento. Retorne SOMENTE JSON válido:
 {"segments":[{"cluster_id":0,"name":"...","action":"..."},...]}
 
-${clusterStats.map(s => `Cluster ${s.c}: LTV=${s.avgLtv.toFixed(2)}, engajamento=${s.avgEng.toFixed(0)}, intenção="${s.topIntent}", origem="${s.topSource}", estado="${s.topState}", recência=${s.avgDays.toFixed(0)} dias, tamanho=${s.size}`).join('\n')}`;
+${validClusterStats.map(s => `Cluster ${s.c}: LTV=${s.avgLtv.toFixed(2)}, engajamento=${s.avgEng.toFixed(0)}, intenção="${s.topIntent}", origem="${s.topSource}", estado="${s.topState}", recência=${s.avgDays.toFixed(0)} dias, tamanho=${s.size}`).join('\n')}`;
 
     const nameRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', { messages: [{ role: 'user', content: namingPrompt }], max_tokens: 800 });
-    let clusterNames = {};
+    let clusterNames: Record<number, ClusterInfo> = {};
     try {
-      const m = (nameRes?.response || '').match(/\{[\s\S]*\}/);
-      if (m) (JSON.parse(m[0]).segments || []).forEach(s => { clusterNames[s.cluster_id] = { name: s.name, action: s.action }; });
+      const m = ((nameRes as any)?.response || '').match(/\{[\s\S]*\}/);
+      if (m) {
+        const parsed = JSON.parse(m[0]);
+        (parsed.segments || []).forEach((s: any) => {
+          if (typeof s.cluster_id === 'number') {
+            clusterNames[s.cluster_id] = {
+              cluster_id: s.cluster_id,
+              name: s.name || `Segmento ${s.cluster_id + 1}`,
+              action: s.action || '',
+            };
+          }
+        });
+      }
     } catch { /* usa nomes fallback */ }
 
     const duration = Date.now() - startTime;
 
-    const clusters = clusterStats.map(s => ({
+    const clusters: Cluster[] = validClusterStats.map(s => ({
       cluster_id: s.c,
       name: clusterNames[s.c]?.name || `Segmento ${s.c + 1}`,
       size: s.size, percentage: s.pct,
@@ -180,8 +241,8 @@ ${clusterStats.map(s => `Cluster ${s.c}: LTV=${s.avgLtv.toFixed(2)}, engajamento
       characteristics: {
         avg_ltv_class: s.avgLtv, avg_engagement_score: s.avgEng,
         avg_intention_level: s.avgLtv, avg_days_since_lead: s.avgDays,
-        dominant_countries: ['BR'], dominant_states: [s.topState],
-        dominant_utm_sources: [s.topSource], top_features: ['ltv', 'engagement', 'intention'],
+        dominant_countries: ['BR'], dominant_states: [s.topState || 'BR'],
+        dominant_utm_sources: [s.topSource || 'direto'], top_features: ['ltv', 'engagement', 'intention'],
       },
     }));
 
@@ -217,7 +278,7 @@ ${clusterStats.map(s => `Cluster ${s.c}: LTV=${s.avgLtv.toFixed(2)}, engajamento
         JSON.stringify({ algorithm, n_clusters: nClusters, vertical: clientVertical, engine: 'embeddinggemma-300m+kmeans' }),
         JSON.stringify({ clusters: clusters.length, silhouette: silhouetteScore }),
       ).run();
-    } catch (e) { console.error('[Segmentation] history log error:', e.message); }
+    } catch (e: any) { console.error('[Segmentation] history log error:', e?.message || String(e)); }
 
     return new Response(JSON.stringify({
       success: true, algorithm, engine: 'embeddinggemma-300m + kmeans vetorial',
@@ -227,20 +288,20 @@ ${clusterStats.map(s => `Cluster ${s.c}: LTV=${s.avgLtv.toFixed(2)}, engajamento
       clusters, generated_at: now,
     }), { status: 200, headers });
 
-  } catch (err) {
-    console.error('[Segmentation] cluster error:', err.message);
+  } catch (err: any) {
+    console.error('[Segmentation] cluster error:', err?.message || String(err));
     try {
       if (env.DB) await env.DB.prepare(`
         INSERT INTO ml_clustering_history (clustering_id, started_at, algorithm, n_leads_processed, n_clusters_created, total_duration_ms, workers_ai_neurons_used, status, error_message, parameters, results_summary)
         VALUES (0, datetime('now'), ?, 0, 0, 0, 0, 'failed', ?, ?, '{}')
-      `).bind(algorithm, err.message, JSON.stringify({ algorithm, n_clusters: nClusters })).run();
+      `).bind(algorithm, err?.message || String(err), JSON.stringify({ algorithm, n_clusters: nClusters })).run();
     } catch { /* não bloquear */ }
-    return new Response(JSON.stringify({ error: 'Erro ao executar clustering', message: err.message }), { status: 500, headers });
+    return new Response(JSON.stringify({ error: 'Erro ao executar clustering', message: err?.message || String(err) }), { status: 500, headers });
   }
 }
 
 // ── GET /api/segmentation/list ────────────────────────────────────────────────
-export async function handleSegmentationList(env, request, headers) {
+export async function handleSegmentationList(env: Env, request: Request, headers: Headers): Promise<Response> {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
 
   const url       = new URL(request.url);
@@ -248,8 +309,8 @@ export async function handleSegmentationList(env, request, headers) {
   const vertical  = url.searchParams.get('vertical')  || null;
 
   try {
-    const conditions = ['is_active = 1'];
-    const bindings   = [];
+    const conditions: string[] = ['is_active = 1'];
+    const bindings: (string | number)[]   = [];
     if (algorithm) { conditions.push('clustering_algorithm = ?'); bindings.push(algorithm); }
     if (vertical)  { conditions.push('client_vertical = ?');      bindings.push(vertical); }
 
@@ -266,7 +327,7 @@ export async function handleSegmentationList(env, request, headers) {
       LIMIT 50
     `).bind(...bindings).all();
 
-    const segments = (result.results || []).map(s => ({
+    const segments = (result.results || []).map((s: any) => ({
       ...s,
       dominant_countries:       tryParseJson(s.dominant_countries, []),
       dominant_states:          tryParseJson(s.dominant_states, []),
@@ -278,14 +339,14 @@ export async function handleSegmentationList(env, request, headers) {
     }));
 
     return new Response(JSON.stringify({ success: true, total: segments.length, segments }), { status: 200, headers });
-  } catch (err) {
-    console.error('[Segmentation] list error:', err.message);
-    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  } catch (err: any) {
+    console.error('[Segmentation] list error:', err?.message || String(err));
+    return new Response(JSON.stringify({ error: err?.message || String(err) }), { status: 500, headers });
   }
 }
 
 // ── GET /api/segmentation/outliers ───────────────────────────────────────────
-export async function handleSegmentationOutliers(env, request, headers) {
+export async function handleSegmentationOutliers(env: Env, request: Request, headers: Headers): Promise<Response> {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
 
   const url   = new URL(request.url);
@@ -304,17 +365,17 @@ export async function handleSegmentationOutliers(env, request, headers) {
     `).bind(days, limit).all();
 
     return new Response(JSON.stringify({ success: true, total: (result.results || []).length, period_days: days, outliers: result.results || [] }), { status: 200, headers });
-  } catch (err) {
-    console.error('[Segmentation] outliers error:', err.message);
-    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  } catch (err: any) {
+    console.error('[Segmentation] outliers error:', err?.message || String(err));
+    return new Response(JSON.stringify({ error: err?.message || String(err) }), { status: 500, headers });
   }
 }
 
 // ── PUT /api/segmentation/update ─────────────────────────────────────────────
-export async function handleSegmentationUpdate(env, request, headers) {
+export async function handleSegmentationUpdate(env: Env, request: Request, headers: Headers): Promise<Response> {
   if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
 
-  let body;
+  let body: any;
   try { body = await request.json(); }
   catch { return new Response(JSON.stringify({ error: 'JSON inválido no body da requisição' }), { status: 400, headers }); }
 
@@ -324,8 +385,8 @@ export async function handleSegmentationUpdate(env, request, headers) {
   }
 
   try {
-    const sets     = [];
-    const bindings = [];
+    const sets: string[] = [];
+    const bindings: (string | number)[] = [];
     if (action_recommendations   !== undefined) { sets.push('action_recommendations = ?');   bindings.push(JSON.stringify(action_recommendations)); }
     if (bid_recommendations      !== undefined) { sets.push('bid_recommendations = ?');      bindings.push(JSON.stringify(bid_recommendations)); }
     if (campaign_recommendations !== undefined) { sets.push('campaign_recommendations = ?'); bindings.push(JSON.stringify(campaign_recommendations)); }
@@ -339,8 +400,8 @@ export async function handleSegmentationUpdate(env, request, headers) {
 
     await env.DB.prepare(`UPDATE ml_segments SET ${sets.join(', ')} WHERE id = ?`).bind(...bindings).run();
     return new Response(JSON.stringify({ success: true, cluster_id, fields_updated: sets.length - 1 }), { status: 200, headers });
-  } catch (err) {
-    console.error('[Segmentation] update error:', err.message);
-    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  } catch (err: any) {
+    console.error('[Segmentation] update error:', err?.message || String(err));
+    return new Response(JSON.stringify({ error: err?.message || String(err) }), { status: 500, headers });
   }
 }

package/server-edge-tracker/modules/{utils.js → utils.ts}

@@ -4,8 +4,26 @@
  * Importadas por todos os outros módulos.
  */
 
+// ── Tipos ───────────────────────────────────────────────────────────────────────
+export interface FunnelStageResult {
+  depth: string;
+  funnelDepth: string;
+}
+
+export interface MetaSignalWeights {
+  intent: number;
+  ltv: number;
+  dist: number;
+}
+
+export type DistanceBucket = 'very_close' | 'close' | 'nearby' | 'moderate' | 'far';
+
+export type FunnelLevel = 'top' | 'mid' | 'bottom' | 'conversion' | 'unknown';
+
+export type MetaSignalBucket = 'hot' | 'warm' | 'cold';
+
 // ── CORS ──────────────────────────────────────────────────────────────────────
-export function isAllowedOrigin(origin, siteDomain) {
+export function isAllowedOrigin(origin: string | null, siteDomain: string | null): boolean {
   if (!origin || !siteDomain) return false;
   return origin === `https://${siteDomain}`
     || origin.endsWith(`.${siteDomain}`)
@@ -13,10 +31,10 @@ export function isAllowedOrigin(origin, siteDomain) {
     || origin === 'http://localhost:5173';
 }
 
-export function corsHeaders(origin, siteDomain) {
-  const allowed = isAllowedOrigin(origin, siteDomain) ? origin : `https://${siteDomain}`;
+export function corsHeaders(origin: string | null, siteDomain: string | null): Record<string, string> {
+  const allowed = isAllowedOrigin(origin, siteDomain) ? origin : (siteDomain ? `https://${siteDomain}` : '*');
   return {
-    'Access-Control-Allow-Origin':  allowed,
+    'Access-Control-Allow-Origin':  allowed || '*',
     'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
     'Access-Control-Allow-Headers': 'Content-Type, X-Requested-With',
     'Access-Control-Max-Age':       '86400',
@@ -24,7 +42,7 @@ export function corsHeaders(origin, siteDomain) {
 }
 
 // ── SHA-256 via WebCrypto (obrigatório no Cloudflare Workers) ─────────────────
-export async function sha256(value) {
+export async function sha256(value: string | null | undefined): Promise<string | undefined> {
   if (!value) return undefined;
   const clean = String(value).toLowerCase().trim();
   if (!clean) return undefined;
@@ -38,7 +56,7 @@ export async function sha256(value) {
 }
 
 // ── Normalização de telefone → somente dígitos + DDI 55 ──────────────────────
-export function normalizePhone(phone) {
+export function normalizePhone(phone: string | null | undefined): string | undefined {
   if (!phone) return undefined;
   let digits = String(phone).replace(/\D/g, '');
   if (digits.length === 11 && !digits.startsWith('55')) digits = '55' + digits;
@@ -47,7 +65,7 @@ export function normalizePhone(phone) {
 }
 
 // ── Normalização de cidade → lowercase sem acentos ────────────────────────────
-export function normalizeCity(city) {
+export function normalizeCity(city: string | null | undefined): string | undefined {
   if (!city) return undefined;
   return String(city)
     .toLowerCase()
@@ -57,13 +75,13 @@ export function normalizeCity(city) {
 }
 
 // ── Parse seguro de JSON armazenado como TEXT no D1 ───────────────────────────
-export function tryParseJson(str, fallback) {
+export function tryParseJson<T = any>(str: string | null, fallback?: T): T | null {
   if (!str) return fallback !== undefined ? fallback : null;
   try { return JSON.parse(str); } catch { return fallback !== undefined ? fallback : null; }
 }
 
 // ── Mapa Meta → GA4 event names ───────────────────────────────────────────────
-export const META_TO_GA4 = {
+export const META_TO_GA4: Record<string, string> = {
   PageView:             'page_view',
   ViewContent:          'view_item',
   Lead:                 'generate_lead',
@@ -100,18 +118,18 @@ export const FUNNEL_TAXONOMY = {
 };
 
 // Índice invertido: funnel_stage → depth (construído uma vez, zero custo em runtime)
-const _STAGE_TO_DEPTH = Object.entries(FUNNEL_TAXONOMY).reduce((acc, [depth, stages]) => {
-  stages.forEach(s => { acc[s] = depth; });
+const _STAGE_TO_DEPTH: Record<string, FunnelLevel> = Object.entries(FUNNEL_TAXONOMY).reduce((acc, [depth, stages]) => {
+  stages.forEach(s => { acc[s] = depth as FunnelLevel; });
   return acc;
-}, {});
+}, {} as Record<string, FunnelLevel>);
 
 /**
  * Resolve funnel_stage em funnelDepth semântico.
  * bottom_intent  = intenção forte (route_click, whatsapp_click)
  * bottom_conversion = ação confirmada (schedule_confirmed, lead_form)
  */
-export function resolveFunnelStage(funnel_stage) {
-  const depth = _STAGE_TO_DEPTH[funnel_stage] || 'unknown';
+export function resolveFunnelStage(funnel_stage: string | null | undefined): FunnelStageResult {
+  const depth = _STAGE_TO_DEPTH[funnel_stage || ''] || 'unknown';
   const funnelDepth = depth === 'conversion' ? 'bottom_conversion'
                     : depth === 'bottom'     ? 'bottom_intent'
                     : depth;
@@ -120,12 +138,12 @@ export function resolveFunnelStage(funnel_stage) {
 
 // ── Normalização de intent_score → 0.0–1.0 ───────────────────────────────────
 // Aceita: string ('high'/'medium'/'low'), numérico 0-1 ou numérico 0-100
-const _INTENT_STRING_MAP = { high: 0.92, medium: 0.65, low: 0.30 };
+const _INTENT_STRING_MAP: Record<string, number> = { high: 0.92, medium: 0.65, low: 0.30 };
 
-export function resolveIntentScore(value) {
+export function resolveIntentScore(value: string | number | null | undefined): number | null {
   if (value === null || value === undefined) return null;
   if (typeof value === 'string') return _INTENT_STRING_MAP[value.toLowerCase()] ?? null;
-  const num = parseFloat(value);
+  const num = parseFloat(String(value));
   if (isNaN(num)) return null;
   const normalized = num > 1 ? num / 100 : num;  // escala 0-100 → 0-1
   return Math.min(1, Math.max(0, Math.round(normalized * 100) / 100));
@@ -135,9 +153,9 @@ export function resolveIntentScore(value) {
  * Distância (distanceBucket) → peso numérico para meta_signal.
  * very_close=1.0 ... far=0.1 ... sem dado=0.3 (neutro)
  */
-export function distanceBucketWeight(bucket) {
-  const map = { very_close: 1.0, close: 0.75, nearby: 0.5, moderate: 0.25, far: 0.1 };
-  return map[bucket] ?? 0.3;
+export function distanceBucketWeight(bucket: string | null | undefined): number {
+  const map: Record<DistanceBucket, number> = { very_close: 1.0, close: 0.75, nearby: 0.5, moderate: 0.25, far: 0.1 };
+  return map[bucket as DistanceBucket] ?? 0.3;
 }
 
 /**
@@ -146,7 +164,7 @@ export function distanceBucketWeight(bucket) {
  * Topo: perfil pesa mais (ltv).
  * Default (mid/unknown): balanceado.
  */
-export function computeMetaSignalWeights(funnelLevel) {
+export function computeMetaSignalWeights(funnelLevel: FunnelLevel | string | null | undefined): MetaSignalWeights {
   if (funnelLevel === 'bottom' || funnelLevel === 'conversion') {
     return { intent: 0.5, ltv: 0.2, dist: 0.3 };
   }
@@ -160,7 +178,8 @@ export function computeMetaSignalWeights(funnelLevel) {
  * Quantiza meta_signal contínuo em bucket legível.
  * Usado em criação de públicos e leitura de BI.
  */
-export function metaSignalBucket(score) {
+export function metaSignalBucket(score: number | null | undefined): MetaSignalBucket {
+  if (!score) return 'cold';
   if (score >= 0.8) return 'hot';
   if (score >= 0.6) return 'warm';
   return 'cold';