@syntrologie/runtime-sdk 0.2.20 → 0.2.21

package/dist/smart-canvas.js

@@ -24551,33 +24551,94 @@ var SyntrologieSDK = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    ActivationConfigZ: () => ActivationConfigZ,
+    AnchorStateZ: () => AnchorStateZ,
+    AnchorVisibleConditionZ: () => AnchorVisibleConditionZ,
+    AugmentationZ: () => AugmentationZ,
+    BoundingBoxZ: () => BoundingBoxZ,
+    CanvasEvents: () => CanvasEvents,
     CanvasRecipeZ: () => CanvasRecipeZ,
+    ConditionZ: () => ConditionZ,
+    ContextManager: () => ContextManager,
+    CooldownActiveConditionZ: () => CooldownActiveConditionZ,
+    DecisionStrategyZ: () => DecisionStrategyZ,
+    DismissedConditionZ: () => DismissedConditionZ,
+    EVENT_SCHEMA_VERSION: () => EVENT_SCHEMA_VERSION,
+    EventBus: () => EventBus,
+    EventFilterZ: () => EventFilterZ,
+    EventOccurredConditionZ: () => EventOccurredConditionZ,
+    EventSourceZ: () => EventSourceZ,
+    ExternalStrategyZ: () => ExternalStrategyZ,
+    FrequencyEntryZ: () => FrequencyEntryZ,
+    FrequencyLimitConditionZ: () => FrequencyLimitConditionZ,
     HighlightStepZ: () => HighlightStepZ,
+    ModelStrategyZ: () => ModelStrategyZ,
+    NormalizedEventZ: () => NormalizedEventZ,
+    PageContextZ: () => PageContextZ,
+    PageHistoryEntryZ: () => PageHistoryEntryZ,
+    PageUrlConditionZ: () => PageUrlConditionZ,
+    RUNTIME_VERSION: () => RUNTIME_VERSION,
+    RouteConditionZ: () => RouteConditionZ,
+    RouteFilterZ: () => RouteFilterZ,
+    RuleStrategyZ: () => RuleStrategyZ,
+    RuleZ: () => RuleZ,
+    RuntimeContextZ: () => RuntimeContextZ,
+    ScoreStrategyZ: () => ScoreStrategyZ,
     SelectorZ: () => SelectorZ,
+    SessionContextZ: () => SessionContextZ,
+    SessionMetricConditionZ: () => SessionMetricConditionZ,
     SessionMetricTracker: () => SessionMetricTracker,
     ShadowCanvasOverlay: () => ShadowCanvasOverlay,
     SmartCanvasApp: () => SmartCanvasApp,
     SmartCanvasController: () => SmartCanvasController,
     SmartCanvasElement: () => SmartCanvasElement,
     SmartCanvasPortal: () => SmartCanvasPortal,
+    StandardEvents: () => StandardEvents,
+    StateEqualsConditionZ: () => StateEqualsConditionZ,
+    StateStore: () => StateStore,
+    StoredValueZ: () => StoredValueZ,
     Syntro: () => Syntro,
     TileCard: () => TileCard,
     TileWheel: () => TileWheel,
     TooltipStepZ: () => TooltipStepZ,
+    ViewportConditionZ: () => ViewportConditionZ,
+    ViewportContextZ: () => ViewportContextZ,
     createCanvasConfigFetcher: () => createCanvasConfigFetcher,
+    createContextManager: () => createContextManager,
+    createDecisionEngine: () => createDecisionEngine,
+    createEventBus: () => createEventBus,
     createGrowthBookClient: () => createGrowthBookClient,
     createOverlayRecipeFetcher: () => createOverlayRecipeFetcher,
     createPostHogClient: () => createPostHogClient,
+    createPostHogNormalizer: () => createPostHogNormalizer,
     createSessionMetricTracker: () => createSessionMetricTracker,
     createSmartCanvas: () => createSmartCanvas,
     createSmartCanvasController: () => createSmartCanvasController,
+    createSmartCanvasRuntime: () => createSmartCanvasRuntime,
+    createStateStore: () => createStateStore,
     decodeToken: () => decodeToken,
     encodeToken: () => encodeToken,
+    evaluate: () => evaluate2,
+    evaluateCondition: () => evaluateCondition,
+    evaluateRule: () => evaluateRule,
+    evaluateRuleStrategy: () => evaluateRuleStrategy,
+    evaluateScoreStrategy: () => evaluateScoreStrategy,
+    evaluateSync: () => evaluateSync,
     getAntiFlickerSnippet: () => getAntiFlickerSnippet,
+    normalizePostHogEvent: () => normalizePostHogEvent,
     registerSmartCanvasElement: () => registerSmartCanvasElement,
     resolveConfigUri: () => resolveConfigUri,
+    shouldNormalizeEvent: () => shouldNormalizeEvent,
     useShadowCanvasConfig: () => useShadowCanvasConfig,
-    validateRecipe: () => validateRecipe
+    validateActivationConfig: () => validateActivationConfig,
+    validateCondition: () => validateCondition,
+    validateEventFilter: () => validateEventFilter,
+    validateFrequencyEntry: () => validateFrequencyEntry,
+    validateNormalizedEvent: () => validateNormalizedEvent,
+    validateRecipe: () => validateRecipe,
+    validateRuntimeContext: () => validateRuntimeContext,
+    validateStoredValue: () => validateStoredValue,
+    validateStrategy: () => validateStrategy
   });
 
   // node_modules/posthog-js/dist/module.js
