@syntrologie/runtime-sdk 2.8.0-canary.8 → 2.8.0-canary.80

package/dist/{chunk-OB5AKUQT.js → chunk-EELCEGS7.js}

@@ -3,7 +3,7 @@ import {
   __privateGet,
   __privateSet,
   __publicField
-} from "./chunk-BU4Z6PD7.js";
+} from "./chunk-YLLWLUQX.js";
 
 // ../adaptives/adaptive-content/dist/reconciliation-guard.js
 function guardAgainstReconciliation(container, anchor, reinsertFn, opts) {
@@ -34,6 +34,11 @@ function guardAgainstReconciliation(container, anchor, reinsertFn, opts) {
         debounceTimer = setTimeout(() => {
           if (disconnected)
             return;
+          if (!anchor.isConnected) {
+            observer.disconnect();
+            disconnected = true;
+            return;
+          }
           retries++;
           try {
             reinsertFn();
@@ -75,7 +80,16 @@ var ALLOWED_TAGS = /* @__PURE__ */ new Set([
   "sup",
   "sub",
   "a",
-  "button"
+  "button",
+  // SVG elements (for inline Lucide icons in config HTML)
+  "svg",
+  "path",
+  "circle",
+  "line",
+  "polyline",
+  "polygon",
+  "rect",
+  "g"
 ]);
 function sanitizeHtml(html) {
   var _a2;
@@ -113,6 +127,12 @@ function sanitizeHtml(html) {
       }
     }
   }
+  const svgs = Array.from(root.querySelectorAll("svg"));
+  for (const svg of svgs) {
+    if (toRemove.some((el) => svg.contains(el) && el.tagName.toLowerCase() === "script")) {
+      toRemove.push(svg);
+    }
+  }
   for (const el of toRemove) {
     while (el.firstChild) {
       (_a2 = el.parentNode) == null ? void 0 : _a2.insertBefore(el.firstChild, el);
@@ -213,15 +233,20 @@ var executeInsertHtml = async (action, context) => {
         container.removeEventListener("click", deepLinkHandler);
       }
       guardCleanup();
-      if (action.position === "replace" && originalContent !== null) {
-        const restoredEl = document.createElement(anchorEl.tagName);
-        restoredEl.innerHTML = originalContent;
-        Array.from(anchorEl.attributes).forEach((attr) => {
-          restoredEl.setAttribute(attr.name, attr.value);
-        });
-        container.replaceWith(restoredEl);
-      } else {
-        container.remove();
+      if (!container.isConnected)
+        return;
+      try {
+        if (action.position === "replace" && originalContent !== null) {
+          const restoredEl = document.createElement(anchorEl.tagName);
+          restoredEl.innerHTML = originalContent;
+          Array.from(anchorEl.attributes).forEach((attr) => {
+            restoredEl.setAttribute(attr.name, attr.value);
+          });
+          container.replaceWith(restoredEl);
+        } else {
+          container.remove();
+        }
+      } catch {
       }
     },
     updateFn: (changes) => {
@@ -251,6 +276,8 @@ var executeSetText = async (action, context) => {
   });
   return {
     cleanup: () => {
+      if (!anchorEl.isConnected)
+        return;
       anchorEl.textContent = originalText;
     },
     updateFn: (changes) => {
@@ -292,6 +319,8 @@ var executeSetAttr = async (action, context) => {
   });
   return {
     cleanup: () => {
+      if (!anchorEl.isConnected)
+        return;
       if (hadAttribute && originalValue !== null) {
         anchorEl.setAttribute(action.attr, originalValue);
       } else {
@@ -325,6 +354,8 @@ var executeAddClass = async (action, context) => {
   });
   return {
     cleanup: () => {
+      if (!anchorEl.isConnected)
+        return;
       if (!hadClass) {
         anchorEl.classList.remove(action.className);
       }
@@ -351,6 +382,8 @@ var executeRemoveClass = async (action, context) => {
   });
   return {
     cleanup: () => {
+      if (!anchorEl.isConnected)
+        return;
       if (hadClass) {
         anchorEl.classList.add(action.className);
       }
@@ -383,6 +416,8 @@ var executeSetStyle = async (action, context) => {
   });
   return {
     cleanup: () => {
+      if (!anchorEl.isConnected)
+        return;
       for (const [prop, originalValue] of originalStyles) {
         if (originalValue) {
           anchorEl.style.setProperty(prop, originalValue);
@@ -726,6 +761,10 @@ var CelebrationEngine = class {
     this.container = null;
   }
   start(container, effect, config) {
+    const prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    if (prefersReducedMotion) {
+      return;
+    }
     this.container = container;
     this.effect = effect;
     this.duration = config.duration;
@@ -1369,7 +1408,7 @@ var alert = {
 var tag = {
   content: slateGrey[10],
   border: slateGrey[4],
-  background: "#1c2124"
+  background: slateGrey[3]
 };
 var menu = {
   backgroundDefault: slateGrey[2],
@@ -1558,10 +1597,10 @@ function showHighlight(anchorEl, overlayRoot, opts) {
       return;
     }
     const rect = anchorEl.getBoundingClientRect();
-    const x = Math.max(0, rect.left - padding);
-    const y = Math.max(0, rect.top - padding);
-    const w = Math.min(window.innerWidth, rect.width + padding * 2);
-    const h = Math.min(window.innerHeight, rect.height + padding * 2);
+    const x = rect.left - padding;
+    const y = rect.top - padding;
+    const w = rect.width + padding * 2;
+    const h = rect.height + padding * 2;
     Object.assign(ring.style, {
       left: `${x}px`,
       top: `${y}px`,
@@ -1610,17 +1649,22 @@ function showHighlight(anchorEl, overlayRoot, opts) {
   window.addEventListener("scroll", onScroll, true);
   window.addEventListener("resize", onResize);
   const onKey = (e) => {
-    if (e.key === "Escape" && onEsc)
+    var _a3;
+    if (e.key === "Escape" && onEsc) {
+      (_a3 = opts == null ? void 0 : opts.onDismiss) == null ? void 0 : _a3.call(opts);
       handle.destroy();
+    }
   };
   if (onEsc) {
     window.addEventListener("keydown", onKey);
   }
   const onClick = (event) => {
+    var _a3;
     if (blocking) {
       event.preventDefault();
       event.stopPropagation();
     } else if (onClickOutside) {
+      (_a3 = opts == null ? void 0 : opts.onDismiss) == null ? void 0 : _a3.call(opts);
       handle.destroy();
     }
   };
@@ -1637,8 +1681,14 @@ function showHighlight(anchorEl, overlayRoot, opts) {
       scrim.style.pointerEvents = "none";
       scrim.style.opacity = "0";
       setTimeout(() => {
-        scrim.remove();
-        ring.remove();
+        try {
+          scrim.remove();
+        } catch {
+        }
+        try {
+          ring.remove();
+        } catch {
+        }
       }, 220);
     }
   };
@@ -1666,7 +1716,16 @@ var ALLOWED_TAGS2 = /* @__PURE__ */ new Set([
   "sup",
   "sub",
   "a",
-  "button"
+  "button",
+  // SVG elements (for inline Lucide icons in config HTML)
+  "svg",
+  "path",
+  "circle",
+  "line",
+  "polyline",
+  "polygon",
+  "rect",
+  "g"
 ]);
 function sanitizeHtml2(html) {
   var _a2;
@@ -1875,8 +1934,14 @@ var executeModal = async (action, context) => {
       modal2.style.transform = "translate(-50%, -50%) scale(0.95)";
       scrimEl.style.opacity = "0";
       setTimeout(() => {
-        modal2.remove();
-        scrimEl.remove();
+        try {
+          modal2.remove();
+        } catch {
+        }
+        try {
+          scrimEl.remove();
+        } catch {
+        }
       }, 200);
       context.publishEvent("action.modal_dismissed", {
         actionClicked
@@ -1923,10 +1988,12 @@ function getAnchorReference(anchorEl) {
 }
 function showTooltip(anchorEl, overlayRoot, opts) {
   var _a2;
-  const rect = anchorEl.getBoundingClientRect();
-  const isLargeElement = rect.width > window.innerWidth * 0.8 || rect.height > window.innerHeight * 0.8;
-  if (!isLargeElement) {
-    anchorEl.scrollIntoView({ behavior: "smooth", block: "center", inline: "center" });
+  if (!opts.trigger || opts.trigger === "immediate") {
+    const rect = anchorEl.getBoundingClientRect();
+    const isLargeElement = rect.width > window.innerWidth * 0.8 || rect.height > window.innerHeight * 0.8;
+    if (!isLargeElement) {
+      anchorEl.scrollIntoView({ behavior: "smooth", block: "center", inline: "center" });
+    }
   }
   const div = document.createElement("div");
   div.className = "syntro-tooltip";
@@ -2136,7 +2203,12 @@ function showTooltip(anchorEl, overlayRoot, opts) {
       }
       div.style.pointerEvents = "none";
       div.style.opacity = "0";
-      setTimeout(() => div.remove(), 200);
+      setTimeout(() => {
+        try {
+          div.remove();
+        } catch {
+        }
+      }, 200);
     }
   };
   return handle;
@@ -2169,7 +2241,7 @@ function WorkflowTracker({ workflows, expanded, onStepClick, onDismiss }) {
 }
 
 // ../adaptives/adaptive-overlays/dist/WorkflowWidget.js
-function showWorkflowToast(container, notification) {
+function showWorkflowToast(notification) {
   const toast = document.createElement("div");
   toast.setAttribute("data-testid", "workflow-toast");
   toast.className = "se-fixed se-bottom-4 se-right-4 se-z-50";
@@ -2203,7 +2275,7 @@ function showWorkflowToast(container, notification) {
     bodyEl.textContent = notification.body;
     toast.appendChild(bodyEl);
   }
-  container.appendChild(toast);
+  document.body.appendChild(toast);
   let removeTimer;
   const fadeTimer = setTimeout(() => {
     toast.style.opacity = "0";
@@ -2221,7 +2293,7 @@ function extractWorkflowsFromActive(activeActions) {
   const workflows = /* @__PURE__ */ new Map();
   for (const entry of activeActions) {
     const action = entry.action;
-    if (action.kind === "core:tour" && action.workflow && action.tourId) {
+    if (action.kind === "overlays:tour" && action.workflow && action.tourId) {
       const meta = action.workflow;
       const rawSteps = action.steps || [];
       const steps = rawSteps.map((s) => {
@@ -2302,10 +2374,10 @@ function WorkflowWidgetInner({ runtime: runtime3 }) {
       return newEntries.length > 0 ? [...prev, ...newEntries] : prev;
     });
     for (const [tourId, { meta }] of tourWorkflows) {
-      if (!notifiedRef.current.has(tourId) && meta.notification && containerRef.current && !dismissed.includes(tourId) && !completed[tourId]) {
+      if (!notifiedRef.current.has(tourId) && meta.notification && !dismissed.includes(tourId) && !completed[tourId]) {
         notifiedRef.current.add(tourId);
         (_c = stateNs == null ? void 0 : stateNs.set) == null ? void 0 : _c.call(stateNs, "notified", [...notifiedRef.current]);
-        const cleanup = showWorkflowToast(containerRef.current, meta.notification);
+        const cleanup = showWorkflowToast(meta.notification);
         toastCleanupsRef.current.push(cleanup);
       }
     }
@@ -2338,8 +2410,8 @@ function WorkflowWidgetInner({ runtime: runtime3 }) {
                 notifiedRef.current.add(tourId);
                 (_c = stateNs == null ? void 0 : stateNs.set) == null ? void 0 : _c.call(stateNs, "notified", [...notifiedRef.current]);
                 const workflow = currentWorkflows.get(tourId);
-                if ((workflow == null ? void 0 : workflow.meta.notification) && containerRef.current) {
-                  const cleanup = showWorkflowToast(containerRef.current, workflow.meta.notification);
+                if (workflow == null ? void 0 : workflow.meta.notification) {
+                  const cleanup = showWorkflowToast(workflow.meta.notification);
                   toastCleanupsRef.current.push(cleanup);
                 }
               }
@@ -2443,6 +2515,10 @@ var executeHighlight = async (action, context) => {
     return { cleanup: () => {
     } };
   }
+  if (anchorEl.getAttribute("data-syntro-highlight-dismissed")) {
+    return { cleanup: () => {
+    } };
+  }
   const existing = anchorEl.getAttribute("data-syntro-highlight");
   if (existing) {
     const prev = context.overlayRoot.querySelectorAll(".syntro-spotlight-scrim, .syntro-spotlight-ring");
@@ -2465,7 +2541,10 @@ var executeHighlight = async (action, context) => {
     ringColor,
     blocking: (_i = action.blocking) != null ? _i : false,
     onClickOutside: (_j = action.onClickOutside) != null ? _j : true,
-    onEsc: (_k = action.onEsc) != null ? _k : true
+    onEsc: (_k = action.onEsc) != null ? _k : true,
+    onDismiss: () => {
+      anchorEl.setAttribute("data-syntro-highlight-dismissed", "true");
+    }
   });
   context.publishEvent("action.applied", {
     id: context.generateId(),
@@ -2476,6 +2555,7 @@ var executeHighlight = async (action, context) => {
     cleanup: () => {
       handle.destroy();
       anchorEl.removeAttribute("data-syntro-highlight");
+      anchorEl.removeAttribute("data-syntro-highlight-dismissed");
     }
   };
 };
@@ -2565,6 +2645,8 @@ var executePulse = async (action, context) => {
   return {
     cleanup: () => {
       clearTimeout(timeoutId);
+      if (!anchorEl.isConnected)
+        return;
       anchorEl.style.animation = originalAnimation;
       anchorEl.removeAttribute("data-syntro-pulse");
     }
@@ -2634,7 +2716,12 @@ var executeBadge = async (action, context) => {
   });
   return {
     cleanup: () => {
-      badge2.remove();
+      try {
+        badge2.remove();
+      } catch {
+      }
+      if (!anchorEl.isConnected)
+        return;
       if (originalPosition !== void 0) {
         anchorEl.style.position = originalPosition;
       }
@@ -2729,7 +2816,7 @@ var executors2 = [
   { kind: "overlays:badge", executor: executeBadge },
   { kind: "overlays:tooltip", executor: executeTooltip },
   { kind: "overlays:modal", executor: executeModal },
-  { kind: "core:tour", executor: executeTour },
+  { kind: "overlays:tour", executor: executeTour },
   { kind: "overlays:celebrate", executor: executeCelebrate }
 ];
 var runtime2 = {
@@ -2849,7 +2936,15 @@ var CORE_ACTION_KINDS = /* @__PURE__ */ new Set([
   "core:wait",
   "core:sequence",
   "core:parallel",
-  "core:tour"
+  "overlays:tour"
+]);
+var BUNDLED_APP_IDS = /* @__PURE__ */ new Set([
+  "adaptive-chatbot",
+  "adaptive-content",
+  "adaptive-faq",
+  "adaptive-gamification",
+  "adaptive-nav",
+  "adaptive-overlays"
 ]);
 var NAMESPACE_TO_APP_ID = {
   faq: "adaptive-faq",
@@ -3003,6 +3098,9 @@ function createAppLoader(options) {
         }
       }
     }
+    for (const bundled of BUNDLED_APP_IDS) {
+      appIds.delete(bundled);
+    }
     return Array.from(appIds);
   }
   async function loadAppsForConfig(config) {
@@ -3358,14 +3456,20 @@ function getAntiFlickerSnippet(config = {}) {
 }
 
 // src/version.ts
-var SDK_VERSION = "2.8.0-canary.8";
+var SDK_VERSION = "2.8.0-canary.80";
 
 // src/types.ts
 var SDK_SCHEMA_VERSION = "2.0";
 
 // src/fetchers/mergeConfigs.ts
-function resolveVariantConfigs(client, keys, _strategy = "first-match") {
-  var _a2, _b, _c, _d;
+function resolveVariantConfigs(client, keys, strategy = "merge") {
+  if (strategy === "first-match") {
+    return resolveFirstMatch(client, keys);
+  }
+  return resolveMerge(client, keys);
+}
+function resolveFirstMatch(client, keys) {
+  var _a2;
   for (const key of keys) {
     const value = (_a2 = client.getFeatureValue) == null ? void 0 : _a2.call(client, key, null);
     if (!value || typeof value !== "object") continue;
@@ -3373,20 +3477,60 @@ function resolveVariantConfigs(client, keys, _strategy = "first-match") {
     const hasTiles = variant.tiles && variant.tiles.length > 0;
     const hasActions = variant.actions && variant.actions.length > 0;
     if (hasTiles || hasActions) {
-      return {
-        tiles: (_b = variant.tiles) != null ? _b : [],
-        actions: (_c = variant.actions) != null ? _c : [],
-        fetchedAt: (_d = variant.fetchedAt) != null ? _d : (/* @__PURE__ */ new Date()).toISOString(),
-        ...variant.schemaVersion && { schemaVersion: variant.schemaVersion },
-        ...variant.configVersion && { configVersion: variant.configVersion },
-        ...variant.canvasTitle && { canvasTitle: variant.canvasTitle },
-        ...variant.theme && { theme: variant.theme },
-        ...variant.launcher && { launcher: variant.launcher }
-      };
+      return buildConfig([variant]);
     }
   }
   return null;
 }
+function resolveMerge(client, keys) {
+  var _a2;
+  const variants = [];
+  for (const key of keys) {
+    const value = (_a2 = client.getFeatureValue) == null ? void 0 : _a2.call(client, key, null);
+    if (!value || typeof value !== "object") continue;
+    const variant = value;
+    const hasTiles = variant.tiles && variant.tiles.length > 0;
+    const hasActions = variant.actions && variant.actions.length > 0;
+    if (hasTiles || hasActions) {
+      variants.push(variant);
+    }
+  }
+  if (variants.length === 0) return null;
+  return buildConfig(variants);
+}
+function buildConfig(variants) {
+  const allTiles = [];
+  const allActions = [];
+  let fetchedAt;
+  let schemaVersion;
+  let configVersion;
+  let canvasTitle;
+  let theme;
+  let launcher;
+  let meta;
+  for (const variant of variants) {
+    if (variant.tiles) allTiles.push(...variant.tiles);
+    if (variant.actions) allActions.push(...variant.actions);
+    fetchedAt != null ? fetchedAt : fetchedAt = variant.fetchedAt;
+    schemaVersion != null ? schemaVersion : schemaVersion = variant.schemaVersion;
+    configVersion != null ? configVersion : configVersion = variant.configVersion;
+    canvasTitle != null ? canvasTitle : canvasTitle = variant.canvasTitle;
+    theme != null ? theme : theme = variant.theme;
+    launcher != null ? launcher : launcher = variant.launcher;
+    meta != null ? meta : meta = variant.meta;
+  }
+  return {
+    tiles: allTiles,
+    actions: allActions,
+    fetchedAt: fetchedAt != null ? fetchedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    ...schemaVersion && { schemaVersion },
+    ...configVersion && { configVersion },
+    ...canvasTitle && { canvasTitle },
+    ...theme && { theme },
+    ...launcher && { launcher },
+    ...meta && { meta }
+  };
+}
 
 // src/logger.ts
 var debugEnabled = false;
@@ -3509,12 +3653,14 @@ function getCachedConfig(sdkVersion) {
 var resolveConfigUri = ({
   configUri,
   experiments,
-  featureKey = "smart-canvas-config-uri"
+  featureKey
 }) => {
   var _a2;
   if (configUri) return configUri;
-  const fromFeature = (_a2 = experiments == null ? void 0 : experiments.getFeatureValue) == null ? void 0 : _a2.call(experiments, featureKey, null);
-  if (fromFeature) return fromFeature;
+  if (experiments && featureKey) {
+    const fromFeature = (_a2 = experiments.getFeatureValue) == null ? void 0 : _a2.call(experiments, featureKey, null);
+    if (fromFeature) return fromFeature;
+  }
   return void 0;
 };
 function getVariantFlagKeys(experiments, manifestKey, variantFlagPrefix) {
@@ -3540,7 +3686,7 @@ var createCanvasConfigFetcher = ({
   experiments,
   featureKey,
   credentials,
-  configFeatureKey = "smart-canvas-config",
+  configFeatureKey,
   manifestKey,
   variantFlagPrefix,
   sdkVersion
@@ -3641,7 +3787,8 @@ function registerFromTriggerWhen(triggerWhen, accumulator) {
       if (cond.type === "event_count" && cond.key) {
         const counter = cond.counter;
         const predicate = counter ? buildPredicate(counter) : () => true;
-        accumulator.register(cond.key, predicate);
+        const needsTimestamps = typeof cond.withinMs === "number";
+        accumulator.register(cond.key, predicate, needsTimestamps);
       }
     }
   }
@@ -3734,113 +3881,666 @@ function useShadowRoot() {
   return ctx;
 }
 
-// src/events/types.ts
+// ../event-processor/dist/types.js
+var EVENT_SCHEMA_VERSION = "1.0.0";
 var StandardEvents = {
-  // UI events (from PostHog autocapture)
   UI_CLICK: "ui.click",
   UI_SCROLL: "ui.scroll",
   UI_INPUT: "ui.input",
   UI_CHANGE: "ui.change",
   UI_SUBMIT: "ui.submit",
-  // Navigation events
   NAV_PAGE_VIEW: "nav.page_view",
   NAV_PAGE_LEAVE: "nav.page_leave",
-  // Canvas events
-  CANVAS_OPENED: "canvas.opened",
-  CANVAS_CLOSED: "canvas.closed",
-  TILE_VIEWED: "tile.viewed",
-  TILE_EXPANDED: "tile.expanded",
-  TILE_COLLAPSED: "tile.collapsed",
-  TILE_ACTION: "tile.action",
-  // Overlay/tour events
-  OVERLAY_STARTED: "overlay.started",
-  OVERLAY_COMPLETED: "overlay.completed",
-  OVERLAY_DISMISSED: "overlay.dismissed",
-  OVERLAY_STEP_VIEWED: "overlay.step_viewed",
-  // Derived behavioral signals (Phase 3)
-  BEHAVIOR_RAGE_CLICK: "behavior.rage_click",
-  BEHAVIOR_HESITATION: "behavior.hesitation",
-  BEHAVIOR_CONFUSION: "behavior.confusion",
-  // Action events
-  ACTION_APPLIED: "action.applied",
-  ACTION_REVERTED: "action.reverted",
-  ACTION_FAILED: "action.failed",
-  ACTION_CTA_CLICKED: "action.cta_clicked",
-  // Notification events
-  NOTIFICATION_SHOWN: "notification.shown",
-  NOTIFICATION_CLICKED: "notification.clicked",
-  NOTIFICATION_DISMISSED: "notification.dismissed",
-  NOTIFICATION_DEEP_LINK: "notification.deep_link",
-  // Surface events
-  SURFACE_MOUNTED: "surface.mounted",
-  SURFACE_UNMOUNTED: "surface.unmounted"
+  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
 };
-var EVENT_SCHEMA_VERSION = "1.0.0";
 
-// src/events/normalizers/canvas.ts
-function createCanvasEvent(name, props) {
-  return {
-    ts: Date.now(),
-    name,
-    source: "canvas",
-    props,
-    schemaVersion: EVENT_SCHEMA_VERSION
-  };
-}
-function canvasOpened(surface) {
-  return createCanvasEvent(StandardEvents.CANVAS_OPENED, { surface });
-}
-function canvasClosed(surface) {
-  return createCanvasEvent(StandardEvents.CANVAS_CLOSED, { surface });
-}
-function tileViewed(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_VIEWED, { tileId, surface });
-}
-function tileExpanded(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_EXPANDED, { tileId, surface });
-}
-function tileCollapsed(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_COLLAPSED, { tileId, surface });
+// ../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.");
 }
-function tileAction(tileId, actionId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_ACTION, {
-    tileId,
-    actionId,
-    surface
+var INTERACTIVE_TAGS = /* @__PURE__ */ new Set(["a", "button", "input", "select", "textarea"]);
+function parseElementsChain(chain) {
+  if (!chain)
+    return void 0;
+  return chain.split(";").map((segment) => {
+    const el = {};
+    const colonIdx = segment.indexOf(":");
+    const tagPart = colonIdx >= 0 ? segment.slice(0, colonIdx) : segment;
+    const attrPart = colonIdx >= 0 ? segment.slice(colonIdx + 1) : "";
+    const dotIdx = tagPart.indexOf(".");
+    if (dotIdx >= 0) {
+      el.tag_name = tagPart.slice(0, dotIdx);
+      el.attr__class = tagPart.slice(dotIdx + 1).replace(/\./g, " ");
+    } else {
+      el.tag_name = tagPart;
+    }
+    const attrRegex = /([\w$]+)="([^"]*)"/g;
+    let match;
+    while ((match = attrRegex.exec(attrPart)) !== null) {
+      const [, key, value] = match;
+      if (key === "nth-child" || key === "nth-of-type")
+        continue;
+      el[key] = value;
+    }
+    if (el.text) {
+      el.$el_text = el.text;
+      delete el.text;
+    }
+    return el;
   });
 }
-function overlayStarted(recipeId, recipeName) {
-  return createCanvasEvent(StandardEvents.OVERLAY_STARTED, {
-    recipeId,
-    recipeName
-  });
+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 overlayCompleted(recipeId, recipeName) {
-  return createCanvasEvent(StandardEvents.OVERLAY_COMPLETED, {
-    recipeId,
-    recipeName
-  });
+function extractProps(phEvent) {
+  var _a2, _b, _c;
+  const props = {};
+  const phProps = phEvent.properties || {};
+  const elements = (_a2 = phProps.$elements) != null ? _a2 : typeof phProps.$elements_chain === "string" ? parseElementsChain(phProps.$elements_chain) : void 0;
+  const directTag = (_c = phProps.$tag_name) != null ? _c : (_b = elements == null ? void 0 : elements[0]) == null ? void 0 : _b.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 (isClickEvent && !elements) {
+    console.warn(`[PostHogNormalizer] $autocapture click has no element chain. PostHog may have changed wire format. Properties: $elements=${!!phProps.$elements}, $elements_chain=${typeof phProps.$elements_chain}`);
+  }
+  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 overlayDismissed(recipeId, recipeName, stepIndex) {
-  return createCanvasEvent(StandardEvents.OVERLAY_DISMISSED, {
-    recipeId,
-    recipeName,
-    stepIndex
-  });
+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 overlayStepViewed(recipeId, stepIndex, stepTitle) {
-  return createCanvasEvent(StandardEvents.OVERLAY_STEP_VIEWED, {
-    recipeId,
-    stepIndex,
-    stepTitle
-  });
+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 customCanvasEvent(name, props) {
-  const eventName = name.startsWith("canvas.") ? name : `canvas.${name}`;
-  return createCanvasEvent(eventName, props);
+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);
+    }
+  };
 }
-var CanvasEvents = {
-  canvasOpened,
+
+// ../event-processor/dist/detectors/focus-bounce.js
+var FocusBounceDetector = class {
+  constructor(config, emit2) {
+    this.config = config;
+    this.emit = emit2;
+    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, emit2) {
+    this.config = config;
+    this.emit = emit2;
+    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, emit2, elementResolver) {
+    this.config = config;
+    this.emit = emit2;
+    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, emit2) {
+    this.config = config;
+    this.emit = emit2;
+    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, emit2) {
+    this.config = config;
+    this.emit = emit2;
+    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, emit2) {
+    this.config = config;
+    this.emit = emit2;
+    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 emit2(event) {
+    for (const cb of listeners)
+      cb(event);
+  }
+  const hesitation = new HesitationDetector(config, emit2);
+  const rageClick = new RageClickDetector(config, emit2);
+  const scrollThrash = new ScrollThrashDetector(config, emit2);
+  const focusBounce = new FocusBounceDetector(config, emit2);
+  const idle = new IdleDetector(config, emit2);
+  const hover = new HoverTracker(config, emit2, options == null ? void 0 : options.elementResolver);
+  const clickAttrBuffer = [];
+  return {
+    ingest(raw) {
+      if (raw.kind === "posthog") {
+        const { kind: _, ...phEvent } = raw;
+        if (shouldNormalizeEvent(phEvent)) {
+          emit2(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",
+  UI_INPUT: "ui.input",
+  UI_CHANGE: "ui.change",
+  UI_SUBMIT: "ui.submit",
+  // Navigation events
+  NAV_PAGE_VIEW: "nav.page_view",
+  NAV_PAGE_LEAVE: "nav.page_leave",
+  // Canvas events
+  CANVAS_OPENED: "canvas.opened",
+  CANVAS_CLOSED: "canvas.closed",
+  TILE_VIEWED: "tile.viewed",
+  TILE_EXPANDED: "tile.expanded",
+  TILE_COLLAPSED: "tile.collapsed",
+  TILE_ACTION: "tile.action",
+  // Overlay/tour events
+  OVERLAY_STARTED: "overlay.started",
+  OVERLAY_COMPLETED: "overlay.completed",
+  OVERLAY_DISMISSED: "overlay.dismissed",
+  OVERLAY_STEP_VIEWED: "overlay.step_viewed",
+  // Derived behavioral signals (Phase 3)
+  BEHAVIOR_RAGE_CLICK: "behavior.rage_click",
+  BEHAVIOR_HESITATION: "behavior.hesitation",
+  BEHAVIOR_CONFUSION: "behavior.confusion",
+  // Action events
+  ACTION_APPLIED: "action.applied",
+  ACTION_REVERTED: "action.reverted",
+  ACTION_FAILED: "action.failed",
+  ACTION_CTA_CLICKED: "action.cta_clicked",
+  // Notification events
+  NOTIFICATION_SHOWN: "notification.shown",
+  NOTIFICATION_CLICKED: "notification.clicked",
+  NOTIFICATION_DISMISSED: "notification.dismissed",
+  NOTIFICATION_DEEP_LINK: "notification.deep_link",
+  // Surface events
+  SURFACE_MOUNTED: "surface.mounted",
+  SURFACE_UNMOUNTED: "surface.unmounted"
+};
+
+// src/events/normalizers/canvas.ts
+function createCanvasEvent(name, props) {
+  return {
+    ts: Date.now(),
+    name,
+    source: "canvas",
+    props,
+    schemaVersion: EVENT_SCHEMA_VERSION
+  };
+}
+function canvasOpened(surface) {
+  return createCanvasEvent(StandardEvents2.CANVAS_OPENED, { surface });
+}
+function canvasClosed(surface) {
+  return createCanvasEvent(StandardEvents2.CANVAS_CLOSED, { surface });
+}
+function tileViewed(tileId, surface) {
+  return createCanvasEvent(StandardEvents2.TILE_VIEWED, { tileId, surface });
+}
+function tileExpanded(tileId, surface) {
+  return createCanvasEvent(StandardEvents2.TILE_EXPANDED, { tileId, surface });
+}
+function tileCollapsed(tileId, surface) {
+  return createCanvasEvent(StandardEvents2.TILE_COLLAPSED, { tileId, surface });
+}
+function tileAction(tileId, actionId, surface) {
+  return createCanvasEvent(StandardEvents2.TILE_ACTION, {
+    tileId,
+    actionId,
+    surface
+  });
+}
+function overlayStarted(recipeId, recipeName) {
+  return createCanvasEvent(StandardEvents2.OVERLAY_STARTED, {
+    recipeId,
+    recipeName
+  });
+}
+function overlayCompleted(recipeId, recipeName) {
+  return createCanvasEvent(StandardEvents2.OVERLAY_COMPLETED, {
+    recipeId,
+    recipeName
+  });
+}
+function overlayDismissed(recipeId, recipeName, stepIndex) {
+  return createCanvasEvent(StandardEvents2.OVERLAY_DISMISSED, {
+    recipeId,
+    recipeName,
+    stepIndex
+  });
+}
+function overlayStepViewed(recipeId, stepIndex, stepTitle) {
+  return createCanvasEvent(StandardEvents2.OVERLAY_STEP_VIEWED, {
+    recipeId,
+    stepIndex,
+    stepTitle
+  });
+}
+function customCanvasEvent(name, props) {
+  const eventName = name.startsWith("canvas.") ? name : `canvas.${name}`;
+  return createCanvasEvent(eventName, props);
+}
+var CanvasEvents = {
+  canvasOpened,
   canvasClosed,
   tileViewed,
   tileExpanded,
@@ -3853,8 +4553,65 @@ var CanvasEvents = {
   custom: customCanvasEvent
 };
 
+// src/components/emojiToIcon.tsx
+import {
+  AlertTriangle,
+  ArrowRight,
+  Banknote,
+  Bell,
+  BookOpen,
+  CheckCircle,
+  ClipboardList,
+  Compass,
+  FileText,
+  Gamepad2,
+  HelpCircle,
+  Landmark,
+  Layers,
+  Lightbulb,
+  MessageCircle,
+  SkipForward,
+  Sparkles,
+  Timer,
+  Trophy
+} from "lucide-react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var EMOJI_ICON_MAP = {
+  "\u2753": HelpCircle,
+  "\u{1F9ED}": Compass,
+  "\u{1F4DD}": FileText,
+  "\u{1F3AF}": Layers,
+  "\u{1F3C6}": Trophy,
+  "\u2728": Sparkles,
+  "\u{1F4AC}": MessageCircle,
+  "\u{1F3AE}": Gamepad2,
+  "\u{1F4A1}": Lightbulb,
+  "\u{1F4B0}": Banknote,
+  "\u{1F4CB}": ClipboardList,
+  "\u2705": CheckCircle,
+  "\u26A0\uFE0F": AlertTriangle,
+  "\u{1F4B5}": Banknote,
+  "\u{1F3DB}\uFE0F": Landmark,
+  "\u23ED\uFE0F": SkipForward,
+  "\u27A1\uFE0F": ArrowRight,
+  "\u23F1\uFE0F": Timer,
+  "\u{1F4D6}": BookOpen,
+  "\u{1F514}": Bell
+};
+function EmojiIcon({
+  emoji,
+  size = 14,
+  color = "currentColor"
+}) {
+  const Icon = EMOJI_ICON_MAP[emoji];
+  if (!Icon) {
+    return /* @__PURE__ */ jsx2("span", { children: emoji });
+  }
+  return /* @__PURE__ */ jsx2(Icon, { size, color });
+}
+
 // src/notifications/NotificationToastStack.tsx
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 var TOAST_STYLES_ID = "syntro-toast-styles";
 var TOAST_CSS = `
   @keyframes syntro-toast-slide-in {
@@ -3891,7 +4648,7 @@ function NotificationToastStack({
   const { shadowRoot } = useShadowRoot();
   ensureToastStyles(shadowRoot);
   if (notifications.length === 0) return null;
-  return /* @__PURE__ */ jsx2(
+  return /* @__PURE__ */ jsx3(
     "div",
     {
       "data-testid": "notification-toast-stack",
@@ -3946,7 +4703,7 @@ function NotificationToastStack({
                       padding: "10px 12px"
                     },
                     children: [
-                      /* @__PURE__ */ jsx2(
+                      /* @__PURE__ */ jsx3(
                         "div",
                         {
                           style: {
@@ -3960,11 +4717,11 @@ function NotificationToastStack({
                             flexShrink: 0,
                             fontSize: "14px"
                           },
-                          children: (_a2 = notif.icon) != null ? _a2 : "\u{1F514}"
+                          children: /* @__PURE__ */ jsx3(EmojiIcon, { emoji: (_a2 = notif.icon) != null ? _a2 : "\u{1F514}", size: 14 })
                         }
                       ),
                       /* @__PURE__ */ jsxs("div", { style: { flex: 1, minWidth: 0 }, children: [
-                        /* @__PURE__ */ jsx2(
+                        /* @__PURE__ */ jsx3(
                           "div",
                           {
                             style: {
@@ -3979,7 +4736,7 @@ function NotificationToastStack({
                             children: notif.title
                           }
                         ),
-                        notif.body && /* @__PURE__ */ jsx2(
+                        notif.body && /* @__PURE__ */ jsx3(
                           "div",
                           {
                             style: {
@@ -3995,7 +4752,7 @@ function NotificationToastStack({
                           }
                         )
                       ] }),
-                      /* @__PURE__ */ jsx2(
+                      /* @__PURE__ */ jsx3(
                         "button",
                         {
                           type: "button",
@@ -4020,7 +4777,7 @@ function NotificationToastStack({
                     ]
                   }
                 ),
-                /* @__PURE__ */ jsx2("div", { style: { height: "2px", background: "rgba(0, 0, 0, 0.08)" }, children: /* @__PURE__ */ jsx2(
+                /* @__PURE__ */ jsx3("div", { style: { height: "2px", background: "rgba(0, 0, 0, 0.08)" }, children: /* @__PURE__ */ jsx3(
                   "div",
                   {
                     className: "syntro-toast-progress",
@@ -4098,7 +4855,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
@@ -4163,7 +4920,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,
@@ -4234,7 +4991,7 @@ function useNotifyWatcher(runtime3, tiles, appRegistry2) {
 
 // src/RuntimeProvider.tsx
 import { createContext as createContext2, useContext as useContext2, useEffect as useEffect4, useMemo as useMemo2, useState as useState3 } from "react";
-import { jsx as jsx3 } from "react/jsx-runtime";
+import { jsx as jsx4 } from "react/jsx-runtime";
 var RuntimeReactContext = createContext2({
   runtime: null,
   context: null
@@ -4252,7 +5009,7 @@ function RuntimeProvider({ runtime: runtime3, children }) {
     return unsubscribe;
   }, [runtime3]);
   const value = useMemo2(() => ({ runtime: runtime3, context }), [runtime3, context]);
-  return /* @__PURE__ */ jsx3(RuntimeReactContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx4(RuntimeReactContext.Provider, { value, children });
 }
 function useRuntime() {
   const { runtime: runtime3 } = useContext2(RuntimeReactContext);
@@ -4326,41 +5083,17 @@ import {
 } from "react";
 
 // src/components/TileIcon.tsx
-import {
-  Compass,
-  FileText,
-  Gamepad2,
-  HelpCircle,
-  Layers,
-  MessageCircle,
-  Sparkles,
-  Trophy
-} from "lucide-react";
-import { jsx as jsx4 } from "react/jsx-runtime";
-var ICON_MAP = {
-  "\u2753": HelpCircle,
-  "\u{1F9ED}": Compass,
-  "\u{1F4DD}": FileText,
-  "\u{1F3AF}": Layers,
-  "\u{1F3C6}": Trophy,
-  "\u2728": Sparkles,
-  "\u{1F4AC}": MessageCircle,
-  "\u{1F3AE}": Gamepad2
-};
+import { jsx as jsx5 } from "react/jsx-runtime";
 function TileIcon({
   emoji,
   size = 18,
   color = "currentColor"
 }) {
-  const Icon = ICON_MAP[emoji];
-  if (!Icon) {
-    return /* @__PURE__ */ jsx4("span", { children: emoji });
-  }
-  return /* @__PURE__ */ jsx4(Icon, { size, color });
+  return /* @__PURE__ */ jsx5(EmojiIcon, { emoji, size, color });
 }
 
 // src/components/TileCard.tsx
-import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
 function WidgetMount({ widgetId, props }) {
   var _a2;
   const runtime3 = useRuntime();
@@ -4390,7 +5123,6 @@ function WidgetMount({ widgetId, props }) {
     return () => {
       handle.unmount();
       handleRef.current = null;
-      container.remove();
     };
   }, [registry, widgetId, widgetAvailable]);
   const propsJson = JSON.stringify(props);
@@ -4401,7 +5133,7 @@ function WidgetMount({ widgetId, props }) {
     prevPropsJsonRef.current = propsJson;
     (_a3 = handleRef.current) == null ? void 0 : _a3.update(propsRef.current);
   }, [propsJson]);
-  if (!registry || !registry.has(widgetId)) {
+  if (!(registry == null ? void 0 : registry.has(widgetId))) {
     return /* @__PURE__ */ jsxs2(
       "div",
       {
@@ -4418,8 +5150,21 @@ function WidgetMount({ widgetId, props }) {
       }
     );
   }
-  return /* @__PURE__ */ jsx5("div", { ref: parentRef });
-}
+  return /* @__PURE__ */ jsx6("div", { ref: parentRef });
+}
+var INTERACTION_PATTERNS = [
+  ":toggled",
+  ":clicked",
+  ":feedback",
+  ":navigate",
+  ":expanded",
+  ":collapsed",
+  ":dismissed",
+  ":submitted",
+  ":interacted",
+  ":tip_clicked",
+  ":tip_focused"
+];
 function TileCard({
   config,
   surface: _surface,
@@ -4428,10 +5173,42 @@ function TileCard({
 }) {
   const { title, subtitle, widget, props, icon } = config;
   const [, setTick] = useState4(0);
+  const articleRef = useRef4(null);
   const runtime3 = useRuntime();
   useEffect5(() => {
     if (runtime3) setTick((t) => t + 1);
   }, [runtime3]);
+  useEffect5(() => {
+    var _a2;
+    const tracker = typeof window !== "undefined" ? (_a2 = window.SynOS) == null ? void 0 : _a2.interventionTracker : null;
+    if (!articleRef.current || !tracker) return;
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        var _a3;
+        if (entry.isIntersecting) {
+          tracker.trackSeen(config.id, (_a3 = config.widget) != null ? _a3 : "unknown");
+          observer.disconnect();
+        }
+      },
+      { threshold: 0.5 }
+    );
+    observer.observe(articleRef.current);
+    return () => observer.disconnect();
+  }, [config.id, config.widget]);
+  useEffect5(() => {
+    var _a2;
+    const tracker = typeof window !== "undefined" ? (_a2 = window.SynOS) == null ? void 0 : _a2.interventionTracker : null;
+    if (!(runtime3 == null ? void 0 : runtime3.events) || !tracker) return;
+    return runtime3.events.subscribe((event) => {
+      var _a3, _b;
+      if (!INTERACTION_PATTERNS.some((p) => {
+        var _a4;
+        return (_a4 = event.name) == null ? void 0 : _a4.includes(p);
+      })) return;
+      if (((_a3 = event.props) == null ? void 0 : _a3.instanceId) !== config.id) return;
+      tracker.trackInteracted(config.id, (_b = config.widget) != null ? _b : "unknown", event.name);
+    });
+  }, [runtime3 == null ? void 0 : runtime3.events, config.id, config.widget]);
   const registration = useMemo3(
     () => {
       var _a2, _b;
@@ -4485,15 +5262,16 @@ function TileCard({
   return /* @__PURE__ */ jsxs2(
     "article",
     {
+      ref: articleRef,
       "data-shadow-canvas-id": `tile-${config.id}`,
       style: cardStyle,
       onMouseEnter,
       onMouseLeave,
       children: [
         /* @__PURE__ */ jsxs2("div", { style: headerStyle, children: [
-          /* @__PURE__ */ jsx5("div", { style: iconStyle, children: /* @__PURE__ */ jsx5(TileIcon, { emoji: resolvedIcon, size: resolvedSubtitle ? 36 : 24 }) }),
+          /* @__PURE__ */ jsx6("div", { style: iconStyle, children: /* @__PURE__ */ jsx6(TileIcon, { emoji: resolvedIcon, size: resolvedSubtitle ? 36 : 24 }) }),
           /* @__PURE__ */ jsxs2("div", { style: { flex: 1, minWidth: 0 }, children: [
-            /* @__PURE__ */ jsx5(
+            /* @__PURE__ */ jsx6(
               "h3",
               {
                 style: {
@@ -4508,7 +5286,7 @@ function TileCard({
                 children: title != null ? title : widget
               }
             ),
-            resolvedSubtitle && /* @__PURE__ */ jsx5(
+            resolvedSubtitle && /* @__PURE__ */ jsx6(
               "p",
               {
                 style: {
@@ -4525,14 +5303,14 @@ function TileCard({
             )
           ] })
         ] }),
-        /* @__PURE__ */ jsx5(
+        /* @__PURE__ */ jsx6(
           "div",
           {
             style: {
               padding: "var(--sc-tile-body-padding, 0 0.75rem 0.5rem)",
               borderTop: "1px solid rgba(255, 255, 255, 0.06)"
             },
-            children: /* @__PURE__ */ jsx5("div", { style: { paddingTop: "var(--sc-tile-gap, 0.25rem)" }, children: /* @__PURE__ */ jsx5(WidgetMount, { widgetId: widget, props: { ...props, instanceId: config.id } }) })
+            children: /* @__PURE__ */ jsx6("div", { style: { paddingTop: "var(--sc-tile-gap, 0.25rem)" }, children: /* @__PURE__ */ jsx6(WidgetMount, { widgetId: widget, props: { ...props, instanceId: config.id } }) })
           }
         )
       ]
@@ -4940,7 +5718,7 @@ function flattenThemeConfig(config) {
 
 // src/theme/ThemeProvider.tsx
 import { createContext as createContext3, useContext as useContext3, useEffect as useEffect6, useMemo as useMemo4 } from "react";
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 var ThemeContext = createContext3(null);
 function ThemeProvider({
   children,
@@ -4971,7 +5749,7 @@ ${cssRules}
     mode: merged.mode,
     cssVariables
   };
-  return /* @__PURE__ */ jsx6(ThemeContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx7(ThemeContext.Provider, { value, children });
 }
 function useTheme() {
   const context = useContext3(ThemeContext);
@@ -4982,7 +5760,7 @@ function useTheme() {
 }
 
 // src/components/ShadowCanvasOverlay.tsx
-import { Fragment, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
 var LAUNCHER_STYLES_ID = "syntro-launcher-styles";
 function ensureLauncherStyles(target, css) {
   if (target.querySelector(`#${LAUNCHER_STYLES_ID}`)) return;
@@ -4996,7 +5774,6 @@ function ShadowCanvasOverlay({
   onToggle,
   telemetry,
   launcherLabel: _launcherLabel = "Adaptives",
-  launcherIcon,
   launcherAnimate = false,
   launcherAnimationStyle: _launcherAnimationStyle = "pulse",
   notificationCount: _notificationCount,
@@ -5007,7 +5784,7 @@ function ShadowCanvasOverlay({
   canvasTitle,
   displayMode = "standard"
 }) {
-  var _a2, _b, _c, _d;
+  var _a2, _b, _c, _d, _e;
   const [mounted, setMounted] = useState5(false);
   const [launcherPos, setLauncherPos] = useState5(null);
   const dragRef = useRef5(null);
@@ -5022,7 +5799,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
@@ -5032,7 +5809,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
         });
@@ -5105,6 +5882,17 @@ function ShadowCanvasOverlay({
     }
     onToggle();
   }, [isOpen, telemetry, runtime3, onToggle]);
+  useEffect7(() => {
+    if (!isOpen) return;
+    const handleOutsideClick = (e) => {
+      const path = e.composedPath();
+      if (containerRef.current && !path.includes(containerRef.current) && launcherRef.current && !path.includes(launcherRef.current)) {
+        toggle2();
+      }
+    };
+    document.addEventListener("mousedown", handleOutsideClick);
+    return () => document.removeEventListener("mousedown", handleOutsideClick);
+  }, [isOpen, toggle2]);
   const onLauncherPointerDown = useCallback4((e) => {
     const rect = e.currentTarget.getBoundingClientRect();
     dragRef.current = {
@@ -5129,7 +5917,7 @@ function ShadowCanvasOverlay({
     }
   }, []);
   const onLauncherPointerUp = useCallback4(
-    (_e) => {
+    (_e2) => {
       const drag = dragRef.current;
       dragRef.current = null;
       if (drag && !drag.dragged) {
@@ -5143,6 +5931,7 @@ function ShadowCanvasOverlay({
   const isPush = config.canvas.layout === "push";
   const canvasBorder = (_b = config.canvas.border) != null ? _b : "none";
   const containerRef = useRef5(null);
+  const launcherRef = useRef5(null);
   const zIndex = 2147483600;
   useEffect7(() => {
     var _a3, _b2, _c2, _d2;
@@ -5223,19 +6012,19 @@ function ShadowCanvasOverlay({
     pointerEvents: "none",
     padding: "0"
   };
-  const content = /* @__PURE__ */ jsx7(
+  const content = /* @__PURE__ */ jsx8(
     "div",
     {
       "data-shadow-canvas-id": "overlay-root",
       style: {
         position: "fixed",
         inset: 0,
-        pointerEvents: isOpen ? "auto" : "none",
+        pointerEvents: "none",
         zIndex
       },
       children: /* @__PURE__ */ jsxs3("div", { style: wrapperStyle, children: [
         /* @__PURE__ */ jsxs3("div", { ref: containerRef, "data-shadow-canvas-id": "overlay-container", style: containerStyle, children: [
-          isFocused && canvasTitle && /* @__PURE__ */ jsx7("header", { style: { color: "white", padding: "1.5rem 1.5rem 0" }, children: /* @__PURE__ */ jsx7(
+          isFocused && canvasTitle && /* @__PURE__ */ jsx8("header", { style: { color: "white", padding: "1.5rem 1.5rem 0" }, children: /* @__PURE__ */ jsx8(
             "p",
             {
               style: {
@@ -5248,7 +6037,7 @@ function ShadowCanvasOverlay({
               children: canvasTitle
             }
           ) }),
-          /* @__PURE__ */ jsx7("div", { style: { flex: 1, overflowY: "auto", padding: isFocused ? "0" : "1rem" }, children: isLoading ? /* @__PURE__ */ jsx7(
+          /* @__PURE__ */ jsx8("div", { style: { flex: 1, overflowY: "auto", padding: isFocused ? "0" : "1rem" }, children: isLoading ? /* @__PURE__ */ jsx8(
             "div",
             {
               style: { color: "var(--sc-overlay-text-color)", padding: isFocused ? "1rem" : "0" },
@@ -5268,7 +6057,7 @@ function ShadowCanvasOverlay({
             }
           ) : isFocused ? (
             /* Focused Mode: Render first tile full size */
-            tiles.length > 0 ? /* @__PURE__ */ jsx7(
+            tiles.length > 0 ? /* @__PURE__ */ jsx8(
               TileCard,
               {
                 config: tiles[0],
@@ -5279,7 +6068,7 @@ function ShadowCanvasOverlay({
             ) : null
           ) : (
             /* Standard Mode: Stacked cards — widgets always visible */
-            /* @__PURE__ */ jsx7(
+            /* @__PURE__ */ jsx8(
               "div",
               {
                 style: {
@@ -5288,7 +6077,7 @@ function ShadowCanvasOverlay({
                   gap: "0.75rem",
                   width: "100%"
                 },
-                children: tiles.map((tile) => /* @__PURE__ */ jsx7(
+                children: tiles.map((tile) => /* @__PURE__ */ jsx8(
                   TileCard,
                   {
                     config: tile,
@@ -5303,17 +6092,7 @@ function ShadowCanvasOverlay({
           ) }),
           footerSlot
         ] }),
-        /* @__PURE__ */ jsx7(
-          "div",
-          {
-            onClick: toggle2,
-            style: {
-              flex: "1 1 auto",
-              pointerEvents: isOpen ? "auto" : "none",
-              cursor: "default"
-            }
-          }
-        )
+        /* @__PURE__ */ jsx8("div", { style: { flex: "1 1 auto" } })
       ] })
     }
   );
@@ -5331,7 +6110,7 @@ function ShadowCanvasOverlay({
             zIndex: zIndex + 47
           },
           children: [
-            /* @__PURE__ */ jsx7(
+            /* @__PURE__ */ jsx8(
               NotificationToastStack,
               {
                 notifications,
@@ -5343,6 +6122,7 @@ function ShadowCanvasOverlay({
             /* @__PURE__ */ jsxs3(
               "button",
               {
+                ref: launcherRef,
                 type: "button",
                 "aria-label": "Toggle shadow canvas",
                 className: launcherAnimate && !isOpen ? "syntro-launcher-animate" : void 0,
@@ -5401,14 +6181,14 @@ function ShadowCanvasOverlay({
                       focusable: "false",
                       style: { transition: "transform 200ms ease" },
                       children: [
-                        /* @__PURE__ */ jsx7("path", { d: "M18 6L6 18" }),
-                        /* @__PURE__ */ jsx7("path", { d: "M6 6l12 12" })
+                        /* @__PURE__ */ jsx8("path", { d: "M18 6L6 18" }),
+                        /* @__PURE__ */ jsx8("path", { d: "M6 6l12 12" })
                       ]
                     }
-                  ) : launcherIcon ? /* @__PURE__ */ jsx7(
+                  ) : ((_e = config.launcher) == null ? void 0 : _e.icon) ? /* @__PURE__ */ jsx8(
                     "img",
                     {
-                      src: launcherIcon,
+                      src: config.launcher.icon,
                       alt: "",
                       "aria-hidden": "true",
                       style: {
@@ -5433,16 +6213,16 @@ function ShadowCanvasOverlay({
                       focusable: "false",
                       style: { transition: "transform 200ms ease" },
                       children: [
-                        /* @__PURE__ */ jsx7("path", { d: "M12 3l1.912 5.813a2 2 0 0 0 1.275 1.275L21 12l-5.813 1.912a2 2 0 0 0-1.275 1.275L12 21l-1.912-5.813a2 2 0 0 0-1.275-1.275L3 12l5.813-1.912a2 2 0 0 0 1.275-1.275L12 3Z" }),
-                        /* @__PURE__ */ jsx7("path", { d: "M5 3v4" }),
-                        /* @__PURE__ */ jsx7("path", { d: "M3 5h4" }),
-                        /* @__PURE__ */ jsx7("path", { d: "M19 17v4" }),
-                        /* @__PURE__ */ jsx7("path", { d: "M17 19h4" })
+                        /* @__PURE__ */ jsx8("path", { d: "M12 3l1.912 5.813a2 2 0 0 0 1.275 1.275L21 12l-5.813 1.912a2 2 0 0 0-1.275 1.275L12 21l-1.912-5.813a2 2 0 0 0-1.275-1.275L3 12l5.813-1.912a2 2 0 0 0 1.275-1.275L12 3Z" }),
+                        /* @__PURE__ */ jsx8("path", { d: "M5 3v4" }),
+                        /* @__PURE__ */ jsx8("path", { d: "M3 5h4" }),
+                        /* @__PURE__ */ jsx8("path", { d: "M19 17v4" }),
+                        /* @__PURE__ */ jsx8("path", { d: "M17 19h4" })
                       ]
                     }
                   ),
                   !isOpen && notifications.length > 0 && /* @__PURE__ */ jsxs3("div", { style: { position: "absolute", top: -2, right: -2, pointerEvents: "none" }, children: [
-                    /* @__PURE__ */ jsx7(
+                    /* @__PURE__ */ jsx8(
                       "span",
                       {
                         className: "syntro-badge-ping",
@@ -5454,7 +6234,7 @@ function ShadowCanvasOverlay({
                         }
                       }
                     ),
-                    /* @__PURE__ */ jsx7(
+                    /* @__PURE__ */ jsx8(
                       "span",
                       {
                         className: "syntro-badge-glow",
@@ -5465,7 +6245,7 @@ function ShadowCanvasOverlay({
                         }
                       }
                     ),
-                    /* @__PURE__ */ jsx7(
+                    /* @__PURE__ */ jsx8(
                       "span",
                       {
                         className: "syntro-badge-bounce",
@@ -5504,6 +6284,14 @@ var sortTiles = (tiles) => [...tiles].sort((a, b) => {
   var _a2, _b;
   return ((_a2 = b.priority) != null ? _a2 : 0) - ((_b = a.priority) != null ? _b : 0);
 });
+function fireTriggeredForTiles(tiles) {
+  var _a2, _b;
+  const tracker = typeof window !== "undefined" ? (_a2 = window.SynOS) == null ? void 0 : _a2.interventionTracker : null;
+  if (!tracker) return;
+  for (const tile of tiles) {
+    tracker.trackTriggered(tile.id, (_b = tile.widget) != null ? _b : "unknown");
+  }
+}
 function useShadowCanvasConfig({
   fetcher,
   experiments,
@@ -5526,6 +6314,7 @@ function useShadowCanvasConfig({
     if (experiments) {
       tiles = tiles.filter((tile) => experiments.shouldRenderRectangle(tile));
     }
+    fireTriggeredForTiles(tiles);
     setState((prev) => ({ ...prev, tiles: sortTiles(tiles) }));
   }, [runtime3, experiments]);
   const load = useCallback5(async () => {
@@ -5543,6 +6332,7 @@ function useShadowCanvasConfig({
       } else if (experiments) {
         tiles = tiles.filter((tile) => experiments.shouldRenderRectangle(tile));
       }
+      fireTriggeredForTiles(tiles);
       debug("SmartCanvas Config", `Tile count after filtering: ${tiles.length}`);
       const newActions = response.actions || [];
       const newActionsJson = JSON.stringify(newActions);
@@ -5600,13 +6390,13 @@ function useShadowCanvasConfig({
 
 // src/SmartCanvasApp.tsx
 import { useEffect as useEffect9, useMemo as useMemo7, useRef as useRef7, useState as useState7 } from "react";
-import { jsx as jsx8 } from "react/jsx-runtime";
+import { jsx as jsx9 } from "react/jsx-runtime";
 function SmartCanvasApp({
   controller,
   fetcher,
   configUri,
-  configUriFeatureKey = "smart-canvas-config-uri",
-  configFeatureKey = "smart-canvas-config",
+  configUriFeatureKey,
+  configFeatureKey,
   fetchCredentials = "include",
   pollIntervalMs,
   experiments,
@@ -5623,7 +6413,7 @@ function SmartCanvasApp({
   workspaceTheme
 }) {
   if (runtime3) {
-    return /* @__PURE__ */ jsx8(RuntimeProvider, { runtime: runtime3, children: /* @__PURE__ */ jsx8(
+    return /* @__PURE__ */ jsx9(RuntimeProvider, { runtime: runtime3, children: /* @__PURE__ */ jsx9(
       SmartCanvasAppInner,
       {
         controller,
@@ -5648,7 +6438,7 @@ function SmartCanvasApp({
       }
     ) });
   }
-  return /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsx9(
     SmartCanvasAppInner,
     {
       controller,
@@ -5676,10 +6466,10 @@ function SmartCanvasAppInner({
   controller,
   fetcher,
   configUri,
-  configUriFeatureKey = "smart-canvas-config-uri",
-  configFeatureKey = "smart-canvas-config",
+  configUriFeatureKey,
+  configFeatureKey,
   fetchCredentials = "include",
-  pollIntervalMs,
+  pollIntervalMs: _pollIntervalMs,
   experiments,
   telemetry,
   runtime: runtime3,
@@ -5693,7 +6483,7 @@ function SmartCanvasAppInner({
   initialBatchHandle,
   workspaceTheme
 }) {
-  var _a2, _b, _c, _d, _e, _f, _g;
+  var _a2, _b, _c, _d, _e, _f;
   const [open, setOpen] = useState7(controller.getState().open);
   const pageContext = usePageContext();
   const [localUrl, setLocalUrl] = useState7(
@@ -5749,6 +6539,7 @@ function SmartCanvasAppInner({
   const batchHandleRef = useRef7(initialBatchHandle != null ? initialBatchHandle : null);
   const adoptedInitialRef = useRef7(!!initialBatchHandle);
   const runVersionRef = useRef7(0);
+  const pendingRevertRef = useRef7(null);
   useEffect9(() => {
     if (!(runtime3 == null ? void 0 : runtime3.actions)) return;
     if (adoptedInitialRef.current) {
@@ -5760,6 +6551,10 @@ function SmartCanvasAppInner({
     const version = ++runVersionRef.current;
     const stale = () => version !== runVersionRef.current;
     const run = async () => {
+      if (pendingRevertRef.current) {
+        await pendingRevertRef.current;
+        pendingRevertRef.current = null;
+      }
       if (batchHandleRef.current) {
         try {
           await batchHandleRef.current.revertAll();
@@ -5787,7 +6582,7 @@ function SmartCanvasAppInner({
     run();
     return () => {
       if (batchHandleRef.current) {
-        batchHandleRef.current.revertAll().catch((err) => {
+        pendingRevertRef.current = batchHandleRef.current.revertAll().catch((err) => {
           console.error("[SmartCanvasApp] Failed to revert actions on cleanup:", err);
         });
         batchHandleRef.current = null;
@@ -5803,16 +6598,13 @@ function SmartCanvasAppInner({
   }, [runtime3, controller]);
   const { shadowRoot } = useShadowRoot();
   const themeConfig = configState.theme;
-  if (!configState.isLoading && !hasContent) {
-    return null;
-  }
-  return /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsx9(
     ThemeProvider,
     {
       themeConfig,
       workspaceTheme,
       shadowRoot,
-      children: /* @__PURE__ */ jsx8(
+      children: !configState.isLoading && !hasContent ? null : /* @__PURE__ */ jsx9(
         ShadowCanvasOverlay,
         {
           tiles: configState.tiles,
@@ -5821,10 +6613,9 @@ function SmartCanvasAppInner({
           canvasTitle: configState.canvasTitle,
           telemetry,
           launcherLabel: launcherLabel != null ? launcherLabel : (_b = configState.launcher) == null ? void 0 : _b.label,
-          launcherIcon: (_c = configState.launcher) == null ? void 0 : _c.icon,
-          launcherAnimate: (_d = configState.launcher) == null ? void 0 : _d.animate,
-          launcherAnimationStyle: (_e = configState.launcher) == null ? void 0 : _e.animationStyle,
-          notificationCount: (_g = (_f = configState.launcher) == null ? void 0 : _f.notificationCount) != null ? _g : configState.tiles.length,
+          launcherAnimate: (_c = configState.launcher) == null ? void 0 : _c.animate,
+          launcherAnimationStyle: (_d = configState.launcher) == null ? void 0 : _d.animationStyle,
+          notificationCount: (_f = (_e = configState.launcher) == null ? void 0 : _e.notificationCount) != null ? _f : configState.tiles.length,
           footerSlot,
           isOpen: open,
           onToggle: () => controller.toggle(),
@@ -5837,7 +6628,7 @@ function SmartCanvasAppInner({
 
 // src/SmartCanvasElement.tsx
 import { createRoot as createRoot2 } from "react-dom/client";
-import { jsx as jsx9 } from "react/jsx-runtime";
+import { jsx as jsx10 } from "react/jsx-runtime";
 var TAG_NAME = "smart-canvas";
 var BASE_CSS = `
 :host {
@@ -5938,13 +6729,13 @@ var SmartCanvasElement = class extends HTMLElement {
       __privateSet(this, _root, createRoot2(__privateGet(this, _mount)));
     }
     __privateGet(this, _root).render(
-      /* @__PURE__ */ jsx9(
+      /* @__PURE__ */ jsx10(
         ShadowRootProvider,
         {
           shadowRoot: __privateGet(this, _shadow),
           portalRoot: __privateGet(this, _portalRoot),
           overlayContainer: __privateGet(this, _overlayContainer),
-          children: /* @__PURE__ */ jsx9(SmartCanvasApp, { ...__privateGet(this, _lastAppProps), controller: __privateGet(this, _controller), canvasHost: this })
+          children: /* @__PURE__ */ jsx10(SmartCanvasApp, { ...__privateGet(this, _lastAppProps), controller: __privateGet(this, _controller), canvasHost: this })
         }
       )
     );
@@ -6513,7 +7304,7 @@ var createSmartCanvas = async (config = {}) => {
         console.log(
           "[SmartCanvas] Actions to apply:",
           canvasConfig.actions.map(
-            (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${typeof a.anchorId === "string" ? a.anchorId : a.anchorId.selector}"` : ""}${a.label ? ` "${a.label}"` : ""}`
+            (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${a.anchorId.selector}"` : ""}${a.label ? ` "${a.label}"` : ""}`
           ).join(", ")
         );
       }
@@ -6964,17 +7755,18 @@ var PostHogAdapter = class {
     __publicField(this, "client");
     __publicField(this, "featureFlagsCallback");
     __publicField(this, "captureCallback");
-    __publicField(this, "consentUnsub");
+    __publicField(this, "rrwebCallback");
     this.client = options.client;
     this.featureFlagsCallback = options.onFeatureFlagsLoaded;
     this.captureCallback = options.onCapture;
+    this.rrwebCallback = options.onRRWebEvent;
     if (!this.client && options.consent && options.requireExplicitConsent && typeof window !== "undefined" && options.apiKey) {
       const consent = options.consent;
       const currentStatus = consent.getStatus();
       if (currentStatus === "granted") {
         this.initPostHog();
       }
-      this.consentUnsub = consent.subscribe((status) => {
+      consent.subscribe((status) => {
         if (status === "granted") {
           if (!this.client) {
             this.initPostHog();
@@ -7001,68 +7793,117 @@ var PostHogAdapter = class {
     if (!options.apiKey) return;
     const enableFeatureFlags = (_a2 = options.enableFeatureFlags) != null ? _a2 : true;
     const instanceName = `syntro_${options.apiKey.slice(-6) || "sdk"}`;
-    this.client = posthog.init(
-      options.apiKey,
-      {
-        api_host: (_b = options.apiHost) != null ? _b : "https://telemetry.syntrologie.com",
-        // Feature flags for segment membership (in_segment_* flags)
-        // When enabled, /decide is called to get segment flags
-        advanced_disable_feature_flags: !enableFeatureFlags,
-        advanced_disable_feature_flags_on_first_load: !enableFeatureFlags,
-        // Full-page tracking - all ON by default
-        autocapture: (_c = options.autocapture) != null ? _c : true,
-        capture_pageview: (_d = options.capturePageview) != null ? _d : true,
-        capture_pageleave: (_e = options.capturePageleave) != null ? _e : true,
-        disable_session_recording: !((_f = options.sessionRecording) != null ? _f : true),
-        // CRITICAL: Disable user agent filtering to allow headless Chrome
-        // PostHog blocks "HeadlessChrome" user agents by default as bot detection
-        // This enables session recording in Playwright/crawler sessions
-        opt_out_useragent_filter: true,
-        // Cross-domain iframe recording for embeds
-        session_recording: {
-          recordCrossDomainIFrames: true
-        },
-        // Capture performance metrics
-        capture_performance: true,
-        // Enable web vitals
-        enable_recording_console_log: true,
-        // Bootstrap callback for when flags are loaded
-        loaded: (ph) => {
-          if (enableFeatureFlags && this.featureFlagsCallback) {
-            ph.onFeatureFlags(() => {
-              const allFlags = this.getAllFeatureFlags();
-              if (allFlags && this.featureFlagsCallback) {
-                this.featureFlagsCallback(allFlags);
-              }
-            });
-            const existingFlags = this.getAllFeatureFlags();
-            if (existingFlags && Object.keys(existingFlags).length > 0) {
-              this.featureFlagsCallback(existingFlags);
-            }
-          }
-          if (this.captureCallback) {
-            ph.on("eventCaptured", (data) => {
-              var _a3;
-              const eventName = typeof data === "string" ? data : data == null ? void 0 : data.event;
-              const properties = typeof data === "string" ? void 0 : data == null ? void 0 : data.properties;
-              if (typeof eventName === "string") {
-                (_a3 = this.captureCallback) == null ? void 0 : _a3.call(this, eventName, properties);
-              }
-            });
-          }
-        }
+    const initOptions = {
+      api_host: (_b = options.apiHost) != null ? _b : "https://telemetry.syntrologie.com",
+      // Feature flags for segment membership (in_segment_* flags)
+      // When enabled, /decide is called to get segment flags
+      advanced_disable_feature_flags: !enableFeatureFlags,
+      advanced_disable_feature_flags_on_first_load: !enableFeatureFlags,
+      // Full-page tracking - all ON by default
+      autocapture: (_c = options.autocapture) != null ? _c : true,
+      capture_pageview: (_d = options.capturePageview) != null ? _d : "history_change",
+      capture_pageleave: (_e = options.capturePageleave) != null ? _e : true,
+      disable_session_recording: !((_f = options.sessionRecording) != null ? _f : true),
+      // CRITICAL: Disable user agent filtering to allow headless Chrome
+      // PostHog blocks "HeadlessChrome" user agents by default as bot detection
+      // This enables session recording in Playwright/crawler sessions
+      opt_out_useragent_filter: true,
+      // Cross-domain iframe recording for embeds
+      session_recording: {
+        recordCrossDomainIFrames: true
       },
+      // Capture performance metrics
+      capture_performance: true,
+      // Enable web vitals
+      enable_recording_console_log: true
+    };
+    const result = posthog.init(
+      options.apiKey,
+      initOptions,
       instanceName
     );
+    if (result) {
+      this.client = result;
+    }
+    if (this.captureCallback && this.client) {
+      this.client.on("eventCaptured", (...args) => {
+        var _a3;
+        const data = args[0];
+        const eventName = typeof data === "string" ? data : data == null ? void 0 : data.event;
+        const properties = typeof data === "string" ? void 0 : data == null ? void 0 : data.properties;
+        if (typeof eventName === "string") {
+          (_a3 = this.captureCallback) == null ? void 0 : _a3.call(this, eventName, properties);
+        }
+      });
+    }
+    if (enableFeatureFlags && this.featureFlagsCallback && this.client) {
+      this.client.onFeatureFlags(() => {
+        const allFlags = this.getAllFeatureFlags();
+        if (allFlags && this.featureFlagsCallback) {
+          this.featureFlagsCallback(allFlags);
+        }
+      });
+      const existingFlags = this.getAllFeatureFlags();
+      if (existingFlags && Object.keys(existingFlags).length > 0) {
+        this.featureFlagsCallback(existingFlags);
+      }
+    }
+    if (this.rrwebCallback && this.client) {
+      this.setupRRWebIntercept();
+    }
+  }
+  /**
+   * Set up rrweb event interception on PostHog's session recording.
+   *
+   * PostHog lazy-loads the rrweb recorder. The SessionRecording wrapper has
+   * an `onRRwebEmit` method, but rrweb delivers events directly to the
+   * lazy-loaded recorder instance's `onRRwebEmit`, bypassing the wrapper.
+   * We must find and patch the recorder instance, not the wrapper.
+   *
+   * The recorder instance is stored on a minified property of SessionRecording.
+   * We detect it by looking for an object with both `onRRwebEmit` and `start` methods.
+   */
+  setupRRWebIntercept(retries = 30) {
+    var _a2;
+    const sr = (_a2 = this.client) == null ? void 0 : _a2.sessionRecording;
+    if (!sr) {
+      if (retries > 0) {
+        setTimeout(() => this.setupRRWebIntercept(retries - 1), 500);
+      }
+      return;
+    }
+    let recorder = null;
+    const srRecord = sr;
+    for (const key of Object.getOwnPropertyNames(srRecord)) {
+      const val = srRecord[key];
+      if (val && typeof val === "object" && typeof val.onRRwebEmit === "function" && typeof val.start === "function" && val !== sr) {
+        recorder = val;
+        break;
+      }
+    }
+    if (!recorder) {
+      if (retries > 0) {
+        setTimeout(() => this.setupRRWebIntercept(retries - 1), 500);
+      }
+      return;
+    }
+    const originalEmit = recorder.onRRwebEmit.bind(recorder);
+    recorder.onRRwebEmit = (rawEvent) => {
+      var _a3;
+      (_a3 = this.rrwebCallback) == null ? void 0 : _a3.call(this, { kind: "rrweb", ...rawEvent });
+      originalEmit(rawEvent);
+    };
+    if (typeof window !== "undefined") {
+      window.__RRWEB_INTERCEPT_READY__ = true;
+    }
   }
   /**
    * Get all feature flags from PostHog.
    * Used to extract segment membership flags (in_segment_*).
    */
   getAllFeatureFlags() {
-    var _a2, _b, _c;
-    const flags = (_c = (_b = (_a2 = this.client) == null ? void 0 : _a2.featureFlags) == null ? void 0 : _b.getFlagVariants) == null ? void 0 : _c.call(_b);
-    return flags;
+    var _a2, _b;
+    return (_b = (_a2 = this.client) == null ? void 0 : _a2.featureFlags) == null ? void 0 : _b.getFlagVariants();
   }
   /**
    * Get segment membership flags (in_segment_*) from PostHog.
@@ -7143,6 +7984,59 @@ function createPostHogClient(options = {}) {
   return new PostHogAdapter(options);
 }
 
+// src/telemetry/InterventionTracker.ts
+var InterventionTracker = class {
+  constructor(telemetry, variantId) {
+    __publicField(this, "telemetry");
+    __publicField(this, "variantId");
+    __publicField(this, "seenSet", /* @__PURE__ */ new Set());
+    __publicField(this, "triggeredSet", /* @__PURE__ */ new Set());
+    this.telemetry = telemetry;
+    this.variantId = variantId;
+  }
+  trackServed(tiles, actions) {
+    var _a2, _b;
+    (_b = (_a2 = this.telemetry).track) == null ? void 0 : _b.call(_a2, "syntro_config_served", {
+      variant_id: this.variantId,
+      tiles,
+      actions
+    });
+  }
+  trackSeen(interventionId, interventionKind) {
+    var _a2, _b;
+    if (this.seenSet.has(interventionId)) return;
+    this.seenSet.add(interventionId);
+    (_b = (_a2 = this.telemetry).track) == null ? void 0 : _b.call(_a2, "syntro_intervention_seen", {
+      variant_id: this.variantId,
+      intervention_id: interventionId,
+      intervention_kind: interventionKind
+    });
+  }
+  trackTriggered(interventionId, interventionKind) {
+    var _a2, _b;
+    if (this.triggeredSet.has(interventionId)) return;
+    this.triggeredSet.add(interventionId);
+    (_b = (_a2 = this.telemetry).track) == null ? void 0 : _b.call(_a2, "syntro_intervention_triggered", {
+      variant_id: this.variantId,
+      intervention_id: interventionId,
+      intervention_kind: interventionKind
+    });
+  }
+  trackInteracted(interventionId, interventionKind, interactionType) {
+    var _a2, _b;
+    (_b = (_a2 = this.telemetry).track) == null ? void 0 : _b.call(_a2, "syntro_intervention_interacted", {
+      variant_id: this.variantId,
+      intervention_id: interventionId,
+      intervention_kind: interventionKind,
+      interaction_type: interactionType
+    });
+  }
+  resetPage() {
+    this.seenSet.clear();
+    this.triggeredSet.clear();
+  }
+};
+
 // src/actions/executors/core-flow.ts
 var executeSequence = async (action, context) => {
   const handles = [];
@@ -7413,158 +8307,7 @@ function hasExecutor(kind) {
   return executorRegistry.has(kind);
 }
 
-// src/actions/validation.ts
-var DANGEROUS_ATTRS = /* @__PURE__ */ new Set([
-  "onclick",
-  "onerror",
-  "onload",
-  "onmouseover",
-  "onfocus",
-  "onblur",
-  "onchange",
-  "onsubmit",
-  "onkeydown",
-  "onkeyup",
-  "onkeypress"
-]);
-var MAX_HTML_LENGTH = 5e4;
-var MAX_STYLE_COUNT = 50;
-function validateAction(action) {
-  const errors = [];
-  const warnings = [];
-  if (!action || typeof action !== "object") {
-    errors.push({
-      code: "INVALID_ACTION",
-      message: "Action must be an object"
-    });
-    return { valid: false, errors, warnings };
-  }
-  const { kind } = action;
-  if (!kind || typeof kind !== "string") {
-    errors.push({
-      code: "MISSING_KIND",
-      message: "Action must have a 'kind' property"
-    });
-    return { valid: false, errors, warnings };
-  }
-  if (!hasExecutor(kind) && kind !== "core:mountWidget") {
-    const registered = executorRegistry.list();
-    console.error(
-      `[ActionValidation] Unknown action kind: "${kind}". Registered kinds (${registered.length}): [${registered.join(", ")}]. This usually means the app that provides "${kind}" hasn't been activated yet, or the executor was never registered in ExecutorRegistry.`
-    );
-    errors.push({
-      code: "UNKNOWN_KIND",
-      message: `Unknown action kind: ${kind}`,
-      field: "kind"
-    });
-    return { valid: false, errors, warnings };
-  }
-  switch (kind) {
-    case "overlays:highlight":
-    case "overlays:pulse":
-    case "navigation:scrollTo":
-      validateAnchorAction(action, errors, warnings);
-      break;
-    case "overlays:badge":
-      validateAnchorAction(action, errors, warnings);
-      validateBadgeAction(action, errors, warnings);
-      break;
-    case "overlays:tooltip":
-      validateAnchorAction(action, errors, warnings);
-      validateTooltipAction(action, errors, warnings);
-      break;
-    case "overlays:modal":
-      validateModalAction(action, errors, warnings);
-      break;
-    case "content:insertHtml":
-      validateAnchorAction(action, errors, warnings);
-      validateInsertHtmlAction(action, errors, warnings);
-      break;
-    case "content:setText":
-      validateAnchorAction(action, errors, warnings);
-      validateSetTextAction(action, errors, warnings);
-      break;
-    case "content:setAttr":
-      validateAnchorAction(action, errors, warnings);
-      validateSetAttrAction(action, errors, warnings);
-      break;
-    case "content:addClass":
-    case "content:removeClass":
-      validateAnchorAction(action, errors, warnings);
-      validateClassAction(action, errors, warnings);
-      break;
-    case "content:setStyle":
-      validateAnchorAction(action, errors, warnings);
-      validateSetStyleAction(action, errors, warnings);
-      break;
-    case "core:mountWidget":
-      validateMountWidgetAction(action, errors, warnings);
-      break;
-    case "core:wait":
-      validateWaitAction(action, errors, warnings);
-      break;
-    case "core:sequence":
-      validateSequenceAction(action, errors, warnings);
-      break;
-    case "core:parallel":
-      validateParallelAction(action, errors, warnings);
-      break;
-    case "core:tour":
-      validateTourAction(action, errors, warnings);
-      break;
-    case "navigation:navigate":
-      validateNavigateAction(action, errors, warnings);
-      break;
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-function validateAnchorAction(action, errors, warnings) {
-  const anchorId = action.anchorId;
-  if (!anchorId || typeof anchorId !== "object") {
-    errors.push({
-      code: "MISSING_ANCHOR_ID",
-      message: "Action requires an 'anchorId' object with a 'selector' string",
-      field: "anchorId"
-    });
-    return;
-  }
-  if (!anchorId.selector || typeof anchorId.selector !== "string") {
-    errors.push({
-      code: "MISSING_ANCHOR_SELECTOR",
-      message: "anchorId requires a 'selector' string",
-      field: "anchorId.selector"
-    });
-  } else if (anchorId.selector.length > 200) {
-    warnings.push({
-      code: "LONG_ANCHOR_ID",
-      message: "Anchor selector is unusually long",
-      suggestion: "Consider using a shorter, more descriptive selector"
-    });
-  }
-  if (anchorId.route === void 0 || anchorId.route === null) {
-    errors.push({
-      code: "MISSING_ANCHOR_ROUTE",
-      message: `anchorId requires a 'route' (string or array of strings). Use "**" for all routes.`,
-      field: "anchorId.route"
-    });
-  } else {
-    const routes = Array.isArray(anchorId.route) ? anchorId.route : [anchorId.route];
-    for (const route of routes) {
-      if (typeof route !== "string") {
-        errors.push({
-          code: "INVALID_ANCHOR_ROUTE",
-          message: "anchorId.route must be a string or array of strings",
-          field: "anchorId.route"
-        });
-        break;
-      }
-    }
-  }
-}
+// src/actions/validation-rules.ts
 function validateBadgeAction(action, errors, warnings) {
   if (!action.content || typeof action.content !== "string") {
     errors.push({
@@ -7951,29 +8694,182 @@ function validateTourAction(action, errors, warnings) {
     }
   }
 }
-function validateActions(actions) {
-  var _a2;
+
+// src/actions/validation-core.ts
+var DANGEROUS_ATTRS = /* @__PURE__ */ new Set([
+  "onclick",
+  "onerror",
+  "onload",
+  "onmouseover",
+  "onfocus",
+  "onblur",
+  "onchange",
+  "onsubmit",
+  "onkeydown",
+  "onkeyup",
+  "onkeypress"
+]);
+var MAX_HTML_LENGTH = 5e4;
+var MAX_STYLE_COUNT = 50;
+function validateAction(action) {
   const errors = [];
   const warnings = [];
-  if (!Array.isArray(actions)) {
-    console.error("[ActionValidation] validateActions called with non-array:", typeof actions);
+  if (!action || typeof action !== "object") {
     errors.push({
-      code: "INVALID_ACTIONS",
-      message: "Actions must be an array"
+      code: "INVALID_ACTION",
+      message: "Action must be an object"
     });
     return { valid: false, errors, warnings };
   }
-  for (let i = 0; i < actions.length; i++) {
-    const result = validateAction(actions[i]);
-    if (!result.valid) {
-      const action = actions[i];
-      console.error(
-        `[ActionValidation] Action [${i}] failed validation:`,
-        `kind="${(_a2 = action == null ? void 0 : action.kind) != null ? _a2 : "undefined"}"`,
-        result.errors.map((e) => `${e.code}: ${e.message}`).join("; "),
-        action
-      );
-    }
+  const { kind } = action;
+  if (!kind || typeof kind !== "string") {
+    errors.push({
+      code: "MISSING_KIND",
+      message: "Action must have a 'kind' property"
+    });
+    return { valid: false, errors, warnings };
+  }
+  if (!hasExecutor(kind) && kind !== "core:mountWidget") {
+    const registered = executorRegistry.list();
+    console.error(
+      `[ActionValidation] Unknown action kind: "${kind}". Registered kinds (${registered.length}): [${registered.join(", ")}]. This usually means the app that provides "${kind}" hasn't been activated yet, or the executor was never registered in ExecutorRegistry.`
+    );
+    errors.push({
+      code: "UNKNOWN_KIND",
+      message: `Unknown action kind: ${kind}`,
+      field: "kind"
+    });
+    return { valid: false, errors, warnings };
+  }
+  switch (kind) {
+    case "overlays:highlight":
+    case "overlays:pulse":
+    case "navigation:scrollTo":
+      validateAnchorAction(action, errors, warnings);
+      break;
+    case "overlays:badge":
+      validateAnchorAction(action, errors, warnings);
+      validateBadgeAction(action, errors, warnings);
+      break;
+    case "overlays:tooltip":
+      validateAnchorAction(action, errors, warnings);
+      validateTooltipAction(action, errors, warnings);
+      break;
+    case "overlays:modal":
+      validateModalAction(action, errors, warnings);
+      break;
+    case "content:insertHtml":
+      validateAnchorAction(action, errors, warnings);
+      validateInsertHtmlAction(action, errors, warnings);
+      break;
+    case "content:setText":
+      validateAnchorAction(action, errors, warnings);
+      validateSetTextAction(action, errors, warnings);
+      break;
+    case "content:setAttr":
+      validateAnchorAction(action, errors, warnings);
+      validateSetAttrAction(action, errors, warnings);
+      break;
+    case "content:addClass":
+    case "content:removeClass":
+      validateAnchorAction(action, errors, warnings);
+      validateClassAction(action, errors, warnings);
+      break;
+    case "content:setStyle":
+      validateAnchorAction(action, errors, warnings);
+      validateSetStyleAction(action, errors, warnings);
+      break;
+    case "core:mountWidget":
+      validateMountWidgetAction(action, errors, warnings);
+      break;
+    case "core:wait":
+      validateWaitAction(action, errors, warnings);
+      break;
+    case "core:sequence":
+      validateSequenceAction(action, errors, warnings);
+      break;
+    case "core:parallel":
+      validateParallelAction(action, errors, warnings);
+      break;
+    case "overlays:tour":
+      validateTourAction(action, errors, warnings);
+      break;
+    case "navigation:navigate":
+      validateNavigateAction(action, errors, warnings);
+      break;
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateAnchorAction(action, errors, warnings) {
+  const anchorId = action.anchorId;
+  if (!anchorId || typeof anchorId !== "object") {
+    errors.push({
+      code: "MISSING_ANCHOR_ID",
+      message: "Action requires an 'anchorId' object with a 'selector' string",
+      field: "anchorId"
+    });
+    return;
+  }
+  if (!anchorId.selector || typeof anchorId.selector !== "string") {
+    errors.push({
+      code: "MISSING_ANCHOR_SELECTOR",
+      message: "anchorId requires a 'selector' string",
+      field: "anchorId.selector"
+    });
+  } else if (anchorId.selector.length > 200) {
+    warnings.push({
+      code: "LONG_ANCHOR_ID",
+      message: "Anchor selector is unusually long",
+      suggestion: "Consider using a shorter, more descriptive selector"
+    });
+  }
+  if (anchorId.route === void 0 || anchorId.route === null) {
+    errors.push({
+      code: "MISSING_ANCHOR_ROUTE",
+      message: `anchorId requires a 'route' (string or array of strings). Use "**" for all routes.`,
+      field: "anchorId.route"
+    });
+  } else {
+    const routes = Array.isArray(anchorId.route) ? anchorId.route : [anchorId.route];
+    for (const route of routes) {
+      if (typeof route !== "string") {
+        errors.push({
+          code: "INVALID_ANCHOR_ROUTE",
+          message: "anchorId.route must be a string or array of strings",
+          field: "anchorId.route"
+        });
+        break;
+      }
+    }
+  }
+}
+function validateActions(actions) {
+  var _a2;
+  const errors = [];
+  const warnings = [];
+  if (!Array.isArray(actions)) {
+    console.error("[ActionValidation] validateActions called with non-array:", typeof actions);
+    errors.push({
+      code: "INVALID_ACTIONS",
+      message: "Actions must be an array"
+    });
+    return { valid: false, errors, warnings };
+  }
+  for (let i = 0; i < actions.length; i++) {
+    const result = validateAction(actions[i]);
+    if (!result.valid) {
+      const action = actions[i];
+      console.error(
+        `[ActionValidation] Action [${i}] failed validation:`,
+        `kind="${(_a2 = action == null ? void 0 : action.kind) != null ? _a2 : "undefined"}"`,
+        result.errors.map((e) => `${e.code}: ${e.message}`).join("; "),
+        action
+      );
+    }
     for (const error2 of result.errors) {
       errors.push({
         ...error2,
@@ -8097,7 +8993,7 @@ function createActionEngine(options) {
     }
     return executor(action, context);
   }
-  function subscribeForReeval(id, action, triggerWhen, handle) {
+  function subscribeForReeval(id, action, triggerWhen, _handle) {
     if (!runtime3) return;
     const unsubs = [];
     const onReeval = async () => {
@@ -8241,13 +9137,9 @@ function createActionEngine(options) {
           entry2.state = "reverted";
           publishEvent("action.reverted", { id, kind: action.kind });
         } catch (error2) {
-          entry2.state = "failed";
-          publishEvent("action.failed", {
-            id,
-            kind: action.kind,
-            error: String(error2)
-          });
-          throw error2;
+          console.warn(`[ActionEngine] Cleanup error for ${action.kind} (${id}), ignoring:`, error2);
+          entry2.state = "reverted";
+          publishEvent("action.reverted", { id, kind: action.kind });
         } finally {
           activeActions.delete(id);
         }
@@ -8291,7 +9183,7 @@ function createActionEngine(options) {
         errorMessages,
         "\nActions:",
         actions.map(
-          (a, i) => `  [${i}] ${a.kind} ${a.anchorId ? `anchor="${typeof a.anchorId === "string" ? a.anchorId : a.anchorId.selector}"` : ""} ${a.label ? `label="${a.label}"` : ""}`
+          (a, i) => `  [${i}] ${a.kind} ${a.anchorId ? `anchor="${a.anchorId.selector}"` : ""} ${a.label ? `label="${a.label}"` : ""}`
         ).join("\n")
       );
       throw new Error(`Batch validation failed: ${errorMessages}`);
@@ -8300,15 +9192,30 @@ function createActionEngine(options) {
     const handles = [];
     const appliedHandles = [];
     try {
-      for (const action of actions) {
-        const handle = await apply(action);
-        handles.push(handle);
-        appliedHandles.push(handle);
+      const results = await Promise.allSettled(actions.map((action) => apply(action)));
+      const errors = [];
+      for (const result of results) {
+        if (result.status === "fulfilled") {
+          handles.push(result.value);
+          appliedHandles.push(result.value);
+        } else {
+          errors.push(
+            result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+          );
+        }
+      }
+      if (errors.length > 0 && appliedHandles.length === 0) {
+        throw errors[0];
+      }
+      if (errors.length > 0) {
+        console.warn(
+          `[ActionEngine] ${errors.length}/${actions.length} action(s) failed in batch:`,
+          errors.map((e) => e.message).join("; ")
+        );
       }
     } catch (error2) {
       console.error(
-        `[ActionEngine] Batch apply FAILED at action ${appliedHandles.length + 1}/${actions.length}.`,
-        `Successfully applied: ${appliedHandles.length}. Rolling back...`,
+        `[ActionEngine] Batch apply FAILED. Successfully applied: ${appliedHandles.length}. Rolling back...`,
         error2
       );
       for (const handle of appliedHandles) {
@@ -8391,6 +9298,7 @@ function createAnchorResolver(opts) {
   function resolve(selector) {
     if (!root) return null;
     try {
+      if (root.matches(selector)) return root;
       return root.querySelector(selector);
     } catch {
       return null;
@@ -8736,7 +9644,7 @@ function createContextManager(options) {
 
 // src/decisions/strategies/rules.ts
 function evaluateCondition(condition, evalContext) {
-  var _a2, _b, _c, _d, _e, _f, _g;
+  var _a2, _b, _c, _d, _e;
   const { context, state, events } = evalContext;
   switch (condition.type) {
     case "page_url": {
@@ -8750,8 +9658,7 @@ function evaluateCondition(condition, evalContext) {
       return context.page.routeId === condition.routeId;
     }
     case "anchor_visible": {
-      const condSelector = typeof condition.anchorId === "string" ? condition.anchorId : (_b = (_a2 = condition.anchorId) == null ? void 0 : _a2.selector) != null ? _b : "";
-      const anchor = (_c = context.anchors) == null ? void 0 : _c.find((a) => a.anchorId === condSelector);
+      const anchor = (_a2 = context.anchors) == null ? void 0 : _a2.find((a) => a.anchorId === condition.anchorId);
       switch (condition.state) {
         case "visible":
           return (anchor == null ? void 0 : anchor.visible) === true;
@@ -8765,7 +9672,7 @@ function evaluateCondition(condition, evalContext) {
     }
     case "event_occurred": {
       if (!events) return false;
-      const withinMs = (_d = condition.withinMs) != null ? _d : 6e4;
+      const withinMs = (_b = condition.withinMs) != null ? _b : 6e4;
       return events.hasRecentEvent(condition.eventName, withinMs);
     }
     case "state_equals": {
@@ -8801,17 +9708,17 @@ function evaluateCondition(condition, evalContext) {
       }
     }
     case "dismissed": {
-      if (!state) return (_e = condition.inverted) != null ? _e : false;
+      if (!state) return (_c = condition.inverted) != null ? _c : false;
       const isDismissed = state.isDismissed(condition.key);
       return condition.inverted ? !isDismissed : isDismissed;
     }
     case "cooldown_active": {
-      if (!state) return (_f = condition.inverted) != null ? _f : false;
+      if (!state) return (_d = condition.inverted) != null ? _d : false;
       const isActive = state.isCooldownActive(condition.key);
       return condition.inverted ? !isActive : isActive;
     }
     case "frequency_limit": {
-      if (!state) return (_g = condition.inverted) != null ? _g : false;
+      if (!state) return (_e = condition.inverted) != null ? _e : false;
       const count = state.getFrequencyCount(condition.key);
       const limitReached = count >= condition.limit;
       return condition.inverted ? !limitReached : limitReached;
@@ -9071,6 +9978,66 @@ function createEventAccumulator(options) {
   };
 }
 
+// src/events/validation.ts
+var APP_PREFIX = "app:";
+var RESERVED_PREFIX = "syntro:";
+var SEGMENT_PATTERN = /^[a-z][a-z0-9_]*$/;
+function validateEventName(name) {
+  if (!name) {
+    return { valid: false, reason: "Event name cannot be empty" };
+  }
+  if (name.startsWith(RESERVED_PREFIX)) {
+    return { valid: false, reason: '"syntro:" prefix is reserved for internal SDK events' };
+  }
+  if (!name.startsWith(APP_PREFIX)) {
+    return { valid: false, reason: `Custom events must start with "app:" prefix. Got: "${name}"` };
+  }
+  const segments = name.slice(APP_PREFIX.length).split(":");
+  if (segments.length < 2) {
+    return {
+      valid: false,
+      reason: `Event name must have at least 2 segments after "app:" (app:{category}:{action}). Got: "${name}"`
+    };
+  }
+  for (const segment of segments) {
+    if (!SEGMENT_PATTERN.test(segment)) {
+      return {
+        valid: false,
+        reason: `Segment "${segment}" must be lowercase alphanumeric + underscores. Got: "${name}"`
+      };
+    }
+  }
+  return { valid: true };
+}
+function isSerializable(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
+}
+function checkDepth(obj, maxDepth, current = 0) {
+  if (current >= maxDepth) return false;
+  for (const value of Object.values(obj)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      if (!checkDepth(value, maxDepth, current + 1)) return false;
+    }
+  }
+  return true;
+}
+function validateProps(props) {
+  if (props === void 0) return { valid: true };
+  if (props === null || typeof props !== "object" || Array.isArray(props)) {
+    return { valid: false, reason: "Props must be a plain object" };
+  }
+  if (!checkDepth(props, 2)) {
+    return { valid: false, reason: "Props nesting depth exceeds 2 levels" };
+  }
+  const stripped = [];
+  for (const [key, value] of Object.entries(props)) {
+    if (value !== null && typeof value === "object") continue;
+    if (!isSerializable(value)) stripped.push(key);
+  }
+  if (stripped.length > 0) return { valid: true, stripped };
+  return { valid: true };
+}
+
 // src/events/EventBus.ts
 function matchesFilter(event, filter) {
   if (!filter) return true;
@@ -9102,8 +10069,16 @@ var EventBus = class {
     __publicField(this, "subscriptions", /* @__PURE__ */ new Set());
     __publicField(this, "history", []);
     __publicField(this, "maxHistorySize");
-    var _a2;
+    __publicField(this, "debug");
+    __publicField(this, "emitHistory");
+    __publicField(this, "posthogCapture");
+    __publicField(this, "testMode");
+    var _a2, _b, _c, _d, _e;
     this.maxHistorySize = (_a2 = options.maxHistorySize) != null ? _a2 : 100;
+    this.debug = (_b = options.debug) != null ? _b : false;
+    this.emitHistory = (_c = options.history) != null ? _c : null;
+    this.posthogCapture = (_d = options.posthogCapture) != null ? _d : null;
+    this.testMode = (_e = options.testMode) != null ? _e : false;
   }
   /**
    * Subscribe to events matching an optional filter.
@@ -9156,6 +10131,83 @@ var EventBus = class {
       }
     }
   }
+  /**
+   * Emit a validated custom event from the host application.
+   *
+   * Custom events must use the `app:` prefix (e.g. `app:cart:abandoned`).
+   * In debug mode, returns an EmitResult with delivery details.
+   * In production mode, returns undefined.
+   */
+  emit(name, props) {
+    const nameResult = validateEventName(name);
+    if (!nameResult.valid) {
+      console.warn(`[EventBus] emit() rejected: ${nameResult.reason}`);
+      return this.debug ? { delivered: false, matchedRules: [], posthogCaptured: false, listenersNotified: 0 } : void 0;
+    }
+    const propsResult = validateProps(props);
+    if (!propsResult.valid) {
+      console.warn(`[EventBus] emit() rejected props: ${propsResult.reason}`);
+      return this.debug ? { delivered: false, matchedRules: [], posthogCaptured: false, listenersNotified: 0 } : void 0;
+    }
+    const event = {
+      ts: Date.now(),
+      name,
+      source: "custom",
+      props,
+      schemaVersion: EVENT_SCHEMA_VERSION
+    };
+    this.history.push(event);
+    if (this.history.length > this.maxHistorySize) {
+      this.history.shift();
+    }
+    let listenersNotified = 0;
+    for (const subscription of this.subscriptions) {
+      if (matchesFilter(event, subscription.filter)) {
+        try {
+          subscription.callback(event);
+          listenersNotified++;
+        } catch (err) {
+          console.error("[EventBus] Subscriber error:", err);
+          listenersNotified++;
+        }
+      }
+    }
+    let posthogCaptured = false;
+    if (this.posthogCapture && !this.testMode) {
+      try {
+        this.posthogCapture(name, props);
+        posthogCaptured = true;
+      } catch (err) {
+        console.error("[EventBus] PostHog capture error:", err);
+      }
+    }
+    if (this.emitHistory) {
+      this.emitHistory.record({
+        name,
+        props,
+        source: "custom",
+        timestamp: event.ts,
+        matchedRules: []
+      });
+    }
+    if (this.debug) {
+      console.debug("[EventBus] emit()", { name, props, listenersNotified, posthogCaptured });
+      return {
+        delivered: true,
+        matchedRules: [],
+        posthogCaptured,
+        listenersNotified
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Set the PostHog capture function after construction.
+   * Used by bootstrap to wire PostHog after the EventBus is created.
+   */
+  setPosthogCapture(fn) {
+    this.posthogCapture = fn;
+  }
   /**
    * Get recent events matching an optional filter.
    */
@@ -9206,124 +10258,26 @@ function createEventBus(options = {}) {
   return new EventBus(options);
 }
 
-// src/events/normalizers/posthog.ts
-var POSTHOG_EVENT_MAP = {
-  // Autocapture events
-  $autocapture: "ui.click",
-  // Default autocapture is usually clicks
-  $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}`;
+// src/events/history.ts
+var EventHistory = class {
+  constructor(maxSize = 100) {
+    __publicField(this, "entries", []);
+    __publicField(this, "maxSize");
+    this.maxSize = maxSize;
   }
-  return eventName.replace("$", "posthog.");
-}
-function extractProps(phEvent) {
-  var _a2;
-  const props = {};
-  const phProps = phEvent.properties || {};
-  const elements = phProps.$elements;
-  if (phProps.$tag_name) {
-    props.tagName = phProps.$tag_name;
-  } else if ((_a2 = elements == null ? void 0 : elements[0]) == null ? void 0 : _a2.tag_name) {
-    props.tagName = elements[0].tag_name;
-  }
-  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();
+  record(entry) {
+    this.entries.push(entry);
+    if (this.maxSize > 0 && this.entries.length > this.maxSize) {
+      this.entries.shift();
+    }
   }
-  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;
+  getAll() {
+    return [...this.entries];
   }
-  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);
-    }
-  };
-}
+  clear() {
+    this.entries = [];
+  }
+};
 
 // src/navigation/NavigationMonitor.ts
 var NavigationMonitor = class {
@@ -10124,9 +11078,18 @@ function createSurfaces(options) {
   }
   async function unmountEntry(entry) {
     var _a2;
-    await playExitAnimation(entry.container, entry.options.animation);
-    (_a2 = entry.cleanup) == null ? void 0 : _a2.call(entry);
-    entry.container.remove();
+    if (entry.container.isConnected) {
+      await playExitAnimation(entry.container, entry.options.animation);
+    }
+    try {
+      (_a2 = entry.cleanup) == null ? void 0 : _a2.call(entry);
+    } catch (error2) {
+      console.warn("[Surfaces] Cleanup error during unmount, ignoring:", error2);
+    }
+    try {
+      entry.container.remove();
+    } catch {
+    }
     mounts.delete(entry.slot);
     publishEvent("surface.unmounted", {
       slot: entry.slot,
@@ -10309,7 +11272,9 @@ var WidgetRegistry = class {
         var _a2;
         const mounted = this.mountedWidgets.get(mountId);
         if (mounted) {
-          (_a2 = mounted.cleanup) == null ? void 0 : _a2.call(mounted);
+          if (container.isConnected) {
+            (_a2 = mounted.cleanup) == null ? void 0 : _a2.call(mounted);
+          }
           this.mountedWidgets.delete(mountId);
           container.removeAttribute("data-widget-mount-id");
           container.removeAttribute("data-widget-id");
@@ -10425,7 +11390,16 @@ function matchesAnchorRoute(anchorId) {
   const pathname = typeof window !== "undefined" ? window.location.pathname : "/";
   const normalizedPath = pathname.replace(/\/$/, "") || "/";
   const routes = Array.isArray(anchorId.route) ? anchorId.route : [anchorId.route];
-  return routes.some((pattern) => matchRoutePattern(normalizedPath, pattern));
+  return routes.some((pattern) => {
+    let normalized = pattern;
+    if (/^https?:\/\//.test(normalized)) {
+      try {
+        normalized = new URL(normalized).pathname;
+      } catch {
+      }
+    }
+    return matchRoutePattern(normalizedPath, normalized);
+  });
 }
 function createSmartCanvasRuntime(options = {}) {
   var _a2, _b, _c, _d;
@@ -10597,6 +11571,142 @@ function encodeToken(payload) {
   return TOKEN_PREFIX + base64;
 }
 
+// src/bootstrap-init.ts
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  try {
+    const meta = (0, eval)("import.meta");
+    if (meta == null ? void 0 : meta.env) {
+      return meta.env[name];
+    }
+  } catch {
+  }
+  return void 0;
+}
+var SEGMENT_CACHE_KEY = "syntro_segment_attributes";
+function loadCachedSegmentAttributes() {
+  if (typeof window === "undefined") return {};
+  try {
+    const cached = localStorage.getItem(SEGMENT_CACHE_KEY);
+    if (cached) {
+      const attrs = JSON.parse(cached);
+      debug("Syntro Bootstrap", "Loaded cached segment attributes:", attrs);
+      return attrs;
+    }
+  } catch (err) {
+    warn("Syntro Bootstrap", "Failed to load cached segment attributes:", err);
+  }
+  return {};
+}
+function cacheSegmentAttributes(attrs) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(SEGMENT_CACHE_KEY, JSON.stringify(attrs));
+    debug("Syntro Bootstrap", "Cached segment attributes:", attrs);
+  } catch (err) {
+    warn("Syntro Bootstrap", "Failed to cache segment attributes:", err);
+  }
+}
+function extractSegmentFlags(allFlags) {
+  if (!allFlags) return {};
+  const segmentFlags = {};
+  for (const [key, value] of Object.entries(allFlags)) {
+    if (key.startsWith("in_segment_")) {
+      segmentFlags[key] = value === true;
+    }
+  }
+  return segmentFlags;
+}
+function collectBrowserMetadata() {
+  var _a2;
+  if (typeof window === "undefined") return {};
+  const attrs = {};
+  try {
+    const params = new URLSearchParams(window.location.search);
+    for (const key of ["utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term"]) {
+      const val = params.get(key);
+      if (val) attrs[key] = val;
+    }
+  } catch {
+  }
+  try {
+    if (navigator.language) attrs.browser_language = navigator.language;
+    if ((_a2 = navigator.languages) == null ? void 0 : _a2.length) attrs.browser_languages = [...navigator.languages];
+  } catch {
+  }
+  try {
+    const w = window.innerWidth;
+    attrs.device_type = w < 768 ? "mobile" : w < 1024 ? "tablet" : "desktop";
+  } catch {
+  }
+  try {
+    if (document.referrer) {
+      attrs.referrer = document.referrer;
+      try {
+        attrs.referrer_hostname = new URL(document.referrer).hostname;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
+    const ua = navigator.userAgent;
+    if (ua.includes("Edg/")) attrs.browser = "Edge";
+    else if (ua.includes("OPR/") || ua.includes("Opera")) attrs.browser = "Opera";
+    else if (ua.includes("Chrome/") && !ua.includes("Chromium")) attrs.browser = "Chrome";
+    else if (ua.includes("Safari/") && !ua.includes("Chrome")) attrs.browser = "Safari";
+    else if (ua.includes("Firefox/")) attrs.browser = "Firefox";
+    if (ua.includes("Windows")) attrs.os = "Windows";
+    else if (ua.includes("iPhone") || ua.includes("iPad")) attrs.os = "iOS";
+    else if (ua.includes("Mac OS X") || ua.includes("Macintosh")) attrs.os = "macOS";
+    else if (ua.includes("Android")) attrs.os = "Android";
+    else if (ua.includes("Linux")) attrs.os = "Linux";
+  } catch {
+  }
+  try {
+    attrs.page_url = window.location.href;
+    attrs.page_path = window.location.pathname;
+    attrs.page_host = window.location.hostname;
+    if (window.location.search) attrs.page_query = window.location.search;
+  } catch {
+  }
+  return attrs;
+}
+var GEO_CACHE_KEY = "syntro_geo";
+var GEO_DEFAULT_HOST = "https://geo.syntrologie.com";
+async function fetchGeo(geoHost) {
+  if (typeof window === "undefined") return {};
+  try {
+    const cached = localStorage.getItem(GEO_CACHE_KEY);
+    if (cached) {
+      const parsed = JSON.parse(cached);
+      debug("Syntro Bootstrap", "Geo: using cached data:", parsed);
+      return parsed;
+    }
+  } catch {
+  }
+  try {
+    const res = await fetch(geoHost, { signal: AbortSignal.timeout(2e3) });
+    if (res.ok) {
+      const geo = await res.json();
+      const cleaned = {};
+      for (const [k, v] of Object.entries(geo)) {
+        if (typeof v === "string" && v) cleaned[k] = v;
+      }
+      try {
+        localStorage.setItem(GEO_CACHE_KEY, JSON.stringify(cleaned));
+      } catch {
+      }
+      debug("Syntro Bootstrap", "Geo: fetched from worker:", cleaned);
+      return cleaned;
+    }
+  } catch {
+  }
+  return {};
+}
+
 // src/experiments/registry.ts
 var adapters = {
   growthbook: (config) => createGrowthBookClient({
@@ -10703,9 +11813,8 @@ var ExperimentsFetcher = class {
     __publicField(this, "featureKey");
     __publicField(this, "manifestKey");
     __publicField(this, "variantFlagPrefix");
-    var _a2;
     this.client = options.client;
-    this.featureKey = (_a2 = options.featureKey) != null ? _a2 : "smart-canvas-config";
+    this.featureKey = options.featureKey;
     this.manifestKey = options.manifestKey;
     this.variantFlagPrefix = options.variantFlagPrefix;
   }
@@ -10734,6 +11843,11 @@ var ExperimentsFetcher = class {
         };
       }
     }
+    if (!this.featureKey) {
+      throw new Error(
+        "[SmartCanvas] No featureKey configured and no variant flags found. Ensure at least one config feature flag exists in your experiment platform."
+      );
+    }
     const config = (_b = (_a2 = this.client).getFeatureValue) == null ? void 0 : _b.call(_a2, this.featureKey, null);
     if (!config || typeof config !== "object") {
       throw new Error(
@@ -10845,95 +11959,9 @@ function createTelemetryClient(provider, config) {
   return factory(config);
 }
 
-// src/bootstrap.ts
-function getEnvVar(name) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[name];
-  }
-  try {
-    const meta = (0, eval)("import.meta");
-    if (meta == null ? void 0 : meta.env) {
-      return meta.env[name];
-    }
-  } catch {
-  }
-  return void 0;
-}
-var SEGMENT_CACHE_KEY = "syntro_segment_attributes";
-function loadCachedSegmentAttributes() {
-  if (typeof window === "undefined") return {};
-  try {
-    const cached = localStorage.getItem(SEGMENT_CACHE_KEY);
-    if (cached) {
-      const attrs = JSON.parse(cached);
-      debug("Syntro Bootstrap", "Loaded cached segment attributes:", attrs);
-      return attrs;
-    }
-  } catch (err) {
-    warn("Syntro Bootstrap", "Failed to load cached segment attributes:", err);
-  }
-  return {};
-}
-function cacheSegmentAttributes(attrs) {
-  if (typeof window === "undefined") return;
-  try {
-    localStorage.setItem(SEGMENT_CACHE_KEY, JSON.stringify(attrs));
-    debug("Syntro Bootstrap", "Cached segment attributes:", attrs);
-  } catch (err) {
-    warn("Syntro Bootstrap", "Failed to cache segment attributes:", err);
-  }
-}
-function extractSegmentFlags(allFlags) {
-  if (!allFlags) return {};
-  const segmentFlags = {};
-  for (const [key, value] of Object.entries(allFlags)) {
-    if (key.startsWith("in_segment_")) {
-      segmentFlags[key] = value === true;
-    }
-  }
-  return segmentFlags;
-}
-function collectBrowserMetadata() {
-  var _a2;
-  if (typeof window === "undefined") return {};
-  const attrs = {};
-  try {
-    const params = new URLSearchParams(window.location.search);
-    for (const key of ["utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term"]) {
-      const val = params.get(key);
-      if (val) attrs[key] = val;
-    }
-  } catch {
-  }
-  try {
-    if (navigator.language) attrs.browser_language = navigator.language;
-    if ((_a2 = navigator.languages) == null ? void 0 : _a2.length) attrs.browser_languages = [...navigator.languages];
-  } catch {
-  }
-  try {
-    const w = window.innerWidth;
-    attrs.device_type = w < 768 ? "mobile" : w < 1024 ? "tablet" : "desktop";
-  } catch {
-  }
-  try {
-    if (document.referrer) {
-      attrs.referrer = document.referrer;
-      try {
-        attrs.referrer_hostname = new URL(document.referrer).hostname;
-      } catch {
-      }
-    }
-  } catch {
-  }
-  try {
-    attrs.page_url = window.location.href;
-    attrs.page_path = window.location.pathname;
-  } catch {
-  }
-  return attrs;
-}
-async function init(options) {
-  var _a2, _b, _c, _d, _e, _f;
+// src/bootstrap-runtime.ts
+async function _initCore(options) {
+  var _a2, _b, _c, _d, _e, _f, _g;
   initLogger();
   debug("Syntro Bootstrap", "====== INIT ======");
   debug("Syntro Bootstrap", "Options:", {
@@ -10998,17 +12026,59 @@ async function init(options) {
   const experimentHost = getEnvVar("NEXT_PUBLIC_SYNTRO_EXPERIMENT_HOST") || getEnvVar("VITE_SYNTRO_EXPERIMENT_HOST") || (payload == null ? void 0 : payload.eh);
   const telemetryHost = getEnvVar("NEXT_PUBLIC_SYNTRO_TELEMETRY_HOST") || getEnvVar("VITE_SYNTRO_TELEMETRY_HOST") || (payload == null ? void 0 : payload.th);
   const editorUrl = getEnvVar("NEXT_PUBLIC_SYNTRO_EDITOR_URL") || getEnvVar("VITE_SYNTRO_EDITOR_URL") || ((_b = options.canvas) == null ? void 0 : _b.editorUrl);
+  const geoHost = (payload == null ? void 0 : payload.g) || getEnvVar("NEXT_PUBLIC_SYNTRO_GEO_HOST") || getEnvVar("VITE_SYNTRO_GEO_HOST") || GEO_DEFAULT_HOST;
   const cachedSegmentAttrs = loadCachedSegmentAttributes();
   const browserMetadata = collectBrowserMetadata();
   const phaseOneAttrs = { ...browserMetadata, ...cachedSegmentAttrs };
   debug("Syntro Bootstrap", "Phase 1: Browser metadata:", browserMetadata);
   debug("Syntro Bootstrap", "Phase 1: Cached segment attributes:", cachedSegmentAttrs);
+  const geoPromise = fetchGeo(geoHost);
   let experiments;
-  const events = createEventBus();
+  const isDebugOrTest = options.debug || options.testMode;
+  const events = createEventBus({
+    debug: options.debug,
+    history: isDebugOrTest ? new EventHistory(options.testMode ? 0 : 100) : void 0,
+    testMode: options.testMode
+  });
   console.log("[Syntro Bootstrap] EventBus created");
-  const postHogNormalizer = createPostHogNormalizer((event) => {
-    events.publishEvent(event);
+  const processor = createEventProcessor({
+    elementResolver: typeof window !== "undefined" ? (x, y) => {
+      const el = document.elementFromPoint(x, y);
+      if (!el) return null;
+      const info = { tag_name: el.tagName.toLowerCase() };
+      if (el.id) info.attr__id = el.id;
+      if (el.className && typeof el.className === "string") {
+        info.classes = el.className.split(" ").filter(Boolean);
+      }
+      for (const attr of el.attributes) {
+        if (attr.name.startsWith("data-")) info[`attr__${attr.name}`] = attr.value;
+      }
+      return info;
+    } : void 0
   });
+  processor.onEvent((event) => events.publishEvent(event));
+  if (typeof window !== "undefined") {
+    setInterval(() => processor.tick(Date.now()), 1e3);
+    document.addEventListener(
+      "click",
+      (e) => {
+        const chain = [];
+        let el = e.target;
+        while (el && el !== document.body) {
+          const info = { tag_name: el.tagName.toLowerCase() };
+          for (const attr of el.attributes) {
+            if (attr.name.startsWith("data-") || attr.name === "id" || attr.name === "class" || attr.name === "aria-label") {
+              info[`attr__${attr.name}`] = attr.value;
+            }
+          }
+          chain.push(info);
+          el = el.parentElement;
+        }
+        processor.enrichClickAttributes(Date.now(), chain);
+      },
+      true
+    );
+  }
   const onFeatureFlagsLoaded = (allFlags) => {
     var _a3, _b2, _c2;
     debug("Syntro Bootstrap", "Phase 2: PostHog feature flags loaded");
@@ -11031,12 +12101,26 @@ async function init(options) {
       // undefined falls back to adapter default
       // Enable PostHog feature flags for segment membership
       enableFeatureFlags: true,
+      // Disable session recording in debug/dev mode (mock telemetry doesn't
+      // support the PostHog recorder extension, causing console errors)
+      sessionRecording: !payload.d,
       // Wire up callback for when flags are loaded (Phase 2)
       onFeatureFlagsLoaded,
-      // Wire up event capture to feed into EventBus
-      onCapture: postHogNormalizer
+      // Wire up event capture to feed into event processor
+      onCapture: (eventName, properties) => {
+        processor.ingest({ kind: "posthog", event: eventName, properties, timestamp: Date.now() });
+      },
+      // Wire rrweb events for behavioral signal detection
+      onRRWebEvent: (event) => {
+        processor.ingest(event);
+      }
     });
     console.log(`[Syntro Bootstrap] Telemetry client created (${provider}) with EventBus wiring`);
+    const telemetryForCapture = telemetry;
+    events.setPosthogCapture((name, props) => {
+      var _a3;
+      (_a3 = telemetryForCapture.track) == null ? void 0 : _a3.call(telemetryForCapture, name, props);
+    });
   }
   let sessionMetrics;
   if (payload == null ? void 0 : payload.e) {
@@ -11129,11 +12213,17 @@ async function init(options) {
       warn("Syntro Bootstrap", "Failed to load GrowthBook features:", err);
     }
   }
+  const geoData = await geoPromise;
+  if (experiments && Object.keys(geoData).length > 0) {
+    const mergedAttrs = { ...browserMetadata, ...geoData };
+    debug("Syntro Bootstrap", "Merging geo data into GrowthBook attributes:", geoData);
+    (_f = experiments.setAttributes) == null ? void 0 : _f.call(experiments, mergedAttrs);
+  }
   let baseFetcher;
   if (options.fetcher) {
     baseFetcher = options.fetcher;
   } else if (payload == null ? void 0 : payload.f) {
-    const configFetcher = createConfigFetcher(payload.f, (_f = payload.o) != null ? _f : {});
+    const configFetcher = createConfigFetcher(payload.f, (_g = payload.o) != null ? _g : {});
     baseFetcher = async () => {
       var _a3;
       const result = await configFetcher.fetch();
@@ -11147,19 +12237,39 @@ async function init(options) {
   }
   const warnedAppFailures = /* @__PURE__ */ new Set();
   const appLoadingFetcher = baseFetcher ? async () => {
-    var _a3, _b2, _c2, _d2, _e2, _f2, _g;
+    var _a3, _b2, _c2, _d2, _e2, _f2, _g2, _h, _i, _j, _k, _l;
     const config = await baseFetcher();
+    const tileCount = (_b2 = (_a3 = config.tiles) == null ? void 0 : _a3.length) != null ? _b2 : 0;
+    const actionCount = (_d2 = (_c2 = config.actions) == null ? void 0 : _c2.length) != null ? _d2 : 0;
+    const variantId = (_e2 = config.meta) == null ? void 0 : _e2.variant_id;
+    if (tileCount > 0 || actionCount > 0) {
+      if (!variantId) {
+        console.warn(
+          "[Syntro] Config has content but no meta.variant_id \u2014 intervention tracking disabled"
+        );
+      }
+    }
+    if (telemetry && variantId) {
+      const tracker = new InterventionTracker(telemetry, variantId);
+      tracker.trackServed(tileCount, actionCount);
+      if (typeof window !== "undefined") {
+        window.SynOS.interventionTracker = tracker;
+      }
+      runtime3.navigation.subscribe(() => {
+        tracker.resetPage();
+      });
+    }
     console.log(
       "[Syntro Bootstrap] Config fetched:",
-      `tiles=${(_b2 = (_a3 = config.tiles) == null ? void 0 : _a3.length) != null ? _b2 : 0},`,
-      `actions=${(_d2 = (_c2 = config.actions) == null ? void 0 : _c2.length) != null ? _d2 : 0},`,
-      `theme=${(_f2 = (_e2 = config.theme) == null ? void 0 : _e2.name) != null ? _f2 : "none"}`
+      `tiles=${(_g2 = (_f2 = config.tiles) == null ? void 0 : _f2.length) != null ? _g2 : 0},`,
+      `actions=${(_i = (_h = config.actions) == null ? void 0 : _h.length) != null ? _i : 0},`,
+      `theme=${(_k = (_j = config.theme) == null ? void 0 : _j.name) != null ? _k : "none"}`
     );
-    if (((_g = config.actions) == null ? void 0 : _g.length) > 0) {
+    if (((_l = config.actions) == null ? void 0 : _l.length) > 0) {
       console.log(
         "[Syntro Bootstrap] Actions in config:",
         config.actions.map(
-          (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${typeof a.anchorId === "string" ? a.anchorId : a.anchorId.selector}"` : ""}${a.label ? ` "${a.label}"` : ""}`
+          (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${a.anchorId.selector}"` : ""}${a.label ? ` "${a.label}"` : ""}`
         ).join(", ")
       );
     }
@@ -11218,10 +12328,33 @@ async function init(options) {
   });
   return { canvas, runtime: runtime3, experiments, telemetry, sessionMetrics, appLoader };
 }
+
+// src/bootstrap.ts
+async function init(options) {
+  var _a2;
+  try {
+    return await _initCore(options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn("[Syntrologie] SDK initialization failed:", message);
+    if (typeof document !== "undefined") {
+      (_a2 = document.getElementById("syntrologie-anti-flicker")) == null ? void 0 : _a2.remove();
+    }
+    return void 0;
+  }
+}
+function emit(eventName, props = {}) {
+  var _a2, _b;
+  if (typeof window === "undefined") return;
+  const runtime3 = (_a2 = window.SynOS) == null ? void 0 : _a2.runtime;
+  if (!((_b = runtime3 == null ? void 0 : runtime3.events) == null ? void 0 : _b.publish)) return;
+  runtime3.events.publish({ name: eventName, source: "custom", props });
+}
 var Syntro = {
   init,
   encodeToken,
-  decodeToken
+  decodeToken,
+  events: { emit }
 };
 if (typeof window !== "undefined") {
   window.Syntro = Syntro;
@@ -11252,8 +12385,11 @@ export {
   createSmartCanvasController,
   ShadowRootProvider,
   useShadowRoot,
-  StandardEvents,
   EVENT_SCHEMA_VERSION,
+  normalizePostHogEvent,
+  shouldNormalizeEvent,
+  createPostHogNormalizer,
+  StandardEvents2 as StandardEvents,
   CanvasEvents,
   NotificationToastStack,
   MAX_VISIBLE_TOASTS,
@@ -11284,6 +12420,7 @@ export {
   createSessionMetricTracker,
   createNoopClient,
   createPostHogClient,
+  InterventionTracker,
   ExecutorRegistry,
   executorRegistry,
   getExecutor,
@@ -11302,11 +12439,11 @@ export {
   evaluateSync,
   createDecisionEngine,
   createEventAccumulator,
+  validateEventName,
+  validateProps,
   EventBus,
   createEventBus,
-  normalizePostHogEvent,
-  shouldNormalizeEvent,
-  createPostHogNormalizer,
+  EventHistory,
   NavigationMonitor,
   StateStore,
   createStateStore,
@@ -11330,4 +12467,4 @@ export {
   encodeToken,
   Syntro
 };
-//# sourceMappingURL=chunk-OB5AKUQT.js.map
+//# sourceMappingURL=chunk-EELCEGS7.js.map