mcp-scraper 0.84.0 → 0.86.0

package/dist/{chunk-TLRJV4SL.js → chunk-X623GTBV.js}

@@ -1688,6 +1688,20 @@ async function migrateAnalytics() {
     await client.query(
       `ALTER TABLE analytics_form_submissions ADD COLUMN IF NOT EXISTS crm_delivery_status text NOT NULL DEFAULT 'pending'`
     );
+    await client.query(
+      `ALTER TABLE analytics_form_submissions ADD COLUMN IF NOT EXISTS crm_entity_id uuid`
+    );
+    await client.query(
+      `ALTER TABLE analytics_form_submissions ADD COLUMN IF NOT EXISTS bridge_run_id uuid`
+    );
+    await client.query(
+      `ALTER TABLE analytics_form_submissions ADD COLUMN IF NOT EXISTS idempotency_key text`
+    );
+    await client.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS analytics_form_submissions_idempotency
+         ON analytics_form_submissions(form_id, idempotency_key)
+         WHERE idempotency_key IS NOT NULL`
+    );
     await client.query(`
       CREATE TABLE IF NOT EXISTS analytics_form_delivery_jobs (
         id uuid PRIMARY KEY,
@@ -1703,6 +1717,29 @@ async function migrateAnalytics() {
         delivered_at timestamptz
       )
     `);
+    await client.query(
+      `ALTER TABLE analytics_form_delivery_jobs ADD COLUMN IF NOT EXISTS bridge_run_id uuid`
+    );
+    await client.query(
+      `ALTER TABLE analytics_form_delivery_jobs ADD COLUMN IF NOT EXISTS crm_entity_id uuid`
+    );
+    await client.query(
+      `ALTER TABLE analytics_form_delivery_jobs ADD COLUMN IF NOT EXISTS idempotency_key text`
+    );
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_form_bridge_receipts (
+        id uuid PRIMARY KEY,
+        bridge_run_id uuid NOT NULL,
+        submission_id uuid NOT NULL REFERENCES analytics_form_submissions(id) ON DELETE CASCADE,
+        system text NOT NULL CHECK (system IN ('analytics','crm')),
+        status text NOT NULL CHECK (status IN ('pending','delivered','failed','expired')),
+        opaque_entity_id uuid,
+        safe_error_code text,
+        occurred_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(bridge_run_id, system)
+      )
+    `);
     await client.query(`
       CREATE TABLE IF NOT EXISTS analytics_people (
         id uuid PRIMARY KEY,
@@ -1713,6 +1750,14 @@ async function migrateAnalytics() {
         UNIQUE(site_id, crm_person_ref)
       )
     `);
+    await client.query(
+      `ALTER TABLE analytics_people ADD COLUMN IF NOT EXISTS crm_entity_id uuid`
+    );
+    await client.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS analytics_people_crm_entity
+         ON analytics_people(site_id, crm_entity_id)
+         WHERE crm_entity_id IS NOT NULL`
+    );
     await client.query(`
       CREATE TABLE IF NOT EXISTS analytics_identity_nodes (
         id uuid PRIMARY KEY,
@@ -1738,6 +1783,72 @@ async function migrateAnalytics() {
         UNIQUE(person_id, identity_node_id, evidence_kind)
       )
     `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_identity_assignments (
+        identity_node_id uuid PRIMARY KEY REFERENCES analytics_identity_nodes(id) ON DELETE CASCADE,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        person_id uuid NOT NULL REFERENCES analytics_people(id) ON DELETE CASCADE,
+        crm_entity_id uuid,
+        evidence_kind text NOT NULL,
+        assigned_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        CHECK (crm_entity_id IS NULL OR crm_entity_id::text <> '')
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_identity_assignment_conflicts (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        identity_node_id uuid REFERENCES analytics_identity_nodes(id) ON DELETE CASCADE,
+        active_person_id uuid REFERENCES analytics_people(id) ON DELETE CASCADE,
+        attempted_person_id uuid REFERENCES analytics_people(id) ON DELETE CASCADE,
+        active_crm_entity_id uuid,
+        attempted_crm_entity_id uuid,
+        evidence_kind text NOT NULL,
+        status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','resolved','dismissed')),
+        observed_at timestamptz NOT NULL DEFAULT now(),
+        resolved_at timestamptz,
+        CONSTRAINT analytics_identity_assignment_conflicts_pending_identity
+          CHECK (status <> 'pending' OR (
+            identity_node_id IS NOT NULL AND active_person_id IS NOT NULL
+            AND attempted_person_id IS NOT NULL AND active_person_id <> attempted_person_id
+          ))
+      )
+    `);
+    await client.query(
+      `ALTER TABLE analytics_identity_assignment_conflicts ALTER COLUMN identity_node_id DROP NOT NULL`
+    );
+    await client.query(
+      `ALTER TABLE analytics_identity_assignment_conflicts ALTER COLUMN active_person_id DROP NOT NULL`
+    );
+    await client.query(
+      `ALTER TABLE analytics_identity_assignment_conflicts ALTER COLUMN attempted_person_id DROP NOT NULL`
+    );
+    await client.query(
+      `ALTER TABLE analytics_identity_assignment_conflicts
+         DROP CONSTRAINT IF EXISTS analytics_identity_assignment_conflicts_check`
+    );
+    await client.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_constraint
+           WHERE conrelid='analytics_identity_assignment_conflicts'::regclass
+             AND conname='analytics_identity_assignment_conflicts_pending_identity'
+        ) THEN
+          ALTER TABLE analytics_identity_assignment_conflicts
+            ADD CONSTRAINT analytics_identity_assignment_conflicts_pending_identity
+            CHECK (status <> 'pending' OR (
+              identity_node_id IS NOT NULL AND active_person_id IS NOT NULL
+              AND attempted_person_id IS NOT NULL AND active_person_id <> attempted_person_id
+            ));
+        END IF;
+      END $$
+    `);
+    await client.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS analytics_identity_assignment_conflicts_pending
+         ON analytics_identity_assignment_conflicts(identity_node_id, active_person_id, attempted_person_id)
+         WHERE status='pending'`
+    );
     await client.query(`
       CREATE TABLE IF NOT EXISTS analytics_linker_tokens (
         id uuid PRIMARY KEY,
@@ -4131,9 +4242,8 @@ async function prepareAnalyticsLinkerIssue(input) {
       [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`,
+      `SELECT person_id FROM analytics_identity_assignments
+        WHERE site_id=$1 AND identity_node_id=$2`,
       [siteId, node.rows[0].id]
     );
     let personId = existingPerson.rows[0]?.person_id;
