jumpy-lion 0.0.41 → 0.0.43

package/dist/fingerprinting/fingerprint-overrides/utils.js

@@ -0,0 +1,517 @@
+/**
+ * Stealth Utility Functions
+ *
+ * Similar to puppeteer-extra-plugin-stealth's utils.js
+ * Provides helper functions for overriding browser properties without detection.
+ */
+/**
+ * Creates a stealth utilities script that can be injected into the browser.
+ * This script provides helper functions for property overrides that hide their tracks.
+ */
+export const createStealthUtilsScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Skip if already initialized
+    if (window.__STEALTH_UTILS_INITIALIZED__) return;
+    window.__STEALTH_UTILS_INITIALIZED__ = true;
+    
+    // ============================================
+    // STEALTH UTILITIES - Hide Property Overrides
+    // ============================================
+    
+    // Cache original toString BEFORE any modifications
+    const nativeToStringFunctionString = Function.prototype.toString.call(Function.prototype.toString);
+    const nativeToStringFunc = Function.prototype.toString;
+    const nativeCall = Function.prototype.call;
+    const nativeApply = Function.prototype.apply;
+    const nativeBind = Function.prototype.bind;
+    
+    // WeakMap to track which functions should appear native
+    const nativeFunctionOverrides = new WeakMap();
+    
+    // Track bound functions to their originals
+    const boundFunctionMap = new WeakMap();
+    
+    // Track proxy targets
+    const proxyTargetMap = new WeakMap();
+    
+    /**
+     * Generate a native-looking function string
+     * Handles various function types for maximum authenticity
+     */
+    const makeNativeString = (name = '', type = 'function') => {
+        // Clean the name - remove "bound " prefix if present
+        const cleanName = name.replace(/^bound /, '');
+        
+        // Different native string formats
+        if (type === 'getter') {
+            return \`function get \${cleanName}() { [native code] }\`;
+        }
+        if (type === 'setter') {
+            return \`function set \${cleanName}() { [native code] }\`;
+        }
+        if (type === 'async') {
+            return \`async function \${cleanName}() { [native code] }\`;
+        }
+        if (type === 'generator') {
+            return \`function* \${cleanName}() { [native code] }\`;
+        }
+        
+        return \`function \${cleanName}() { [native code] }\`;
+    };
+    
+    /**
+     * Register a function to appear native when toString is called
+     * Enhanced to handle bound functions and proxies
+     */
+    const registerNativeFunction = (fn, name = '', type = 'function') => {
+        if (typeof fn !== 'function') return;
+        
+        nativeFunctionOverrides.set(fn, { name, type });
+        
+        // Also register any bound versions
+        try {
+            const boundVersion = fn.bind(null);
+            if (boundVersion !== fn) {
+                boundFunctionMap.set(boundVersion, fn);
+            }
+        } catch (e) {
+            // Some functions can't be bound, ignore
+        }
+    };
+    
+    /**
+     * Check if a function is a Proxy
+     */
+    const isProxy = (fn) => {
+        try {
+            // Proxies throw when you try to get their prototype in certain ways
+            return proxyTargetMap.has(fn);
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    /**
+     * Register a Proxy and its target for toString lookup
+     */
+    const registerProxyTarget = (proxy, target, name = '') => {
+        proxyTargetMap.set(proxy, { target, name });
+        registerNativeFunction(proxy, name);
+    };
+    
+    /**
+     * Patch Function.prototype.toString to hide overridden functions
+     * Enhanced with multiple levels of protection
+     */
+    const patchToString = () => {
+        const patchedToString = function() {
+            // Handle registered native functions
+            if (nativeFunctionOverrides.has(this)) {
+                const info = nativeFunctionOverrides.get(this);
+                return makeNativeString(info.name, info.type);
+            }
+            
+            // Handle bound functions - look up original
+            if (boundFunctionMap.has(this)) {
+                const original = boundFunctionMap.get(this);
+                if (nativeFunctionOverrides.has(original)) {
+                    const info = nativeFunctionOverrides.get(original);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // Handle proxies
+            if (proxyTargetMap.has(this)) {
+                const { target, name } = proxyTargetMap.get(this);
+                if (name) {
+                    return makeNativeString(name);
+                }
+                if (target && nativeFunctionOverrides.has(target)) {
+                    const info = nativeFunctionOverrides.get(target);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // Check if this is an anonymous arrow function that should look native
+            // Arrow functions have no prototype property
+            const result = nativeCall.call(nativeToStringFunc, this);
+            
+            // Clean result to remove CDP/automation markers
+            if (typeof result === 'string') {
+                // Remove sourceURL comments
+                let cleaned = result
+                    .replace(/\\/\\/# sourceURL=[^\\n]*/g, '')
+                    .replace(/\\/\\/# sourceMappingURL=[^\\n]*/g, '')
+                    .replace(/__puppeteer_evaluation_script__/g, '')
+                    .replace(/__playwright_evaluation_script__/g, '')
+                    .replace(/pptr:[^\\n]*/g, '');
+                
+                return cleaned;
+            }
+            
+            return result;
+        };
+        
+        // Make patchedToString itself appear native
+        nativeFunctionOverrides.set(patchedToString, { name: 'toString', type: 'function' });
+        
+        // Replace Function.prototype.toString
+        Function.prototype.toString = patchedToString;
+        
+        // Patch toString.call and toString.apply to use our version
+        // CRITICAL: Bypass patchedToString completely - call nativeToStringFunc directly
+        // to prevent infinite recursion when scripts call toString.call.call() etc.
+        const patchedCall = function(thisArg, ...args) {
+            // Handle our registered overrides first
+            if (thisArg && nativeFunctionOverrides.has(thisArg)) {
+                const info = nativeFunctionOverrides.get(thisArg);
+                return makeNativeString(info.name, info.type);
+            }
+            
+            // Handle bound functions
+            if (thisArg && boundFunctionMap.has(thisArg)) {
+                const original = boundFunctionMap.get(thisArg);
+                if (nativeFunctionOverrides.has(original)) {
+                    const info = nativeFunctionOverrides.get(original);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // Handle proxies
+            if (thisArg && proxyTargetMap.has(thisArg)) {
+                const { target, name } = proxyTargetMap.get(thisArg);
+                if (name) return makeNativeString(name);
+                if (target && nativeFunctionOverrides.has(target)) {
+                    const info = nativeFunctionOverrides.get(target);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // CRITICAL: Call native toString directly to avoid any recursion
+            // Never go through patchedToString from here
+            return nativeCall.call(nativeToStringFunc, thisArg);
+        };
+        
+        const patchedApply = function(thisArg, argsArray) {
+            // Handle our registered overrides first
+            if (thisArg && nativeFunctionOverrides.has(thisArg)) {
+                const info = nativeFunctionOverrides.get(thisArg);
+                return makeNativeString(info.name, info.type);
+            }
+            
+            // Handle bound functions
+            if (thisArg && boundFunctionMap.has(thisArg)) {
+                const original = boundFunctionMap.get(thisArg);
+                if (nativeFunctionOverrides.has(original)) {
+                    const info = nativeFunctionOverrides.get(original);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // Handle proxies
+            if (thisArg && proxyTargetMap.has(thisArg)) {
+                const { target, name } = proxyTargetMap.get(thisArg);
+                if (name) return makeNativeString(name);
+                if (target && nativeFunctionOverrides.has(target)) {
+                    const info = nativeFunctionOverrides.get(target);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // CRITICAL: Call native toString directly to avoid any recursion
+            return nativeCall.call(nativeToStringFunc, thisArg);
+        };
+        
+        // Register call/apply as native
+        nativeFunctionOverrides.set(patchedCall, { name: 'call', type: 'function' });
+        nativeFunctionOverrides.set(patchedApply, { name: 'apply', type: 'function' });
+        
+        // Make toString.toString return the native string
+        Object.defineProperty(Function.prototype.toString, 'toString', {
+            value: patchedToString,
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+        
+        // Patch call and apply on our toString
+        Object.defineProperty(Function.prototype.toString, 'call', {
+            value: patchedCall,
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+        
+        Object.defineProperty(Function.prototype.toString, 'apply', {
+            value: patchedApply,
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+        
+        // Also protect against Function.prototype.toString.bind()
+        const originalBind = Function.prototype.toString.bind;
+        Object.defineProperty(Function.prototype.toString, 'bind', {
+            value: function(...args) {
+                const bound = nativeBind.apply(patchedToString, args);
+                nativeFunctionOverrides.set(bound, { name: 'toString', type: 'function' });
+                boundFunctionMap.set(bound, patchedToString);
+                return bound;
+            },
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+    };
+    
+    /**
+     * Check if a property can be redefined on an object
+     */
+    const canRedefineProperty = (obj, prop) => {
+        try {
+            const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+            // Property doesn't exist or is configurable
+            return !descriptor || descriptor.configurable !== false;
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    /**
+     * Safely override a property with guards
+     * Returns true if successful, false otherwise
+     */
+    const overridePropertyWithGuard = (obj, prop, descriptor) => {
+        if (!canRedefineProperty(obj, prop)) {
+            return false;
+        }
+        try {
+            Object.defineProperty(obj, prop, descriptor);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    /**
+     * Override a getter property and make the getter appear native
+     */
+    const overrideGetterWithNative = (obj, prop, getter, name = '') => {
+        // Register the getter to appear native
+        registerNativeFunction(getter, name || \`get \${prop}\`);
+        
+        return overridePropertyWithGuard(obj, prop, {
+            get: getter,
+            configurable: true,
+            enumerable: true
+        });
+    };
+    
+    /**
+     * Create a proxy handler that makes all accessed functions appear native
+     */
+    const createNativeProxyHandler = (targetName = '') => {
+        return {
+            get(target, property, receiver) {
+                const value = Reflect.get(target, property, receiver);
+                
+                // Bind functions to target and register as native
+                if (typeof value === 'function') {
+                    const bound = value.bind(target);
+                    registerNativeFunction(bound, value.name || property);
+                    return bound;
+                }
+                
+                return value;
+            },
+            
+            // Make the proxy's toString appear native
+            apply(target, thisArg, args) {
+                return Reflect.apply(target, thisArg, args);
+            }
+        };
+    };
+    
+    /**
+     * Cache original property value before overriding
+     * This prevents infinite recursion when getter calls itself
+     */
+    const cacheAndOverride = (obj, prop, transformFn) => {
+        // Cache the original value BEFORE any override
+        let originalValue;
+        try {
+            originalValue = obj[prop];
+        } catch (e) {
+            originalValue = undefined;
+        }
+        
+        // Create getter that uses cached value
+        const getter = function() {
+            return transformFn(originalValue);
+        };
+        
+        return overrideGetterWithNative(obj, prop, getter, \`get \${prop}\`);
+    };
+    
+    /**
+     * Log property override success
+     */
+    const logPropertyOverride = (objName, propName, value, success = true) => {
+        const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+        const ERROR_PREFIX = '[CDP-FP-ERROR]';
+        
+        if (success) {
+            console.log(DEBUG_PREFIX, \`✓ Overridden \${objName}.\${propName} to:\`, value);
+        } else {
+            console.warn(ERROR_PREFIX, \`⚠ Failed to override \${objName}.\${propName}\`);
+        }
+    };
+    
+    /**
+     * Verify that a property override was successful
+     */
+    const verifyOverride = (obj, objName, propName, expectedValue) => {
+        const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+        try {
+            const actualValue = obj[propName];
+            const matches = JSON.stringify(actualValue) === JSON.stringify(expectedValue);
+            
+            if (matches) {
+                console.log(DEBUG_PREFIX, \`✓ Verified \${objName}.\${propName}\`);
+            } else {
+                console.warn(DEBUG_PREFIX, \`⚠ Mismatch for \${objName}.\${propName}: expected\`, expectedValue, 'got', actualValue);
+            }
+            
+            return matches;
+        } catch (error) {
+            console.error(DEBUG_PREFIX, \`Error verifying \${objName}.\${propName}:\`, error);
+            return false;
+        }
+    };
+    
+    /**
+     * Handle frozen properties using Proxy fallback (puppeteer-stealth style)
+     */
+    const handleFrozenProperty = (obj, prop, value) => {
+        const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+        const ERROR_PREFIX = '[CDP-FP-ERROR]';
+        
+        try {
+            const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+            
+            // If property is frozen (configurable: false), use Proxy approach
+            if (descriptor && descriptor.configurable === false) {
+                console.warn(DEBUG_PREFIX, \`Property is frozen: \${prop}, attempting Proxy fallback\`);
+                
+                // Strategy 1: Try to redefine on the prototype
+                const proto = Object.getPrototypeOf(obj);
+                if (proto && canRedefineProperty(proto, prop)) {
+                    const getter = () => value;
+                    registerNativeFunction(getter, \`get \${prop}\`);
+                    
+                    Object.defineProperty(proto, prop, {
+                        get: getter,
+                        configurable: true,
+                        enumerable: true
+                    });
+                    
+                    console.log(DEBUG_PREFIX, \`✓ Overridden \${prop} via prototype\`);
+                    return true;
+                }
+                
+                // Strategy 2: Log that we cannot override
+                console.warn(ERROR_PREFIX, \`Cannot override frozen property: \${prop}\`);
+                return false;
+            }
+            
+            // Property is configurable, use normal override
+            return false; // Let caller handle normal override
+        } catch (error) {
+            console.error(ERROR_PREFIX, \`Error handling frozen property \${prop}:\`, error);
+            return false;
+        }
+    };
+    
+    /**
+     * Wrap a function with error boundary that logs errors
+     */
+    const withErrorBoundary = (fn, fnName = 'anonymous') => {
+        return function(...args) {
+            const ERROR_PREFIX = '[CDP-FP-ERROR]';
+            try {
+                return fn.apply(this, args);
+            } catch (error) {
+                console.error(ERROR_PREFIX, \`Error in \${fnName}:\`, error);
+                throw error; // Re-throw to make errors visible
+            }
+        };
+    };
+    
+    /**
+     * Enhanced override with frozen property handling and logging
+     */
+    const overridePropertySafe = (obj, objName, prop, value) => {
+        const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+        
+        // First, check if property is frozen
+        const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+        if (descriptor && descriptor.configurable === false) {
+            console.warn(DEBUG_PREFIX, \`⚠ Property \${objName}.\${prop} is frozen\`);
+            
+            // Attempt frozen property handling
+            const handled = handleFrozenProperty(obj, prop, value);
+            if (handled) {
+                logPropertyOverride(objName, prop, value, true);
+                return true;
+            }
+            
+            logPropertyOverride(objName, prop, value, false);
+            return false;
+        }
+        
+        // Property is configurable, override normally
+        const getter = () => value;
+        registerNativeFunction(getter, \`get \${prop}\`);
+        
+        const success = overridePropertyWithGuard(obj, prop, {
+            get: getter,
+            configurable: true,
+            enumerable: true
+        });
+        
+        logPropertyOverride(objName, prop, value, success);
+        return success;
+    };
+    
+    // Initialize toString patch immediately
+    patchToString();
+    
+    // Export utilities to global scope for use by other scripts
+    window.__stealthUtils__ = {
+        makeNativeString,
+        registerNativeFunction,
+        registerProxyTarget,
+        canRedefineProperty,
+        overridePropertyWithGuard,
+        overrideGetterWithNative,
+        createNativeProxyHandler,
+        cacheAndOverride,
+        nativeFunctionOverrides,
+        boundFunctionMap,
+        proxyTargetMap,
+        // New logging and safety utilities
+        logPropertyOverride,
+        verifyOverride,
+        handleFrozenProperty,
+        withErrorBoundary,
+        overridePropertySafe
+    };
+    
+    console.log('[CDP-FP-DEBUG] ✓ Stealth utilities initialized with enhanced toString masking');
+})();
+`;
+};
+//# sourceMappingURL=utils.js.map

package/dist/fingerprinting/fingerprint-overrides/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAW,EAAE;IACjD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAufV,CAAC;AACF,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"webgl-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,yBAAyB,sBAAuB,WAAW,KAAG,MAkK1E,CAAC"}
+{"version":3,"file":"webgl-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,yBAAyB,sBAAuB,WAAW,KAAG,MA2M1E,CAAC"}

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

