@syntrologie/runtime-sdk 2.8.0-canary.23 → 2.8.0-canary.24

package/dist/{chunk-M3BRHRCI.js → chunk-UJFBG2NR.js}

@@ -3439,7 +3439,7 @@ function getAntiFlickerSnippet(config = {}) {
 }
 
 // src/version.ts
-var SDK_VERSION = "2.8.0-canary.23";
+var SDK_VERSION = "2.8.0-canary.24";
 
 // src/types.ts
 var SDK_SCHEMA_VERSION = "2.0";
@@ -3816,9 +3816,529 @@ function useShadowRoot() {
   return ctx;
 }
 
-// src/events/types.ts
-import { EVENT_SCHEMA_VERSION } from "@syntrologie/event-processor";
+// ../event-processor/dist/types.js
+var EVENT_SCHEMA_VERSION = "1.0.0";
 var StandardEvents = {
+  UI_CLICK: "ui.click",
+  UI_SCROLL: "ui.scroll",
+  UI_INPUT: "ui.input",
+  UI_CHANGE: "ui.change",
+  UI_SUBMIT: "ui.submit",
+  NAV_PAGE_VIEW: "nav.page_view",
+  NAV_PAGE_LEAVE: "nav.page_leave",
+  UI_HESITATE: "ui.hesitate",
+  UI_RAGE_CLICK: "ui.rage_click",
+  UI_SCROLL_THRASH: "ui.scroll_thrash",
+  UI_FOCUS_BOUNCE: "ui.focus_bounce",
+  UI_IDLE: "ui.idle",
+  UI_HOVER: "ui.hover"
+};
+var RRWebSource = {
+  Mutation: 0,
+  MouseMove: 1,
+  MouseInteraction: 2,
+  Scroll: 3,
+  ViewportResize: 4,
+  Input: 5,
+  TouchMove: 6,
+  MediaInteraction: 7,
+  Drag: 12
+};
+var RRWebMouseInteraction = {
+  MouseUp: 0,
+  MouseDown: 1,
+  Click: 2,
+  ContextMenu: 3,
+  DblClick: 4,
+  Focus: 5,
+  Blur: 6,
+  TouchStart: 7,
+  TouchEnd: 9
+};
+var DEFAULT_DETECTOR_CONFIG = {
+  hesitationMs: 3e3,
+  hesitationRadiusPx: 10,
+  rageClickCount: 3,
+  rageClickWindowMs: 1e3,
+  rageClickRadiusPx: 30,
+  scrollThrashReversals: 3,
+  scrollThrashWindowMs: 2e3,
+  focusBounceMaxInputs: 0,
+  idleMs: 5e3,
+  hoverSampleMs: 100
+};
+
+// ../event-processor/dist/normalizers/posthog.js
+var POSTHOG_EVENT_MAP = {
+  // NOTE: $autocapture is intentionally NOT in this map.
+  // It's handled below in getEventName() with $event_type refinement
+  // so that change/submit events aren't all mapped to ui.click.
+  $click: StandardEvents.UI_CLICK,
+  $scroll: StandardEvents.UI_SCROLL,
+  $input: StandardEvents.UI_INPUT,
+  $change: StandardEvents.UI_CHANGE,
+  $submit: StandardEvents.UI_SUBMIT,
+  // Navigation events
+  $pageview: StandardEvents.NAV_PAGE_VIEW,
+  $pageleave: StandardEvents.NAV_PAGE_LEAVE,
+  // Session events
+  $session_start: "session.start",
+  // Identify events
+  $identify: "user.identify"
+};
+function getEventName(phEvent) {
+  var _a2, _b;
+  const eventName = phEvent.event;
+  if (typeof eventName !== "string") {
+    return "posthog.unknown";
+  }
+  if (POSTHOG_EVENT_MAP[eventName]) {
+    return POSTHOG_EVENT_MAP[eventName];
+  }
+  if (eventName === "$autocapture") {
+    const tagName = (_a2 = phEvent.properties) == null ? void 0 : _a2.$tag_name;
+    const eventType = (_b = phEvent.properties) == null ? void 0 : _b.$event_type;
+    if (eventType === "submit")
+      return StandardEvents.UI_SUBMIT;
+    if (eventType === "change")
+      return StandardEvents.UI_CHANGE;
+    if (tagName === "input" || tagName === "textarea")
+      return StandardEvents.UI_INPUT;
+    return StandardEvents.UI_CLICK;
+  }
+  if (!eventName.startsWith("$")) {
+    return `posthog.${eventName}`;
+  }
+  return eventName.replace("$", "posthog.");
+}
+var INTERACTIVE_TAGS = /* @__PURE__ */ new Set(["a", "button", "input", "select", "textarea"]);
+function resolveInteractiveTag(elements, directTag) {
+  if (directTag && INTERACTIVE_TAGS.has(directTag))
+    return directTag;
+  if (!elements)
+    return directTag;
+  for (const el of elements) {
+    const tag2 = el.tag_name;
+    if (tag2 && INTERACTIVE_TAGS.has(tag2))
+      return tag2;
+  }
+  return directTag;
+}
+function extractProps(phEvent) {
+  var _a2, _b;
+  const props = {};
+  const phProps = phEvent.properties || {};
+  const elements = phProps.$elements;
+  const directTag = (_b = phProps.$tag_name) != null ? _b : (_a2 = elements == null ? void 0 : elements[0]) == null ? void 0 : _a2.tag_name;
+  const isClickEvent = phEvent.event === "$autocapture" || phEvent.event === "$click";
+  props.tagName = isClickEvent ? resolveInteractiveTag(elements, directTag) : directTag;
+  if (phProps.$el_text)
+    props.elementText = phProps.$el_text;
+  if (elements)
+    props.elements = elements;
+  if (phProps.$current_url)
+    props.url = phProps.$current_url;
+  if (phProps.$pathname)
+    props.pathname = phProps.$pathname;
+  if (phProps.$host)
+    props.host = phProps.$host;
+  if (phProps.$viewport_width)
+    props.viewportWidth = phProps.$viewport_width;
+  if (phProps.$viewport_height)
+    props.viewportHeight = phProps.$viewport_height;
+  if (phProps.$session_id)
+    props.sessionId = phProps.$session_id;
+  if (phProps.$scroll_depth)
+    props.scrollDepth = phProps.$scroll_depth;
+  if (phProps.$scroll_percentage)
+    props.scrollPercentage = phProps.$scroll_percentage;
+  props.originalEvent = phEvent.event;
+  return props;
+}
+function normalizePostHogEvent(phEvent) {
+  let ts;
+  if (typeof phEvent.timestamp === "number") {
+    ts = phEvent.timestamp;
+  } else if (typeof phEvent.timestamp === "string") {
+    ts = new Date(phEvent.timestamp).getTime();
+  } else {
+    ts = Date.now();
+  }
+  return {
+    ts,
+    name: getEventName(phEvent),
+    source: "posthog",
+    props: extractProps(phEvent),
+    schemaVersion: EVENT_SCHEMA_VERSION
+  };
+}
+function shouldNormalizeEvent(phEvent) {
+  const eventName = phEvent.event;
+  if (typeof eventName !== "string")
+    return false;
+  const skipEvents = [
+    "$feature_flag_called",
+    "$feature_flags",
+    "$groups",
+    "$groupidentify",
+    "$set",
+    "$set_once",
+    "$unset",
+    "$create_alias",
+    "$capture_metrics",
+    "$performance_event",
+    "$web_vitals",
+    "$exception",
+    "$dead_click",
+    "$heatmap"
+  ];
+  if (skipEvents.includes(eventName)) {
+    return false;
+  }
+  return true;
+}
+function createPostHogNormalizer(publishFn) {
+  return (eventName, properties) => {
+    if (typeof eventName !== "string")
+      return;
+    const phEvent = {
+      event: eventName,
+      properties,
+      timestamp: Date.now()
+    };
+    if (shouldNormalizeEvent(phEvent)) {
+      const normalizedEvent = normalizePostHogEvent(phEvent);
+      publishFn(normalizedEvent);
+    }
+  };
+}
+
+// ../event-processor/dist/detectors/focus-bounce.js
+var FocusBounceDetector = class {
+  constructor(config, emit) {
+    this.config = config;
+    this.emit = emit;
+    this.focused = /* @__PURE__ */ new Map();
+  }
+  ingest(raw) {
+    var _a2, _b;
+    if (raw.type !== 3)
+      return;
+    const ts = raw.timestamp;
+    if (raw.data.source === RRWebSource.MouseInteraction) {
+      const id = (_a2 = raw.data.id) != null ? _a2 : 0;
+      if (raw.data.type === RRWebMouseInteraction.Focus) {
+        this.focused.set(id, { id, focusTs: ts, inputCount: 0 });
+      } else if (raw.data.type === RRWebMouseInteraction.Blur) {
+        const entry = this.focused.get(id);
+        if (entry && entry.inputCount <= this.config.focusBounceMaxInputs) {
+          this.emit({
+            ts,
+            name: StandardEvents.UI_FOCUS_BOUNCE,
+            source: "rrweb",
+            schemaVersion: EVENT_SCHEMA_VERSION,
+            props: {
+              elementId: id,
+              duration_ms: ts - entry.focusTs
+            }
+          });
+        }
+        this.focused.delete(id);
+      }
+    } else if (raw.data.source === RRWebSource.Input) {
+      const id = (_b = raw.data.id) != null ? _b : 0;
+      const entry = this.focused.get(id);
+      if (entry) {
+        entry.inputCount++;
+      }
+    }
+  }
+};
+
+// ../event-processor/dist/detectors/hesitation.js
+var HesitationDetector = class {
+  constructor(config, emit) {
+    this.config = config;
+    this.emit = emit;
+    this.anchorX = 0;
+    this.anchorY = 0;
+    this.anchorTs = 0;
+    this.emitted = false;
+    this.hasPosition = false;
+  }
+  ingest(raw) {
+    var _a2;
+    if (raw.type !== 3 || raw.data.source !== RRWebSource.MouseMove)
+      return;
+    const positions = raw.data.positions;
+    if (!positions || positions.length === 0)
+      return;
+    const last = positions[positions.length - 1];
+    const ts = raw.timestamp + ((_a2 = last.timeOffset) != null ? _a2 : 0);
+    if (!this.hasPosition) {
+      this.anchorX = last.x;
+      this.anchorY = last.y;
+      this.anchorTs = ts;
+      this.hasPosition = true;
+      this.emitted = false;
+      return;
+    }
+    const dx = last.x - this.anchorX;
+    const dy = last.y - this.anchorY;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    if (dist > this.config.hesitationRadiusPx) {
+      this.anchorX = last.x;
+      this.anchorY = last.y;
+      this.anchorTs = ts;
+      this.emitted = false;
+    }
+  }
+  tick(now) {
+    if (!this.hasPosition || this.emitted)
+      return;
+    const elapsed = now - this.anchorTs;
+    if (elapsed >= this.config.hesitationMs) {
+      this.emit({
+        ts: now,
+        name: StandardEvents.UI_HESITATE,
+        source: "rrweb",
+        schemaVersion: EVENT_SCHEMA_VERSION,
+        props: {
+          x: this.anchorX,
+          y: this.anchorY,
+          duration_ms: elapsed
+        }
+      });
+      this.emitted = true;
+    }
+  }
+};
+
+// ../event-processor/dist/detectors/hover.js
+var HoverTracker = class {
+  constructor(config, emit, elementResolver) {
+    this.config = config;
+    this.emit = emit;
+    this.elementResolver = elementResolver;
+    this.currentElement = null;
+    this.hoverStartTs = null;
+    this.lastX = 0;
+    this.lastY = 0;
+    this.lastSampleTs = -Infinity;
+  }
+  ingest(raw) {
+    if (raw.type !== 3 || raw.data.source !== RRWebSource.MouseMove)
+      return;
+    const positions = raw.data.positions;
+    if (!positions || positions.length === 0)
+      return;
+    const last = positions[positions.length - 1];
+    this.lastX = last.x;
+    this.lastY = last.y;
+  }
+  tick(now) {
+    if (!this.elementResolver)
+      return;
+    if (now - this.lastSampleTs < this.config.hoverSampleMs)
+      return;
+    this.lastSampleTs = now;
+    const newElement = this.elementResolver(this.lastX, this.lastY);
+    const newKey = newElement ? elementKey(newElement) : null;
+    const currentKey = this.currentElement ? elementKey(this.currentElement) : null;
+    if (newKey !== currentKey) {
+      if (this.currentElement && this.hoverStartTs !== null) {
+        this.emit({
+          ts: now,
+          name: StandardEvents.UI_HOVER,
+          source: "rrweb",
+          schemaVersion: EVENT_SCHEMA_VERSION,
+          props: {
+            x: this.lastX,
+            y: this.lastY,
+            duration_ms: now - this.hoverStartTs,
+            element: this.currentElement
+          }
+        });
+      }
+      this.currentElement = newElement;
+      this.hoverStartTs = now;
+    }
+  }
+};
+function elementKey(el) {
+  var _a2, _b, _c;
+  return `${(_a2 = el.tag_name) != null ? _a2 : ""}|${(_b = el.attr__id) != null ? _b : ""}|${((_c = el.classes) != null ? _c : []).join(",")}`;
+}
+
+// ../event-processor/dist/detectors/idle.js
+var IdleDetector = class {
+  constructor(config, emit) {
+    this.config = config;
+    this.emit = emit;
+    this.lastActivityTs = null;
+    this.emitted = false;
+  }
+  ingest(raw) {
+    if (raw.type !== 3)
+      return;
+    const src = raw.data.source;
+    if (src === RRWebSource.MouseMove || src === RRWebSource.MouseInteraction || src === RRWebSource.Scroll) {
+      this.lastActivityTs = raw.timestamp;
+      this.emitted = false;
+    }
+  }
+  tick(now) {
+    if (this.lastActivityTs === null || this.emitted)
+      return;
+    if (now - this.lastActivityTs >= this.config.idleMs) {
+      this.emit({
+        ts: now,
+        name: StandardEvents.UI_IDLE,
+        source: "rrweb",
+        schemaVersion: EVENT_SCHEMA_VERSION,
+        props: {
+          idle_ms: now - this.lastActivityTs
+        }
+      });
+      this.emitted = true;
+    }
+  }
+};
+
+// ../event-processor/dist/detectors/rage-click.js
+var RageClickDetector = class {
+  constructor(config, emit) {
+    this.config = config;
+    this.emit = emit;
+    this.clicks = [];
+  }
+  ingest(raw) {
+    var _a2, _b;
+    if (raw.type !== 3 || raw.data.source !== RRWebSource.MouseInteraction)
+      return;
+    if (raw.data.type !== RRWebMouseInteraction.Click)
+      return;
+    const x = (_a2 = raw.data.x) != null ? _a2 : 0;
+    const y = (_b = raw.data.y) != null ? _b : 0;
+    const ts = raw.timestamp;
+    const cutoff = ts - this.config.rageClickWindowMs;
+    this.clicks = this.clicks.filter((c) => c.ts >= cutoff);
+    this.clicks.push({ ts, x, y });
+    const nearby = this.clicks.filter((c) => {
+      const dx = c.x - x;
+      const dy = c.y - y;
+      return Math.sqrt(dx * dx + dy * dy) <= this.config.rageClickRadiusPx;
+    });
+    if (nearby.length >= this.config.rageClickCount) {
+      this.emit({
+        ts,
+        name: StandardEvents.UI_RAGE_CLICK,
+        source: "rrweb",
+        schemaVersion: EVENT_SCHEMA_VERSION,
+        props: {
+          x,
+          y,
+          clickCount: nearby.length,
+          duration_ms: ts - nearby[0].ts
+        }
+      });
+      this.clicks = [];
+    }
+  }
+};
+
+// ../event-processor/dist/detectors/scroll-thrash.js
+var ScrollThrashDetector = class {
+  constructor(config, emit) {
+    this.config = config;
+    this.emit = emit;
+    this.lastY = null;
+    this.lastDirection = null;
+    this.reversals = [];
+  }
+  ingest(raw) {
+    var _a2;
+    if (raw.type !== 3 || raw.data.source !== RRWebSource.Scroll)
+      return;
+    const y = (_a2 = raw.data.y) != null ? _a2 : 0;
+    const ts = raw.timestamp;
+    if (this.lastY !== null) {
+      const direction = y > this.lastY ? "down" : y < this.lastY ? "up" : this.lastDirection;
+      if (direction && direction !== this.lastDirection) {
+        const cutoff = ts - this.config.scrollThrashWindowMs;
+        this.reversals = this.reversals.filter((t) => t > cutoff);
+        this.reversals.push(ts);
+        if (this.reversals.length >= this.config.scrollThrashReversals) {
+          this.emit({
+            ts,
+            name: StandardEvents.UI_SCROLL_THRASH,
+            source: "rrweb",
+            schemaVersion: EVENT_SCHEMA_VERSION,
+            props: {
+              reversals: this.reversals.length,
+              duration_ms: ts - this.reversals[0]
+            }
+          });
+          this.reversals = [];
+        }
+      }
+      this.lastDirection = direction;
+    }
+    this.lastY = y;
+  }
+};
+
+// ../event-processor/dist/processor.js
+function createEventProcessor(options) {
+  const config = { ...DEFAULT_DETECTOR_CONFIG, ...options == null ? void 0 : options.config };
+  const listeners = [];
+  function emit(event) {
+    for (const cb of listeners)
+      cb(event);
+  }
+  const hesitation = new HesitationDetector(config, emit);
+  const rageClick = new RageClickDetector(config, emit);
+  const scrollThrash = new ScrollThrashDetector(config, emit);
+  const focusBounce = new FocusBounceDetector(config, emit);
+  const idle = new IdleDetector(config, emit);
+  const hover = new HoverTracker(config, emit, options == null ? void 0 : options.elementResolver);
+  const clickAttrBuffer = [];
+  return {
+    ingest(raw) {
+      if (raw.kind === "posthog") {
+        const { kind: _, ...phEvent } = raw;
+        if (shouldNormalizeEvent(phEvent)) {
+          emit(normalizePostHogEvent(phEvent));
+        }
+      } else if (raw.kind === "rrweb") {
+        hesitation.ingest(raw);
+        rageClick.ingest(raw);
+        scrollThrash.ingest(raw);
+        focusBounce.ingest(raw);
+        idle.ingest(raw);
+        hover.ingest(raw);
+      }
+    },
+    onEvent(callback) {
+      listeners.push(callback);
+    },
+    tick(timestamp) {
+      hesitation.tick(timestamp);
+      idle.tick(timestamp);
+      hover.tick(timestamp);
+    },
+    enrichClickAttributes(timestamp, elements) {
+      clickAttrBuffer.push({ ts: timestamp, elements });
+      const cutoff = timestamp - 500;
+      while (clickAttrBuffer.length > 0 && clickAttrBuffer[0].ts < cutoff) {
+        clickAttrBuffer.shift();
+      }
+    }
+  };
+}
+
+// src/events/types.ts
+var StandardEvents2 = {
   // UI events (from PostHog autocapture)
   UI_CLICK: "ui.click",
   UI_SCROLL: "ui.scroll",
@@ -3870,48 +4390,48 @@ function createCanvasEvent(name, props) {
   };
 }
 function canvasOpened(surface) {
-  return createCanvasEvent(StandardEvents.CANVAS_OPENED, { surface });
+  return createCanvasEvent(StandardEvents2.CANVAS_OPENED, { surface });
 }
 function canvasClosed(surface) {
-  return createCanvasEvent(StandardEvents.CANVAS_CLOSED, { surface });
+  return createCanvasEvent(StandardEvents2.CANVAS_CLOSED, { surface });
 }
 function tileViewed(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_VIEWED, { tileId, surface });