@@ -4151,6 +4261,12 @@ async function prepareAnalyticsLinkerIssue(input) {
          ON CONFLICT(person_id, identity_node_id, evidence_kind) DO UPDATE SET last_seen_at=now()`,
         [randomUUID2(), siteId, personId, node.rows[0].id]
       );
+      await assignAnalyticsIdentityNode(client, {
+        siteId,
+        personId,
+        identityNodeId: node.rows[0].id,
+        evidenceKind: "first_party_linker"
+      });
     }
     const tokenId = randomUUID2();
     await client.query(
@@ -4195,9 +4311,8 @@ async function redeemAnalyticsLinkerRecord(input) {
         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`,
+      `SELECT person_id FROM analytics_identity_assignments
+        WHERE site_id=$1 AND identity_node_id=$2`,
       [input.siteId, input.identityNodeId]
     );
     const personId = sourceEdge.rows[0]?.person_id;
@@ -4216,6 +4331,18 @@ async function redeemAnalyticsLinkerRecord(input) {
        ON CONFLICT(person_id, identity_node_id, evidence_kind) DO UPDATE SET last_seen_at=now()`,
       [randomUUID2(), input.siteId, personId, targetNode.rows[0].id]
     );
+    const targetAssignment = await assignAnalyticsIdentityNode(client, {
+      siteId: input.siteId,
+      personId,
+      identityNodeId: targetNode.rows[0].id,
+      evidenceKind: "cross_domain_linker"
+    });
+    if (targetAssignment === "conflict")
+      throw new AnalyticsRepositoryError(
+        "identity_assignment_conflict",
+        "The destination identity is already assigned and requires review.",
+        409
+      );
     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]
@@ -6256,6 +6383,12 @@ async function backfillAnalyticsJourneyLinkageHmacs(client) {
 function newAnalyticsPersonPublicRef() {
   return `xrp_${randomBytes2(18).toString("base64url")}`;
 }
+function deterministicAnalyticsCrmEntityId(siteId, stableIdentity) {
+  const hex = identityHmac("crm_entity_id", `${siteId}:${stableIdentity}`).slice(0, 32).split("");
+  hex[12] = "5";
+  hex[16] = ["8", "9", "a", "b"][Number.parseInt(hex[16], 16) % 4];
+  return `${hex.slice(0, 8).join("")}-${hex.slice(8, 12).join("")}-${hex.slice(12, 16).join("")}-${hex.slice(16, 20).join("")}-${hex.slice(20).join("")}`;
+}
 async function ensurePrimaryAnalyticsIdentityNamespace(client, siteId, source) {
   let namespace = await client.query(
     "SELECT id FROM analytics_identity_namespaces WHERE site_id=$1 AND status='approved' ORDER BY version DESC LIMIT 1",
@@ -6347,142 +6480,107 @@ async function backfillAnalyticsConfirmedHistory(client, input) {
   };
 }
 async function resolveAndMergeConfirmedAnalyticsPerson(client, input) {
-  const matches = await client.query(
-    `SELECT p.id
-       FROM analytics_people p
-       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
-          WHERE n.site_id=$1 AND EXISTS (
-            SELECT 1 FROM jsonb_to_recordset($2::jsonb) signal(kind text,value_hmac text)
-             WHERE signal.kind=n.kind AND signal.value_hmac=n.value_hmac
-          )
-       ) matched ON matched.person_id=p.id
-      WHERE p.site_id=$1 AND (p.namespace_id=$3 OR p.namespace_id IS NULL)
-        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.crmPersonRef
-    ]
-  );
-  const canonicalId = matches.rows[0]?.id;
-  if (!canonicalId) {
+  const explicit = await client.query(
+    `SELECT id FROM analytics_people
+      WHERE site_id=$1 AND (namespace_id=$2 OR namespace_id IS NULL)
+        AND (($3::uuid IS NOT NULL AND crm_entity_id=$3::uuid)
+          OR ($3::uuid IS NULL AND $4::text IS NOT NULL AND crm_person_ref=$4))
+      ORDER BY first_seen_at,id LIMIT 1 FOR UPDATE`,
+    [input.siteId, input.namespaceId, input.crmEntityId ?? null, input.crmPersonRef ?? null]
+  );
+  let personId = explicit.rows[0]?.id;
+  if (!personId && !input.crmEntityId && !input.crmPersonRef && input.signals.length) {
+    const assigned = await client.query(
+      `SELECT assignment.person_id
+         FROM analytics_identity_nodes node
+         JOIN analytics_identity_assignments assignment
+           ON assignment.identity_node_id=node.id AND assignment.site_id=node.site_id
+        WHERE node.site_id=$1 AND EXISTS (
+          SELECT 1 FROM jsonb_to_recordset($2::jsonb) signal(kind text,value_hmac text)
+           WHERE signal.kind=node.kind AND signal.value_hmac=node.value_hmac
+        )
+        ORDER BY assignment.assigned_at,assignment.person_id LIMIT 1`,
+      [input.siteId, JSON.stringify(input.signals.map((signal) => ({ kind: signal.kind, value_hmac: signal.valueHmac })))]
+    );
+    personId = assigned.rows[0]?.person_id;
+  }
+  if (!personId) {
+    const entityId = input.crmEntityId ?? null;
+    const compatibilityRef = input.crmPersonRef ?? (entityId ? `XRay::entity::${entityId}` : `XRay::anonymous::${randomUUID2()}`);
     const inserted = await client.query(
-      `INSERT INTO analytics_people(id, site_id, namespace_id, crm_person_ref, public_ref) VALUES ($1,$2,$3,$4,$5)
-       ON CONFLICT(site_id, crm_person_ref) DO UPDATE SET last_seen_at = now(),
+      `INSERT INTO analytics_people(id,site_id,namespace_id,crm_person_ref,crm_entity_id,public_ref)
+       VALUES($1,$2,$3,$4,$5::uuid,$6)
+       ON CONFLICT(site_id,crm_person_ref) DO UPDATE SET last_seen_at=now(),
          namespace_id=COALESCE(analytics_people.namespace_id,EXCLUDED.namespace_id),
-         public_ref=COALESCE(analytics_people.public_ref,EXCLUDED.public_ref) RETURNING id`,
-      [randomUUID2(), input.siteId, input.namespaceId, input.crmPersonRef, newAnalyticsPersonPublicRef()]
+         crm_entity_id=COALESCE(analytics_people.crm_entity_id,EXCLUDED.crm_entity_id),
+         public_ref=COALESCE(analytics_people.public_ref,EXCLUDED.public_ref)
+       RETURNING id`,
+      [randomUUID2(), input.siteId, input.namespaceId, compatibilityRef, entityId, newAnalyticsPersonPublicRef()]
     );
-    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),
-       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, input.crmPersonRef]
-  );
-  const duplicateIds = matches.rows.slice(1).map((row) => row.id);
-  if (duplicateIds.length === 0) return { personId: canonicalId, mergedPersonIds: [] };
-  await client.query(
-    `DELETE FROM analytics_identity_edges duplicate
-      USING analytics_identity_edges canonical
-      WHERE duplicate.site_id=$1 AND duplicate.person_id=ANY($2::uuid[])
-        AND canonical.site_id=duplicate.site_id AND canonical.person_id=$3
-        AND canonical.identity_node_id=duplicate.identity_node_id
-        AND canonical.evidence_kind=duplicate.evidence_kind`,
-    [input.siteId, duplicateIds, canonicalId]
-  );
-  await client.query(
-    `UPDATE analytics_identity_edges SET person_id=$3,namespace_id=$4
-      WHERE site_id=$1 AND person_id=ANY($2::uuid[])`,
-    [input.siteId, duplicateIds, canonicalId, input.namespaceId]
-  );
-  for (const table of [
-    "analytics_form_submissions",
-    "analytics_events",
-    "analytics_conversions",
-    "analytics_sessions",
-    "analytics_attribution_touches",
-    "analytics_external_events",
-    "analytics_restricted_data",
-    "analytics_crm_outbound_jobs"
-  ]) {
+    personId = inserted.rows[0].id;
+  } else {
     await client.query(
-      `UPDATE ${table} SET person_id=$3 WHERE site_id=$1 AND person_id=ANY($2::uuid[])`,
-      [input.siteId, duplicateIds, canonicalId]
+      `UPDATE analytics_people SET last_seen_at=now(),
+         namespace_id=COALESCE(namespace_id,$2),
+         crm_entity_id=COALESCE(crm_entity_id,$3::uuid),
+         public_ref=COALESCE(public_ref,$4)
+       WHERE id=$1 AND site_id=$5`,
+      [personId, input.namespaceId, input.crmEntityId ?? null, newAnalyticsPersonPublicRef(), input.siteId]
     );
   }