@@ -20,44 +20,75 @@ export const createWebGLSpoofingScript = (fingerprintWebGL) => {
         const fingerprintConfig = ${JSON.stringify(fingerprintWebGL)};
         const selectedVendor = fingerprintConfig.vendorUnmasked || fingerprintConfig.vendor || 'Intel Inc.';
         const selectedRenderer = fingerprintConfig.rendererUnmasked || fingerprintConfig.renderer || 'Intel Iris OpenGL Engine';
+        console.log('[CDP-FP-DEBUG] WebGL using fingerprint data - Vendor:', selectedVendor, 'Renderer:', selectedRenderer.substring(0, 50));
         ` : `
         // Detect platform from navigator
-        const platform = navigator.platform || 'Linux x86_64';
+        const platform = navigator.platform || 'Win32';
         
-        // Platform-specific GPU configurations
+        // Platform-specific GPU configurations - 2024-2025 updated
+        // IMPORTANT: Windows GPU strings must follow the exact Chrome ANGLE format
         const gpuConfigs = {
             'Win32': {
-                vendors: ['NVIDIA Corporation', 'AMD', 'Intel Inc.'],
+                // Windows uses "Google Inc. (VENDOR)" format for vendor
+                vendors: [
+                    'Google Inc. (NVIDIA)',
+                    'Google Inc. (AMD)',
+                    'Google Inc. (Intel)'
+                ],
+                // Windows renderers use Direct3D11 format - authentic Chrome strings
                 renderers: [
                     'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)',
                     'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)',
                     'ANGLE (AMD, AMD Radeon RX 6600 Direct3D11 vs_5_0 ps_5_0, D3D11)',
                     'ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (Intel, Intel(R) Iris(R) Xe Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (AMD)', renderer: 'ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
                 ],
             },
             'MacIntel': {
-                vendors: ['Apple Inc.', 'Intel Inc.', 'AMD'],
+                vendors: ['Google Inc. (Apple)', 'Google Inc. (Intel)', 'Google Inc. (AMD)'],
                 renderers: [
                     'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)',
                     'ANGLE (Apple, Apple M2, OpenGL 4.1)',
                     'ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics OpenGL Engine, OpenGL 4.1)',
                     'ANGLE (AMD, AMD Radeon Pro 5500M OpenGL Engine, OpenGL 4.1)',
                 ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (Apple)', renderer: 'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)' },
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics OpenGL Engine, OpenGL 4.1)' },
+                ],
             },
             'Linux x86_64': {
-                vendors: ['Intel', 'NVIDIA Corporation', 'AMD'],
+                vendors: ['Google Inc. (Intel)', 'Google Inc. (NVIDIA)', 'Google Inc. (AMD)'],
                 renderers: [
                     'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630 (CFL GT2), OpenGL 4.6)',
                     'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti/PCIe/SSE2, OpenGL 4.6)',
                     'ANGLE (AMD, AMD Radeon RX 6600 (NAVY_FLOUNDER, DRM 3.42.0, 5.15.0-56-generic, LLVM 12.0.0), OpenGL 4.6)',
-                    'ANGLE (Intel, Mesa Intel(R) Xe Graphics (TGL GT2), OpenGL 4.6)',
+                ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630 (CFL GT2), OpenGL 4.6)' },
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti/PCIe/SSE2, OpenGL 4.6)' },
                 ],
             },
         };
         