+  return createCanvasEvent(StandardEvents2.TILE_VIEWED, { tileId, surface });
 }
 function tileExpanded(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_EXPANDED, { tileId, surface });
+  return createCanvasEvent(StandardEvents2.TILE_EXPANDED, { tileId, surface });
 }
 function tileCollapsed(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_COLLAPSED, { tileId, surface });
+  return createCanvasEvent(StandardEvents2.TILE_COLLAPSED, { tileId, surface });
 }
 function tileAction(tileId, actionId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_ACTION, {
+  return createCanvasEvent(StandardEvents2.TILE_ACTION, {
     tileId,
     actionId,
     surface
   });
 }
 function overlayStarted(recipeId, recipeName) {
-  return createCanvasEvent(StandardEvents.OVERLAY_STARTED, {
+  return createCanvasEvent(StandardEvents2.OVERLAY_STARTED, {
     recipeId,
     recipeName
   });
 }
 function overlayCompleted(recipeId, recipeName) {
-  return createCanvasEvent(StandardEvents.OVERLAY_COMPLETED, {
+  return createCanvasEvent(StandardEvents2.OVERLAY_COMPLETED, {
     recipeId,
     recipeName
   });
 }
 function overlayDismissed(recipeId, recipeName, stepIndex) {
-  return createCanvasEvent(StandardEvents.OVERLAY_DISMISSED, {
+  return createCanvasEvent(StandardEvents2.OVERLAY_DISMISSED, {
     recipeId,
     recipeName,
     stepIndex
   });
 }
 function overlayStepViewed(recipeId, stepIndex, stepTitle) {
-  return createCanvasEvent(StandardEvents.OVERLAY_STEP_VIEWED, {
+  return createCanvasEvent(StandardEvents2.OVERLAY_STEP_VIEWED, {
     recipeId,
     stepIndex,
     stepTitle
@@ -4237,7 +4757,7 @@ function useNotifications(eventBus, tiles) {
   const timerIds = useRef2(/* @__PURE__ */ new Map());
   const publishDismissed = useCallback2(
     (notif) => {
-      eventBus == null ? void 0 : eventBus.publish(StandardEvents.NOTIFICATION_DISMISSED, {
+      eventBus == null ? void 0 : eventBus.publish(StandardEvents2.NOTIFICATION_DISMISSED, {
         notificationId: notif.id,
         tileId: notif.tileId,
         itemId: notif.itemId
@@ -4302,7 +4822,7 @@ function useNotifications(eventBus, tiles) {
         }
         return next;
       });
-      eventBus.publish(StandardEvents.NOTIFICATION_SHOWN, {
+      eventBus.publish(StandardEvents2.NOTIFICATION_SHOWN, {
         notificationId: matched.id,
         tileId: matched.tileId,
         itemId: matched.itemId,
@@ -5136,7 +5656,7 @@ function ShadowCanvasOverlay({
   const handleNotificationClick = useCallback4(
     (notif) => {
       if (runtime3) {
-        runtime3.events.publish(StandardEvents.NOTIFICATION_CLICKED, {
+        runtime3.events.publish(StandardEvents2.NOTIFICATION_CLICKED, {
           notificationId: notif.id,
           tileId: notif.tileId,
           itemId: notif.itemId
@@ -5146,7 +5666,7 @@ function ShadowCanvasOverlay({
         onToggle();
       }
       if (runtime3 && notif.tileId) {
-        runtime3.events.publish(StandardEvents.NOTIFICATION_DEEP_LINK, {
+        runtime3.events.publish(StandardEvents2.NOTIFICATION_DEEP_LINK, {
           tileId: notif.tileId,
           itemId: notif.itemId
         });
@@ -10654,9 +11174,6 @@ function encodeToken(payload) {
   return TOKEN_PREFIX + base64;
 }
 
-// src/bootstrap.ts
-import { createEventProcessor } from "@syntrologie/event-processor";
-
 // src/experiments/registry.ts
 var adapters = {
   growthbook: (config) => createGrowthBookClient({
@@ -11369,8 +11886,11 @@ export {
   createSmartCanvasController,
   ShadowRootProvider,
   useShadowRoot,
-  StandardEvents,
   EVENT_SCHEMA_VERSION,
+  normalizePostHogEvent,
+  shouldNormalizeEvent,
+  createPostHogNormalizer,
+  StandardEvents2 as StandardEvents,
   CanvasEvents,
   NotificationToastStack,
   MAX_VISIBLE_TOASTS,
@@ -11444,4 +11964,4 @@ export {
   encodeToken,
   Syntro
 };
-//# sourceMappingURL=chunk-M3BRHRCI.js.map
+//# sourceMappingURL=chunk-UJFBG2NR.js.map