mcp-scraper 0.67.0 → 0.68.0

package/dist/{chunk-CNLLTD5B.js → chunk-SZEDXVJH.js}

@@ -1,5 +1,10 @@
+import {
+  getDb,
+  getUserByEmail
+} from "./chunk-65FTMB7G.js";
+
 // src/api/analytics-repository.ts
-import { createHash, createHmac as createHmac2, randomBytes, randomUUID } from "crypto";
+import { createHash, createHmac as createHmac2, randomBytes, randomUUID as randomUUID2 } from "crypto";
 import { Pool } from "pg";
 
 // src/api/session.ts
@@ -111,6 +116,823 @@ function resolveAnalyticsAttribution(input) {
   };
 }
 
+// src/api/service-connections.ts
+import { randomUUID } from "crypto";
+function serviceConnectionAdvertisesAction(connection, providerConfigKeys, actionName) {
+  return connection.lifecycleStatus === "connected" && connection.actionsEnabled && providerConfigKeys.includes(connection.providerConfigKey) && connection.actionTools.includes(actionName);
+}
+var schemaReady = null;
+var schemaDb = null;
+function ensureServiceConnectionsSchema() {
+  const currentDb = getDb();
+  if (schemaReady && schemaDb === currentDb) return schemaReady;
+  schemaDb = currentDb;
+  schemaReady = (async () => {
+    const db = currentDb;
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connections (
+        id                         TEXT PRIMARY KEY,
+        user_id                    INTEGER NOT NULL REFERENCES users(id),
+        provider_config_key        TEXT NOT NULL,
+        provider                   TEXT,
+        transport                  TEXT NOT NULL,
+        upstream_connection_id     TEXT,
+        label                      TEXT,
+        user_label                 TEXT,
+        provider_account_id        TEXT,
+        provider_account_email     TEXT,
+        provider_account_name      TEXT,
+        provider_identity_checked_at TEXT,
+        provider_identity_source_updated_at TEXT,
+        lifecycle_status           TEXT NOT NULL DEFAULT 'pending',
+        operational_status         TEXT NOT NULL DEFAULT 'unknown',
+        reconnect_required         INTEGER NOT NULL DEFAULT 0,
+        actions_enabled            INTEGER NOT NULL DEFAULT 0,
+        read_tools_json            TEXT NOT NULL DEFAULT '[]',
+        action_tools_json          TEXT NOT NULL DEFAULT '[]',
+        tool_revision              TEXT,
+        last_checked_at            TEXT,
+        last_successful_call_at    TEXT,
+        last_failure_at            TEXT,
+        last_failure_code          TEXT,
+        last_failure_retryable     INTEGER,
+        consecutive_failures       INTEGER NOT NULL DEFAULT 0,
+        vault_name                 TEXT,
+        table_name                 TEXT,
+        legacy_owner_identity      TEXT,
+        created_at                 TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at                 TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(user_id, provider_config_key, upstream_connection_id)
+      )
+    `);
+    try {
+      await db.execute(`ALTER TABLE service_connections ADD COLUMN user_label TEXT`);
+    } catch {
+    }
+    try {
+      await db.execute(`ALTER TABLE service_connections ADD COLUMN provider_account_id TEXT`);
+    } catch {
+    }
+    try {
+      await db.execute(`ALTER TABLE service_connections ADD COLUMN provider_account_email TEXT`);
+    } catch {
+    }
+    try {
+      await db.execute(`ALTER TABLE service_connections ADD COLUMN provider_account_name TEXT`);
+    } catch {
+    }
+    try {
+      await db.execute(`ALTER TABLE service_connections ADD COLUMN provider_identity_checked_at TEXT`);
+    } catch {
+    }
+    try {
+      await db.execute(`ALTER TABLE service_connections ADD COLUMN provider_identity_source_updated_at TEXT`);
+    } catch {
+    }
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connections_user_updated ON service_connections(user_id, updated_at DESC)`);
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connections_upstream ON service_connections(provider_config_key, upstream_connection_id)`);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connection_health_events (
+        id                    TEXT PRIMARY KEY,
+        connection_id         TEXT NOT NULL REFERENCES service_connections(id) ON DELETE CASCADE,
+        operational_status    TEXT NOT NULL,
+        failure_code          TEXT,
+        retryable             INTEGER,
+        evidence_source       TEXT NOT NULL,
+        created_at            TEXT NOT NULL DEFAULT (datetime('now'))
+      )
+    `);
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connection_health_events_connection ON service_connection_health_events(connection_id, created_at DESC)`);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connection_action_audit (
+        id                    TEXT PRIMARY KEY,
+        connection_id         TEXT NOT NULL REFERENCES service_connections(id) ON DELETE CASCADE,
+        user_id               INTEGER NOT NULL REFERENCES users(id),
+        tool                  TEXT NOT NULL,
+        request_id            TEXT NOT NULL,
+        status                TEXT NOT NULL,
+        error_code            TEXT,
+        created_at            TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(user_id, request_id)
+      )
+    `);
+    try {
+      await db.execute(`ALTER TABLE service_connection_action_audit ADD COLUMN request_digest TEXT`);
+    } catch {
+    }
+    try {
+      await db.execute(`ALTER TABLE service_connection_action_audit ADD COLUMN result_json TEXT`);
+    } catch {
+    }
+  })().catch((error) => {
+    schemaReady = null;
+    schemaDb = null;
+    throw error;
+  });
+  return schemaReady;
+}
+function parseTools(value) {
+  if (typeof value !== "string") return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function rowToRecord(row) {
+  return {
+    id: String(row.id),
+    userId: Number(row.user_id),
+    providerConfigKey: String(row.provider_config_key),
+    provider: typeof row.provider === "string" ? row.provider : null,
+    transport: row.transport === "remote_mcp" ? "remote_mcp" : "nango",
+    upstreamConnectionId: typeof row.upstream_connection_id === "string" ? row.upstream_connection_id : null,
+    label: typeof row.label === "string" ? row.label : null,
+    userLabel: typeof row.user_label === "string" ? row.user_label : null,
+    providerAccountId: typeof row.provider_account_id === "string" ? row.provider_account_id : null,
+    providerAccountEmail: typeof row.provider_account_email === "string" ? row.provider_account_email : null,
+    providerAccountName: typeof row.provider_account_name === "string" ? row.provider_account_name : null,
+    providerIdentityCheckedAt: typeof row.provider_identity_checked_at === "string" ? row.provider_identity_checked_at : null,
+    providerIdentitySourceUpdatedAt: typeof row.provider_identity_source_updated_at === "string" ? row.provider_identity_source_updated_at : null,
+    lifecycleStatus: String(row.lifecycle_status),
+    operationalStatus: String(row.operational_status),
+    reconnectRequired: Number(row.reconnect_required) === 1,
+    actionsEnabled: Number(row.actions_enabled) === 1,
+    readTools: parseTools(row.read_tools_json),
+    actionTools: parseTools(row.action_tools_json),
+    toolRevision: typeof row.tool_revision === "string" ? row.tool_revision : null,
+    lastCheckedAt: typeof row.last_checked_at === "string" ? row.last_checked_at : null,
+    lastSuccessfulCallAt: typeof row.last_successful_call_at === "string" ? row.last_successful_call_at : null,
+    lastFailureAt: typeof row.last_failure_at === "string" ? row.last_failure_at : null,
+    lastFailureCode: typeof row.last_failure_code === "string" ? row.last_failure_code : null,
+    lastFailureRetryable: row.last_failure_retryable === null || row.last_failure_retryable === void 0 ? null : Number(row.last_failure_retryable) === 1,
+    consecutiveFailures: Number(row.consecutive_failures ?? 0),
+    vaultName: typeof row.vault_name === "string" ? row.vault_name : null,
+    tableName: typeof row.table_name === "string" ? row.table_name : null,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
+async function userIdForIdentity(identity) {
+  const user = await getUserByEmail(identity.normalize("NFKC").trim().toLowerCase());
+  if (!user) throw new Error("service_connection_user_not_found");
+  return Number(user.id);
+}
+async function reconcileDiscoveredNangoConnections(identity, discovered) {
+  await ensureServiceConnectionsSchema();
+  const db = getDb();
+  const userId = await userIdForIdentity(identity);
+  for (const connection of discovered) {
+    await db.execute({
+      sql: `
+        INSERT INTO service_connections (
+          id, user_id, provider_config_key, provider, transport, upstream_connection_id,
+          label, lifecycle_status, reconnect_required, actions_enabled, legacy_owner_identity, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, 'nango', ?, ?, ?, ?, 1, ?, COALESCE(?, datetime('now')), COALESCE(?, datetime('now')))
+        ON CONFLICT(user_id, provider_config_key, upstream_connection_id) DO UPDATE SET
+          provider = excluded.provider,
+          label = COALESCE(excluded.label, service_connections.label),
+          lifecycle_status = excluded.lifecycle_status,
+          reconnect_required = excluded.reconnect_required,
+          updated_at = excluded.updated_at
+      `,
+      args: [
+        randomUUID(),
+        userId,
+        connection.providerConfigKey,
+        connection.provider,
+        connection.upstreamConnectionId,
+        connection.label,
+        connection.lifecycleStatus,
+        connection.reconnectRequired ? 1 : 0,
+        identity,
+        connection.createdAt,
+        connection.updatedAt
+      ]
+    });
+  }
+  return listServiceConnections(identity, "nango");
+}
+async function listServiceConnections(identity, transport) {
+  await ensureServiceConnectionsSchema();
+  const userId = await userIdForIdentity(identity);
+  const result = await getDb().execute({
+    sql: `SELECT * FROM service_connections WHERE user_id = ?${transport ? " AND transport = ?" : ""} AND lifecycle_status <> 'disconnected' ORDER BY updated_at DESC`,
+    args: transport ? [userId, transport] : [userId]
+  });
+  return result.rows.map((row) => rowToRecord(row));
+}
+async function getOwnedServiceConnection(identity, connectionId) {
+  await ensureServiceConnectionsSchema();
+  const userId = await userIdForIdentity(identity);
+  const result = await getDb().execute({
+    sql: "SELECT * FROM service_connections WHERE id = ? AND user_id = ? LIMIT 1",
+    args: [connectionId, userId]
+  });
+  const row = result.rows[0];
+  return row ? rowToRecord(row) : null;
+}
+async function updateServiceConnectionTools(connectionId, readTools, actionTools, toolRevision) {
+  await ensureServiceConnectionsSchema();
+  await getDb().execute({
+    sql: `UPDATE service_connections SET read_tools_json = ?, action_tools_json = ?, tool_revision = ?, updated_at = datetime('now') WHERE id = ?`,
+    args: [JSON.stringify(readTools), JSON.stringify(actionTools), toolRevision, connectionId]
+  });
+}
+async function setServiceConnectionProviderIdentity(args) {
+  await ensureServiceConnectionsSchema();
+  await getDb().execute({
+    sql: `
+      UPDATE service_connections SET
+        provider_account_id = ?, provider_account_email = ?, provider_account_name = ?,
+        provider_identity_checked_at = datetime('now'), provider_identity_source_updated_at = ?,
+        updated_at = datetime('now')
+      WHERE id = ?
+    `,
+    args: [
+      args.providerAccountId ?? null,
+      args.providerAccountEmail?.toLowerCase() ?? null,
+      args.providerAccountName ?? null,
+      args.sourceUpdatedAt,
+      args.connectionId
+    ]
+  });
+}
+async function setServiceConnectionUserLabel(identity, connectionId, userLabel) {
+  const connection = await getOwnedServiceConnection(identity, connectionId);
+  if (!connection || connection.lifecycleStatus === "disconnected") throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connections SET user_label = ?, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
+    args: [userLabel, connectionId, connection.userId]
+  });
+  return userLabel;
+}
+async function recordServiceConnectionHealth(args) {
+  await ensureServiceConnectionsSchema();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await getDb().execute({
+    sql: `
+      UPDATE service_connections SET
+        operational_status = ?, last_checked_at = ?,
+        last_successful_call_at = CASE WHEN ? = 'available' THEN ? ELSE last_successful_call_at END,
+        last_failure_at = CASE WHEN ? IN ('degraded', 'unavailable') THEN ? ELSE NULL END,
+        last_failure_code = ?, last_failure_retryable = ?,
+        consecutive_failures = CASE WHEN ? = 'available' THEN 0 ELSE consecutive_failures + 1 END,
+        updated_at = datetime('now')
+      WHERE id = ?
+    `,
+    args: [
+      args.operationalStatus,
+      now,
+      args.operationalStatus,
+      now,
+      args.operationalStatus,
+      now,
+      args.failureCode ?? null,
+      args.retryable == null ? null : args.retryable ? 1 : 0,
+      args.operationalStatus,
+      args.connectionId
+    ]
+  });
+  await getDb().execute({
+    sql: `INSERT INTO service_connection_health_events (id, connection_id, operational_status, failure_code, retryable, evidence_source) VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [randomUUID(), args.connectionId, args.operationalStatus, args.failureCode ?? null, args.retryable == null ? null : args.retryable ? 1 : 0, args.evidenceSource]
+  });
+}
+async function setServiceConnectionActions(identity, connectionId, enabled) {
+  const connection = await getOwnedServiceConnection(identity, connectionId);
+  if (!connection || connection.lifecycleStatus === "disconnected") throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connections SET actions_enabled = ?, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
+    args: [enabled ? 1 : 0, connectionId, connection.userId]
+  });
+  return enabled;
+}
+async function markServiceConnectionDisconnected(identity, connectionId) {
+  const connection = await getOwnedServiceConnection(identity, connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connections SET lifecycle_status = 'disconnected', operational_status = 'unknown', reconnect_required = 0, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
+    args: [connectionId, connection.userId]
+  });
+  const remaining = await getDb().execute({
+    sql: `SELECT COUNT(*) AS count FROM service_connections WHERE user_id = ? AND transport = 'nango' AND lifecycle_status = 'connected'`,
+    args: [connection.userId]
+  });
+  return Number(remaining.rows[0]?.count ?? 0);
+}
+async function recordServiceConnectionAction(args) {
+  await ensureServiceConnectionsSchema();
+  const connection = await getOwnedServiceConnection(args.identity, args.connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connection_action_audit SET status = ?, error_code = ?, result_json = ? WHERE user_id = ? AND request_id = ? AND connection_id = ?`,
+    args: [args.status, args.errorCode ?? null, args.result === void 0 ? null : JSON.stringify(args.result), connection.userId, args.requestId, connection.id]
+  });
+}
+async function claimServiceConnectionAction(args) {
+  await ensureServiceConnectionsSchema();
+  const connection = await getOwnedServiceConnection(args.identity, args.connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  const inserted = await getDb().execute({
+    sql: `INSERT OR IGNORE INTO service_connection_action_audit (id, connection_id, user_id, tool, request_id, status, request_digest) VALUES (?, ?, ?, ?, ?, 'started', ?)`,
+    args: [randomUUID(), connection.id, connection.userId, args.tool, args.requestId, args.requestDigest]
+  });
+  if (Number(inserted.rowsAffected ?? 0) === 1) return { claimed: true };
+  const existing = await getDb().execute({
+    sql: `SELECT connection_id, tool, status, error_code, request_digest, result_json FROM service_connection_action_audit WHERE user_id = ? AND request_id = ? LIMIT 1`,
+    args: [connection.userId, args.requestId]
+  });
+  const row = existing.rows[0];
+  const conflict = String(row?.connection_id ?? "") !== connection.id || String(row?.tool ?? "") !== args.tool || String(row?.request_digest ?? "") !== args.requestDigest;
+  let result = void 0;
+  if (!conflict && typeof row?.result_json === "string") {
+    try {
+      result = JSON.parse(row.result_json);
+    } catch {
+      result = void 0;
+    }
+  }
+  return {
+    claimed: false,
+    status: String(row?.status ?? "unknown"),
+    errorCode: typeof row?.error_code === "string" ? row.error_code : null,
+    conflict,
+    ...result !== void 0 ? { result } : {}
+  };
+}
+
+// src/api/analytics-provider-registry.ts
+var META_ACTION_SOURCES = /* @__PURE__ */ new Set([
+  "email",
+  "website",
+  "app",
+  "phone_call",
+  "chat",
+  "physical_store",
+  "system_generated",
+  "business_messaging",
+  "other"
+]);
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function boundedString(value, max = 2048) {
+  return typeof value === "string" && value.trim() ? value.trim().slice(0, max) : void 0;
+}
+function metaEventTime(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.trunc(value > 1e10 ? value / 1e3 : value);
+  }
+  if (typeof value === "string") {
+    const milliseconds = Date.parse(value);
+    if (Number.isFinite(milliseconds) && milliseconds > 0) {
+      return Math.trunc(milliseconds / 1e3);
+    }
+  }
+  return Math.trunc(Date.now() / 1e3);
+}
+function googleEventTime(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return new Date(value < 1e10 ? value * 1e3 : value).toISOString();
+  }
+  if (typeof value === "string") {
+    const milliseconds = Date.parse(value);
+    if (Number.isFinite(milliseconds) && milliseconds > 0) return new Date(milliseconds).toISOString();
+  }
+  throw new AnalyticsProviderRegistryError(
+    "analytics_provider_destination_required",
+    "Google Data Manager requires a valid eventTimestamp."
+  );
+}
+function eventTimeMilliseconds(value, provider) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.trunc(value < 1e10 ? value * 1e3 : value);
+  }
+  if (typeof value === "string") {
+    const milliseconds = Date.parse(value);
+    if (Number.isFinite(milliseconds) && milliseconds > 0) return Math.trunc(milliseconds);
+  }
+  throw new AnalyticsProviderRegistryError(
+    "analytics_provider_destination_required",
+    `${provider} requires a valid event timestamp.`
+  );
+}
+function sha256Value(value) {
+  const candidate = boundedString(value, 64)?.toLowerCase();
+  return candidate && /^[a-f0-9]{64}$/.test(candidate) ? candidate : void 0;
+}
+function googleConsent(payload) {
+  const consent = recordValue(payload.consent);
+  const adUserData = consent.adUserData === "granted" ? "CONSENT_GRANTED" : consent.adUserData === "denied" ? "CONSENT_DENIED" : void 0;
+  const adPersonalization = consent.adPersonalization === "granted" ? "CONSENT_GRANTED" : consent.adPersonalization === "denied" ? "CONSENT_DENIED" : void 0;
+  return adUserData ? { adUserData, ...adPersonalization ? { adPersonalization } : {} } : void 0;
+}
+function buildGoogleDeliveryRequest(destinationId, payload) {
+  const operatingAccountId = boundedString(
+    payload.operatingAccountId ?? payload.googleAdsCustomerId ?? payload.customerId,
+    256
+  );
+  if (!operatingAccountId) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      "A Google Ads operating account ID is required for Data Manager activation."
+    );
+  }
+  const transactionId = boundedString(
+    payload.transactionId ?? payload.orderId ?? payload.eventId,
+    256
+  );
+  if (!transactionId) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      "A stable transactionId, orderId, or eventId is required for Google deduplication."
+    );
+  }
+  const clickIds = recordValue(payload.clickIds);
+  const match = recordValue(payload.match);
+  const gclid = boundedString(clickIds.gclid, 2e3);
+  const gbraid = boundedString(clickIds.gbraid, 2e3);
+  const wbraid = boundedString(clickIds.wbraid, 2e3);
+  const emailSha256 = boundedString(match.emailSha256, 64);
+  const phoneSha256 = boundedString(match.phoneSha256, 64);
+  if (!gclid && !gbraid && !wbraid && !emailSha256 && !phoneSha256) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      "Google Data Manager requires a click identifier or normalized SHA-256 user identifier."
+    );
+  }
+  const valueMinor = typeof payload.valueMinor === "number" && Number.isSafeInteger(payload.valueMinor) && payload.valueMinor >= 0 ? payload.valueMinor : void 0;
+  const currency = boundedString(payload.currency, 3)?.toUpperCase();
+  const actionSource = boundedString(payload.actionSource, 64);
+  const consent = googleConsent(payload);
+  return {
+    operatingAccountId,
+    ...boundedString(payload.loginAccountId, 256) ? { loginAccountId: boundedString(payload.loginAccountId, 256) } : {},
+    conversionActionId: destinationId,
+    events: [{
+      eventTimestamp: googleEventTime(payload.eventTime ?? payload.eventTimestamp),
+      transactionId,
+      eventSource: actionSource === "phone_call" ? "PHONE" : actionSource === "app" ? "APP" : "WEB",
+      ...gclid ? { gclid } : {},
+      ...gbraid ? { gbraid } : {},
+      ...wbraid ? { wbraid } : {},
+      ...emailSha256 ? { emailSha256: [emailSha256] } : {},
+      ...phoneSha256 ? { phoneSha256: [phoneSha256] } : {},
+      ...valueMinor !== void 0 && currency ? { conversionValue: valueMinor / 100, currency } : {},
+      ...consent ? { consent } : {}
+    }],
+    ...consent ? { consent } : {},
+    validateOnly: false
+  };
+}
+function metaNetworkRetentionPermits(payload) {
+  const consent = recordValue(payload.consent);
+  const retentionUntil = boundedString(payload.networkDataRetentionUntil, 64);
+  const retentionExpiry = retentionUntil ? Date.parse(retentionUntil) : Number.NaN;
+  return consent.analytics === "granted" && consent.adUserData === "granted" && consent.globalPrivacyControl !== true && Number.isFinite(retentionExpiry) && retentionExpiry > Date.now();
+}
+function metaUserData(payload) {
+  const match = recordValue(payload.match);
+  const clickIds = recordValue(payload.clickIds);
+  const emailSha256 = boundedString(match.emailSha256, 64);
+  const phoneSha256 = boundedString(match.phoneSha256, 64);
+  const fbp = boundedString(clickIds.fbp, 255);
+  const fbc = boundedString(clickIds.fbc, 255);
+  const userData = {
+    ...emailSha256 ? { em: [emailSha256] } : {},
+    ...phoneSha256 ? { ph: [phoneSha256] } : {},
+    ...fbp ? { fbp } : {},
+    ...fbc ? { fbc } : {}
+  };
+  if (metaNetworkRetentionPermits(payload)) {
+    const clientIpAddress = boundedString(match.clientIpAddress, 64);
+    const clientUserAgent = boundedString(match.clientUserAgent, 1e3);
+    if (clientIpAddress) userData.client_ip_address = clientIpAddress;
+    if (clientUserAgent) userData.client_user_agent = clientUserAgent;
+  }
+  return userData;
+}
+function buildMetaDeliveryRequest(destinationId, eventName, payload) {
+  const actionSource = boundedString(payload.actionSource, 64);
+  const valueMinor = typeof payload.valueMinor === "number" && Number.isSafeInteger(payload.valueMinor) ? payload.valueMinor : void 0;
+  const currency = boundedString(payload.currency, 3)?.toUpperCase();
+  const orderId = boundedString(payload.orderId, 240);
+  const customData = {
+    ...valueMinor !== void 0 && valueMinor >= 0 ? { value: valueMinor / 100 } : {},
+    ...currency ? { currency } : {},
+    ...orderId ? { order_id: orderId } : {}
+  };
+  const eventId = boundedString(payload.eventId, 255);
+  const eventSourceUrl = boundedString(payload.sourceUrl);
+  const event = {
+    eventName,
+    eventTime: metaEventTime(payload.eventTime),
+    actionSource: actionSource && META_ACTION_SOURCES.has(actionSource) ? actionSource : "system_generated",
+    ...eventId ? { eventId } : {},
+    ...eventSourceUrl ? { eventSourceUrl } : {},
+    userData: metaUserData(payload),
+    ...Object.keys(customData).length ? { customData } : {}
+  };
+  const testEventCode = boundedString(payload.testEventCode, 64);
+  return {
+    datasetId: destinationId,
+    events: [event],
+    ...testEventCode ? { testEventCode } : {}
+  };
+}
+function privacyPermitsNetworkData(payload) {
+  return metaNetworkRetentionPermits(payload);
+}
+function buildTikTokDeliveryRequest(destinationId, eventName, payload) {
+  const eventId = boundedString(payload.eventId, 255);
+  if (!eventId) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      "TikTok requires the stable X-Ray conversion ID for event deduplication."
+    );
+  }
+  const clickIds = recordValue(payload.clickIds);
+  const match = recordValue(payload.match);
+  const emailSha256 = sha256Value(match.emailSha256);
+  const phoneSha256 = sha256Value(match.phoneSha256);
+  const externalIdSha256 = sha256Value(match.externalIdSha256);
+  const ttclid = boundedString(clickIds.ttclid, 2e3);
+  const ttp = boundedString(clickIds.ttp, 255);
+  const userData = {
+    ...emailSha256 ? { emailSha256: [emailSha256] } : {},
+    ...phoneSha256 ? { phoneSha256: [phoneSha256] } : {},
+    ...externalIdSha256 ? { externalIdSha256: [externalIdSha256] } : {},
+    ...ttclid ? { ttclid } : {},
+    ...ttp ? { ttp } : {}
+  };
+  if (privacyPermitsNetworkData(payload)) {
+    const clientIpAddress = boundedString(match.clientIpAddress, 64);
+    const clientUserAgent = boundedString(match.clientUserAgent, 1e3);
+    if (clientIpAddress) userData.clientIpAddress = clientIpAddress;
+    if (clientUserAgent) userData.clientUserAgent = clientUserAgent;
+  }
+  if (!Object.keys(userData).length) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      "TikTok requires ttclid, ttp, or a documented SHA-256 match field."
+    );
+  }
+  const eventTime = Math.trunc(eventTimeMilliseconds(payload.eventTime, "TikTok") / 1e3);
+  const valueMinor = typeof payload.valueMinor === "number" && Number.isSafeInteger(payload.valueMinor) && payload.valueMinor >= 0 ? payload.valueMinor : void 0;
+  const currency = boundedString(payload.currency, 3)?.toUpperCase();
+  const sourceUrl = boundedString(payload.sourceUrl, 2048);
+  const referrer = boundedString(payload.referrer, 2048);
+  const orderId = boundedString(payload.orderId, 255);
+  const testEventCode = boundedString(payload.testEventCode, 128);
+  return {
+    pixelCode: destinationId,
+    events: [{
+      eventId,
+      eventName,
+      eventTime,
+      userData,
+      ...sourceUrl ? { page: { url: sourceUrl, ...referrer ? { referrer } : {} } } : {},
+      ...valueMinor !== void 0 && currency ? { properties: { value: valueMinor / 100, currency, ...orderId ? { orderId } : {} } } : orderId ? { properties: { orderId } } : {}
+    }],
+    ...testEventCode ? { testEventCode } : {},
+    schemaValidationOnly: false
+  };
+}
+var REDDIT_TRACKING_TYPES = /* @__PURE__ */ new Map([
+  ["page_view", "PAGE_VISIT"],
+  ["page_visit", "PAGE_VISIT"],
+  ["view_content", "VIEW_CONTENT"],
+  ["search", "SEARCH"],
+  ["add_to_cart", "ADD_TO_CART"],
+  ["add_to_wishlist", "ADD_TO_WISHLIST"],
+  ["purchase", "PURCHASE"],
+  ["lead", "LEAD"],
+  ["qualified_lead", "LEAD"],
+  ["sign_up", "SIGN_UP"],
+  ["signup", "SIGN_UP"]
+]);
+function redditActionSource(value) {
+  const source = boundedString(value, 64);
+  if (source === "website") return "WEBSITE";
+  if (source === "app") return "APP";
+  if (source === "physical_store") return "PHYSICAL_STORE";
+  return "OTHER";
+}
+function buildRedditDeliveryRequest(destinationId, eventName, payload) {
+  const conversionId = boundedString(payload.eventId, 255);
+  if (!conversionId) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      "Reddit requires the stable X-Ray conversion ID for event deduplication."
+    );
+  }
+  const clickIds = recordValue(payload.clickIds);
+  const match = recordValue(payload.match);
+  const clickId = boundedString(clickIds.rdtCid ?? clickIds.rdt_cid, 2e3);
+  const emailSha256 = sha256Value(match.emailSha256);
+  const phoneSha256 = sha256Value(match.phoneSha256);
+  const externalIdSha256 = sha256Value(match.externalIdSha256);
+  const uuid = boundedString(match.redditUuid ?? match.uuid, 255);
+  const user = {
+    ...emailSha256 ? { emailSha256 } : {},
+    ...phoneSha256 ? { phoneSha256 } : {},
+    ...externalIdSha256 ? { externalIdSha256 } : {},
+    ...uuid ? { uuid } : {}
+  };
+  if (privacyPermitsNetworkData(payload)) {
+    const ipAddress = boundedString(match.clientIpAddress, 64);
+    const userAgent = boundedString(match.clientUserAgent, 1e3);
+    if (ipAddress) user.ipAddress = ipAddress;
+    if (userAgent) user.userAgent = userAgent;
+  }
+  if (!clickId && !Object.keys(user).length) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      "Reddit requires rdt_cid or a documented user match field."
+    );
+  }
+  const normalizedName = eventName.trim().toLowerCase().replace(/[ -]+/g, "_");
+  const trackingType = REDDIT_TRACKING_TYPES.get(normalizedName) ?? "CUSTOM";
+  const valueMinor = typeof payload.valueMinor === "number" && Number.isSafeInteger(payload.valueMinor) && payload.valueMinor >= 0 ? payload.valueMinor : void 0;
+  const currency = boundedString(payload.currency, 3)?.toUpperCase();
+  const itemCount = typeof payload.itemCount === "number" && Number.isSafeInteger(payload.itemCount) && payload.itemCount >= 0 ? payload.itemCount : void 0;
+  const sourceUrl = boundedString(payload.sourceUrl, 2048);
+  const testId = boundedString(payload.testId, 255);
+  return {
+    pixelId: destinationId,
+    events: [{
+      conversionId,
+      ...clickId ? { clickId } : {},
+      eventAt: eventTimeMilliseconds(payload.eventTime, "Reddit"),
+      actionSource: redditActionSource(payload.actionSource),
+      ...sourceUrl ? { eventSourceUrl: sourceUrl } : {},
+      trackingType,
+      ...trackingType === "CUSTOM" ? { customEventName: eventName.slice(0, 64) } : {},
+      ...valueMinor !== void 0 && currency ? { value: valueMinor / 100, currency } : {},
+      ...itemCount !== void 0 ? { itemCount } : {},
+      user
+    }],
+    ...testId ? { testId } : {},
+    schemaValidationOnly: false
+  };
+}
+var AnalyticsProviderRegistryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "AnalyticsProviderRegistryError";
+    this.code = code;
+  }
+};
+var DEFAULT_RETRY_CLASSIFICATION = Object.freeze({
+  retryableStatusCodes: Object.freeze([408, 425, 429, 500, 502, 503, 504]),
+  permanentStatusCodes: Object.freeze([400, 401, 403, 404, 409, 422]),
+  maxAttempts: 8
+});
+var ANALYTICS_PROVIDER_REGISTRY = Object.freeze({
+  meta: Object.freeze({
+    platform: "meta",
+    integrationKeys: Object.freeze(["meta-marketing-api"]),
+    actionName: "send-conversion-events",
+    requiredDestinationField: "datasetId",
+    supportsTestMode: true,
+    supportsDiagnostics: false,
+    maxBatchSize: 1e3,
+    retryClassification: DEFAULT_RETRY_CLASSIFICATION
+  }),
+  google: Object.freeze({
+    platform: "google",
+    integrationKeys: Object.freeze(["google-data-manager"]),
+    actionName: "send-conversion-events",
+    requiredDestinationField: "conversionActionId",
+    supportsTestMode: true,
+    supportsDiagnostics: true,
+    diagnosticsActionName: "get-ingestion-diagnostics",
+    maxBatchSize: 1e3,
+    retryClassification: DEFAULT_RETRY_CLASSIFICATION
+  }),
+  tiktok: Object.freeze({
+    platform: "tiktok",
+    integrationKeys: Object.freeze(["tiktok-business"]),
+    actionName: "send-events",
+    requiredDestinationField: "pixelCode",
+    supportsTestMode: true,
+    supportsDiagnostics: false,
+    maxBatchSize: 1e3,
+    retryClassification: DEFAULT_RETRY_CLASSIFICATION
+  }),
+  reddit: Object.freeze({
+    platform: "reddit",
+    integrationKeys: Object.freeze(["reddit-ads"]),
+    actionName: "send-conversion-events",
+    requiredDestinationField: "pixelId",
+    supportsTestMode: true,
+    supportsDiagnostics: false,
+    maxBatchSize: 1e3,
+    retryClassification: DEFAULT_RETRY_CLASSIFICATION
+  })
+});
+function getAnalyticsProviderDefinition(platform) {
+  return ANALYTICS_PROVIDER_REGISTRY[platform];
+}
+function assertProviderDestination(platform, destinationId) {
+  const trimmed = destinationId?.trim() ?? "";
+  if (!trimmed) {
+    const definition = getAnalyticsProviderDefinition(platform);
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      `A ${definition.requiredDestinationField} is required for this activation provider.`
+    );
+  }
+  return trimmed;
+}
+function assertSafeAnalyticsEventMapping(eventMapping) {
+  if (eventMapping && Object.prototype.hasOwnProperty.call(eventMapping, "__tool")) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_action_unavailable",
+      "Activation action selection is managed by X-Ray."
+    );
+  }
+}
+function assertConnectionSupportsProvider(connection, platform) {
+  const definition = getAnalyticsProviderDefinition(platform);
+  if (!serviceConnectionAdvertisesAction(
+    connection,
+    definition.integrationKeys,
+    definition.actionName
+  )) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_action_unavailable",
+      "The selected connection cannot send conversions for this provider."
+    );
+  }
+  return definition;
+}
+function mappedEventName(input) {
+  const canonical = String(input.payload.eventName || "conversion");
+  return input.eventMapping?.[canonical] || canonical;
+}
+function buildProviderDeliveryRequest(input) {
+  const destinationId = assertProviderDestination(input.platform, input.destinationId);
+  assertSafeAnalyticsEventMapping(input.eventMapping);
+  const eventName = mappedEventName(input);
+  if (input.platform === "meta") {
+    return buildMetaDeliveryRequest(destinationId, eventName, input.payload);
+  }
+  if (input.platform === "google") {
+    return buildGoogleDeliveryRequest(destinationId, input.payload);
+  }
+  if (input.platform === "tiktok") {
+    return buildTikTokDeliveryRequest(destinationId, eventName, input.payload);
+  }
+  return buildRedditDeliveryRequest(destinationId, eventName, input.payload);
+}
+function buildProviderTestRequest(input) {
+  const definition = getAnalyticsProviderDefinition(input.platform);
+  const request = buildProviderDeliveryRequest(input);
+  if (input.platform === "google") return { ...request, validateOnly: true };
+  if (input.platform === "tiktok") {
+    return boundedString(input.payload.testEventCode, 128) ? request : { ...request, schemaValidationOnly: true };
+  }
+  if (input.platform === "reddit") {
+    return boundedString(input.payload.testId, 255) ? request : { ...request, schemaValidationOnly: true };
+  }
+  return definition.supportsTestMode ? { ...request, testMode: true } : request;
+}
+function optionalString(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value.trim().slice(0, 500);
+  }
+  return void 0;
+}
+function normalizeProviderReceipt(platform, receipt, stableEventId) {
+  void getAnalyticsProviderDefinition(platform);
+  const record = receipt && typeof receipt === "object" ? receipt : {};
+  const warnings = [record.warnings, record.messages, record.fieldWarnings].flatMap((value) => Array.isArray(value) ? value : []).map((value) => {
+    if (typeof value === "string") return value;
+    const warning = recordValue(value);
+    const reason = boundedString(warning.reason, 200);
+    const field = boundedString(warning.field, 200);
+    const description = boundedString(warning.description, 500);
+    return [reason, field, description].filter(Boolean).join(": ");
+  }).filter((value) => Boolean(value)).slice(0, 50).map((value) => value.slice(0, 500));
+  const eventsReceived = typeof record.eventsReceived === "number" && Number.isFinite(record.eventsReceived) ? Math.max(0, Math.trunc(record.eventsReceived)) : void 0;
+  const eventsRejected = typeof record.eventsRejected === "number" && Number.isFinite(record.eventsRejected) ? Math.max(0, Math.trunc(record.eventsRejected)) : void 0;
+  const partiallyAccepted = record.partiallyAccepted === true;
+  return {
+    accepted: record.schemaValidationOnly !== true && (record.accepted === true || record.success === true || record.providerAccepted === true || record.acceptedForProcessing === true || (eventsReceived ?? 0) > 0),
+    ...partiallyAccepted ? { partiallyAccepted: true } : {},
+    ...optionalString(record, "requestId", "receiptId", "id") ? { requestId: optionalString(record, "requestId", "receiptId", "id") } : {},
+    ...optionalString(record, "eventId", "conversionId") || boundedString(stableEventId, 255) ? { eventId: optionalString(record, "eventId", "conversionId") || boundedString(stableEventId, 255) } : {},
+    ...eventsReceived !== void 0 ? { eventsReceived } : {},
+    ...eventsRejected !== void 0 ? { eventsRejected } : {},
+    warnings
+  };
+}
+
 // src/api/analytics-repository.ts
 var AnalyticsRepositoryError = class extends Error {
   constructor(code, message, status = 400) {
@@ -205,6 +1027,26 @@ async function migrateAnalytics() {
         UNIQUE(pixel_id, hostname)
       )
     `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_host_groups (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid NOT NULL REFERENCES analytics_pixels(id) ON DELETE CASCADE,
+        name text NOT NULL,
+        auto_decorate boolean NOT NULL DEFAULT false,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(pixel_id, name)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_host_group_members (
+        group_id uuid NOT NULL REFERENCES analytics_host_groups(id) ON DELETE CASCADE,
+        hostname text NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        PRIMARY KEY(group_id, hostname)
+      )
+    `);
     await client.query(`
       CREATE TABLE IF NOT EXISTS analytics_events (
         id uuid PRIMARY KEY,
@@ -420,6 +1262,20 @@ async function migrateAnalytics() {
         UNIQUE(person_id, identity_node_id, evidence_kind)
       )
     `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_linker_tokens (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid NOT NULL REFERENCES analytics_pixels(id) ON DELETE CASCADE,
+        host_group_id uuid NOT NULL REFERENCES analytics_host_groups(id) ON DELETE CASCADE,
+        identity_node_id uuid NOT NULL REFERENCES analytics_identity_nodes(id) ON DELETE CASCADE,
+        source_hostname text NOT NULL,
+        audience_hostname text NOT NULL,
+        expires_at timestamptz NOT NULL,
+        consumed_at timestamptz,
+        created_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
     await client.query(
       `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS click_ids jsonb NOT NULL DEFAULT '{}'::jsonb`
     );
@@ -596,6 +1452,302 @@ async function migrateAnalytics() {
     await client.query(
       `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS region_code text`
     );
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_sessions (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid REFERENCES analytics_pixels(id) ON DELETE SET NULL,
+        visitor_hmac text NOT NULL,
+        session_hmac text NOT NULL,
+        person_id uuid REFERENCES analytics_people(id) ON DELETE SET NULL,
+        started_at timestamptz NOT NULL,
+        last_active_at timestamptz NOT NULL,
+        ended_at timestamptz,
+        duration_ms bigint NOT NULL DEFAULT 0 CHECK (duration_ms >= 0),
+        landing_path text,
+        exit_path text,
+        pageview_count integer NOT NULL DEFAULT 0,
+        event_count integer NOT NULL DEFAULT 0,
+        first_touch_id uuid,
+        last_touch_id uuid,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, session_hmac)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_attribution_touches (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        session_id uuid REFERENCES analytics_sessions(id) ON DELETE SET NULL,
+        person_id uuid REFERENCES analytics_people(id) ON DELETE SET NULL,
+        visitor_hmac text,
+        occurred_at timestamptz NOT NULL,
+        source text,
+        medium text,
+        campaign text,
+        referrer text,
+        click_ids jsonb NOT NULL DEFAULT '{}'::jsonb,
+        landing_path text,
+        touch_hash text NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, touch_hash)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_connections (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        provider text NOT NULL,
+        name text NOT NULL,
+        source_account_ref text NOT NULL,
+        service_connection_ref text,
+        secret_ciphertext text,
+        config jsonb NOT NULL DEFAULT '{}'::jsonb,
+        readiness text NOT NULL DEFAULT 'configured_unverified'
+          CHECK (readiness IN ('not_configured','configured_unverified','verified','live','degraded','disabled')),
+        last_verified_at timestamptz,
+        last_event_at timestamptz,
+        last_reconciled_at timestamptz,
+        last_error_code text,
+        verification_evidence text CHECK (verification_evidence IN ('synthetic','provider')),
+        last_verified_receipt_id uuid,
+        created_by_user_id bigint NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, provider, source_account_ref)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_webhook_receipts (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        connection_id uuid REFERENCES analytics_connections(id) ON DELETE SET NULL,
+        provider text NOT NULL,
+        source_account_ref text NOT NULL,
+        source_event_id text NOT NULL,
+        signature_status text NOT NULL CHECK (signature_status IN ('verified','invalid','not_supported')),
+        normalization_status text NOT NULL DEFAULT 'pending'
+          CHECK (normalization_status IN ('pending','accepted','rejected','replayed')),
+        payload_ciphertext text,
+        payload_expires_at timestamptz,
+        error_code text,
+        received_at timestamptz NOT NULL DEFAULT now(),
+        normalized_at timestamptz,
+        UNIQUE(site_id, provider, source_account_ref, source_event_id)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_external_events (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        receipt_id uuid REFERENCES analytics_webhook_receipts(id) ON DELETE SET NULL,
+        person_id uuid REFERENCES analytics_people(id) ON DELETE SET NULL,
+        source text NOT NULL,
+        source_account_ref text NOT NULL,
+        source_event_id text NOT NULL,
+        event_kind text NOT NULL CHECK (event_kind IN ('form','call','crm','transaction','custom_server','conversion','delivery')),
+        event_name text NOT NULL,
+        occurred_at timestamptz NOT NULL,
+        visitor_hmac text,
+        session_hmac text,
+        call_id text,
+        deal_id text,
+        order_id text,
+        value_minor bigint,
+        currency text,
+        click_ids jsonb NOT NULL DEFAULT '{}'::jsonb,
+        properties jsonb NOT NULL DEFAULT '{}'::jsonb,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, source, source_account_ref, source_event_id)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_reconciliation_cursors (
+        connection_id uuid PRIMARY KEY REFERENCES analytics_connections(id) ON DELETE CASCADE,
+        cursor jsonb,
+        health text NOT NULL DEFAULT 'webhook_only'
+          CHECK (health IN ('webhook_only','reconciled','degraded')),
+        records_replayed bigint NOT NULL DEFAULT 0,
+        last_started_at timestamptz,
+        last_completed_at timestamptz,
+        last_source_event_id text,
+        last_error_code text,
+        updated_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_reconciliation_jobs (
+        id uuid PRIMARY KEY,
+        connection_id uuid NOT NULL UNIQUE REFERENCES analytics_connections(id) ON DELETE CASCADE,
+        status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','leased')),
+        attempts integer NOT NULL DEFAULT 0,
+        next_attempt_at timestamptz NOT NULL DEFAULT now(),
+        lease_until timestamptz,
+        last_error_code text,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_event_definitions (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        name text NOT NULL,
+        event_name text NOT NULL,
+        trigger_kind text NOT NULL CHECK (trigger_kind IN ('page','click','form','semantic','custom_server','call','crm_stage','transaction')),
+        definition jsonb NOT NULL,
+        version integer NOT NULL DEFAULT 1,
+        status text NOT NULL DEFAULT 'active' CHECK (status IN ('active','disabled','archived')),
+        created_by_user_id bigint NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, name)
+      )
+    `);
+    await client.query(`
+      DO $$
+      BEGIN
+        IF EXISTS (
+          SELECT 1
+            FROM pg_constraint
+           WHERE conrelid = 'analytics_event_definitions'::regclass
+             AND conname = 'analytics_event_definitions_trigger_kind_check'
+             AND pg_get_constraintdef(oid) NOT LIKE '%semantic%'
+        ) THEN
+          ALTER TABLE analytics_event_definitions
+            DROP CONSTRAINT analytics_event_definitions_trigger_kind_check;
+          ALTER TABLE analytics_event_definitions
+            ADD CONSTRAINT analytics_event_definitions_trigger_kind_check
+            CHECK (trigger_kind IN ('page','click','form','semantic','custom_server','call','crm_stage','transaction'));
+        END IF;
+      END $$
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_conversion_rules (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        name text NOT NULL,
+        conversion_kind text NOT NULL,
+        condition jsonb NOT NULL,
+        default_value_minor bigint,
+        default_currency text NOT NULL DEFAULT 'USD',
+        version integer NOT NULL DEFAULT 1,
+        status text NOT NULL DEFAULT 'active' CHECK (status IN ('active','disabled','archived')),
+        created_by_user_id bigint NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, name)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_restricted_data (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        person_id uuid REFERENCES analytics_people(id) ON DELETE CASCADE,
+        purpose text NOT NULL,
+        subject_ref text NOT NULL,
+        payload_ciphertext text NOT NULL,
+        expires_at timestamptz NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, purpose, subject_ref)
+      )
+    `);
+    await client.query(
+      `ALTER TABLE analytics_activation_destinations ADD COLUMN IF NOT EXISTS readiness text NOT NULL DEFAULT 'configured_unverified' CHECK (readiness IN ('not_configured','configured_unverified','verified','live','degraded','disabled'))`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_destinations ADD COLUMN IF NOT EXISTS last_tested_at timestamptz`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_destinations ADD COLUMN IF NOT EXISTS last_receipt_id text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_destinations ADD COLUMN IF NOT EXISTS provider_config jsonb NOT NULL DEFAULT '{}'::jsonb`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_destinations ADD COLUMN IF NOT EXISTS mapping_version integer NOT NULL DEFAULT 1`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_jobs ADD COLUMN IF NOT EXISTS lease_until timestamptz`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_jobs ADD COLUMN IF NOT EXISTS mapping_version integer NOT NULL DEFAULT 1`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_jobs ADD COLUMN IF NOT EXISTS external_receipt_id text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_jobs ADD COLUMN IF NOT EXISTS response_code integer`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_jobs ADD COLUMN IF NOT EXISTS response_category text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_activation_jobs ADD COLUMN IF NOT EXISTS dead_lettered_at timestamptz`
+    );
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_activation_destination_tests (
+        id uuid PRIMARY KEY,
+        destination_id uuid NOT NULL REFERENCES analytics_activation_destinations(id) ON DELETE CASCADE,
+        mapping_version integer NOT NULL,
+        provider_request_id text,
+        provider_event_id text,
+        warnings jsonb NOT NULL DEFAULT '[]'::jsonb,
+        safe_error_category text,
+        request_started_at timestamptz NOT NULL DEFAULT now(),
+        response_received_at timestamptz,
+        next_diagnostic_at timestamptz,
+        actor text NOT NULL,
+        accepted boolean NOT NULL DEFAULT false,
+        validation_only boolean NOT NULL DEFAULT false,
+        created_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_activation_delivery_attempts (
+        id uuid PRIMARY KEY,
+        job_id uuid NOT NULL REFERENCES analytics_activation_jobs(id) ON DELETE CASCADE,
+        destination_id uuid NOT NULL REFERENCES analytics_activation_destinations(id) ON DELETE CASCADE,
+        mapping_version integer NOT NULL,
+        attempt_number integer NOT NULL,
+        provider_request_id text,
+        provider_event_id text,
+        warnings jsonb NOT NULL DEFAULT '[]'::jsonb,
+        safe_error_category text,
+        request_started_at timestamptz NOT NULL DEFAULT now(),
+        response_received_at timestamptz,
+        next_diagnostic_at timestamptz,
+        actor text NOT NULL,
+        accepted boolean NOT NULL DEFAULT false,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(job_id, attempt_number)
+      )
+    `);
+    await client.query(
+      `ALTER TABLE analytics_crm_import_rows ADD COLUMN IF NOT EXISTS next_attempt_at timestamptz NOT NULL DEFAULT now()`
+    );
+    await client.query(
+      `ALTER TABLE analytics_crm_import_rows ADD COLUMN IF NOT EXISTS lease_until timestamptz`
+    );
+    await client.query(
+      `ALTER TABLE analytics_crm_import_rows ADD COLUMN IF NOT EXISTS expires_at timestamptz NOT NULL DEFAULT (now() + interval '7 days')`
+    );
+    await client.query(
+      `ALTER TABLE analytics_conversions ADD COLUMN IF NOT EXISTS rule_id uuid REFERENCES analytics_conversion_rules(id) ON DELETE SET NULL`
+    );
+    await client.query(
+      `ALTER TABLE analytics_conversions ADD COLUMN IF NOT EXISTS rule_version integer`
+    );
+    await client.query(
+      `ALTER TABLE analytics_conversions ADD COLUMN IF NOT EXISTS order_id text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_connections ADD COLUMN IF NOT EXISTS verification_evidence text CHECK (verification_evidence IN ('synthetic','provider'))`
+    );
+    await client.query(
+      `ALTER TABLE analytics_connections ADD COLUMN IF NOT EXISTS last_verified_receipt_id uuid`
+    );
     await client.query(`CREATE UNIQUE INDEX IF NOT EXISTS analytics_exports_owner_idempotency
       ON analytics_exports(requested_by_user_id, idempotency_key) WHERE idempotency_key IS NOT NULL`);
     await client.query(
@@ -613,9 +1765,42 @@ async function migrateAnalytics() {
     await client.query(
       "CREATE INDEX IF NOT EXISTS analytics_conversions_site_time ON analytics_conversions(site_id, occurred_at DESC)"
     );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_sessions_site_visitor_time ON analytics_sessions(site_id, visitor_hmac, started_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_touches_site_person_time ON analytics_attribution_touches(site_id, person_id, occurred_at)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_external_events_site_time ON analytics_external_events(site_id, occurred_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_webhook_receipts_reconcile ON analytics_webhook_receipts(connection_id, received_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_reconciliation_jobs_due ON analytics_reconciliation_jobs(status, next_attempt_at, lease_until)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_activation_jobs_due ON analytics_activation_jobs(status, next_attempt_at) WHERE status = 'pending'"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_activation_tests_destination_time ON analytics_activation_destination_tests(destination_id, created_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_activation_attempts_destination_time ON analytics_activation_delivery_attempts(destination_id, created_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_activation_tests_diagnostics_due ON analytics_activation_destination_tests(next_diagnostic_at) WHERE next_diagnostic_at IS NOT NULL"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_restricted_data_expiry ON analytics_restricted_data(expires_at)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_linker_tokens_expiry ON analytics_linker_tokens(expires_at) WHERE consumed_at IS NULL"
+    );
     await client.query(`
       INSERT INTO analytics_schema_migrations(version)
-      VALUES ('2026-08-05.1'), ('2026-08-05.2'), ('2026-08-05.3'), ('2026-08-05.4'), ('2026-08-05.5'), ('2026-08-05.6'), ('2026-08-05.7'), ('2026-08-05.8'), ('2026-08-05.9'), ('2026-08-05.10'), ('2026-08-05.11'), ('2026-08-05.12'), ('2026-08-05.13'), ('2026-08-05.14')
+      VALUES ('2026-08-05.1'), ('2026-08-05.2'), ('2026-08-05.3'), ('2026-08-05.4'), ('2026-08-05.5'), ('2026-08-05.6'), ('2026-08-05.7'), ('2026-08-05.8'), ('2026-08-05.9'), ('2026-08-05.10'), ('2026-08-05.11'), ('2026-08-05.12'), ('2026-08-05.13'), ('2026-08-05.14'), ('2026-08-26.1'), ('2026-08-26.2'), ('2026-08-26.3'), ('2026-08-26.4')
       ON CONFLICT (version) DO NOTHING
     `);
     await client.query("COMMIT");
@@ -670,10 +1855,16 @@ async function requireEditor(client, siteId, userId) {
     );
   return role;
 }
+async function requireAnalyticsAccess(client, siteId, userId) {
+  return accessFor(client, siteId, userId);
+}
+async function requireAnalyticsEditor(client, siteId, userId) {
+  return requireEditor(client, siteId, userId);
+}
 async function createAnalyticsSite(input) {
   const db = getAnalyticsPool();
   const client = await db.connect();
-  const id = randomUUID();
+  const id = randomUUID2();
   const baseSlug = normalizeSlug(input.slug || input.name);
   try {
     await client.query("BEGIN");
@@ -904,7 +2095,7 @@ async function createAnalyticsPixel(input) {
      VALUES ($1, $2, $3, $4, $5)
      RETURNING id, site_id, public_id, name, environment, status, created_at::text, NULL::text AS last_event_at`,
     [
-      randomUUID(),
+      randomUUID2(),
       input.siteId,
       publicPixelId(),
       input.name.trim(),
@@ -976,19 +2167,244 @@ async function setAnalyticsPixelDomainState(input) {
       "invalid_hostname",
       "Enter a valid hostname."
     );
-  const result = await db.query(
-    `INSERT INTO analytics_pixel_domains(id, pixel_id, hostname, state)
-     SELECT $1, p.id, $4, $5 FROM analytics_pixels p WHERE p.id = $2 AND p.site_id = $3
-     ON CONFLICT(pixel_id, hostname) DO UPDATE SET state = EXCLUDED.state, updated_at = now()
-     RETURNING id`,
-    [randomUUID(), input.pixelId, input.siteId, hostname, input.state]
-  );
-  if (!result.rowCount)
-    throw new AnalyticsRepositoryError(
-      "analytics_pixel_not_found",
-      "Pixel not found.",
-      404
+  const result = await db.query(
+    `INSERT INTO analytics_pixel_domains(id, pixel_id, hostname, state)
+     SELECT $1, p.id, $4, $5 FROM analytics_pixels p WHERE p.id = $2 AND p.site_id = $3
+     ON CONFLICT(pixel_id, hostname) DO UPDATE SET state = EXCLUDED.state, updated_at = now()
+     RETURNING id`,
+    [randomUUID2(), input.pixelId, input.siteId, hostname, input.state]
+  );
+  if (!result.rowCount)
+    throw new AnalyticsRepositoryError(
+      "analytics_pixel_not_found",
+      "Pixel not found.",
+      404
+    );
+}
+async function upsertAnalyticsHostGroup(input) {
+  const client = await getAnalyticsPool().connect();
+  try {
+    await client.query("BEGIN");
+    await requireEditor(client, input.siteId, input.userId);
+    const hostnames = [...new Set(input.hostnames.map(
+      (hostname) => normalizeObservedHostname(`https://${hostname}`)
+    ).filter((hostname) => Boolean(hostname)))];
+    if (hostnames.length < 2 || hostnames.length > 20)
+      throw new AnalyticsRepositoryError(
+        "invalid_host_group",
+        "A host group requires between two and twenty valid hostnames."
+      );
+    const approved = await client.query(
+      `SELECT d.hostname
+         FROM analytics_pixels p
+         JOIN analytics_pixel_domains d ON d.pixel_id=p.id
+        WHERE p.id=$1 AND p.site_id=$2 AND p.status='active'
+          AND d.state='approved' AND d.hostname = ANY($3::text[])`,
+      [input.pixelId, input.siteId, hostnames]
+    );
+    if (approved.rows.length !== hostnames.length)
+      throw new AnalyticsRepositoryError(
+        "host_group_unapproved",
+        "Every host group member must be approved for this active Pixel.",
+        403
+      );
+    const group = await client.query(
+      `INSERT INTO analytics_host_groups(id, site_id, pixel_id, name, auto_decorate)
+       VALUES ($1,$2,$3,$4,$5)
+       ON CONFLICT(pixel_id, name) DO UPDATE SET
+         auto_decorate=EXCLUDED.auto_decorate, updated_at=now()
+       RETURNING id`,
+      [randomUUID2(), input.siteId, input.pixelId, input.name.trim().slice(0, 120), Boolean(input.autoDecorate)]
+    );
+    await client.query("DELETE FROM analytics_host_group_members WHERE group_id=$1", [group.rows[0].id]);
+    for (const hostname of hostnames)
+      await client.query(
+        "INSERT INTO analytics_host_group_members(group_id, hostname) VALUES ($1,$2)",
+        [group.rows[0].id, hostname]
+      );
+    await client.query("COMMIT");
+    return {
+      id: group.rows[0].id,
+      siteId: input.siteId,
+      pixelId: input.pixelId,
+      name: input.name.trim().slice(0, 120),
+      autoDecorate: Boolean(input.autoDecorate),
+      hostnames
+    };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function listAnalyticsHostGroups(input) {
+  const db = getAnalyticsPool();
+  await accessFor(db, input.siteId, input.userId);
+  const result = await db.query(
+    `SELECT g.id, g.site_id, g.pixel_id, g.name, g.auto_decorate,
+            COALESCE(array_agg(m.hostname ORDER BY m.hostname) FILTER (WHERE m.hostname IS NOT NULL), '{}') AS hostnames
+       FROM analytics_host_groups g
+       LEFT JOIN analytics_host_group_members m ON m.group_id=g.id
+      WHERE g.site_id=$1 AND g.pixel_id=$2
+      GROUP BY g.id ORDER BY g.created_at`,
+    [input.siteId, input.pixelId]
+  );
+  return result.rows.map((row) => ({
+    id: row.id,
+    siteId: row.site_id,
+    pixelId: row.pixel_id,
+    name: row.name,
+    autoDecorate: row.auto_decorate,
+    hostnames: row.hostnames
+  }));
+}
+async function prepareAnalyticsLinkerIssue(input) {
+  const client = await getAnalyticsPool().connect();
+  const sourceHostname = normalizeObservedHostname(`https://${input.sourceHostname}`);
+  const audienceHostname = normalizeObservedHostname(`https://${input.audienceHostname}`);
+  if (!sourceHostname || !audienceHostname || sourceHostname === audienceHostname)
+    throw new AnalyticsRepositoryError("linker_host_invalid", "Choose a different approved destination hostname.", 403);
+  try {
+    await client.query("BEGIN");
+    const context = await client.query(
+      `SELECT p.site_id, p.id AS pixel_id, g.id AS host_group_id
+         FROM analytics_pixels p
+         JOIN analytics_host_groups g ON g.pixel_id=p.id AND g.site_id=p.site_id
+         JOIN analytics_host_group_members source ON source.group_id=g.id AND source.hostname=$2
+         JOIN analytics_host_group_members audience ON audience.group_id=g.id AND audience.hostname=$3
+         JOIN analytics_pixel_domains source_domain ON source_domain.pixel_id=p.id AND source_domain.hostname=$2 AND source_domain.state='approved'
+         JOIN analytics_pixel_domains audience_domain ON audience_domain.pixel_id=p.id AND audience_domain.hostname=$3 AND audience_domain.state='approved'
+        WHERE p.public_id=$1 AND p.status='active'
+          AND NOT EXISTS (
+            SELECT 1 FROM analytics_host_group_members member
+            LEFT JOIN analytics_pixel_domains member_domain
+              ON member_domain.pixel_id=p.id AND member_domain.hostname=member.hostname
+            WHERE member.group_id=g.id AND COALESCE(member_domain.state, '') <> 'approved'
+          )
+        LIMIT 1`,
+      [input.publicPixelId, sourceHostname, audienceHostname]
+    );
+    if (!context.rowCount)
+      throw new AnalyticsRepositoryError(
+        "linker_host_unapproved",
+        "Both hostnames must belong to the same approved Pixel host group.",
+        403
+      );
+    const { site_id: siteId, pixel_id: pixelId, host_group_id: hostGroupId } = context.rows[0];
+    const node = await client.query(
+      `INSERT INTO analytics_identity_nodes(id, site_id, kind, value_hmac)
+       VALUES ($1,$2,'visitor_id',$3)
+       ON CONFLICT(site_id, kind, value_hmac) DO UPDATE SET last_seen_at=now()
+       RETURNING id`,
+      [randomUUID2(), siteId, identityHmac("visitor_id", input.visitorId)]
+    );
+    const existingPerson = await client.query(
+      `SELECT person_id FROM analytics_identity_edges
+        WHERE site_id=$1 AND identity_node_id=$2
+        ORDER BY confidence DESC, first_seen_at ASC LIMIT 1`,
+      [siteId, node.rows[0].id]
+    );
+    let personId = existingPerson.rows[0]?.person_id;
+    if (!personId) {
+      const person = await client.query(
+        `INSERT INTO analytics_people(id, site_id, crm_person_ref) VALUES ($1,$2,$3)
+         ON CONFLICT(site_id, crm_person_ref) DO UPDATE SET last_seen_at=now() RETURNING id`,
+        [randomUUID2(), siteId, `XRay::anonymous::${identityHmac("visitor_id", input.visitorId).slice(0, 24)}`]
+      );
+      personId = person.rows[0].id;
+      await client.query(
+        `INSERT INTO analytics_identity_edges(id, site_id, person_id, identity_node_id, evidence_kind, confidence)
+         VALUES ($1,$2,$3,$4,'first_party_linker',0.980)
+         ON CONFLICT(person_id, identity_node_id, evidence_kind) DO UPDATE SET last_seen_at=now()`,
+        [randomUUID2(), siteId, personId, node.rows[0].id]
+      );
+    }
+    const tokenId = randomUUID2();
+    await client.query(
+      `INSERT INTO analytics_linker_tokens(
+         id, site_id, pixel_id, host_group_id, identity_node_id,
+         source_hostname, audience_hostname, expires_at
+       ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`,
+      [tokenId, siteId, pixelId, hostGroupId, node.rows[0].id, sourceHostname, audienceHostname, input.expiresAt]
+    );
+    await client.query("COMMIT");
+    return {
+      tokenId,
+      siteId,
+      pixelId,
+      identityNodeId: node.rows[0].id,
+      sourceHostname,
+      audienceHostname,
+      expiresAt: input.expiresAt
+    };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function redeemAnalyticsLinkerRecord(input) {
+  const client = await getAnalyticsPool().connect();
+  try {
+    await client.query("BEGIN");
+    const redeemed = await client.query(
+      `UPDATE analytics_linker_tokens SET consumed_at=now()
+        WHERE id=$1 AND site_id=$2 AND pixel_id=$3 AND identity_node_id=$4
+          AND audience_hostname=$5 AND consumed_at IS NULL AND expires_at > now()
+        RETURNING identity_node_id`,
+      [input.tokenId, input.siteId, input.pixelId, input.identityNodeId, input.audienceHostname]
+    );
+    if (!redeemed.rowCount)
+      throw new AnalyticsRepositoryError(
+        "linker_replayed_or_expired",
+        "The linker token was already used or has expired.",
+        409
+      );
+    const sourceEdge = await client.query(
+      `SELECT person_id FROM analytics_identity_edges
+        WHERE site_id=$1 AND identity_node_id=$2
+        ORDER BY confidence DESC, first_seen_at ASC LIMIT 1`,
+      [input.siteId, input.identityNodeId]
+    );
+    const personId = sourceEdge.rows[0]?.person_id;
+    if (!personId)
+      throw new AnalyticsRepositoryError("linker_identity_missing", "The linker identity is unavailable.", 409);
+    const targetNode = await client.query(
+      `INSERT INTO analytics_identity_nodes(id, site_id, kind, value_hmac)
+       VALUES ($1,$2,'visitor_id',$3)
+       ON CONFLICT(site_id, kind, value_hmac) DO UPDATE SET last_seen_at=now()
+       RETURNING id`,
+      [randomUUID2(), input.siteId, identityHmac("visitor_id", input.visitorId)]
+    );
+    await client.query(
+      `INSERT INTO analytics_identity_edges(id, site_id, person_id, identity_node_id, evidence_kind, confidence)
+       VALUES ($1,$2,$3,$4,'cross_domain_linker',0.980)
+       ON CONFLICT(person_id, identity_node_id, evidence_kind) DO UPDATE SET last_seen_at=now()`,
+      [randomUUID2(), input.siteId, personId, targetNode.rows[0].id]
+    );
+    await client.query(
+      "UPDATE analytics_events SET person_id=$1 WHERE site_id=$2 AND visitor_id=$3 AND person_id IS NULL",
+      [personId, input.siteId, input.visitorId]
+    );
+    const visitorHmac = identityHmac("visitor_id", input.visitorId);
+    await client.query(
+      "UPDATE analytics_sessions SET person_id=$1 WHERE site_id=$2 AND visitor_hmac=$3 AND person_id IS NULL",
+      [personId, input.siteId, visitorHmac]
+    );
+    await client.query(
+      "UPDATE analytics_attribution_touches SET person_id=$1 WHERE site_id=$2 AND visitor_hmac=$3 AND person_id IS NULL",
+      [personId, input.siteId, visitorHmac]
     );
+    await client.query("COMMIT");
+    return { personId };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
 }
 var MAX_ENGAGED_MS = 30 * 60 * 1e3;
 var ENGAGED_SESSION_MS = 1e4;
@@ -1032,9 +2448,94 @@ function sanitizeAnalyticsProperties(value) {
   }
   return output;
 }
+async function materializeAnalyticsSessionAndTouch(input) {
+  if (!input.event.visitorId || !input.event.sessionId) return;
+  const visitorHmac = identityHmac("visitor_id", input.event.visitorId);
+  const sessionHmac = identityHmac("session_id", input.event.sessionId);
+  const occurredAt = new Date(input.event.occurredAt);
+  if (!Number.isFinite(occurredAt.getTime())) return;
+  const path = normalizeAnalyticsPath(input.event.path || input.event.canonicalUrl);
+  const session = await input.client.query(
+    `INSERT INTO analytics_sessions(
+       id, site_id, pixel_id, visitor_hmac, session_hmac, person_id,
+       started_at, last_active_at, landing_path, exit_path, pageview_count, event_count
+     ) VALUES ($1,$2,$3,$4,$5,$6,$7,$7,$8,$8,$9,1)
+     ON CONFLICT(site_id, session_hmac) DO UPDATE SET
+       person_id = COALESCE(analytics_sessions.person_id, EXCLUDED.person_id),
+       last_active_at = GREATEST(analytics_sessions.last_active_at, EXCLUDED.last_active_at),
+       ended_at = GREATEST(COALESCE(analytics_sessions.ended_at, EXCLUDED.last_active_at), EXCLUDED.last_active_at),
+       duration_ms = GREATEST(
+         analytics_sessions.duration_ms,
+         LEAST(1800000, (EXTRACT(EPOCH FROM (GREATEST(analytics_sessions.last_active_at, EXCLUDED.last_active_at) - analytics_sessions.started_at)) * 1000)::bigint)
+       ),
+       exit_path = EXCLUDED.exit_path,
+       pageview_count = analytics_sessions.pageview_count + EXCLUDED.pageview_count,
+       event_count = analytics_sessions.event_count + 1,
+       updated_at = now()
+     RETURNING id`,
+    [
+      randomUUID2(),
+      input.siteId,
+      input.pixelId,
+      visitorHmac,
+      sessionHmac,
+      input.personId ?? null,
+      input.event.occurredAt,
+      path,
+      input.event.eventName === "page_view" ? 1 : 0
+    ]
+  );
+  const clickIds = sanitizeClickIds(input.event.clickIds);
+  const hasTouch = Boolean(
+    input.event.source || input.event.medium || input.event.campaign || input.event.referrer || Object.keys(clickIds).length
+  );
+  if (!hasTouch) return;
+  const touchHash = createHash("sha256").update(
+    JSON.stringify({
+      siteId: input.siteId,
+      sessionHmac,
+      source: input.event.source ?? null,
+      medium: input.event.medium ?? null,
+      campaign: input.event.campaign ?? null,
+      referrer: normalizeAnalyticsUrl(input.event.referrer),
+      clickIds,
+      path
+    })
+  ).digest("hex");
+  const touch = await input.client.query(
+    `INSERT INTO analytics_attribution_touches(
+       id, site_id, session_id, person_id, visitor_hmac, occurred_at,
+       source, medium, campaign, referrer, click_ids, landing_path, touch_hash
+     ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11::jsonb,$12,$13)
+     ON CONFLICT(site_id, touch_hash) DO UPDATE SET
+       person_id = COALESCE(analytics_attribution_touches.person_id, EXCLUDED.person_id)
+     RETURNING id`,
+    [
+      randomUUID2(),
+      input.siteId,
+      session.rows[0].id,
+      input.personId ?? null,
+      visitorHmac,
+      input.event.occurredAt,
+      input.event.source?.slice(0, 180) ?? null,
+      input.event.medium?.slice(0, 180) ?? null,
+      input.event.campaign?.slice(0, 240) ?? null,
+      normalizeAnalyticsUrl(input.event.referrer),
+      JSON.stringify(clickIds),
+      path,
+      touchHash
+    ]
+  );
+  await input.client.query(
+    `UPDATE analytics_sessions
+        SET first_touch_id = COALESCE(first_touch_id, $2), last_touch_id = $2, updated_at = now()
+      WHERE id = $1`,
+    [session.rows[0].id, touch.rows[0].id]
+  );
+}
 async function ingestAnalyticsEvents(input) {
   const db = getAnalyticsPool();
-  const requestId = `air_${randomUUID()}`;
+  const requestId = `air_${randomUUID2()}`;
   const hostname = normalizeObservedHostname(input.origin);
   const pixelResult = await db.query(
     `SELECT p.id, p.site_id, p.status,
@@ -1055,7 +2556,7 @@ async function ingestAnalyticsEvents(input) {
       `INSERT INTO analytics_ingestion_receipts(id, request_id, site_id, pixel_id, hostname, rejected_count, reason_codes)
        VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)`,
       [
-        randomUUID(),
+        randomUUID2(),
         requestId,
         pixel?.site_id ?? null,
         pixel?.id ?? null,
@@ -1080,7 +2581,7 @@ async function ingestAnalyticsEvents(input) {
       `INSERT INTO analytics_ingestion_receipts(id, request_id, site_id, pixel_id, hostname, rejected_count, reason_codes)
        VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)`,
       [
-        randomUUID(),
+        randomUUID2(),
         requestId,
         pixel.site_id,
         pixel.id,
@@ -1105,7 +2606,7 @@ async function ingestAnalyticsEvents(input) {
       `INSERT INTO analytics_ingestion_receipts(id, request_id, site_id, pixel_id, rejected_count, reason_codes)
        VALUES ($1, $2, $3, $4, $5, $6::jsonb)`,
       [
-        randomUUID(),
+        randomUUID2(),
         requestId,
         pixel.site_id,
         pixel.id,
@@ -1129,7 +2630,7 @@ async function ingestAnalyticsEvents(input) {
      ON CONFLICT(pixel_id, hostname) DO UPDATE
        SET last_seen_at = now(), updated_at = now()
      RETURNING state`,
-    [randomUUID(), pixel.id, hostname]
+    [randomUUID2(), pixel.id, hostname]
   );
   if (domainResult.rows[0]?.state !== "approved") {
     await db.query(
@@ -1143,7 +2644,7 @@ async function ingestAnalyticsEvents(input) {
       `INSERT INTO analytics_ingestion_receipts(id, request_id, site_id, pixel_id, hostname, rejected_count, reason_codes)
        VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)`,
       [
-        randomUUID(),
+        randomUUID2(),
         requestId,
         pixel.site_id,
         pixel.id,
@@ -1171,7 +2672,17 @@ async function ingestAnalyticsEvents(input) {
     for (const event of input.events) {
       try {
         const attribution = resolveAnalyticsAttribution(event);
-        const resolvedPerson = event.visitorId || event.sessionId ? await client.query(
+        const identifiedPersonId = event.identity && event.consent?.analytics === "granted" ? await linkAnalyticsIdentityInTransaction(client, {
+          siteId: pixel.site_id,
+          visitorId: event.visitorId,
+          sessionId: event.sessionId,
+          email: event.identity.email,
+          phone: event.identity.phone,
+          customerId: event.identity.customerId,
+          orderId: event.identity.orderId,
+          clickIds: event.clickIds
+        }) : null;
+        const resolvedPerson = identifiedPersonId ? { rows: [{ person_id: identifiedPersonId }] } : event.visitorId || event.sessionId ? await client.query(
           `SELECT e.person_id FROM analytics_identity_nodes n JOIN analytics_identity_edges e ON e.identity_node_id = n.id
               WHERE n.site_id = $1 AND ((n.kind = 'visitor_id' AND n.value_hmac = $2) OR (n.kind = 'session_id' AND n.value_hmac = $3))
               ORDER BY e.confidence DESC, e.last_seen_at DESC LIMIT 1`,
@@ -1193,7 +2704,7 @@ async function ingestAnalyticsEvents(input) {
              $23, $24, $25, $26, $27, $28, $29, $30, $31, $32, $33
            ) ON CONFLICT(site_id, event_id) DO NOTHING`,
           [
-            randomUUID(),
+            randomUUID2(),
             event.eventId,
             pixel.site_id,
             pixel.id,
@@ -1228,8 +2739,16 @@ async function ingestAnalyticsEvents(input) {
             boundedScrollDepth(event.scrollDepth)
           ]
         );
-        if (inserted.rowCount) accepted += 1;
-        else {
+        if (inserted.rowCount) {
+          accepted += 1;
+          await materializeAnalyticsSessionAndTouch({
+            client,
+            siteId: pixel.site_id,
+            pixelId: pixel.id,
+            personId: resolvedPerson.rows[0]?.person_id,
+            event
+          });
+        } else {
           rejected += 1;
           reasonCodes.add("duplicate_event");
         }
@@ -1251,7 +2770,7 @@ async function ingestAnalyticsEvents(input) {
          id, request_id, site_id, pixel_id, hostname, accepted_count, rejected_count, reason_codes
        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb)`,
       [
-        randomUUID(),
+        randomUUID2(),
         requestId,
         pixel.site_id,
         pixel.id,
@@ -1320,45 +2839,86 @@ function paginateRows(rows, input, fingerprint) {
 }
 async function createAnalyticsConversion(input) {
   const db = getAnalyticsPool();
-  await requireEditor(db, input.siteId, input.userId);
-  if (input.pixelId) {
-    const pixel = await db.query(
-      `SELECT 1 FROM analytics_pixels WHERE id = $1 AND site_id = $2`,
-      [input.pixelId, input.siteId]
+  const client = await db.connect();
+  try {
+    await client.query("BEGIN");
+    await requireEditor(client, input.siteId, input.userId);
+    if (input.pixelId) {
+      const pixel = await client.query(
+        `SELECT 1 FROM analytics_pixels WHERE id = $1 AND site_id = $2`,
+        [input.pixelId, input.siteId]
+      );
+      if (!pixel.rowCount)
+        throw new AnalyticsRepositoryError(
+          "analytics_pixel_not_found",
+          "Pixel not found.",
+          404
+        );
+    }
+    const resolvedPerson = input.personId ? { rows: [{ person_id: input.personId }] } : input.sessionId ? await client.query(
+      `SELECT e.person_id FROM analytics_identity_nodes n JOIN analytics_identity_edges e ON e.identity_node_id = n.id
+             WHERE n.site_id = $1 AND n.kind = 'session_id' AND n.value_hmac = $2
+             ORDER BY e.confidence DESC LIMIT 1`,
+      [input.siteId, identityHmac("session_id", input.sessionId)]
+    ) : { rows: [] };
+    const proposedId = randomUUID2();
+    const inserted = await client.query(
+      `INSERT INTO analytics_conversions(
+         id, source_event_id, site_id, pixel_id, session_id, conversion_kind,
+         value_minor, currency, occurred_at, person_id, order_id
+       ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)
+       ON CONFLICT(site_id, source_event_id) DO NOTHING RETURNING id`,
+      [
+        proposedId,
+        input.sourceEventId,
+        input.siteId,
+        input.pixelId ?? null,
+        input.sessionId ?? null,
+        input.conversionKind,
+        input.valueMinor ?? 0,
+        (input.currency || "USD").toUpperCase(),
+        input.occurredAt,
+        resolvedPerson.rows[0]?.person_id ?? null,
+        input.orderId ?? null
+      ]
     );
-    if (!pixel.rowCount)
-      throw new AnalyticsRepositoryError(
-        "analytics_pixel_not_found",
-        "Pixel not found.",
-        404
+    const created = Boolean(inserted.rowCount);
+    const conversionId = created ? inserted.rows[0].id : (await client.query(
+      `SELECT id FROM analytics_conversions WHERE site_id = $1 AND source_event_id = $2`,
+      [input.siteId, input.sourceEventId]
+    )).rows[0].id;
+    let queuedDestinations = 0;
+    if (created && input.activationPayloadCiphertext) {
+      const destinations = await client.query(
+        `SELECT id FROM analytics_activation_destinations
+          WHERE site_id = $1 AND status = 'active' AND readiness IN ('verified','live')`,
+        [input.siteId]
       );
+      for (const destination of destinations.rows) {
+        const queued = await client.query(
+          `INSERT INTO analytics_activation_jobs(
+             id, destination_id, conversion_id, person_id, payload_ciphertext
+           ) VALUES ($1,$2,$3,$4,$5)
+           ON CONFLICT(destination_id, conversion_id) DO NOTHING`,
+          [
+            randomUUID2(),
+            destination.id,
+            conversionId,
+            resolvedPerson.rows[0]?.person_id ?? null,
+            input.activationPayloadCiphertext
+          ]
+        );
+        queuedDestinations += queued.rowCount ?? 0;
+      }
+    }
+    await client.query("COMMIT");
+    return { id: conversionId, created, queuedDestinations };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
   }
-  const id = randomUUID();
-  const resolvedPerson = input.sessionId ? await db.query(
-    `SELECT e.person_id FROM analytics_identity_nodes n JOIN analytics_identity_edges e ON e.identity_node_id = n.id
-        WHERE n.site_id = $1 AND n.kind = 'session_id' AND n.value_hmac = $2 ORDER BY e.confidence DESC LIMIT 1`,
-    [input.siteId, identityHmac("session_id", input.sessionId)]
-  ) : { rows: [] };
-  const result = await db.query(
-    `INSERT INTO analytics_conversions(
-       id, source_event_id, site_id, pixel_id, session_id, conversion_kind, value_minor, currency, occurred_at, person_id
-     ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
-     ON CONFLICT(site_id, source_event_id) DO NOTHING
-     RETURNING id`,
-    [
-      id,
-      input.sourceEventId,
-      input.siteId,
-      input.pixelId ?? null,
-      input.sessionId ?? null,
-      input.conversionKind,
-      input.valueMinor ?? 0,
-      (input.currency || "USD").toUpperCase(),
-      input.occurredAt,
-      resolvedPerson.rows[0]?.person_id ?? null
-    ]
-  );
-  return { id: result.rows[0]?.id ?? id, created: Boolean(result.rowCount) };
 }
 function eventFilterSql(siteId, filters) {
   const values = [siteId, filters.start, filters.end];
@@ -2114,7 +3674,7 @@ async function createAnalyticsCampaignLink(input) {
        ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)
        RETURNING *, 0::int AS click_count`,
       [
-        randomUUID(),
+        randomUUID2(),
         input.siteId,
         input.pixelId ?? null,
         input.name.trim(),
@@ -2185,7 +3745,7 @@ async function resolveAnalyticsCampaignLink(shortCode, referrer) {
   if (!row) return null;
   await db.query(
     `INSERT INTO analytics_campaign_clicks(id, link_id, referrer) VALUES ($1, $2, $3)`,
-    [randomUUID(), row.id, normalizeAnalyticsUrl(referrer || void 0)]
+    [randomUUID2(), row.id, normalizeAnalyticsUrl(referrer || void 0)]
   );
   return buildTaggedCampaignUrl(row);
 }
@@ -2210,7 +3770,7 @@ async function createAnalyticsForm(input) {
      VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8::jsonb,$9,$10,$11,$12,$13,$14)
      RETURNING *, 0::int AS submission_count`,
     [
-      randomUUID(),
+      randomUUID2(),
       publicId,
       input.siteId,
       input.pixelId,
@@ -2255,7 +3815,7 @@ async function getPublicAnalyticsForm(publicId) {
   return result.rows[0] ?? null;
 }
 async function recordAnalyticsFormSubmission(input) {
-  const id = randomUUID();
+  const id = randomUUID2();
   await getAnalyticsPool().query(
     `INSERT INTO analytics_form_submissions(id, form_id, site_id, pixel_id, visitor_id, session_id, crm_person_ref, source, medium, campaign, crm_delivery_status, click_ids)
      VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12::jsonb)`,
@@ -2283,7 +3843,11 @@ var clickIdKeys = /* @__PURE__ */ new Set([
   "wbraid",
   "ttclid",
   "rdt_cid",
-  "msclkid"
+  "msclkid",
+  "fbp",
+  "fbc",
+  "li_fat_id",
+  "snapclid"
 ]);
 function sanitizeClickIds(value) {
   const output = {};
@@ -2297,6 +3861,47 @@ function sanitizeClickIds(value) {
 function identityHmac(kind, value) {
   return createHmac2("sha256", getSessionSecret()).update(`${kind}:${value.trim().toLowerCase()}`).digest("hex");
 }
+async function linkAnalyticsIdentityInTransaction(client, input) {
+  const stable = input.customerId || input.orderId || input.email || input.phone;
+  if (!stable) return null;
+  const crmPersonRef = `XRay::${identityHmac("person_ref", stable).slice(0, 24)}`;
+  const person = await client.query(
+    `INSERT INTO analytics_people(id, site_id, crm_person_ref) VALUES ($1,$2,$3)
+     ON CONFLICT(site_id, crm_person_ref) DO UPDATE SET last_seen_at = now() RETURNING id`,
+    [randomUUID2(), input.siteId, crmPersonRef]
+  );
+  const personId = person.rows[0].id;
+  const signals = [];
+  if (input.visitorId)
+    signals.push({ kind: "visitor_id", value: input.visitorId, evidence: "pixel_identify", confidence: 0.98 });
+  if (input.sessionId)
+    signals.push({ kind: "session_id", value: input.sessionId, evidence: "pixel_identify", confidence: 0.98 });
+  if (input.email)
+    signals.push({ kind: "email", value: input.email, evidence: "pixel_identify", confidence: 1 });
+  if (input.phone)
+    signals.push({ kind: "phone", value: input.phone, evidence: "pixel_identify", confidence: 0.99 });
+  if (input.customerId)
+    signals.push({ kind: "customer_id", value: input.customerId, evidence: "customer_id", confidence: 1 });
+  if (input.orderId)
+    signals.push({ kind: "customer_id", value: `order:${input.orderId}`, evidence: "order_id", confidence: 1 });
+  for (const [platform, clickId] of Object.entries(sanitizeClickIds(input.clickIds)))
+    signals.push({ kind: "click_id", value: `${platform}:${clickId}`, evidence: platform, confidence: 0.9 });
+  for (const signal of signals) {
+    const node = await client.query(
+      `INSERT INTO analytics_identity_nodes(id, site_id, kind, value_hmac) VALUES ($1,$2,$3,$4)
+       ON CONFLICT(site_id, kind, value_hmac) DO UPDATE SET last_seen_at = now() RETURNING id`,
+      [randomUUID2(), input.siteId, signal.kind, identityHmac(signal.kind, signal.value)]
+    );
+    await client.query(
+      `INSERT INTO analytics_identity_edges(id, site_id, person_id, identity_node_id, evidence_kind, confidence)
+       VALUES ($1,$2,$3,$4,$5,$6)
+       ON CONFLICT(person_id, identity_node_id, evidence_kind) DO UPDATE
+       SET last_seen_at = now(), confidence = greatest(analytics_identity_edges.confidence, EXCLUDED.confidence)`,
+      [randomUUID2(), input.siteId, personId, node.rows[0].id, signal.evidence, signal.confidence]
+    );
+  }
+  return personId;
+}
 async function linkAnalyticsFormIdentity(input) {
   const client = await getAnalyticsPool().connect();
   try {
@@ -2304,7 +3909,7 @@ async function linkAnalyticsFormIdentity(input) {
     const person = await client.query(
       `INSERT INTO analytics_people(id, site_id, crm_person_ref) VALUES ($1,$2,$3)
        ON CONFLICT(site_id, crm_person_ref) DO UPDATE SET last_seen_at = now() RETURNING id`,
-      [randomUUID(), input.siteId, input.crmPersonRef]
+      [randomUUID2(), input.siteId, input.crmPersonRef]
     );
     const personId = person.rows[0].id;
     const signals = [];
@@ -2351,7 +3956,7 @@ async function linkAnalyticsFormIdentity(input) {
         `INSERT INTO analytics_identity_nodes(id, site_id, kind, value_hmac) VALUES ($1,$2,$3,$4)
          ON CONFLICT(site_id, kind, value_hmac) DO UPDATE SET last_seen_at = now() RETURNING id`,
         [
-          randomUUID(),
+          randomUUID2(),
           input.siteId,
           signal.kind,
           identityHmac(signal.kind, signal.value)
@@ -2362,7 +3967,7 @@ async function linkAnalyticsFormIdentity(input) {
          VALUES ($1,$2,$3,$4,$5,$6)
          ON CONFLICT(person_id, identity_node_id, evidence_kind) DO UPDATE SET last_seen_at = now(), confidence = greatest(analytics_identity_edges.confidence, EXCLUDED.confidence)`,
         [
-          randomUUID(),
+          randomUUID2(),
           input.siteId,
           personId,
           node.rows[0].id,
@@ -2460,7 +4065,7 @@ async function createAnalyticsCrmImport(input) {
   const db = getAnalyticsPool();
   await requireEditor(db, input.siteId, input.userId);
   const client = await db.connect();
-  const id = randomUUID();
+  const id = randomUUID2();
   try {
     await client.query("BEGIN");
     await client.query(
@@ -2480,7 +4085,7 @@ async function createAnalyticsCrmImport(input) {
       await client.query(
         `INSERT INTO analytics_crm_import_rows(id, import_id, crm_person_ref, payload_ciphertext)
          VALUES ($1,$2,$3,$4) ON CONFLICT(import_id, crm_person_ref) DO NOTHING`,
-        [randomUUID(), id, row.crmPersonRef, row.payloadCiphertext]
+        [randomUUID2(), id, row.crmPersonRef, row.payloadCiphertext]
       );
     }
     await client.query("COMMIT");
@@ -2512,20 +4117,105 @@ async function listAnalyticsCrmImports(siteId, userId, page) {
   );
   return { imports: paged.items, pageInfo: paged.pageInfo };
 }
+async function claimAnalyticsCrmImportRows(limit = 10) {
+  const result = await getAnalyticsPool().query(
+    `WITH due AS (
+       SELECT r.id FROM analytics_crm_import_rows r
+       WHERE r.delivery_status='pending' AND r.next_attempt_at <= now()
+         AND r.expires_at > now() AND (r.lease_until IS NULL OR r.lease_until < now())
+       ORDER BY r.next_attempt_at, r.created_at FOR UPDATE SKIP LOCKED LIMIT $1
+     )
+     UPDATE analytics_crm_import_rows r SET attempts=r.attempts+1,
+       lease_until=now()+interval '5 minutes'
+     FROM due, analytics_crm_imports i WHERE r.id=due.id AND i.id=r.import_id
+     RETURNING r.id, r.import_id, i.requested_by_user_id, r.payload_ciphertext, r.attempts`,
+    [Math.min(Math.max(limit, 1), 50)]
+  );
+  return result.rows.map((row) => ({
+    id: row.id,
+    importId: row.import_id,
+    ownerUserId: Number(row.requested_by_user_id),
+    payloadCiphertext: row.payload_ciphertext,
+    attempts: row.attempts
+  }));
+}
+async function completeAnalyticsCrmImportRow(rowId, importId) {
+  const db = getAnalyticsPool();
+  const client = await db.connect();
+  try {
+    await client.query("BEGIN");
+    await client.query(
+      `UPDATE analytics_crm_import_rows SET delivery_status='delivered', delivered_at=now(),
+       lease_until=NULL, last_error_code=NULL WHERE id=$1`,
+      [rowId]
+    );
+    await client.query(
+      `UPDATE analytics_crm_imports i SET status=CASE
+         WHEN EXISTS(SELECT 1 FROM analytics_crm_import_rows r WHERE r.import_id=i.id AND r.delivery_status='pending') THEN 'processing'
+         WHEN EXISTS(SELECT 1 FROM analytics_crm_import_rows r WHERE r.import_id=i.id AND r.delivery_status IN ('failed','expired')) THEN 'partial'
+         ELSE 'complete' END,
+       completed_at=CASE WHEN EXISTS(SELECT 1 FROM analytics_crm_import_rows r WHERE r.import_id=i.id AND r.delivery_status='pending') THEN NULL ELSE now() END
+       WHERE i.id=$1`,
+      [importId]
+    );
+    await client.query("COMMIT");
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function deferAnalyticsCrmImportRow(rowId, importId, attempts, errorCode) {
+  const terminal = attempts >= 8;
+  const delayMinutes = Math.min(5 * 2 ** Math.max(0, attempts - 1), 360);
+  await getAnalyticsPool().query(
+    `UPDATE analytics_crm_import_rows SET
+       delivery_status=CASE WHEN expires_at<=now() THEN 'expired' WHEN $2 THEN 'failed' ELSE 'pending' END,
+       lease_until=NULL, last_error_code=$3,
+       next_attempt_at=now()+($4::text || ' minutes')::interval WHERE id=$1`,
+    [rowId, terminal, errorCode.slice(0, 80), String(delayMinutes)]
+  );
+  if (terminal) {
+    await getAnalyticsPool().query(
+      `UPDATE analytics_crm_imports SET status='partial' WHERE id=$1`,
+      [importId]
+    );
+  }
+}
 async function createAnalyticsActivationDestination(input) {
+  assertSafeAnalyticsEventMapping(input.eventMapping);
+  const externalDatasetId = assertProviderDestination(input.platform, input.externalDatasetId);
+  const operatingAccountId = input.operatingAccountId?.trim();
+  if (input.platform === "google" && !operatingAccountId) {
+    throw new AnalyticsRepositoryError(
+      "analytics_provider_destination_required",
+      "A Google Ads operating account ID is required for Data Manager activation.",
+      400
+    );
+  }
+  assertConnectionSupportsProvider(input.validatedConnection, input.platform);
+  if (input.validatedConnection.id !== input.connectionRef) {
+    throw new AnalyticsRepositoryError(
+      "analytics_provider_action_unavailable",
+      "The selected connection cannot send conversions for this provider.",
+      409
+    );
+  }
   const db = getAnalyticsPool();
   await requireEditor(db, input.siteId, input.userId);
   const result = await db.query(
-    `INSERT INTO analytics_activation_destinations(id, site_id, platform, name, connection_ref, external_dataset_id, event_mapping, created_by_user_id)
-     VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8) RETURNING *`,
+    `INSERT INTO analytics_activation_destinations(id, site_id, platform, name, connection_ref, external_dataset_id, event_mapping, provider_config, created_by_user_id)
+     VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8::jsonb,$9) RETURNING *`,
     [
-      randomUUID(),
+      randomUUID2(),
       input.siteId,
       input.platform,
       input.name.trim(),
-      input.connectionRef?.trim() || null,
-      input.externalDatasetId?.trim() || null,
+      input.connectionRef.trim(),
+      externalDatasetId,
       JSON.stringify(input.eventMapping ?? {}),
+      JSON.stringify(operatingAccountId ? { operatingAccountId } : {}),
       input.userId
     ]
   );
@@ -2559,10 +4249,342 @@ async function archiveAnalyticsActivationDestination(input) {
       404
     );
 }
+function safeActivationErrorCategory(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : "";
+  if (/401|403|authori[sz]/.test(message)) return "activation_authorization_failed";
+  if (/429|rate.?limit/.test(message)) return "activation_rate_limited";
+  if (/invalid|required|schema|validation/.test(message)) return "activation_payload_invalid";
+  if (/timeout|timed out|temporar|unavailable|\b5\d\d\b/.test(message)) return "activation_provider_unavailable";
+  return "activation_provider_test_failed";
+}
+function boundedActivationWarnings(receipt) {
+  return receipt.warnings.slice(0, 50).map((warning) => warning.slice(0, 500));
+}
+async function loadActivationDestinationForEditor(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const result = await db.query(
+    `SELECT id, site_id, platform, connection_ref, external_dataset_id,
+            event_mapping, provider_config, mapping_version, readiness
+       FROM analytics_activation_destinations
+      WHERE id=$1 AND site_id=$2 AND status='active'`,
+    [input.destinationId, input.siteId]
+  );
+  const destination = result.rows[0];
+  if (!destination) {
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_destination_not_found",
+      "Activation destination not found.",
+      404
+    );
+  }
+  return destination;
+}
+async function getAnalyticsActivationDestinationConnectionRef(input) {
+  const destination = await loadActivationDestinationForEditor(input);
+  if (!destination.connection_ref) {
+    throw new AnalyticsRepositoryError(
+      "analytics_provider_action_unavailable",
+      "This destination has no connected provider account.",
+      409
+    );
+  }
+  return destination.connection_ref;
+}
+async function setAnalyticsActivationReadiness(input) {
+  const allowed = input.evidenceKind === "provider_test" && input.nextReadiness === "verified" || input.evidenceKind === "real_delivery" && input.nextReadiness === "live" || input.evidenceKind === "provider_diagnostic" && input.nextReadiness === "degraded";
+  if (!allowed || input.expectedReadiness.length === 0) {
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_readiness_evidence_required",
+      "Provider evidence is required for this activation readiness transition.",
+      409
+    );
+  }
+  const evidencePredicate = input.evidenceKind === "provider_test" ? `EXISTS (SELECT 1 FROM analytics_activation_destination_tests t
+                WHERE t.id=$5 AND t.destination_id=d.id AND t.accepted=true)` : input.evidenceKind === "real_delivery" ? `EXISTS (SELECT 1 FROM analytics_activation_delivery_attempts a
+                  WHERE a.id=$5 AND a.destination_id=d.id AND a.accepted=true)` : `EXISTS (SELECT 1 FROM analytics_activation_destination_tests t
+                  WHERE t.id=$5 AND t.destination_id=d.id AND t.safe_error_category IS NOT NULL)`;
+  const result = await getAnalyticsPool().query(
+    `UPDATE analytics_activation_destinations d
+        SET readiness=$3, updated_at=now(),
+            last_tested_at=CASE WHEN $3='verified' THEN now() ELSE last_tested_at END,
+            last_receipt_id=CASE WHEN $3 IN ('verified','live') THEN $5 ELSE last_receipt_id END
+      WHERE d.id=$1 AND d.site_id=$2 AND d.readiness = ANY($4::text[])
+        AND ${evidencePredicate}
+      RETURNING d.readiness`,
+    [input.destinationId, input.siteId, input.nextReadiness, [...input.expectedReadiness], input.evidenceId]
+  );
+  const readiness = result.rows[0]?.readiness;
+  if (!readiness) {
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_readiness_conflict",
+      "Activation readiness changed or the required provider evidence is unavailable.",
+      409
+    );
+  }
+  return readiness;
+}
+async function testAnalyticsActivationDestination(input) {
+  const destination = await loadActivationDestinationForEditor(input);
+  if (!destination.connection_ref || !destination.external_dataset_id) {
+    throw new AnalyticsRepositoryError(
+      "analytics_provider_destination_required",
+      "This destination is missing its provider connection or destination identifier.",
+      409
+    );
+  }
+  if (destination.connection_ref !== input.validatedConnection.id) {
+    throw new AnalyticsRepositoryError(
+      "analytics_provider_action_unavailable",
+      "The selected connection cannot test this destination.",
+      409
+    );
+  }
+  const definition = assertConnectionSupportsProvider(input.validatedConnection, destination.platform);
+  if ((destination.platform === "meta" || destination.platform === "tiktok") && !input.testEventCode) {
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_provider_test_code_required",
+      `A ${destination.platform} provider test event code is required; X-Ray will not send a synthetic test as a live event.`,
+      400
+    );
+  }
+  if (destination.platform === "reddit" && !input.testId) {
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_provider_test_code_required",
+      "A Reddit CAPI test ID is required; X-Ray will not send a synthetic test as a live event.",
+      400
+    );
+  }
+  const testId = randomUUID2();
+  const syntheticHash = createHash("sha256").update(`xray-provider-test:${testId}`).digest("hex");
+  const providerConfig = destination.provider_config ?? {};
+  const payload = {
+    eventId: `xray-test:${testId}`,
+    eventName: "xray_destination_test",
+    eventTime: (/* @__PURE__ */ new Date()).toISOString(),
+    actionSource: "system_generated",
+    match: { emailSha256: syntheticHash },
+    operatingAccountId: providerConfig.operatingAccountId,
+    ...input.testEventCode ? { testEventCode: input.testEventCode } : {},
+    ...input.testId ? { testId: input.testId } : {}
+  };
+  const request = buildProviderTestRequest({
+    platform: destination.platform,
+    destinationId: destination.external_dataset_id,
+    eventMapping: destination.event_mapping,
+    payload
+  });
+  await getAnalyticsPool().query(
+    `INSERT INTO analytics_activation_destination_tests(
+       id,destination_id,mapping_version,actor
+     ) VALUES ($1,$2,$3,$4)`,
+    [testId, destination.id, destination.mapping_version, input.actor.slice(0, 240)]
+  );
+  try {
+    const raw = await input.runAction({
+      connectionRef: destination.connection_ref,
+      actionName: definition.actionName,
+      idempotencyKey: `xray-destination-test:${testId}`,
+      payload: request
+    });
+    const receipt = normalizeProviderReceipt(destination.platform, raw, payload.eventId);
+    const rawRecord = raw && typeof raw === "object" ? raw : {};
+    const validationOnly = rawRecord.validationOnly === true || rawRecord.schemaValidationOnly === true;
+    const accepted = receipt.accepted || destination.platform === "google" && validationOnly;
+    await getAnalyticsPool().query(
+      `UPDATE analytics_activation_destination_tests
+          SET provider_request_id=$2, provider_event_id=$3, warnings=$4::jsonb,
+              response_received_at=now(), accepted=$5, validation_only=$6,
+              next_diagnostic_at=CASE WHEN $7 THEN now()+interval '2 minutes' ELSE NULL END
+        WHERE id=$1 AND response_received_at IS NULL`,
+      [
+        testId,
+        receipt.requestId ?? null,
+        receipt.eventId ?? null,
+        JSON.stringify(boundedActivationWarnings(receipt)),
+        accepted,
+        validationOnly,
+        Boolean(definition.supportsDiagnostics && receipt.requestId && !validationOnly)
+      ]
+    );
+    let readiness = destination.readiness;
+    if (accepted && destination.readiness !== "live") {
+      readiness = await setAnalyticsActivationReadiness({
+        siteId: input.siteId,
+        destinationId: destination.id,
+        expectedReadiness: ["configured_unverified", "degraded", "verified"],
+        nextReadiness: "verified",
+        evidenceKind: "provider_test",
+        evidenceId: testId
+      });
+    }
+    return {
+      testId,
+      accepted,
+      validationOnly,
+      readiness,
+      providerRequestId: receipt.requestId,
+      providerEventId: receipt.eventId,
+      warnings: boundedActivationWarnings(receipt)
+    };
+  } catch (error) {
+    if (error instanceof AnalyticsRepositoryError && error.code.startsWith("analytics_activation_readiness_")) {
+      throw error;
+    }
+    const category = safeActivationErrorCategory(error);
+    await getAnalyticsPool().query(
+      `UPDATE analytics_activation_destination_tests
+          SET safe_error_category=$2, response_received_at=now()
+        WHERE id=$1 AND response_received_at IS NULL`,
+      [testId, category]
+    );
+    throw new AnalyticsRepositoryError(category, "The provider did not accept the destination test.", 409);
+  }
+}
+async function listAnalyticsActivationReceipts(input) {
+  const db = getAnalyticsPool();
+  await accessFor(db, input.siteId, input.userId);
+  const limit = Math.min(Math.max(input.limit ?? 50, 1), 100);
+  const result = await db.query(
+    `SELECT * FROM (
+       SELECT t.id, 'test'::text AS kind, t.mapping_version, t.provider_request_id,
+              t.provider_event_id, t.warnings, t.safe_error_category,
+              t.request_started_at, t.response_received_at, t.next_diagnostic_at,
+              t.actor, t.accepted, t.validation_only, t.created_at,
+              NULL::uuid AS job_id, false AS retryable
+         FROM analytics_activation_destination_tests t
+         JOIN analytics_activation_destinations d ON d.id=t.destination_id
+        WHERE t.destination_id=$1 AND d.site_id=$2
+       UNION ALL
+       SELECT a.id, 'delivery'::text AS kind, a.mapping_version, a.provider_request_id,
+              a.provider_event_id, a.warnings, a.safe_error_category,
+              a.request_started_at, a.response_received_at, a.next_diagnostic_at,
+              a.actor, a.accepted, false AS validation_only, a.created_at,
+              CASE WHEN j.status IN ('failed','expired')
+                         AND d.status='active'
+                         AND d.readiness IN ('verified','live','degraded')
+                   THEN j.id ELSE NULL END AS job_id,
+              (j.status IN ('failed','expired')
+                AND d.status='active'
+                AND d.readiness IN ('verified','live','degraded')) AS retryable
+         FROM analytics_activation_delivery_attempts a
+         JOIN analytics_activation_destinations d ON d.id=a.destination_id
+         JOIN analytics_activation_jobs j ON j.id=a.job_id
+        WHERE a.destination_id=$1 AND d.site_id=$2
+     ) receipts ORDER BY created_at DESC LIMIT $3`,
+    [input.destinationId, input.siteId, limit]
+  );
+  return result.rows.map((row) => {
+    const record = row;
+    if (record.kind === "delivery" && record.retryable === true && typeof record.job_id === "string") {
+      return record;
+    }
+    const safeReceipt = { ...record };
+    delete safeReceipt.job_id;
+    return { ...safeReceipt, retryable: false };
+  });
+}
+async function retryAnalyticsActivationJob(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const result = await db.query(
+    `UPDATE analytics_activation_jobs j
+        SET status='pending', next_attempt_at=now(), lease_until=NULL,
+            dead_lettered_at=NULL, last_error_code=NULL, response_category=NULL
+       FROM analytics_activation_destinations d
+      WHERE j.id=$1 AND d.id=j.destination_id AND d.site_id=$2
+        AND d.status='active' AND d.readiness IN ('verified','live','degraded')
+        AND j.status IN ('failed','expired')
+      RETURNING j.id, j.status, j.attempts, j.next_attempt_at`,
+    [input.jobId, input.siteId]
+  );
+  const job = result.rows[0];
+  if (!job) {
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_retry_conflict",
+      "Only a failed delivery for an active verified destination can be retried.",
+      409
+    );
+  }
+  return job;
+}
+function safeDiagnosticSummary(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  const destinations = Array.isArray(record.destinations) ? record.destinations.filter((entry) => Boolean(entry && typeof entry === "object")) : [];
+  const warnings = destinations.flatMap((entry) => {
+    const warningRows = Array.isArray(entry.warnings) ? entry.warnings : [];
+    return warningRows.map((warning) => {
+      const row = warning && typeof warning === "object" ? warning : {};
+      return `${String(row.reason ?? "provider_warning").slice(0, 200)}: ${String(row.count ?? 0).slice(0, 20)}`;
+    });
+  }).slice(0, 50);
+  const hasErrors = destinations.some((entry) => Array.isArray(entry.errors) && entry.errors.length > 0);
+  const pending = destinations.some((entry) => /pending|processing|received/i.test(String(entry.status ?? "")));
+  return { warnings, ...hasErrors ? { errorCategory: "activation_provider_diagnostic_rejected" } : {}, pending };
+}
+async function pollAnalyticsActivationDiagnostics(input) {
+  const destination = await loadActivationDestinationForEditor(input);
+  const definition = assertConnectionSupportsProvider(input.validatedConnection, destination.platform);
+  if (!definition.supportsDiagnostics || !definition.diagnosticsActionName || !destination.connection_ref) {
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_diagnostics_unavailable",
+      "Diagnostics are not available for this activation provider.",
+      409
+    );
+  }
+  if (destination.connection_ref !== input.validatedConnection.id) {
+    throw new AnalyticsRepositoryError(
+      "analytics_provider_action_unavailable",
+      "The selected connection cannot read diagnostics for this destination.",
+      409
+    );
+  }
+  const testResult = await getAnalyticsPool().query(
+    `SELECT id, provider_request_id FROM analytics_activation_destination_tests
+      WHERE destination_id=$1 AND provider_request_id IS NOT NULL
+      ORDER BY created_at DESC LIMIT 1`,
+    [destination.id]
+  );
+  const test = testResult.rows[0];
+  if (!test) {
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_diagnostics_unavailable",
+      "No provider request is available for diagnostics.",
+      409
+    );
+  }
+  const raw = await input.runAction({
+    connectionRef: destination.connection_ref,
+    actionName: definition.diagnosticsActionName,
+    idempotencyKey: `xray-diagnostics:${test.id}`,
+    payload: { requestId: test.provider_request_id }
+  });
+  const summary = safeDiagnosticSummary(raw);
+  await getAnalyticsPool().query(
+    `UPDATE analytics_activation_destination_tests
+        SET warnings=$2::jsonb, safe_error_category=$3,
+            next_diagnostic_at=CASE WHEN $4 THEN now()+interval '5 minutes' ELSE NULL END
+      WHERE id=$1`,
+    [test.id, JSON.stringify(summary.warnings), summary.errorCategory ?? null, summary.pending]
+  );
+  let readiness = destination.readiness;
+  if (summary.errorCategory && ["verified", "live"].includes(destination.readiness)) {
+    readiness = await setAnalyticsActivationReadiness({
+      siteId: input.siteId,
+      destinationId: destination.id,
+      expectedReadiness: [destination.readiness],
+      nextReadiness: "degraded",
+      evidenceKind: "provider_diagnostic",
+      evidenceId: test.id
+    });
+  }
+  return { testId: test.id, readiness, ...summary };
+}
 async function queueAnalyticsActivation(input) {
   const db = getAnalyticsPool();
   const destinations = await db.query(
-    `SELECT id FROM analytics_activation_destinations WHERE site_id = $1 AND status = 'active'`,
+    `SELECT id FROM analytics_activation_destinations
+      WHERE site_id = $1 AND status = 'active' AND readiness IN ('verified','live')`,
     [input.siteId]
   );
   let queued = 0;
@@ -2571,7 +4593,7 @@ async function queueAnalyticsActivation(input) {
       `INSERT INTO analytics_activation_jobs(id, destination_id, conversion_id, person_id, payload_ciphertext)
        VALUES ($1,$2,$3,$4,$5) ON CONFLICT(destination_id, conversion_id) DO NOTHING`,
       [
-        randomUUID(),
+        randomUUID2(),
         destination.id,
         input.conversionId,
         input.personId ?? null,
@@ -2583,7 +4605,7 @@ async function queueAnalyticsActivation(input) {
   return queued;
 }
 async function queueAnalyticsFormDelivery(input) {
-  const id = randomUUID();
+  const id = randomUUID2();
   await getAnalyticsPool().query(
     `INSERT INTO analytics_form_delivery_jobs(id, submission_id, owner_user_id, payload_ciphertext, last_error_code)
      VALUES ($1,$2,$3,$4,$5)`,
@@ -2597,6 +4619,36 @@ async function queueAnalyticsFormDelivery(input) {
   );
   return id;
 }
+async function sweepAnalyticsRestrictedRetention() {
+  const db = getAnalyticsPool();
+  const client = await db.connect();
+  try {
+    await client.query("BEGIN");
+    const restricted = await client.query(
+      `DELETE FROM analytics_restricted_data WHERE expires_at <= now()`
+    );
+    const webhooks = await client.query(
+      `UPDATE analytics_webhook_receipts SET payload_ciphertext=NULL
+       WHERE payload_ciphertext IS NOT NULL AND payload_expires_at <= now()`
+    );
+    const imports = await client.query(
+      `UPDATE analytics_crm_import_rows SET delivery_status='expired', lease_until=NULL,
+       last_error_code='retention_expired'
+       WHERE delivery_status='pending' AND expires_at <= now()`
+    );
+    await client.query("COMMIT");
+    return {
+      restrictedDeleted: restricted.rowCount ?? 0,
+      webhookPayloadsCleared: webhooks.rowCount ?? 0,
+      expiredImportRows: imports.rowCount ?? 0
+    };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
 async function claimAnalyticsFormDeliveryJobs(limit = 10) {
   const result = await getAnalyticsPool().query(
     `WITH due AS (
@@ -2710,7 +4762,7 @@ async function analyticsHealth(siteId, userId) {
 }
 async function refreshAnalyticsDailyRollups(input) {
   const db = getAnalyticsPool();
-  const runId = randomUUID();
+  const runId = randomUUID2();
   await db.query(
     `INSERT INTO analytics_rollup_runs(id, window_start, window_end, status) VALUES ($1, $2, $3, 'running')`,
     [runId, input.start, input.end]
@@ -2907,7 +4959,7 @@ async function createAnalyticsExport(input) {
       `Generated ${(/* @__PURE__ */ new Date()).toISOString()} from the governed ${input.report} report contract.`
     ].join("\n");
   }
-  const id = randomUUID();
+  const id = randomUUID2();
   const inserted = await getAnalyticsPool().query(
     `INSERT INTO analytics_exports(id, site_id, requested_by_user_id, idempotency_key, report, format, filters, content)
      VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8)
@@ -2945,11 +4997,30 @@ export {
   getSessionSecret,
   signSession,
   verifySession,
+  ensureServiceConnectionsSchema,
+  reconcileDiscoveredNangoConnections,
+  listServiceConnections,
+  getOwnedServiceConnection,
+  updateServiceConnectionTools,
+  setServiceConnectionProviderIdentity,
+  setServiceConnectionUserLabel,
+  recordServiceConnectionHealth,
+  setServiceConnectionActions,
+  markServiceConnectionDisconnected,
+  recordServiceConnectionAction,
+  claimServiceConnectionAction,
+  AnalyticsProviderRegistryError,
+  getAnalyticsProviderDefinition,
+  assertConnectionSupportsProvider,
+  buildProviderDeliveryRequest,
+  normalizeProviderReceipt,
   AnalyticsRepositoryError,
   getAnalyticsPool,
   closeAnalyticsPool,
   migrateAnalytics,
   normalizeObservedHostname,
+  requireAnalyticsAccess,
+  requireAnalyticsEditor,
   createAnalyticsSite,
   listAnalyticsSites,
   updateAnalyticsBusinessModel,
@@ -2961,6 +5032,10 @@ export {
   listAnalyticsPixels,
   updateAnalyticsPixel,
   setAnalyticsPixelDomainState,
+  upsertAnalyticsHostGroup,
+  listAnalyticsHostGroups,
+  prepareAnalyticsLinkerIssue,
+  redeemAnalyticsLinkerRecord,
   MAX_ENGAGED_MS,
   ENGAGED_SESSION_MS,
   normalizeAnalyticsPath,
@@ -2988,16 +5063,27 @@ export {
   getPublicAnalyticsForm,
   recordAnalyticsFormSubmission,
   sanitizeClickIds,
+  identityHmac,
   linkAnalyticsFormIdentity,
   listAnalyticsPeople,
   getAnalyticsPersonJourney,
   createAnalyticsCrmImport,
   listAnalyticsCrmImports,
+  claimAnalyticsCrmImportRows,
+  completeAnalyticsCrmImportRow,
+  deferAnalyticsCrmImportRow,
   createAnalyticsActivationDestination,
   listAnalyticsActivationDestinations,
   archiveAnalyticsActivationDestination,
+  getAnalyticsActivationDestinationConnectionRef,
+  setAnalyticsActivationReadiness,
+  testAnalyticsActivationDestination,
+  listAnalyticsActivationReceipts,
+  retryAnalyticsActivationJob,
+  pollAnalyticsActivationDiagnostics,
   queueAnalyticsActivation,
   queueAnalyticsFormDelivery,
+  sweepAnalyticsRestrictedRetention,
   claimAnalyticsFormDeliveryJobs,
   completeAnalyticsFormDelivery,
   deferAnalyticsFormDelivery,