@bufinance/gtm-graph 0.1.0

package/dist/view/index.cjs

@@ -0,0 +1,1142 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/view/index.ts
+var view_exports = {};
+__export(view_exports, {
+  CLASS_ACCENTS: () => CLASS_ACCENTS,
+  EDGE_TYPE_STYLES: () => EDGE_TYPE_STYLES,
+  ENTITY_COLORS: () => ENTITY_COLORS,
+  FALLBACK_ENTITY_COLOR: () => FALLBACK_ENTITY_COLOR,
+  GtmGraphView: () => GtmGraphView,
+  TRACE_ACCENTS: () => TRACE_ACCENTS,
+  buildEdgeVisuals: () => buildEdgeVisuals,
+  buildNodeVisuals: () => buildNodeVisuals,
+  buildTrace: () => buildTrace,
+  edgeTypeStyle: () => edgeTypeStyle,
+  entityColor: () => entityColor,
+  nodeRadius: () => nodeRadius,
+  resolveClasses: () => resolveClasses,
+  traceEdgeIds: () => traceEdgeIds
+});
+module.exports = __toCommonJS(view_exports);
+
+// src/view/gtm-graph-view.tsx
+var import_react = require("react");
+
+// src/algorithms/graph-paths.ts
+var RECENCY_HALF_LIFE_DAYS = 90;
+var DEFAULT_STRENGTH = 1;
+var DEFAULT_EVIDENCE_COUNT = 1;
+var MIN_EDGE_WEIGHT = 1e-6;
+var MS_PER_DAY = 864e5;
+function recencyFactor(lastSeenAt, now) {
+  if (!lastSeenAt) return 1;
+  const seenAt = Date.parse(lastSeenAt);
+  if (Number.isNaN(seenAt)) return 1;
+  const daysStale = Math.max(0, (now - seenAt) / MS_PER_DAY);
+  return 0.5 ** (daysStale / RECENCY_HALF_LIFE_DAYS);
+}
+function edgeWeight(edge, now) {
+  const strength = edge.strength ?? DEFAULT_STRENGTH;
+  const evidence = edge.evidenceCount ?? DEFAULT_EVIDENCE_COUNT;
+  const weight = strength * Math.log(1 + Math.max(0, evidence)) * recencyFactor(edge.lastSeenAt, now);
+  return Math.max(MIN_EDGE_WEIGHT, weight);
+}
+function buildAdjacency(data, options) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const entity of data.entities) adjacency.set(entity.id, []);
+  for (const edge of data.relationships) {
+    const weight = edgeWeight(edge, options.now);
+    const forward = {
+      edgeId: edge.id,
+      otherId: edge.targetEntityId,
+      relationshipType: edge.relationshipType,
+      weight
+    };
+    const backward = {
+      edgeId: edge.id,
+      otherId: edge.sourceEntityId,
+      relationshipType: edge.relationshipType,
+      weight
+    };
+    if (adjacency.has(edge.sourceEntityId) && adjacency.has(edge.targetEntityId)) {
+      adjacency.get(edge.sourceEntityId).push(forward);
+      adjacency.get(edge.targetEntityId).push(backward);
+    }
+  }
+  return adjacency;
+}
+function fewestHops(data, fromId, toId, options = {}) {
+  const adjacency = options.adjacency ?? buildAdjacency(data, { now: options.now ?? 0 });
+  if (!adjacency.has(fromId) || !adjacency.has(toId)) return null;
+  if (fromId === toId) return { nodeIds: [fromId], edgeIds: [], hops: 0, cost: 0 };
+  const previous = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set([fromId]);
+  let frontier = [fromId];
+  let depth = 0;
+  while (frontier.length > 0) {
+    depth++;
+    if (options.maxHops != null && depth > options.maxHops) return null;
+    const next = [];
+    for (const nodeId of frontier) {
+      for (const edge of adjacency.get(nodeId) ?? []) {
+        if (visited.has(edge.otherId)) continue;
+        visited.add(edge.otherId);
+        previous.set(edge.otherId, { nodeId, edge });
+        if (edge.otherId === toId) return reconstructPath(previous, fromId, toId);
+        next.push(edge.otherId);
+      }
+    }
+    frontier = next;
+  }
+  return null;
+}
+function reconstructPath(previous, fromId, toId) {
+  const nodeIds = [toId];
+  const edgeIds = [];
+  let cost = 0;
+  let cursor = toId;
+  while (cursor !== fromId) {
+    const step = previous.get(cursor);
+    edgeIds.unshift(step.edge.edgeId);
+    cost += 1 / step.edge.weight;
+    nodeIds.unshift(step.nodeId);
+    cursor = step.nodeId;
+  }
+  return { nodeIds, edgeIds, hops: edgeIds.length, cost };
+}
+function strongestPath(data, fromId, toId, options) {
+  const adjacency = options.adjacency ?? buildAdjacency(data, { now: options.now });
+  if (!adjacency.has(fromId) || !adjacency.has(toId)) return null;
+  if (fromId === toId) return { nodeIds: [fromId], edgeIds: [], hops: 0, cost: 0 };
+  const distance = /* @__PURE__ */ new Map([[fromId, 0]]);
+  const previous = /* @__PURE__ */ new Map();
+  const settled = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Set([fromId]);
+  while (pending.size > 0) {
+    let current = null;
+    let best = Number.POSITIVE_INFINITY;
+    for (const nodeId of pending) {
+      const d = distance.get(nodeId) ?? Number.POSITIVE_INFINITY;
+      if (d < best) {
+        best = d;
+        current = nodeId;
+      }
+    }
+    if (current == null) break;
+    pending.delete(current);
+    if (current === toId) break;
+    if (settled.has(current)) continue;
+    settled.add(current);
+    for (const edge of adjacency.get(current) ?? []) {
+      if (settled.has(edge.otherId)) continue;
+      const candidate = best + 1 / edge.weight;
+      if (candidate < (distance.get(edge.otherId) ?? Number.POSITIVE_INFINITY)) {
+        distance.set(edge.otherId, candidate);
+        previous.set(edge.otherId, { nodeId: current, edge });
+        pending.add(edge.otherId);
+      }
+    }
+  }
+  if (!distance.has(toId)) return null;
+  return reconstructPath(previous, fromId, toId);
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t ^= t + Math.imul(t ^ t >>> 7, 61 | t);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var DEFAULT_BRIDGE_SAMPLE_SIZE = 200;
+var DEFAULT_BRIDGE_SEED = 99;
+function bridgeScores(data, options = {}) {
+  const now = options.now ?? 0;
+  const adjacency = buildAdjacency(data, { now });
+  const nodeIds = data.entities.map((e) => e.id);
+  const scores = new Map(nodeIds.map((id) => [id, 0]));
+  if (nodeIds.length < 3) return scores;
+  let pairs;
+  if (options.pairs) {
+    pairs = options.pairs;
+  } else {
+    const sampleSize = options.sampleSize ?? DEFAULT_BRIDGE_SAMPLE_SIZE;
+    const random = mulberry32(options.seed ?? DEFAULT_BRIDGE_SEED);
+    const seen = /* @__PURE__ */ new Set();
+    pairs = [];
+    const maxDistinctPairs = nodeIds.length * (nodeIds.length - 1) / 2;
+    const target = Math.min(sampleSize, maxDistinctPairs);
+    for (let attempt = 0; attempt < target * 20 && pairs.length < target; attempt++) {
+      const i = Math.floor(random() * nodeIds.length);
+      const j = Math.floor(random() * nodeIds.length);
+      if (i === j) continue;
+      const key = i < j ? `${i}|${j}` : `${j}|${i}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      pairs.push([nodeIds[Math.min(i, j)], nodeIds[Math.max(i, j)]]);
+    }
+  }
+  for (const [fromId, toId] of pairs) {
+    const path = fewestHops(data, fromId, toId, { adjacency });
+    if (!path) continue;
+    for (const nodeId of path.nodeIds.slice(1, -1)) {
+      scores.set(nodeId, (scores.get(nodeId) ?? 0) + 1);
+    }
+  }
+  let max = 0;
+  for (const score of scores.values()) if (score > max) max = score;
+  if (max > 0) {
+    for (const [nodeId, score] of scores) scores.set(nodeId, score / max);
+  }
+  return scores;
+}
+
+// src/algorithms/gtm-decorations.ts
+var POI_EDGE_TYPES = ["champion_of", "decision_maker_for"];
+var DEFAULT_CLOSED_STAGES = ["activo", "nurture/perdido", "won", "lost"];
+var DEFAULT_POI_TITLE_PATTERNS = [
+  "founder",
+  "co-founder",
+  "cofounder",
+  "ceo",
+  "coo",
+  "cfo",
+  "owner",
+  "partner",
+  "managing director",
+  "director general",
+  "general manager",
+  "head of finance",
+  "head of operations",
+  "finance manager",
+  "operations manager"
+];
+function metadataString(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" ? value : null;
+}
+function isOpenDeal(deal, closedStages = DEFAULT_CLOSED_STAGES) {
+  const stage = metadataString(deal.metadata, "stage");
+  if (!stage) return true;
+  return !closedStages.includes(stage.trim().toLowerCase());
+}
+function computePoiIds(data, options = {}) {
+  const closedStages = options.closedStages ?? DEFAULT_CLOSED_STAGES;
+  const titlePatterns = options.titlePatterns ?? DEFAULT_POI_TITLE_PATTERNS;
+  const byId = new Map(data.entities.map((e) => [e.id, e]));
+  const pois = /* @__PURE__ */ new Set();
+  for (const edge of data.relationships) {
+    if (!POI_EDGE_TYPES.includes(edge.relationshipType))
+      continue;
+    const source = byId.get(edge.sourceEntityId);
+    const target = byId.get(edge.targetEntityId);
+    if (!source || source.entityType !== "person" || !target) continue;
+    const isDealTarget = target.entityType === "project";
+    if (isDealTarget && !isOpenDeal(target, closedStages)) continue;
+    pois.add(source.id);
+  }
+  for (const entity of data.entities) {
+    if (entity.entityType !== "person") continue;
+    const title = metadataString(entity.metadata, "title")?.toLowerCase();
+    if (!title) continue;
+    if (titlePatterns.some((pattern) => title.includes(pattern))) pois.add(entity.id);
+  }
+  return pois;
+}
+function computeBridgeIds(data, options = {}) {
+  const topN = options.topN ?? 5;
+  const scores = bridgeScores(data, {
+    now: options.now ?? 0,
+    seed: options.seed,
+    pairs: options.pairs
+  });
+  const ranked = [...scores.entries()].filter(([, score]) => score > 0).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, topN);
+  return new Set(ranked.map(([id]) => id));
+}
+function classifyNode(id, poiIds, bridgeIds) {
+  if (poiIds.has(id)) return "poi";
+  if (bridgeIds.has(id)) return "bridge";
+  return "other";
+}
+function capGraph(data, maxNodes, pinned = /* @__PURE__ */ new Set()) {
+  if (data.entities.length <= maxNodes) return data;
+  const degree = /* @__PURE__ */ new Map();
+  for (const edge of data.relationships) {
+    degree.set(edge.sourceEntityId, (degree.get(edge.sourceEntityId) ?? 0) + 1);
+    degree.set(edge.targetEntityId, (degree.get(edge.targetEntityId) ?? 0) + 1);
+  }
+  const ranked = [...data.entities].sort((a, b) => {
+    const pinnedDelta = Number(pinned.has(b.id)) - Number(pinned.has(a.id));
+    if (pinnedDelta !== 0) return pinnedDelta;
+    return (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0) || a.id.localeCompare(b.id);
+  });
+  const keep = new Set(ranked.slice(0, maxNodes).map((e) => e.id));
+  return {
+    entities: data.entities.filter((e) => keep.has(e.id)),
+    relationships: data.relationships.filter(
+      (r) => keep.has(r.sourceEntityId) && keep.has(r.targetEntityId)
+    )
+  };
+}
+
+// src/view/physics.ts
+var REPULSION_STRENGTH = 225;
+var MAX_REPULSION_FORCE = 22;
+var SPRING_REST = 120;
+var SPRING_K = 0.055;
+var COLLISION_PADDING = 18;
+var CENTER_GRAVITY = 0.025;
+var DAMPING = 0.85;
+var MAX_VELOCITY = 15;
+var SIM_STEPS = 500;
+var SEMANTIC_GRAVITY = 0.33;
+var SEARCH_PULL = 0.25;
+var CLEARING_PUSH = 0.01;
+var SEARCH_DAMPING = 0.88;
+function initializePositions(nodes, width, height) {
+  const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+  const maxRadius = Math.min(width, height) * 0.35;
+  nodes.forEach((n, i) => {
+    const angle = i * goldenAngle;
+    const r = maxRadius * Math.sqrt((i + 1) / nodes.length);
+    n.x = Math.cos(angle) * r;
+    n.y = Math.sin(angle) * r;
+    n.vx = 0;
+    n.vy = 0;
+  });
+}
+function simulateStep(nodes, edges, _width, _height, activeSearchIds) {
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const a = nodes[i];
+      const b = nodes[j];
+      let dx = b.x - a.x;
+      let dy = b.y - a.y;
+      if (Math.abs(dx) < 0.5 && Math.abs(dy) < 0.5) {
+        dx = (Math.random() - 0.5) * 4;
+        dy = (Math.random() - 0.5) * 4;
+      }
+      const distSq = dx * dx + dy * dy;
+      const dist = Math.sqrt(distSq);
+      const rawForce = REPULSION_STRENGTH / Math.max(dist, 1);
+      const force = Math.min(rawForce, MAX_REPULSION_FORCE);
+      const fx = dx / dist * force;
+      const fy = dy / dist * force;
+      a.vx -= fx;
+      a.vy -= fy;
+      b.vx += fx;
+      b.vy += fy;
+    }
+  }
+  for (const e of edges) {
+    const a = nodeMap.get(e.source);
+    const b = nodeMap.get(e.target);
+    if (!a || !b) continue;
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const dist = Math.max(Math.sqrt(dx * dx + dy * dy), 1);
+    const edgeStrength = e.strength ?? 0.5;
+    const restLength = SPRING_REST * (1.4 - edgeStrength * 0.9);
+    const k = SPRING_K * (0.5 + edgeStrength);
+    const displacement = dist - restLength;
+    const force = displacement * k;
+    const fx = dx / dist * force;
+    const fy = dy / dist * force;
+    a.vx += fx;
+    a.vy += fy;
+    b.vx -= fx;
+    b.vy -= fy;
+  }
+  const searching = activeSearchIds && activeSearchIds.size > 0;
+  for (const n of nodes) {
+    const dx = -n.x;
+    const dy = -n.y;
+    const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+    if (searching) {
+      if (activeSearchIds.has(n.id)) {
+        n.vx += dx / dist * SEARCH_PULL * dist * 0.01;
+        n.vy += dy / dist * SEARCH_PULL * dist * 0.01;
+      } else {
+        n.vx -= dx / dist * CLEARING_PUSH;
+        n.vy -= dy / dist * CLEARING_PUSH;
+      }
+    } else {
+      n.vx += dx * CENTER_GRAVITY;
+      n.vy += dy * CENTER_GRAVITY;
+    }
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const a = nodes[i];
+      const b = nodes[j];
+      if (a.group !== b.group) continue;
+      const dx = b.x - a.x;
+      const dy = b.y - a.y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist < 1 || dist > 300) continue;
+      const force = SEMANTIC_GRAVITY * Math.min(dist * 0.1, 2);
+      const fx = dx / dist * force;
+      const fy = dy / dist * force;
+      a.vx += fx;
+      a.vy += fy;
+      b.vx -= fx;
+      b.vy -= fy;
+    }
+  }
+  const currentDamping = searching ? SEARCH_DAMPING : DAMPING;
+  for (const n of nodes) {
+    n.vx *= currentDamping;
+    n.vy *= currentDamping;
+    const speed = Math.sqrt(n.vx * n.vx + n.vy * n.vy);
+    if (speed > MAX_VELOCITY) {
+      n.vx = n.vx / speed * MAX_VELOCITY;
+      n.vy = n.vy / speed * MAX_VELOCITY;
+    }
+    n.x += n.vx;
+    n.y += n.vy;
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const a = nodes[i];
+      const b = nodes[j];
+      const dx = b.x - a.x;
+      const dy = b.y - a.y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      const minDist = a.radius + b.radius + COLLISION_PADDING;
+      if (dist < minDist && dist > 0.01) {
+        const overlap = (minDist - dist) / 2;
+        const nx = dx / dist;
+        const ny = dy / dist;
+        a.x -= nx * overlap;
+        a.y -= ny * overlap;
+        b.x += nx * overlap;
+        b.y += ny * overlap;
+        const relVelDot = (b.vx - a.vx) * nx + (b.vy - a.vy) * ny;
+        if (relVelDot < 0) {
+          a.vx += nx * relVelDot * 0.5;
+          a.vy += ny * relVelDot * 0.5;
+          b.vx -= nx * relVelDot * 0.5;
+          b.vy -= ny * relVelDot * 0.5;
+        }
+      }
+    }
+  }
+}
+function runSimulation(nodes, edges, width, height) {
+  initializePositions(nodes, width, height);
+  for (let i = 0; i < SIM_STEPS; i++) {
+    simulateStep(nodes, edges, width, height);
+  }
+}
+function getMotionSeed(id) {
+  let hash = 0;
+  for (let i = 0; i < id.length; i++) {
+    hash = (hash << 5) - hash + id.charCodeAt(i) | 0;
+  }
+  const norm = (v) => (v % 1e3 + 1e3) % 1e3 / 1e3;
+  return {
+    phase: norm(hash) * Math.PI * 2,
+    amplitude: 2 + norm(hash >> 8) * 2.5,
+    speed: 3e-4 + norm(hash >> 16) * 3e-4
+  };
+}
+function getFloatingOffset(id, time) {
+  const seed = getMotionSeed(id);
+  const phase = seed.phase + time * seed.speed;
+  return {
+    dx: Math.sin(phase) * seed.amplitude,
+    dy: Math.cos(phase * 0.9) * seed.amplitude
+  };
+}
+
+// src/view/theme.ts
+var ENTITY_COLORS = {
+  person: { fill: "#D4BFFF", glow: "#B794FF", stroke: "#A78BFA", label: "People" },
+  organization: { fill: "#818CF8", glow: "#6366F1", stroke: "#4F46E5", label: "Organizations" },
+  project: { fill: "#86EFAC", glow: "#4ADE80", stroke: "#22C55E", label: "Deals" },
+  meeting: { fill: "#FDE68A", glow: "#FBBF24", stroke: "#F59E0B", label: "Meetings" },
+  topic: { fill: "#F9A8D4", glow: "#F472B6", stroke: "#EC4899", label: "Topics" },
+  contact: { fill: "#99F6E4", glow: "#5EEAD4", stroke: "#2DD4BF", label: "Contacts" }
+};
+var FALLBACK_ENTITY_COLOR = {
+  fill: "#9CA3AF",
+  glow: "#9CA3AF",
+  stroke: "#6B7280",
+  label: "Other"
+};
+function entityColor(entityType) {
+  return ENTITY_COLORS[entityType] ?? FALLBACK_ENTITY_COLOR;
+}
+var CLASS_ACCENTS = {
+  /** POI — BUFI brand purple (purpleDanis). */
+  poi: "#6954CF",
+  /** Bridge — warm attention amber (agnusDeiDanis family, darkened for contrast). */
+  bridge: "#D9A514"
+};
+var TRACE_ACCENTS = {
+  strongest: "#6954CF",
+  fewest: "#647CE6",
+  endpoints: "#FFADEC"
+};
+var EDGE_TYPE_STYLES = {
+  works_at: { label: "works at" },
+  related_to: { dash: "4 3", label: "related to" },
+  champion_of: { label: "champion of" },
+  decision_maker_for: { label: "decision maker" },
+  owner_of_deal: { label: "deal owner" },
+  called: { dash: "2 3", label: "called" },
+  messaged: { dash: "2 3", label: "messaged" },
+  emailed: { dash: "2 3", label: "emailed" },
+  replied_to: { dash: "2 3", label: "replied" },
+  met_with: { dash: "6 3", label: "met with" },
+  supports: { dash: "4 3", label: "support ticket" },
+  enrolled_in: { dash: "1 3", label: "in campaign" },
+  intro_path: { dash: "8 4", label: "warm intro" },
+  li_connection: { dash: "1 2", label: "LinkedIn connection" }
+};
+function edgeTypeStyle(relationshipType) {
+  return EDGE_TYPE_STYLES[relationshipType] ?? {
+    dash: "4 3",
+    label: relationshipType.replace(/_/g, " ")
+  };
+}
+function nodeRadius(entityType) {
+  switch (entityType) {
+    case "organization":
+      return 16;
+    case "project":
+      return 13;
+    case "person":
+    case "contact":
+      return 12;
+    default:
+      return 10;
+  }
+}
+
+// src/view/view-model.ts
+var MIN_EDGE_OPACITY = 0.08;
+var MAX_EDGE_OPACITY = 0.8;
+function resolveClasses(data, decorations, options = {}) {
+  const poiIds = decorations?.poiIds ? new Set(decorations.poiIds) : computePoiIds(data);
+  let bridgeIds;
+  if (decorations?.bridgeScores) {
+    const topN = options.bridgeTopN ?? 5;
+    bridgeIds = new Set(
+      Object.entries(decorations.bridgeScores).filter(([, score]) => score > 0).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, topN).map(([id]) => id)
+    );
+  } else {
+    bridgeIds = computeBridgeIds(data, { topN: options.bridgeTopN ?? 5, now: options.now ?? 0 });
+  }
+  return { poiIds, bridgeIds };
+}
+function buildNodeVisuals(data, poiIds, bridgeIds, searchQuery) {
+  const query = searchQuery.trim().toLowerCase();
+  return data.entities.map((entity) => {
+    const nodeClass = classifyNode(entity.id, poiIds, bridgeIds);
+    const colors = entityColor(entity.entityType);
+    return {
+      id: entity.id,
+      entityName: entity.entityName,
+      entityType: entity.entityType,
+      nodeClass,
+      radius: nodeRadius(entity.entityType),
+      fill: colors.fill,
+      glow: colors.glow,
+      stroke: colors.stroke,
+      ring: nodeClass === "poi" ? CLASS_ACCENTS.poi : nodeClass === "bridge" ? CLASS_ACCENTS.bridge : null,
+      matched: query.length === 0 || entity.entityName.toLowerCase().includes(query)
+    };
+  });
+}
+function buildEdgeVisuals(data, now) {
+  return data.relationships.map((edge) => {
+    const strength = Math.min(1, Math.max(0, edge.strength ?? 0.5));
+    const recency = recencyFactor(edge.lastSeenAt, now);
+    const style = edgeTypeStyle(edge.relationshipType);
+    const opacity = Math.min(
+      MAX_EDGE_OPACITY,
+      Math.max(MIN_EDGE_OPACITY, (0.15 + strength * 0.55) * recency)
+    );
+    return {
+      id: edge.id,
+      sourceEntityId: edge.sourceEntityId,
+      targetEntityId: edge.targetEntityId,
+      relationshipType: edge.relationshipType,
+      label: style.label,
+      dash: style.dash,
+      springStrength: strength,
+      opacity,
+      evidenceCount: edge.evidenceCount ?? 1
+    };
+  });
+}
+function buildTrace(data, fromId, toId, now) {
+  const strongest = strongestPath(data, fromId, toId, { now });
+  const fewest = fewestHops(data, fromId, toId, { now });
+  const diverges = strongest !== null && fewest !== null && strongest.nodeIds.join("|") !== fewest.nodeIds.join("|");
+  return { fromId, toId, strongest, fewest, diverges };
+}
+function traceEdgeIds(trace) {
+  const strongest = new Set(trace?.strongest?.edgeIds ?? []);
+  const fewest = new Set(trace?.fewest?.edgeIds ?? []);
+  const nodes = /* @__PURE__ */ new Set([...trace?.strongest?.nodeIds ?? [], ...trace?.fewest?.nodeIds ?? []]);
+  return { strongest, fewest, nodes };
+}
+
+// src/view/gtm-graph-view.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var SIM_WIDTH = 1200;
+var SIM_HEIGHT = 800;
+function GtmGraphView({
+  data,
+  decorations,
+  now,
+  maxNodes = 400,
+  bridgeTopN = 5,
+  onEntitySelect,
+  height = 560,
+  dark = false
+}) {
+  const [expanded, setExpanded] = (0, import_react.useState)(false);
+  const [searchQuery, setSearchQuery] = (0, import_react.useState)("");
+  const [traceMode, setTraceMode] = (0, import_react.useState)(false);
+  const [tracePick, setTracePick] = (0, import_react.useState)([]);
+  const [hoveredId, setHoveredId] = (0, import_react.useState)(null);
+  const [pan, setPan] = (0, import_react.useState)({ x: 0, y: 0 });
+  const [zoom, setZoom] = (0, import_react.useState)(0.9);
+  const [motionTick, setMotionTick] = (0, import_react.useState)(0);
+  const containerRef = (0, import_react.useRef)(null);
+  const panningRef = (0, import_react.useRef)(null);
+  const motionTimeRef = (0, import_react.useRef)(0);
+  const nowRef = (0, import_react.useRef)(now ?? Date.now());
+  const effectiveNow = now ?? nowRef.current;
+  const { poiIds, bridgeIds } = (0, import_react.useMemo)(
+    () => resolveClasses(data, decorations, { bridgeTopN, now: effectiveNow }),
+    [data, decorations, bridgeTopN, effectiveNow]
+  );
+  const pinned = (0, import_react.useMemo)(() => /* @__PURE__ */ new Set([...poiIds, ...bridgeIds]), [poiIds, bridgeIds]);
+  const visible = (0, import_react.useMemo)(
+    () => expanded ? data : capGraph(data, maxNodes, pinned),
+    [data, expanded, maxNodes, pinned]
+  );
+  const cappedCount = data.entities.length - visible.entities.length;
+  const nodeVisuals = (0, import_react.useMemo)(
+    () => buildNodeVisuals(visible, poiIds, bridgeIds, searchQuery),
+    [visible, poiIds, bridgeIds, searchQuery]
+  );
+  const edgeVisuals = (0, import_react.useMemo)(
+    () => buildEdgeVisuals(visible, effectiveNow),
+    [visible, effectiveNow]
+  );
+  const nodeById = (0, import_react.useMemo)(() => new Map(nodeVisuals.map((n) => [n.id, n])), [nodeVisuals]);
+  const positions = (0, import_react.useMemo)(() => {
+    const physicsNodes = nodeVisuals.map((n) => ({
+      id: n.id,
+      x: 0,
+      y: 0,
+      vx: 0,
+      vy: 0,
+      radius: n.radius,
+      group: n.entityType
+    }));
+    const physicsEdges = edgeVisuals.map((e) => ({
+      source: e.sourceEntityId,
+      target: e.targetEntityId,
+      strength: e.springStrength
+    }));
+    runSimulation(physicsNodes, physicsEdges, SIM_WIDTH, SIM_HEIGHT);
+    return { map: new Map(physicsNodes.map((n) => [n.id, { x: n.x, y: n.y }])) };
+  }, [nodeVisuals, edgeVisuals]);
+  (0, import_react.useEffect)(() => {
+    let rafId = 0;
+    let last = typeof performance !== "undefined" ? performance.now() : 0;
+    const animate = (time) => {
+      if (time - last >= 48) {
+        motionTimeRef.current += time - last;
+        last = time;
+        setMotionTick((t) => t + 1);
+      }
+      rafId = requestAnimationFrame(animate);
+    };
+    if (typeof requestAnimationFrame !== "undefined") rafId = requestAnimationFrame(animate);
+    return () => {
+      if (rafId && typeof cancelAnimationFrame !== "undefined") cancelAnimationFrame(rafId);
+    };
+  }, []);
+  (0, import_react.useEffect)(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    setPan({ x: el.clientWidth / 2, y: height / 2 });
+  }, [height]);
+  const displayPosition = (0, import_react.useCallback)(
+    (id) => {
+      const base = positions.map.get(id);
+      if (!base) return null;
+      const offset = getFloatingOffset(id, motionTimeRef.current);
+      return { x: base.x + offset.dx, y: base.y + offset.dy };
+    },
+    // motionTick forces recompute as the float clock advances
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [positions, motionTick]
+  );
+  const trace = (0, import_react.useMemo)(() => {
+    if (tracePick.length !== 2) return null;
+    return buildTrace(visible, tracePick[0], tracePick[1], effectiveNow);
+  }, [tracePick, visible, effectiveNow]);
+  const traced = (0, import_react.useMemo)(() => traceEdgeIds(trace), [trace]);
+  const handleNodeClick = (0, import_react.useCallback)(
+    (entityId) => {
+      if (traceMode) {
+        setTracePick((prev) => {
+          if (prev.includes(entityId)) return prev.filter((id) => id !== entityId);
+          if (prev.length >= 2) return [prev[1], entityId];
+          return [...prev, entityId];
+        });
+        return;
+      }
+      onEntitySelect?.(entityId);
+    },
+    [traceMode, onEntitySelect]
+  );
+  const handlePointerDown = (0, import_react.useCallback)(
+    (event) => {
+      if (event.button !== 0) return;
+      event.currentTarget.setPointerCapture(event.pointerId);
+      panningRef.current = {
+        startX: event.clientX,
+        startY: event.clientY,
+        originX: pan.x,
+        originY: pan.y
+      };
+    },
+    [pan]
+  );
+  const handlePointerMove = (0, import_react.useCallback)((event) => {
+    const panning = panningRef.current;
+    if (!panning) return;
+    setPan({
+      x: panning.originX + (event.clientX - panning.startX),
+      y: panning.originY + (event.clientY - panning.startY)
+    });
+  }, []);
+  const handlePointerUp = (0, import_react.useCallback)(() => {
+    panningRef.current = null;
+  }, []);
+  const handleWheel = (0, import_react.useCallback)((event) => {
+    const factor = Math.exp(-event.deltaY * 22e-4);
+    setZoom((z) => Math.min(2.5, Math.max(0.25, z * factor)));
+  }, []);
+  const bg = dark ? "#0b1020" : "#fbfaff";
+  const text = dark ? "#c6bbff" : "#333336";
+  const subText = dark ? "#8f86c4" : "#87839c";
+  const panelBg = dark ? "rgba(15,20,45,0.9)" : "rgba(255,255,255,0.92)";
+  const panelBorder = dark ? "rgba(130,140,255,0.25)" : "#e2d0fd";
+  const hovered = hoveredId ? nodeById.get(hoveredId) : null;
+  const legendTypes = (0, import_react.useMemo)(() => {
+    const present = new Set(nodeVisuals.map((n) => n.entityType));
+    return Object.entries(ENTITY_COLORS).filter(([type]) => present.has(type));
+  }, [nodeVisuals]);
+  const traceChain = (path) => {
+    if (!path) return "no path";
+    return path.nodeIds.map((id, i) => {
+      const name = nodeById.get(id)?.entityName ?? id.slice(0, 6);
+      if (i === path.nodeIds.length - 1) return name;
+      const edge = edgeVisuals.find((e) => e.id === path.edgeIds[i]);
+      return `${name} \u2014${edge ? `${edge.label} \xD7${edge.evidenceCount}` : "?"}\u2192 `;
+    }).join("");
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "div",
+    {
+      ref: containerRef,
+      style: {
+        position: "relative",
+        width: "100%",
+        height,
+        overflow: "hidden",
+        borderRadius: 12,
+        border: `1px solid ${panelBorder}`,
+        background: bg,
+        fontFamily: "Poppins, ui-sans-serif, system-ui, sans-serif",
+        color: text
+      },
+      "data-testid": "gtm-graph-view",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: 10,
+              left: 10,
+              zIndex: 20,
+              display: "flex",
+              gap: 8,
+              alignItems: "center"
+            },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "input",
+                {
+                  value: searchQuery,
+                  onChange: (e) => setSearchQuery(e.target.value),
+                  placeholder: "Search entities\u2026",
+                  "aria-label": "Search entities",
+                  style: {
+                    padding: "6px 10px",
+                    fontSize: 12,
+                    borderRadius: 8,
+                    border: `1px solid ${panelBorder}`,
+                    background: panelBg,
+                    color: text,
+                    outline: "none",
+                    width: 180
+                  }
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => {
+                    setTraceMode((m) => !m);
+                    setTracePick([]);
+                  },
+                  style: {
+                    padding: "6px 10px",
+                    fontSize: 12,
+                    borderRadius: 8,
+                    cursor: "pointer",
+                    border: `1px solid ${traceMode ? CLASS_ACCENTS.poi : panelBorder}`,
+                    background: traceMode ? CLASS_ACCENTS.poi : panelBg,
+                    color: traceMode ? "#fff" : text
+                  },
+                  children: traceMode ? `Trace: pick ${2 - Math.min(tracePick.length, 2)} node${tracePick.length === 1 ? "" : "s"}` : "Trace warm path"
+                }
+              ),
+              !expanded && cappedCount > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => setExpanded(true),
+                  style: {
+                    padding: "6px 10px",
+                    fontSize: 12,
+                    borderRadius: 8,
+                    cursor: "pointer",
+                    border: `1px solid ${panelBorder}`,
+                    background: panelBg,
+                    color: text
+                  },
+                  children: [
+                    "Expand +",
+                    cappedCount,
+                    " nodes"
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "svg",
+          {
+            width: "100%",
+            height: "100%",
+            style: { touchAction: "none", cursor: panningRef.current ? "grabbing" : "grab" },
+            onPointerDown: handlePointerDown,
+            onPointerMove: handlePointerMove,
+            onPointerUp: handlePointerUp,
+            onWheel: handleWheel,
+            role: "img",
+            "aria-label": "GTM graph",
+            children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("g", { transform: `translate(${pan.x} ${pan.y}) scale(${zoom})`, children: [
+              edgeVisuals.map((edge) => {
+                const source = displayPosition(edge.sourceEntityId);
+                const target = displayPosition(edge.targetEntityId);
+                if (!source || !target) return null;
+                const onStrongest = traced.strongest.has(edge.id);
+                const onFewest = traced.fewest.has(edge.id);
+                const isTraced = onStrongest || onFewest;
+                const dimmedByTrace = trace !== null && !isTraced;
+                const srcColor = nodeById.get(edge.sourceEntityId)?.stroke ?? "#818CF8";
+                const strokeColor = onStrongest ? TRACE_ACCENTS.strongest : onFewest ? TRACE_ACCENTS.fewest : srcColor;
+                const opacity = dimmedByTrace ? 0.04 : isTraced ? 0.95 : edge.opacity;
+                const width = isTraced ? 2.4 : 0.6 + edge.springStrength * 1.2;
+                return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "line",
+                  {
+                    x1: source.x,
+                    y1: source.y,
+                    x2: target.x,
+                    y2: target.y,
+                    stroke: strokeColor,
+                    strokeOpacity: opacity,
+                    strokeWidth: width,
+                    strokeLinecap: "round",
+                    strokeDasharray: isTraced ? void 0 : edge.dash,
+                    "data-testid": `gtm-edge-${edge.id}`,
+                    "data-traced": isTraced ? onStrongest ? "strongest" : "fewest" : void 0
+                  },
+                  edge.id
+                );
+              }),
+              nodeVisuals.map((node) => {
+                const pos = displayPosition(node.id);
+                if (!pos) return null;
+                const isHovered = hoveredId === node.id;
+                const isPicked = tracePick.includes(node.id);
+                const onTracePath = traced.nodes.has(node.id);
+                let opacity = node.matched ? 1 : 0.12;
+                if (trace !== null) opacity = onTracePath || isPicked ? 1 : 0.15;
+                return (
+                  // biome-ignore lint/a11y/useKeyWithClickEvents: canvas nodes; hosts provide accessible detail UI via onEntitySelect
+                  /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+                    "g",
+                    {
+                      transform: `translate(${pos.x}, ${pos.y})`,
+                      opacity,
+                      style: { cursor: "pointer", transition: "opacity 0.25s" },
+                      onClick: () => handleNodeClick(node.id),
+                      onPointerEnter: () => setHoveredId(node.id),
+                      onPointerLeave: () => setHoveredId(null),
+                      "data-testid": `gtm-node-${node.id}`,
+                      "data-node-class": node.nodeClass,
+                      children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("circle", { r: node.radius + 7, fill: node.glow, opacity: isHovered ? 0.35 : 0.12 }),
+                        node.ring && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                          "circle",
+                          {
+                            r: node.radius + 3.5,
+                            fill: "none",
+                            stroke: node.ring,
+                            strokeWidth: 2,
+                            strokeDasharray: node.nodeClass === "bridge" ? "3 2" : void 0
+                          }
+                        ),
+                        isPicked && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                          "circle",
+                          {
+                            r: node.radius + 7.5,
+                            fill: "none",
+                            stroke: TRACE_ACCENTS.endpoints,
+                            strokeWidth: 2.5
+                          }
+                        ),
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                          "circle",
+                          {
+                            r: node.radius,
+                            fill: node.fill,
+                            stroke: isHovered ? "#fff" : node.stroke,
+                            strokeWidth: isHovered ? 2 : 0.8
+                          }
+                        ),
+                        (isHovered || node.nodeClass !== "other" || zoom > 1.3) && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                          "text",
+                          {
+                            y: node.radius + 14,
+                            textAnchor: "middle",
+                            style: {
+                              fontSize: 10,
+                              fill: subText,
+                              pointerEvents: "none",
+                              userSelect: "none"
+                            },
+                            children: node.entityName.length > 24 ? `${node.entityName.slice(0, 23)}\u2026` : node.entityName
+                          }
+                        )
+                      ]
+                    },
+                    node.id
+                  )
+                );
+              })
+            ] })
+          }
+        ),
+        hovered && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              bottom: 12,
+              left: 12,
+              zIndex: 20,
+              padding: "8px 12px",
+              borderRadius: 10,
+              border: `1px solid ${panelBorder}`,
+              background: panelBg,
+              fontSize: 12,
+              maxWidth: 280,
+              pointerEvents: "none"
+            },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { fontWeight: 600 }, children: hovered.entityName }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { color: subText }, children: [
+                hovered.entityType,
+                hovered.nodeClass !== "other" && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { style: { color: hovered.ring ?? text, fontWeight: 600 }, children: [
+                  " ",
+                  "\xB7 ",
+                  hovered.nodeClass === "poi" ? "person of interest" : "bridge"
+                ] })
+              ] })
+            ]
+          }
+        ),
+        trace && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          "div",
+          {
+            "data-testid": "gtm-trace-panel",
+            style: {
+              position: "absolute",
+              bottom: 12,
+              right: 12,
+              zIndex: 20,
+              padding: "10px 12px",
+              borderRadius: 10,
+              border: `1px solid ${panelBorder}`,
+              background: panelBg,
+              fontSize: 11,
+              maxWidth: 380
+            },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { fontWeight: 600, marginBottom: 4 }, children: [
+                "Warm path ",
+                trace.diverges ? "(strongest \u2260 fewest)" : ""
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { color: TRACE_ACCENTS.strongest, marginBottom: 2 }, children: [
+                "Strongest: ",
+                traceChain(trace.strongest)
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { color: TRACE_ACCENTS.fewest }, children: [
+                "Fewest hops: ",
+                traceChain(trace.fewest)
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          "div",
+          {
+            "data-testid": "gtm-legend",
+            style: {
+              position: "absolute",
+              top: 10,
+              right: 10,
+              zIndex: 20,
+              padding: "8px 12px",
+              borderRadius: 10,
+              border: `1px solid ${panelBorder}`,
+              background: panelBg,
+              fontSize: 11,
+              display: "flex",
+              flexDirection: "column",
+              gap: 4
+            },
+            children: [
+              legendTypes.map(([type, color]) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "span",
+                  {
+                    style: {
+                      width: 9,
+                      height: 9,
+                      borderRadius: "50%",
+                      background: color.fill,
+                      border: `1px solid ${color.stroke}`
+                    }
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { color: subText }, children: color.label })
+              ] }, type)),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "span",
+                  {
+                    style: {
+                      width: 9,
+                      height: 9,
+                      borderRadius: "50%",
+                      border: `2px solid ${CLASS_ACCENTS.poi}`
+                    }
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { color: subText }, children: "Person of interest" })
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "span",
+                  {
+                    style: {
+                      width: 9,
+                      height: 9,
+                      borderRadius: "50%",
+                      border: `2px dashed ${CLASS_ACCENTS.bridge}`
+                    }
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { color: subText }, children: "Bridge" })
+              ] })
+            ]
+          }
+        ),
+        visible.entities.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              inset: 0,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              color: subText,
+              fontSize: 13
+            },
+            children: "No GTM entities yet \u2014 the graph fills as the sync ingests leads, deals, and activities."
+          }
+        )
+      ]
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLASS_ACCENTS,
+  EDGE_TYPE_STYLES,
+  ENTITY_COLORS,
+  FALLBACK_ENTITY_COLOR,
+  GtmGraphView,
+  TRACE_ACCENTS,
+  buildEdgeVisuals,
+  buildNodeVisuals,
+  buildTrace,
+  edgeTypeStyle,
+  entityColor,
+  nodeRadius,
+  resolveClasses,
+  traceEdgeIds
+});
+//# sourceMappingURL=index.cjs.map