@sessionvision/core 0.2.0

package/dist/sessionvision.cjs.js

@@ -0,0 +1,1903 @@
+/*!
+ * Session Vision Core v0.2.0
+ * (c) 2026 Session Vision
+ * Released under the MIT License
+ */
+'use strict';
+
+/**
+ * Session Vision Snippet Type Definitions
+ */
+/**
+ * Storage key constants
+ */
+const STORAGE_KEYS = {
+    ANONYMOUS_ID: 'sessionvision_anonymous_id',
+    USER_ID: 'sessionvision_user_id',
+    SESSION: 'sessionvision_session',
+    REGISTERED_PROPS: 'sessionvision_registered',
+    REGISTERED_ONCE_PROPS: 'sessionvision_registered_once',
+    CONFIG_CACHE: 'sessionvision_config',
+};
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+    apiHost: 'https://cdn.sessionvision.com',
+    ingestHost: 'https://app.sessionvision.com',
+    version: 'latest',
+    debug: false,
+    optOut: false,
+    maskAllInputs: true,
+    autocapture: {
+        pageview: true,
+        clicks: true,
+        formSubmit: true,
+    },
+};
+/**
+ * Session timeout in milliseconds (30 minutes)
+ */
+const SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+/**
+ * Event buffer configuration
+ */
+const BUFFER_CONFIG = {
+    MAX_EVENTS: 10,
+    FLUSH_INTERVAL_MS: 5000,
+    MAX_RETRIES: 3,
+    RETRY_DELAYS_MS: [1000, 2000, 4000],
+};
+/**
+ * Config cache TTL in milliseconds (1 hour)
+ */
+const CONFIG_CACHE_TTL_MS = 60 * 60 * 1000;
+
+/**
+ * Storage utility for localStorage and sessionStorage operations
+ * Provides safe access with error handling for environments where storage is unavailable
+ */
+/**
+ * Check if localStorage is available
+ */
+function isLocalStorageAvailable() {
+    try {
+        const testKey = '__sessionvision_test__';
+        window.localStorage.setItem(testKey, testKey);
+        window.localStorage.removeItem(testKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if sessionStorage is available
+ */
+function isSessionStorageAvailable() {
+    try {
+        const testKey = '__sessionvision_test__';
+        window.sessionStorage.setItem(testKey, testKey);
+        window.sessionStorage.removeItem(testKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get a value from localStorage
+ */
+function getLocalStorage(key) {
+    if (!isLocalStorageAvailable()) {
+        return null;
+    }
+    try {
+        const value = window.localStorage.getItem(key);
+        if (value === null) {
+            return null;
+        }
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Set a value in localStorage
+ */
+function setLocalStorage(key, value) {
+    if (!isLocalStorageAvailable()) {
+        return false;
+    }
+    try {
+        window.localStorage.setItem(key, JSON.stringify(value));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove a value from localStorage
+ */
+function removeLocalStorage(key) {
+    if (!isLocalStorageAvailable()) {
+        return false;
+    }
+    try {
+        window.localStorage.removeItem(key);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get a value from sessionStorage
+ */
+function getSessionStorage(key) {
+    if (!isSessionStorageAvailable()) {
+        return null;
+    }
+    try {
+        const value = window.sessionStorage.getItem(key);
+        if (value === null) {
+            return null;
+        }
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Set a value in sessionStorage
+ */
+function setSessionStorage(key, value) {
+    if (!isSessionStorageAvailable()) {
+        return false;
+    }
+    try {
+        window.sessionStorage.setItem(key, JSON.stringify(value));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove a value from sessionStorage
+ */
+function removeSessionStorage(key) {
+    if (!isSessionStorageAvailable()) {
+        return false;
+    }
+    try {
+        window.sessionStorage.removeItem(key);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get a raw string value from localStorage (without JSON parsing)
+ */
+function getLocalStorageRaw(key) {
+    if (!isLocalStorageAvailable()) {
+        return null;
+    }
+    try {
+        return window.localStorage.getItem(key);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Set a raw string value in localStorage (without JSON stringifying)
+ */
+function setLocalStorageRaw(key, value) {
+    if (!isLocalStorageAvailable()) {
+        return false;
+    }
+    try {
+        window.localStorage.setItem(key, value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * UUID v4 generation utility
+ * Generates cryptographically random UUIDs when available, falls back to Math.random
+ */
+/**
+ * Generate a UUID v4 string
+ * Uses crypto.randomUUID() when available, falls back to manual generation
+ */
+function generateUUID() {
+    // Use native crypto.randomUUID if available (modern browsers)
+    if (typeof crypto !== 'undefined' &&
+        typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    // Fallback using crypto.getRandomValues
+    if (typeof crypto !== 'undefined' &&
+        typeof crypto.getRandomValues === 'function') {
+        const bytes = new Uint8Array(16);
+        crypto.getRandomValues(bytes);
+        // Set version (4) and variant (RFC 4122)
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        return formatUUID(bytes);
+    }
+    // Final fallback using Math.random (less secure but works everywhere)
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Format a Uint8Array as a UUID string
+ */
+function formatUUID(bytes) {
+    const hex = [];
+    for (let i = 0; i < bytes.length; i++) {
+        hex.push(bytes[i].toString(16).padStart(2, '0'));
+    }
+    return [
+        hex.slice(0, 4).join(''),
+        hex.slice(4, 6).join(''),
+        hex.slice(6, 8).join(''),
+        hex.slice(8, 10).join(''),
+        hex.slice(10, 16).join(''),
+    ].join('-');
+}
+/**
+ * Validate a UUID string format
+ */
+function isValidUUID(uuid) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(uuid);
+}
+
+/**
+ * Session ID management
+ * Manages session lifecycle with configurable inactivity timeout
+ */
+let cachedSessionData = null;
+let sessionTimeoutMs = SESSION_TIMEOUT_MS;
+/**
+ * Set the session timeout duration (for server-side configuration)
+ */
+function setSessionTimeout(timeoutMinutes) {
+    sessionTimeoutMs = timeoutMinutes * 60 * 1000;
+}
+/**
+ * Get or create a session ID
+ * Creates a new session if:
+ * - No existing session
+ * - Session has timed out (30 minutes of inactivity by default)
+ */
+function getSessionId() {
+    const now = Date.now();
+    // Check cached session first
+    if (cachedSessionData) {
+        if (now - cachedSessionData.lastActivity < sessionTimeoutMs) {
+            // Session still active, update activity
+            updateSessionActivity(cachedSessionData.id);
+            return cachedSessionData.id;
+        }
+    }
+    // Check stored session
+    const stored = getSessionStorage(STORAGE_KEYS.SESSION);
+    if (stored && isValidUUID(stored.id)) {
+        if (now - stored.lastActivity < sessionTimeoutMs) {
+            // Session still active, update activity and cache
+            updateSessionActivity(stored.id);
+            return stored.id;
+        }
+    }
+    // Create new session
+    return createNewSession();
+}
+/**
+ * Create a new session
+ */
+function createNewSession() {
+    const sessionId = generateUUID();
+    cachedSessionData = {
+        id: sessionId,
+        lastActivity: Date.now(),
+    };
+    setSessionStorage(STORAGE_KEYS.SESSION, cachedSessionData);
+    return sessionId;
+}
+/**
+ * Update the session's last activity timestamp
+ */
+function updateSessionActivity(sessionId) {
+    cachedSessionData = {
+        id: sessionId,
+        lastActivity: Date.now(),
+    };
+    setSessionStorage(STORAGE_KEYS.SESSION, cachedSessionData);
+}
+/**
+ * Reset the session (clear storage and cache)
+ */
+function resetSession() {
+    cachedSessionData = null;
+    removeSessionStorage(STORAGE_KEYS.SESSION);
+    return createNewSession();
+}
+
+/**
+ * Configuration management module
+ * Handles fetching, caching, and merging configuration
+ */
+/**
+ * Resolve user config with defaults
+ */
+function resolveConfig(projectToken, userConfig) {
+    // Parse autocapture config
+    let autocapture = { ...DEFAULT_CONFIG.autocapture };
+    if (userConfig?.autocapture !== undefined) {
+        if (typeof userConfig.autocapture === 'boolean') {
+            // Boolean: enable or disable all
+            autocapture = {
+                pageview: userConfig.autocapture,
+                clicks: userConfig.autocapture,
+                formSubmit: userConfig.autocapture,
+            };
+        }
+        else if (typeof userConfig.autocapture === 'object') {
+            // Object: merge with defaults
+            const userAutocapture = userConfig.autocapture;
+            autocapture = {
+                pageview: userAutocapture.pageview ?? DEFAULT_CONFIG.autocapture.pageview,
+                clicks: userAutocapture.clicks ?? DEFAULT_CONFIG.autocapture.clicks,
+                formSubmit: userAutocapture.formSubmit ?? DEFAULT_CONFIG.autocapture.formSubmit,
+            };
+        }
+    }
+    return {
+        projectToken,
+        apiHost: userConfig?.apiHost ?? DEFAULT_CONFIG.apiHost,
+        ingestHost: userConfig?.ingestHost ?? DEFAULT_CONFIG.ingestHost,
+        version: userConfig?.version ?? DEFAULT_CONFIG.version,
+        debug: userConfig?.debug ?? DEFAULT_CONFIG.debug,
+        optOut: userConfig?.optOut ?? DEFAULT_CONFIG.optOut,
+        maskAllInputs: userConfig?.maskAllInputs ?? DEFAULT_CONFIG.maskAllInputs,
+        autocapture,
+    };
+}
+/**
+ * Get the cache key for a project's config
+ */
+function getCacheKey(projectToken) {
+    return `${STORAGE_KEYS.CONFIG_CACHE}_${projectToken}`;
+}
+/**
+ * Get cached remote config if valid
+ */
+function getCachedConfig(projectToken) {
+    const cached = getLocalStorage(getCacheKey(projectToken));
+    if (!cached) {
+        return null;
+    }
+    // Check if cache is expired
+    if (Date.now() - cached.timestamp > CONFIG_CACHE_TTL_MS) {
+        return null;
+    }
+    return cached.config;
+}
+/**
+ * Save remote config to cache
+ */
+function setCachedConfig(projectToken, config) {
+    const cached = {
+        config,
+        timestamp: Date.now(),
+    };
+    setLocalStorage(getCacheKey(projectToken), cached);
+}
+/**
+ * Fetch remote configuration from server
+ */
+async function fetchRemoteConfig(resolvedConfig) {
+    const { projectToken, debug } = resolvedConfig;
+    // Check cache first
+    const cached = getCachedConfig(projectToken);
+    if (cached) {
+        if (debug) {
+            console.log('[SessionVision] Using cached config');
+        }
+        return cached;
+    }
+    try {
+        // Fetch config from CDN (static file hosted at apiHost)
+        const url = `${resolvedConfig.apiHost}/static/config/${projectToken}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Config fetch failed: ${response.status}`);
+        }
+        const config = await response.json();
+        // Cache the config
+        setCachedConfig(projectToken, config);
+        if (debug) {
+            console.log('[SessionVision] Remote config fetched:', config);
+        }
+        return config;
+    }
+    catch (error) {
+        if (debug) {
+            console.warn('[SessionVision] Failed to fetch remote config:', error);
+        }
+        // Try to use stale cache as fallback
+        const staleCache = getLocalStorage(getCacheKey(projectToken));
+        if (staleCache) {
+            if (debug) {
+                console.log('[SessionVision] Using stale cached config');
+            }
+            return staleCache.config;
+        }
+        return null;
+    }
+}
+/**
+ * Apply remote config settings
+ */
+function applyRemoteConfig(remoteConfig) {
+    // Apply session timeout if specified
+    if (remoteConfig.session?.timeoutMinutes) {
+        setSessionTimeout(remoteConfig.session.timeoutMinutes);
+    }
+}
+
+/**
+ * Anonymous ID management
+ * Generates and persists anonymous user identifiers using UUID v4
+ */
+let cachedAnonymousId = null;
+/**
+ * Get the current anonymous ID, creating one if it doesn't exist
+ */
+function getAnonymousId() {
+    // Return cached value if available
+    if (cachedAnonymousId) {
+        return cachedAnonymousId;
+    }
+    // Try to load from localStorage
+    const stored = getLocalStorageRaw(STORAGE_KEYS.ANONYMOUS_ID);
+    if (stored && isValidUUID(stored)) {
+        cachedAnonymousId = stored;
+        return cachedAnonymousId;
+    }
+    // Generate new anonymous ID
+    cachedAnonymousId = generateUUID();
+    setLocalStorageRaw(STORAGE_KEYS.ANONYMOUS_ID, cachedAnonymousId);
+    return cachedAnonymousId;
+}
+/**
+ * Reset the anonymous ID (generates a new one)
+ * Called during reset() when user logs out
+ */
+function resetAnonymousId() {
+    cachedAnonymousId = generateUUID();
+    setLocalStorageRaw(STORAGE_KEYS.ANONYMOUS_ID, cachedAnonymousId);
+    return cachedAnonymousId;
+}
+
+/**
+ * User identification management
+ * Handles identify() calls and user ID persistence
+ */
+let cachedUserId = null;
+let identifyCallback = null;
+/**
+ * Set the callback to be called when identify() is invoked
+ * Used by the SDK to capture an $identify event
+ */
+function setIdentifyCallback(callback) {
+    identifyCallback = callback;
+}
+/**
+ * Get the current user ID, or null if not identified
+ */
+function getUserId() {
+    // Return cached value if available
+    if (cachedUserId !== null) {
+        return cachedUserId;
+    }
+    // Try to load from localStorage
+    const stored = getLocalStorageRaw(STORAGE_KEYS.USER_ID);
+    if (stored) {
+        cachedUserId = stored;
+        return cachedUserId;
+    }
+    return null;
+}
+/**
+ * Identify a user with an ID and optional traits
+ * - Sets the user ID in localStorage
+ * - Triggers an $identify event with traits
+ * - Forward-only: does not retroactively link past anonymous events
+ */
+function identify$1(userId, traits) {
+    if (!userId || typeof userId !== 'string') {
+        console.warn('[SessionVision] identify() requires a non-empty user ID string');
+        return;
+    }
+    // Normalize userId
+    const normalizedUserId = userId.trim();
+    if (!normalizedUserId) {
+        console.warn('[SessionVision] identify() requires a non-empty user ID string');
+        return;
+    }
+    // Set user ID
+    cachedUserId = normalizedUserId;
+    setLocalStorageRaw(STORAGE_KEYS.USER_ID, normalizedUserId);
+    // Trigger $identify event callback
+    if (identifyCallback) {
+        identifyCallback(normalizedUserId, traits);
+    }
+}
+/**
+ * Get the distinct ID (user ID if identified, anonymous ID otherwise)
+ */
+function getDistinctId() {
+    const userId = getUserId();
+    return userId || getAnonymousId();
+}
+/**
+ * Reset user identity
+ * - Clears user ID
+ * - Generates new anonymous ID
+ * - Starts new session
+ * Used on logout
+ */
+function reset$1() {
+    // Clear user ID
+    cachedUserId = null;
+    removeLocalStorage(STORAGE_KEYS.USER_ID);
+    // Generate new anonymous ID
+    resetAnonymousId();
+    // Start new session
+    resetSession();
+    // Clear registered properties
+    removeLocalStorage(STORAGE_KEYS.REGISTERED_PROPS);
+    removeLocalStorage(STORAGE_KEYS.REGISTERED_ONCE_PROPS);
+}
+
+/**
+ * DOM utility functions for element inspection and event handling
+ */
+/**
+ * Get the visible text content of an element, truncated to maxLength
+ */
+function getElementText(element, maxLength = 100) {
+    // Check for data-sessionvision-mask attribute
+    if (element.hasAttribute('data-sessionvision-mask')) {
+        return '[masked]';
+    }
+    const text = element.textContent?.trim().replace(/\s+/g, ' ').slice(0, maxLength) || '';
+    return text;
+}
+/**
+ * Get CSS classes of an element as a space-separated string
+ */
+function getElementClasses(element) {
+    if (element.classList && element.classList.length > 0) {
+        return Array.from(element.classList).join(' ');
+    }
+    return '';
+}
+/**
+ * Get the tag name of an element in lowercase
+ */
+function getElementTag(element) {
+    return element.tagName?.toLowerCase() || '';
+}
+/**
+ * Get the ID of an element, or null if not present
+ */
+function getElementId(element) {
+    return element.id || null;
+}
+/**
+ * Get the href attribute for anchor elements
+ */
+function getElementHref(element) {
+    if (element instanceof HTMLAnchorElement) {
+        return element.href || null;
+    }
+    return element.getAttribute('href');
+}
+/**
+ * Check if an element should be ignored for tracking
+ */
+function shouldIgnoreElement(element) {
+    // Check for explicit ignore attribute
+    if (element.hasAttribute('data-sessionvision-ignore')) {
+        return true;
+    }
+    // Ignore elements inside sessionvision-ignore containers
+    const closestIgnore = element.closest('[data-sessionvision-ignore]');
+    if (closestIgnore) {
+        return true;
+    }
+    // Ignore hidden elements
+    if (element instanceof HTMLElement) {
+        const style = window.getComputedStyle(element);
+        if (style.display === 'none' || style.visibility === 'hidden') {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if an element is interactive (clickable, input, etc.)
+ */
+function isInteractiveElement(element) {
+    const tag = getElementTag(element);
+    const interactiveTags = [
+        'a',
+        'button',
+        'input',
+        'select',
+        'textarea',
+        'label',
+    ];
+    if (interactiveTags.includes(tag)) {
+        return true;
+    }
+    // Check for role attributes
+    const role = element.getAttribute('role');
+    if (role && ['button', 'link', 'checkbox', 'radio', 'tab'].includes(role)) {
+        return true;
+    }
+    // Check for click handlers or tabindex
+    if (element.hasAttribute('onclick') ||
+        element.hasAttribute('tabindex') ||
+        (element instanceof HTMLElement && element.contentEditable === 'true')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get the closest interactive parent element
+ */
+function getInteractiveParent(element) {
+    let current = element;
+    while (current) {
+        if (isInteractiveElement(current)) {
+            return current;
+        }
+        current = current.parentElement;
+    }
+    return null;
+}
+/**
+ * Safe document ready check
+ */
+function onDocumentReady(callback) {
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', callback);
+    }
+    else {
+        callback();
+    }
+}
+/**
+ * Get the current page URL
+ */
+function getCurrentUrl() {
+    return window.location.href;
+}
+/**
+ * Get the document referrer
+ */
+function getReferrer() {
+    return document.referrer || '';
+}
+/**
+ * Get the document title
+ */
+function getDocumentTitle() {
+    return document.title || '';
+}
+
+/**
+ * Automatic properties module
+ * Collects browser, device, and environment information
+ */
+/**
+ * Parse browser and version from user agent
+ */
+function parseBrowser() {
+    const ua = navigator.userAgent;
+    // Order matters - check more specific browsers first
+    const browsers = [
+        { name: 'Edge', pattern: /Edg(?:e|A|iOS)?\/(\d+(?:\.\d+)*)/ },
+        { name: 'Chrome', pattern: /Chrome\/(\d+(?:\.\d+)*)/ },
+        { name: 'Firefox', pattern: /Firefox\/(\d+(?:\.\d+)*)/ },
+        { name: 'Safari', pattern: /Version\/(\d+(?:\.\d+)*).*Safari/ },
+        { name: 'Opera', pattern: /OPR\/(\d+(?:\.\d+)*)/ },
+        { name: 'IE', pattern: /MSIE (\d+(?:\.\d+)*)|Trident.*rv:(\d+(?:\.\d+)*)/ },
+    ];
+    for (const browser of browsers) {
+        const match = ua.match(browser.pattern);
+        if (match) {
+            return {
+                name: browser.name,
+                version: match[1] || match[2] || 'unknown',
+            };
+        }
+    }
+    return { name: 'unknown', version: 'unknown' };
+}
+/**
+ * Parse operating system from user agent
+ */
+function parseOS() {
+    const ua = navigator.userAgent;
+    const osPatterns = [
+        { name: 'iOS', pattern: /iPad|iPhone|iPod/ },
+        { name: 'Android', pattern: /Android/ },
+        { name: 'Windows', pattern: /Windows NT/ },
+        { name: 'macOS', pattern: /Mac OS X/ },
+        { name: 'Linux', pattern: /Linux/ },
+        { name: 'Chrome OS', pattern: /CrOS/ },
+    ];
+    for (const os of osPatterns) {
+        if (os.pattern.test(ua)) {
+            return os.name;
+        }
+    }
+    return 'unknown';
+}
+/**
+ * Determine device type from user agent and screen size
+ */
+function parseDeviceType() {
+    const ua = navigator.userAgent;
+    // Check for tablet patterns first
+    if (/iPad|tablet|playbook|silk/i.test(ua)) {
+        return 'tablet';
+    }
+    // Check for mobile patterns
+    if (/Mobile|Android|iP(hone|od)|IEMobile|BlackBerry|Opera Mini/i.test(ua)) {
+        return 'mobile';
+    }
+    // Fallback to screen width heuristic
+    const screenWidth = window.screen?.width || window.innerWidth;
+    if (screenWidth < 768) {
+        return 'mobile';
+    }
+    if (screenWidth < 1024) {
+        return 'tablet';
+    }
+    return 'desktop';
+}
+/**
+ * Get the user's timezone
+ */
+function getTimezone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Get the user's locale
+ */
+function getLocale() {
+    return navigator.language || 'unknown';
+}
+/**
+ * Get the connection type if available
+ */
+function getConnectionType() {
+    const connection = navigator
+        .connection;
+    return connection?.effectiveType || null;
+}
+/**
+ * Get all automatic properties
+ */
+function getAutomaticProperties() {
+    const browser = parseBrowser();
+    return {
+        $current_url: getCurrentUrl(),
+        $referrer: getReferrer(),
+        $browser: browser.name,
+        $browser_version: browser.version,
+        $os: parseOS(),
+        $device_type: parseDeviceType(),
+        $screen_width: window.screen?.width || 0,
+        $screen_height: window.screen?.height || 0,
+        $viewport_width: window.innerWidth || 0,
+        $viewport_height: window.innerHeight || 0,
+        $timezone: getTimezone(),
+        $locale: getLocale(),
+        $connection_type: getConnectionType(),
+        $lib_version: "0.2.0"
+            ,
+    };
+}
+/**
+ * Get registered properties (properties sent with every event)
+ */
+function getRegisteredProperties() {
+    const props = getLocalStorage(STORAGE_KEYS.REGISTERED_PROPS);
+    const onceProps = getLocalStorage(STORAGE_KEYS.REGISTERED_ONCE_PROPS);
+    return {
+        ...onceProps,
+        ...props,
+    };
+}
+/**
+ * Register properties to be sent with every event
+ */
+function registerProperties(properties) {
+    const existing = getLocalStorage(STORAGE_KEYS.REGISTERED_PROPS) || {};
+    setLocalStorage(STORAGE_KEYS.REGISTERED_PROPS, {
+        ...existing,
+        ...properties,
+    });
+}
+/**
+ * Register properties only if they don't already exist
+ */
+function registerOnceProperties(properties) {
+    const existing = getLocalStorage(STORAGE_KEYS.REGISTERED_ONCE_PROPS) || {};
+    const merged = { ...existing };
+    for (const key of Object.keys(properties)) {
+        if (!(key in merged)) {
+            merged[key] = properties[key];
+        }
+    }
+    setLocalStorage(STORAGE_KEYS.REGISTERED_ONCE_PROPS, merged);
+}
+
+/**
+ * Event capture module
+ * Core event capture functionality
+ */
+let eventCallback = null;
+let config$3 = null;
+/**
+ * Set the configuration
+ */
+function setConfig(cfg) {
+    config$3 = cfg;
+}
+/**
+ * Set the callback to be called when an event is captured
+ */
+function setEventCallback(callback) {
+    eventCallback = callback;
+}
+/**
+ * Capture an event
+ */
+function captureEvent(eventName, properties = {}, options = {}) {
+    // Check if opted out
+    if (config$3?.optOut) {
+        if (config$3.debug) {
+            console.log('[SessionVision] Tracking disabled (optOut: true)');
+        }
+        return;
+    }
+    // Validate event name
+    if (!eventName || typeof eventName !== 'string') {
+        console.warn('[SessionVision] capture() requires a non-empty event name');
+        return;
+    }
+    const { includeAutoProperties = true } = options;
+    // Build event
+    const event = {
+        event: eventName,
+        timestamp: Date.now(),
+        properties: {
+            ...properties,
+            ...(includeAutoProperties ? getAutomaticProperties() : {}),
+            ...getRegisteredProperties(),
+        },
+        anonymousId: getAnonymousId(),
+        userId: getUserId(),
+        sessionId: getSessionId(),
+    };
+    // Debug logging
+    if (config$3?.debug) {
+        console.log('[SessionVision] Event captured:', event);
+    }
+    // Call the callback to buffer the event
+    if (eventCallback) {
+        eventCallback(event);
+    }
+}
+/**
+ * Capture an internal/system event (like $identify)
+ */
+function captureSystemEvent(eventName, properties = {}) {
+    captureEvent(eventName, properties, { includeAutoProperties: true });
+}
+
+/**
+ * Pageview tracking module
+ * Handles initial page load and SPA navigation
+ */
+let isInitialized$1 = false;
+let lastUrl = null;
+/**
+ * Capture a pageview event
+ */
+function capturePageview(customProperties = {}) {
+    const url = getCurrentUrl();
+    // Avoid duplicate pageviews for the same URL
+    if (url === lastUrl) {
+        return;
+    }
+    lastUrl = url;
+    const properties = {
+        $current_url: url,
+        $referrer: getReferrer(),
+        $title: getDocumentTitle(),
+        ...customProperties,
+    };
+    captureEvent('$pageview', properties);
+}
+/**
+ * Handle history state changes for SPA navigation
+ */
+function handleHistoryChange() {
+    // Small delay to ensure URL has updated
+    setTimeout(() => {
+        capturePageview();
+    }, 0);
+}
+/**
+ * Initialize pageview tracking
+ * - Captures initial pageview
+ * - Listens for SPA navigation (pushState, replaceState, popstate)
+ */
+function initPageviewTracking() {
+    if (isInitialized$1) {
+        return;
+    }
+    isInitialized$1 = true;
+    // Capture initial pageview
+    capturePageview();
+    // Monkey-patch history.pushState
+    const originalPushState = history.pushState;
+    history.pushState = function (...args) {
+        const result = originalPushState.apply(this, args);
+        handleHistoryChange();
+        return result;
+    };
+    // Monkey-patch history.replaceState
+    const originalReplaceState = history.replaceState;
+    history.replaceState = function (...args) {
+        const result = originalReplaceState.apply(this, args);
+        handleHistoryChange();
+        return result;
+    };
+    // Listen for popstate (back/forward navigation)
+    window.addEventListener('popstate', handleHistoryChange);
+}
+
+/**
+ * CSS Selector generation utility
+ * Generates stable, unique selectors for DOM elements
+ */
+/**
+ * Maximum depth for selector generation
+ */
+const MAX_SELECTOR_DEPTH = 5;
+/**
+ * Generate a CSS selector for an element
+ * Priority:
+ * 1. data-sessionvision-id attribute
+ * 2. ID attribute (if unique)
+ * 3. Path-based selector with classes
+ */
+function generateSelector(element) {
+    // Priority 1: Custom sessionvision ID
+    const customId = element.getAttribute('data-sessionvision-id');
+    if (customId) {
+        return `[data-sessionvision-id="${escapeAttributeValue(customId)}"]`;
+    }
+    // Priority 2: Element ID (if unique in document)
+    const id = getElementId(element);
+    if (id && isUniqueId(id)) {
+        return `#${escapeCssIdentifier(id)}`;
+    }
+    // Priority 3: Build path-based selector
+    return buildPathSelector(element);
+}
+/**
+ * Check if an ID is unique in the document
+ */
+function isUniqueId(id) {
+    try {
+        const elements = document.querySelectorAll(`#${escapeCssIdentifier(id)}`);
+        return elements.length === 1;
+    }
+    catch {
+        // Invalid ID (e.g., starts with number)
+        return false;
+    }
+}
+/**
+ * Build a path-based selector walking up the DOM tree
+ */
+function buildPathSelector(element) {
+    const parts = [];
+    let current = element;
+    let depth = 0;
+    while (current && depth < MAX_SELECTOR_DEPTH) {
+        const part = buildElementPart(current);
+        parts.unshift(part);
+        // Stop at unique ID
+        const id = getElementId(current);
+        if (id && isUniqueId(id)) {
+            break;
+        }
+        // Stop at body
+        if (current === document.body) {
+            break;
+        }
+        current = current.parentElement;
+        depth++;
+    }
+    return parts.join(' > ');
+}
+/**
+ * Build the selector part for a single element
+ */
+function buildElementPart(element) {
+    const tag = getElementTag(element);
+    const id = getElementId(element);
+    // Use ID if unique
+    if (id && isUniqueId(id)) {
+        return `#${escapeCssIdentifier(id)}`;
+    }
+    let selector = tag;
+    // Add significant classes (up to 2)
+    const classes = getElementClasses(element);
+    if (classes) {
+        const significantClasses = classes
+            .split(' ')
+            .filter(isSignificantClass)
+            .slice(0, 2);
+        if (significantClasses.length > 0) {
+            selector += significantClasses
+                .map((c) => `.${escapeCssIdentifier(c)}`)
+                .join('');
+        }
+    }
+    // Add nth-child if needed for uniqueness among siblings
+    const nthChild = getNthChildIndex(element);
+    if (nthChild !== null && needsNthChild(element, selector)) {
+        selector += `:nth-child(${nthChild})`;
+    }
+    return selector;
+}
+/**
+ * Check if a class name is significant (not utility/generated)
+ */
+function isSignificantClass(className) {
+    // Skip empty
+    if (!className) {
+        return false;
+    }
+    // Skip common utility framework classes
+    const utilityPatterns = [
+        /^(mt|mb|ml|mr|mx|my|pt|pb|pl|pr|px|py)-/, // Tailwind spacing
+        /^(w|h|min-w|min-h|max-w|max-h)-/, // Tailwind sizing
+        /^(text|font|bg|border|rounded)-/, // Tailwind common
+        /^(flex|grid|block|inline|hidden)$/, // Tailwind display
+        /^(col|row)-/, // Grid/flex
+        /^(sm|md|lg|xl|2xl):/, // Responsive prefixes
+        /^hover:/, // State prefixes
+        /^[a-z]{1,3}-\d+$/, // Generic utility (e.g., p-4, m-2)
+        /^css-[a-z0-9]+$/i, // CSS-in-JS generated
+        /^_[a-zA-Z0-9]+$/, // CSS modules
+        /^svelte-[a-z0-9]+$/i, // Svelte generated
+    ];
+    return !utilityPatterns.some((pattern) => pattern.test(className));
+}
+/**
+ * Get the nth-child index of an element (1-based)
+ */
+function getNthChildIndex(element) {
+    const parent = element.parentElement;
+    if (!parent) {
+        return null;
+    }
+    const siblings = Array.from(parent.children);
+    const index = siblings.indexOf(element);
+    return index >= 0 ? index + 1 : null;
+}
+/**
+ * Check if nth-child is needed to make selector unique among siblings
+ */
+function needsNthChild(element, baseSelector) {
+    const parent = element.parentElement;
+    if (!parent) {
+        return false;
+    }
+    try {
+        const matches = parent.querySelectorAll(`:scope > ${baseSelector}`);
+        return matches.length > 1;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Escape a string for use in a CSS identifier (class, id)
+ */
+function escapeCssIdentifier(str) {
+    return str.replace(/([^\w-])/g, '\\$1').replace(/^(\d)/, '\\3$1 ');
+}
+/**
+ * Escape a string for use in an attribute value selector
+ */
+function escapeAttributeValue(str) {
+    return str.replace(/"/g, '\\"').replace(/\\/g, '\\\\');
+}
+
+/**
+ * PII (Personally Identifiable Information) detection utility
+ * Detects and masks sensitive data patterns in text
+ */
+/**
+ * PII patterns to detect and mask
+ */
+const PII_PATTERNS = [
+    {
+        // Credit card numbers (with or without separators)
+        name: 'credit_card',
+        pattern: /\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}/g,
+        mask: '[CARD XXXX]',
+    },
+    {
+        // US Social Security Numbers
+        name: 'ssn',
+        pattern: /\b\d{3}-\d{2}-\d{4}\b/g,
+        mask: '[SSN XXX-XX-XXXX]',
+    },
+    {
+        // US Phone numbers (various formats)
+        name: 'phone_us',
+        pattern: /(?:\+1[\s.-]?)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}/g,
+        mask: '[PHONE XXX-XXX-XXXX]',
+    },
+    {
+        // Email addresses (supports multi-part TLDs like .co.uk)
+        name: 'email',
+        pattern: /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}(?:\.[A-Za-z]{2,})?/g,
+        mask: '[EMAIL]',
+    },
+];
+/**
+ * Mask PII in text
+ */
+function maskPII(text) {
+    if (!text) {
+        return text;
+    }
+    let masked = text;
+    for (const pii of PII_PATTERNS) {
+        // Reset lastIndex for global patterns
+        pii.pattern.lastIndex = 0;
+        masked = masked.replace(pii.pattern, pii.mask);
+    }
+    return masked;
+}
+
+/**
+ * Autocapture module
+ * Handles automatic capture of clicks and form submissions
+ */
+let isClickTrackingActive = false;
+let isFormTrackingActive = false;
+let config$2 = null;
+/**
+ * Set the configuration
+ */
+function setAutocaptureConfig(cfg) {
+    config$2 = cfg;
+}
+/**
+ * Handle click events
+ */
+function handleClick(event) {
+    const target = event.target;
+    if (!target || shouldIgnoreElement(target)) {
+        return;
+    }
+    // Find the most relevant interactive element
+    const element = getInteractiveParent(target) || target;
+    if (shouldIgnoreElement(element)) {
+        return;
+    }
+    const properties = {
+        $element_tag: getElementTag(element),
+        $element_text: maskPII(getElementText(element)),
+        $element_classes: getElementClasses(element),
+        $element_id: getElementId(element),
+        $element_selector: generateSelector(element),
+        $element_href: getElementHref(element),
+    };
+    captureEvent('$click', properties);
+}
+/**
+ * Handle form submission events
+ */
+function handleFormSubmit(event) {
+    const form = event.target;
+    if (!form || !(form instanceof HTMLFormElement)) {
+        return;
+    }
+    if (shouldIgnoreElement(form)) {
+        return;
+    }
+    const properties = {
+        $form_id: form.id || null,
+        $form_action: form.action || '',
+        $form_method: (form.method || 'GET').toUpperCase(),
+        $form_name: form.name || null,
+    };
+    captureEvent('$form_submit', properties);
+}
+/**
+ * Initialize click tracking
+ */
+function initClickTracking() {
+    if (isClickTrackingActive) {
+        return;
+    }
+    isClickTrackingActive = true;
+    document.addEventListener('click', handleClick, { capture: true });
+}
+/**
+ * Initialize form submission tracking
+ */
+function initFormTracking() {
+    if (isFormTrackingActive) {
+        return;
+    }
+    isFormTrackingActive = true;
+    document.addEventListener('submit', handleFormSubmit, { capture: true });
+}
+/**
+ * Initialize all autocapture based on configuration
+ */
+function initAutocapture(cfg) {
+    config$2 = cfg;
+    if (config$2.autocapture.clicks) {
+        initClickTracking();
+    }
+    if (config$2.autocapture.formSubmit) {
+        initFormTracking();
+    }
+}
+
+/**
+ * Payload compression module
+ * Uses CompressionStream API when available
+ */
+/**
+ * Check if compression is supported
+ */
+function isCompressionSupported() {
+    return (typeof CompressionStream !== 'undefined' &&
+        typeof ReadableStream !== 'undefined');
+}
+/**
+ * Compress a string using gzip
+ * Returns the compressed data as a Blob, or null if compression is not supported
+ */
+async function compressPayload(data) {
+    if (!isCompressionSupported()) {
+        return null;
+    }
+    try {
+        const encoder = new TextEncoder();
+        const inputBytes = encoder.encode(data);
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(inputBytes);
+                controller.close();
+            },
+        });
+        const compressedStream = stream.pipeThrough(new CompressionStream('gzip'));
+        const reader = compressedStream.getReader();
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+        }
+        // Combine chunks into a single Blob
+        return new Blob(chunks, { type: 'application/gzip' });
+    }
+    catch {
+        // Compression failed, return null to use uncompressed
+        return null;
+    }
+}
+/**
+ * Get the size of data in bytes
+ */
+function getByteSize(data) {
+    return new Blob([data]).size;
+}
+/**
+ * Check if payload should be compressed (based on size threshold)
+ * Only compress if payload is larger than 1KB
+ */
+function shouldCompress(data) {
+    return isCompressionSupported() && getByteSize(data) > 1024;
+}
+
+/**
+ * HTTP transport module
+ * Handles sending events to the ingest API
+ */
+let config$1 = null;
+let consecutiveFailures = 0;
+/**
+ * Set the configuration
+ */
+function setTransportConfig(cfg) {
+    config$1 = cfg;
+}
+/**
+ * Sleep for a given number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Send events to the ingest API
+ * Handles compression and retry logic
+ */
+async function sendEvents(payload) {
+    if (!config$1) {
+        console.warn('[SessionVision] SDK not initialized');
+        return false;
+    }
+    const url = `${config$1.ingestHost}/api/v1/ingest/events`;
+    const jsonPayload = JSON.stringify(payload);
+    // Try to compress if payload is large enough
+    const useCompression = shouldCompress(jsonPayload);
+    let body = jsonPayload;
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (useCompression) {
+        const compressed = await compressPayload(jsonPayload);
+        if (compressed) {
+            body = compressed;
+            headers['Content-Type'] = 'application/json';
+            headers['Content-Encoding'] = 'gzip';
+        }
+    }
+    // Attempt to send with retries
+    for (let attempt = 0; attempt <= BUFFER_CONFIG.MAX_RETRIES; attempt++) {
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body,
+                keepalive: true, // Keep connection alive for background sends
+            });
+            if (response.ok || response.status === 202) {
+                // Success
+                consecutiveFailures = 0;
+                if (config$1.debug) {
+                    console.log(`[SessionVision] Events sent successfully (${payload.events.length} events)`);
+                }
+                return true;
+            }
+            // Server error, might be worth retrying
+            if (response.status >= 500) {
+                throw new Error(`Server error: ${response.status}`);
+            }
+            // Client error (4xx), don't retry
+            if (config$1.debug) {
+                console.warn(`[SessionVision] Failed to send events: ${response.status}`);
+            }
+            return false;
+        }
+        catch (error) {
+            // Network error or server error, retry if attempts remaining
+            if (attempt < BUFFER_CONFIG.MAX_RETRIES) {
+                const delay = BUFFER_CONFIG.RETRY_DELAYS_MS[attempt] || 4000;
+                if (config$1.debug) {
+                    console.log(`[SessionVision] Retry ${attempt + 1}/${BUFFER_CONFIG.MAX_RETRIES} in ${delay}ms`);
+                }
+                await sleep(delay);
+            }
+            else {
+                // All retries exhausted
+                consecutiveFailures++;
+                if (config$1.debug) {
+                    console.warn('[SessionVision] Failed to send events after retries:', error);
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check if we should stop retrying (3+ consecutive failures)
+ */
+function shouldStopRetrying() {
+    return consecutiveFailures >= 3;
+}
+
+/**
+ * Event buffer module
+ * Buffers events and flushes them periodically or when buffer is full
+ */
+let eventBuffer = [];
+let flushTimer = null;
+let config = null;
+let isFlushing = false;
+/**
+ * Set the configuration
+ */
+function setBufferConfig(cfg) {
+    config = cfg;
+}
+/**
+ * Add an event to the buffer
+ */
+function addToBuffer(event) {
+    // If we've had too many failures, drop events
+    if (shouldStopRetrying()) {
+        if (config?.debug) {
+            console.warn('[SessionVision] Too many failures, dropping event');
+        }
+        return;
+    }
+    eventBuffer.push(event);
+    // Flush if buffer is full
+    if (eventBuffer.length >= BUFFER_CONFIG.MAX_EVENTS) {
+        flush();
+    }
+}
+/**
+ * Flush the event buffer
+ * Sends all buffered events to the server
+ */
+async function flush() {
+    if (isFlushing || eventBuffer.length === 0 || !config) {
+        return;
+    }
+    isFlushing = true;
+    // Take events from buffer (FIFO eviction on failure)
+    const eventsToSend = [...eventBuffer];
+    eventBuffer = [];
+    const payload = {
+        projectToken: config.projectToken,
+        events: eventsToSend,
+    };
+    const success = await sendEvents(payload);
+    if (!success) {
+        // Re-add events to buffer if we haven't exceeded max retries
+        if (!shouldStopRetrying()) {
+            // Only keep most recent events up to max buffer size
+            const combined = [...eventsToSend, ...eventBuffer];
+            eventBuffer = combined.slice(-10);
+            if (config.debug && combined.length > BUFFER_CONFIG.MAX_EVENTS) {
+                console.warn(`[SessionVision] Buffer overflow, dropped ${combined.length - BUFFER_CONFIG.MAX_EVENTS} oldest events`);
+            }
+        }
+    }
+    isFlushing = false;
+}
+/**
+ * Start the flush timer
+ */
+function startFlushTimer() {
+    if (flushTimer) {
+        return;
+    }
+    flushTimer = setInterval(() => {
+        flush();
+    }, BUFFER_CONFIG.FLUSH_INTERVAL_MS);
+}
+/**
+ * Initialize visibility change handler for flushing on tab hide
+ */
+function initVisibilityHandler() {
+    document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+            // Best-effort flush when tab is hidden
+            flush();
+        }
+    });
+}
+
+/**
+ * SDK initialization module
+ * Orchestrates the initialization of all SDK components
+ */
+let isInitialized = false;
+let resolvedConfig = null;
+/**
+ * Initialize the SDK
+ */
+async function init(projectToken, config) {
+    if (isInitialized) {
+        console.warn('[SessionVision] SDK already initialized');
+        return;
+    }
+    // Validate project token
+    if (!projectToken || typeof projectToken !== 'string') {
+        console.error('[SessionVision] init() requires a valid project token');
+        return;
+    }
+    // Resolve configuration
+    resolvedConfig = resolveConfig(projectToken, config);
+    if (resolvedConfig.debug) {
+        console.log('[SessionVision] Initializing with config:', resolvedConfig);
+    }
+    // Set up components with config
+    setConfig(resolvedConfig);
+    setBufferConfig(resolvedConfig);
+    setTransportConfig(resolvedConfig);
+    setAutocaptureConfig(resolvedConfig);
+    // Wire up event callback to buffer
+    setEventCallback((event) => {
+        addToBuffer(event);
+    });
+    // Wire up identify callback
+    setIdentifyCallback((userId, traits) => {
+        captureSystemEvent('$identify', {
+            $user_id: userId,
+            ...traits,
+        });
+    });
+    // Initialize identity
+    getAnonymousId();
+    getSessionId();
+    // Check if opted out
+    if (resolvedConfig.optOut) {
+        if (resolvedConfig.debug) {
+            console.log('[SessionVision] Tracking disabled (optOut: true)');
+        }
+        isInitialized = true;
+        return;
+    }
+    // Fetch remote config (async, don't block initialization)
+    fetchRemoteConfig(resolvedConfig).then((remoteConfig) => {
+        if (remoteConfig) {
+            applyRemoteConfig(remoteConfig);
+        }
+    });
+    // Start event buffer flush timer
+    startFlushTimer();
+    // Initialize visibility change handler
+    initVisibilityHandler();
+    // Initialize autocapture when DOM is ready
+    onDocumentReady(() => {
+        if (resolvedConfig && resolvedConfig.autocapture.pageview) {
+            initPageviewTracking();
+        }
+        if (resolvedConfig) {
+            initAutocapture(resolvedConfig);
+        }
+    });
+    isInitialized = true;
+    if (resolvedConfig.debug) {
+        console.log('[SessionVision] SDK initialized successfully');
+    }
+}
+/**
+ * Capture a custom event
+ */
+function capture(eventName, properties) {
+    if (!isInitialized) {
+        console.warn('[SessionVision] SDK not initialized. Call init() first.');
+        return;
+    }
+    captureEvent(eventName, properties || {});
+}
+/**
+ * Identify a user
+ */
+function identify(userId, traits) {
+    if (!isInitialized) {
+        console.warn('[SessionVision] SDK not initialized. Call init() first.');
+        return;
+    }
+    identify$1(userId, traits);
+}
+/**
+ * Reset user identity (for logout)
+ */
+function reset() {
+    if (!isInitialized) {
+        console.warn('[SessionVision] SDK not initialized. Call init() first.');
+        return;
+    }
+    reset$1();
+}
+/**
+ * Get the current distinct ID
+ */
+function getDistinctIdValue() {
+    return getDistinctId();
+}
+/**
+ * Register properties to send with every event
+ */
+function register(properties) {
+    if (!isInitialized) {
+        console.warn('[SessionVision] SDK not initialized. Call init() first.');
+        return;
+    }
+    registerProperties(properties);
+}
+/**
+ * Register properties only if they don't exist
+ */
+function registerOnce(properties) {
+    if (!isInitialized) {
+        console.warn('[SessionVision] SDK not initialized. Call init() first.');
+        return;
+    }
+    registerOnceProperties(properties);
+}
+
+/**
+ * Queue replay module
+ * Handles replaying method calls that were queued before SDK loaded
+ */
+/**
+ * Replay queued method calls
+ * The stub queues calls like ['capture', 'event_name', {...}] before SDK loads
+ */
+function replayQueue(queue, api) {
+    if (!queue || !Array.isArray(queue)) {
+        return;
+    }
+    for (const call of queue) {
+        if (!call || typeof call !== 'object') {
+            continue;
+        }
+        const { method, args } = call;
+        if (!method || typeof method !== 'string') {
+            continue;
+        }
+        // Get the method from the API
+        const fn = api[method];
+        if (typeof fn === 'function') {
+            try {
+                // Call the method with the queued arguments
+                fn.apply(api, args || []);
+            }
+            catch (error) {
+                console.warn(`[SessionVision] Error replaying queued call ${method}:`, error);
+            }
+        }
+        else {
+            console.warn(`[SessionVision] Unknown method in queue: ${method}`);
+        }
+    }
+}
+/**
+ * Parse the legacy array-style queue format
+ * PostHog-style: sessionvision._q = [['capture', 'event', {}], ...]
+ */
+function parseLegacyQueue(legacyQueue) {
+    if (!legacyQueue || !Array.isArray(legacyQueue)) {
+        return [];
+    }
+    return legacyQueue
+        .filter((item) => Array.isArray(item) && item.length > 0)
+        .map((item) => ({
+        method: String(item[0]),
+        args: item.slice(1),
+    }));
+}
+/**
+ * Get init calls from _i array
+ */
+function getInitCalls(initArray) {
+    if (!initArray || !Array.isArray(initArray)) {
+        return [];
+    }
+    return initArray
+        .filter((item) => Array.isArray(item) && item.length > 0 && typeof item[0] === 'string')
+        .map((item) => ({
+        projectToken: item[0],
+        config: item[1],
+    }));
+}
+
+/**
+ * Session Vision JavaScript Snippet
+ * Main SDK entry point
+ *
+ * @version "0.2.0"
+ */
+/**
+ * Session Vision SDK instance
+ */
+const sessionvision = {
+    /**
+     * SDK version
+     */
+    version: "0.2.0" ,
+    /**
+     * Initialize the SDK with a project token and optional configuration
+     *
+     * @param projectToken - Your Session Vision project token
+     * @param config - Optional configuration options
+     *
+     * @example
+     * ```js
+     * sessionvision.init('proj_abc123', {
+     *   apiHost: 'https://cdn.sessionvision.com',
+     *   debug: true,
+     *   autocapture: true
+     * });
+     * ```
+     */
+    init(projectToken, config) {
+        init(projectToken, config);
+    },
+    /**
+     * Capture a custom event
+     *
+     * @param eventName - Name of the event to capture
+     * @param properties - Optional properties to attach to the event
+     *
+     * @example
+     * ```js
+     * sessionvision.capture('button_clicked', {
+     *   button_id: 'signup_cta',
+     *   page: '/pricing'
+     * });
+     * ```
+     */
+    capture(eventName, properties) {
+        capture(eventName, properties);
+    },
+    /**
+     * Identify a user with a unique ID and optional traits
+     *
+     * @param userId - Unique identifier for the user
+     * @param traits - Optional user properties (email, name, plan, etc.)
+     *
+     * @example
+     * ```js
+     * sessionvision.identify('user_12345', {
+     *   email: 'user@example.com',
+     *   name: 'Jane Doe',
+     *   plan: 'pro'
+     * });
+     * ```
+     */
+    identify(userId, traits) {
+        identify(userId, traits);
+    },
+    /**
+     * Reset user identity (call on logout)
+     * - Clears the current user ID
+     * - Generates a new anonymous ID
+     * - Starts a new session
+     *
+     * @example
+     * ```js
+     * // On user logout
+     * sessionvision.reset();
+     * ```
+     */
+    reset() {
+        reset();
+    },
+    /**
+     * Get the current distinct ID
+     * Returns the user ID if identified, or the anonymous ID otherwise
+     *
+     * @returns The current user identifier
+     *
+     * @example
+     * ```js
+     * const distinctId = sessionvision.getDistinctId();
+     * // Use for server-side correlation
+     * ```
+     */
+    getDistinctId() {
+        return getDistinctIdValue();
+    },
+    /**
+     * Register properties to be sent with every event
+     *
+     * @param properties - Properties to attach to all future events
+     *
+     * @example
+     * ```js
+     * sessionvision.register({
+     *   app_version: '2.1.0',
+     *   environment: 'production'
+     * });
+     * ```
+     */
+    register(properties) {
+        register(properties);
+    },
+    /**
+     * Register properties only if they don't already exist
+     *
+     * @param properties - Properties to attach if not already set
+     *
+     * @example
+     * ```js
+     * sessionvision.registerOnce({
+     *   initial_referrer: document.referrer
+     * });
+     * ```
+     */
+    registerOnce(properties) {
+        registerOnce(properties);
+    },
+};
+/**
+ * Bootstrap the SDK
+ * - Check for existing global instance
+ * - Replay queued method calls
+ * - Process any pending init calls
+ */
+function bootstrap() {
+    // Check if there's an existing stub instance
+    const existingInstance = window.sessionvision;
+    if (existingInstance && existingInstance.__SV) {
+        // SDK already loaded, don't reinitialize
+        return;
+    }
+    // Replay queued method calls from stub
+    if (existingInstance?._q) {
+        const queue = parseLegacyQueue(existingInstance._q);
+        replayQueue(queue, sessionvision);
+    }
+    // Process init calls
+    if (existingInstance?._i) {
+        const initCalls = getInitCalls(existingInstance._i);
+        for (const { projectToken, config } of initCalls) {
+            sessionvision.init(projectToken, config);
+        }
+    }
+    // Mark SDK as loaded
+    sessionvision.__SV = 1;
+    // Set global instance
+    window.sessionvision = sessionvision;
+}
+// Bootstrap on load
+bootstrap();
+
+module.exports = sessionvision;
+//# sourceMappingURL=sessionvision.cjs.js.map