@sessionvision/core 0.2.0

package/dist/sessionvision.js

@@ -0,0 +1,1909 @@
+/*!
+ * Session Vision Core v0.2.0
+ * (c) 2026 Session Vision
+ * Released under the MIT License
+ */
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.sessionvision = factory());
+})(this, (function () { '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();
+
+    return sessionvision;
+
+}));
+//# sourceMappingURL=sessionvision.js.map