@syntrologie/runtime-sdk 2.11.0 → 2.12.0

package/dist/{chunk-H3FAYTUV.js → chunk-J2LGX2PV.js}

@@ -3,7 +3,7 @@ import {
   __privateGet,
   __privateSet,
   __publicField
-} from "./chunk-JMHRHAEL.js";
+} from "./chunk-BU4Z6PD7.js";
 
 // ../adaptives/adaptive-content/dist/reconciliation-guard.js
 function guardAgainstReconciliation(container, anchor, reinsertFn, opts) {
@@ -127,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);
@@ -755,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;
@@ -1398,7 +1408,7 @@ var alert = {
 var tag = {
   content: slateGrey[10],
   border: slateGrey[4],
-  background: "#1c2124"
+  background: slateGrey[3]
 };
 var menu = {
   backgroundDefault: slateGrey[2],
@@ -2283,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) => {
@@ -2806,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 = {
@@ -2926,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",
@@ -3080,6 +3098,9 @@ function createAppLoader(options) {
         }
       }
     }
+    for (const bundled of BUNDLED_APP_IDS) {
+      appIds.delete(bundled);
+    }
     return Array.from(appIds);
   }
   async function loadAppsForConfig(config) {
@@ -3435,7 +3456,7 @@ function getAntiFlickerSnippet(config = {}) {
 }
 
 // src/version.ts
-var SDK_VERSION = "2.11.0";
+var SDK_VERSION = "2.12.0";
 
 // src/types.ts
 var SDK_SCHEMA_VERSION = "2.0";
@@ -3586,12 +3607,15 @@ 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) {
+    const key = featureKey != null ? featureKey : "smart-canvas-config";
+    const fromFeature = (_a2 = experiments.getFeatureValue) == null ? void 0 : _a2.call(experiments, key, null);
+    if (fromFeature) return fromFeature;
+  }
   return void 0;
 };
 function getVariantFlagKeys(experiments, manifestKey, variantFlagPrefix) {
@@ -3617,14 +3641,15 @@ var createCanvasConfigFetcher = ({
   experiments,
   featureKey,
   credentials,
-  configFeatureKey = "smart-canvas-config",
+  configFeatureKey,
   manifestKey,
   variantFlagPrefix,
   sdkVersion
 }) => async () => {
   var _a2;
-  if (experiments && configFeatureKey) {
-    const directConfig = (_a2 = experiments.getFeatureValue) == null ? void 0 : _a2.call(experiments, configFeatureKey, null);
+  const effectiveConfigKey = configFeatureKey != null ? configFeatureKey : "smart-canvas-config";
+  if (experiments) {
+    const directConfig = (_a2 = experiments.getFeatureValue) == null ? void 0 : _a2.call(experiments, effectiveConfigKey, null);
     if (directConfig && typeof directConfig === "object") {
       debug("SmartCanvas Config", "Resolved config directly from feature flag", directConfig);
       return directConfig;
@@ -3812,9 +3837,529 @@ function useShadowRoot() {
   return ctx;
 }
 
-// src/events/types.ts
-import { EVENT_SCHEMA_VERSION } from "@syntrologie/event-processor";
+// ../event-processor/dist/types.js
+var EVENT_SCHEMA_VERSION = "1.0.0";
 var StandardEvents = {
+  UI_CLICK: "ui.click",
+  UI_SCROLL: "ui.scroll",
+  UI_INPUT: "ui.input",
+  UI_CHANGE: "ui.change",
+  UI_SUBMIT: "ui.submit",
+  NAV_PAGE_VIEW: "nav.page_view",
+  NAV_PAGE_LEAVE: "nav.page_leave",
+  UI_HESITATE: "ui.hesitate",
+  UI_RAGE_CLICK: "ui.rage_click",
+  UI_SCROLL_THRASH: "ui.scroll_thrash",
+  UI_FOCUS_BOUNCE: "ui.focus_bounce",
+  UI_IDLE: "ui.idle",
+  UI_HOVER: "ui.hover"
+};
+var RRWebSource = {
+  Mutation: 0,
+  MouseMove: 1,
+  MouseInteraction: 2,
+  Scroll: 3,
+  ViewportResize: 4,
+  Input: 5,
+  TouchMove: 6,
+  MediaInteraction: 7,
+  Drag: 12
+};
+var RRWebMouseInteraction = {
+  MouseUp: 0,
+  MouseDown: 1,
+  Click: 2,
+  ContextMenu: 3,
+  DblClick: 4,
+  Focus: 5,
+  Blur: 6,
+  TouchStart: 7,
+  TouchEnd: 9
+};
+var DEFAULT_DETECTOR_CONFIG = {
+  hesitationMs: 3e3,
+  hesitationRadiusPx: 10,
+  rageClickCount: 3,
+  rageClickWindowMs: 1e3,
+  rageClickRadiusPx: 30,
+  scrollThrashReversals: 3,
+  scrollThrashWindowMs: 2e3,
+  focusBounceMaxInputs: 0,
+  idleMs: 5e3,
+  hoverSampleMs: 100
+};
+
+// ../event-processor/dist/normalizers/posthog.js
+var POSTHOG_EVENT_MAP = {
+  // NOTE: $autocapture is intentionally NOT in this map.
+  // It's handled below in getEventName() with $event_type refinement
+  // so that change/submit events aren't all mapped to ui.click.
+  $click: StandardEvents.UI_CLICK,
+  $scroll: StandardEvents.UI_SCROLL,
+  $input: StandardEvents.UI_INPUT,
+  $change: StandardEvents.UI_CHANGE,
+  $submit: StandardEvents.UI_SUBMIT,
+  // Navigation events
+  $pageview: StandardEvents.NAV_PAGE_VIEW,
+  $pageleave: StandardEvents.NAV_PAGE_LEAVE,
+  // Session events
+  $session_start: "session.start",
+  // Identify events
+  $identify: "user.identify"
+};
+function getEventName(phEvent) {
+  var _a2, _b;
+  const eventName = phEvent.event;
+  if (typeof eventName !== "string") {
+    return "posthog.unknown";
+  }
+  if (POSTHOG_EVENT_MAP[eventName]) {
+    return POSTHOG_EVENT_MAP[eventName];
+  }
+  if (eventName === "$autocapture") {
+    const tagName = (_a2 = phEvent.properties) == null ? void 0 : _a2.$tag_name;
+    const eventType = (_b = phEvent.properties) == null ? void 0 : _b.$event_type;
+    if (eventType === "submit")
+      return StandardEvents.UI_SUBMIT;
+    if (eventType === "change")
+      return StandardEvents.UI_CHANGE;
+    if (tagName === "input" || tagName === "textarea")
+      return StandardEvents.UI_INPUT;
+    return StandardEvents.UI_CLICK;
+  }
+  if (!eventName.startsWith("$")) {
+    return `posthog.${eventName}`;
+  }
+  return eventName.replace("$", "posthog.");
+}
+var INTERACTIVE_TAGS = /* @__PURE__ */ new Set(["a", "button", "input", "select", "textarea"]);
+function resolveInteractiveTag(elements, directTag) {
+  if (directTag && INTERACTIVE_TAGS.has(directTag))
+    return directTag;
+  if (!elements)
+    return directTag;
+  for (const el of elements) {
+    const tag2 = el.tag_name;
+    if (tag2 && INTERACTIVE_TAGS.has(tag2))
+      return tag2;
+  }
+  return directTag;
+}
+function extractProps(phEvent) {
+  var _a2, _b;
+  const props = {};
+  const phProps = phEvent.properties || {};
+  const elements = phProps.$elements;
+  const directTag = (_b = phProps.$tag_name) != null ? _b : (_a2 = elements == null ? void 0 : elements[0]) == null ? void 0 : _a2.tag_name;
+  const isClickEvent = phEvent.event === "$autocapture" || phEvent.event === "$click";
+  props.tagName = isClickEvent ? resolveInteractiveTag(elements, directTag) : directTag;
+  if (phProps.$el_text)
+    props.elementText = phProps.$el_text;
+  if (elements)
+    props.elements = elements;
+  if (phProps.$current_url)
+    props.url = phProps.$current_url;
+  if (phProps.$pathname)
+    props.pathname = phProps.$pathname;
+  if (phProps.$host)
+    props.host = phProps.$host;
+  if (phProps.$viewport_width)
+    props.viewportWidth = phProps.$viewport_width;
+  if (phProps.$viewport_height)
+    props.viewportHeight = phProps.$viewport_height;
+  if (phProps.$session_id)
+    props.sessionId = phProps.$session_id;
+  if (phProps.$scroll_depth)
+    props.scrollDepth = phProps.$scroll_depth;
+  if (phProps.$scroll_percentage)
+    props.scrollPercentage = phProps.$scroll_percentage;
+  props.originalEvent = phEvent.event;
+  return props;
+}
+function normalizePostHogEvent(phEvent) {
+  let ts;
+  if (typeof phEvent.timestamp === "number") {
+    ts = phEvent.timestamp;
+  } else if (typeof phEvent.timestamp === "string") {
+    ts = new Date(phEvent.timestamp).getTime();
+  } else {
+    ts = Date.now();
+  }
+  return {
+    ts,
+    name: getEventName(phEvent),
+    source: "posthog",
+    props: extractProps(phEvent),
+    schemaVersion: EVENT_SCHEMA_VERSION
+  };
+}
+function shouldNormalizeEvent(phEvent) {
+  const eventName = phEvent.event;
+  if (typeof eventName !== "string")
+    return false;
+  const skipEvents = [
+    "$feature_flag_called",
+    "$feature_flags",
+    "$groups",
+    "$groupidentify",
+    "$set",
+    "$set_once",
+    "$unset",
+    "$create_alias",
+    "$capture_metrics",
+    "$performance_event",
+    "$web_vitals",
+    "$exception",
+    "$dead_click",
+    "$heatmap"
+  ];
+  if (skipEvents.includes(eventName)) {
+    return false;
+  }
+  return true;
+}
+function createPostHogNormalizer(publishFn) {
+  return (eventName, properties) => {
+    if (typeof eventName !== "string")
+      return;
+    const phEvent = {
+      event: eventName,
+      properties,
+      timestamp: Date.now()
+    };
+    if (shouldNormalizeEvent(phEvent)) {
+      const normalizedEvent = normalizePostHogEvent(phEvent);
+      publishFn(normalizedEvent);
+    }
+  };
+}
+
+// ../event-processor/dist/detectors/focus-bounce.js
+var FocusBounceDetector = class {
+  constructor(config, 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",
@@ -3866,48 +4411,48 @@ function createCanvasEvent(name, props) {
   };
 }
 function canvasOpened(surface) {
-  return createCanvasEvent(StandardEvents.CANVAS_OPENED, { surface });
+  return createCanvasEvent(StandardEvents2.CANVAS_OPENED, { surface });
 }
 function canvasClosed(surface) {
-  return createCanvasEvent(StandardEvents.CANVAS_CLOSED, { surface });
+  return createCanvasEvent(StandardEvents2.CANVAS_CLOSED, { surface });
 }
 function tileViewed(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_VIEWED, { tileId, surface });
+  return createCanvasEvent(StandardEvents2.TILE_VIEWED, { tileId, surface });
 }
 function tileExpanded(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_EXPANDED, { tileId, surface });
+  return createCanvasEvent(StandardEvents2.TILE_EXPANDED, { tileId, surface });
 }
 function tileCollapsed(tileId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_COLLAPSED, { tileId, surface });
+  return createCanvasEvent(StandardEvents2.TILE_COLLAPSED, { tileId, surface });
 }
 function tileAction(tileId, actionId, surface) {
-  return createCanvasEvent(StandardEvents.TILE_ACTION, {
+  return createCanvasEvent(StandardEvents2.TILE_ACTION, {
     tileId,
     actionId,
     surface
   });
 }
 function overlayStarted(recipeId, recipeName) {
-  return createCanvasEvent(StandardEvents.OVERLAY_STARTED, {
+  return createCanvasEvent(StandardEvents2.OVERLAY_STARTED, {
     recipeId,
     recipeName
   });
 }
 function overlayCompleted(recipeId, recipeName) {
-  return createCanvasEvent(StandardEvents.OVERLAY_COMPLETED, {
+  return createCanvasEvent(StandardEvents2.OVERLAY_COMPLETED, {
     recipeId,
     recipeName
   });
 }
 function overlayDismissed(recipeId, recipeName, stepIndex) {
-  return createCanvasEvent(StandardEvents.OVERLAY_DISMISSED, {
+  return createCanvasEvent(StandardEvents2.OVERLAY_DISMISSED, {
     recipeId,
     recipeName,
     stepIndex
   });
 }
 function overlayStepViewed(recipeId, stepIndex, stepTitle) {
-  return createCanvasEvent(StandardEvents.OVERLAY_STEP_VIEWED, {
+  return createCanvasEvent(StandardEvents2.OVERLAY_STEP_VIEWED, {
     recipeId,
     stepIndex,
     stepTitle
@@ -4233,7 +4778,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
@@ -4298,7 +4843,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,
@@ -4511,7 +5056,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",
       {
@@ -5132,7 +5677,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
@@ -5142,7 +5687,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
         });
@@ -5215,6 +5760,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 = {
@@ -5253,6 +5809,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;
@@ -5340,7 +5897,7 @@ function ShadowCanvasOverlay({
       style: {
         position: "fixed",
         inset: 0,
-        pointerEvents: isOpen ? "auto" : "none",
+        pointerEvents: "none",
         zIndex
       },
       children: /* @__PURE__ */ jsxs3("div", { style: wrapperStyle, children: [
@@ -5413,17 +5970,7 @@ function ShadowCanvasOverlay({
           ) }),
           footerSlot
         ] }),
-        /* @__PURE__ */ jsx8(
-          "div",
-          {
-            onClick: toggle2,
-            style: {
-              flex: "1 1 auto",
-              pointerEvents: isOpen ? "auto" : "none",
-              cursor: "default"
-            }
-          }
-        )
+        /* @__PURE__ */ jsx8("div", { style: { flex: "1 1 auto" } })
       ] })
     }
   );
@@ -5453,6 +6000,7 @@ function ShadowCanvasOverlay({
             /* @__PURE__ */ jsxs3(
               "button",
               {
+                ref: launcherRef,
                 type: "button",
                 "aria-label": "Toggle shadow canvas",
                 className: launcherAnimate && !isOpen ? "syntro-launcher-animate" : void 0,
@@ -5715,8 +6263,8 @@ function SmartCanvasApp({
   controller,
   fetcher,
   configUri,
-  configUriFeatureKey = "smart-canvas-config-uri",
-  configFeatureKey = "smart-canvas-config",
+  configUriFeatureKey,
+  configFeatureKey,
   fetchCredentials = "include",
   pollIntervalMs,
   experiments,
@@ -5786,10 +6334,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,
@@ -7072,7 +7620,6 @@ var PostHogAdapter = class {
     __publicField(this, "featureFlagsCallback");
     __publicField(this, "captureCallback");
     __publicField(this, "rrwebCallback");
-    __publicField(this, "consentUnsub");
     this.client = options.client;
     this.featureFlagsCallback = options.onFeatureFlagsLoaded;
     this.captureCallback = options.onCapture;
@@ -7083,7 +7630,7 @@ var PostHogAdapter = class {
       if (currentStatus === "granted") {
         this.initPostHog();
       }
-      this.consentUnsub = consent.subscribe((status) => {
+      consent.subscribe((status) => {
         if (status === "granted") {
           if (!this.client) {
             this.initPostHog();
@@ -7110,71 +7657,67 @@ 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);
+    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,
+      // 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);
             }
-          }
-          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 existingFlags = this.getAllFeatureFlags();
+          if (existingFlags && Object.keys(existingFlags).length > 0) {
+            this.featureFlagsCallback(existingFlags);
           }
         }
-      },
+        if (this.captureCallback) {
+          ph.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);
+            }
+          });
+        }
+      }
+    };
+    const result = posthog.init(
+      options.apiKey,
+      initOptions,
       instanceName
     );
+    if (result) {
+      this.client = result;
+    }
     if (this.rrwebCallback && this.client) {
       this.setupRRWebIntercept();
     }
-    if (options.replayMirrorEndpoint && this.client) {
-      import("./replayMirror-QZ3GQ527.js").then(({ setupReplayMirror }) => {
-        var _a3;
-        setupReplayMirror({
-          posthogHost: (_a3 = options.apiHost) != null ? _a3 : "https://telemetry.syntrologie.com",
-          mirrorEndpoint: options.replayMirrorEndpoint
-        });
-      });
-    }
   }
   /**
    * Set up rrweb event interception on PostHog's session recording.
@@ -7197,8 +7740,9 @@ var PostHogAdapter = class {
       return;
     }
     let recorder = null;
-    for (const key of Object.getOwnPropertyNames(sr)) {
-      const val = sr[key];
+    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;
@@ -7225,9 +7769,8 @@ var PostHogAdapter = class {
    * 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.
@@ -7578,187 +8121,36 @@ 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") {
+// src/actions/validation-rules.ts
+function validateBadgeAction(action, errors, warnings) {
+  if (!action.content || typeof action.content !== "string") {
     errors.push({
-      code: "INVALID_ACTION",
-      message: "Action must be an object"
+      code: "MISSING_CONTENT",
+      message: "Badge action requires 'content' property",
+      field: "content"
+    });
+  } else if (action.content.length > 100) {
+    warnings.push({
+      code: "LONG_BADGE_CONTENT",
+      message: "Badge content is quite long",
+      suggestion: "Keep badge content short (under 100 characters)"
     });
-    return { valid: false, errors, warnings };
   }
-  const { kind } = action;
-  if (!kind || typeof kind !== "string") {
+}
+function validateTooltipAction(action, errors, _warnings) {
+  if (!action.content || typeof action.content !== "object") {
     errors.push({
-      code: "MISSING_KIND",
-      message: "Action must have a 'kind' property"
+      code: "MISSING_CONTENT",
+      message: "Tooltip action requires 'content' object",
+      field: "content"
     });
-    return { valid: false, errors, warnings };
+    return;
   }
-  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.`
-    );
+  if (!action.content.body || typeof action.content.body !== "string") {
     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;
-      }
-    }
-  }
-}
-function validateBadgeAction(action, errors, warnings) {
-  if (!action.content || typeof action.content !== "string") {
-    errors.push({
-      code: "MISSING_CONTENT",
-      message: "Badge action requires 'content' property",
-      field: "content"
-    });
-  } else if (action.content.length > 100) {
-    warnings.push({
-      code: "LONG_BADGE_CONTENT",
-      message: "Badge content is quite long",
-      suggestion: "Keep badge content short (under 100 characters)"
-    });
-  }
-}
-function validateTooltipAction(action, errors, _warnings) {
-  if (!action.content || typeof action.content !== "object") {
-    errors.push({
-      code: "MISSING_CONTENT",
-      message: "Tooltip action requires 'content' object",
-      field: "content"
-    });
-    return;
-  }
-  if (!action.content.body || typeof action.content.body !== "string") {
-    errors.push({
-      code: "MISSING_BODY",
-      message: "Tooltip content requires 'body' property",
-      field: "content.body"
+      code: "MISSING_BODY",
+      message: "Tooltip content requires 'body' property",
+      field: "content.body"
     });
   }
 }
@@ -8116,6 +8508,159 @@ function validateTourAction(action, errors, warnings) {
     }
   }
 }
+
+// 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 (!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 "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 = [];
@@ -8262,7 +8807,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 () => {
@@ -9232,6 +9777,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;
@@ -9263,8 +9868,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.
@@ -9287,35 +9900,112 @@ var EventBus = class {
     };
   }
   /**
-   * Publish an event to all matching subscribers.
+   * Publish an event to all matching subscribers.
+   */
+  publish(name, props, source = "canvas") {
+    const event = {
+      ts: Date.now(),
+      name,
+      source,
+      props,
+      schemaVersion: EVENT_SCHEMA_VERSION
+    };
+    this.publishEvent(event);
+  }
+  /**
+   * Publish a pre-constructed NormalizedEvent.
+   */
+  publishEvent(event) {
+    this.history.push(event);
+    if (this.history.length > this.maxHistorySize) {
+      this.history.shift();
+    }
+    for (const subscription of this.subscriptions) {
+      if (matchesFilter(event, subscription.filter)) {
+        try {
+          subscription.callback(event);
+        } catch (err) {
+          console.error("[EventBus] Subscriber error:", err);
+        }
+      }
+    }
+  }
+  /**
+   * 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.
    */
-  publish(name, props, source = "canvas") {
+  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,
+      source: "custom",
       props,
       schemaVersion: EVENT_SCHEMA_VERSION
     };
-    this.publishEvent(event);
-  }
-  /**
-   * Publish a pre-constructed NormalizedEvent.
-   */
-  publishEvent(event) {
     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.
@@ -9367,6 +10057,27 @@ function createEventBus(options = {}) {
   return new EventBus(options);
 }
 
+// src/events/history.ts
+var EventHistory = class {
+  constructor(maxSize = 100) {
+    __publicField(this, "entries", []);
+    __publicField(this, "maxSize");
+    this.maxSize = maxSize;
+  }
+  record(entry) {
+    this.entries.push(entry);
+    if (this.maxSize > 0 && this.entries.length > this.maxSize) {
+      this.entries.shift();
+    }
+  }
+  getAll() {
+    return [...this.entries];
+  }
+  clear() {
+    this.entries = [];
+  }
+};
+
 // src/navigation/NavigationMonitor.ts
 var NavigationMonitor = class {
   constructor() {
@@ -10478,7 +11189,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;
@@ -10650,8 +11370,141 @@ function encodeToken(payload) {
   return TOKEN_PREFIX + base64;
 }
 
-// src/bootstrap.ts
-import { createEventProcessor } from "@syntrologie/event-processor";
+// 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 = {
@@ -10790,6 +11643,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(
@@ -10901,95 +11759,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:", {
@@ -11054,13 +11826,20 @@ 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 processor = createEventProcessor({
     elementResolver: typeof window !== "undefined" ? (x, y) => {
@@ -11122,6 +11901,9 @@ 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 event processor
@@ -11134,6 +11916,11 @@ async function init(options) {
       }
     });
     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) {
@@ -11226,11 +12013,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();
@@ -11244,7 +12037,7 @@ 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;
     const config = await baseFetcher();
     console.log(
       "[Syntro Bootstrap] Config fetched:",
@@ -11252,7 +12045,7 @@ async function init(options) {
       `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"}`
     );
-    if (((_g = config.actions) == null ? void 0 : _g.length) > 0) {
+    if (((_g2 = config.actions) == null ? void 0 : _g2.length) > 0) {
       console.log(
         "[Syntro Bootstrap] Actions in config:",
         config.actions.map(
@@ -11315,10 +12108,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;
@@ -11349,8 +12165,11 @@ export {
   createSmartCanvasController,
   ShadowRootProvider,
   useShadowRoot,
-  StandardEvents,
   EVENT_SCHEMA_VERSION,
+  normalizePostHogEvent,
+  shouldNormalizeEvent,
+  createPostHogNormalizer,
+  StandardEvents2 as StandardEvents,
   CanvasEvents,
   NotificationToastStack,
   MAX_VISIBLE_TOASTS,
@@ -11399,8 +12218,11 @@ export {
   evaluateSync,
   createDecisionEngine,
   createEventAccumulator,
+  validateEventName,
+  validateProps,
   EventBus,
   createEventBus,
+  EventHistory,
   NavigationMonitor,
   StateStore,
   createStateStore,
@@ -11424,4 +12246,4 @@ export {
   encodeToken,
   Syntro
 };
-//# sourceMappingURL=chunk-H3FAYTUV.js.map
+//# sourceMappingURL=chunk-J2LGX2PV.js.map