mcp-scraper 0.74.0 → 0.75.1

package/dist/{chunk-52PVP5P2.js → chunk-IBQNOZ7E.js}

@@ -438,7 +438,7 @@ function buildGoogleDeliveryRequest(destinationId, payload) {
     );
   }
   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 currency2 = boundedString(payload.currency, 3)?.toUpperCase();
   const actionSource = boundedString(payload.actionSource, 64);
   const consent = googleConsent(payload);
   return {
@@ -454,7 +454,7 @@ function buildGoogleDeliveryRequest(destinationId, payload) {
       ...wbraid ? { wbraid } : {},
       ...emailSha256 ? { emailSha256: [emailSha256] } : {},
       ...phoneSha256 ? { phoneSha256: [phoneSha256] } : {},
-      ...valueMinor !== void 0 && currency ? { conversionValue: valueMinor / 100, currency } : {},
+      ...valueMinor !== void 0 && currency2 ? { conversionValue: valueMinor / 100, currency: currency2 } : {},
       ...consent ? { consent } : {}
     }],
     ...consent ? { consent } : {},
@@ -491,20 +491,26 @@ function metaUserData(payload) {
 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 currency2 = boundedString(payload.currency, 3)?.toUpperCase();
   const orderId = boundedString(payload.orderId, 240);
   const customData = {
     ...valueMinor !== void 0 && valueMinor >= 0 ? { value: valueMinor / 100 } : {},
-    ...currency ? { currency } : {},
+    ...currency2 ? { currency: currency2 } : {},
     ...orderId ? { order_id: orderId } : {}
   };
   const eventId = boundedString(payload.eventId, 255);
+  if (!eventId) {
+    throw new AnalyticsProviderRegistryError(
+      "analytics_provider_destination_required",
+      "Meta requires the stable X-Ray conversion ID for event deduplication."
+    );
+  }
   const eventSourceUrl = boundedString(payload.sourceUrl);
   const event = {
     eventName,
     eventTime: metaEventTime(payload.eventTime),
     actionSource: actionSource && META_ACTION_SOURCES.has(actionSource) ? actionSource : "system_generated",
-    ...eventId ? { eventId } : {},
+    eventId,
     ...eventSourceUrl ? { eventSourceUrl } : {},
     userData: metaUserData(payload),
     ...Object.keys(customData).length ? { customData } : {}
@@ -555,7 +561,7 @@ function buildTikTokDeliveryRequest(destinationId, eventName, payload) {
   }
   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 currency2 = boundedString(payload.currency, 3)?.toUpperCase();
   const sourceUrl = boundedString(payload.sourceUrl, 2048);
   const referrer = boundedString(payload.referrer, 2048);
   const orderId = boundedString(payload.orderId, 255);
@@ -568,7 +574,7 @@ function buildTikTokDeliveryRequest(destinationId, eventName, payload) {
       eventTime,
       userData,
       ...sourceUrl ? { page: { url: sourceUrl, ...referrer ? { referrer } : {} } } : {},
-      ...valueMinor !== void 0 && currency ? { properties: { value: valueMinor / 100, currency, ...orderId ? { orderId } : {} } } : orderId ? { properties: { orderId } } : {}
+      ...valueMinor !== void 0 && currency2 ? { properties: { value: valueMinor / 100, currency: currency2, ...orderId ? { orderId } : {} } } : orderId ? { properties: { orderId } } : {}
     }],
     ...testEventCode ? { testEventCode } : {},
     schemaValidationOnly: false
@@ -630,7 +636,7 @@ function buildRedditDeliveryRequest(destinationId, eventName, payload) {
   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 currency2 = 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);
@@ -644,7 +650,7 @@ function buildRedditDeliveryRequest(destinationId, eventName, payload) {
       ...sourceUrl ? { eventSourceUrl: sourceUrl } : {},
       trackingType,
       ...trackingType === "CUSTOM" ? { customEventName: eventName.slice(0, 64) } : {},
-      ...valueMinor !== void 0 && currency ? { value: valueMinor / 100, currency } : {},
+      ...valueMinor !== void 0 && currency2 ? { value: valueMinor / 100, currency: currency2 } : {},
       ...itemCount !== void 0 ? { itemCount } : {},
       user
     }],
@@ -722,13 +728,82 @@ function assertProviderDestination(platform, destinationId) {
   }
   return trimmed;
 }