-        const config = gpuConfigs[platform] || gpuConfigs['Linux x86_64'];
-        const selectedVendor = config.vendors[Math.floor(Math.random() * config.vendors.length)];
-        const selectedRenderer = config.renderers.find(r => r.includes(selectedVendor.split(' ')[0])) || config.renderers[0];
+        // Default to Windows for better anti-bot evasion (most common platform)
+        const config = gpuConfigs[platform] || gpuConfigs['Win32'];
+        
+        // Select a consistent vendor/renderer pair
+        const pairIndex = Math.floor(Math.random() * config.vendorPairs.length);
+        const selectedPair = config.vendorPairs[pairIndex];
+        const selectedVendor = selectedPair.vendor;
+        const selectedRenderer = selectedPair.renderer;
+        
+        console.log('[CDP-FP-DEBUG] WebGL using platform:', platform, '- Vendor:', selectedVendor, 'Renderer:', selectedRenderer.substring(0, 60) + '...');
         `}
         
         // Override getParameter
@@ -161,7 +192,17 @@ export const createWebGLSpoofingScript = (fingerprintWebGL) => {
         }
     };
     
-    spoofWebGL();
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting WebGL spoofing...');
+        spoofWebGL();
+        console.log(DEBUG_PREFIX, '✓ WebGL spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply WebGL spoofing:', e);
+        throw e; // Rethrow to make errors visible
+    }
 })();`;
 };
 //# sourceMappingURL=webgl-spoofing.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"webgl-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,gBAA8B,EAAU,EAAE;IAChF,iFAAiF;IACjF,MAAM,cAAc,GAAG,gBAAgB,IAAI,CAAC,gBAAgB,CAAC,cAAc,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;IAElH,OAAO;;;;;;;;;;UAUD,cAAc,CAAC,CAAC,CAAC;;oCAES,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC;;;SAG3D,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAsCH;;;;;;;;;;;;;;yBAcgB,cAAc,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,UAAU;;;yBAGxF,cAAc,IAAI,gBAAgB,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2CjH,CAAC,cAAc,CAAC,CAAC,CAAC;;;;;;;;;SASnB,CAAC,CAAC,CAAC;;SAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiCH,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"webgl-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,gBAA8B,EAAU,EAAE;IAChF,iFAAiF;IACjF,MAAM,cAAc,GAAG,gBAAgB,IAAI,CAAC,gBAAgB,CAAC,cAAc,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;IAElH,OAAO;;;;;;;;;;UAUD,cAAc,CAAC,CAAC,CAAC;;oCAES,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC;;;;SAI3D,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAoEH;;;;;;;;;;;;;;yBAcgB,cAAc,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,UAAU;;;yBAGxF,cAAc,IAAI,gBAAgB,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2CjH,CAAC,cAAc,CAAC,CAAC,CAAC;;;;;;;;;SASnB,CAAC,CAAC,CAAC;;SAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2CH,CAAC;AACP,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"webgpu-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgpu-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,0BAA0B,kCAA+B,MAuMrE,CAAC"}
+{"version":3,"file":"webgpu-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgpu-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,0BAA0B,kCAA+B,MAiNrE,CAAC"}

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

@@ -199,7 +199,17 @@ export const createWebGPUSpoofingScript = (experimentalMode = false) => {
         }
     };
     
-    spoofWebGPU();
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting WebGPU spoofing...');
+        spoofWebGPU();
+        console.log(DEBUG_PREFIX, '✓ WebGPU spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply WebGPU spoofing:', e);
+        throw e;
+    }
 })();`;
 };
 //# sourceMappingURL=webgpu-spoofing.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"webgpu-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgpu-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,gBAAgB,GAAG,KAAK,EAAU,EAAE;IAC3E,OAAO;;;;;;;UAOD,gBAAgB,CAAC,CAAC,CAAC;;;;;;;;;SASpB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqLR,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"webgpu-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgpu-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,gBAAgB,GAAG,KAAK,EAAU,EAAE;IAC3E,OAAO;;;;;;;UAOD,gBAAgB,CAAC,CAAC,CAAC;;;;;;;;;SASpB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+LR,CAAC;AACP,CAAC,CAAC"}

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

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