jumpy-lion 0.0.42 → 0.0.44

package/dist/fingerprinting/fingerprint-overrides/locale-spoofing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locale-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/locale-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,0BAA0B,QAAO,MAgS7C,CAAC"}
+{"version":3,"file":"locale-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/locale-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,0BAA0B,QAAO,MA+T7C,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/locale-spoofing.js

@@ -39,71 +39,70 @@ export const createLocaleSpoofingScript = () => {
         };
         
         // Override Intl.DateTimeFormat to use Windows-consistent formatting
+        // CRITICAL: Store reference BEFORE override and use recursion guard
         const OriginalDateTimeFormat = Intl.DateTimeFormat;
+        let isCreatingDateTimeFormat = false; // Recursion guard
+        let cachedTimeZone = 'UTC';
+        try {
+            cachedTimeZone = new OriginalDateTimeFormat().resolvedOptions().timeZone;
+        } catch (e) {
+            // Fallback to UTC if timezone detection fails
+        }
+        
         Intl.DateTimeFormat = function(locales, options) {
-            // Ensure Windows-like date formatting regardless of actual locale
-            const windowsOptions = Object.assign({}, windowsLocaleConfig.dateFormat, options);
-            
-            // Force specific Windows locale patterns
-            if (platform === 'Win32' || !platform.includes('Linux')) {
-                if (!options || !options.timeZone) {
-                    // Use common Windows timezone handling
-                    windowsOptions.timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-                }
+            // CRITICAL: Recursion guard - if we're already inside this function, use original directly
+            if (isCreatingDateTimeFormat) {
+                return Reflect.construct(OriginalDateTimeFormat, [locales, options], OriginalDateTimeFormat);
             }
             
-            const formatter = new OriginalDateTimeFormat(locales, windowsOptions);
-            
-            // Override format method to ensure Windows-style output
-            const originalFormat = formatter.format;
-            formatter.format = function(date) {
-                let result = originalFormat.call(this, date);
+            isCreatingDateTimeFormat = true;
+            try {
+                // Ensure Windows-like date formatting regardless of actual locale
+                const windowsOptions = Object.assign({}, windowsLocaleConfig.dateFormat, options);
                 
-                // Apply Windows-specific formatting adjustments
-                if (platform === 'Win32') {
-                    // Windows often uses specific date separators and formats
-                    result = result.replace(/\\b(\\d{1,2})\\/(\\d{1,2})\\/(\\d{4})\\b/, '$1/$2/$3');
-                    result = result.replace(/\\b(\\d{4})-(\\d{2})-(\\d{2})\\b/, '$2/$3/$1');
+                // Force specific Windows locale patterns
+                if (platform === 'Win32' || !platform.includes('Linux')) {
+                    if (!options || !options.timeZone) {
+                        windowsOptions.timeZone = cachedTimeZone;
+                    }
                 }
                 
-                return result;
-            };
-            
-            return formatter;
+                // Use Reflect.construct to properly create instance with original constructor
+                const formatter = Reflect.construct(OriginalDateTimeFormat, [locales, windowsOptions], OriginalDateTimeFormat);
+                
+                return formatter;
+            } finally {
+                isCreatingDateTimeFormat = false;
+            }
         };
         
         // Override Intl.NumberFormat for Windows-consistent number formatting
         const OriginalNumberFormat = Intl.NumberFormat;
+        let isCreatingNumberFormat = false; // Recursion guard
+        
         Intl.NumberFormat = function(locales, options) {
-            const windowsOptions = Object.assign({}, windowsLocaleConfig.numberFormat, options);
-            
-            // Windows-specific number formatting
-            if (platform === 'Win32') {
-                windowsOptions.useGrouping = true;
-                if (options && options.style === 'currency') {
-                    Object.assign(windowsOptions, windowsLocaleConfig.currencyFormat, options);
-                }
+            // CRITICAL: Recursion guard
+            if (isCreatingNumberFormat) {
+                return Reflect.construct(OriginalNumberFormat, [locales, options], OriginalNumberFormat);
             }
             
-            const formatter = new OriginalNumberFormat(locales, windowsOptions);
-            
-            // Override format method for Windows-style numbers
-            const originalFormat = formatter.format;
-            formatter.format = function(number) {
-                let result = originalFormat.call(this, number);
+            isCreatingNumberFormat = true;
+            try {
+                const windowsOptions = Object.assign({}, windowsLocaleConfig.numberFormat, options);
                 
-                // Windows-specific formatting adjustments
+                // Windows-specific number formatting
                 if (platform === 'Win32') {
-                    // Ensure Windows-style thousand separators and decimal points
-                    if (typeof number === 'number' && Math.abs(number) >= 1000) {
-                        result = result.replace(/\\s/g, ','); // Replace spaces with commas for thousands
+                    windowsOptions.useGrouping = true;
+                    if (options && options.style === 'currency') {
+                        Object.assign(windowsOptions, windowsLocaleConfig.currencyFormat, options);
                     }
                 }
                 
-                return result;
-            };
-            
-            return formatter;
+                // Use Reflect.construct to properly create instance with original constructor
+                return Reflect.construct(OriginalNumberFormat, [locales, windowsOptions], OriginalNumberFormat);
+            } finally {
+                isCreatingNumberFormat = false;
+            }
         };
         
         // Override Date.prototype methods for consistent formatting
@@ -140,20 +139,27 @@ export const createLocaleSpoofingScript = () => {
         
         // Spoof timezone-related methods for consistency
         const originalGetTimezoneOffset = Date.prototype.getTimezoneOffset;
+        // Cache winter/summer offsets at init time to prevent recursion
+        let cachedWinterOffset = null;
+        let cachedSummerOffset = null;
+        try {
+            const now = new Date();
+            cachedWinterOffset = originalGetTimezoneOffset.call(new Date(now.getFullYear(), 0, 1));
+            cachedSummerOffset = originalGetTimezoneOffset.call(new Date(now.getFullYear(), 6, 1));
+        } catch (e) {
+            // Fallback - no DST adjustment
+        }
+        
         Date.prototype.getTimezoneOffset = function() {
             const offset = originalGetTimezoneOffset.call(this);
             
             // Ensure timezone offset is reported consistently
             // Windows tends to handle DST slightly differently
-            if (platform === 'Win32') {
-                const now = new Date();
-                const winterOffset = new Date(now.getFullYear(), 0, 1).getTimezoneOffset();
-                const summerOffset = new Date(now.getFullYear(), 6, 1).getTimezoneOffset();
-                
+            if (platform === 'Win32' && cachedWinterOffset !== null && cachedSummerOffset !== null) {
                 // Apply Windows-style DST calculation if needed
-                if (winterOffset !== summerOffset) {
-                    const isDST = offset === Math.min(winterOffset, summerOffset);
-                    return isDST ? summerOffset : winterOffset;
+                if (cachedWinterOffset !== cachedSummerOffset) {
+                    const isDST = offset === Math.min(cachedWinterOffset, cachedSummerOffset);
+                    return isDST ? cachedSummerOffset : cachedWinterOffset;
                 }
             }
             
@@ -163,35 +169,60 @@ export const createLocaleSpoofingScript = () => {
         // Override Intl.Collator for Windows-consistent string comparison
         if (typeof Intl.Collator !== 'undefined') {
             const OriginalCollator = Intl.Collator;
+            let isCreatingCollator = false;
             Intl.Collator = function(locales, options) {
-                const windowsOptions = Object.assign({
-                    sensitivity: 'base',
-                    usage: 'sort',
-                    caseFirst: 'upper' // Windows typically sorts uppercase first
-                }, options);
-                
-                return new OriginalCollator(locales, windowsOptions);
+                if (isCreatingCollator) {
+                    return Reflect.construct(OriginalCollator, [locales, options], OriginalCollator);
+                }
+                isCreatingCollator = true;
+                try {
+                    const windowsOptions = Object.assign({
+                        sensitivity: 'base',
+                        usage: 'sort',
+                        caseFirst: 'upper'
+                    }, options);
+                    return Reflect.construct(OriginalCollator, [locales, windowsOptions], OriginalCollator);
+                } finally {
+                    isCreatingCollator = false;
+                }
             };
         }
         
         // Override Intl.PluralRules for consistency
         if (typeof Intl.PluralRules !== 'undefined') {
             const OriginalPluralRules = Intl.PluralRules;
+            let isCreatingPluralRules = false;
             Intl.PluralRules = function(locales, options) {
-                return new OriginalPluralRules(locales || 'en-US', options);
+                if (isCreatingPluralRules) {
+                    return Reflect.construct(OriginalPluralRules, [locales, options], OriginalPluralRules);
+                }
+                isCreatingPluralRules = true;
+                try {
+                    return Reflect.construct(OriginalPluralRules, [locales || 'en-US', options], OriginalPluralRules);
+                } finally {
+                    isCreatingPluralRules = false;
+                }
             };
         }
         
         // Override Intl.RelativeTimeFormat if available
         if (typeof Intl.RelativeTimeFormat !== 'undefined') {
             const OriginalRelativeTimeFormat = Intl.RelativeTimeFormat;
+            let isCreatingRelativeTimeFormat = false;
             Intl.RelativeTimeFormat = function(locales, options) {
-                const windowsOptions = Object.assign({
-                    style: 'long',
-                    numeric: 'auto'
-                }, options);
-                
-                return new OriginalRelativeTimeFormat(locales || 'en-US', windowsOptions);
+                if (isCreatingRelativeTimeFormat) {
+                    return Reflect.construct(OriginalRelativeTimeFormat, [locales, options], OriginalRelativeTimeFormat);
+                }
+                isCreatingRelativeTimeFormat = true;
+                try {
+                    const windowsOptions = Object.assign({
+                        style: 'long',
+                        numeric: 'auto'
+                    }, options);
+                    return Reflect.construct(OriginalRelativeTimeFormat, [locales || 'en-US', windowsOptions], OriginalRelativeTimeFormat);
+                } finally {
+                    isCreatingRelativeTimeFormat = false;
+                }
             };
         }
         

package/dist/fingerprinting/fingerprint-overrides/locale-spoofing.js.map

@@ -1 +1 @@
-{"version":3,"file":"locale-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/locale-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAW,EAAE;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8RV,CAAC;AACF,CAAC,CAAC"}
+{"version":3,"file":"locale-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/locale-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAW,EAAE;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6TV,CAAC;AACF,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/prototype-integrity.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Prototype Integrity Module
+ *
+ * Ensures all property overrides are undetectable by:
+ * - Making overridden properties appear native (configurable: false)
+ * - Hiding modified property descriptors from Object.getOwnPropertyDescriptor
+ * - Protecting prototype chains from Object.getPrototypeOf inspection
+ * - Masking shadow properties from enumeration
+ *
+ * This module MUST be injected FIRST, before any other fingerprint overrides.
+ */
+export declare const createPrototypeIntegrityScript: () => string;
+//# sourceMappingURL=prototype-integrity.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/prototype-integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototype-integrity.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/prototype-integrity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,8BAA8B,QAAO,MAsVjD,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/prototype-integrity.js

@@ -0,0 +1,355 @@
+/**
+ * Prototype Integrity Module
+ *
+ * Ensures all property overrides are undetectable by:
+ * - Making overridden properties appear native (configurable: false)
+ * - Hiding modified property descriptors from Object.getOwnPropertyDescriptor
+ * - Protecting prototype chains from Object.getPrototypeOf inspection
+ * - Masking shadow properties from enumeration
+ *
+ * This module MUST be injected FIRST, before any other fingerprint overrides.
+ */
+export const createPrototypeIntegrityScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Skip if already initialized
+    if (window.__PROTOTYPE_INTEGRITY_INITIALIZED__) return;
+    window.__PROTOTYPE_INTEGRITY_INITIALIZED__ = true;
+    
+    // ============================================
+    // PROTOTYPE INTEGRITY - Hide All Overrides
+    // ============================================
+    
+    // Shadow maps to track original descriptors and overrides
+    const originalDescriptors = new WeakMap(); // obj -> Map<prop, originalDescriptor>
+    const overriddenProperties = new WeakMap(); // obj -> Set<prop>
+    const fakeDescriptors = new WeakMap(); // obj -> Map<prop, fakeDescriptor>
+    
+    // Cache original functions BEFORE any modifications
+    const _Object = Object;
+    const _Reflect = Reflect;
+    const _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    const _getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+    const _getPrototypeOf = Object.getPrototypeOf;
+    const _defineProperty = Object.defineProperty;
+    const _getOwnPropertyNames = Object.getOwnPropertyNames;
+    const _keys = Object.keys;
+    const _hasOwnProperty = Object.prototype.hasOwnProperty;
+    const _ReflectGetOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor;
+    const _ReflectDefineProperty = Reflect.defineProperty;
+    const _ReflectOwnKeys = Reflect.ownKeys;
+    const _ReflectGet = Reflect.get;
+    const _ReflectHas = Reflect.has;
+    
+    /**
+     * Register a property as overridden and cache its original descriptor
+     */
+    const registerOverride = (obj, prop, originalDescriptor) => {
+        if (!originalDescriptors.has(obj)) {
+            originalDescriptors.set(obj, new Map());
+        }
+        if (!overriddenProperties.has(obj)) {
+            overriddenProperties.set(obj, new Set());
+        }
+        
+        const objDescriptors = originalDescriptors.get(obj);
+        const objOverrides = overriddenProperties.get(obj);
+        
+        // Only cache original if not already cached
+        if (!objDescriptors.has(prop) && originalDescriptor) {
+            objDescriptors.set(prop, originalDescriptor);
+        }
+        
+        objOverrides.add(prop);
+    };
+    
+    /**
+     * Check if a property has been overridden
+     */
+    const isOverridden = (obj, prop) => {
+        const objOverrides = overriddenProperties.get(obj);
+        return objOverrides ? objOverrides.has(prop) : false;
+    };
+    
+    /**
+     * Get the original descriptor for an overridden property
+     */
+    const getOriginalDescriptor = (obj, prop) => {
+        const objDescriptors = originalDescriptors.get(obj);
+        return objDescriptors ? objDescriptors.get(prop) : undefined;
+    };
+    
+    /**
+     * Create a native-like descriptor that hides the override
+     */
+    const createNativeDescriptor = (obj, prop, actualDescriptor) => {
+        const original = getOriginalDescriptor(obj, prop);
+        
+        if (original) {
+            // Return a descriptor that looks like the original
+            // but actually uses our getter/setter
+            return {
+                configurable: original.configurable !== undefined ? original.configurable : false,
+                enumerable: original.enumerable !== undefined ? original.enumerable : true,
+                get: actualDescriptor?.get,
+                set: actualDescriptor?.set,
+                value: actualDescriptor?.value,
+                writable: original.writable
+            };
+        }
+        
+        // Default: make it look like a native property
+        if (actualDescriptor?.get || actualDescriptor?.set) {
+            return {
+                configurable: false,
+                enumerable: true,
+                get: actualDescriptor.get,
+                set: actualDescriptor.set
+            };
+        }
+        
+        return {
+            configurable: false,
+            enumerable: true,
+            writable: false,
+            value: actualDescriptor?.value
+        };
+    };
+    
+    /**
+     * Set a fake descriptor to return for getOwnPropertyDescriptor
+     */
+    const setFakeDescriptor = (obj, prop, descriptor) => {
+        if (!fakeDescriptors.has(obj)) {
+            fakeDescriptors.set(obj, new Map());
+        }
+        fakeDescriptors.get(obj).set(prop, descriptor);
+    };
+    
+    /**
+     * Override a property with native-like appearance
+     * This is the main function other modules should use
+     */
+    const overridePropertyNative = (obj, prop, descriptor) => {
+        // Cache original descriptor first
+        const originalDescriptor = _getOwnPropertyDescriptor.call(_Object, obj, prop);
+        registerOverride(obj, prop, originalDescriptor);
+        
+        // Apply the actual override
+        try {
+            _defineProperty.call(_Object, obj, prop, {
+                ...descriptor,
+                configurable: true // We need this to work, but will fake it
+            });
+            
+            // Set up the fake descriptor to return
+            const fakeDesc = createNativeDescriptor(obj, prop, descriptor);
+            setFakeDescriptor(obj, prop, fakeDesc);
+            
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    /**
+     * Override Object.getOwnPropertyDescriptor to hide our modifications
+     */
+    const patchGetOwnPropertyDescriptor = () => {
+        _defineProperty.call(_Object, _Object, 'getOwnPropertyDescriptor', {
+            value: function(obj, prop) {
+                // Check if we have a fake descriptor for this property
+                const objFakes = fakeDescriptors.get(obj);
+                if (objFakes && objFakes.has(prop)) {
+                    const fake = objFakes.get(prop);
+                    // Return a copy to prevent modification
+                    return { ...fake };
+                }
+                
+                // Otherwise return the real descriptor
+                return _getOwnPropertyDescriptor.call(_Object, obj, prop);
+            },
+            writable: true,
+            configurable: true
+        });
+        
+        // Also patch Reflect.getOwnPropertyDescriptor
+        if (_Reflect && _ReflectGetOwnPropertyDescriptor) {
+            _defineProperty.call(_Object, _Reflect, 'getOwnPropertyDescriptor', {
+                value: function(obj, prop) {
+                    const objFakes = fakeDescriptors.get(obj);
+                    if (objFakes && objFakes.has(prop)) {
+                        return { ...objFakes.get(prop) };
+                    }
+                    return _ReflectGetOwnPropertyDescriptor.call(_Reflect, obj, prop);
+                },
+                writable: true,
+                configurable: true
+            });
+        }
+    };
+    
+    /**
+     * Override Object.getOwnPropertyDescriptors to use our patched version
+     */
+    const patchGetOwnPropertyDescriptors = () => {
+        _defineProperty.call(_Object, _Object, 'getOwnPropertyDescriptors', {
+            value: function(obj) {
+                const result = {};
+                const props = _getOwnPropertyNames.call(_Object, obj);
+                
+                for (const prop of props) {
+                    // Use our patched getOwnPropertyDescriptor
+                    const desc = _Object.getOwnPropertyDescriptor(obj, prop);
+                    if (desc) {
+                        result[prop] = desc;
+                    }
+                }
+                
+                // Also include symbol properties
+                const symbols = _Object.getOwnPropertySymbols ? _Object.getOwnPropertySymbols(obj) : [];
+                for (const sym of symbols) {
+                    const desc = _Object.getOwnPropertyDescriptor(obj, sym);
+                    if (desc) {
+                        result[sym] = desc;
+                    }
+                }
+                
+                return result;
+            },
+            writable: true,
+            configurable: true
+        });
+    };
+    
+    /**
+     * Protect prototype chain inspection
+     */
+    const patchGetPrototypeOf = () => {
+        // Store original prototypes before any modification
+        const originalPrototypes = new WeakMap();
+        
+        // We don't modify Object.getPrototypeOf because we want prototypes to look normal
+        // But we can use this to verify prototype chains are intact
+    };
+    
+    /**
+     * Patch Object.keys to filter automation properties
+     */
+    const patchObjectKeys = () => {
+        const automationProps = new Set([
+            'webdriver', '__webdriver_evaluate', '__selenium_evaluate',
+            '__driver_evaluate', '__webdriver_script_function',
+            '__webdriver_script_fn', '__fxdriver_evaluate',
+            '__webdriver_unwrapped', '$cdc_', 'cdc_'
+        ]);
+        
+        _defineProperty.call(_Object, _Object, 'keys', {
+            value: function(obj) {
+                const keys = _keys.call(_Object, obj);
+                return keys.filter(key => {
+                    const keyStr = String(key).toLowerCase();
+                    for (const autoProp of automationProps) {
+                        if (keyStr.includes(autoProp.toLowerCase())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            },
+            writable: true,
+            configurable: true
+        });
+    };
+    
+    /**
+     * Patch Object.getOwnPropertyNames to filter automation properties
+     */
+    const patchGetOwnPropertyNames = () => {
+        const automationProps = new Set([
+            'webdriver', '__webdriver_evaluate', '__selenium_evaluate',
+            '__driver_evaluate', '__webdriver_script_function',
+            '__webdriver_script_fn', '__fxdriver_evaluate',
+            '__webdriver_unwrapped', '$cdc_', 'cdc_', '__puppeteer',
+            '__playwright'
+        ]);
+        
+        _defineProperty.call(_Object, _Object, 'getOwnPropertyNames', {
+            value: function(obj) {
+                const names = _getOwnPropertyNames.call(_Object, obj);
+                return names.filter(name => {
+                    const nameStr = String(name).toLowerCase();
+                    for (const autoProp of automationProps) {
+                        if (nameStr.includes(autoProp.toLowerCase())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            },
+            writable: true,
+            configurable: true
+        });
+    };
+    
+    /**
+     * Patch Reflect.ownKeys to filter automation properties
+     */
+    const patchReflectOwnKeys = () => {
+        if (!_Reflect || !_ReflectOwnKeys) return;
+        
+        const automationProps = new Set([
+            'webdriver', '__webdriver', '__selenium', '__driver',
+            '__puppeteer', '__playwright', '$cdc_', 'cdc_'
+        ]);
+        
+        _defineProperty.call(_Object, _Reflect, 'ownKeys', {
+            value: function(obj) {
+                const keys = _ReflectOwnKeys.call(_Reflect, obj);
+                return keys.filter(key => {
+                    const keyStr = String(key).toLowerCase();
+                    for (const autoProp of automationProps) {
+                        if (keyStr.includes(autoProp.toLowerCase())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            },
+            writable: true,
+            configurable: true
+        });
+    };
+    
+    /**
+     * Initialize all prototype integrity patches
+     */
+    const initialize = () => {
+        patchGetOwnPropertyDescriptor();
+        patchGetOwnPropertyDescriptors();
+        patchGetPrototypeOf();
+        patchObjectKeys();
+        patchGetOwnPropertyNames();
+        patchReflectOwnKeys();
+    };
+    
+    // Initialize immediately
+    initialize();
+    
+    // Export utilities for use by other modules
+    window.__prototypeIntegrity__ = {
+        registerOverride,
+        isOverridden,
+        getOriginalDescriptor,
+        setFakeDescriptor,
+        overridePropertyNative,
+        createNativeDescriptor
+    };
+    
+    console.log('[CDP-FP-DEBUG] ✓ Prototype integrity initialized');
+})();
+`;
+};
+//# sourceMappingURL=prototype-integrity.js.map

package/dist/fingerprinting/fingerprint-overrides/prototype-integrity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototype-integrity.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/prototype-integrity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACvD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoVV,CAAC;AACF,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.d.ts

@@ -4,6 +4,8 @@
  *
  * IMPORTANT: This is now a SCRIPT to be injected via addScriptToEvaluateOnNewDocument,
  * NOT via Runtime.evaluate (which would defeat the purpose since Runtime.evaluate IS detectable!)
+ *
+ * Enhanced 2024-2025: Comprehensive stack trace sanitization that removes ALL CDP markers
  */
 /**
  * Creates the runtime enable bypass script that should be bundled with other stealth scripts.

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-enable-bypass.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,eAAO,MAAM,+BAA+B,QAAO,MAkIlD,CAAC"}
+{"version":3,"file":"runtime-enable-bypass.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;GAGG;AACH,eAAO,MAAM,+BAA+B,QAAO,MAmQlD,CAAC"}