humanbehavior-js 0.4.22 → 0.4.24

package/dist/cjs/react/index.cjs

@@ -12886,15 +12886,15 @@ class HumanBehaviorAPI {
     }
 }
 
-// Redaction functionality for sensitive input fields
-// 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$3 = typeof window !== 'undefined';
+// Simplified redaction functionality for HumanBehavior SDK
+// Since rrweb auto-redacts all input fields by default, this module only handles
+// selectively unredacting specific fields (except passwords which remain protected)
 class RedactionManager {
     constructor(options) {
         this.redactedText = '[REDACTED]';
-        this.userSelectedFields = new Set(); // User-selected fields to redact
+        this.unredactedFields = new Set(); // Fields that user wants to unredact
+        this.redactedFields = new Set(); // Fields that user wants to redact
+        this.redactionMode = 'privacy-first';
         this.excludeSelectors = [
             '[data-no-redact="true"]',
             '.human-behavior-no-redact'
@@ -12905,419 +12905,180 @@ class RedactionManager {
         if (options === null || options === void 0 ? void 0 : options.excludeSelectors) {
             this.excludeSelectors = [...this.excludeSelectors, ...options.excludeSelectors];
         }
+        // Handle new redaction strategy
+        if (options === null || options === void 0 ? void 0 : options.redactionStrategy) {
+            this.redactionMode = options.redactionStrategy.mode;
+            if (this.redactionMode === 'privacy-first') {
+                // Privacy-first: everything redacted by default, unredact specific fields
+                if (options.redactionStrategy.unredactFields) {
+                    this.setFieldsToUnredact(options.redactionStrategy.unredactFields);
+                }
+            }
+            else {
+                // Visibility-first: everything visible by default, redact specific fields
+                if (options.redactionStrategy.redactFields) {
+                    this.setFieldsToRedact(options.redactionStrategy.redactFields);
+                }
+            }
+        }
+        // Handle legacy redactFields (backward compatibility)
+        if (options === null || options === void 0 ? void 0 : options.legacyRedactFields) {
+            this.setFieldsToUnredact(options.legacyRedactFields);
+        }
+        // Handle legacy userFields
         if (options === null || options === void 0 ? void 0 : options.userFields) {
-            this.setFieldsToRedact(options.userFields);
+            this.setFieldsToUnredact(options.userFields);
         }
     }
     /**
-     * Set specific fields to be redacted using CSS selectors
-     * These selectors are used to configure rrweb's built-in masking
+     * Set specific fields to be redacted (for visibility-first mode)
      * @param fields Array of CSS selectors for fields to redact
      */
     setFieldsToRedact(fields) {
-        this.userSelectedFields.clear();
-        fields.forEach(field => this.userSelectedFields.add(field));
-        if (fields.length > 0) {
-            logDebug(`Redaction: Active for ${fields.length} field(s):`, fields);
-            // Debug: Check if elements exist
-            fields.forEach(selector => {
-                const elements = document.querySelectorAll(selector);
-                logDebug(`Redaction: Found ${elements.length} element(s) for selector '${selector}'`);
-                elements.forEach((el, index) => {
-                    logDebug(`Redaction: Element ${index} for '${selector}':`, el);
-                });
-            });
+        this.redactedFields.clear();
+        // Always include password fields in redacted list
+        const passwordFields = [
+            'input[type="password"]',
+            'input[type="password" i]',
+            '[type="password"]',
+            '[type="password" i]'
+        ];
+        // Add password fields and user-specified fields
+        [...passwordFields, ...fields].forEach(field => {
+            this.redactedFields.add(field);
+        });
+        if (this.redactedFields.size > 0) {
+            logDebug(`Redaction: Active for ${this.redactedFields.size} field(s):`, Array.from(this.redactedFields));
         }
         else {
-            logDebug('Redaction: Disabled - no fields selected');
-        }
-    }
-    /**
-     * Check if redaction is currently active (has fields selected)
-     */
-    isActive() {
-        return this.userSelectedFields.size > 0;
-    }
-    /**
-     * Get the currently selected fields for redaction
-     */
-    getSelectedFields() {
-        return Array.from(this.userSelectedFields);
-    }
-    /**
-     * Process an event and redact sensitive data if needed
-     * NOTE: This method is no longer used - events are handled directly by rrweb
-     * Kept for backward compatibility but not called in the current implementation
-     */
-    processEvent(event) {
-        // Only process if we have fields selected for redaction
-        if (this.userSelectedFields.size === 0) {
-            return event;
-        }
-        // Clone the event to avoid modifying the original
-        const processedEvent = JSON.parse(JSON.stringify(event));
-        // Handle different event types
-        if (processedEvent.type === 3) { // IncrementalSnapshot
-            if (processedEvent.data.source === 5) { // Input event
-                const shouldRedact = this.isFieldSelected(processedEvent.data);
-                if (shouldRedact) {
-                    logDebug('Redaction: Processing input event for redaction');
-                    this.redactInputEvent(processedEvent.data);
-                }
-            }
-            // Also check for other sources that might contain text changes
-            else if (processedEvent.data.source === 0) { // DOM mutations
-                this.redactDOMEvent(processedEvent.data);
-            }
-            // Handle other sources that might contain text
-            else if (processedEvent.data.source === 2) { // Mouse/Touch interaction
-                this.redactMouseEvent(processedEvent.data);
-            }
-        }
-        else if (processedEvent.type === 2) { // FullSnapshot
-            this.redactFullSnapshot(processedEvent.data);
+            logDebug('Redaction: No fields to redact');
         }
-        return processedEvent;
+        this.applyRedactionClasses();
     }
     /**
-     * Redact sensitive data in input events
+     * Set specific fields to be unredacted (everything else stays redacted by rrweb)
+     * @param fields Array of CSS selectors for fields to unredact
      */
-    redactInputEvent(inputData) {
-        // Check if this input event is from a field we want to redact
-        if (!this.isFieldSelected(inputData)) {
-            return;
-        }
-        logDebug('Redaction: Redacting input event with text:', inputData.text);
-        // Redact all text-related properties that could contain input data
-        const textProperties = ['text', 'value', 'content', 'data', 'input', 'textContent'];
-        textProperties.forEach(prop => {
-            if (inputData[prop] !== undefined && typeof inputData[prop] === 'string') {
-                inputData[prop] = this.redactedText;
-                logDebug(`Redaction: Redacted property '${prop}'`);
-            }
-        });
-        // Also check for any other string properties that might contain input data
-        Object.keys(inputData).forEach(key => {
-            if (typeof inputData[key] === 'string' && inputData[key].length > 0) {
-                inputData[key] = this.redactedText;
-                logDebug(`Redaction: Redacted additional property '${key}'`);
-            }
+    setFieldsToUnredact(fields) {
+        this.unredactedFields.clear();
+        // Filter out password fields (they cannot be unredacted)
+        const validFields = fields.filter(field => {
+            const isPasswordField = this.isPasswordSelector(field);
+            if (isPasswordField) {
+                logWarn(`Cannot unredact password field: ${field} - Password fields are always protected`);
+                return false;
+            }
+            return true;
         });
-        // Handle nested objects that might contain text data
-        if (inputData.attributes && typeof inputData.attributes === 'object') {
-            if (inputData.attributes.value && typeof inputData.attributes.value === 'string') {
-                inputData.attributes.value = this.redactedText;
-                logDebug('Redaction: Redacted nested value attribute');
-            }
-        }
-        logDebug('Redaction: Input event redaction complete');
-    }
-    /**
-     * Redact sensitive data in DOM mutation events
-     */
-    redactDOMEvent(domData) {
-        // Check for text changes in DOM mutations
-        if (domData.texts && Array.isArray(domData.texts)) {
-            domData.texts.forEach((textChange) => {
-                if (textChange.text && typeof textChange.text === 'string' &&
-                    this.shouldRedactDOMChange(textChange)) {
-                    textChange.text = this.redactedText;
-                }
-            });
-        }
-        // Also check for attribute changes that might contain input data
-        if (domData.attributes && Array.isArray(domData.attributes)) {
-            domData.attributes.forEach((attrChange) => {
-                if (attrChange.attributes && attrChange.attributes.value &&
-                    typeof attrChange.attributes.value === 'string' &&
-                    this.shouldRedactDOMChange(attrChange)) {
-                    attrChange.attributes.value = this.redactedText;
-                }
-            });
+        validFields.forEach(field => this.unredactedFields.add(field));
+        if (validFields.length > 0) {
+            logDebug(`Unredaction: Active for ${validFields.length} field(s):`, validFields);
         }
-        // Check for any other properties that might contain text data
-        if (domData.adds && Array.isArray(domData.adds)) {
-            domData.adds.forEach((add) => {
-                if (add.node && add.node.textContent && typeof add.node.textContent === 'string' &&
-                    this.shouldRedactDOMChange(add)) {
-                    add.node.textContent = this.redactedText;
-                }
-            });
+        else {
+            logDebug('Unredaction: No valid fields to unredact');
         }
+        this.applyUnredactionClasses();
     }
     /**
-     * Check if a DOM change should be redacted based on its ID
+     * Remove specific fields from unredaction (they become redacted again)
+     * @param fields Array of CSS selectors for fields to redact
      */
-    shouldRedactDOMChange(changeData) {
-        if (!isBrowser$3)
-            return false;
-        try {
-            // Check if this change has an ID that we can use to find the element
-            const elementId = changeData.id;
-            if (elementId !== undefined) {
-                // Try to find the element by data-rrweb-id attribute
-                let element = document.querySelector(`[data-rrweb-id="${elementId}"]`);
-                if (element) {
-                    return this.shouldRedactElement(element);
-                }
-            }
-            // Also check for nodeId which is another way rrweb identifies elements
-            const nodeId = changeData.nodeId;
-            if (nodeId !== undefined) {
-                const element = document.querySelector(`[data-rrweb-id="${nodeId}"]`);
-                if (element) {
-                    return this.shouldRedactElement(element);
-                }
-            }
-            return false;
+    redactFields(fields) {
+        fields.forEach(field => {
+            this.unredactedFields.delete(field);
+        });
+        if (this.unredactedFields.size > 0) {
+            logDebug(`Unredaction: Removed ${fields.length} field(s), ${this.unredactedFields.size} remaining:`, Array.from(this.unredactedFields));
         }
-        catch (e) {
-            logWarn('Error checking if DOM change should be redacted:', e);
-            return false;
+        else {
+            logDebug('Unredaction: All fields redacted');
         }
+        this.applyUnredactionClasses();
     }
     /**
-     * Redact sensitive data in mouse/touch interaction events
+     * Clear all unredacted fields (everything becomes redacted again)
      */
-    redactMouseEvent(mouseData) {
-        // Mouse events typically don't contain text data, but check for any text properties
-        if (mouseData.text && typeof mouseData.text === 'string' &&
-            this.isFieldSelected(mouseData)) {
-            mouseData.text = this.redactedText;
-        }
+    clearUnredactedFields() {
+        this.unredactedFields.clear();
+        logDebug('Unredaction: All fields cleared, everything redacted');
+        this.removeUnredactionClasses();
     }
     /**
-     * Redact sensitive data in full snapshot events
+     * Check if any fields are currently unredacted
      */
-    redactFullSnapshot(snapshotData) {
-        if (snapshotData.node && snapshotData.node.type === 2) { // Element node
-            this.redactNode(snapshotData.node);
-        }
+    hasUnredactedFields() {
+        return this.unredactedFields.size > 0;
     }
     /**
-     * Recursively redact sensitive data in DOM nodes
+     * Get the current redaction mode
      */
-    redactNode(node) {
-        if (!node)
-            return;
-        // Check if this node should be redacted
-        if (node.type === 2 && node.tagName &&
-            (node.tagName.toLowerCase() === 'input' || node.tagName.toLowerCase() === 'textarea')) {
-            // Check if this input/textarea should be redacted
-            if (this.shouldRedactNode(node)) {
-                // Redact value attribute
-                if (node.attributes && node.attributes.value) {
-                    node.attributes.value = this.redactedText;
-                }
-                // Redact text content
-                if (node.textContent) {
-                    node.textContent = this.redactedText;
-                }
-            }
-        }
-        // Recursively process child nodes
-        if (node.childNodes && Array.isArray(node.childNodes)) {
-            node.childNodes.forEach((childNode) => {
-                this.redactNode(childNode);
-            });
-        }
+    getRedactionMode() {
+        return this.redactionMode;
     }
     /**
-     * Check if a node should be redacted based on its attributes
+     * Get the currently unredacted fields
      */
-    shouldRedactNode(node) {
-        if (!node.attributes)
-            return false;
-        // Check if any of our selectors would match this node
-        for (const selector of this.userSelectedFields) {
-            if (this.selectorMatchesNode(selector, node)) {
-                return true;
-            }
-        }
-        return false;
+    getUnredactedFields() {
+        return Array.from(this.unredactedFields);
     }
     /**
-     * Check if a CSS selector would match a node based on its attributes
-     */
-    selectorMatchesNode(selector, node) {
-        if (!node.attributes)
-            return false;
-        // Create a temporary element to test the selector
-        try {
-            const tempElement = document.createElement(node.tagName || 'div');
-            // Copy attributes from the node to the temp element
-            if (node.attributes) {
-                Object.keys(node.attributes).forEach(key => {
-                    tempElement.setAttribute(key, node.attributes[key]);
-                });
-            }
-            // Test if the selector matches this element
-            return tempElement.matches(selector);
-        }
-        catch (e) {
-            // If matches() is not supported or fails, fall back to basic attribute checking
-            return this.basicSelectorMatch(selector, node);
-        }
-    }
-    /**
-     * Basic selector matching for environments where matches() is not available
+     * Get CSS selectors for rrweb masking configuration
+     * Returns null if no fields are unredacted (everything stays redacted)
      */
-    basicSelectorMatch(selector, node) {
-        if (!node.attributes)
-            return false;
-        // Handle simple selectors like 'input[type="password"]'
-        if (selector.includes('input[type=')) {
-            const typeMatch = selector.match(/input\[type="([^"]+)"\]/);
-            if (typeMatch && node.tagName === 'input' && node.attributes.type === typeMatch[1]) {
-                return true;
+    getMaskTextSelector() {
+        if (this.redactionMode === 'privacy-first') {
+            // Privacy-first: mask everything except unredacted fields
+            if (this.unredactedFields.size === 0) {
+                return null; // Everything stays redacted
             }
+            return Array.from(this.unredactedFields).join(',');
         }
-        // Handle ID selectors like '#email'
-        if (selector.startsWith('#')) {
-            const id = selector.substring(1);
-            return node.attributes.id === id;
-        }
-        // Handle class selectors like '.sensitive-field'
-        if (selector.startsWith('.')) {
-            const className = selector.substring(1);
-            return node.attributes.class && node.attributes.class.includes(className);
-        }
-        // Handle tag selectors like 'input'
-        if (!selector.includes('[') && !selector.includes('.')) {
-            return node.tagName && node.tagName.toLowerCase() === selector.toLowerCase();
-        }
-        return false;
-    }
-    /**
-     * Check if an event is from a field that should be redacted
-     */
-    isFieldSelected(eventData) {
-        if (!isBrowser$3)
-            return false;
-        try {
-            // For input events (source 5), we need to determine if this is a sensitive field
-            if (eventData.source === 5) { // Input event
-                const elementId = eventData.id;
-                if (elementId !== undefined) {
-                    // Try to find the element by data-rrweb-id attribute
-                    let element = document.querySelector(`[data-rrweb-id="${elementId}"]`);
-                    if (element) {
-                        return this.shouldRedactElement(element);
-                    }
-                    // Fallback: Try to find by nodeId if available
-                    if (eventData.nodeId !== undefined) {
-                        element = document.querySelector(`[data-rrweb-id="${eventData.nodeId}"]`);
-                        if (element) {
-                            return this.shouldRedactElement(element);
-                        }
-                    }
-                    // More aggressive approach: Check all elements that match our selectors
-                    // and see if any of them are currently focused or have the same ID
-                    for (const selector of this.userSelectedFields) {
-                        const matchingElements = document.querySelectorAll(selector);
-                        if (matchingElements.length > 0) {
-                            // Check if any of these elements are currently focused
-                            for (const el of matchingElements) {
-                                if (el === document.activeElement) {
-                                    logDebug('Redaction: Found focused element matching selector:', selector);
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-                    // If we still can't find it, try a more direct approach
-                    // Look for any input element that might be the active one
-                    const activeElement = document.activeElement;
-                    if (activeElement && this.shouldRedactElement(activeElement)) {
-                        logDebug('Redaction: Active element should be redacted');
-                        return true;
-                    }
-                    return false;
-                }
-            }
-            // For other event types, try to find the element
-            const elementId = eventData.id;
-            if (elementId !== undefined) {
-                // First try to find by data-rrweb-id attribute
-                let element = document.querySelector(`[data-rrweb-id="${elementId}"]`);
-                if (element) {
-                    return this.shouldRedactElement(element);
-                }
-            }
-            // Also check for nodeId which is another way rrweb identifies elements
-            const nodeId = eventData.nodeId;
-            if (nodeId !== undefined) {
-                const element = document.querySelector(`[data-rrweb-id="${nodeId}"]`);
-                if (element) {
-                    return this.shouldRedactElement(element);
-                }
-            }
-            // For DOM mutations, check if the target element should be redacted
-            if (eventData.target && eventData.target.id) {
-                const element = document.querySelector(`[data-rrweb-id="${eventData.target.id}"]`);
-                if (element) {
-                    return this.shouldRedactElement(element);
-                }
+        else {
+            // Visibility-first: mask only redacted fields
+            if (this.redactedFields.size === 0) {
+                return null; // Nothing to redact
             }
-            return false;
-        }
-        catch (e) {
-            logWarn('Error checking if field should be redacted:', e);
-            return false;
-        }
-    }
-    /**
-     * Get CSS selectors for rrweb masking configuration
-     * Used to configure rrweb's maskTextSelector option
-     */
-    getMaskTextSelector() {
-        if (this.userSelectedFields.size === 0) {
-            return null;
+            return Array.from(this.redactedFields).join(',');
         }
-        return Array.from(this.userSelectedFields).join(',');
     }
     /**
-     * Check if an element should be redacted (for rrweb maskTextFn/maskInputFn)
+     * Apply redaction classes to DOM elements (for visibility-first mode)
+     * Adds 'rr-mask' class to elements that should be redacted
      */
-    shouldRedactElement(element) {
-        if (this.userSelectedFields.size === 0) {
-            return false;
+    applyRedactionClasses() {
+        if (this.redactedFields.size === 0) {
+            return;
         }
-        // Check if any selector matches this element
-        for (const selector of this.userSelectedFields) {
+        // Add 'rr-mask' class to redacted elements
+        this.redactedFields.forEach(selector => {
             try {
-                if (element.matches(selector)) {
-                    return true;
-                }
+                const elements = document.querySelectorAll(selector);
+                elements.forEach(element => {
+                    element.classList.add('rr-mask');
+                });
+                logDebug(`Added rr-mask class to ${elements.length} element(s) for selector: ${selector}`);
             }
             catch (e) {
-                // Invalid selector, skip
                 logWarn(`Invalid selector: ${selector}`);
             }
-        }
-        return false;
+        });
     }
     /**
-     * Apply rrweb masking classes to DOM elements
-     * Adds 'rr-mask' class to elements that should be redacted
-     * This enables rrweb's built-in masking functionality
+     * Apply unredaction classes to DOM elements
+     * Removes 'rr-mask' class from elements that should be unredacted
      */
-    applyRedactionClasses() {
-        if (this.userSelectedFields.size === 0) {
+    applyUnredactionClasses() {
+        if (this.unredactedFields.size === 0) {
             return;
         }
-        // Remove existing redaction classes
-        document.querySelectorAll('.rr-mask').forEach(element => {
-            element.classList.remove('rr-mask');
-        });
-        // Add redaction classes to matching elements
-        this.userSelectedFields.forEach(selector => {
+        // Remove 'rr-mask' class from unredacted elements
+        this.unredactedFields.forEach(selector => {
             try {
                 const elements = document.querySelectorAll(selector);
                 elements.forEach(element => {
-                    element.classList.add('rr-mask');
+                    element.classList.remove('rr-mask');
                 });
-                logDebug(`Applied rr-mask class to ${elements.length} element(s) for selector: ${selector}`);
+                logDebug(`Removed rr-mask class from ${elements.length} element(s) for selector: ${selector}`);
             }
             catch (e) {
                 logWarn(`Invalid selector: ${selector}`);
@@ -13325,7 +13086,26 @@ class RedactionManager {
         });
     }
     /**
-     * Get the original value of a redacted element (for debugging)
+     * Remove all unredaction classes from DOM elements
+     */
+    removeUnredactionClasses() {
+        // Note: This doesn't add 'rr-mask' classes back - rrweb handles that automatically
+        logDebug('Unredaction classes removed');
+    }
+    /**
+     * Check if a selector represents a password field
+     */
+    isPasswordSelector(selector) {
+        const passwordPatterns = [
+            'input[type="password"]',
+            'input[type="password" i]',
+            '[type="password"]',
+            '[type="password" i]'
+        ];
+        return passwordPatterns.some(pattern => selector.toLowerCase().includes(pattern.toLowerCase().replace(/[\[\]]/g, '')));
+    }
+    /**
+     * Get the original value of an element (for debugging)
      */
     getOriginalValue(element) {
         if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
@@ -13334,10 +13114,51 @@ class RedactionManager {
         return undefined;
     }
     /**
-     * Check if an element is currently being redacted
+     * Check if an element is currently unredacted
      */
-    isElementRedacted(element) {
-        return this.shouldRedactElement(element);
+    isElementUnredacted(element) {
+        return this.shouldUnredactElement(element);
+    }
+    /**
+     * Check if an element should be unredacted
+     */
+    shouldUnredactElement(element) {
+        if (this.redactionMode === 'privacy-first') {
+            // Privacy-first: check if element is in unredacted fields
+            if (this.unredactedFields.size === 0) {
+                return false; // Nothing unredacted
+            }
+            // Check if any selector matches this element
+            for (const selector of this.unredactedFields) {
+                try {
+                    if (element.matches(selector)) {
+                        return true;
+                    }
+                }
+                catch (e) {
+                    logWarn(`Invalid selector: ${selector}`);
+                }
+            }
+            return false;
+        }
+        else {
+            // Visibility-first: check if element is NOT in redacted fields
+            if (this.redactedFields.size === 0) {
+                return true; // Nothing redacted, everything visible
+            }
+            // Check if any selector matches this element
+            for (const selector of this.redactedFields) {
+                try {
+                    if (element.matches(selector)) {
+                        return false; // Element is redacted
+                    }
+                }
+                catch (e) {
+                    logWarn(`Invalid selector: ${selector}`);
+                }
+            }
+            return true; // Element is not redacted
+        }
     }
 }
 // Export a default instance
@@ -13906,11 +13727,22 @@ class HumanBehaviorTracker {
         });
         // 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
+        // Set unredacted fields if specified (legacy support)
         if (options === null || options === void 0 ? void 0 : options.redactFields) {
-            tracker.setRedactedFields(options.redactFields);
-            // ✅ Apply redaction classes to existing elements
-            tracker.redactionManager.applyRedactionClasses();
+            tracker.setUnredactedFields(options.redactFields);
+        }
+        // Handle new redaction strategy
+        if (options === null || options === void 0 ? void 0 : options.redactionStrategy) {
+            if (options.redactionStrategy.mode === 'privacy-first') {
+                if (options.redactionStrategy.unredactFields) {
+                    tracker.setUnredactedFields(options.redactionStrategy.unredactFields);
+                }
+            }
+            else {
+                if (options.redactionStrategy.redactFields) {
+                    tracker.setRedactedFields(options.redactionStrategy.redactFields);
+                }
+            }
         }
         // Setup automatic tracking if enabled
         if ((options === null || options === void 0 ? void 0 : options.enableAutomaticTracking) !== false) {
@@ -13957,7 +13789,10 @@ class HumanBehaviorTracker {
             ingestionUrl: ingestionUrl || defaultIngestionUrl
         });
         this.apiKey = apiKey;
-        this.redactionManager = new RedactionManager();
+        this.redactionManager = new RedactionManager({
+            redactionStrategy: options === null || options === void 0 ? void 0 : options.redactionStrategy,
+            legacyRedactFields: options === null || options === void 0 ? void 0 : options.redactFields // For backward compatibility
+        });
         // Initialize property manager
         this.propertyManager = new PropertyManager({
             enableAutomaticProperties: (options === null || options === void 0 ? void 0 : options.enableAutomaticProperties) !== false,
@@ -14535,6 +14370,31 @@ class HumanBehaviorTracker {
             if (!userResponse.ok) {
                 throw new Error(`Failed to identify user: ${userResponse.statusText}`);
             }
+            // Get IP info and GeoIP data
+            try {
+                const ipResponse = yield fetch(`${this.api['baseUrl']}/api/ingestion/ip-info`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        sessionId: this.sessionId,
+                        clientIP: null, // Let server detect from headers
+                        ipDetectionMethod: 'headers',
+                        timestamp: new Date().toISOString()
+                    })
+                });
+                if (ipResponse.ok) {
+                    logDebug('✅ IP info and GeoIP data retrieved successfully');
+                }
+                else {
+                    logDebug(`⚠️ IP info request failed: ${ipResponse.statusText}`);
+                }
+            }
+            catch (error) {
+                logDebug(`⚠️ IP info request error: ${error}`);
+            }
             // Don't update endUserId - keep it as the original UUID
             return originalEndUserId || '';
         });
@@ -14574,7 +14434,7 @@ class HumanBehaviorTracker {
                     // ✅ HUMANBEHAVIOR'S CUSTOM SETTINGS
                     maskTextSelector: this.redactionManager.getMaskTextSelector() || undefined,
                     maskTextFn: undefined,
-                    maskAllInputs: true, // HumanBehavior default
+                    maskAllInputs: this.redactionManager.getRedactionMode() === 'privacy-first', // Configurable based on strategy
                     maskInputOptions: { password: true }, // HumanBehavior default
                     maskInputFn: undefined,
                     slimDOMOptions: {},
@@ -14884,15 +14744,23 @@ class HumanBehaviorTracker {
         });
     }
     /**
-     * Set specific fields to be redacted during session recording
-     * Uses rrweb's built-in masking instead of custom redaction processing
-     * @param fields Array of CSS selectors for fields to redact (e.g., ['input[type="password"]', '#email-field'])
+     * Set specific fields to be redacted (for visibility-first mode)
+     * @param fields Array of CSS selectors for fields to redact
      */
     setRedactedFields(fields) {
         this.redactionManager.setFieldsToRedact(fields);
-        // ✅ APPLY RRWEB MASKING CLASSES - More reliable than custom processing
-        this.redactionManager.applyRedactionClasses();
-        // ✅ RESTART RECORDING WITH NEW SETTINGS - Ensures masking is applied
+        // ✅ RESTART RECORDING WITH NEW SETTINGS - Ensures redaction is applied
+        if (this.recordInstance) {
+            this.restartWithNewRedaction();
+        }
+    }
+    /**
+     * Set specific fields to be unredacted (everything else stays redacted by rrweb)
+     * @param fields Array of CSS selectors for fields to unredact (e.g., ['#username', '#comment'])
+     */
+    setUnredactedFields(fields) {
+        this.redactionManager.setFieldsToUnredact(fields);
+        // ✅ RESTART RECORDING WITH NEW SETTINGS - Ensures unredaction is applied
         if (this.recordInstance) {
             this.restartWithNewRedaction();
         }
@@ -14904,16 +14772,37 @@ class HumanBehaviorTracker {
         }
     }
     /**
-     * Check if redaction is currently active
+     * Check if any fields are currently unredacted
      */
-    isRedactionActive() {
-        return this.redactionManager.isActive();
+    hasUnredactedFields() {
+        return this.redactionManager.hasUnredactedFields();
     }
     /**
-     * Get the currently selected fields for redaction
+     * Get the currently unredacted fields
      */
-    getRedactedFields() {
-        return this.redactionManager.getSelectedFields();
+    getUnredactedFields() {
+        return this.redactionManager.getUnredactedFields();
+    }
+    /**
+     * Remove specific fields from unredaction (they become redacted again)
+     * @param fields Array of CSS selectors for fields to redact
+     */
+    redactFields(fields) {
+        this.redactionManager.redactFields(fields);
+        // ✅ RESTART RECORDING WITH NEW SETTINGS - Ensures redaction is updated
+        if (this.recordInstance) {
+            this.restartWithNewRedaction();
+        }
+    }
+    /**
+     * Clear all unredacted fields (everything becomes redacted again)
+     */
+    clearUnredactedFields() {
+        this.redactionManager.clearUnredactedFields();
+        // ✅ RESTART RECORDING WITH NEW SETTINGS - Ensures redaction is updated
+        if (this.recordInstance) {
+            this.restartWithNewRedaction();
+        }
     }
     /**
      * Get the current session ID
@@ -15199,22 +15088,22 @@ const useHumanBehavior = () => {
     }
     return tracker;
 };
-// Custom hook for managing redaction fields dynamically
+// Custom hook for managing unredaction fields dynamically
 const useRedaction = () => {
     const tracker = useHumanBehavior();
-    const setRedactedFields = React.useCallback((fields) => {
-        tracker.setRedactedFields(fields);
+    const setUnredactedFields = React.useCallback((fields) => {
+        tracker.setUnredactedFields(fields);
     }, [tracker]);
-    const isRedactionActive = React.useCallback(() => {
-        return tracker.isRedactionActive();
+    const hasUnredactedFields = React.useCallback(() => {
+        return tracker.hasUnredactedFields();
     }, [tracker]);
-    const getRedactedFields = React.useCallback(() => {
-        return tracker.getRedactedFields();
+    const getUnredactedFields = React.useCallback(() => {
+        return tracker.getUnredactedFields();
     }, [tracker]);
     return {
-        setRedactedFields,
-        isRedactionActive,
-        getRedactedFields
+        setUnredactedFields,
+        hasUnredactedFields,
+        getUnredactedFields
     };
 };
 // Custom hook for managing user info