@syntrologie/runtime-sdk 2.2.0-canary.9 → 2.2.0

package/dist/integrations/gtm-bridge.d.ts

@@ -0,0 +1,36 @@
+/**
+ * GTM DataLayer Bridge
+ *
+ * Subscribes to the EventBus and pushes events to window.dataLayer
+ * so customers' existing GTM setups can surface Syntro events.
+ */
+export interface GtmBridgeConfig {
+    /** EventBus to subscribe to */
+    eventBus: {
+        subscribe: (filter: {
+            names?: string[];
+            patterns?: string[];
+        }, callback: (event: {
+            name: string;
+            props?: Record<string, unknown>;
+            source?: string;
+            ts: number;
+        }) => void) => () => void;
+    };
+    /** Prefix for event names in dataLayer. @default "syntro" */
+    prefix?: string;
+    /** Optional filter -- return true to include event, false to skip */
+    eventFilter?: (eventName: string) => boolean;
+}
+export interface GtmBridge {
+    destroy: () => void;
+}
+declare global {
+    interface Window {
+        dataLayer?: Array<Record<string, unknown>>;
+    }
+}
+/**
+ * Create a GTM DataLayer bridge that forwards EventBus events to window.dataLayer.
+ */
+export declare function createGtmBridge(config: GtmBridgeConfig): GtmBridge;

package/dist/navigation/NavigationMonitor.d.ts

@@ -0,0 +1,45 @@
+/**
+ * NavigationMonitor - Centralized History API patching.
+ *
+ * This is the SINGLE point in the SDK that wraps history.pushState and
+ * history.replaceState. All other modules that need to react to navigation
+ * (ContextManager, overlay runner, tour executor, SmartCanvasApp) must
+ * subscribe to this monitor instead of patching the History API directly.
+ *
+ * This prevents the "quadruple-patching" problem where multiple SDK modules
+ * each wrap pushState/replaceState independently, creating a fragile chain
+ * that can break when combined with React Router, GA4, and GTM — all of
+ * which also wrap the History API.
+ */
+export type NavigationMethod = 'pushState' | 'replaceState' | 'popstate';
+export type NavigationListener = (url: string, method: NavigationMethod) => void;
+export interface NavigationDiagnostics {
+    /** Whether pushState was native (not already wrapped) when we captured it */
+    isNative: boolean;
+    /** Number of active subscribers */
+    subscriberCount: number;
+}
+export declare class NavigationMonitor {
+    private listeners;
+    private capturedPushState;
+    private capturedReplaceState;
+    private wasNative;
+    private destroyed;
+    constructor();
+    /**
+     * Subscribe to navigation events.
+     * Returns an unsubscribe function.
+     */
+    subscribe(listener: NavigationListener): () => void;
+    /**
+     * Get diagnostics about the History API chain.
+     */
+    diagnose(): NavigationDiagnostics;
+    /**
+     * Restore the History API to the state we captured and remove all listeners.
+     */
+    destroy(): void;
+    private onPopState;
+    private notify;
+    private isNativeFunction;
+}

package/dist/overlays/runtime/utils/AnchorWatcher.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AnchorWatcher — Detects when an anchor element is removed from the DOM.
+ *
+ * Uses MutationObserver on document.body to watch for subtree changes
+ * that disconnect the watched element. Calls onDetach exactly once
+ * when the anchor's isConnected becomes false.
+ */
+export interface AnchorWatcherOptions {
+    /** Called once when the anchor element is removed from the DOM. */
+    onDetach: () => void;
+}
+export declare class AnchorWatcher {
+    private opts;
+    private anchor;
+    private observer;
+    private detached;
+    constructor(anchor: HTMLElement, opts: AnchorWatcherOptions);
+    /** Returns the current connection status of the anchor. */
+    isConnected(): boolean;
+    /** Stop watching. Safe to call multiple times. */
+    destroy(): void;
+}

package/dist/overlays/types.d.ts

@@ -119,4 +119,6 @@ export type OverlayContext = {
     telemetry?: {
         setPersonPropertiesOnce?: (props: Record<string, unknown>) => void;
     };
+    /** Subscribe to navigation changes (from NavigationMonitor) */
+    subscribeNavigation?: (callback: (url: string, method: string) => void) => () => void;
 };

package/dist/react.js

@@ -1,6 +1,6 @@
 import {
   Syntro
-} from "./chunk-UEAP7WOK.js";
+} from "./chunk-V4MDQX67.js";
 import "./chunk-AYTRRBR5.js";
 
 // src/react.tsx

package/dist/runtime.d.ts

@@ -20,6 +20,7 @@ import type { DecisionResult, DecisionStrategy } from './decisions/types';
 import { type EventAccumulator } from './events/EventAccumulator';
 import { type EventBus } from './events/EventBus';
 import type { SessionMetricTracker } from './metrics/sessionMetrics';
+import { NavigationMonitor } from './navigation/NavigationMonitor';
 import { type StateStore } from './state/StateStore';
 import { type Surfaces } from './surfaces';
 import type { TelemetryClient } from './telemetry/types';
@@ -59,6 +60,8 @@ export interface SmartCanvasRuntime {
     apps: AppRegistry;
     /** Event accumulator for event_count conditions */
     accumulator: EventAccumulator;
+    /** Centralized navigation monitor for History API interception */
+    navigation: NavigationMonitor;
     /** Runtime version */
     version: string;
     /** Runtime mode */