-function assertSafeAnalyticsEventMapping(eventMapping) {
+function validMappingName(value, max) {
+  return typeof value === "string" && value.trim().length > 0 && value.trim().length <= max && /^[a-zA-Z][a-zA-Z0-9_.: -]*$/.test(value.trim());
+}
+function normalizeAnalyticsActivationEventMapping(eventMapping) {
   if (eventMapping && Object.prototype.hasOwnProperty.call(eventMapping, "__tool")) {
     throw new AnalyticsProviderRegistryError(
       "analytics_provider_action_unavailable",
       "Activation action selection is managed by X-Ray."
     );
   }
+  if (!eventMapping) return { schemaVersion: 1, mappings: [] };
+  if ("schemaVersion" in eventMapping || "mappings" in eventMapping) {
+    const candidate = eventMapping;
+    if (candidate.schemaVersion !== 1 || !Array.isArray(candidate.mappings) || candidate.mappings.length > 200) {
+      throw new AnalyticsProviderRegistryError(
+        "analytics_provider_destination_required",
+        "Activation mappings must use the supported versioned mapping contract."
+      );
+    }
+    const mappings2 = candidate.mappings.map((row) => {
+      if (!row || typeof row !== "object" || !validMappingName(row.source, 160) || !validMappingName(row.providerEvent, 160) || typeof row.enabled !== "boolean" || !["primary", "observation"].includes(row.role) || !["none", "event", "fixed"].includes(row.valueMode)) {
+        throw new AnalyticsProviderRegistryError(
+          "analytics_provider_destination_required",
+          "Activation mapping contains an unsupported event, role, or value mode."
+        );
+      }
+      const currency2 = row.currency?.trim().toUpperCase();
+      if (row.valueMode === "fixed" && (!Number.isFinite(row.fixedValue) || Number(row.fixedValue) < 0 || Number(row.fixedValue) > 1e9 || !currency2 || !/^[A-Z]{3}$/.test(currency2))) {
+        throw new AnalyticsProviderRegistryError(
+          "analytics_provider_destination_required",
+          "Fixed activation values require a non-negative value and ISO currency."
+        );
+      }
+      return {
+        source: row.source.trim(),
+        providerEvent: row.providerEvent.trim(),
+        enabled: row.enabled,
+        role: row.role,
+        valueMode: row.valueMode,
+        ...row.valueMode === "fixed" ? { fixedValue: Number(row.fixedValue), currency: currency2 } : {}
+      };
+    });
+    const enabled = mappings2.filter((row) => row.enabled);
+    if (enabled.length && enabled.filter((row) => row.role === "primary").length !== 1) {
+      throw new AnalyticsProviderRegistryError(
+        "analytics_provider_destination_required",
+        "Enabled activation mappings require exactly one primary optimization event."
+      );
+    }
+    if (new Set(mappings2.map((row) => row.source.toLowerCase())).size !== mappings2.length) {
+      throw new AnalyticsProviderRegistryError(
+        "analytics_provider_destination_required",
+        "Each X-Ray event may be mapped only once per destination."
+      );
+    }
+    return { schemaVersion: 1, mappings: mappings2 };
+  }
+  const mappings = Object.entries(eventMapping).map(([source, providerEvent], index) => {
+    if (!validMappingName(source, 160) || !validMappingName(providerEvent, 160)) {
+      throw new AnalyticsProviderRegistryError(
+        "analytics_provider_destination_required",
+        "Activation mapping contains an invalid event name."
+      );
+    }
+    return {
+      source: source.trim(),
+      providerEvent: providerEvent.trim(),
+      enabled: true,
+      role: index === 0 ? "primary" : "observation",
+      valueMode: "event"
+    };
+  });
+  return { schemaVersion: 1, mappings };
+}
+function assertSafeAnalyticsEventMapping(eventMapping) {
+  normalizeAnalyticsActivationEventMapping(eventMapping);
 }
 function assertConnectionSupportsProvider(connection, platform) {
   const definition = getAnalyticsProviderDefinition(platform);
@@ -746,22 +821,42 @@ function assertConnectionSupportsProvider(connection, platform) {
 }
 function mappedEventName(input) {
   const canonical = String(input.payload.eventName || "conversion");
-  return input.eventMapping?.[canonical] || canonical;
+  const mapping = normalizeAnalyticsActivationEventMapping(input.eventMapping).mappings.find((row) => row.enabled && row.source === canonical);
+  return mapping?.providerEvent || canonical;
+}
+function analyticsActivationMappingEligible(eventMapping, sourceEvent) {
+  const normalized = normalizeAnalyticsActivationEventMapping(eventMapping);
+  return normalized.mappings.length === 0 || normalized.mappings.some((row) => row.enabled && row.source === sourceEvent);
+}
+function mappedPayload(input) {
+  const canonical = String(input.payload.eventName || "conversion");
+  const mapping = normalizeAnalyticsActivationEventMapping(input.eventMapping).mappings.find((row) => row.enabled && row.source === canonical);
+  if (!mapping || mapping.valueMode === "event") return input.payload;
+  const payload = { ...input.payload };
+  if (mapping.valueMode === "none") {
+    delete payload.valueMinor;
+    delete payload.currency;
+    return payload;
+  }
+  payload.valueMinor = Math.round((mapping.fixedValue ?? 0) * 100);
+  payload.currency = mapping.currency;
+  return payload;
 }
 function buildProviderDeliveryRequest(input) {
   const destinationId = assertProviderDestination(input.platform, input.destinationId);
   assertSafeAnalyticsEventMapping(input.eventMapping);
   const eventName = mappedEventName(input);
+  const payload = mappedPayload(input);
   if (input.platform === "meta") {
-    return buildMetaDeliveryRequest(destinationId, eventName, input.payload);
+    return buildMetaDeliveryRequest(destinationId, eventName, payload);
   }
   if (input.platform === "google") {
-    return buildGoogleDeliveryRequest(destinationId, input.payload);
+    return buildGoogleDeliveryRequest(destinationId, payload);
   }
   if (input.platform === "tiktok") {
-    return buildTikTokDeliveryRequest(destinationId, eventName, input.payload);
+    return buildTikTokDeliveryRequest(destinationId, eventName, payload);
   }
-  return buildRedditDeliveryRequest(destinationId, eventName, input.payload);
+  return buildRedditDeliveryRequest(destinationId, eventName, payload);
 }
 function buildProviderTestRequest(input) {
   const definition = getAnalyticsProviderDefinition(input.platform);
@@ -813,14 +908,502 @@ function normalizeProviderReceipt(platform, receipt, stableEventId) {
   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;
+  const providerErrors = Array.isArray(record.errors) ? record.errors : [];
+  const googlePartialFailure = platform === "google" && (/PARTIAL_SUCCESS/i.test(String(record.status ?? "")) || partiallyAccepted) && (providerErrors.length > 0 || (eventsRejected ?? 0) > 0);
+  const googlePending = platform === "google" && record.acceptedForProcessing === true && Boolean(optionalString(record, "requestId")) && !googlePartialFailure;
+  const generallyAccepted = record.accepted === true || record.success === true || record.providerAccepted === true || (eventsReceived ?? 0) > 0;
   return {
-    accepted: record.schemaValidationOnly !== true && (record.accepted === true || record.success === true || record.providerAccepted === true || record.acceptedForProcessing === true || (eventsReceived ?? 0) > 0),
+    accepted: record.schemaValidationOnly !== true && !googlePartialFailure && (platform === "google" ? generallyAccepted && !googlePending : generallyAccepted),
+    ...googlePending ? { pending: true } : {},
     ...partiallyAccepted ? { partiallyAccepted: true } : {},
-    ...optionalString(record, "requestId", "receiptId", "id") ? { requestId: optionalString(record, "requestId", "receiptId", "id") } : {},
+    ...optionalString(record, "requestId", "receiptId", "fbtraceId", "fbtrace_id", "id") ? { requestId: optionalString(record, "requestId", "receiptId", "fbtraceId", "fbtrace_id", "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
+    warnings: [...warnings, ...providerErrors.map((value) => {
+      const error = recordValue(value);
+      return [boundedString(error.reason, 200), boundedString(error.field, 200), boundedString(error.description, 500)].filter(Boolean).join(": ") || "provider_error";
+    })].slice(0, 50)
+  };
+}
+
+// src/api/analytics-attribution-reports.ts
+var CREDIT_SCALE = 1e6;
+var ANALYTICS_ATTRIBUTION_MODELS = [
+  "first_touch",
+  "last_touch",
+  "last_non_direct",
+  "linear",
+  "time_decay",
+  "position_based",
+  "custom_weighted"
+];
+var ANALYTICS_ATTRIBUTION_WINDOWS = [7, 14, 30, 60, 90, 180, 365, "lifetime"];
+var AnalyticsAttributionReportError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AnalyticsAttributionReportError";
+  }
+  code;
+};
+function normalizeAnalyticsAttributionModel(model) {
+  const normalized = model === "position_40_20_40" ? "position_based" : model;
+  if (!ANALYTICS_ATTRIBUTION_MODELS.includes(normalized)) {
+    throw new AnalyticsAttributionReportError("invalid_model", `Unsupported attribution model: ${model}.`);
+  }
+  return normalized;
+}
+function instant(value, field) {
+  const milliseconds = value instanceof Date ? value.getTime() : Date.parse(value);
+  if (!Number.isFinite(milliseconds)) throw new AnalyticsAttributionReportError("invalid_timestamp", `${field} must be a valid timestamp.`);
+  return milliseconds;
+}
+function minorUnits(value, field) {
+  if (value == null) return 0n;
+  try {
+    const parsed = typeof value === "bigint" ? value : BigInt(value);
+    if (parsed < 0n) throw new Error("negative");
+    return parsed;
+  } catch {
+    throw new AnalyticsAttributionReportError("invalid_minor_units", `${field} must be a non-negative integer.`);
+  }
+}
+function currency(value) {
+  if (value == null || value.trim() === "") return null;
+  const normalized = value.trim().toUpperCase();
+  if (!/^[A-Z]{3}$/.test(normalized)) throw new AnalyticsAttributionReportError("invalid_currency", `Invalid currency ${value}.`);
+  return normalized;
+}
+function isDirect(touch) {
+  return touch.touchKind === "direct" || touch.source?.trim().toLowerCase() === "(direct)" && ["(none)", "none", ""].includes(touch.medium?.trim().toLowerCase() ?? "");
+}
+function windowForTouch(touch, config) {
+  return touch.touchKind === "view" ? config.viewWindow ?? 90 : config.clickWindow ?? 90;
+}
+function eligibleTouches(touches, conversion, config) {
+  const conversionTime = instant(conversion.occurredAt, "conversion.occurredAt");
+  return touches.filter((touch) => touch.subjectRef === conversion.subjectRef && touch.journeyTier === conversion.journeyTier).filter((touch) => {
+    const touchTime = instant(touch.occurredAt, "touch.occurredAt");
+    if (touchTime > conversionTime) return false;
+    const window = windowForTouch(touch, config);
+    return window === "lifetime" || conversionTime - touchTime <= window * 864e5;
+  }).sort((left, right) => instant(left.occurredAt, "touch.occurredAt") - instant(right.occurredAt, "touch.occurredAt") || left.touchId.localeCompare(right.touchId));
+}
+function customWeight(touch, weights) {
+  const selectors = [
+    `touch:${touch.touchId}`,
+    touch.adId ? `ad:${touch.adId}` : null,
+    touch.adSetId ? `ad_set:${touch.adSetId}` : null,
+    touch.campaignId ? `campaign:${touch.campaignId}` : null,
+    touch.platform ? `platform:${touch.platform}` : null,
+    touch.source ? `source:${touch.source}` : null,
+    touch.medium ? `medium:${touch.medium}` : null,
+    `touch_kind:${touch.touchKind}`,
+    "default"
+  ];
+  for (const selector of selectors) if (selector && weights[selector] != null) return weights[selector];
+  return 0;
+}
+function rawWeights(touches, config) {
+  if (touches.length === 0) return [];
+  if (config.model === "first_touch") return touches.map((_, index) => index === 0 ? 1 : 0);
+  if (config.model === "last_touch") return touches.map((_, index) => index === touches.length - 1 ? 1 : 0);
+  if (config.model === "last_non_direct") {
+    let index = -1;
+    for (let cursor = touches.length - 1; cursor >= 0; cursor -= 1) {
+      if (!isDirect(touches[cursor])) {
+        index = cursor;
+        break;
+      }
+    }
+    if (index === -1) index = touches.length - 1;
+    return touches.map((_, cursor) => cursor === index ? 1 : 0);
+  }
+  if (config.model === "linear") return touches.map(() => 1);
+  if (config.model === "time_decay") {
+    const halfLife = config.timeDecayHalfLifeDays ?? 7;
+    if (!Number.isFinite(halfLife) || halfLife <= 0) throw new AnalyticsAttributionReportError("invalid_half_life", "Time-decay half-life must be positive.");
+    const newestTouchTime = Math.max(...touches.map((touch) => instant(touch.occurredAt, "touch.occurredAt")));
+    return touches.map((touch) => Math.pow(0.5, (newestTouchTime - instant(touch.occurredAt, "touch.occurredAt")) / 864e5 / halfLife));
+  }
+  if (config.model === "position_based" || config.model === "position_40_20_40") {
+    if (touches.length === 1) return [1];
+    if (touches.length === 2) return [0.5, 0.5];
+    return touches.map((_, index) => index === 0 || index === touches.length - 1 ? 0.4 : 0.2 / (touches.length - 2));
+  }
+  const weights = config.customWeights;
+  if (!weights || Object.keys(weights).length === 0) throw new AnalyticsAttributionReportError("custom_weights_required", "Custom-weighted attribution requires at least one selector.");
+  for (const [selector, weight] of Object.entries(weights)) {
+    if (!selector.trim() || !Number.isFinite(weight) || weight < 0) throw new AnalyticsAttributionReportError("invalid_custom_weight", `Invalid custom weight for ${selector || "(empty)"}.`);
+  }
+  const positionalKeys = /* @__PURE__ */ new Set(["first", "middle", "last"]);
+  if (Object.keys(weights).every((key) => positionalKeys.has(key))) {
+    const first = weights.first ?? 0;
+    const middle = weights.middle ?? 0;
+    const last = weights.last ?? 0;
+    if (touches.length === 1) return [first + middle + last];
+    if (touches.length === 2) return [first + middle / 2, last + middle / 2];
+    return touches.map((_, index) => index === 0 ? first : index === touches.length - 1 ? last : middle / (touches.length - 2));
+  }
+  return touches.map((touch) => customWeight(touch, weights));
+}
+function allocateMicros(weights) {
+  if (weights.length === 0) return [];
+  const total = weights.reduce((sum, value) => sum + value, 0);
+  if (!Number.isFinite(total) || total <= 0) throw new AnalyticsAttributionReportError("zero_attribution_weight", "Eligible touches must have a positive total weight.");
+  const exact = weights.map((value) => value / total * CREDIT_SCALE);
+  const floors = exact.map((value) => Math.floor(value));
+  let remainder = CREDIT_SCALE - floors.reduce((sum, value) => sum + value, 0);
+  const order = exact.map((value, index) => ({ index, fraction: value - floors[index] })).sort((left, right) => right.fraction - left.fraction || left.index - right.index);
+  for (let cursor = 0; cursor < remainder; cursor += 1) floors[order[cursor % order.length].index] += 1;
+  return floors;
+}
+function allocateMinor(total, micros) {
+  if (micros.length === 0) return [];
+  const scale = BigInt(CREDIT_SCALE);
+  const floors = micros.map((value) => total * BigInt(value) / scale);
+  let remainder = total - floors.reduce((sum, value) => sum + value, 0n);
+  const order = micros.map((value, index) => ({ index, remainder: total * BigInt(value) % scale })).sort((left, right) => left.remainder === right.remainder ? left.index - right.index : left.remainder > right.remainder ? -1 : 1);
+  let cursor = 0;
+  while (remainder > 0n) {
+    floors[order[cursor % order.length].index] += 1n;
+    remainder -= 1n;
+    cursor += 1;
+  }
+  return floors;
+}
+function dimensionsAtGranularity(source, granularity) {
+  const output = { platform: source.platform?.trim() || null };
+  if (granularity === "platform") return output;
+  output.accountId = source.accountId?.trim() || null;
+  if (granularity === "account") return output;
+  output.campaignId = source.campaignId?.trim() || null;
+  output.campaignName = source.campaignName?.trim() || null;
+  if (granularity === "campaign") return output;
+  output.adSetId = source.adSetId?.trim() || null;
+  output.adSetName = source.adSetName?.trim() || null;
+  if (granularity === "ad_set") return output;
+  output.adId = source.adId?.trim() || null;
+  output.adName = source.adName?.trim() || null;
+  return output;
+}
+function dimensionKey(value, granularity) {
+  const dimensions = dimensionsAtGranularity(value, granularity);
+  return [dimensions.platform, dimensions.accountId, dimensions.campaignId, dimensions.adSetId, dimensions.adId].filter((_, index) => index <= ["platform", "account", "campaign", "ad_set", "ad"].indexOf(granularity)).map((item) => item || "(missing)").join("|");
+}
+function missingDimension(value, granularity) {
+  const dimensions = dimensionsAtGranularity(value, granularity);
+  if (!dimensions.platform) return true;
+  if (granularity !== "platform" && !dimensions.accountId) return true;
+  if (["campaign", "ad_set", "ad"].includes(granularity) && !dimensions.campaignId) return true;
+  if (["ad_set", "ad"].includes(granularity) && !dimensions.adSetId) return true;
+  return granularity === "ad" && !dimensions.adId;
+}
+function makeCredits(conversions, touches, config) {
+  const credits = [];
+  for (const conversion of conversions) {
+    const eligible = eligibleTouches(touches, conversion, config);
+    const conversionCurrency = currency(conversion.currency);
+    const value = minorUnits(conversion.valueMinor, "conversion.valueMinor");
+    if (eligible.length === 0) {
+      credits.push({
+        conversionId: conversion.conversionId,
+        touchId: null,
+        subjectRef: conversion.subjectRef,
+        journeyTier: conversion.journeyTier,
+        occurredAt: new Date(instant(conversion.occurredAt, "conversion.occurredAt")).toISOString(),
+        outcome: conversion.outcome,
+        creditMicros: CREDIT_SCALE,
+        creditedValueMinor: value.toString(),
+        currency: conversionCurrency,
+        unattributed: true
+      });
+      continue;
+    }
+    const micros = allocateMicros(rawWeights(eligible, config));
+    const values = allocateMinor(value, micros);
+    eligible.forEach((touch, index) => {
+      if (micros[index] === 0) return;
+      credits.push({
+        ...dimensionsAtGranularity(touch, "ad"),
+        conversionId: conversion.conversionId,
+        touchId: touch.touchId,
+        subjectRef: conversion.subjectRef,
+        journeyTier: conversion.journeyTier,
+        occurredAt: new Date(instant(conversion.occurredAt, "conversion.occurredAt")).toISOString(),
+        outcome: conversion.outcome,
+        creditMicros: micros[index],
+        creditedValueMinor: values[index].toString(),
+        currency: conversionCurrency,
+        unattributed: false
+      });
+    });
+  }
+  return credits;
+}
+function efficiencyRows(credits, spendFacts, granularity) {
+  const rows = /* @__PURE__ */ new Map();
+  const rowFor = (key, dimensions, unattributed) => {
+    let row = rows.get(key);
+    if (!row) {
+      row = { dimensions, unattributed, leadMicros: 0, qualifiedMicros: 0, conversionMicros: 0, customerMicros: 0, revenueMinor: 0n, spendMinor: 0n, currencies: /* @__PURE__ */ new Set(), spendFacts: 0, matchedSpendFacts: 0, missingDimension: missingDimension(dimensions, granularity), hasCredits: false };
+      rows.set(key, row);
+    }
+    return row;
+  };
+  let missingDimensionCredits = 0;
+  for (const credit of credits) {
+    const dimensions = credit.unattributed ? {} : dimensionsAtGranularity(credit, granularity);
+    const key = credit.unattributed ? "(unattributed)" : dimensionKey(dimensions, granularity);
+    const row = rowFor(key, dimensions, credit.unattributed);
+    row.hasCredits = true;
+    if (!credit.unattributed && row.missingDimension) missingDimensionCredits += 1;
+    if (credit.outcome === "lead") row.leadMicros += credit.creditMicros;
+    if (credit.outcome === "qualified") row.qualifiedMicros += credit.creditMicros;
+    if (credit.outcome === "conversion") row.conversionMicros += credit.creditMicros;
+    if (credit.outcome === "customer") row.customerMicros += credit.creditMicros;
+    row.revenueMinor += BigInt(credit.creditedValueMinor);
+    if (credit.currency) row.currencies.add(credit.currency);
+  }
+  let unmatchedSpendFactCount = 0;
+  for (const fact of spendFacts) {
+    const dimensions = dimensionsAtGranularity(fact, granularity);
+    const key = dimensionKey(dimensions, granularity);
+    const row = rowFor(key, dimensions, false);
+    row.spendMinor += minorUnits(fact.spendMinor, "spendFact.spendMinor");
+    row.currencies.add(currency(fact.currency));
+    row.spendFacts += 1;
+    if (row.hasCredits && !row.missingDimension) row.matchedSpendFacts += 1;
+    else unmatchedSpendFactCount += 1;
+  }
+  const allCurrencies = /* @__PURE__ */ new Set();
+  for (const row of rows.values()) for (const item of row.currencies) allCurrencies.add(item);
+  if (allCurrencies.size > 1) throw new AnalyticsAttributionReportError("mixed_currencies", `Attribution reports require one currency; received ${[...allCurrencies].sort().join(", ")}.`);
+  const result = [...rows.entries()].map(([key, row]) => {
+    const leadCredit = row.leadMicros / CREDIT_SCALE;
+    const qualifiedCredit = row.qualifiedMicros / CREDIT_SCALE;
+    const conversionCredit = row.conversionMicros / CREDIT_SCALE;
+    const customerCredit = row.customerMicros / CREDIT_SCALE;
+    const spend = Number(row.spendMinor);
+    const revenue = Number(row.revenueMinor);
+    const hasSpend = row.spendFacts > 0;
+    const safeRatio = (denominator) => hasSpend && denominator > 0 ? spend / denominator : null;
+    return {
+      ...row.dimensions,
+      key,
+      unattributed: row.unattributed,
+      leadCredit,
+      qualifiedCredit,
+      conversionCredit,
+      customerCredit,
+      spendMinor: hasSpend ? row.spendMinor.toString() : null,
+      revenueMinor: row.hasCredits && row.currencies.size > 0 ? row.revenueMinor.toString() : null,
+      currency: row.currencies.size === 1 ? [...row.currencies][0] : null,
+      cplMinor: safeRatio(leadCredit),
+      cpqlMinor: safeRatio(qualifiedCredit),
+      cpaMinor: safeRatio(conversionCredit),
+      cacMinor: safeRatio(customerCredit),
+      roas: hasSpend && spend > 0 && row.hasCredits ? revenue / spend : null,
+      coverage: { spendFacts: row.spendFacts, matchedSpendFacts: row.matchedSpendFacts, missingDimension: row.missingDimension }
+    };
+  });
+  return { rows: result.sort((left, right) => left.key.localeCompare(right.key)), unmatchedSpendFactCount, missingDimensionCredits };
+}
+function validateUniqueIds(values, kind) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (!value.id || ids.has(value.id)) throw new AnalyticsAttributionReportError(`invalid_${kind}_id`, `${kind} IDs must be present and unique.`);
+    ids.add(value.id);
+  }
+}
+function buildAnalyticsAttributionReport(input) {
+  const model = normalizeAnalyticsAttributionModel(input.configuration.model);
+  const clickWindow = input.configuration.clickWindow ?? 90;
+  const viewWindow = input.configuration.viewWindow ?? 90;
+  if (!ANALYTICS_ATTRIBUTION_WINDOWS.includes(clickWindow) || !ANALYTICS_ATTRIBUTION_WINDOWS.includes(viewWindow)) throw new AnalyticsAttributionReportError("invalid_window", "Attribution window must be 7, 14, 30, 60, 90, 180, 365 or lifetime.");
+  validateUniqueIds(input.touches.map((touch) => ({ id: touch.touchId })), "touch");
+  validateUniqueIds(input.conversions.map((conversion) => ({ id: conversion.conversionId })), "conversion");
+  validateUniqueIds((input.spendFacts ?? []).map((fact) => ({ id: fact.spendFactId })), "spend_fact");
+  const config = { ...input.configuration, model, clickWindow, viewWindow };
+  const confirmedConversions = input.conversions.filter((item) => item.journeyTier === "confirmed");
+  const candidateConversions = input.conversions.filter((item) => item.journeyTier === "candidate" && item.candidateConfidence === "high");
+  const confirmedCredits = makeCredits(confirmedConversions, input.touches.filter((item) => item.journeyTier === "confirmed"), config);
+  const candidateCredits = makeCredits(candidateConversions, input.touches.filter((item) => item.journeyTier === "candidate" && item.candidateConfidence === "high"), config);
+  const granularity = input.granularity ?? "campaign";
+  const confirmedRows = efficiencyRows(confirmedCredits, input.spendFacts ?? [], granularity);
+  const candidateRows = efficiencyRows(candidateCredits, [], granularity);
+  return {
+    configuration: {
+      id: input.configuration.id ?? `${model}:${clickWindow}:${viewWindow}`,
+      model,
+      clickWindow,
+      viewWindow,
+      timeDecayHalfLifeDays: input.configuration.timeDecayHalfLifeDays ?? 7
+    },
+    confirmed: {
+      credits: confirmedCredits,
+      rows: confirmedRows.rows,
+      conversionCount: confirmedConversions.length,
+      unattributedCount: new Set(confirmedCredits.filter((item) => item.unattributed).map((item) => item.conversionId)).size
+    },
+    candidateAssist: {
+      credits: candidateCredits,
+      rows: candidateRows.rows,
+      conversionCount: candidateConversions.length,
+      unattributedCount: new Set(candidateCredits.filter((item) => item.unattributed).map((item) => item.conversionId)).size,
+      eligibility: "high_confidence_only"
+    },
+    coverage: {
+      touchCount: input.touches.length,
+      conversionCount: input.conversions.length,
+      excludedCandidateConversions: input.conversions.filter((item) => item.journeyTier === "candidate" && item.candidateConfidence !== "high").length,
+      spendFactCount: input.spendFacts?.length ?? 0,
+      unmatchedSpendFactCount: confirmedRows.unmatchedSpendFactCount,
+      missingDimensionCredits: confirmedRows.missingDimensionCredits
+    },
+    providerComparison: input.providerRead ? { availability: "available", provider: input.providerRead.provider, conversionCount: input.providerRead.conversionCount, sourceRef: input.providerRead.sourceRef } : { availability: "unavailable" }
+  };
+}
+function compareAnalyticsAttributionModels(input) {
+  if (input.configurations.length < 1 || input.configurations.length > 3) throw new AnalyticsAttributionReportError("invalid_comparison_count", "Compare between one and three attribution configurations.");
+  const ids = input.configurations.map((config, index) => config.id ?? `${config.model}:${config.clickWindow ?? 90}:${config.viewWindow ?? 90}:${index}`);
+  if (new Set(ids).size !== ids.length) throw new AnalyticsAttributionReportError("duplicate_comparison_id", "Comparison configuration IDs must be unique.");
+  return {
+    evidence: {
+      touchIds: input.touches.map((item) => item.touchId).sort(),
+      conversionIds: input.conversions.map((item) => item.conversionId).sort(),
+      spendFactIds: (input.spendFacts ?? []).map((item) => item.spendFactId).sort()
+    },
+    projections: input.configurations.map((configuration, index) => buildAnalyticsAttributionReport({
+      ...input,
+      configuration: { ...configuration, id: ids[index] }
+    }))
+  };
+}
+async function readImmutableConfirmedAttributionEvidence(input) {
+  const from = new Date(instant(input.from, "from")).toISOString();
+  const to = new Date(instant(input.to, "to")).toISOString();
+  const conversionsResult = await input.client.query(
+    `SELECT id, person_id, occurred_at, conversion_kind, value_minor::text, currency
+       FROM analytics_conversions
+      WHERE site_id = $1 AND person_id IS NOT NULL AND occurred_at >= $2 AND occurred_at < $3
+      ORDER BY occurred_at, id`,
+    [input.siteId, from, to]
+  );
+  const touchesResult = await input.client.query(
+    `SELECT id, person_id, occurred_at, touch_kind, source, medium, platform, account_id, campaign_id, campaign, ad_set_id, ad_id
+       FROM analytics_attribution_touches
+      WHERE site_id = $1 AND person_id IS NOT NULL AND occurred_at < $2
+      ORDER BY occurred_at, id`,
+    [input.siteId, to]
+  );
+  const spendResult = await input.client.query(
+    `SELECT id, bucket, platform, account_id, campaign_id, campaign_name, ad_set_id, ad_set_name, ad_id, ad_name, spend_minor::text, currency, source_ref
+       FROM analytics_ad_spend_facts
+      WHERE site_id = $1 AND bucket >= $2::date AND bucket < $3::date
+      ORDER BY bucket, id`,
+    [input.siteId, from, to]
+  );
+  return {
+    conversions: conversionsResult.rows.map((row) => ({
+      conversionId: row.id,
+      subjectRef: row.person_id,
+      journeyTier: "confirmed",
+      occurredAt: row.occurred_at,
+      outcome: ["lead", "qualified", "conversion", "customer"].includes(row.conversion_kind) ? row.conversion_kind : "conversion",
+      valueMinor: row.value_minor,
+      currency: row.currency
+    })),
+    touches: touchesResult.rows.map((row) => ({
+      touchId: row.id,
+      subjectRef: row.person_id,
+      journeyTier: "confirmed",
+      occurredAt: row.occurred_at,
+      touchKind: row.touch_kind,
+      source: row.source,
+      medium: row.medium,
+      platform: row.platform,
+      accountId: row.account_id,
+      campaignId: row.campaign_id,
+      campaignName: row.campaign,
+      adSetId: row.ad_set_id,
+      adId: row.ad_id
+    })),
+    spendFacts: spendResult.rows.map((row) => ({
+      spendFactId: row.id,
+      bucket: row.bucket,
+      platform: row.platform,
+      accountId: row.account_id,
+      campaignId: row.campaign_id,
+      campaignName: row.campaign_name,
+      adSetId: row.ad_set_id,
+      adSetName: row.ad_set_name,
+      adId: row.ad_id,
+      adName: row.ad_name,
+      spendMinor: row.spend_minor,
+      currency: row.currency,
+      sourceRef: row.source_ref
+    }))
+  };
+}
+async function readImmutableCandidateAttributionEvidence(input) {
+  const from = new Date(instant(input.from, "from")).toISOString();
+  const to = new Date(instant(input.to, "to")).toISOString();
+  const touchesResult = await input.client.query(
+    `SELECT t.id, cat.association_id, cat.association_confidence, t.occurred_at, t.touch_kind,
+            t.source, t.medium, t.platform, t.account_id, t.campaign_id, t.campaign, t.ad_set_id, t.ad_id
+       FROM analytics_candidate_attribution_touches cat
+       JOIN analytics_candidate_associations ca ON ca.id=cat.association_id AND ca.namespace_id=cat.namespace_id
+       JOIN analytics_attribution_touches t ON t.id=cat.touch_id AND t.site_id=cat.site_id
+      WHERE cat.site_id=$1 AND cat.eligibility='overlay_only' AND cat.expires_at > now()
+        AND ca.status='active' AND ca.confidence_band='high' AND ca.expires_at > now()
+        AND t.occurred_at < $2
+      ORDER BY t.occurred_at,t.id`,
+    [input.siteId, to]
+  );
+  const conversionsResult = await input.client.query(
+    `SELECT DISTINCT ON (c.id) c.id, cat.association_id, cat.association_confidence, c.occurred_at,
+            c.conversion_kind, c.value_minor::text, c.currency
+       FROM analytics_candidate_attribution_touches cat
+       JOIN analytics_candidate_associations ca ON ca.id=cat.association_id AND ca.namespace_id=cat.namespace_id
+       JOIN analytics_attribution_touches t ON t.id=cat.touch_id AND t.site_id=cat.site_id
+       JOIN analytics_sessions s ON s.id=t.session_id AND s.site_id=t.site_id
+       JOIN analytics_conversions c ON c.site_id=cat.site_id AND c.session_hmac=s.session_hmac
+      WHERE cat.site_id=$1 AND cat.eligibility='overlay_only' AND cat.expires_at > now()
+        AND ca.status='active' AND ca.confidence_band='high' AND ca.expires_at > now()
+        AND c.occurred_at >= $2 AND c.occurred_at < $3
+      ORDER BY c.id,cat.association_confidence DESC,cat.association_id`,
+    [input.siteId, from, to]
+  );
+  return {
+    touches: touchesResult.rows.map((row) => ({
+      touchId: `candidate:${row.association_id}:${row.id}`,
+      subjectRef: `candidate:${row.association_id}`,
+      journeyTier: "candidate",
+      candidateConfidence: "high",
+      occurredAt: row.occurred_at,
+      touchKind: row.touch_kind,
+      source: row.source,
+      medium: row.medium,
+      platform: row.platform,
+      accountId: row.account_id,
+      campaignId: row.campaign_id,
+      campaignName: row.campaign,
+      adSetId: row.ad_set_id,
+      adId: row.ad_id
+    })),
+    conversions: conversionsResult.rows.map((row) => ({
+      conversionId: `candidate:${row.association_id}:${row.id}`,
+      subjectRef: `candidate:${row.association_id}`,
+      journeyTier: "candidate",
+      candidateConfidence: "high",
+      occurredAt: row.occurred_at,
+      outcome: ["lead", "qualified", "conversion", "customer"].includes(row.conversion_kind) ? row.conversion_kind : "conversion",
+      valueMinor: row.value_minor,
+      currency: row.currency
+    })),
+    spendFacts: []
   };
 }
 
@@ -1280,6 +1863,7 @@ async function migrateAnalytics() {
         connection_ref text,
         external_dataset_id text,
         status text NOT NULL DEFAULT 'active' CHECK (status IN ('active','paused','archived')),
+        automatic_delivery_enabled boolean NOT NULL DEFAULT false,
         event_mapping jsonb NOT NULL DEFAULT '{}'::jsonb,
         created_by_user_id bigint NOT NULL,
         created_at timestamptz NOT NULL DEFAULT now(),
@@ -1598,6 +2182,9 @@ async function migrateAnalytics() {
     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_destinations ADD COLUMN IF NOT EXISTS automatic_delivery_enabled boolean NOT NULL DEFAULT false`
+    );
     await client.query(
       `ALTER TABLE analytics_activation_jobs ADD COLUMN IF NOT EXISTS lease_until timestamptz`
     );
@@ -1780,6 +2367,27 @@ async function migrateAnalytics() {
         UNIQUE(site_id, user_id, milestone)
       )
     `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_scheduled_occurrences (
+        id uuid PRIMARY KEY,
+        lane_key text NOT NULL,
+        scheduled_for timestamptz NOT NULL,
+        status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','running','retrying','succeeded','dead_letter')),
+        attempt_count integer NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
+        max_attempts integer NOT NULL DEFAULT 5 CHECK (max_attempts BETWEEN 1 AND 20),
+        next_attempt_at timestamptz NOT NULL,
+        lease_owner text,
+        lease_until timestamptz,
+        started_at timestamptz,
+        completed_at timestamptz,
+        dead_lettered_at timestamptz,
+        last_error_code text,
+        result_summary jsonb NOT NULL DEFAULT '{}'::jsonb,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(lane_key, scheduled_for)
+      )
+    `);
     await client.query(`
       CREATE TABLE IF NOT EXISTS analytics_purpose_policies (
         id uuid PRIMARY KEY,
@@ -2025,6 +2633,27 @@ async function migrateAnalytics() {
         UNIQUE(association_id, person_id)
       )
     `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_identity_promotion_receipts (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        namespace_id uuid NOT NULL,
+        canonical_person_id uuid NOT NULL,
+        canonical_person_ref_hmac text NOT NULL,
+        evidence_kind text NOT NULL,
+        evidence_ref_hmac text NOT NULL,
+        prior_person_ids uuid[] NOT NULL DEFAULT '{}',
+        prior_identity_node_ids uuid[] NOT NULL DEFAULT '{}',
+        candidate_association_ids uuid[] NOT NULL DEFAULT '{}',
+        affected_history_counts jsonb NOT NULL DEFAULT '{}'::jsonb CHECK (jsonb_typeof(affected_history_counts)='object'),
+        schema_version text NOT NULL DEFAULT 'xray.identity-promotion.v1',
+        idempotency_key text NOT NULL,
+        promoted_at timestamptz NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        FOREIGN KEY(namespace_id, site_id) REFERENCES analytics_identity_namespaces(id, site_id) ON DELETE CASCADE,
+        UNIQUE(site_id, idempotency_key)
+      )
+    `);
     await client.query(
       "CREATE UNIQUE INDEX IF NOT EXISTS analytics_touches_site_ref ON analytics_attribution_touches(id, site_id)"
     );
@@ -2261,6 +2890,7 @@ async function migrateAnalytics() {
         last_started_at timestamptz,
         last_success_at timestamptz,
         next_run_at timestamptz,
+        interval_seconds integer CHECK (interval_seconds IS NULL OR (interval_seconds >= 900 AND interval_seconds <= 604800)),
         imported integer NOT NULL DEFAULT 0 CHECK (imported >= 0),
         deduplicated integer NOT NULL DEFAULT 0 CHECK (deduplicated >= 0),
         rejected integer NOT NULL DEFAULT 0 CHECK (rejected >= 0),
@@ -2270,6 +2900,7 @@ async function migrateAnalytics() {
         UNIQUE(site_id, idempotency_key)
       )
     `);
+    await client.query("ALTER TABLE analytics_crm_sync_runs ADD COLUMN IF NOT EXISTS interval_seconds integer CHECK (interval_seconds IS NULL OR (interval_seconds >= 900 AND interval_seconds <= 604800))");
     await client.query("CREATE INDEX IF NOT EXISTS analytics_crm_sync_runs_due ON analytics_crm_sync_runs(state, next_run_at) WHERE next_run_at IS NOT NULL");
     await client.query(`
       CREATE TABLE IF NOT EXISTS analytics_crm_outbound_policies (
@@ -2560,6 +3191,12 @@ async function migrateAnalytics() {
     await client.query(
       "CREATE INDEX IF NOT EXISTS analytics_product_milestones_site_time ON analytics_product_milestones(site_id, occurred_at DESC)"
     );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_scheduled_occurrences_due ON analytics_scheduled_occurrences(status,next_attempt_at,scheduled_for) WHERE status IN ('pending','retrying')"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_scheduled_occurrences_lease ON analytics_scheduled_occurrences(lease_until) WHERE status='running'"
+    );
     await client.query(
       "CREATE INDEX IF NOT EXISTS analytics_consent_receipts_subject_time ON analytics_consent_receipts(site_id, subject_ref, occurred_at DESC)"
     );
@@ -2584,6 +3221,9 @@ async function migrateAnalytics() {
     await client.query(
       "CREATE INDEX IF NOT EXISTS analytics_candidate_promotions_person_time ON analytics_candidate_promotions(site_id, person_id, promoted_at DESC)"
     );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_identity_promotion_receipts_person_time ON analytics_identity_promotion_receipts(site_id, canonical_person_id, promoted_at DESC)"
+    );
     await client.query(
       "CREATE INDEX IF NOT EXISTS analytics_candidate_touches_overlay ON analytics_candidate_attribution_touches(site_id, namespace_id, linked_at DESC) WHERE eligibility = 'overlay_only'"
     );
@@ -2625,7 +3265,7 @@ async function migrateAnalytics() {
     );
     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'), ('2026-08-26.1'), ('2026-08-26.2'), ('2026-08-26.3'), ('2026-08-26.4'), ('2026-08-27.1'), ('2026-08-28.1')
+      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'), ('2026-08-27.1'), ('2026-08-28.1'), ('2026-08-28.2'), ('2026-08-28.3'), ('2026-08-28.4')
       ON CONFLICT (version) DO NOTHING
     `);
   } catch (error) {
@@ -3629,6 +4269,20 @@ async function ingestAnalyticsEvents(input) {
         });
         const attribution = resolveAnalyticsAttribution(event);
         const eventIdentity = event.identity;
+        let eventDefinitionId = null;
+        let eventDefinitionVersion = null;
+        if (event.eventDefinitionId && event.eventDefinitionVersion) {
+          const definitionMatch = await client.query(
+            `SELECT id, version FROM analytics_event_definitions
+              WHERE id=$1 AND site_id=$2 AND version=$3 AND event_name=$4 AND status='active'
+              LIMIT 1`,
+            [event.eventDefinitionId, pixel.site_id, event.eventDefinitionVersion, event.eventName]
+          );
+          if (definitionMatch.rows[0]) {
+            eventDefinitionId = definitionMatch.rows[0].id;
+            eventDefinitionVersion = definitionMatch.rows[0].version;
+          }
+        }
         const resolvedPerson = analyticsIdentityResolutionAllowed(event) && (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))
@@ -3645,10 +4299,10 @@ async function ingestAnalyticsEvents(input) {
              occurred_at, path, canonical_url, title, referrer, source, medium, campaign,
              device_class, properties, country_code, region_code, click_ids, person_id,
              channel_family, platform, campaign_id, ad_set_id, ad_id, creative_id, placement, utm_term, utm_content,
-             engaged_ms, scroll_depth, visitor_hmac, session_hmac
+             engaged_ms, scroll_depth, visitor_hmac, session_hmac, event_definition_id, event_definition_version
            ) VALUES (
              $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18::jsonb, $19, $20, $21::jsonb, $22,
-             $23, $24, $25, $26, $27, $28, $29, $30, $31, $32, $33, $34, $35
+             $23, $24, $25, $26, $27, $28, $29, $30, $31, $32, $33, $34, $35, $36, $37
            ) ON CONFLICT(site_id, event_id) DO NOTHING`,
           [
             randomUUID2(),
@@ -3685,7 +4339,9 @@ async function ingestAnalyticsEvents(input) {
             boundedEngagedMs(event.engagedMs),
             boundedScrollDepth(event.scrollDepth),
             event.visitorId ? identityHmac("visitor_id", event.visitorId) : null,
-            event.sessionId ? identityHmac("session_id", event.sessionId) : null
+            event.sessionId ? identityHmac("session_id", event.sessionId) : null,
+            eventDefinitionId,
+            eventDefinitionVersion
           ]
         );
         if (inserted.rowCount) {
@@ -3715,7 +4371,8 @@ async function ingestAnalyticsEvents(input) {
               phone: eventIdentity.phone,
               customerId: eventIdentity.customerId,
               orderId: eventIdentity.orderId,
-              clickIds: event.clickIds
+              clickIds: event.clickIds,
+              occurredAt: event.occurredAt
             });
           }
         } else {
@@ -3861,11 +4518,12 @@ async function createAnalyticsConversion(input) {
     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')`,
+        `SELECT id,event_mapping FROM analytics_activation_destinations
+          WHERE site_id = $1 AND status = 'active' AND automatic_delivery_enabled=true
+            AND readiness IN ('verified','live')`,
         [input.siteId]
       );
-      for (const destination of destinations.rows) {
+      for (const destination of destinations.rows.filter((row) => activationMappingAllows(row.event_mapping, input.conversionKind))) {
         const queued = await client.query(
           `INSERT INTO analytics_activation_jobs(
              id, destination_id, conversion_id, person_id, payload_ciphertext
@@ -4095,127 +4753,103 @@ async function analyticsAcquisition(siteId, userId, filters, page) {
   const db = getAnalyticsPool();
   await accessFor(db, siteId, userId);
   const query = eventFilterSql(siteId, filters);
+  const eventWhere = filters.journeyTier === "best_guess" ? `${query.where} AND EXISTS (
+         SELECT 1 FROM analytics_sessions candidate_session
+         JOIN analytics_attribution_touches candidate_touch
+           ON candidate_touch.session_id=candidate_session.id AND candidate_touch.site_id=candidate_session.site_id
+         JOIN analytics_candidate_attribution_touches candidate_overlay
+           ON candidate_overlay.touch_id=candidate_touch.id AND candidate_overlay.site_id=candidate_touch.site_id
+         JOIN analytics_candidate_associations candidate_association
+           ON candidate_association.id=candidate_overlay.association_id
+          AND candidate_association.namespace_id=candidate_overlay.namespace_id
+        WHERE candidate_session.site_id=e.site_id AND candidate_session.session_hmac=e.session_hmac
+          AND candidate_overlay.eligibility='overlay_only' AND candidate_overlay.expires_at > now()
+          AND candidate_association.status='active' AND candidate_association.confidence_band='high'
+          AND candidate_association.expires_at > now()
+       )` : `${query.where} AND e.person_id IS NOT NULL`;
   const result = await db.query(
     `SELECT COALESCE(e.source, '(direct)') AS source,
             COALESCE(e.medium, '(none)') AS medium,
             COALESCE(e.campaign, '(none)') AS campaign,
+            COALESCE(e.platform, e.source, '(direct)') AS platform,
+            e.campaign_id, e.ad_set_id, e.ad_id, e.creative_id,
             count(DISTINCT e.visitor_id)::int AS visitors,
             count(DISTINCT e.session_id)::int AS sessions,
             count(*) FILTER (WHERE e.event_name = 'page_view')::int AS pageviews
        FROM analytics_events e
-      WHERE ${query.where}
-      GROUP BY 1, 2, 3
+      WHERE ${eventWhere}
+      GROUP BY 1, 2, 3, 4, 5, 6, 7, 8
       ORDER BY sessions DESC, visitors DESC
       LIMIT 1000`,
     query.values
   );
-  const values = [siteId, filters.start, filters.end];
-  const touchClauses = [
-    "c.site_id = $1",
-    "c.occurred_at >= $2::timestamptz",
-    "c.occurred_at < $3::timestamptz"
-  ];
-  const addTouch = (sql, value) => {
-    values.push(value);
-    touchClauses.push(sql.replace("?", `$${values.length}`));
+  const [confirmedEvidence, candidateEvidence] = await Promise.all([
+    readImmutableConfirmedAttributionEvidence({ client: db, siteId, from: filters.start, to: filters.end }),
+    filters.journeyTier === "best_guess" || filters.journeyTier === "all" ? readImmutableCandidateAttributionEvidence({ client: db, siteId, from: filters.start, to: filters.end }) : Promise.resolve({ touches: [], conversions: [], spendFacts: [] })
+  ]);
+  const touchMatches = (touch) => (!filters.source || (touch.source ?? "(direct)") === filters.source) && (!filters.medium || (touch.medium ?? "(none)") === filters.medium) && (!filters.campaign || (touch.campaignName ?? "(none)") === filters.campaign) && (!filters.platform || (touch.platform ?? touch.source ?? "(direct)") === filters.platform);
+  confirmedEvidence.touches = confirmedEvidence.touches.filter(touchMatches);
+  candidateEvidence.touches = candidateEvidence.touches.filter(touchMatches);
+  if (filters.conversionKind) {
+    confirmedEvidence.conversions = confirmedEvidence.conversions.filter((item) => item.outcome === filters.conversionKind);
+    candidateEvidence.conversions = candidateEvidence.conversions.filter((item) => item.outcome === filters.conversionKind);
+  }
+  const configuration = {
+    model: filters.attributionModel ?? "position_based",
+    clickWindow: filters.clickWindow ?? 90,
+    viewWindow: filters.viewWindow ?? 30,
+    customWeights: filters.customWeights
   };
-  if (filters.pixelIds?.length)
-    addTouch("touch.pixel_id = ANY(?::uuid[])", filters.pixelIds);
-  if (filters.hostnames?.length)
-    addTouch("touch.hostname = ANY(?::text[])", filters.hostnames);
-  if (filters.source)
-    addTouch(`COALESCE(touch.source, '(direct)') = ?`, filters.source);
-  if (filters.medium)
-    addTouch(`COALESCE(touch.medium, '(none)') = ?`, filters.medium);
-  if (filters.campaign)
-    addTouch(`COALESCE(touch.campaign, '(none)') = ?`, filters.campaign);
-  if (filters.channelFamily)
-    addTouch(
-      `COALESCE(touch.channel_family, 'other') = ?`,
-      filters.channelFamily
-    );
-  if (filters.platform)
-    addTouch(
-      `COALESCE(touch.platform, touch.source, '(direct)') = ?`,
-      filters.platform
-    );
-  if (filters.referrer)
-    addTouch(
-      `COALESCE(touch.referrer, '') ILIKE '%' || ? || '%'`,
-      filters.referrer
-    );
-  if (filters.path) addTouch(`touch.path = ?`, filters.path);
-  if (filters.deviceClass)
-    addTouch(
-      `COALESCE(touch.device_class, 'unknown') = ?`,
-      filters.deviceClass
-    );
-  if (filters.countryCode)
-    addTouch(
-      `COALESCE(touch.country_code, 'unknown') = ?`,
-      filters.countryCode.toUpperCase()
-    );
-  if (filters.regionCode)
-    addTouch(
-      `COALESCE(touch.region_code, 'unknown') = ?`,
-      filters.regionCode.toUpperCase()
-    );
-  if (filters.conversionKind)
-    addTouch(`c.conversion_kind = ?`, filters.conversionKind);
-  const direction = filters.attributionModel === "last_touch" ? "DESC" : "ASC";
-  const attributed = await db.query(
-    `SELECT COALESCE(touch.source, '(direct)') AS source,
-             COALESCE(touch.medium, '(none)') AS medium,
-             COALESCE(touch.campaign, '(none)') AS campaign,
-             count(*)::int AS conversions, COALESCE(sum(c.value_minor), 0)::bigint AS revenue_minor
-        FROM analytics_conversions c
-        JOIN LATERAL (
-          SELECT e.* FROM analytics_events e
-           WHERE e.site_id = c.site_id AND e.occurred_at <= c.occurred_at
-             AND ((c.person_id IS NOT NULL AND e.person_id = c.person_id)
-               OR (c.person_id IS NULL AND e.session_id = c.session_id))
-           ORDER BY e.occurred_at ${direction} LIMIT 1
-        ) touch ON true
-       WHERE ${touchClauses.join(" AND ")}
-       GROUP BY 1,2,3`,
-    values
-  );
-  const outcomes = new Map(
-    attributed.rows.map((row) => [
-      `${row.source}\0${row.medium}\0${row.campaign}`,
-      row
-    ])
-  );
-  const rows = result.rows.map((row) => {
-    const outcome = outcomes.get(
-      `${row.source}\0${row.medium}\0${row.campaign}`
-    );
-    const conversions = Number(outcome?.conversions ?? 0);
+  const evidence = {
+    touches: [...confirmedEvidence.touches, ...candidateEvidence.touches],
+    conversions: [...confirmedEvidence.conversions, ...candidateEvidence.conversions],
+    spendFacts: confirmedEvidence.spendFacts
+  };
+  const projection = buildAnalyticsAttributionReport({ ...evidence, configuration, granularity: "campaign" });
+  const selectedTier = filters.journeyTier === "best_guess" ? "candidate" : "confirmed";
+  const selectedCredits = selectedTier === "candidate" ? projection.candidateAssist.credits : projection.confirmed.credits;
+  const selectedRows = selectedTier === "candidate" ? projection.candidateAssist.rows : projection.confirmed.rows;
+  const outcomes = summarizeAttributionCredits(selectedCredits, evidence.touches);
+  const traffic = new Map(result.rows.map((row) => [`${row.source}\0${row.medium}\0${row.campaign}`, row]));
+  const efficiency = new Map(selectedRows.map((row) => [`${row.platform ?? ""}\0${row.campaignId ?? ""}`, row]));
+  const keys = /* @__PURE__ */ new Set([...traffic.keys(), ...outcomes.keys()]);
+  const rows = [...keys].map((key) => {
+    const visit = traffic.get(key);
+    const outcome = outcomes.get(key);
+    const platform = outcome?.platform ?? visit?.platform ?? null;
+    const campaignId = outcome?.campaignId ?? visit?.campaign_id ?? null;
+    const metrics = efficiency.get(`${platform ?? ""}\0${campaignId ?? ""}`);
+    const sessions = Number(visit?.sessions ?? 0);
     return {
-      ...row,
-      conversions,
-      conversionRate: row.sessions > 0 ? conversions / row.sessions : 0,
-      revenueMinor: Number(outcome?.revenue_minor ?? 0)
+      source: outcome?.source ?? visit?.source ?? "(direct)",
+      medium: outcome?.medium ?? visit?.medium ?? "(none)",
+      campaign: outcome?.campaign ?? visit?.campaign ?? "(none)",
+      platform,
+      campaignId,
+      adSetGroupId: visit?.ad_set_id ?? null,
+      adId: visit?.ad_id ?? null,
+      creativeId: visit?.creative_id ?? null,
+      visitors: Number(visit?.visitors ?? 0),
+      sessions,
+      pageviews: Number(visit?.pageviews ?? 0),
+      leads: outcome?.leads ?? 0,
+      qualifiedLeads: outcome?.qualifiedLeads ?? 0,
+      conversions: outcome?.conversions ?? 0,
+      customers: outcome?.customers ?? 0,
+      conversionRate: sessions > 0 ? (outcome?.conversions ?? 0) / sessions : 0,
+      revenueMinor: outcome?.revenueMinor ?? 0,
+      spendMinor: metrics?.spendMinor == null ? null : Number(metrics.spendMinor),
+      cplMinor: metrics?.cplMinor ?? null,
+      cpqlMinor: metrics?.cpqlMinor ?? null,
+      cpaMinor: metrics?.cpaMinor ?? null,
+      cacMinor: metrics?.cacMinor ?? null,
+      roas: metrics?.roas ?? null,
+      scoreEligible: null,
+      propensityEligible: null,
+      coveragePercent: outcome && outcome.attributedCredit > 0 ? 1 : 0,
+      currency: metrics?.currency ?? selectedCredits.find((credit) => credit.currency)?.currency ?? null
     };
   });
-  for (const outcome of attributed.rows) {
-    const key = `${outcome.source}\0${outcome.medium}\0${outcome.campaign}`;
-    if (!result.rows.some(
-      (row) => `${row.source}\0${row.medium}\0${row.campaign}` === key
-    )) {
-      rows.push({
-        source: outcome.source,
-        medium: outcome.medium,
-        campaign: outcome.campaign,
-        visitors: 0,
-        sessions: 0,
-        pageviews: 0,
-        conversions: Number(outcome.conversions),
-        conversionRate: 0,
-        revenueMinor: Number(outcome.revenue_minor)
-      });
-    }
-  }
   rows.sort(
     (a, b) => Number(b.sessions) - Number(a.sessions) || Number(b.conversions) - Number(a.conversions)
   );
@@ -4226,10 +4860,72 @@ async function analyticsAcquisition(siteId, userId, filters, page) {
   );
   return {
     channels: paged.items,
+    candidateAssistChannels: filters.journeyTier === "all" ? [...summarizeAttributionCredits(projection.candidateAssist.credits, evidence.touches).values()] : void 0,
+    comparisons: summarizeAttributionComparisons(
+      filters.compareModels?.length ? compareAnalyticsAttributionModels({
+        ...evidence,
+        configurations: [configuration, ...filters.compareModels.map((model) => ({ ...configuration, model, id: model }))],
+        granularity: "campaign"
+      }).projections : [projection],
+      selectedTier
+    ),
+    attribution: {
+      model: projection.configuration.model,
+      clickWindow: projection.configuration.clickWindow,
+      viewWindow: projection.configuration.viewWindow,
+      journeyTier: filters.journeyTier ?? "confirmed",
+      confirmedAndCandidateTotalsSeparated: true
+    },
     pageInfo: paged.pageInfo,
     dataFreshThrough: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function summarizeAttributionCredits(credits, touches) {
+  const touchById = new Map(touches.map((touch) => [touch.touchId, touch]));
+  const rows = /* @__PURE__ */ new Map();
+  for (const credit of credits) {
+    const touch = credit.touchId ? touchById.get(credit.touchId) : void 0;
+    const source = touch?.source ?? "(unattributed)";
+    const medium = touch?.medium ?? "(none)";
+    const campaign = touch?.campaignName ?? "(none)";
+    const key = `${source}\0${medium}\0${campaign}`;
+    const row = rows.get(key) ?? {
+      source,
+      medium,
+      campaign,
+      platform: touch?.platform ?? null,
+      campaignId: touch?.campaignId ?? null,
+      leads: 0,
+      qualifiedLeads: 0,
+      conversions: 0,
+      customers: 0,
+      revenueMinor: 0,
+      attributedCredit: 0
+    };
+    const fraction = credit.creditMicros / 1e6;
+    if (credit.outcome === "lead") row.leads += fraction;
+    if (credit.outcome === "qualified") row.qualifiedLeads += fraction;
+    if (credit.outcome === "conversion") row.conversions += fraction;
+    if (credit.outcome === "customer") row.customers += fraction;
+    row.attributedCredit += fraction;
+    row.revenueMinor += Number(credit.creditedValueMinor);
+    rows.set(key, row);
+  }
+  return rows;
+}
+function summarizeAttributionComparisons(projections, tier) {
+  return projections.map((projection) => {
+    const section = tier === "candidate" ? projection.candidateAssist : projection.confirmed;
+    const conversionIds = new Set(section.credits.map((credit) => credit.conversionId));
+    const attributedIds = new Set(section.credits.filter((credit) => !credit.unattributed).map((credit) => credit.conversionId));
+    return {
+      model: projection.configuration.model,
+      conversions: section.credits.reduce((sum, credit) => sum + credit.creditMicros / 1e6, 0),
+      revenueMinor: section.credits.reduce((sum, credit) => sum + Number(credit.creditedValueMinor), 0),
+      coveragePercent: conversionIds.size > 0 ? attributedIds.size / conversionIds.size : null
+    };
+  });
+}
 var inferredFamilySql = `COALESCE(e.channel_family, CASE
   WHEN lower(COALESCE(e.source,'') || ' ' || COALESCE(e.referrer,'')) ~ '(perplexity|chatgpt|openai|claude|anthropic|grok|xai|ai[_ -]?overview|google[_ -]?ai|gemini)' THEN 'llm'
   WHEN lower(COALESCE(e.source,'') || ' ' || COALESCE(e.referrer,'')) ~ '(facebook|instagram|linkedin|tiktok|youtube|youtu\\.be|twitter|x\\.com)' THEN 'social'
@@ -4977,7 +5673,7 @@ async function resolveAndMergeConfirmedAnalyticsPerson(client, input) {
   const matches = await client.query(
     `SELECT p.id
        FROM analytics_people p
-       JOIN (
+       LEFT JOIN (
          SELECT DISTINCT e.person_id
            FROM analytics_identity_nodes n
            JOIN analytics_identity_edges e ON e.identity_node_id=n.id AND e.site_id=n.site_id
@@ -4987,12 +5683,15 @@ async function resolveAndMergeConfirmedAnalyticsPerson(client, input) {
           )
        ) matched ON matched.person_id=p.id
       WHERE p.site_id=$1 AND (p.namespace_id=$3 OR p.namespace_id IS NULL)
-      ORDER BY p.first_seen_at ASC,p.id ASC
+        AND (matched.person_id IS NOT NULL OR p.crm_person_ref=$4)
+      ORDER BY CASE WHEN p.crm_person_ref LIKE 'XRay::anonymous::%' THEN 1 ELSE 0 END,
+               p.first_seen_at ASC,p.id ASC
       FOR UPDATE OF p`,
     [
       input.siteId,
       JSON.stringify(input.signals.map((signal) => ({ kind: signal.kind, value_hmac: signal.valueHmac }))),
-      input.namespaceId
+      input.namespaceId,
+      input.crmPersonRef
     ]
   );
   const canonicalId = matches.rows[0]?.id;
@@ -5004,16 +5703,17 @@ async function resolveAndMergeConfirmedAnalyticsPerson(client, input) {
          public_ref=COALESCE(analytics_people.public_ref,EXCLUDED.public_ref) RETURNING id`,
       [randomUUID2(), input.siteId, input.namespaceId, input.crmPersonRef, newAnalyticsPersonPublicRef()]
     );
-    return inserted.rows[0].id;
+    return { personId: inserted.rows[0].id, mergedPersonIds: [] };
   }
   await client.query(
     `UPDATE analytics_people SET last_seen_at=now(),
-       namespace_id=COALESCE(namespace_id,$2),public_ref=COALESCE(public_ref,$3)
+       namespace_id=COALESCE(namespace_id,$2),public_ref=COALESCE(public_ref,$3),
+       crm_person_ref=CASE WHEN crm_person_ref LIKE 'XRay::anonymous::%' THEN $5 ELSE crm_person_ref END
       WHERE id=$1 AND site_id=$4`,
-    [canonicalId, input.namespaceId, newAnalyticsPersonPublicRef(), input.siteId]
+    [canonicalId, input.namespaceId, newAnalyticsPersonPublicRef(), input.siteId, input.crmPersonRef]
   );
   const duplicateIds = matches.rows.slice(1).map((row) => row.id);
-  if (duplicateIds.length === 0) return canonicalId;
+  if (duplicateIds.length === 0) return { personId: canonicalId, mergedPersonIds: [] };
   await client.query(
     `DELETE FROM analytics_identity_edges duplicate
       USING analytics_identity_edges canonical
@@ -5105,7 +5805,106 @@ async function resolveAndMergeConfirmedAnalyticsPerson(client, input) {
     "DELETE FROM analytics_people WHERE site_id=$1 AND id=ANY($2::uuid[])",
     [input.siteId, duplicateIds]
   );
-  return canonicalId;
+  return { personId: canonicalId, mergedPersonIds: duplicateIds };
+}
+async function promoteAnalyticsCandidatesForConfirmedPerson(client, input) {
+  const associations = await client.query(
+    `WITH person_nodes AS (
+       SELECT DISTINCT identity_node_id
+         FROM analytics_identity_edges
+        WHERE site_id=$1 AND namespace_id=$2 AND person_id=$3
+     )
+     UPDATE analytics_candidate_associations a
+        SET status='promoted',promoted_person_id=$3,promoted_at=$4::timestamptz,updated_at=now()
+      WHERE a.site_id=$1 AND a.namespace_id=$2
+        AND (a.left_identity_node_id IN (SELECT identity_node_id FROM person_nodes)
+          OR a.right_identity_node_id IN (SELECT identity_node_id FROM person_nodes))
+        AND (a.status IN ('active','expired') OR (a.status='promoted' AND a.promoted_person_id=$3))
+     RETURNING a.id`,
+    [input.siteId, input.namespaceId, input.personId, input.occurredAt]
+  );
+  const associationIds = associations.rows.map((row) => row.id);
+  if (!associationIds.length) return { associationIds: [], touches: 0 };
+  for (const associationId of associationIds) {
+    await client.query(
+      `INSERT INTO analytics_candidate_promotions(
+         id,site_id,namespace_id,association_id,person_id,evidence_kind,
+         evidence_ref_hmac,promoted_by,promoted_at
+       ) VALUES($1,$2,$3,$4,$5,$6,$7,'system',$8::timestamptz)
+       ON CONFLICT(association_id,person_id) DO NOTHING`,
+      [
+        randomUUID2(),
+        input.siteId,
+        input.namespaceId,
+        associationId,
+        input.personId,
+        input.candidateEvidenceKind,
+        input.evidenceRefHmac,
+        input.occurredAt
+      ]
+    );
+  }
+  const touches = await client.query(
+    `UPDATE analytics_attribution_touches touch SET person_id=$3
+       FROM analytics_candidate_attribution_touches candidate_touch
+      WHERE candidate_touch.site_id=$1 AND candidate_touch.namespace_id=$2
+        AND candidate_touch.association_id=ANY($4::uuid[])
+        AND candidate_touch.touch_id=touch.id AND touch.site_id=$1 AND touch.person_id IS NULL`,
+    [input.siteId, input.namespaceId, input.personId, associationIds]
+  );
+  return { associationIds, touches: touches.rowCount ?? 0 };
+}
+async function recordAnalyticsIdentityPromotionReceipt(client, input) {
+  const evidenceRefHmac = identityHmac("promotion_evidence", `${input.evidenceKind}:${input.evidenceRef}`);
+  const personRefHmac = identityHmac("promotion_person", input.personId);
+  const idempotencyKey = identityHmac(
+    "promotion_receipt",
+    `${input.siteId}:${input.personId}:${input.evidenceKind}:${input.evidenceRef}`
+  );
+  await client.query(
+    `INSERT INTO analytics_identity_promotion_receipts(
+       id,site_id,namespace_id,canonical_person_id,canonical_person_ref_hmac,
+       evidence_kind,evidence_ref_hmac,prior_person_ids,prior_identity_node_ids,
+       candidate_association_ids,affected_history_counts,schema_version,idempotency_key,promoted_at
+     ) VALUES($1,$2,$3,$4,$5,$6,$7,$8::uuid[],$9::uuid[],$10::uuid[],$11::jsonb,
+       'xray.identity-promotion.v1',$12,$13::timestamptz)
+     ON CONFLICT(site_id,idempotency_key) DO NOTHING`,
+    [
+      randomUUID2(),
+      input.siteId,
+      input.namespaceId,
+      input.personId,
+      personRefHmac,
+      input.evidenceKind,
+      evidenceRefHmac,
+      input.priorPersonIds,
+      input.priorIdentityNodeIds,
+      input.candidateAssociationIds,
+      JSON.stringify({ ...input.history, candidateTouches: input.candidateTouches }),
+      idempotencyKey,
+      input.occurredAt
+    ]
+  );
+}
+async function completeAnalyticsIdentityPromotion(client, input) {
+  const occurredAt = input.occurredAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const history = await backfillAnalyticsConfirmedHistory(client, input);
+  const evidenceRefHmac = identityHmac("promotion_evidence", `${input.evidenceKind}:${input.evidenceRef}`);
+  const candidates = await promoteAnalyticsCandidatesForConfirmedPerson(client, {
+    siteId: input.siteId,
+    namespaceId: input.namespaceId,
+    personId: input.personId,
+    candidateEvidenceKind: input.candidateEvidenceKind,
+    evidenceRefHmac,
+    occurredAt
+  });
+  await recordAnalyticsIdentityPromotionReceipt(client, {
+    ...input,
+    history,
+    candidateAssociationIds: candidates.associationIds,
+    candidateTouches: candidates.touches,
+    occurredAt
+  });
 }
 async function linkAnalyticsIdentityInTransaction(client, input) {
   const stable = input.customerId || input.orderId || input.email || input.phone;
@@ -5128,12 +5927,18 @@ async function linkAnalyticsIdentityInTransaction(client, input) {
     signals: tombstoneSignals
   });
   const crmPersonRef = `XRay::${identityHmac("person_ref", stable).slice(0, 24)}`;
-  const personId = await resolveAndMergeConfirmedAnalyticsPerson(client, {
+  const matchSignals = [
+    ...tombstoneSignals,
+    ...input.visitorId ? [{ kind: "visitor_id", valueHmac: identityHmac("visitor_id", input.visitorId) }] : [],
+    ...input.sessionId ? [{ kind: "session_id", valueHmac: identityHmac("session_id", input.sessionId) }] : []
+  ];
+  const resolution = await resolveAndMergeConfirmedAnalyticsPerson(client, {
     siteId: input.siteId,
     namespaceId,
     crmPersonRef,
-    signals: tombstoneSignals
+    signals: matchSignals
   });
+  const personId = resolution.personId;
   const signals = [];
   if (input.visitorId)
     signals.push({ kind: "visitor_id", value: input.visitorId, evidence: "pixel_identify", confidence: 0.98 });
@@ -5149,6 +5954,7 @@ async function linkAnalyticsIdentityInTransaction(client, input) {
     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 });
+  const identityNodeIds = [];
   for (const signal of signals) {
     const node = await client.query(
       `INSERT INTO analytics_identity_nodes(id, site_id, namespace_id, kind, value_hmac) VALUES ($1,$2,$3,$4,$5)
@@ -5156,6 +5962,7 @@ async function linkAnalyticsIdentityInTransaction(client, input) {
          namespace_id=COALESCE(analytics_identity_nodes.namespace_id,EXCLUDED.namespace_id) RETURNING id`,
       [randomUUID2(), input.siteId, namespaceId, signal.kind, identityHmac(signal.kind, signal.value)]
     );
+    identityNodeIds.push(node.rows[0].id);
     await client.query(
       `INSERT INTO analytics_identity_edges(id, site_id, namespace_id, person_id, identity_node_id, evidence_kind, confidence)
        VALUES ($1,$2,$3,$4,$5,$6,$7)
@@ -5165,11 +5972,18 @@ async function linkAnalyticsIdentityInTransaction(client, input) {
       [randomUUID2(), input.siteId, namespaceId, personId, node.rows[0].id, signal.evidence, signal.confidence]
     );
   }
-  await backfillAnalyticsConfirmedHistory(client, {
+  await completeAnalyticsIdentityPromotion(client, {
     siteId: input.siteId,
+    namespaceId,
     personId,
+    evidenceKind: input.customerId ? "authenticated_login" : "browser_identify",
+    candidateEvidenceKind: input.email ? "verified_email" : input.phone ? "verified_phone" : "authenticated_user",
+    evidenceRef: stable,
+    priorPersonIds: resolution.mergedPersonIds,
+    priorIdentityNodeIds: identityNodeIds,
     visitorId: input.visitorId,
-    sessionId: input.sessionId
+    sessionId: input.sessionId,
+    occurredAt: input.occurredAt
   });
   if (input.customerId) {
     await writeAnalyticsConfirmedIdentityProfile(client, {
@@ -5205,12 +6019,18 @@ async function linkAnalyticsFormIdentity(input) {
       siteId: input.siteId,
       signals: deterministicSignals
     });
-    const personId = await resolveAndMergeConfirmedAnalyticsPerson(client, {
+    const matchSignals = [
+      ...deterministicSignals,
+      ...input.visitorId ? [{ kind: "visitor_id", valueHmac: identityHmac("visitor_id", input.visitorId) }] : [],
+      ...input.sessionId ? [{ kind: "session_id", valueHmac: identityHmac("session_id", input.sessionId) }] : []
+    ];
+    const resolution = await resolveAndMergeConfirmedAnalyticsPerson(client, {
       siteId: input.siteId,
       namespaceId,
       crmPersonRef: input.crmPersonRef,
-      signals: deterministicSignals
+      signals: matchSignals
     });
+    const personId = resolution.personId;
     const signals = [];
     if (input.visitorId)
       signals.push({
@@ -5250,6 +6070,7 @@ async function linkAnalyticsFormIdentity(input) {
         confidence: 0.9
       });
     }
+    const identityNodeIds = [];
     for (const signal of signals) {
       const node = await client.query(
         `INSERT INTO analytics_identity_nodes(id, site_id, namespace_id, kind, value_hmac) VALUES ($1,$2,$3,$4,$5)
@@ -5263,6 +6084,7 @@ async function linkAnalyticsFormIdentity(input) {
           identityHmac(signal.kind, signal.value)
         ]
       );
+      identityNodeIds.push(node.rows[0].id);
       await client.query(
         `INSERT INTO analytics_identity_edges(id, site_id, namespace_id, person_id, identity_node_id, evidence_kind, confidence)
          VALUES ($1,$2,$3,$4,$5,$6,$7)
@@ -5285,14 +6107,18 @@ async function linkAnalyticsFormIdentity(input) {
         "UPDATE analytics_form_submissions SET person_id = $1 WHERE id = $2 AND site_id = $3",
         [personId, input.submissionId, input.siteId]
       );
-    if (input.visitorId || input.sessionId) {
-      await backfillAnalyticsConfirmedHistory(client, {
-        siteId: input.siteId,
-        personId,
-        visitorId: input.visitorId,
-        sessionId: input.sessionId
-      });
-    }
+    await completeAnalyticsIdentityPromotion(client, {
+      siteId: input.siteId,
+      namespaceId,
+      personId,
+      evidenceKind: "form_fill",
+      candidateEvidenceKind: input.email ? "verified_email" : input.phone ? "verified_phone" : "authenticated_user",
+      evidenceRef: input.submissionId ?? input.crmPersonRef,
+      priorPersonIds: resolution.mergedPersonIds,
+      priorIdentityNodeIds: identityNodeIds,
+      visitorId: input.visitorId,
+      sessionId: input.sessionId
+    });
     await writeAnalyticsConfirmedIdentityProfile(client, {
       siteId: input.siteId,
       personId,
@@ -5334,6 +6160,19 @@ async function enrichAnalyticsExistingCrmIdentity(input) {
       siteId: input.siteId,
       signals: signals.map((signal) => ({ kind: signal.kind, valueHmac: identityHmac(signal.kind, signal.value) }))
     });
+    const resolution = await resolveAndMergeConfirmedAnalyticsPerson(client, {
+      siteId: input.siteId,
+      namespaceId: person.namespace_id,
+      crmPersonRef: input.crmPersonRef,
+      signals: signals.map((signal) => ({ kind: signal.kind, valueHmac: identityHmac(signal.kind, signal.value) }))
+    });
+    const personId = resolution.personId;
+    const canonical = await client.query(
+      "SELECT public_ref FROM analytics_people WHERE id=$1 AND site_id=$2",
+      [personId, input.siteId]
+    );
+    const canonicalPublicRef = canonical.rows[0]?.public_ref ?? person.public_ref;
+    const identityNodeIds = [];
     for (const signal of signals) {
       const node = await client.query(
         `INSERT INTO analytics_identity_nodes(id,site_id,namespace_id,kind,value_hmac) VALUES($1,$2,$3,$4,$5)
@@ -5341,25 +6180,36 @@ async function enrichAnalyticsExistingCrmIdentity(input) {
            namespace_id=COALESCE(analytics_identity_nodes.namespace_id,EXCLUDED.namespace_id) RETURNING id`,
         [randomUUID2(), input.siteId, person.namespace_id, signal.kind, identityHmac(signal.kind, signal.value)]
       );
+      identityNodeIds.push(node.rows[0].id);
       await client.query(
         `INSERT INTO analytics_identity_edges(id,site_id,namespace_id,person_id,identity_node_id,evidence_kind,confidence)
          VALUES($1,$2,$3,$4,$5,'crm_contact',$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, person.namespace_id, person.id, node.rows[0].id, signal.confidence]
+        [randomUUID2(), input.siteId, person.namespace_id, personId, node.rows[0].id, signal.confidence]
       );
     }
+    await completeAnalyticsIdentityPromotion(client, {
+      siteId: input.siteId,
+      namespaceId: person.namespace_id,
+      personId,
+      evidenceKind: "crm_identity",
+      candidateEvidenceKind: "crm_contact",
+      evidenceRef: input.crmPersonRef,
+      priorPersonIds: resolution.mergedPersonIds,
+      priorIdentityNodeIds: identityNodeIds
+    });
     await writeAnalyticsConfirmedIdentityProfile(client, {
       siteId: input.siteId,
-      personId: person.id,
-      consentSubjectRefs: [person.public_ref],
+      personId,
+      consentSubjectRefs: [canonicalPublicRef],
       evidenceType: "crm_contact",
       displayName: input.displayName,
       email: input.email,
       phone: input.phone
     });
     await client.query("COMMIT");
-    return { personId: person.id, linkedSignals: signals.length };
+    return { personId, linkedSignals: signals.length };
   } catch (error) {
     await client.query("ROLLBACK");
     throw error;
@@ -5426,12 +6276,14 @@ async function createAnalyticsCrmImport(input) {
   const db = getAnalyticsPool();
   await requireEditor(db, input.siteId, input.userId);
   const client = await db.connect();
-  const id = randomUUID2();
+  const id = input.id ?? randomUUID2();
   try {
     await client.query("BEGIN");
-    await client.query(
+    const inserted = await client.query(
       `INSERT INTO analytics_crm_imports(id, site_id, requested_by_user_id, source_system, filename, accepted_count, rejected_count)
-       VALUES ($1,$2,$3,$4,$5,$6,$7)`,
+       VALUES ($1,$2,$3,$4,$5,$6,$7)
+       ON CONFLICT(id) DO NOTHING
+       RETURNING id,status,accepted_count,rejected_count`,
       [
         id,
         input.siteId,
@@ -5442,6 +6294,18 @@ async function createAnalyticsCrmImport(input) {
         input.rejectedCount
       ]
     );
+    if (!inserted.rowCount) {
+      const existing = await client.query(
+        `SELECT id,status,accepted_count,rejected_count
+           FROM analytics_crm_imports
+          WHERE id=$1 AND site_id=$2 AND requested_by_user_id=$3`,
+        [id, input.siteId, input.userId]
+      );
+      const row = existing.rows[0];
+      if (!row) throw new AnalyticsRepositoryError("analytics_crm_import_idempotency_conflict", "Import idempotency receipt belongs to another request.", 409);
+      await client.query("COMMIT");
+      return { id: row.id, status: row.status, acceptedCount: Number(row.accepted_count), rejectedCount: Number(row.rejected_count) };
+    }
     for (const row of input.rows) {
       await client.query(
         `INSERT INTO analytics_crm_import_rows(id, import_id, crm_person_ref, payload_ciphertext)
@@ -5546,6 +6410,7 @@ async function deferAnalyticsCrmImportRow(rowId, importId, attempts, errorCode)
 }
 async function createAnalyticsActivationDestination(input) {
   assertSafeAnalyticsEventMapping(input.eventMapping);
+  const eventMapping = normalizeAnalyticsActivationEventMapping(input.eventMapping);
   const externalDatasetId = assertProviderDestination(input.platform, input.externalDatasetId);
   const operatingAccountId = input.operatingAccountId?.trim();
   if (input.platform === "google" && !operatingAccountId) {
@@ -5566,8 +6431,8 @@ async function createAnalyticsActivationDestination(input) {
   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, provider_config, created_by_user_id)
-     VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8::jsonb,$9) RETURNING *`,
+    `INSERT INTO analytics_activation_destinations(id, site_id, platform, name, connection_ref, external_dataset_id, event_mapping, provider_config, mapping_version, automatic_delivery_enabled, created_by_user_id)
+     VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8::jsonb,$9,false,$10) RETURNING *`,
     [
       randomUUID2(),
       input.siteId,
@@ -5575,8 +6440,9 @@ async function createAnalyticsActivationDestination(input) {
       input.name.trim(),
       input.connectionRef.trim(),
       externalDatasetId,
-      JSON.stringify(input.eventMapping ?? {}),
+      JSON.stringify(eventMapping),
       JSON.stringify(operatingAccountId ? { operatingAccountId } : {}),
+      eventMapping.schemaVersion,
       input.userId
     ]
   );
@@ -5610,6 +6476,13 @@ async function archiveAnalyticsActivationDestination(input) {
       404
     );
 }
+function activationMappingAllows(eventMapping, sourceEvent) {
+  try {
+    return analyticsActivationMappingEligible(eventMapping, sourceEvent);
+  } catch {
+    return false;
+  }
+}
 function safeActivationErrorCategory(error) {
   const message = error instanceof Error ? error.message.toLowerCase() : "";
   if (/401|403|authori[sz]/.test(message)) return "activation_authorization_failed";
@@ -5626,7 +6499,7 @@ async function loadActivationDestinationForEditor(input) {
   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
+            event_mapping, provider_config, mapping_version, readiness, automatic_delivery_enabled
        FROM analytics_activation_destinations
       WHERE id=$1 AND site_id=$2 AND status='active'`,
     [input.destinationId, input.siteId]
@@ -5854,7 +6727,8 @@ async function retryAnalyticsActivationJob(input) {
             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 d.status='active' AND d.automatic_delivery_enabled=true
+        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]
@@ -5944,12 +6818,14 @@ async function pollAnalyticsActivationDiagnostics(input) {
 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' AND readiness IN ('verified','live')`,
+    `SELECT id,event_mapping FROM analytics_activation_destinations
+      WHERE site_id = $1 AND status = 'active' AND automatic_delivery_enabled=true
+        AND readiness IN ('verified','live')`,
     [input.siteId]
   );
   let queued = 0;
   for (const destination of destinations.rows) {
+    if (!activationMappingAllows(destination.event_mapping, input.conversionKind)) continue;
     const result = await db.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`,
@@ -6217,17 +7093,18 @@ async function refreshAnalyticsDailyRollupsIfDue(now = /* @__PURE__ */ new Date(
     lockClient.release();
   }
 }
-function csvCell(value) {
+function analyticsCsvCell(value) {
   const text = value == null ? "" : String(value);
-  return /[\n\r,\"]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+  const neutralized = /^[=+\-@\t\r]/.test(text) ? `'${text}` : text;
+  return /[\n\r,\"]/.test(neutralized) ? `"${neutralized.replaceAll('"', '""')}"` : neutralized;
 }
 function rowsToCsv(rows) {
   const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
   if (!columns.length) return "";
   return [
-    columns.join(","),
+    columns.map((column) => analyticsCsvCell(column)).join(","),
     ...rows.map(
-      (row) => columns.map((column) => csvCell(row[column])).join(",")
+      (row) => columns.map((column) => analyticsCsvCell(row[column])).join(",")
     )
   ].join("\n");
 }
@@ -6364,6 +7241,7 @@ export {
   resolveAnalyticsMaskedIdentityProfile,
   AnalyticsProviderRegistryError,
   getAnalyticsProviderDefinition,
+  normalizeAnalyticsActivationEventMapping,
   assertConnectionSupportsProvider,
   buildProviderDeliveryRequest,
   normalizeProviderReceipt,
@@ -6451,5 +7329,6 @@ export {
   analyticsHealth,
   refreshAnalyticsDailyRollups,
   refreshAnalyticsDailyRollupsIfDue,
+  analyticsCsvCell,
   createAnalyticsExport
 };