cdp-edge 1.0.0

package/server-edge-tracker/modules/dispatch/ga4.ts

@@ -0,0 +1,72 @@
+/**
+ * CDP Edge — GA4 Measurement Protocol
+ * Envia eventos server-side para o GA4 via Measurement Protocol.
+ */
+
+import { normalizePhone } from '../utils.js';
+import { logApiFailure } from '../db.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
+
+export async function sendGA4Mp(env: Env, ga4EventName: string, payload: TrackPayload, ctx: ExecutionContext | null): Promise<{ ok?: boolean; status?: number; skipped?: string; error?: string }> {
+  if (!env.GA4_API_SECRET) return { skipped: 'GA4_API_SECRET not set' };
+
+  const {
+    gaClientId: clientId, sessionId,
+    value, currency, contentName,
+    email, phone, firstName,
+    orderId,
+  } = payload;
+
+  if (!clientId) return { skipped: 'no clientId' };
+
+  const eventParams: Record<string, string | number> = {
+    ...(value       !== undefined && { value: parseFloat(String(value)) }),
+    ...(currency    && { currency: String(currency).toUpperCase() }),
+    ...(contentName && { content_name: contentName }),
+    ...(orderId     && { transaction_id: orderId }),
+    ...(email       && { user_data_email_address: email.toLowerCase().trim() }),
+    ...(phone       && { user_data_phone_number: normalizePhone(phone) || '' }),
+    ...(firstName   && { user_data_first_name: firstName.toLowerCase().trim() }),
+    ...(sessionId   && { session_id: sessionId }),
+    engagement_time_msec: 100,
+  };
+
+  const body = {
+    client_id: clientId,
+    events: [{ name: ga4EventName, params: eventParams }],
+  };
+
+  const url = `https://www.google-analytics.com/mp/collect`
+            + `?measurement_id=${env.GA4_MEASUREMENT_ID}`
+            + `&api_secret=${env.GA4_API_SECRET}`;
+
+  try {
+    const res = await fetch(url, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify(body),
+    });
+
+    if (res.status !== 204) {
+      if (env.DB && ctx) {
+        ctx.waitUntil(logApiFailure(env.DB, 'ga4', ga4EventName, String(res.status), 'GA4 returned non-204 status', '', JSON.stringify(body)));
+      }
+    }
+
+    return res.status === 204 ? { ok: true } : { status: res.status };
+  } catch (err: any) {
+    console.error('GA4 MP fetch failed:', err?.message || String(err));
+
+    if (env.DB && ctx) {
+      ctx.waitUntil(logApiFailure(env.DB, 'ga4', ga4EventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    }
+
+    if (env.RETRY_QUEUE) {
+      const send = env.RETRY_QUEUE.send({ eventType: ga4EventName, payload, platform: 'ga4' });
+      if (ctx) ctx.waitUntil(send); else send.catch(() => {});
+    }
+
+    return { error: err?.message || String(err) };
+  }
+}

package/server-edge-tracker/modules/dispatch/meta.ts

@@ -0,0 +1,143 @@
+/**
+ * CDP Edge — Meta Conversions API v22.0
+ * Envia eventos server-side para a Meta CAPI.
+ */
+
+import { sha256, normalizePhone, normalizeCity } from '../utils.js';
+import { logApiFailure } from '../db.js';
+import { logMatchQuality, autoEnrichPayload } from '../ml/matchquality.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
+
+interface EnrichedPayload {
+  payload: TrackPayload;
+  recovered: { email: boolean; utm: boolean };
+}
+
+export async function sendMetaCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
+  // Auto-enriquecer payload com dados do Identity Graph antes do envio
+  let recovered = { email: false, utm: false };
+  if (env.DB && payload) {
+    const enriched  = await autoEnrichPayload(env, payload) as EnrichedPayload;
+    payload         = enriched.payload;
+    recovered       = enriched.recovered;
+  }
+
+  const {
+    email, phone, firstName, lastName,
+    city, state, country,
+    zip, dob,
+    fbp, fbc, userId,
+    eventId, pageUrl,
+    value, currency,
+    contentIds, contentName, contentType, numItems,
+    // Dual-layer context — funil avançado + imóveis
+    funnel_stage, distanceBucket: distance_bucket, intentScoreNum: intent_score, intent_bucket,
+    ltvScore, ltvClass, metaSignal, metaSignalBucket: metaSignalBucketVal,
+  } = payload;
+
+  const phoneNorm   = normalizePhone(phone);
+  const countryCode = (country || (request as any)?.cf?.country || 'br').toLowerCase();
+  const stateCode   = state ? String(state).toLowerCase() : undefined;
+  const cityNorm    = normalizeCity(city);
+
+  const userData: Record<string, string> = {
+    ...(email      && { em:       await sha256(email) || '' }),
+    ...(phoneNorm  && { ph:       await sha256(phoneNorm) || '' }),
+    ...(firstName  && { fn:       await sha256(firstName) || '' }),
+    ...(lastName   && { ln:       await sha256(lastName) || '' }),
+    ...(cityNorm   && { ct:       await sha256(cityNorm) || '' }),
+    ...(stateCode  && { st:       await sha256(stateCode) || '' }),
+    ...(countryCode && { country: await sha256(countryCode) || '' }),
+    ...(userId     && { external_id: await sha256(String(userId)) || '' }),
+    ...(zip        && { zp:         await sha256(zip) || '' }),
+    ...(dob        && { db:         await sha256(dob) || '' }),
+    ...(fbp        && { fbp }),
+    ...(fbc        && { fbc }),
+    client_ip_address: request?.headers.get('CF-Connecting-IP')
+                    || request?.headers.get('X-Forwarded-For')
+                    || '',
+    client_user_agent: request?.headers.get('User-Agent') || '',
+  };
+
+  const customData: Record<string, string | number | string[]> = {
+    ...(value       !== undefined && { value: parseFloat(String(value)) }),
+    ...(currency    && { currency: String(currency).toUpperCase() }),
+    ...(contentIds  && contentIds.length > 0 && { content_ids: contentIds }),
+    ...(contentName && { content_name: contentName }),
+    ...(contentType && { content_type: contentType }),
+    ...(numItems    && { num_items: parseInt(String(numItems)) }),
+    // Contexto de funil e proximidade — enriquece matching e otimização Meta
+    ...(funnel_stage    && { funnel_stage }),
+    ...(distance_bucket && { distance_bucket }),
+    ...(intent_score    && { intent_score }),
+    ...(ltvScore    !== undefined && ltvScore    !== null && { ltv_score: ltvScore }),
+    ...(ltvClass    && { ltv_class: ltvClass }),
+    ...(metaSignal       !== undefined && metaSignal       !== null && { meta_signal: metaSignal }),
+    ...(metaSignalBucketVal && { meta_signal_bucket: metaSignalBucketVal }),
+    ...(intent_bucket    && { intent_bucket }),
+  };
+
+  const eventPayload = {
+    event_name:       eventName,
+    event_time:       Math.floor(Date.now() / 1000),
+    event_id:         eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    event_source_url: pageUrl || `https://${env.SITE_DOMAIN}`,
+    action_source:    'website',
+    user_data:        userData,
+    ...(Object.keys(customData).length > 0 && { custom_data: customData }),
+  };
+
+  const requestBody: Record<string, any> = {
+    data:         [eventPayload],
+    access_token: env.META_ACCESS_TOKEN,
+  };
+
+  if (env.META_TEST_CODE) {
+    requestBody.test_event_code = env.META_TEST_CODE;
+  }
+
+  // Logar match quality em background (não bloqueia dispatch)
+  if (env.DB && ctx) {
+    ctx.waitUntil(logMatchQuality(env.DB, eventName, payload, recovered));
+  } else if (env.DB) {
+    logMatchQuality(env.DB, eventName, payload, recovered).catch(() => {});
+  }
+
+  const endpoint = `https://graph.facebook.com/v22.0/${env.META_PIXEL_ID}/events`;
+
+  try {
+    const res = await fetch(endpoint, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify(requestBody),
+    });
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      const errorCode    = (data as any).error?.code || String(res.status);
+      const errorMessage = (data as any).error?.message || (data as any).error?.error_user_msg || 'Unknown error';
+      console.error('Meta CAPI error:', res.status, errorMessage);
+
+      if (env.DB && ctx) {
+        ctx.waitUntil(logApiFailure(env.DB, 'meta', eventName, errorCode, errorMessage, eventPayload.event_id, JSON.stringify(requestBody)));
+      }
+    }
+
+    return data;
+  } catch (err: any) {
+    console.error('Meta CAPI fetch failed:', err?.message || String(err));
+
+    if (env.DB && ctx) {
+      ctx.waitUntil(logApiFailure(env.DB, 'meta', eventName, 'FETCH_ERROR', err?.message || String(err), eventPayload.event_id, JSON.stringify(requestBody)));
+    }
+
+    if (env.RETRY_QUEUE) {
+      const send = env.RETRY_QUEUE.send({ eventType: eventName, payload, platform: 'meta' });
+      if (ctx) ctx.waitUntil(send); else send.catch(() => {});
+    }
+
+    return { error: err?.message || String(err) };
+  }
+}

