jumpy-lion 0.1.5 → 0.1.6-beta.1

package/dist/fingerprinting/fingerprint-overrides/stealth-script.js

@@ -33,15 +33,18 @@ export const createStealthScript = () => {
         });
     };
     
-    // Generate consistent session seed for stable values
-    const generateSessionSeed = () => {
-        const ua = navigator.userAgent || '';
-        const screen = window.screen;
-        const seed = ua.length + (screen.width || 0) + (screen.height || 0);
-        return seed;
-    };
-    
-    const sessionSeed = generateSessionSeed();
+    // Use centralized stable hash from __stealth store (set up by utils.ts preamble).
+    // Falls back to a UA+screen hash so the module works even if utils.ts somehow
+    // runs after this script (should not happen given injection order).
+    const _ss = typeof __stealth !== 'undefined' ? __stealth : {};
+    const sessionSeed = (_ss.stableHash
+        ? _ss.stableHash(0xCAFE9001)
+        : (() => {
+            const ua = navigator.userAgent || '';
+            const s = window.screen;
+            return ua.length + (s.width || 0) + (s.height || 0);
+        })()
+    );
     
     // Helper to safely define property with guards
     const safeDefineProperty = (obj, prop, descriptor) => {
@@ -84,11 +87,13 @@ export const createStealthScript = () => {
 
     // 3. WebDriver and Automation Flags Removal (2025)
     const removeAutomationFlags = () => {
-        // Override webdriver to false (NOT undefined).
-        // In real Chrome 89+, navigator.webdriver exists and is false.
-        // Setting to undefined would make 'webdriver' in navigator return false,
-        // which is itself a detection vector.
-        safeDefineGetter(navigator, 'webdriver', () => false, true);
+        // NOTE: navigator.webdriver is NOT overridden here.
+        // The Chromium C++ patch (Anti-Detect 0006) makes navigator.webdriver
+        // unconditionally return false at the prototype level. Adding a JS own
+        // property here would make navigator.hasOwnProperty('webdriver') === true
+        // and Object.getOwnPropertyDescriptor(navigator,'webdriver') return a
+        // descriptor, both of which are detectable tells that don't exist in real
+        // Chrome. The C++ patch is the correct and sufficient fix.
 
         // Remove automation indicators
         const automationProperties = [
@@ -113,6 +118,10 @@ export const createStealthScript = () => {
             } catch (e) {}
         });
 
+        // Ensure Error.stackTraceLimit is the V8 default (10).
+        // Some automation frameworks change this value; FingerprintJS checks it.
+        try { if (typeof Error.stackTraceLimit !== 'undefined') Error.stackTraceLimit = 10; } catch (e) {}
+
         // Ensure window.chrome exists (handled more fully by spoofChromeRuntime)
         // NOTE: Removed stack-trace-based chrome getter that created new Error()
         // on every access - expensive and broken since stack sanitization removes
@@ -205,6 +214,8 @@ export const createStealthScript = () => {
                 Object.defineProperty(arr, 'item', { value: (index) => arr[index] || null, writable: false, enumerable: false });
                 Object.defineProperty(arr, 'namedItem', { value: (name) => arr[name] || null, writable: false, enumerable: false });
                 Object.defineProperty(arr, 'refresh', { value: () => {}, writable: false, enumerable: false });
+                // Allow for...of iteration — checked by DataDome and FingerprintJS Pro
+                arr[Symbol.iterator] = function* () { for (let i = 0; i < fakePlugins.length; i++) yield arr[i]; };
                 return arr;
             };
             safeDefineGetter(navigator, 'plugins', pluginsGetter);
@@ -317,13 +328,11 @@ export const createStealthScript = () => {
                 getManifest: () => ({}),
                 // Real Chrome extension IDs are 32 lowercase alpha chars (a-p, base16 with a-p)
                 id: undefined,
-                connect: () => ({
-                    name: '',
-                    disconnect: () => {},
-                    onDisconnect: { addListener: () => {}, removeListener: () => {} },
-                    onMessage: { addListener: () => {}, removeListener: () => {} },
-                    postMessage: () => {}
-                }),
+                connect: function() {
+                    // Real Chrome throws this exact error when no extension is receiving
+                    // DataDome and PerimeterX specifically test this error message
+                    throw new Error('Could not establish connection. Receiving end does not exist.');
+                },
                 sendMessage: () => {},
                 getURL: (path) => '',
                 onConnect: { addListener: () => {}, removeListener: () => {} },
@@ -376,11 +385,17 @@ export const createStealthScript = () => {
         }
 
         // chrome.csi() - Chrome-specific, returns page load timing info
+        // Values are pre-computed from session seed so they're stable across calls.
+        // Real Chrome returns consistent timing per page load; Math.random() is detectable.
         if (window.chrome && !window.chrome.csi) {
+            const _csiRng = (_ss.createRNG ? _ss.createRNG(sessionSeed ^ 0x1001) : (() => { let x = sessionSeed ^ 0x1001; return () => { x = (x * 1664525 + 1013904223) >>> 0; return x / 4294967296; }; })());
+            const _csiLoadOffset = 500 + _csiRng() * 2000;
+            const _csiStartOffset = 1000 + _csiRng() * 3000;
             window.chrome.csi = function() {
+                const now = Date.now();
                 return {
-                    onloadT: Date.now() - (Math.random() * 2000 + 500),
-                    startE: Date.now() - (Math.random() * 3000 + 1000),
+                    onloadT: now - _csiLoadOffset,
+                    startE: now - _csiStartOffset,
                     pageT: performance.now(),
                     tran: 15, // Normal navigation
                 };
@@ -388,20 +403,30 @@ export const createStealthScript = () => {
         }
 
         // chrome.loadTimes() - Chrome-specific, returns load timing info
+        // Pre-computed offsets from session seed for stability across calls.
         if (window.chrome && !window.chrome.loadTimes) {
+            const _ltRng = (_ss.createRNG ? _ss.createRNG(sessionSeed ^ 0x1002) : (() => { let x = sessionSeed ^ 0x1002; return () => { x = (x * 1664525 + 1013904223) >>> 0; return x / 4294967296; }; })());
+            const _ltOffsets = {
+                commit: _ltRng() * 2,
+                finishDoc: _ltRng() * 1,
+                finishLoad: _ltRng() * 0.5,
+                firstPaint: _ltRng() * 1.5,
+                request: _ltRng() * 3,
+                startLoad: _ltRng() * 2.5,
+            };
             window.chrome.loadTimes = function() {
                 const now = Date.now() / 1000;
                 return {
-                    commitLoadTime: now - Math.random() * 2,
+                    commitLoadTime: now - _ltOffsets.commit,
                     connectionInfo: 'h2',
-                    finishDocumentLoadTime: now - Math.random(),
-                    finishLoadTime: now - Math.random() * 0.5,
+                    finishDocumentLoadTime: now - _ltOffsets.finishDoc,
+                    finishLoadTime: now - _ltOffsets.finishLoad,
                     firstPaintAfterLoadTime: 0,
-                    firstPaintTime: now - Math.random() * 1.5,
+                    firstPaintTime: now - _ltOffsets.firstPaint,
                     navigationType: 'Other',
                     npnNegotiatedProtocol: 'h2',
-                    requestTime: now - Math.random() * 3,
-                    startLoadTime: now - Math.random() * 2.5,
+                    requestTime: now - _ltOffsets.request,
+                    startLoadTime: now - _ltOffsets.startLoad,
                     wasAlternateProtocolAvailable: false,
                     wasFetchedViaSpdy: true,
                     wasNpnNegotiated: true,
@@ -622,8 +647,10 @@ export const createStealthScript = () => {
         const originalGetGamepads = navigator.getGamepads;
         if (originalGetGamepads) {
             navigator.getGamepads = function() {
-                // Return empty array like no gamepads connected
-                return [];
+                // Real Chrome returns GamepadList with 4 null slots when no gamepads
+                // connected — NOT an empty array.  [] vs [null,null,null,null] is a
+                // checked difference between headed Chrome and headless/Chromium.
+                return [null, null, null, null];
             };
         }
     };
@@ -922,10 +949,112 @@ export const createStealthScript = () => {
         if (_s5.utils) _s5.utils.registerNativeFunction(window.postMessage, 'postMessage');
     };
 
+    // 30. Document Visibility Spoofing
+    // hasFocus() and visibilityState were only patched inside datadome-bypass.ts,
+    // meaning Cloudflare / Akamai / PerimeterX saw raw headless values.  Move them
+    // here so all crawls benefit.
+    const spoofDocumentVisibility = () => {
+        try {
+            Object.defineProperty(document, 'hidden', { get: () => false, configurable: true });
+            Object.defineProperty(document, 'visibilityState', { get: () => 'visible', configurable: true });
+        } catch (e) {}
+
+        document.hasFocus = function() { return true; };
+        try {
+            Object.defineProperty(document.hasFocus, 'toString', {
+                value: () => 'function hasFocus() { [native code] }',
+                configurable: true
+            });
+        } catch (e) {}
+
+        // Suppress CDP-lifecycle-driven visibilitychange events that expose headless state
+        const origAEL = document.addEventListener.bind(document);
+        const _hiddenEvtHandler = (e) => {
+            if (e.type === 'visibilitychange') { e.stopImmediatePropagation(); }
+        };
+        origAEL('visibilitychange', _hiddenEvtHandler, true);
+    };
+
+    // 31. Encrypted Media Extensions (Widevine) Spoofing
+    // Vanilla Chromium rejects requestMediaKeySystemAccess('com.widevine.alpha')
+    // with NotSupportedError.  Real Chrome ships Widevine L3 and resolves.
+    // This is one of the most reliable Chrome-vs-Chromium signals (Cloudflare, FPjs, CreepJS).
+    const spoofEME = () => {
+        if (typeof navigator.requestMediaKeySystemAccess !== 'function') return;
+
+        const _origRMKSA = navigator.requestMediaKeySystemAccess.bind(navigator);
+
+        const _fakeRMKSA = function requestMediaKeySystemAccess(keySystem, configs) {
+            if (keySystem === 'com.widevine.alpha') {
+                const cfg = (Array.isArray(configs) && configs[0]) ? configs[0] : {};
+                const resolvedCfg = {
+                    label: cfg.label || '',
+                    initDataTypes: cfg.initDataTypes || ['cenc'],
+                    audioCapabilities: cfg.audioCapabilities || [
+                        { contentType: 'audio/mp4;codecs="mp4a.40.2"', robustness: '' }
+                    ],
+                    videoCapabilities: cfg.videoCapabilities || [
+                        { contentType: 'video/mp4;codecs="avc1.42E01E"', robustness: '' }
+                    ],
+                    distinctiveIdentifier: 'not-allowed',
+                    persistentState: 'not-allowed',
+                    sessionTypes: ['temporary']
+                };
+
+                const fakeMKS = {
+                    setServerCertificate: () => Promise.resolve(true),
+                    createSession: function(sessionType) {
+                        const sess = {
+                            sessionId: '',
+                            expiration: NaN,
+                            closed: new Promise(() => {}),
+                            keyStatuses: new Map(),
+                            onkeystatuseschange: null,
+                            onmessage: null,
+                            generateRequest: () => Promise.reject(new DOMException('InvalidStateError', 'InvalidStateError')),
+                            load: () => Promise.resolve(false),
+                            update: () => Promise.reject(new DOMException('InvalidStateError', 'InvalidStateError')),
+                            close: () => Promise.resolve(),
+                            remove: () => Promise.reject(new DOMException('InvalidStateError', 'InvalidStateError')),
+                            addEventListener: () => {},
+                            removeEventListener: () => {},
+                            dispatchEvent: () => true
+                        };
+                        return sess;
+                    }
+                };
+
+                const fakeMKSA = {
+                    keySystem: 'com.widevine.alpha',
+                    getConfiguration: () => resolvedCfg,
+                    createMediaKeys: () => Promise.resolve(fakeMKS)
+                };
+
+                return Promise.resolve(fakeMKSA);
+            }
+            // All other key systems fall through to native
+            try { return _origRMKSA(keySystem, configs); }
+            catch (e) { return Promise.reject(e); }
+        };
+
+        // Override on both Navigator.prototype and the instance
+        try {
+            Object.defineProperty(Navigator.prototype, 'requestMediaKeySystemAccess', {
+                value: _fakeRMKSA, writable: true, configurable: true
+            });
+        } catch (e) {
+            try { navigator.requestMediaKeySystemAccess = _fakeRMKSA; } catch (e2) {}
+        }
+
+        // Register for native-code toString masking
+        const _s6 = typeof __stealth !== 'undefined' ? __stealth : {};
+        if (_s6.utils) _s6.utils.registerNativeFunction(_fakeRMKSA, 'requestMediaKeySystemAccess');
+    };
+
     // Initialize all protections
     const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
     const ERROR_PREFIX = '[CDP-FP-ERROR]';
-    
+
     console.log(DEBUG_PREFIX, 'Starting stealth protection injection...');
     
     const applyProtection = (name, fn) => {
@@ -972,7 +1101,10 @@ export const createStealthScript = () => {
         applyProtection('Worker Constructor Protection', protectWorkerConstructor);
         applyProtection('SharedWorker Protection', protectSharedWorkerConstructor);
         applyProtection('PostMessage Protection', protectPostMessage);
-        
+        // Chrome authenticity patches — make Chromium look like real Chrome
+        applyProtection('Document Visibility Spoofing', spoofDocumentVisibility);
+        applyProtection('EME/Widevine Spoofing', spoofEME);
+
         console.log(DEBUG_PREFIX, '✓ All stealth protections applied successfully');
     } catch (e) {
         console.error(ERROR_PREFIX, '✗ Failed to apply stealth protections:', e);

package/dist/fingerprinting/fingerprint-overrides/stealth-script.js.map

@@ -1 +1 @@
-{"version":3,"file":"stealth-script.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/stealth-script.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAW,EAAE;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAu8BL,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"stealth-script.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/stealth-script.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAW,EAAE;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2kCL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.d.ts.map

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

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.js

@@ -18,14 +18,16 @@ export const createStorageConsistencyScript = () => {
     const spoofStorageAPIs = () => {
         const platform = navigator.platform || 'Win32';
         
-        // Generate consistent seed for stable values
-        const generateSeed = () => {
-            const ua = navigator.userAgent || '';
-            const screen = window.screen;
-            return (ua.length * 17 + (screen.width || 0) * 31 + (screen.height || 0) * 13) % 1000000;
-        };
-        
-        const sessionSeed = generateSeed();
+        // Use centralized stable hash (set up by utils.ts before this module runs).
+        const _ss = typeof __stealth !== 'undefined' ? __stealth : {};
+        const sessionSeed = (_ss.stableHash
+            ? _ss.stableHash(0xCAFE9002)
+            : (() => {
+                const ua = navigator.userAgent || '';
+                const s = window.screen;
+                return (ua.length * 17 + (s.width || 0) * 31 + (s.height || 0) * 13) % 1000000;
+            })()
+        );
         
         // Seeded PRNG (mulberry32) for consistent values
         const createSeededRNG = (seed) => {

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.js.map

@@ -1 +1 @@
-{"version":3,"file":"storage-consistency.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/storage-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACvD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2UL,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"storage-consistency.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/storage-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACvD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6UL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/timing-consistency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timing-consistency.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/timing-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,6BAA6B,QAAO,MA2PhD,CAAC"}
+{"version":3,"file":"timing-consistency.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/timing-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,6BAA6B,QAAO,MA6PhD,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/timing-consistency.js

@@ -24,13 +24,15 @@ export const createTimingConsistencyScript = () => {
         const originalDateNow = Date.now;
         const originalPerformanceNow = performance.now.bind(performance);
         
-        // Generate session seed for consistent variations
-        const generateSeed = () => {
-            const ua = navigator.userAgent || '';
-            return ua.length * 17 + (screen.width || 0) * 31;
-        };
-        
-        const sessionSeed = generateSeed();
+        // Use centralized stable hash (set up by utils.ts before this module runs).
+        const _ss = typeof __stealth !== 'undefined' ? __stealth : {};
+        const sessionSeed = (_ss.stableHash
+            ? _ss.stableHash(0xCAFE9003)
+            : (() => {
+                const ua = navigator.userAgent || '';
+                return ua.length * 17 + (screen.width || 0) * 31;
+            })()
+        );
         
         // Seeded PRNG (mulberry32) for consistent values
         const seededRandom = (seed) => {

package/dist/fingerprinting/fingerprint-overrides/timing-consistency.js.map

@@ -1 +1 @@
-{"version":3,"file":"timing-consistency.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/timing-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAW,EAAE;IACtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyPL,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"timing-consistency.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/timing-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAW,EAAE;IACtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2PL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/ua-ch.js

@@ -132,24 +132,24 @@ export const createUAClientHintsSpoofingScript = (platform = 'Win32', generatedU
             getHighEntropyValues: {
                 value: function(hints) {
                     return new Promise((resolve) => {
-                        // Simulate slight async delay like real browser
-                        setTimeout(() => {
+                        // Real Chrome resolves getHighEntropyValues via IPC microtask, not a random setTimeout
+                        Promise.resolve().then(() => {
                             const result = {};
-                            
+
                             if (!hints || !Array.isArray(hints)) {
                                 resolve(result);
                                 return;
                             }
-                            
+
                             // Return requested hints
                             for (const hint of hints) {
                                 if (hint in highEntropyValues) {
                                     result[hint] = highEntropyValues[hint];
                                 }
                             }
-                            
+
                             resolve(result);
-                        }, 1 + Math.random() * 2);
+                        });
                     });
                 },
                 writable: false,

package/dist/fingerprinting/fingerprint-overrides/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAO,MAyf3C,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAO,MAoiB3C,CAAC"}

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

@@ -491,7 +491,50 @@ export const createStealthUtilsScript = () => {
     
     // Initialize toString patch immediately
     patchToString();
-    
+
+    // ============================================
+    // SHARED SEED UTILITIES
+    // Exposed via __stealth so all override modules
+    // use the same deterministic hash instead of
+    // duplicating _stableHash in every file.
+    // ============================================
+
+    /**
+     * Deterministic hash that incorporates __stealth.seedKey + UA + screen.
+     * Every override module should call _s.stableHash(uniqueSalt) for its seed.
+     */
+    const _stableHashFn = (salt) => {
+        const key = _s.seedKey || '';
+        const ua = (typeof navigator !== 'undefined' && navigator.userAgent) || '';
+        const sw = (typeof screen !== 'undefined' && screen.width) || 0;
+        const sh = (typeof screen !== 'undefined' && screen.height) || 0;
+        const cd = (typeof screen !== 'undefined' && screen.colorDepth) || 0;
+        let h = salt | 0;
+        for (let i = 0; i < key.length; i++) h = (h << 5) - h + key.charCodeAt(i) | 0;
+        for (let i = 0; i < ua.length; i++) h = (h << 5) - h + ua.charCodeAt(i) | 0;
+        h = (h << 5) - h + sw | 0;
+        h = (h << 5) - h + sh | 0;
+        h = (h << 5) - h + cd | 0;
+        return h >>> 0;
+    };
+
+    /**
+     * Seeded PRNG factory (mulberry32).
+     * Usage: const rng = _s.createRNG(seed); rng() -> [0, 1)
+     */
+    const _createRNGFn = (seed) => {
+        let s = seed | 0;
+        return () => {
+            s = s + 0x6D2B79F5 | 0;
+            let t = Math.imul(s ^ s >>> 15, 1 | s);
+            t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+            return ((t ^ t >>> 14) >>> 0) / 4294967296;
+        };
+    };
+
+    _s.stableHash = _stableHashFn;
+    _s.createRNG = _createRNGFn;
+
     // Export utilities via shared stealth store (not on window - avoids detection)
     _s.utils = {
         makeNativeString,

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkiBV,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,MA8N1E,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,MAwQ1E,CAAC"}

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

@@ -109,7 +109,12 @@ export const createWebGLSpoofingScript = (fingerprintWebGL) => {
         
         console.log('[CDP-FP-DEBUG] WebGL using platform:', platform, '- Vendor:', selectedVendor, 'Renderer:', selectedRenderer.substring(0, 60) + '...');
         `}
-        
+
+        // Store selected GPU info on __stealth for cross-API consistency (WebGPU reads this)
+        if (typeof __stealth !== 'undefined') {
+            __stealth.webglRenderer = selectedRenderer;
+        }
+
         // Override getParameter
         WebGLRenderingContext.prototype.getParameter = function(param) {
             // UNMASKED_VENDOR_WEBGL
@@ -154,6 +159,43 @@ export const createWebGLSpoofingScript = (fingerprintWebGL) => {
             };
         }
         
+        // Override getShaderPrecisionFormat to prevent GPU cross-referencing.
+        // Anti-bot scripts can compare precision values against the claimed GPU/platform.
+        // These values match the standard IEEE 754 precision formats reported by modern
+        // D3D11/Metal/Vulkan drivers — consistent across NVIDIA, AMD, and Intel GPUs.
+        const _shaderPrecision = {
+            35633: { // VERTEX_SHADER
+                36336: { rangeMin: 1, rangeMax: 1, precision: 8 },    // LOW_FLOAT
+                36337: { rangeMin: 14, rangeMax: 14, precision: 10 }, // MEDIUM_FLOAT
+                36338: { rangeMin: 127, rangeMax: 127, precision: 23 }, // HIGH_FLOAT
+                36339: { rangeMin: 8, rangeMax: 7, precision: 0 },    // LOW_INT
+                36340: { rangeMin: 15, rangeMax: 14, precision: 0 },  // MEDIUM_INT
+                36341: { rangeMin: 31, rangeMax: 30, precision: 0 },  // HIGH_INT
+            },
+            35632: { // FRAGMENT_SHADER
+                36336: { rangeMin: 1, rangeMax: 1, precision: 8 },
+                36337: { rangeMin: 14, rangeMax: 14, precision: 10 },
+                36338: { rangeMin: 127, rangeMax: 127, precision: 23 },
+                36339: { rangeMin: 8, rangeMax: 7, precision: 0 },
+                36340: { rangeMin: 15, rangeMax: 14, precision: 0 },
+                36341: { rangeMin: 31, rangeMax: 30, precision: 0 },
+            },
+        };
+        const _origGetShaderPrecisionFormat = WebGLRenderingContext.prototype.getShaderPrecisionFormat;
+        WebGLRenderingContext.prototype.getShaderPrecisionFormat = function(shaderType, precisionType) {
+            const shaderFmts = _shaderPrecision[shaderType];
+            const fmt = shaderFmts && shaderFmts[precisionType];
+            if (fmt) {
+                // Return a plain object that mirrors WebGLShaderPrecisionFormat fields.
+                // Anti-bot scripts read .rangeMin/.rangeMax/.precision — instanceof is not checked.
+                return { rangeMin: fmt.rangeMin, rangeMax: fmt.rangeMax, precision: fmt.precision };
+            }
+            return _origGetShaderPrecisionFormat.apply(this, arguments);
+        };
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+            WebGL2RenderingContext.prototype.getShaderPrecisionFormat = WebGLRenderingContext.prototype.getShaderPrecisionFormat;
+        }
+
         // Override getSupportedExtensions with platform-appropriate extensions
         const baseExtensions = [
             'ANGLE_instanced_arrays', 'EXT_blend_minmax', 'EXT_color_buffer_half_float',

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;;;;SAI3D,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAuFH;;;;;;;;;;;;;;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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAuFH;;;;;;;;;;;;;;;;;;;yBAmBgB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgFjH,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,MAkNrE,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,MA0NrE,CAAC"}

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

@@ -64,7 +64,15 @@ export const createWebGPUSpoofingScript = (experimentalMode = false) => {
                             return new Proxy(adapter, {
                                 get(adapterTarget, adapterProp) {
                                     if (adapterProp === 'name') {
-                                        // Return a common GPU name based on platform
+                                        // Derive GPU name from WebGL renderer for cross-API consistency.
+                                        // webgl-spoofing.ts stores the selected renderer on __stealth.webglRenderer.
+                                        const _wglR = typeof __stealth !== 'undefined' && __stealth.webglRenderer;
+                                        if (_wglR) {
+                                            // Extract from "ANGLE (NVIDIA, NVIDIA GeForce RTX 4060 Direct3D11 ...)"
+                                            const _m = _wglR.match(/ANGLE \\(\\w+, ([^,]+?)(?:\\s+Direct3D|\\s+OpenGL|,)/);
+                                            if (_m) return _m[1].trim();
+                                        }
+                                        // Fallback: seeded pick from list
                                         const gpuNames = [
                                             'NVIDIA GeForce RTX 4060',
                                             'NVIDIA GeForce RTX 3060',

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgMR,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwMR,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,MAiM7C,CAAC;AAEF,eAAO,MAAM,yBAAyB,QAAO,MAgC5C,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,MA4M7C,CAAC;AAEF,eAAO,MAAM,yBAAyB,QAAO,MAgC5C,CAAC"}

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

@@ -159,9 +159,20 @@ export const createWebRTCSpoofingScript = () => {
                 if (cachedDeviceList) return Promise.resolve(cachedDeviceList);
 
                 return originalEnumerateDevices.apply(this, arguments).then(devices => {
-                    // Replace device IDs with crypto-random ones, keep real device kinds/count
-                    // This preserves the natural device count from the actual browser
-                    // while preventing tracking via device IDs
+                    // If the platform returns no devices (headless/server/CI), inject
+                    // plausible fake devices so fingerprinters don't flag an empty list.
+                    // A real desktop Chrome always has at least audioinput + audiooutput.
+                    if (devices.length === 0) {
+                        devices = [
+                            { kind: 'audioinput',  label: '', deviceId: 'default', groupId: 'default' },
+                            { kind: 'audiooutput', label: '', deviceId: 'default', groupId: 'default' },
+                            { kind: 'audioinput',  label: '', deviceId: '',        groupId: '' },
+                            { kind: 'audiooutput', label: '', deviceId: '',        groupId: '' },
+                        ];
+                    }
+
+                    // Replace device IDs with deterministic session-keyed ones,
+                    // keeping the real device count so repeated calls are consistent.
                     const groupIds = {};
                     cachedDeviceList = devices.map((device, index) => {
                         const groupKey = device.kind.replace(/input|output/, '');

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

@@ -1 +1 @@
-{"version":3,"file":"webrtc-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webrtc-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAW,EAAE;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+LL,CAAC;AACP,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAW,EAAE;IAClD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8BL,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"webrtc-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webrtc-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAW,EAAE;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0ML,CAAC;AACP,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAW,EAAE;IAClD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8BL,CAAC;AACP,CAAC,CAAC"}