-  await client.query(
-    "UPDATE analytics_activation_jobs SET person_id=$2 WHERE person_id=ANY($1::uuid[])",
-    [duplicateIds, canonicalId]
-  );
-  await client.query(
-    `UPDATE analytics_candidate_associations SET promoted_person_id=$3,namespace_id=$4
-      WHERE site_id=$1 AND promoted_person_id=ANY($2::uuid[])`,
-    [input.siteId, duplicateIds, canonicalId, input.namespaceId]
-  );
-  await client.query(
-    `DELETE FROM analytics_candidate_promotions duplicate
-      USING analytics_candidate_promotions canonical
-      WHERE duplicate.site_id=$1 AND duplicate.person_id=ANY($2::uuid[])
-        AND canonical.site_id=duplicate.site_id AND canonical.person_id=$3
-        AND canonical.association_id=duplicate.association_id`,
-    [input.siteId, duplicateIds, canonicalId]
-  );
-  await client.query(
-    `UPDATE analytics_candidate_promotions SET person_id=$3,namespace_id=$4
-      WHERE site_id=$1 AND person_id=ANY($2::uuid[])`,
-    [input.siteId, duplicateIds, canonicalId, input.namespaceId]
-  );
-  await client.query(
-    `DELETE FROM analytics_crm_person_mappings duplicate
-      USING analytics_crm_person_mappings canonical
-      WHERE duplicate.site_id=$1 AND duplicate.person_id=ANY($2::uuid[])
-        AND canonical.site_id=duplicate.site_id AND canonical.person_id=$3
-        AND canonical.connection_id=duplicate.connection_id`,
-    [input.siteId, duplicateIds, canonicalId]
-  );
-  await client.query(
-    `UPDATE analytics_crm_person_mappings SET person_id=$3,namespace_id=$4
-      WHERE site_id=$1 AND person_id=ANY($2::uuid[])`,
-    [input.siteId, duplicateIds, canonicalId, input.namespaceId]
-  );
-  await client.query(
-    `DELETE FROM analytics_prediction_results duplicate
-      USING analytics_prediction_results canonical
-      WHERE duplicate.site_id=$1 AND duplicate.person_id=ANY($2::uuid[])
-        AND canonical.site_id=duplicate.site_id AND canonical.person_id=$3
-        AND canonical.manifest_id=duplicate.manifest_id`,
-    [input.siteId, duplicateIds, canonicalId]
-  );
-  for (const table of ["analytics_score_evaluations", "analytics_prediction_results"]) {
+  return { personId, mergedPersonIds: [] };
+}
+async function assignAnalyticsIdentityNode(client, input) {
+  const active = await client.query(
+    `SELECT person_id,crm_entity_id::text FROM analytics_identity_assignments
+      WHERE identity_node_id=$1 AND site_id=$2 FOR UPDATE`,
+    [input.identityNodeId, input.siteId]
+  );
+  let assignment = active.rows[0];
+  if (!assignment) {
+    await client.query(
+      `INSERT INTO analytics_identity_assignments(
+         identity_node_id,site_id,person_id,crm_entity_id,evidence_kind
+       ) VALUES($1,$2,$3,$4::uuid,$5)
+       ON CONFLICT(identity_node_id) DO NOTHING`,
+      [input.identityNodeId, input.siteId, input.personId, input.crmEntityId ?? null, input.evidenceKind]
+    );
+    const winner = await client.query(
+      `SELECT person_id FROM analytics_identity_assignments WHERE identity_node_id=$1 AND site_id=$2`,
+      [input.identityNodeId, input.siteId]
+    );
+    if (winner.rows[0]?.person_id === input.personId) return "assigned";
+    if (!winner.rows[0]) throw new AnalyticsRepositoryError("identity_assignment_unavailable", "Identity assignment could not be recorded.", 409);
+    assignment = { person_id: winner.rows[0].person_id, crm_entity_id: null };
+  }
+  if (assignment.person_id === input.personId) {
     await client.query(
-      `UPDATE ${table} SET person_id=$3,namespace_id=$4
-        WHERE site_id=$1 AND person_id=ANY($2::uuid[])`,
-      [input.siteId, duplicateIds, canonicalId, input.namespaceId]
+      `UPDATE analytics_identity_assignments SET updated_at=now(),
+         crm_entity_id=COALESCE(crm_entity_id,$3::uuid),evidence_kind=$4
+       WHERE identity_node_id=$1 AND site_id=$2`,
+      [input.identityNodeId, input.siteId, input.crmEntityId ?? null, input.evidenceKind]
     );
+    return "existing";
   }
   await client.query(
-    "UPDATE analytics_identity_profile_access_audits SET person_id=$3 WHERE site_id=$1 AND person_id=ANY($2::uuid[])",
-    [input.siteId, duplicateIds, canonicalId]
-  );
-  await client.query(
-    "UPDATE analytics_identity_tombstones SET person_id=$3 WHERE site_id=$1 AND person_id=ANY($2::uuid[])",
-    [input.siteId, duplicateIds, canonicalId]
-  );
-  await client.query(
-    "DELETE FROM analytics_people WHERE site_id=$1 AND id=ANY($2::uuid[])",
-    [input.siteId, duplicateIds]
+    `INSERT INTO analytics_identity_assignment_conflicts(
+       id,site_id,identity_node_id,active_person_id,attempted_person_id,
+       active_crm_entity_id,attempted_crm_entity_id,evidence_kind
+     ) VALUES($1,$2,$3,$4,$5,$6::uuid,$7::uuid,$8)
+     ON CONFLICT(identity_node_id,active_person_id,attempted_person_id)
+       WHERE status='pending' DO UPDATE SET observed_at=now(),evidence_kind=EXCLUDED.evidence_kind`,
+    [
+      randomUUID2(),
+      input.siteId,
+      input.identityNodeId,
+      assignment.person_id,
+      input.personId,
+      assignment.crm_entity_id,
+      input.crmEntityId ?? null,
+      input.evidenceKind
+    ]
   );
-  return { personId: canonicalId, mergedPersonIds: duplicateIds };
+  return "conflict";
 }
 async function promoteAnalyticsCandidatesForConfirmedPerson(client, input) {
   const associations = await client.query(
@@ -6632,6 +6730,7 @@ async function linkAnalyticsIdentityInTransaction(client, input) {
   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 = [];
+  let hasAssignmentConflict = false;
   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)
@@ -6648,8 +6747,15 @@ async function linkAnalyticsIdentityInTransaction(client, input) {
          namespace_id=COALESCE(analytics_identity_edges.namespace_id,EXCLUDED.namespace_id)`,
       [randomUUID2(), input.siteId, namespaceId, personId, node.rows[0].id, signal.evidence, signal.confidence]
     );
+    const assignment = await assignAnalyticsIdentityNode(client, {
+      siteId: input.siteId,
+      personId,
+      identityNodeId: node.rows[0].id,
+      evidenceKind: signal.evidence
+    });
+    hasAssignmentConflict ||= assignment === "conflict";
   }
-  await completeAnalyticsIdentityPromotion(client, {
+  if (!hasAssignmentConflict) await completeAnalyticsIdentityPromotion(client, {
     siteId: input.siteId,
     namespaceId,
     personId,
@@ -6662,7 +6768,7 @@ async function linkAnalyticsIdentityInTransaction(client, input) {
     sessionId: input.sessionId,
     occurredAt: input.occurredAt
   });
-  if (input.customerId) {
+  if (input.customerId && !hasAssignmentConflict) {
     await writeAnalyticsConfirmedIdentityProfile(client, {
       siteId: input.siteId,
       personId,
@@ -6685,7 +6791,7 @@ async function linkAnalyticsFormIdentity(input) {
       input.sessionId
     )) {
       await client.query("COMMIT");
-      return { personId: null, linkedSignals: 0 };
+      return { personId: null, linkedSignals: 0, conflicts: 0 };
     }
     const namespaceId = await ensurePrimaryAnalyticsIdentityNamespace(client, input.siteId, "form");
     const deterministicSignals = [
@@ -6705,6 +6811,7 @@ async function linkAnalyticsFormIdentity(input) {
       siteId: input.siteId,
       namespaceId,
       crmPersonRef: input.crmPersonRef,
+      crmEntityId: input.crmEntityId,
       signals: matchSignals
     });
     const personId = resolution.personId;
@@ -6748,6 +6855,7 @@ async function linkAnalyticsFormIdentity(input) {
       });
     }
     const identityNodeIds = [];
+    let conflicts = 0;
     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)
@@ -6778,25 +6886,33 @@ async function linkAnalyticsFormIdentity(input) {
           signal.confidence
         ]
       );
+      const assignment = await assignAnalyticsIdentityNode(client, {
+        siteId: input.siteId,
+        personId,
+        crmEntityId: input.crmEntityId,
+        identityNodeId: node.rows[0].id,
+        evidenceKind: signal.evidence
+      });
+      if (assignment === "conflict") conflicts += 1;
     }
     if (input.submissionId)
       await client.query(
         "UPDATE analytics_form_submissions SET person_id = $1 WHERE id = $2 AND site_id = $3",
         [personId, input.submissionId, input.siteId]
       );
-    await completeAnalyticsIdentityPromotion(client, {
+    if (conflicts === 0) 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,
+      evidenceRef: input.submissionId ?? input.crmEntityId ?? input.crmPersonRef ?? personId,
       priorPersonIds: resolution.mergedPersonIds,
       priorIdentityNodeIds: identityNodeIds,
       visitorId: input.visitorId,
       sessionId: input.sessionId
     });
-    await writeAnalyticsConfirmedIdentityProfile(client, {
+    if (conflicts === 0) await writeAnalyticsConfirmedIdentityProfile(client, {
       siteId: input.siteId,
       personId,
       consentSubjectRefs: [input.visitorId ?? ""],
@@ -6806,7 +6922,7 @@ async function linkAnalyticsFormIdentity(input) {
       phone: input.phone
     });
     await client.query("COMMIT");
-    return { personId, linkedSignals: signals.length };
+    return { personId, linkedSignals: signals.length, conflicts };
   } catch (error) {
     await client.query("ROLLBACK");
     throw error;
@@ -6827,7 +6943,7 @@ async function enrichAnalyticsExistingCrmIdentity(input) {
     const person = existing.rows[0];
     if (!person || !await hasCurrentPersonIdentityConsent(client, input.siteId, person.public_ref)) {
       await client.query("COMMIT");
-      return { personId: null, linkedSignals: 0 };
+      return { personId: null, linkedSignals: 0, conflicts: 0 };
     }
     const signals = [
       ...input.email ? [{ kind: "email", value: input.email, confidence: 1 }] : [],
@@ -6841,6 +6957,7 @@ async function enrichAnalyticsExistingCrmIdentity(input) {
       siteId: input.siteId,
       namespaceId: person.namespace_id,
       crmPersonRef: input.crmPersonRef,
+      crmEntityId: input.crmEntityId,
       signals: signals.map((signal) => ({ kind: signal.kind, valueHmac: identityHmac(signal.kind, signal.value) }))
     });
     const personId = resolution.personId;
@@ -6850,6 +6967,7 @@ async function enrichAnalyticsExistingCrmIdentity(input) {
     );
     const canonicalPublicRef = canonical.rows[0]?.public_ref ?? person.public_ref;
     const identityNodeIds = [];
+    let conflicts = 0;
     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)
@@ -6865,8 +6983,16 @@ async function enrichAnalyticsExistingCrmIdentity(input) {
            confidence=greatest(analytics_identity_edges.confidence,EXCLUDED.confidence)`,
         [randomUUID2(), input.siteId, person.namespace_id, personId, node.rows[0].id, signal.confidence]
       );
+      const assignment = await assignAnalyticsIdentityNode(client, {
+        siteId: input.siteId,
+        personId,
+        crmEntityId: input.crmEntityId,
+        identityNodeId: node.rows[0].id,
+        evidenceKind: "crm_contact"
+      });
+      if (assignment === "conflict") conflicts += 1;
     }
-    await completeAnalyticsIdentityPromotion(client, {
+    if (conflicts === 0) await completeAnalyticsIdentityPromotion(client, {
       siteId: input.siteId,
       namespaceId: person.namespace_id,
       personId,
@@ -6876,7 +7002,7 @@ async function enrichAnalyticsExistingCrmIdentity(input) {
       priorPersonIds: resolution.mergedPersonIds,
       priorIdentityNodeIds: identityNodeIds
     });
-    await writeAnalyticsConfirmedIdentityProfile(client, {
+    if (conflicts === 0) await writeAnalyticsConfirmedIdentityProfile(client, {
       siteId: input.siteId,
       personId,
       consentSubjectRefs: [canonicalPublicRef],
@@ -6886,7 +7012,7 @@ async function enrichAnalyticsExistingCrmIdentity(input) {
       phone: input.phone
     });
     await client.query("COMMIT");
-    return { personId, linkedSignals: signals.length };
+    return { personId, linkedSignals: signals.length, conflicts };
   } catch (error) {
     await client.query("ROLLBACK");
     throw error;
@@ -7533,6 +7659,111 @@ async function queueAnalyticsFormDelivery(input) {
   );
   return id;
 }
+async function queueAnalyticsFormBridgeTransaction(input) {
+  const client = await getAnalyticsPool().connect();
+  const proposedSubmissionId = randomUUID2();
+  const proposedBridgeRunId = randomUUID2();
+  const proposedCrmEntityId = input.crmEntityId ?? randomUUID2();
+  const occurredAt = input.occurredAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    await client.query("BEGIN");
+    const inserted = await client.query(
+      `INSERT INTO analytics_form_submissions(
+         id,form_id,site_id,pixel_id,visitor_id,session_id,crm_person_ref,
+         crm_entity_id,bridge_run_id,idempotency_key,source,medium,campaign,
+         crm_delivery_status,click_ids,occurred_at
+       ) VALUES($1,$2,$3,$4,$5,$6,$7,$8::uuid,$9,$10,$11,$12,$13,'pending',$14::jsonb,$15)
+       ON CONFLICT(form_id,idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING
+       RETURNING id,bridge_run_id,crm_entity_id::text`,
+      [
+        proposedSubmissionId,
+        input.form.id,
+        input.form.site_id,
+        input.form.pixel_id,
+        input.visitorId ?? null,
+        input.sessionId ?? null,
+        input.legacyCrmPersonRef ?? null,
+        proposedCrmEntityId,
+        proposedBridgeRunId,
+        input.idempotencyKey,
+        input.source?.slice(0, 180) ?? null,
+        input.medium?.slice(0, 180) ?? null,
+        input.campaign?.slice(0, 240) ?? null,
+        JSON.stringify(sanitizeClickIds(input.clickIds)),
+        occurredAt
+      ]
+    );
+    const created = Boolean(inserted.rows[0]);
+    const existing = inserted.rows[0] ?? (await client.query(
+      `SELECT id,bridge_run_id::text,crm_entity_id::text
+         FROM analytics_form_submissions
+        WHERE form_id=$1 AND idempotency_key=$2 FOR UPDATE`,
+      [input.form.id, input.idempotencyKey]
+    )).rows[0];
+    if (!existing?.bridge_run_id || !existing.crm_entity_id)
+      throw new AnalyticsRepositoryError(
+        "form_bridge_idempotency_conflict",
+        "The form idempotency receipt belongs to a legacy submission.",
+        409
+      );
+    const conversionId = randomUUID2();
+    const conversion = await client.query(
+      `INSERT INTO analytics_conversions(
+         id,source_event_id,site_id,pixel_id,session_id,session_hmac,
+         conversion_kind,value_minor,currency,occurred_at
+       ) VALUES($1,$2,$3,$4,$5,$6,'form_submitted',0,'USD',$7)
+       ON CONFLICT(site_id,source_event_id) DO UPDATE SET source_event_id=EXCLUDED.source_event_id
+       RETURNING id`,
+      [
+        conversionId,
+        `form:${existing.id}`,
+        input.form.site_id,
+        input.form.pixel_id,
+        input.sessionId ?? null,
+        input.sessionId ? identityHmac("session_id", input.sessionId) : null,
+        occurredAt
+      ]
+    );
+    await client.query(
+      `INSERT INTO analytics_form_delivery_jobs(
+         id,submission_id,owner_user_id,payload_ciphertext,bridge_run_id,
+         crm_entity_id,idempotency_key
+       ) VALUES($1,$2,$3,$4,$5,$6::uuid,$7)
+       ON CONFLICT(submission_id) DO NOTHING`,
+      [
+        randomUUID2(),
+        existing.id,
+        input.ownerUserId,
+        input.payloadCiphertext,
+        existing.bridge_run_id,
+        existing.crm_entity_id,
+        input.idempotencyKey
+      ]
+    );
+    await client.query(
+      `INSERT INTO analytics_form_bridge_receipts(
+         id,bridge_run_id,submission_id,system,status,opaque_entity_id
+       ) VALUES
+         ($1,$2,$3,'analytics','delivered',NULL),
+         ($4,$2,$3,'crm','pending',$5::uuid)
+       ON CONFLICT(bridge_run_id,system) DO NOTHING`,
+      [randomUUID2(), existing.bridge_run_id, existing.id, randomUUID2(), existing.crm_entity_id]
+    );
+    await client.query("COMMIT");
+    return {
+      submissionId: existing.id,
+      bridgeRunId: existing.bridge_run_id,
+      crmEntityId: existing.crm_entity_id,
+      conversionId: conversion.rows[0].id,
+      created
+    };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
 async function sweepAnalyticsRestrictedRetention() {
   const db = getAnalyticsPool();
   const client = await db.connect();
@@ -7575,7 +7806,8 @@ async function claimAnalyticsFormDeliveryJobs(limit = 10) {
         SET attempts = j.attempts + 1,
             next_attempt_at = now() + interval '5 minutes'
        FROM due WHERE j.id = due.id
-     RETURNING j.id, j.submission_id, j.owner_user_id, j.payload_ciphertext, j.attempts`,
+     RETURNING j.id, j.submission_id, j.owner_user_id, j.payload_ciphertext, j.attempts,
+       j.bridge_run_id::text,j.crm_entity_id::text,j.idempotency_key`,
     [Math.min(Math.max(limit, 1), 50)]
   );
   return result.rows.map((row) => ({
@@ -7583,21 +7815,37 @@ async function claimAnalyticsFormDeliveryJobs(limit = 10) {
     submissionId: row.submission_id,
     ownerUserId: Number(row.owner_user_id),
     payloadCiphertext: row.payload_ciphertext,
-    attempts: row.attempts
+    attempts: row.attempts,
+    bridgeRunId: row.bridge_run_id,
+    crmEntityId: row.crm_entity_id,
+    idempotencyKey: row.idempotency_key
   }));
 }
 async function completeAnalyticsFormDelivery(jobId, submissionId) {
+  await completeAnalyticsFormBridgeDelivery({ jobId, submissionId });
+}
+async function completeAnalyticsFormBridgeDelivery(input) {
   const db = getAnalyticsPool();
   const client = await db.connect();
   try {
     await client.query("BEGIN");
     await client.query(
       `UPDATE analytics_form_delivery_jobs SET status='delivered', delivered_at=now(), last_error_code=NULL WHERE id=$1`,
-      [jobId]
+      [input.jobId]
     );
     await client.query(
-      `UPDATE analytics_form_submissions SET crm_delivery_status='delivered' WHERE id=$1`,
-      [submissionId]
+      `UPDATE analytics_form_submissions SET crm_delivery_status='delivered',
+         crm_entity_id=COALESCE(crm_entity_id,$2::uuid) WHERE id=$1`,
+      [input.submissionId, input.crmEntityId ?? null]
+    );
+    await client.query(
+      `UPDATE analytics_form_bridge_receipts receipt
+          SET status='delivered',opaque_entity_id=COALESCE(opaque_entity_id,$3::uuid),
+              safe_error_code=NULL,updated_at=now()
+         FROM analytics_form_delivery_jobs job
+        WHERE job.id=$1 AND receipt.bridge_run_id=job.bridge_run_id
+          AND receipt.submission_id=$2 AND receipt.system='crm'`,
+      [input.jobId, input.submissionId, input.crmEntityId ?? null]
     );
     await client.query("COMMIT");
   } catch (error) {
@@ -7610,14 +7858,34 @@ async function completeAnalyticsFormDelivery(jobId, submissionId) {
 async function deferAnalyticsFormDelivery(jobId, attempts, errorCode) {
   const terminal = attempts >= 8;
   const delayMinutes = Math.min(5 * 2 ** Math.max(0, attempts - 1), 360);
-  await getAnalyticsPool().query(
-    `UPDATE analytics_form_delivery_jobs
-        SET status = CASE WHEN expires_at <= now() THEN 'expired' WHEN $2 THEN 'failed' ELSE 'pending' END,
-            last_error_code = $3,
-            next_attempt_at = now() + ($4::text || ' minutes')::interval
-      WHERE id = $1`,
-    [jobId, terminal, errorCode.slice(0, 80), String(delayMinutes)]
-  );
+  const client = await getAnalyticsPool().connect();
+  try {
+    await client.query("BEGIN");
+    const updated = await client.query(
+      `UPDATE analytics_form_delivery_jobs
+          SET status = CASE WHEN expires_at <= now() THEN 'expired' WHEN $2 THEN 'failed' ELSE 'pending' END,
+              last_error_code = $3,
+              next_attempt_at = now() + ($4::text || ' minutes')::interval
+        WHERE id = $1
+        RETURNING bridge_run_id::text,submission_id::text,status`,
+      [jobId, terminal, errorCode.slice(0, 80), String(delayMinutes)]
+    );
+    const job = updated.rows[0];
+    if (job?.bridge_run_id) {
+      await client.query(
+        `UPDATE analytics_form_bridge_receipts SET status=$3,
+           safe_error_code=$4,updated_at=now()
+         WHERE bridge_run_id=$1 AND submission_id=$2 AND system='crm'`,
+        [job.bridge_run_id, job.submission_id, job.status, errorCode.slice(0, 80)]
+      );
+    }
+    await client.query("COMMIT");
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
 }
 async function isAnalyticsFormPlacementApproved(pixelId, placementUrl) {
   if (!placementUrl) return false;
@@ -7983,7 +8251,9 @@ export {
   recordAnalyticsFormSubmission,
   sanitizeClickIds,
   identityHmac,
+  deterministicAnalyticsCrmEntityId,
   backfillAnalyticsConfirmedHistory,
+  assignAnalyticsIdentityNode,
   linkAnalyticsIdentityInTransaction,
   linkAnalyticsFormIdentity,
   enrichAnalyticsExistingCrmIdentity,
@@ -8005,9 +8275,11 @@ export {
   pollAnalyticsActivationDiagnostics,
   queueAnalyticsActivation,
   queueAnalyticsFormDelivery,
+  queueAnalyticsFormBridgeTransaction,
   sweepAnalyticsRestrictedRetention,
   claimAnalyticsFormDeliveryJobs,
   completeAnalyticsFormDelivery,
+  completeAnalyticsFormBridgeDelivery,
   deferAnalyticsFormDelivery,
   isAnalyticsFormPlacementApproved,
   analyticsHealth,