package/server-edge-tracker/modules/dispatch/platforms.ts

@@ -0,0 +1,255 @@
+/**
+ * CDP Edge — Plataformas Adicionais
+ * Pinterest CAPI v5, Reddit CAPI v2.0, LinkedIn CAPI 202401, Spotify CAPI v1
+ */
+
+import { sha256, normalizePhone } from '../utils.js';
+import { logApiFailure } from '../db.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
+
+// ── Pinterest Conversions API v5 ──────────────────────────────────────────────
+export async function sendPinterestCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
+  if (!env.PINTEREST_ACCESS_TOKEN || !env.PINTEREST_AD_ACCOUNT_ID) {
+    return { skipped: 'Pinterest credentials not set' };
+  }
+
+  const { email, phone, userId, eventId, pageUrl, value, currency, contentIds, contentName } = payload;
+  const phoneNorm = normalizePhone(phone);
+
+  const pinterestEventMap: Record<string, string> = {
+    PageView: 'pagevisit', ViewContent: 'pagevisit', Lead: 'lead', Purchase: 'checkout',
+    AddToCart: 'addtocart', InitiateCheckout: 'checkout', CompleteRegistration: 'signup',
+    Search: 'search', Contact: 'lead',
+  };
+  const pEvent = pinterestEventMap[eventName] || 'custom';
+
+  const userData: Record<string, string | string[]> = {
+    ...(email     && { em: [await sha256(email) || ''] }),
+    ...(phoneNorm && { ph: [await sha256(phoneNorm) || ''] }),
+    ...(userId    && { external_id: [await sha256(String(userId)) || ''] }),
+    client_ip_address: request?.headers.get('CF-Connecting-IP') || '',
+    client_user_agent: request?.headers.get('User-Agent') || '',
+  };
+
+  const body = {
+    data: [{
+      event_name:       pEvent,
+      action_source:    'web',
+      event_time:       Math.floor(Date.now() / 1000),
+      event_id:         eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      event_source_url: pageUrl || '',
+      user_data:        userData,
+      custom_data: {
+        currency:     (currency || 'BRL').toUpperCase(),
+        value:        value ? String(parseFloat(String(value))) : '0',
+        ...(contentIds && contentIds.length > 0 && { content_ids: contentIds.map(String) }),
+        ...(contentName            && { content_name: contentName }),
+        content_type: 'product',
+      },
+    }],
+  };
+
+  try {
+    const res = await fetch(
+      `https://api.pinterest.com/v5/ad_accounts/${env.PINTEREST_AD_ACCOUNT_ID}/events`,
+      { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${env.PINTEREST_ACCESS_TOKEN}` }, body: JSON.stringify(body) }
+    );
+    const data = await res.json();
+    if (!res.ok) {
+      const msg = (data as any).message || (data as any).code || String(res.status);
+      console.error('Pinterest CAPI error:', res.status, msg);
+      if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'pinterest', eventName, String(res.status), msg, (body.data as any)[0].event_id, JSON.stringify(body)));
+    }
+    return data;
+  } catch (err: any) {
+    console.error('Pinterest CAPI fetch failed:', err?.message || String(err));
+    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'pinterest', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    if (env.RETRY_QUEUE) {
+      const send = env.RETRY_QUEUE.send({ eventType: eventName, payload, platform: 'pinterest' });
+      if (ctx) ctx.waitUntil(send); else send.catch(() => {});
+    }
+    return { error: err?.message || String(err) };
+  }
+}
+
+// ── Reddit Conversions API v2.0 ───────────────────────────────────────────────
+export async function sendRedditCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
+  if (!env.REDDIT_ACCESS_TOKEN || !env.REDDIT_AD_ACCOUNT_ID) {
+    return { skipped: 'Reddit credentials not set' };
+  }
+
+  const { email, phone, userId, eventId, pageUrl, value, currency } = payload;
+  const phoneNorm = normalizePhone(phone);
+
+  const redditEventMap: Record<string, string> = {
+    PageView: 'PageVisit', ViewContent: 'ViewContent', Lead: 'Lead', Purchase: 'Purchase',
+    AddToCart: 'AddToCart', InitiateCheckout: 'Purchase', CompleteRegistration: 'SignUp',
+    Search: 'Search', Contact: 'Lead',
+  };
+  const rEvent = redditEventMap[eventName] || 'Custom';
+
+  const user: Record<string, { value: string }> = {
+    ...(email     && { email:       { value: await sha256(email) || '' } }),
+    ...(phoneNorm && { phoneNumber: { value: await sha256(phoneNorm) || '' } }),
+    ...(userId    && { externalId:  { value: await sha256(String(userId)) || '' } }),
+    ipAddress: { value: request?.headers.get('CF-Connecting-IP') || '' },
+    userAgent: { value: request?.headers.get('User-Agent') || '' },
+  };
+
+  const event: Record<string, any> = {
+    event_at:   new Date().toISOString(),
+    event_type: { tracking_type: rEvent, ...(eventName === 'InitiateCheckout' && { conversion_type: 'BEGIN_CHECKOUT' }) },
+    click_id:   (payload as any).rdtClid || '',
+    event_metadata: {
+      currency:      (currency || 'BRL').toUpperCase(),
+      value_decimal: String(value || 0),
+      item_count:    '1',
+      conversion_id: eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    },
+    user,
+  };
+
+  const body = { events: [event] };
+
+  try {
+    const res = await fetch(
+      `https://ads-api.reddit.com/api/v2.0/conversions/events/${env.REDDIT_AD_ACCOUNT_ID}`,
+      { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${env.REDDIT_ACCESS_TOKEN}` }, body: JSON.stringify(body) }
+    );
+    if (!res.ok) {
+      const txt = await res.text();
+      console.error('Reddit CAPI error:', txt);
+      if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'reddit', eventName, String(res.status), txt, event.event_metadata.conversion_id, JSON.stringify(body)));
+      return { error: `HTTP ${res.status}` };
+    }
+    return await res.json();
+  } catch (err: any) {
+    console.error('Reddit CAPI fetch failed:', err?.message || String(err));
+    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'reddit', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    if (env.RETRY_QUEUE) {
+      const send = env.RETRY_QUEUE.send({ eventType: eventName, payload, platform: 'reddit' });
+      if (ctx) ctx.waitUntil(send); else send.catch(() => {});
+    }
+    return { error: err?.message || String(err) };
+  }
+}
+
+// ── LinkedIn Conversions API (LinkedIn-Version: 202401) ───────────────────────
+export async function sendLinkedInCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
+  if (!env.LINKEDIN_ACCESS_TOKEN || !env.LINKEDIN_CONVERSION_ID) {
+    return { skipped: 'LinkedIn credentials not set' };
+  }
+
+  const { email, phone, firstName, lastName, userId, eventId, pageUrl, value, currency } = payload;
+  const phoneNorm = normalizePhone(phone);
+
+  const linkedInEventMap: Record<string, string> = {
+    Lead: 'LEAD', Purchase: 'PURCHASE', CompleteRegistration: 'REGISTRATION',
+    AddToCart: 'ADD_TO_CART', InitiateCheckout: 'OTHER', ViewContent: 'OTHER',
+    PageView: 'OTHER', Contact: 'LEAD',
+  };
+
+  const userInfo: Record<string, string> = {
+    ...(email     && { 'SHA256_EMAIL':      await sha256(email) || '' }),
+    ...(phoneNorm && { 'SHA256_PHONE':      await sha256(phoneNorm) || '' }),
+    ...(firstName && { 'SHA256_FIRST_NAME': await sha256(firstName.toLowerCase().trim()) || '' }),
+    ...(lastName  && { 'SHA256_LAST_NAME':  await sha256(lastName.toLowerCase().trim()) || '' }),
+  };
+
+  const body: Record<string, any> = {
+    conversion:    `urn:li:conversion:${env.LINKEDIN_CONVERSION_ID}`,
+    conversionHappenedAt: Date.now(),
+    conversionValue: value ? { currencyCode: (currency || 'BRL').toUpperCase(), amount: String(parseFloat(String(value))) } : undefined,
+    eventId: eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    ...(Object.keys(userInfo).length > 0 && { user: { userIds: Object.entries(userInfo).map(([idType, idValue]) => ({ idType, idValue })) } }),
+  };
+
+  try {
+    const res = await fetch('https://api.linkedin.com/rest/conversionEvents', {
+      method:  'POST',
+      headers: {
+        'Content-Type':              'application/json',
+        Authorization:               `Bearer ${env.LINKEDIN_ACCESS_TOKEN}`,
+        'LinkedIn-Version':          '202401',
+        'X-Restli-Protocol-Version': '2.0.0',
+      },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const txt = await res.text();
+      console.error('LinkedIn CAPI error:', txt);
+      if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'linkedin', eventName, String(res.status), txt, body.eventId, JSON.stringify(body)));
+      return { error: `HTTP ${res.status}` };
+    }
+    return { ok: true };
+  } catch (err: any) {
+    console.error('LinkedIn CAPI fetch failed:', err?.message || String(err));
+    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'linkedin', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    if (env.RETRY_QUEUE) {
+      const send = env.RETRY_QUEUE.send({ eventType: eventName, payload, platform: 'linkedin' });
+      if (ctx) ctx.waitUntil(send); else send.catch(() => {});
+    }
+    return { error: err?.message || String(err) };
+  }
+}
+
+// ── Spotify Conversions API v1 ────────────────────────────────────────────────
+export async function sendSpotifyCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
+  if (!env.SPOTIFY_ACCESS_TOKEN || !env.SPOTIFY_AD_ACCOUNT_ID) {
+    return { skipped: 'Spotify credentials not set' };
+  }
+
+  const { email, phone, userId, eventId, pageUrl, value, currency } = payload;
+  const phoneNorm = normalizePhone(phone);
+
+  const spotifyEventMap: Record<string, string> = {
+    Purchase: 'PURCHASE', Lead: 'LEAD', CompleteRegistration: 'SIGN_UP',
+    AddToCart: 'ADD_TO_CART', InitiateCheckout: 'INITIATE_CHECKOUT',
+    ViewContent: 'VIEW_CONTENT', PageView: 'PAGE_VIEW', Contact: 'LEAD',
+  };
+  const spEvent = spotifyEventMap[eventName] || 'CUSTOM';
+
+  const user: Record<string, string> = {
+    ...(email     && { hashed_email: await sha256(email) || '' }),
+    ...(phoneNorm && { hashed_phone: await sha256(phoneNorm) || '' }),
+    ...(userId    && { user_id: userId }),
+    ip_address: request?.headers.get('CF-Connecting-IP') || '',
+    user_agent: request?.headers.get('User-Agent') || '',
+  };
+
+  const body = {
+    data: [{
+      event_id:   eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      event_type: spEvent,
+      event_time: Math.floor(Date.now() / 1000),
+      url:        pageUrl || '',
+      user,
+      ...(value !== undefined && {
+        value: { currency: (currency || 'BRL').toUpperCase(), amount: parseFloat(String(value)) },
+      }),
+    }],
+  };
+
+  try {
+    const res = await fetch(
+      `https://advertising-api.spotify.com/conversion/v1/accounts/${env.SPOTIFY_AD_ACCOUNT_ID}/events`,
+      { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${env.SPOTIFY_ACCESS_TOKEN}` }, body: JSON.stringify(body) }
+    );
+    if (!res.ok) {
+      const txt = await res.text();
+      console.error('Spotify CAPI error:', txt);
+      if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'spotify', eventName, String(res.status), txt, (body.data as any)[0].event_id, JSON.stringify(body)));
+      return { error: `HTTP ${res.status}` };
+    }
+    return await res.json();
+  } catch (err: any) {
+    console.error('Spotify CAPI fetch failed:', err?.message || String(err));
+    if (env.DB && ctx) ctx.waitUntil(logApiFailure(env.DB, 'spotify', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    if (env.RETRY_QUEUE) {
+      const send = env.RETRY_QUEUE.send({ eventType: eventName, payload, platform: 'spotify' });
+      if (ctx) ctx.waitUntil(send); else send.catch(() => {});
+    }
+    return { error: err?.message || String(err) };
+  }
+}

package/server-edge-tracker/modules/dispatch/tiktok.ts

@@ -0,0 +1,107 @@
+/**
+ * CDP Edge — TikTok Events API v1.3
+ * Envia eventos server-side para a TikTok Events API.
+ */
+
+import { sha256, normalizePhone } from '../utils.js';
+import { logApiFailure } from '../db.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
+
+export async function sendTikTokApi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
+  if (!env.TIKTOK_ACCESS_TOKEN) return { skipped: 'TIKTOK_ACCESS_TOKEN not set' };
+
+  const pixelId = env.TIKTOK_PIXEL_ID;
+  if (!pixelId || pixelId === 'SEU_TIKTOK_PIXEL_ID') return { skipped: 'TIKTOK_PIXEL_ID not configured' };
+
+  const {
+    email, phone, firstName, lastName,
+    fbp, fbc, ttp, ttclid, userId,
+    eventId, pageUrl,
+    value, currency,
+    contentIds, contentName, contentType,
+  } = payload;
+
+  const phoneNorm = normalizePhone(phone);
+
+  const user: Record<string, string> = {
+    ...(email      && { email:        await sha256(email) || '' }),
+    ...(phoneNorm  && { phone_number: await sha256(phoneNorm) || '' }),
+    ...(userId     && { external_id:  await sha256(String(userId)) || '' }),
+    ...(ttp        && { ttp }),
+    ...(ttclid     && { ttclid }),
+  };
+
+  const properties: Record<string, any> = {
+    ...(value       !== undefined && { value: parseFloat(String(value)) }),
+    ...(currency    && { currency: String(currency).toUpperCase() }),
+    ...(contentIds  && contentIds && contentIds.length > 0 && {
+      contents: contentIds.map(id => ({
+        content_id:   String(id),
+        content_name: contentName || '',
+        content_type: contentType || 'product',
+        quantity:     1,
+        price:        value ? parseFloat(String(value)) : 0,
+      })),
+    }),
+  };
+
+  const event: Record<string, any> = {
+    event:      eventName,
+    event_time: Math.floor(Date.now() / 1000),
+    event_id:   eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    user,
+    page: {
+      url:      pageUrl || `https://${env.SITE_DOMAIN}`,
+      referrer: request?.headers.get('Referer') || '',
+    },
+    ...(Object.keys(properties).length > 0 && { properties }),
+    context: {
+      ip:         request?.headers.get('CF-Connecting-IP') || '',
+      user_agent: request?.headers.get('User-Agent') || '',
+    },
+  };
+
+  const body = {
+    event_source:    'web',
+    event_source_id: pixelId,
+    data:            [event],
+  };
+
+  // Endpoint canônico: sempre /v1.3/event/track/
+  const endpoint = 'https://business-api.tiktok.com/open_api/v1.3/event/track/';
+
+  try {
+    const res = await fetch(endpoint, {
+      method:  'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Access-Token':  env.TIKTOK_ACCESS_TOKEN,
+      },
+      body: JSON.stringify(body),
+    });
+
+    const data = await res.json();
+    if (!res.ok || (data as any).code !== 0) {
+      console.error('TikTok Events API error:', res.status, (data as any).message || (data as any).code || 'unknown');
+
+      if (env.DB && ctx) {
+        ctx.waitUntil(logApiFailure(env.DB, 'tiktok', eventName, String((data as any).code || res.status), (data as any).message || 'TikTok API error', event.event_id, JSON.stringify(body)));
+      }
+    }
+    return data;
+  } catch (err: any) {
+    console.error('TikTok Events API fetch failed:', err?.message || String(err));
+
+    if (env.DB && ctx) {
+      ctx.waitUntil(logApiFailure(env.DB, 'tiktok', eventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
+    }
+
+    if (env.RETRY_QUEUE) {
+      const send = env.RETRY_QUEUE.send({ eventType: eventName, payload, platform: 'tiktok' });
+      if (ctx) ctx.waitUntil(send); else send.catch(() => {});
+    }
+
+    return { error: err?.message || String(err) };
+  }
+}