@@ -29118,7 +29179,7 @@ var SyntrologieSDK = (() => {
         this.client = Uo;
         const enableFeatureFlags = options.enableFeatureFlags ?? true;
         this.client.init(options.apiKey, {
-          api_host: options.apiHost ?? "https://posthog-dev.syntrologie.com",
+          api_host: options.apiHost ?? "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,
@@ -32186,7 +32247,8 @@ var SyntrologieSDK = (() => {
   function useShadowCanvasConfig({
     fetcher,
     pollIntervalMs = 3e4,
-    experiments
+    experiments,
+    runtime
   }) {
     const [state, setState] = (0, import_react.useState)({
       tiles: [],
@@ -32197,7 +32259,15 @@ var SyntrologieSDK = (() => {
         setState((prev) => ({ ...prev, isLoading: true, error: void 0 }));
         const response = await fetcher();
         let tiles = response.tiles || [];
-        if (experiments) {
+        if (runtime && response.routes) {
+          runtime.setRoutes(response.routes);
+        }
+        if (runtime) {
+          tiles = await runtime.filterTiles(tiles);
+          if (experiments) {
+            tiles = tiles.filter((tile) => experiments.shouldRenderRectangle(tile));
+          }
+        } else if (experiments) {
           tiles = tiles.filter((tile) => experiments.shouldRenderRectangle(tile));
         }
         setState({
@@ -32220,7 +32290,7 @@ var SyntrologieSDK = (() => {
           error: err instanceof Error ? err.message : "Unknown error"
         }));
       }
-    }, [experiments, fetcher]);
+    }, [experiments, fetcher, runtime]);
     (0, import_react.useEffect)(() => {
       load();
       if (!pollIntervalMs) return;
@@ -39021,6 +39091,33 @@ var SyntrologieSDK = (() => {
     console.log("[Syntro Runtime] ================================");
     return shouldLoad;
   };
+  var isAuditMode = () => {
+    console.log("[Syntro Runtime] ====== AUDIT MODE CHECK ======");
+    if (typeof window === "undefined") {
+      console.log("[Syntro Runtime] Not in browser - skipping audit");
+      return false;
+    }
+    const params = new URLSearchParams(window.location.search);
+    const hasAuditFlag = params.has("syntro_audit");
+    const auditSessionId = params.get("audit_session_id");
+    console.log("[Syntro Runtime] Audit flags:", {
+      hasAuditFlag,
+      auditSessionId: auditSessionId ? `${auditSessionId.slice(0, 8)}...` : "none"
+    });
+    if (!hasAuditFlag) {
+      console.log("[Syntro Runtime] No syntro_audit param - not in audit mode");
+      console.log("[Syntro Runtime] ================================");
+      return false;
+    }
+    console.log("[Syntro Runtime] \u2713 Audit mode active");
+    console.log("[Syntro Runtime] ================================");
+    return true;
+  };
+  var getActiveSdkMode = () => {
+    if (shouldLoadEditor()) return "editor";
+    if (isAuditMode()) return "audit";
+    return null;
+  };
   var loadEditorSdk = async (editorUrlOrOptions) => {
     console.log("[Syntro Runtime] ====== LOAD EDITOR SDK ======");
     if (typeof window === "undefined") {
@@ -39107,7 +39204,9 @@ var SyntrologieSDK = (() => {
     if (removeAntiFlicker) {
       removeAntiFlicker();
     }
-    if (shouldLoadEditor()) {
+    const sdkMode = getActiveSdkMode();
+    if (sdkMode) {
+      console.log(`[SmartCanvas] Loading editor SDK for ${sdkMode} mode`);
       loadEditorSdk(config.editorUrl).catch(console.error);
     }
     registerSmartCanvasElement();
@@ -39205,9 +39304,8 @@ var SyntrologieSDK = (() => {
       }
     };
     if (typeof window !== "undefined") {
-      const isEditorMode2 = new URLSearchParams(window.location.search).has("editor_token");
       const isDev = true;
-      if (isEditorMode2 || isDev) {
+      if (sdkMode || isDev) {
         window.__smartCanvasHandle = handle;
       }
     }
@@ -39366,6 +39464,1363 @@ var SyntrologieSDK = (() => {
     return new SessionMetricTracker(options);
   }
 
+  // src/context/schema.ts
+  var PageContextZ = external_exports.object({
+    url: external_exports.string(),
+    routeId: external_exports.string().optional(),
+    title: external_exports.string().optional(),
+    locale: external_exports.string().optional()
+  });
+  var PageHistoryEntryZ = external_exports.object({
+    url: external_exports.string(),
+    ts: external_exports.number()
+  });
+  var SessionContextZ = external_exports.object({
+    sessionId: external_exports.string(),
+    startTs: external_exports.number(),
+    pageHistory: external_exports.array(PageHistoryEntryZ).optional()
+  });
+  var ViewportContextZ = external_exports.object({
+    width: external_exports.number(),
+    height: external_exports.number()
+  });
+  var BoundingBoxZ = external_exports.object({
+    x: external_exports.number(),
+    y: external_exports.number(),
+    w: external_exports.number(),
+    h: external_exports.number()
+  });
+  var AnchorStateZ = external_exports.object({
+    anchorId: external_exports.string(),
+    present: external_exports.boolean(),
+    visible: external_exports.boolean().optional(),
+    boundingBox: BoundingBoxZ.optional()
+  });
+  var AugmentationZ = external_exports.record(
+    external_exports.union([external_exports.number(), external_exports.string(), external_exports.boolean(), external_exports.undefined()])
+  );
+  var RuntimeContextZ = external_exports.object({
+    page: PageContextZ,
+    session: SessionContextZ,
+    viewport: ViewportContextZ,
+    anchors: external_exports.array(AnchorStateZ).optional(),
+    augmented: AugmentationZ.optional()
+  });
+  function validateRuntimeContext(data) {
+    return RuntimeContextZ.safeParse(data);
+  }
+
+  // src/context/ContextManager.ts
+  function createDefaultContext() {
+    const now = Date.now();
+    return {
+      page: {
+        url: typeof window !== "undefined" ? window.location.href : "",
+        title: typeof document !== "undefined" ? document.title : void 0
+      },
+      session: {
+        sessionId: "",
+        startTs: now,
+        pageHistory: []
+      },
+      viewport: {
+        width: typeof window !== "undefined" ? window.innerWidth : 0,
+        height: typeof window !== "undefined" ? window.innerHeight : 0
+      }
+    };
+  }
+  function matchRoute2(url, routes) {
+    if (!routes) return void 0;
+    let pathname;
+    try {
+      pathname = new URL(url).pathname;
+    } catch {
+      pathname = url;
+    }
+    if (routes.exclude) {
+      for (const pattern of routes.exclude) {
+        if (matchPattern(pathname, pattern)) {
+          return void 0;
+        }
+      }
+    }
+    if (routes.include) {
+      for (const pattern of routes.include) {
+        if (matchPattern(pathname, pattern)) {
+          return pattern;
+        }
+      }
+      return void 0;
+    }
+    return pathname;
+  }
+  function matchPattern(pathname, pattern) {
+    const normalizedPath = pathname.replace(/\/$/, "") || "/";
+    const normalizedPattern = pattern.replace(/\/$/, "") || "/";
+    if (normalizedPath === normalizedPattern) return true;
+    const regexPattern = normalizedPattern.replace(/:[^/]+/g, "[^/]+").replace(/\*/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(normalizedPath);
+  }
+  var ContextManager = class {
+    constructor(options = {}) {
+      __publicField(this, "context");
+      __publicField(this, "previousContext");
+      __publicField(this, "listeners", /* @__PURE__ */ new Set());
+      __publicField(this, "telemetry");
+      __publicField(this, "routes");
+      // Event listener cleanup functions
+      __publicField(this, "cleanupFns", []);
+      this.telemetry = options.telemetry;
+      this.routes = options.routes;
+      this.context = createDefaultContext();
+      this.previousContext = { ...this.context };
+      if (options.telemetry?.getSessionId) {
+        const sessionId = options.telemetry.getSessionId();
+        if (sessionId) {
+          this.context.session.sessionId = sessionId;
+        }
+      }
+      if (options.initialPageHistory) {
+        this.context.session.pageHistory = options.initialPageHistory;
+      }
+      this.context.page.routeId = matchRoute2(this.context.page.url, this.routes);
+      this.addPageToHistory(this.context.page.url);
+      if (typeof window !== "undefined") {
+        this.setupBrowserListeners();
+      }
+    }
+    /**
+     * Get the current runtime context.
+     */
+    get() {
+      return { ...this.context };
+    }
+    /**
+     * Subscribe to context changes.
+     * Returns an unsubscribe function.
+     */
+    subscribe(callback) {
+      this.listeners.add(callback);
+      return () => {
+        this.listeners.delete(callback);
+      };
+    }
+    /**
+     * Update the routes config (e.g., when config is fetched).
+     */
+    setRoutes(routes) {
+      this.routes = routes;
+      const newRouteId = matchRoute2(this.context.page.url, this.routes);
+      if (newRouteId !== this.context.page.routeId) {
+        this.updateContext({ page: { ...this.context.page, routeId: newRouteId } });
+      }
+    }
+    /**
+     * Update anchor states.
+     */
+    setAnchors(anchors) {
+      this.updateContext({ anchors });
+    }
+    /**
+     * Manually update the session ID (e.g., when telemetry initializes).
+     */
+    setSessionId(sessionId) {
+      if (sessionId !== this.context.session.sessionId) {
+        this.updateContext({
+          session: { ...this.context.session, sessionId }
+        });
+      }
+    }
+    /**
+     * Clean up event listeners and subscriptions.
+     */
+    destroy() {
+      for (const cleanup of this.cleanupFns) {
+        cleanup();
+      }
+      this.cleanupFns = [];
+      this.listeners.clear();
+    }
+    // ==================== Private Methods ====================
+    setupBrowserListeners() {
+      let resizeTimeout;
+      const handleResize = () => {
+        clearTimeout(resizeTimeout);
+        resizeTimeout = setTimeout(() => {
+          this.updateViewport();
+        }, 100);
+      };
+      window.addEventListener("resize", handleResize);
+      this.cleanupFns.push(() => window.removeEventListener("resize", handleResize));
+      const handlePopState = () => {
+        this.updatePage();
+      };
+      window.addEventListener("popstate", handlePopState);
+      this.cleanupFns.push(() => window.removeEventListener("popstate", handlePopState));
+      const originalPushState = history.pushState.bind(history);
+      const originalReplaceState = history.replaceState.bind(history);
+      history.pushState = (...args) => {
+        originalPushState(...args);
+        this.updatePage();
+      };
+      history.replaceState = (...args) => {
+        originalReplaceState(...args);
+        this.updatePage();
+      };
+      this.cleanupFns.push(() => {
+        history.pushState = originalPushState;
+        history.replaceState = originalReplaceState;
+      });
+    }
+    updateViewport() {
+      const newViewport = {
+        width: window.innerWidth,
+        height: window.innerHeight
+      };
+      if (newViewport.width !== this.context.viewport.width || newViewport.height !== this.context.viewport.height) {
+        this.updateContext({ viewport: newViewport });
+      }
+    }
+    updatePage() {
+      const url = window.location.href;
+      const title = document.title;
+      const routeId = matchRoute2(url, this.routes);
+      const newPage = {
+        url,
+        title,
+        routeId
+      };
+      if (newPage.url !== this.context.page.url || newPage.title !== this.context.page.title || newPage.routeId !== this.context.page.routeId) {
+        if (newPage.url !== this.context.page.url) {
+          this.addPageToHistory(newPage.url);
+        }
+        this.updateContext({ page: newPage });
+      }
+    }
+    addPageToHistory(url) {
+      const entry = {
+        url,
+        ts: Date.now()
+      };
+      const pageHistory = [...this.context.session.pageHistory || [], entry];
+      if (pageHistory.length > 50) {
+        pageHistory.shift();
+      }
+      this.context.session.pageHistory = pageHistory;
+    }
+    updateContext(partial) {
+      this.previousContext = { ...this.context };
+      this.context = {
+        ...this.context,
+        ...partial
+      };
+      this.notifyListeners();
+    }
+    notifyListeners() {
+      for (const callback of this.listeners) {
+        try {
+          callback(this.context, this.previousContext);
+        } catch (err) {
+          console.error("[ContextManager] Listener error:", err);
+        }
+      }
+    }
+  };
+  function createContextManager(options = {}) {
+    return new ContextManager(options);
+  }
+
+  // src/events/types.ts
+  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"
+  };
+  var EVENT_SCHEMA_VERSION = "1.0.0";
+
+  // src/events/schema.ts
+  var EventSourceZ = external_exports.enum(["posthog", "canvas", "derived"]);
+  var NormalizedEventZ = external_exports.object({
+    ts: external_exports.number(),
+    name: external_exports.string(),
+    source: EventSourceZ,
+    props: external_exports.record(external_exports.unknown()).optional(),
+    schemaVersion: external_exports.string()
+  });
+  var EventFilterZ = external_exports.object({
+    names: external_exports.array(external_exports.string()).optional(),
+    patterns: external_exports.array(external_exports.string()).optional(),
+    sources: external_exports.array(EventSourceZ).optional()
+  });
+  function validateNormalizedEvent(data) {
+    return NormalizedEventZ.safeParse(data);
+  }
+  function validateEventFilter(data) {
+    return EventFilterZ.safeParse(data);
+  }
+
+  // src/events/EventBus.ts
+  function matchesFilter(event, filter) {
+    if (!filter) return true;
+    if (filter.names && filter.names.length > 0) {
+      if (!filter.names.includes(event.name)) {
+        return false;
+      }
+    }
+    if (filter.patterns && filter.patterns.length > 0) {
+      const matched = filter.patterns.some((pattern) => {
+        try {
+          const regex = new RegExp(pattern);
+          return regex.test(event.name);
+        } catch {
+          return false;
+        }
+      });
+      if (!matched) return false;
+    }
+    if (filter.sources && filter.sources.length > 0) {
+      if (!filter.sources.includes(event.source)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  var EventBus = class {
+    constructor(options = {}) {
+      __publicField(this, "subscriptions", /* @__PURE__ */ new Set());
+      __publicField(this, "history", []);
+      __publicField(this, "maxHistorySize");
+      this.maxHistorySize = options.maxHistorySize ?? 100;
+    }
+    /**
+     * Subscribe to events matching an optional filter.
+     * Returns an unsubscribe function.
+     */
+    subscribe(filterOrCallback, maybeCallback) {
+      let filter;
+      let callback;
+      if (typeof filterOrCallback === "function") {
+        filter = void 0;
+        callback = filterOrCallback;
+      } else {
+        filter = filterOrCallback;
+        callback = maybeCallback;
+      }
+      const subscription = { filter, callback };
+      this.subscriptions.add(subscription);
+      return () => {
+        this.subscriptions.delete(subscription);
+      };
+    }
+    /**
+     * 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);
+          }
+        }
+      }
+    }
+    /**
+     * Get recent events matching an optional filter.
+     */
+    getRecent(filter, limit) {
+      let events = this.history;
+      if (filter) {
+        events = events.filter((e2) => matchesFilter(e2, filter));
+      }
+      if (limit && limit > 0) {
+        events = events.slice(-limit);
+      }
+      return events;
+    }
+    /**
+     * Check if an event with a specific name occurred within a time window.
+     */
+    hasRecentEvent(eventName, withinMs, source) {
+      const cutoff = Date.now() - withinMs;
+      return this.history.some(
+        (e2) => e2.name === eventName && e2.ts >= cutoff && (source === void 0 || e2.source === source)
+      );
+    }
+    /**
+     * Count events matching a filter within a time window.
+     */
+    countRecentEvents(filter, withinMs) {
+      let events = this.history.filter((e2) => matchesFilter(e2, filter));
+      if (withinMs !== void 0) {
+        const cutoff = Date.now() - withinMs;
+        events = events.filter((e2) => e2.ts >= cutoff);
+      }
+      return events.length;
+    }
+    /**
+     * Clear all event history.
+     */
+    clearHistory() {
+      this.history = [];
+    }
+    /**
+     * Get the number of current subscribers.
+     */
+    getSubscriberCount() {
+      return this.subscriptions.size;
+    }
+  };
+  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) {
+    const eventName = phEvent.event;
+    if (POSTHOG_EVENT_MAP[eventName]) {
+      return POSTHOG_EVENT_MAP[eventName];
+    }
+    if (eventName === "$autocapture") {
+      const tagName = phEvent.properties?.$tag_name;
+      const eventType = phEvent.properties?.$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 extractProps(phEvent) {
+    const props = {};
+    const phProps = phEvent.properties || {};
+    if (phProps.$tag_name) props.tagName = phProps.$tag_name;
+    if (phProps.$el_text) props.elementText = phProps.$el_text;
+    if (phProps.$elements) props.elements = phProps.$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 ts2;
+    if (typeof phEvent.timestamp === "number") {
+      ts2 = phEvent.timestamp;
+    } else if (typeof phEvent.timestamp === "string") {
+      ts2 = new Date(phEvent.timestamp).getTime();
+    } else {
+      ts2 = Date.now();
+    }
+    return {
+      ts: ts2,
+      name: getEventName(phEvent),
+      source: "posthog",
+      props: extractProps(phEvent),
+      schemaVersion: EVENT_SCHEMA_VERSION
+    };
+  }
+  function shouldNormalizeEvent(phEvent) {
+    const eventName = phEvent.event;
+    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) => {
+      const phEvent = {
+        event: eventName,
+        properties,
+        timestamp: Date.now()
+      };
+      if (shouldNormalizeEvent(phEvent)) {
+        const normalizedEvent = normalizePostHogEvent(phEvent);
+        publishFn(normalizedEvent);
+      }
+    };
+  }
+
+  // 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 });
+  }
+  function tileAction(tileId, actionId, surface) {
+    return createCanvasEvent(StandardEvents.TILE_ACTION, {
+      tileId,
+      actionId,
+      surface
+    });
+  }
+  function overlayStarted(recipeId, recipeName) {
+    return createCanvasEvent(StandardEvents.OVERLAY_STARTED, {
+      recipeId,
+      recipeName
+    });
+  }
+  function overlayCompleted(recipeId, recipeName) {
+    return createCanvasEvent(StandardEvents.OVERLAY_COMPLETED, {
+      recipeId,
+      recipeName
+    });
+  }
+  function overlayDismissed(recipeId, recipeName, stepIndex) {
+    return createCanvasEvent(StandardEvents.OVERLAY_DISMISSED, {
+      recipeId,
+      recipeName,
+      stepIndex
+    });
+  }
+  function overlayStepViewed(recipeId, stepIndex, stepTitle) {
+    return createCanvasEvent(StandardEvents.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,
+    tileCollapsed,
+    tileAction,
+    overlayStarted,
+    overlayCompleted,
+    overlayDismissed,
+    overlayStepViewed,
+    custom: customCanvasEvent
+  };
+
+  // src/state/schema.ts
+  var StoredValueZ = external_exports.object({
+    value: external_exports.unknown(),
+    expiresAt: external_exports.number().optional()
+  });
+  var FrequencyEntryZ = external_exports.object({
+    count: external_exports.number(),
+    resetAt: external_exports.number().optional()
+  });
+  function validateStoredValue(data) {
+    return StoredValueZ.safeParse(data);
+  }
+  function validateFrequencyEntry(data) {
+    return FrequencyEntryZ.safeParse(data);
+  }
+
+  // src/state/helpers/dismissals.ts
+  var DISMISSAL_PREFIX = "dismissed:";
+  function createDismissalStore(sessionStorage2, userStorage) {
+    return {
+      mark(key, permanent = false) {
+        const storageKey = DISMISSAL_PREFIX + key;
+        const storage = permanent ? userStorage : sessionStorage2;
+        storage.set(storageKey, true);
+      },
+      isDismissed(key) {
+        const storageKey = DISMISSAL_PREFIX + key;
+        return sessionStorage2.has(storageKey) || userStorage.has(storageKey);
+      },
+      clear(key) {
+        const storageKey = DISMISSAL_PREFIX + key;
+        sessionStorage2.remove(storageKey);
+        userStorage.remove(storageKey);
+      },
+      clearAll() {
+        for (const key of sessionStorage2.keys()) {
+          if (key.startsWith(DISMISSAL_PREFIX)) {
+            sessionStorage2.remove(key);
+          }
+        }
+        for (const key of userStorage.keys()) {
+          if (key.startsWith(DISMISSAL_PREFIX)) {
+            userStorage.remove(key);
+          }
+        }
+      }
+    };
+  }
+
+  // src/state/helpers/cooldowns.ts
+  var COOLDOWN_PREFIX = "cooldown:";
+  function createCooldownStore(storage) {
+    return {
+      set(key, durationMs) {
+        const storageKey = COOLDOWN_PREFIX + key;
+        const expiresAt = Date.now() + durationMs;
+        storage.set(storageKey, expiresAt);
+      },
+      isActive(key) {
+        return this.remaining(key) > 0;
+      },
+      remaining(key) {
+        const storageKey = COOLDOWN_PREFIX + key;
+        const expiresAt = storage.get(storageKey);
+        if (expiresAt === void 0) return 0;
+        const remaining = expiresAt - Date.now();
+        if (remaining <= 0) {
+          storage.remove(storageKey);
+          return 0;
+        }
+        return remaining;
+      },
+      clear(key) {
+        const storageKey = COOLDOWN_PREFIX + key;
+        storage.remove(storageKey);
+      }
+    };
+  }
+
+  // src/state/helpers/frequency.ts
+  var FREQUENCY_PREFIX = "freq:";
+  function createFrequencyStore(storage) {
+    function getEntry(key) {
+      const storageKey = FREQUENCY_PREFIX + key;
+      const entry = storage.get(storageKey);
+      if (!entry) return void 0;
+      if (entry.resetAt && Date.now() >= entry.resetAt) {
+        storage.remove(storageKey);
+        return void 0;
+      }
+      return entry;
+    }
+    return {
+      increment(key, resetAfterMs) {
+        const storageKey = FREQUENCY_PREFIX + key;
+        const existing = getEntry(key);
+        const newCount = (existing?.count ?? 0) + 1;
+        const entry = {
+          count: newCount,
+          // Keep existing resetAt or set new one
+          resetAt: existing?.resetAt ?? (resetAfterMs ? Date.now() + resetAfterMs : void 0)
+        };
+        storage.set(storageKey, entry);
+        return newCount;
+      },
+      count(key) {
+        const entry = getEntry(key);
+        return entry?.count ?? 0;
+      },
+      reset(key) {
+        const storageKey = FREQUENCY_PREFIX + key;
+        storage.remove(storageKey);
+      },
+      hasReachedLimit(key, limit) {
+        return this.count(key) >= limit;
+      }
+    };
+  }
+
+  // src/state/StateStore.ts
+  var DEFAULT_NAMESPACE = "syntro";
+  function createBrowserStorage(storage, namespace) {
+    const prefix = `${namespace}:`;
+    return {
+      get(key) {
+        if (!storage) return void 0;
+        try {
+          const raw = storage.getItem(prefix + key);
+          if (!raw) return void 0;
+          const stored = JSON.parse(raw);
+          if (stored.expiresAt && Date.now() >= stored.expiresAt) {
+            storage.removeItem(prefix + key);
+            return void 0;
+          }
+          return stored.value;
+        } catch {
+          return void 0;
+        }
+      },
+      set(key, value, ttlMs) {
+        if (!storage) return;
+        try {
+          const stored = {
+            value,
+            expiresAt: ttlMs ? Date.now() + ttlMs : void 0
+          };
+          storage.setItem(prefix + key, JSON.stringify(stored));
+        } catch (err) {
+          console.warn("[StateStore] Failed to save:", err);
+        }
+      },
+      remove(key) {
+        if (!storage) return;
+        storage.removeItem(prefix + key);
+      },
+      has(key) {
+        if (!storage) return false;
+        return this.get(key) !== void 0;
+      },
+      keys() {
+        if (!storage) return [];
+        const keys = [];
+        for (let i2 = 0; i2 < storage.length; i2++) {
+          const key = storage.key(i2);
+          if (key?.startsWith(prefix)) {
+            keys.push(key.slice(prefix.length));
+          }
+        }
+        return keys;
+      },
+      clear() {
+        if (!storage) return;
+        const keysToRemove = this.keys();
+        for (const key of keysToRemove) {
+          storage.removeItem(prefix + key);
+        }
+      }
+    };
+  }
+  function createMemoryStorage(namespace) {
+    const store = /* @__PURE__ */ new Map();
+    const prefix = `${namespace}:`;
+    return {
+      get(key) {
+        const stored = store.get(prefix + key);
+        if (!stored) return void 0;
+        if (stored.expiresAt && Date.now() >= stored.expiresAt) {
+          store.delete(prefix + key);
+          return void 0;
+        }
+        return stored.value;
+      },
+      set(key, value, ttlMs) {
+        store.set(prefix + key, {
+          value,
+          expiresAt: ttlMs ? Date.now() + ttlMs : void 0
+        });
+      },
+      remove(key) {
+        store.delete(prefix + key);
+      },
+      has(key) {
+        return this.get(key) !== void 0;
+      },
+      keys() {
+        const keys = [];
+        for (const key of store.keys()) {
+          if (key.startsWith(prefix)) {
+            keys.push(key.slice(prefix.length));
+          }
+        }
+        return keys;
+      },
+      clear() {
+        for (const key of store.keys()) {
+          if (key.startsWith(prefix)) {
+            store.delete(key);
+          }
+        }
+      }
+    };
+  }
+  var StateStore = class {
+    constructor(options = {}) {
+      /** Session-scoped storage (cleared on browser close) */
+      __publicField(this, "session");
+      /** User-scoped storage (persists across sessions) */
+      __publicField(this, "user");
+      /** Dismissal tracking */
+      __publicField(this, "dismissals");
+      /** Cooldown tracking */
+      __publicField(this, "cooldowns");
+      /** Frequency tracking */
+      __publicField(this, "frequency");
+      __publicField(this, "namespace");
+      __publicField(this, "namespacedStorages", /* @__PURE__ */ new Map());
+      this.namespace = options.namespace ?? DEFAULT_NAMESPACE;
+      if (typeof window !== "undefined") {
+        this.session = createBrowserStorage(
+          typeof sessionStorage !== "undefined" ? sessionStorage : void 0,
+          this.namespace
+        );
+        this.user = createBrowserStorage(
+          typeof localStorage !== "undefined" ? localStorage : void 0,
+          this.namespace
+        );
+      } else {
+        this.session = createMemoryStorage(this.namespace);
+        this.user = createMemoryStorage(this.namespace);
+      }
+      this.dismissals = createDismissalStore(this.session, this.user);
+      this.cooldowns = createCooldownStore(this.user);
+      this.frequency = createFrequencyStore(this.session);
+    }
+    /**
+     * Create a namespaced storage scope.
+     * Useful for isolating state by adaptive/tile.
+     *
+     * @param namespace - Additional namespace segment
+     * @returns A ScopedStorage with the nested namespace
+     */
+    ns(namespace) {
+      const fullNamespace = `${this.namespace}:${namespace}`;
+      if (!this.namespacedStorages.has(fullNamespace)) {
+        const storage = typeof window !== "undefined" && typeof sessionStorage !== "undefined" ? createBrowserStorage(sessionStorage, fullNamespace) : createMemoryStorage(fullNamespace);
+        this.namespacedStorages.set(fullNamespace, storage);
+      }
+      return this.namespacedStorages.get(fullNamespace);
+    }
+  };
+  function createStateStore(options = {}) {
+    return new StateStore(options);
+  }
+
+  // src/decisions/schema.ts
+  var PageUrlConditionZ = external_exports.object({
+    type: external_exports.literal("page_url"),
+    url: external_exports.string()
+  });
+  var RouteConditionZ = external_exports.object({
+    type: external_exports.literal("route"),
+    routeId: external_exports.string()
+  });
+  var AnchorVisibleConditionZ = external_exports.object({
+    type: external_exports.literal("anchor_visible"),
+    anchorId: external_exports.string(),
+    state: external_exports.enum(["visible", "present", "absent"])
+  });
+  var EventOccurredConditionZ = external_exports.object({
+    type: external_exports.literal("event_occurred"),
+    eventName: external_exports.string(),
+    withinMs: external_exports.number().optional()
+  });
+  var StateEqualsConditionZ = external_exports.object({
+    type: external_exports.literal("state_equals"),
+    key: external_exports.string(),
+    value: external_exports.unknown()
+  });
+  var ViewportConditionZ = external_exports.object({
+    type: external_exports.literal("viewport"),
+    minWidth: external_exports.number().optional(),
+    maxWidth: external_exports.number().optional(),
+    minHeight: external_exports.number().optional(),
+    maxHeight: external_exports.number().optional()
+  });
+  var SessionMetricConditionZ = external_exports.object({
+    type: external_exports.literal("session_metric"),
+    key: external_exports.string(),
+    operator: external_exports.enum(["gte", "lte", "eq", "gt", "lt"]),
+    threshold: external_exports.number()
+  });
+  var DismissedConditionZ = external_exports.object({
+    type: external_exports.literal("dismissed"),
+    key: external_exports.string(),
+    inverted: external_exports.boolean().optional()
+  });
+  var CooldownActiveConditionZ = external_exports.object({
+    type: external_exports.literal("cooldown_active"),
+    key: external_exports.string(),
+    inverted: external_exports.boolean().optional()
+  });
+  var FrequencyLimitConditionZ = external_exports.object({
+    type: external_exports.literal("frequency_limit"),
+    key: external_exports.string(),
+    limit: external_exports.number(),
+    inverted: external_exports.boolean().optional()
+  });
+  var ConditionZ = external_exports.discriminatedUnion("type", [
+    PageUrlConditionZ,
+    RouteConditionZ,
+    AnchorVisibleConditionZ,
+    EventOccurredConditionZ,
+    StateEqualsConditionZ,
+    ViewportConditionZ,
+    SessionMetricConditionZ,
+    DismissedConditionZ,
+    CooldownActiveConditionZ,
+    FrequencyLimitConditionZ
+  ]);
+  var RuleZ = external_exports.object({
+    conditions: external_exports.array(ConditionZ),
+    value: external_exports.unknown()
+  });
+  var RuleStrategyZ = external_exports.object({
+    type: external_exports.literal("rules"),
+    rules: external_exports.array(RuleZ),
+    default: external_exports.unknown()
+  });
+  var ScoreStrategyZ = external_exports.object({
+    type: external_exports.literal("score"),
+    field: external_exports.string(),
+    threshold: external_exports.number(),
+    above: external_exports.unknown(),
+    below: external_exports.unknown()
+  });
+  var ModelStrategyZ = external_exports.object({
+    type: external_exports.literal("model"),
+    modelId: external_exports.string(),
+    inputs: external_exports.array(external_exports.string()),
+    outputMapping: external_exports.record(external_exports.unknown()),
+    default: external_exports.unknown()
+  });
+  var ExternalStrategyZ = external_exports.object({
+    type: external_exports.literal("external"),
+    endpoint: external_exports.string(),
+    method: external_exports.enum(["GET", "POST"]).optional(),
+    default: external_exports.unknown(),
+    timeoutMs: external_exports.number().optional()
+  });
+  var DecisionStrategyZ = external_exports.discriminatedUnion("type", [
+    RuleStrategyZ,
+    ScoreStrategyZ,
+    ModelStrategyZ,
+    ExternalStrategyZ
+  ]);
+  var RouteFilterZ = external_exports.object({
+    include: external_exports.array(external_exports.string()).optional(),
+    exclude: external_exports.array(external_exports.string()).optional()
+  });
+  var ActivationConfigZ = external_exports.object({
+    routes: RouteFilterZ.optional(),
+    strategy: DecisionStrategyZ.optional()
+  });
+  function validateCondition(data) {
+    return ConditionZ.safeParse(data);
+  }
+  function validateStrategy(data) {
+    return DecisionStrategyZ.safeParse(data);
+  }
+  function validateActivationConfig(data) {
+    return ActivationConfigZ.safeParse(data);
+  }
+
+  // src/decisions/strategies/rules.ts
+  function evaluateCondition(condition, evalContext) {
+    const { context, state, events } = evalContext;
+    switch (condition.type) {
+      case "page_url": {
+        const { url } = condition;
+        const currentUrl = context.page.url;
+        const pattern = url.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+        const regex = new RegExp(`^${pattern}$`);
+        return regex.test(currentUrl);
+      }
+      case "route": {
+        return context.page.routeId === condition.routeId;
+      }
+      case "anchor_visible": {
+        const anchor = context.anchors?.find(
+          (a2) => a2.anchorId === condition.anchorId
+        );
+        switch (condition.state) {
+          case "visible":
+            return anchor?.visible === true;
+          case "present":
+            return anchor?.present === true;
+          case "absent":
+            return !anchor?.present;
+          default:
+            return false;
+        }
+      }
+      case "event_occurred": {
+        if (!events) return false;
+        const withinMs = condition.withinMs ?? 6e4;
+        return events.hasRecentEvent(condition.eventName, withinMs);
+      }
+      case "state_equals": {
+        if (!state) return false;
+        return false;
+      }
+      case "viewport": {
+        const { width, height } = context.viewport;
+        if (condition.minWidth !== void 0 && width < condition.minWidth)
+          return false;
+        if (condition.maxWidth !== void 0 && width > condition.maxWidth)
+          return false;
+        if (condition.minHeight !== void 0 && height < condition.minHeight)
+          return false;
+        if (condition.maxHeight !== void 0 && height > condition.maxHeight)
+          return false;
+        return true;
+      }
+      case "session_metric": {
+        if (!state) return false;
+        const metricValue = state.getSessionMetric(condition.key);
+        const { operator, threshold } = condition;
+        switch (operator) {
+          case "gte":
+            return metricValue >= threshold;
+          case "lte":
+            return metricValue <= threshold;
+          case "eq":
+            return metricValue === threshold;
+          case "gt":
+            return metricValue > threshold;
+          case "lt":
+            return metricValue < threshold;
+          default:
+            return false;
+        }
+      }
+      case "dismissed": {
+        if (!state) return condition.inverted ?? false;
+        const isDismissed = state.isDismissed(condition.key);
+        return condition.inverted ? !isDismissed : isDismissed;
+      }
+      case "cooldown_active": {
+        if (!state) return condition.inverted ?? false;
+        const isActive = state.isCooldownActive(condition.key);
+        return condition.inverted ? !isActive : isActive;
+      }
+      case "frequency_limit": {
+        if (!state) return condition.inverted ?? false;
+        const count = state.getFrequencyCount(condition.key);
+        const limitReached = count >= condition.limit;
+        return condition.inverted ? !limitReached : limitReached;
+      }
+      default:
+        console.warn("[RuleStrategy] Unknown condition type:", condition.type);
+        return false;
+    }
+  }
+  function evaluateRule(rule, evalContext) {
+    const conditionResults = [];
+    for (const condition of rule.conditions) {
+      const result = evaluateCondition(condition, evalContext);
+      conditionResults.push({ condition, result });
+      if (!result) {
+        return { matched: false, conditionResults };
+      }
+    }
+    return { matched: true, conditionResults };
+  }
+  function evaluateRuleStrategy(strategy, evalContext) {
+    for (let i2 = 0; i2 < strategy.rules.length; i2++) {
+      const rule = strategy.rules[i2];
+      const { matched, conditionResults } = evaluateRule(rule, evalContext);
+      if (matched) {
+        return {
+          value: rule.value,
+          isFallback: false,
+          matchInfo: {
+            strategyType: "rules",
+            matchedRuleIndex: i2,
+            evaluatedConditions: conditionResults
+          }
+        };
+      }
+    }
+    return {
+      value: strategy.default,
+      isFallback: true,
+      matchInfo: {
+        strategyType: "rules"
+      }
+    };
+  }
+
+  // src/decisions/strategies/score.ts
+  function evaluateScoreStrategy(strategy, evalContext) {
+    const { context } = evalContext;
+    const score = context.augmented?.[strategy.field];
+    if (score === void 0 || typeof score !== "number") {
+      return {
+        value: strategy.below,
+        isFallback: true,
+        matchInfo: {
+          strategyType: "score"
+        }
+      };
+    }
+    const isAbove = score >= strategy.threshold;
+    return {
+      value: isAbove ? strategy.above : strategy.below,
+      isFallback: false,
+      matchInfo: {
+        strategyType: "score"
+      }
+    };
+  }
+
+  // src/decisions/engine.ts
+  function createEvaluationContext(context, options) {
+    const { state, events, sessionMetrics } = options;
+    return {
+      context,
+      state: state ? {
+        isDismissed: (key) => state.dismissals.isDismissed(key),
+        isCooldownActive: (key) => state.cooldowns.isActive(key),
+        getFrequencyCount: (key) => state.frequency.count(key),
+        getSessionMetric: (key) => sessionMetrics?.get(key) ?? 0
+      } : void 0,
+      events: events ? {
+        hasRecentEvent: (eventName, withinMs) => events.hasRecentEvent(eventName, withinMs)
+      } : void 0
+    };
+  }
+  async function evaluate2(strategy, context, options = {}) {
+    const evalContext = createEvaluationContext(context, options);
+    switch (strategy.type) {
+      case "rules":
+        return evaluateRuleStrategy(strategy, evalContext);
+      case "score":
+        return evaluateScoreStrategy(strategy, evalContext);
+      case "model":
+        return {
+          value: strategy.default,
+          isFallback: true,
+          matchInfo: {
+            strategyType: "model"
+          }
+        };
+      case "external":
+        return {
+          value: strategy.default,
+          isFallback: true,
+          matchInfo: {
+            strategyType: "external"
+          }
+        };
+      default:
+        console.warn("[DecisionEngine] Unknown strategy type:", strategy.type);
+        return {
+          value: void 0,
+          isFallback: true,
+          matchInfo: {
+            strategyType: strategy.type
+          }
+        };
+    }
+  }
+  function evaluateSync(strategy, context, options = {}) {
+    const evalContext = createEvaluationContext(context, options);
+    switch (strategy.type) {
+      case "rules":
+        return evaluateRuleStrategy(strategy, evalContext);
+      case "score":
+        return evaluateScoreStrategy(strategy, evalContext);
+      case "model":
+      case "external":
+        return {
+          value: strategy.default,
+          isFallback: true,
+          matchInfo: {
+            strategyType: strategy.type
+          }
+        };
+      default:
+        return {
+          value: void 0,
+          isFallback: true,
+          matchInfo: {
+            strategyType: strategy.type
+          }
+        };
+    }
+  }
+  function createDecisionEngine(options) {
+    return {
+      evaluate: (strategy, context) => evaluate2(strategy, context, options),
+      evaluateSync: (strategy, context) => evaluateSync(strategy, context, options)
+    };
+  }
+
+  // src/runtime.ts
+  var RUNTIME_VERSION = "2.0.0";
+  function matchesRouteFilter(url, filter) {
+    if (!filter) return true;
+    let pathname;
+    try {
+      pathname = new URL(url).pathname;
+    } catch {
+      pathname = url;
+    }
+    const normalizedPath = pathname.replace(/\/$/, "") || "/";
+    if (filter.exclude) {
+      for (const pattern of filter.exclude) {
+        if (matchRoutePattern(normalizedPath, pattern)) {
+          return false;
+        }
+      }
+    }
+    if (filter.include && filter.include.length > 0) {
+      for (const pattern of filter.include) {
+        if (matchRoutePattern(normalizedPath, pattern)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+  function matchRoutePattern(pathname, pattern) {
+    const normalizedPattern = pattern.replace(/\/$/, "") || "/";
+    if (pathname === normalizedPattern) return true;
+    const regexPattern = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/:[^/]+/g, "[^/]+");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(pathname);
+  }
+  function createSmartCanvasRuntime(options = {}) {
+    const { telemetry, sessionMetrics, routes, mode = "production", namespace } = options;
+    const context = createContextManager({
+      telemetry,
+      routes
+    });
+    const events = createEventBus();
+    const state = createStateStore({
+      namespace
+    });
+    const decisionEngine = createDecisionEngine({
+      state,
+      events,
+      sessionMetrics
+    });
+    const runtime = {
+      telemetry,
+      context,
+      events,
+      state,
+      sessionMetrics,
+      version: RUNTIME_VERSION,
+      mode,
+      async evaluate(strategy) {
+        return decisionEngine.evaluate(strategy, context.get());
+      },
+      evaluateSync(strategy) {
+        return decisionEngine.evaluateSync(strategy, context.get());
+      },
+      async filterTiles(tiles) {
+        const currentUrl = context.get().page.url;
+        const results = [];
+        for (const tile of tiles) {
+          const activation = tile.activation;
+          if (!activation) {
+            results.push(tile);
+            continue;
+          }
+          if (!matchesRouteFilter(currentUrl, activation.routes)) {
+            continue;
+          }
+          if (!activation.strategy) {
+            results.push(tile);
+            continue;
+          }
+          const result = await this.evaluate(activation.strategy);
+          if (result.value) {
+            results.push(tile);
+          }
+        }
+        return results;
+      },
+      setRoutes(routes2) {
+        context.setRoutes(routes2);
+      },
+      destroy() {
+        context.destroy();
+      }
+    };
+    return runtime;
+  }
+
   // src/token.ts
   var TOKEN_PREFIX = "syn_";
   function decodeToken(token) {
@@ -39617,6 +41072,20 @@ var SyntrologieSDK = (() => {
     });
     return hasToken;
   }
+  function isAuditMode3() {
+    if (typeof window === "undefined") {
+      console.log("[Syntro Bootstrap] isAuditMode: not in browser");
+      return false;
+    }
+    const params = new URLSearchParams(window.location.search);
+    const hasAuditFlag = params.has("syntro_audit");
+    console.log("[Syntro Bootstrap] isAuditMode check:", {
+      url: window.location.href,
+      hasAuditFlag,
+      auditSessionId: params.get("audit_session_id") ?? "none"
+    });
+    return hasAuditFlag;
+  }
   var SEGMENT_CACHE_KEY = "syntro_segment_attributes";
   function loadCachedSegmentAttributes() {
     if (typeof window === "undefined") return {};
@@ -39659,24 +41128,26 @@ var SyntrologieSDK = (() => {
       hasCanvasOptions: !!options.canvas
     });
     const editorMode = isEditorMode();
-    console.log("[Syntro Bootstrap] Editor mode:", editorMode);
+    const auditMode = isAuditMode3();
+    const sdkMode = editorMode ? "editor" : auditMode ? "audit" : null;
+    console.log("[Syntro Bootstrap] SDK mode:", sdkMode ?? "normal");
     let payload;
     if (options.token) {
       if (options.token.startsWith("syn_")) {
         console.log("[Syntro Bootstrap] Token starts with syn_, decoding...");
         payload = decodeToken(options.token);
-      } else if (!editorMode) {
-        console.error("[Syntro Bootstrap] \u274C Token does not start with syn_ and NOT in editor mode!");
+      } else if (!sdkMode) {
+        console.error("[Syntro Bootstrap] \u274C Token does not start with syn_ and NOT in editor/audit mode!");
         console.error("[Syntro Bootstrap] Token received:", options.token);
         throw new Error("Invalid Syntro token: must start with 'syn_'");
       } else {
-        console.log("[Syntro Bootstrap] \u2713 Non-syn_ token allowed (editor mode)");
+        console.log(`[Syntro Bootstrap] \u2713 Non-syn_ token allowed (${sdkMode} mode)`);
       }
-    } else if (!editorMode) {
-      console.error("[Syntro Bootstrap] \u274C No token provided and NOT in editor mode!");
-      throw new Error("Syntro token is required (unless in editor mode)");
+    } else if (!sdkMode) {
+      console.error("[Syntro Bootstrap] \u274C No token provided and NOT in editor/audit mode!");
+      throw new Error("Syntro token is required (unless in editor or audit mode)");
     } else {
-      console.log("[Syntro Bootstrap] \u2713 No token, but editor mode - proceeding");
+      console.log(`[Syntro Bootstrap] \u2713 No token, but ${sdkMode} mode - proceeding`);
     }
     const experimentHost = getEnvVar("NEXT_PUBLIC_SYNTRO_EXPERIMENT_HOST") || getEnvVar("VITE_SYNTRO_EXPERIMENT_HOST") || payload?.eh;
     const telemetryHost = getEnvVar("NEXT_PUBLIC_SYNTRO_TELEMETRY_HOST") || getEnvVar("VITE_SYNTRO_TELEMETRY_HOST") || payload?.th;
@@ -39752,7 +41223,23 @@ var SyntrologieSDK = (() => {
       integrations: { experiments, telemetry },
       editorUrl
     });
-    return { canvas, experiments, telemetry, sessionMetrics };
+    let runtimeMode = "production";
+    if (editorMode) runtimeMode = "editor";
+    else if (auditMode) runtimeMode = "audit";
+    else if (getEnvVar("NODE_ENV") === "development") runtimeMode = "development";
+    const runtime = createSmartCanvasRuntime({
+      telemetry,
+      sessionMetrics,
+      mode: runtimeMode
+    });
+    console.log("[Syntro Bootstrap] Runtime created:", {
+      version: runtime.version,
+      mode: runtime.mode,
+      hasContext: !!runtime.context,
+      hasEvents: !!runtime.events,
+      hasState: !!runtime.state
+    });
+    return { canvas, runtime, experiments, telemetry, sessionMetrics };
   }
   var Syntro = {
     init,