humanbehavior-js 0.4.19 → 0.4.21

package/dist/cjs/react/index.cjs

@@ -12393,6 +12393,145 @@ const logWarn = (message, ...args) => logger.warn(message, ...args);
 const logInfo = (message, ...args) => logger.info(message, ...args);
 const logDebug = (message, ...args) => logger.debug(message, ...args);
 
+/**
+ * IP Address Detection Utility
+ * Attempts to get the client's public IP address using multiple methods
+ */
+/**
+ * Get IP address using STUN server (most reliable)
+ */
+function getIPFromSTUN() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const pc = new RTCPeerConnection({
+                iceServers: [
+                    { urls: 'stun:stun.l.google.com:19302' },
+                    { urls: 'stun:stun1.l.google.com:19302' },
+                    { urls: 'stun:stun2.l.google.com:19302' }
+                ]
+            });
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    pc.close();
+                    resolve(null);
+                }, 5000);
+                pc.createDataChannel('');
+                pc.createOffer()
+                    .then(offer => pc.setLocalDescription(offer))
+                    .catch(() => resolve(null));
+                pc.onicecandidate = (event) => {
+                    if (event.candidate) {
+                        const candidate = event.candidate.candidate;
+                        const match = candidate.match(/([0-9]{1,3}(\.[0-9]{1,3}){3})/);
+                        if (match) {
+                            clearTimeout(timeout);
+                            pc.close();
+                            resolve(match[1]);
+                        }
+                    }
+                };
+            });
+        }
+        catch (error) {
+            return null;
+        }
+    });
+}
+/**
+ * Get IP address using public IP service (fallback)
+ */
+function getIPFromPublicService() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield fetch('https://api.ipify.org?format=json', {
+                method: 'GET'
+            });
+            if (response.ok) {
+                const data = yield response.json();
+                return data.ip;
+            }
+        }
+        catch (error) {
+            // Try alternative service
+            try {
+                const response = yield fetch('https://httpbin.org/ip', {
+                    method: 'GET'
+                });
+                if (response.ok) {
+                    const data = yield response.json();
+                    return data.origin;
+                }
+            }
+            catch (fallbackError) {
+                // Last resort
+                try {
+                    const response = yield fetch('https://api.myip.com', {
+                        method: 'GET'
+                    });
+                    if (response.ok) {
+                        const data = yield response.json();
+                        return data.ip;
+                    }
+                }
+                catch (lastError) {
+                    return null;
+                }
+            }
+        }
+        return null;
+    });
+}
+/**
+ * Get client's public IP address
+ * Tries STUN first (most reliable), then falls back to public services
+ */
+function getClientIP() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const startTime = Date.now();
+        // Try STUN first (most reliable and privacy-friendly)
+        const stunIP = yield getIPFromSTUN();
+        if (stunIP) {
+            return {
+                ip: stunIP,
+                method: 'stun',
+                timestamp: startTime
+            };
+        }
+        // Fallback to public IP service
+        const publicIP = yield getIPFromPublicService();
+        if (publicIP) {
+            return {
+                ip: publicIP,
+                method: 'public-service',
+                timestamp: startTime
+            };
+        }
+        return null;
+    });
+}
+/**
+ * Get IP address with caching to avoid repeated requests
+ */
+let cachedIP = null;
+let cacheTimestamp = 0;
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+function getCachedIP() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const now = Date.now();
+        // Return cached IP if still valid
+        if (cachedIP && (now - cacheTimestamp) < CACHE_DURATION) {
+            return cachedIP;
+        }
+        // Get fresh IP
+        const ipInfo = yield getClientIP();
+        if (ipInfo) {
+            cachedIP = ipInfo;
+            cacheTimestamp = now;
+        }
+        return ipInfo;
+    });
+}
+
 const MAX_CHUNK_SIZE_BYTES = 1024 * 1024; // 1MB chunk size - more conservative
 function isChunkSizeExceeded(currentChunk, newEvent, sessionId) {
     const nextChunkSize = new TextEncoder().encode(JSON.stringify({
@@ -12486,6 +12625,45 @@ class HumanBehaviorAPI {
             }
         });
     }
+    /**
+     * Send IP address information to the server
+     * This is called after successful initialization
+     */
+    sendIPInfo(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const ipInfo = yield getCachedIP();
+                if (!ipInfo) {
+                    logWarn('No IP address available to send');
+                    return;
+                }
+                logDebug('Sending IP info:', ipInfo);
+                const response = yield fetch(`${this.baseUrl}/api/ingestion/ip-info`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        sessionId: sessionId,
+                        clientIP: ipInfo.ip,
+                        ipDetectionMethod: ipInfo.method,
+                        timestamp: ipInfo.timestamp
+                    })
+                });
+                if (!response.ok) {
+                    const errorText = yield response.text();
+                    logWarn('Failed to send IP info:', response.status, errorText);
+                }
+                else {
+                    logDebug('IP info sent successfully');
+                }
+            }
+            catch (error) {
+                logWarn('Error sending IP info:', error);
+            }
+        });
+    }
     sendEvents(events, sessionId, userId) {
         return __awaiter(this, void 0, void 0, function* () {
             // ✅ SIMPLE VALIDATION FOR ALL EVENTS
@@ -12712,7 +12890,7 @@ class HumanBehaviorAPI {
 // This module provides methods to configure rrweb's built-in masking
 // Uses CSS selectors and classes for reliable redaction without event corruption
 // Check if we're in a browser environment
-const isBrowser$2 = typeof window !== 'undefined';
+const isBrowser$3 = typeof window !== 'undefined';
 class RedactionManager {
     constructor(options) {
         this.redactedText = '[REDACTED]';
@@ -12871,7 +13049,7 @@ class RedactionManager {
      * Check if a DOM change should be redacted based on its ID
      */
     shouldRedactDOMChange(changeData) {
-        if (!isBrowser$2)
+        if (!isBrowser$3)
             return false;
         try {
             // Check if this change has an ID that we can use to find the element
@@ -13014,7 +13192,7 @@ class RedactionManager {
      * Check if an event is from a field that should be redacted
      */
     isFieldSelected(eventData) {
-        if (!isBrowser$2)
+        if (!isBrowser$3)
             return false;
         try {
             // For input events (source 5), we need to determine if this is a sensitive field
@@ -13165,6 +13343,485 @@ class RedactionManager {
 // Export a default instance
 new RedactionManager();
 
+/**
+ * Automatic Property Detection for HumanBehavior SDK
+ * Captures device type, location, and initial referrer information
+ */
+// Check if we're in a browser environment
+const isBrowser$2 = typeof window !== 'undefined';
+/**
+ * Detect device type based on user agent and screen size
+ */
+function detectDeviceType() {
+    if (!isBrowser$2)
+        return 'unknown';
+    const userAgent = navigator.userAgent.toLowerCase();
+    const screenWidth = window.screen.width;
+    const screenHeight = window.screen.height;
+    // Mobile detection
+    if (/mobile|android|iphone|ipad|ipod|blackberry|windows phone/i.test(userAgent)) {
+        if (/ipad/i.test(userAgent) || (screenWidth >= 768 && screenHeight >= 1024)) {
+            return 'tablet';
+        }
+        return 'mobile';
+    }
+    // Desktop detection
+    if (/windows|macintosh|linux/i.test(userAgent)) {
+        return 'desktop';
+    }
+    return 'unknown';
+}
+/**
+ * Extract browser information from user agent
+ */
+function detectBrowser() {
+    if (!isBrowser$2)
+        return { browser: 'unknown', browser_version: 'unknown' };
+    const userAgent = navigator.userAgent;
+    // Chrome
+    if (/chrome/i.test(userAgent) && !/edge/i.test(userAgent)) {
+        const match = userAgent.match(/chrome\/(\d+)/i);
+        return {
+            browser: 'chrome',
+            browser_version: match ? match[1] : 'unknown'
+        };
+    }
+    // Firefox
+    if (/firefox/i.test(userAgent)) {
+        const match = userAgent.match(/firefox\/(\d+)/i);
+        return {
+            browser: 'firefox',
+            browser_version: match ? match[1] : 'unknown'
+        };
+    }
+    // Safari
+    if (/safari/i.test(userAgent) && !/chrome/i.test(userAgent)) {
+        const match = userAgent.match(/version\/(\d+)/i);
+        return {
+            browser: 'safari',
+            browser_version: match ? match[1] : 'unknown'
+        };
+    }
+    // Edge
+    if (/edge/i.test(userAgent)) {
+        const match = userAgent.match(/edge\/(\d+)/i);
+        return {
+            browser: 'edge',
+            browser_version: match ? match[1] : 'unknown'
+        };
+    }
+    // Internet Explorer
+    if (/msie|trident/i.test(userAgent)) {
+        const match = userAgent.match(/msie (\d+)/i) || userAgent.match(/rv:(\d+)/i);
+        return {
+            browser: 'ie',
+            browser_version: match ? match[1] : 'unknown'
+        };
+    }
+    return { browser: 'unknown', browser_version: 'unknown' };
+}
+/**
+ * Extract operating system information from user agent
+ */
+function detectOS() {
+    if (!isBrowser$2)
+        return { os: 'unknown', os_version: 'unknown' };
+    const userAgent = navigator.userAgent;
+    // Windows
+    if (/windows/i.test(userAgent)) {
+        const match = userAgent.match(/windows nt (\d+\.\d+)/i);
+        let version = 'unknown';
+        if (match) {
+            const versionNum = parseFloat(match[1]);
+            if (versionNum === 10.0)
+                version = '10';
+            else if (versionNum === 6.3)
+                version = '8.1';
+            else if (versionNum === 6.2)
+                version = '8';
+            else if (versionNum === 6.1)
+                version = '7';
+            else
+                version = match[1];
+        }
+        return { os: 'windows', os_version: version };
+    }
+    // macOS
+    if (/macintosh|mac os x/i.test(userAgent)) {
+        const match = userAgent.match(/mac os x (\d+[._]\d+)/i);
+        return {
+            os: 'macos',
+            os_version: match ? match[1].replace('_', '.') : 'unknown'
+        };
+    }
+    // iOS
+    if (/iphone|ipad|ipod/i.test(userAgent)) {
+        const match = userAgent.match(/os (\d+[._]\d+)/i);
+        return {
+            os: 'ios',
+            os_version: match ? match[1].replace('_', '.') : 'unknown'
+        };
+    }
+    // Android
+    if (/android/i.test(userAgent)) {
+        const match = userAgent.match(/android (\d+\.\d+)/i);
+        return {
+            os: 'android',
+            os_version: match ? match[1] : 'unknown'
+        };
+    }
+    // Linux
+    if (/linux/i.test(userAgent)) {
+        return { os: 'linux', os_version: 'unknown' };
+    }
+    return { os: 'unknown', os_version: 'unknown' };
+}
+/**
+ * Extract UTM parameters from URL
+ */
+function extractUTMParams(url) {
+    const urlObj = new URL(url);
+    const utmParams = {};
+    const utmKeys = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content'];
+    utmKeys.forEach(key => {
+        const value = urlObj.searchParams.get(key);
+        if (value) {
+            utmParams[key] = value;
+        }
+    });
+    return utmParams;
+}
+/**
+ * Extract domain from URL
+ */
+function extractDomain(url) {
+    try {
+        const urlObj = new URL(url);
+        return urlObj.hostname;
+    }
+    catch (_a) {
+        return '';
+    }
+}
+/**
+ * Get device information
+ */
+function getDeviceInfo() {
+    if (!isBrowser$2) {
+        return {
+            device_type: 'unknown',
+            browser: 'unknown',
+            browser_version: 'unknown',
+            os: 'unknown',
+            os_version: 'unknown',
+            screen_resolution: 'unknown',
+            viewport_size: 'unknown',
+            color_depth: 0,
+            timezone: 'unknown',
+            language: 'unknown',
+            languages: []
+        };
+    }
+    const { browser, browser_version } = detectBrowser();
+    const { os, os_version } = detectOS();
+    return {
+        device_type: detectDeviceType(),
+        browser,
+        browser_version,
+        os,
+        os_version,
+        screen_resolution: `${window.screen.width}x${window.screen.height}`,
+        viewport_size: `${window.innerWidth}x${window.innerHeight}`,
+        color_depth: window.screen.colorDepth,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        language: navigator.language,
+        languages: [...(navigator.languages || [navigator.language])],
+        raw_user_agent: navigator.userAgent
+    };
+}
+/**
+ * Get location information
+ */
+function getLocationInfo() {
+    if (!isBrowser$2) {
+        return {
+            current_url: '',
+            pathname: '',
+            search: '',
+            hash: '',
+            title: '',
+            referrer: '',
+            referrer_domain: '',
+            initial_referrer: '',
+            initial_referrer_domain: ''
+        };
+    }
+    const currentUrl = window.location.href;
+    const referrer = document.referrer;
+    const utmParams = extractUTMParams(currentUrl);
+    return Object.assign({ current_url: currentUrl, pathname: window.location.pathname, search: window.location.search, hash: window.location.hash, title: document.title, referrer, referrer_domain: extractDomain(referrer), initial_referrer: referrer, initial_referrer_domain: extractDomain(referrer), initial_host: window.location.hostname }, utmParams);
+}
+/**
+ * Get all automatic properties
+ */
+function getAutomaticProperties() {
+    return Object.assign(Object.assign({}, getDeviceInfo()), getLocationInfo());
+}
+/**
+ * Get initial properties that should be captured once per session
+ */
+function getInitialProperties() {
+    if (!isBrowser$2)
+        return {};
+    const locationInfo = getLocationInfo();
+    return {
+        initial_referrer: locationInfo.initial_referrer,
+        initial_referrer_domain: locationInfo.initial_referrer_domain,
+        initial_url: locationInfo.current_url,
+        initial_pathname: locationInfo.pathname,
+        initial_utm_source: locationInfo.utm_source,
+        initial_utm_medium: locationInfo.utm_medium,
+        initial_utm_campaign: locationInfo.utm_campaign,
+        initial_utm_term: locationInfo.utm_term,
+        initial_utm_content: locationInfo.utm_content
+    };
+}
+/**
+ * Get current page properties (changes with navigation)
+ */
+function getCurrentPageProperties() {
+    if (!isBrowser$2)
+        return {};
+    const locationInfo = getLocationInfo();
+    return {
+        current_url: locationInfo.current_url,
+        pathname: locationInfo.pathname,
+        search: locationInfo.search,
+        hash: locationInfo.hash,
+        title: locationInfo.title,
+        referrer: locationInfo.referrer,
+        referrer_domain: locationInfo.referrer_domain,
+        utm_source: locationInfo.utm_source,
+        utm_medium: locationInfo.utm_medium,
+        utm_campaign: locationInfo.utm_campaign,
+        utm_term: locationInfo.utm_term,
+        utm_content: locationInfo.utm_content
+    };
+}
+
+/**
+ * Property Manager for HumanBehavior SDK
+ * Handles automatic properties, session properties, and user properties
+ */
+class PropertyManager {
+    constructor(config = {}) {
+        this.sessionProperties = {};
+        this.userProperties = {};
+        this.initialProperties = {};
+        this.isInitialized = false;
+        this.config = Object.assign({ enableAutomaticProperties: true, enableSessionProperties: true, enableUserProperties: true, propertyDenylist: [] }, config);
+        this.automaticProperties = getAutomaticProperties();
+        this.initialize();
+    }
+    /**
+     * Initialize the property manager
+     */
+    initialize() {
+        if (this.isInitialized)
+            return;
+        // Capture initial properties once
+        this.initialProperties = getInitialProperties();
+        // Load session properties from sessionStorage
+        this.loadSessionProperties();
+        this.isInitialized = true;
+    }
+    /**
+     * Get all properties for an event
+     */
+    getEventProperties(eventProperties = {}) {
+        const properties = Object.assign({}, eventProperties);
+        // Add automatic properties
+        if (this.config.enableAutomaticProperties) {
+            Object.assign(properties, this.getAutomaticProperties());
+        }
+        // Add session properties
+        if (this.config.enableSessionProperties) {
+            Object.assign(properties, this.sessionProperties);
+        }
+        // Add user properties
+        if (this.config.enableUserProperties) {
+            Object.assign(properties, this.userProperties);
+        }
+        // Add initial properties (only once per session)
+        if (!this.sessionProperties['$initial_properties_captured']) {
+            Object.assign(properties, this.initialProperties);
+            this.setSessionProperty('$initial_properties_captured', true);
+        }
+        // Apply denylist
+        this.applyDenylist(properties);
+        return properties;
+    }
+    /**
+     * Get automatic properties
+     */
+    getAutomaticProperties() {
+        return Object.assign(Object.assign({}, this.automaticProperties), getCurrentPageProperties() // Always get fresh page properties
+        );
+    }
+    /**
+     * Get automatic properties with GeoIP data merged in
+     */
+    getAutomaticPropertiesWithGeoIP(geoIPProperties = {}) {
+        return Object.assign(Object.assign(Object.assign({}, this.automaticProperties), getCurrentPageProperties()), geoIPProperties);
+    }
+    /**
+     * Set a session property
+     */
+    setSessionProperty(key, value) {
+        this.sessionProperties[key] = value;
+        this.saveSessionProperties();
+    }
+    /**
+     * Set multiple session properties
+     */
+    setSessionProperties(properties) {
+        Object.assign(this.sessionProperties, properties);
+        this.saveSessionProperties();
+    }
+    /**
+     * Get a session property
+     */
+    getSessionProperty(key) {
+        return this.sessionProperties[key];
+    }
+    /**
+     * Remove a session property
+     */
+    removeSessionProperty(key) {
+        delete this.sessionProperties[key];
+        this.saveSessionProperties();
+    }
+    /**
+     * Set a user property
+     */
+    setUserProperty(key, value) {
+        this.userProperties[key] = value;
+    }
+    /**
+     * Set multiple user properties
+     */
+    setUserProperties(properties) {
+        Object.assign(this.userProperties, properties);
+    }
+    /**
+     * Get a user property
+     */
+    getUserProperty(key) {
+        return this.userProperties[key];
+    }
+    /**
+     * Remove a user property
+     */
+    removeUserProperty(key) {
+        delete this.userProperties[key];
+    }
+    /**
+     * Set a property only if it hasn't been set before
+     */
+    setOnce(key, value, scope = 'user') {
+        if (scope === 'session') {
+            if (!(key in this.sessionProperties)) {
+                this.setSessionProperty(key, value);
+            }
+        }
+        else {
+            if (!(key in this.userProperties)) {
+                this.setUserProperty(key, value);
+            }
+        }
+    }
+    /**
+     * Clear all session properties
+     */
+    clearSessionProperties() {
+        this.sessionProperties = {};
+        this.saveSessionProperties();
+    }
+    /**
+     * Clear all user properties
+     */
+    clearUserProperties() {
+        this.userProperties = {};
+    }
+    /**
+     * Reset all properties
+     */
+    reset() {
+        this.clearSessionProperties();
+        this.clearUserProperties();
+        this.initialProperties = {};
+        this.isInitialized = false;
+        this.initialize();
+    }
+    /**
+     * Load session properties from sessionStorage
+     */
+    loadSessionProperties() {
+        if (typeof sessionStorage === 'undefined')
+            return;
+        try {
+            const stored = sessionStorage.getItem('hb_session_properties');
+            if (stored) {
+                this.sessionProperties = JSON.parse(stored);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load session properties:', error);
+        }
+    }
+    /**
+     * Save session properties to sessionStorage
+     */
+    saveSessionProperties() {
+        if (typeof sessionStorage === 'undefined')
+            return;
+        try {
+            sessionStorage.setItem('hb_session_properties', JSON.stringify(this.sessionProperties));
+        }
+        catch (error) {
+            console.warn('Failed to save session properties:', error);
+        }
+    }
+    /**
+     * Apply property denylist
+     */
+    applyDenylist(properties) {
+        if (!this.config.propertyDenylist || this.config.propertyDenylist.length === 0) {
+            return;
+        }
+        this.config.propertyDenylist.forEach(deniedKey => {
+            delete properties[deniedKey];
+        });
+    }
+    /**
+     * Update automatic properties (call when page changes)
+     */
+    updateAutomaticProperties() {
+        this.automaticProperties = getAutomaticProperties();
+    }
+    /**
+     * Get all properties for debugging
+     */
+    getAllProperties() {
+        return {
+            automatic: this.getAutomaticProperties(),
+            session: Object.assign({}, this.sessionProperties),
+            user: Object.assign({}, this.userProperties),
+            initial: Object.assign({}, this.initialProperties)
+        };
+    }
+}
+
 // Check if we're in a browser environment
 const isBrowser$1 = typeof window !== 'undefined';
 class HumanBehaviorTracker {
@@ -13231,7 +13888,10 @@ class HumanBehaviorTracker {
             this.configureLogging({ level: options.logLevel });
         }
         // Create new tracker instance
-        const tracker = new HumanBehaviorTracker(apiKey, options === null || options === void 0 ? void 0 : options.ingestionUrl);
+        const tracker = new HumanBehaviorTracker(apiKey, options === null || options === void 0 ? void 0 : options.ingestionUrl, {
+            enableAutomaticProperties: options === null || options === void 0 ? void 0 : options.enableAutomaticProperties,
+            propertyDenylist: options === null || options === void 0 ? void 0 : options.propertyDenylist
+        });
         // Store canvas recording preference
         tracker.recordCanvas = (_a = options === null || options === void 0 ? void 0 : options.recordCanvas) !== null && _a !== void 0 ? _a : false;
         // Set redacted fields if specified
@@ -13248,7 +13908,7 @@ class HumanBehaviorTracker {
         tracker.start();
         return tracker;
     }
-    constructor(apiKey, ingestionUrl) {
+    constructor(apiKey, ingestionUrl, options) {
         this.eventIngestionQueue = [];
         this.userProperties = {};
         this.isProcessing = false;
@@ -13286,6 +13946,11 @@ class HumanBehaviorTracker {
         });
         this.apiKey = apiKey;
         this.redactionManager = new RedactionManager();
+        // Initialize property manager
+        this.propertyManager = new PropertyManager({
+            enableAutomaticProperties: (options === null || options === void 0 ? void 0 : options.enableAutomaticProperties) !== false,
+            propertyDenylist: (options === null || options === void 0 ? void 0 : options.propertyDenylist) || []
+        });
         // Handle session restoration with improved continuity
         if (isBrowser$1) {
             const existingSessionId = localStorage.getItem(`human_behavior_session_id_${this.apiKey}`);
@@ -13324,7 +13989,28 @@ class HumanBehaviorTracker {
             try {
                 const userId = this.getCookie(`human_behavior_end_user_id_${this.apiKey}`);
                 logDebug(`Initializing with sessionId: ${this.sessionId}, userId: ${userId}`);
-                const { sessionId, endUserId } = yield this.api.init(this.sessionId, userId);
+                // Get automatic properties for init
+                const automaticProperties = this.propertyManager.getAutomaticProperties();
+                // Create a custom init request with automatic properties
+                const initResponse = yield fetch(`${this.api['baseUrl']}/api/ingestion/init`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`,
+                        'Referer': document.referrer || ''
+                    },
+                    body: JSON.stringify({
+                        sessionId: this.sessionId,
+                        endUserId: userId,
+                        entryURL: window.location.href,
+                        referrer: document.referrer,
+                        automaticProperties: automaticProperties
+                    })
+                });
+                if (!initResponse.ok) {
+                    throw new Error(`Failed to initialize: ${initResponse.statusText}`);
+                }
+                const { sessionId, endUserId } = yield initResponse.json();
                 // Check if server returned a different session ID (for session continuity)
                 if (sessionId !== this.sessionId) {
                     logDebug(`Server returned different sessionId: ${sessionId} (client had: ${this.sessionId})`);
@@ -13336,6 +14022,10 @@ class HumanBehaviorTracker {
                 }
                 this.endUserId = endUserId;
                 this.setCookie(`human_behavior_end_user_id_${this.apiKey}`, endUserId, 365);
+                // Send IP information after successful initialization
+                this.api.sendIPInfo(this.sessionId).catch(error => {
+                    logWarn('Failed to send IP info:', error);
+                });
                 // Only setup browser-specific handlers when in browser environment
                 if (isBrowser$1) {
                     this.setupPageUnloadHandler();
@@ -13456,6 +14146,8 @@ class HumanBehaviorTracker {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.initialized)
                 return;
+            // Update automatic properties for new page
+            this.propertyManager.updateAutomaticProperties();
             try {
                 const pageViewData = {
                     url: url || window.location.href,
@@ -13465,11 +14157,13 @@ class HumanBehaviorTracker {
                     referrer: document.referrer,
                     timestamp: new Date().toISOString()
                 };
+                // Get enhanced properties with automatic properties
+                const enhancedProperties = this.propertyManager.getEventProperties(pageViewData);
                 // Add pageview event to the main event stream
                 yield this.addEvent({
                     type: 5, // Custom event type
                     data: {
-                        payload: Object.assign({ eventType: 'pageview' }, pageViewData)
+                        payload: Object.assign({ eventType: 'pageview' }, enhancedProperties)
                     },
                     timestamp: Date.now()
                 });
@@ -13485,10 +14179,12 @@ class HumanBehaviorTracker {
             var _a, _b, _c, _d, _e;
             if (!this.initialized)
                 return;
+            // Get enhanced properties with automatic properties
+            const enhancedProperties = this.propertyManager.getEventProperties(properties);
             try {
                 // Send custom event directly to the API
-                yield this.api.sendCustomEvent(this.sessionId, eventName, properties);
-                logDebug(`Custom event tracked: ${eventName}`, properties);
+                yield this.api.sendCustomEvent(this.sessionId, eventName, enhancedProperties);
+                logDebug(`Custom event tracked: ${eventName}`, enhancedProperties);
             }
             catch (error) {
                 logError('Failed to track custom event:', error);
@@ -13508,7 +14204,7 @@ class HumanBehaviorTracker {
                 try {
                     const customEventData = {
                         eventName: eventName,
-                        properties: properties || {},
+                        properties: enhancedProperties || {},
                         timestamp: new Date().toISOString(),
                         url: window.location.href,
                         pathname: window.location.pathname
@@ -13808,8 +14504,25 @@ class HumanBehaviorTracker {
             // Store user properties
             this.userProperties = userProperties;
             logDebug('Identifying user:', { userProperties, originalEndUserId, sessionId: this.sessionId });
-            // Send user data with the original endUserId
-            yield this.api.sendUserData(originalEndUserId, userProperties, this.sessionId);
+            // Get automatic properties and send with user data
+            const automaticProperties = this.propertyManager.getAutomaticProperties();
+            // Create a custom user request with automatic properties
+            const userResponse = yield fetch(`${this.api['baseUrl']}/api/ingestion/user`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    userId: originalEndUserId,
+                    userAttributes: userProperties,
+                    sessionId: this.sessionId,
+                    automaticProperties: automaticProperties
+                })
+            });
+            if (!userResponse.ok) {
+                throw new Error(`Failed to identify user: ${userResponse.statusText}`);
+            }
             // Don't update endUserId - keep it as the original UUID
             return originalEndUserId || '';
         });
@@ -13857,7 +14570,7 @@ class HumanBehaviorTracker {
                     collectFonts: false, // Disable font collection to reduce errors
                     inlineStylesheet: true, // Keep styles for proper session replay
                     recordCrossOriginIframes: false, // Prevent cross-origin iframe errors
-                    // ✅ CANVAS RECORDING - PostHog-style protection against overwhelm
+                    // ✅ CANVAS RECORDING - protection against overwhelm
                     recordCanvas: this.recordCanvas, // Opt-in only
                     sampling: this.recordCanvas ? { canvas: 4 } : undefined, // 4 FPS throttle
                     dataURLOptions: this.recordCanvas ? {
@@ -14281,6 +14994,79 @@ class HumanBehaviorTracker {
             initialized: this.initialized
         };
     }
+    // ===== PROPERTY MANAGEMENT METHODS =====
+    /**
+     * Set a session property that will be included in all events for this session
+     */
+    setSessionProperty(key, value) {
+        this.propertyManager.setSessionProperty(key, value);
+    }
+    /**
+     * Set multiple session properties
+     */
+    setSessionProperties(properties) {
+        this.propertyManager.setSessionProperties(properties);
+    }
+    /**
+     * Get a session property
+     */
+    getSessionProperty(key) {
+        return this.propertyManager.getSessionProperty(key);
+    }
+    /**
+     * Remove a session property
+     */
+    removeSessionProperty(key) {
+        this.propertyManager.removeSessionProperty(key);
+    }
+    /**
+     * Set a user property that will be included in all events
+     */
+    setUserProperty(key, value) {
+        this.propertyManager.setUserProperty(key, value);
+    }
+    /**
+     * Set multiple user properties
+     */
+    setUserProperties(properties) {
+        this.propertyManager.setUserProperties(properties);
+    }
+    /**
+     * Get a user property
+     */
+    getUserProperty(key) {
+        return this.propertyManager.getUserProperty(key);
+    }
+    /**
+     * Remove a user property
+     */
+    removeUserProperty(key) {
+        this.propertyManager.removeUserProperty(key);
+    }
+    /**
+     * Set a property only if it hasn't been set before
+     */
+    setOnce(key, value, scope = 'user') {
+        this.propertyManager.setOnce(key, value, scope);
+    }
+    /**
+     * Clear all session properties
+     */
+    clearSessionProperties() {
+        this.propertyManager.clearSessionProperties();
+    }
+    /**
+     * Clear all user properties
+     */
+    clearUserProperties() {
+        this.propertyManager.clearUserProperties();
+    }
+    /**
+     * Get all properties for debugging
+     */
+    getAllProperties() {
+        return this.propertyManager.getAllProperties();
+    }
 }
 // Only expose to window object in browser environments
 if (isBrowser$1) {
@@ -14436,7 +15222,7 @@ const useUserTracking = () => {
         identifyUser
     };
 };
-// Automatic page tracking component (similar to PostHog's PostHogPageView)
+// Automatic page tracking component
 function HumanBehaviorPageView() {
     const tracker = React.useContext(HumanBehaviorContext);
     React.useEffect(() => {