jumpy-lion 0.1.0 → 0.1.2

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA64BL,CAAC;AACP,CAAC,CAAC"}

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

@@ -0,0 +1,13 @@
+/**
+ * Storage Consistency Spoofing
+ * Handles storage-related fingerprinting for 2024-2025
+ *
+ * Features:
+ * - navigator.storage.estimate() with realistic quota values
+ * - StorageManager.persist() behavior spoofing
+ * - IndexedDB database name consistency
+ * - localStorage/sessionStorage quota reporting
+ * - CacheStorage.keys() consistent cache names
+ */
+export declare const createStorageConsistencyScript: () => string;
+//# sourceMappingURL=storage-consistency.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,346 @@
+/**
+ * Storage Consistency Spoofing
+ * Handles storage-related fingerprinting for 2024-2025
+ *
+ * Features:
+ * - navigator.storage.estimate() with realistic quota values
+ * - StorageManager.persist() behavior spoofing
+ * - IndexedDB database name consistency
+ * - localStorage/sessionStorage quota reporting
+ * - CacheStorage.keys() consistent cache names
+ */
+export const createStorageConsistencyScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Storage Consistency Spoofing for 2024-2025
+    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();
+        
+        // Seeded PRNG (mulberry32) for consistent values
+        const createSeededRNG = (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;
+            };
+        };
+        const _rng = createSeededRNG(sessionSeed);
+        const seededRandom = (seed, min = 0, max = 1) => {
+            const rng = createSeededRNG(seed);
+            return min + rng() * (max - min);
+        };
+
+        // 1. Override navigator.storage.estimate()
+        const spoofStorageEstimate = () => {
+            if (navigator.storage && navigator.storage.estimate) {
+                const originalEstimate = navigator.storage.estimate;
+                
+                navigator.storage.estimate = function() {
+                    // Realistic storage values for different platforms
+                    const storageConfigs = {
+                        'Win32': {
+                            quotaBase: 300 * 1024 * 1024 * 1024, // ~300GB typical Windows
+                            usageBase: 50 * 1024 * 1024, // ~50MB typical usage
+                            variance: 0.15
+                        },
+                        'MacIntel': {
+                            quotaBase: 250 * 1024 * 1024 * 1024, // ~250GB typical Mac
+                            usageBase: 45 * 1024 * 1024,
+                            variance: 0.12
+                        },
+                        'Linux x86_64': {
+                            quotaBase: 200 * 1024 * 1024 * 1024, // ~200GB typical Linux
+                            usageBase: 40 * 1024 * 1024,
+                            variance: 0.18
+                        }
+                    };
+                    
+                    const config = storageConfigs[platform] || storageConfigs['Win32'];
+                    
+                    // Calculate consistent but varied values
+                    const quotaVariance = seededRandom(sessionSeed, 1 - config.variance, 1 + config.variance);
+                    const usageVariance = seededRandom(sessionSeed + 1, 0.5, 2);
+                    
+                    const quota = Math.floor(config.quotaBase * quotaVariance);
+                    const usage = Math.floor(config.usageBase * usageVariance);
+                    
+                    return Promise.resolve({
+                        quota: quota,
+                        usage: usage,
+                        usageDetails: {
+                            indexedDB: Math.floor(usage * 0.6),
+                            caches: Math.floor(usage * 0.3),
+                            serviceWorkerRegistrations: Math.floor(usage * 0.1)
+                        }
+                    });
+                };
+            }
+        };
+
+        // 2. Override StorageManager.persist()
+        const spoofStoragePersist = () => {
+            if (navigator.storage && navigator.storage.persist) {
+                navigator.storage.persist = function() {
+                    // Most browsers return false unless explicitly granted
+                    return Promise.resolve(false);
+                };
+            }
+            
+            if (navigator.storage && navigator.storage.persisted) {
+                navigator.storage.persisted = function() {
+                    return Promise.resolve(false);
+                };
+            }
+        };
+
+        // 3. Protect IndexedDB from fingerprinting
+        const spoofIndexedDB = () => {
+            if (!window.indexedDB) return;
+            
+            const originalOpen = window.indexedDB.open;
+            const originalDatabases = window.indexedDB.databases;
+            
+            // Track opened databases for consistency
+            const openedDatabases = new Set();
+            
+            window.indexedDB.open = function(name, version) {
+                openedDatabases.add(name);
+                return originalOpen.call(this, name, version);
+            };
+            
+            // Override databases() to hide fingerprinting attempts
+            if (originalDatabases) {
+                window.indexedDB.databases = function() {
+                    // Return only databases that were opened in this session
+                    return originalDatabases.call(this).then(databases => {
+                        // Filter to only known databases or return empty for privacy
+                        return databases.filter(db => 
+                            openedDatabases.has(db.name) || 
+                            // Allow common legitimate databases
+                            db.name.startsWith('firebaseLocalStorage') ||
+                            db.name === 'localforage'
+                        );
+                    });
+                };
+            }
+        };
+
+        // 4. Override localStorage/sessionStorage quota reporting
+        const spoofStorageQuota = () => {
+            // Create consistent storage size reporting
+            const getStorageSize = (storage) => {
+                let totalSize = 0;
+                try {
+                    for (let i = 0; i < storage.length; i++) {
+                        const key = storage.key(i);
+                        if (key) {
+                            totalSize += key.length + (storage.getItem(key) || '').length;
+                        }
+                    }
+                } catch (e) {}
+                return totalSize;
+            };
+            
+            // Ensure storage appears normal
+            const originalLocalStorageLength = Object.getOwnPropertyDescriptor(Storage.prototype, 'length');
+            
+            if (originalLocalStorageLength) {
+                Object.defineProperty(Storage.prototype, 'length', {
+                    get() {
+                        // Return actual length but ensure it's reasonable
+                        const actualLength = originalLocalStorageLength.get.call(this);
+                        return actualLength;
+                    },
+                    configurable: true,
+                    enumerable: true
+                });
+            }
+        };
+
+        // 5. Override CacheStorage.keys()
+        const spoofCacheStorage = () => {
+            if ('caches' in window) {
+                const originalKeys = CacheStorage.prototype.keys;
+                const originalOpen = CacheStorage.prototype.open;
+                const originalHas = CacheStorage.prototype.has;
+                const originalDelete = CacheStorage.prototype.delete;
+                
+                // Track caches opened in this session
+                const sessionCaches = new Set();
+                
+                CacheStorage.prototype.open = function(cacheName) {
+                    sessionCaches.add(cacheName);
+                    return originalOpen.call(this, cacheName);
+                };
+                
+                CacheStorage.prototype.keys = function() {
+                    return originalKeys.call(this).then(keys => {
+                        // Filter to only return caches that are expected
+                        return keys.filter(key => 
+                            sessionCaches.has(key) ||
+                            // Allow common legitimate cache names
+                            key.includes('workbox') ||
+                            key.includes('runtime') ||
+                            key.includes('precache') ||
+                            key.includes('sw-') ||
+                            key.includes('v1') ||
+                            key.includes('v2')
+                        );
+                    });
+                };
+                
+                CacheStorage.prototype.has = function(cacheName) {
+                    // Be honest about caches that exist
+                    return originalHas.call(this, cacheName);
+                };
+            }
+        };
+
+        // 6. Protect FileSystem API
+        const spoofFileSystemAPI = () => {
+            // Protect requestFileSystem if available
+            if (window.requestFileSystem || window.webkitRequestFileSystem) {
+                const originalRequestFileSystem = window.requestFileSystem || window.webkitRequestFileSystem;
+                
+                window.requestFileSystem = window.webkitRequestFileSystem = function(type, size, successCallback, errorCallback) {
+                    // Allow the request but with controlled quota
+                    const maxSize = 50 * 1024 * 1024; // 50MB max
+                    const limitedSize = Math.min(size, maxSize);
+                    
+                    return originalRequestFileSystem.call(
+                        window,
+                        type,
+                        limitedSize,
+                        successCallback,
+                        errorCallback
+                    );
+                };
+            }
+            
+            // Protect StorageManager quota
+            if (navigator.storage && navigator.storage.estimate) {
+                // Already handled above
+            }
+        };
+
+        // 7. Cookie Store API protection
+        // NOTE: Removed aggressive cookie filtering that blocked cookies containing
+        // 'deviceId' or 'browser_id'. This broke legitimate site functionality
+        // (many sites use these cookie names for session tracking).
+        // Cookie-based fingerprinting is better handled at the network/proxy layer.
+        const spoofCookieStore = () => {
+            // No-op: cookie filtering removed to avoid breaking sites
+        };
+
+        // 8. Web SQL Database protection (deprecated but still detected)
+        const spoofWebSQL = () => {
+            if (window.openDatabase) {
+                const originalOpenDatabase = window.openDatabase;
+                const openedDatabases = new Set();
+                
+                window.openDatabase = function(name, version, displayName, estimatedSize) {
+                    openedDatabases.add(name);
+                    
+                    // Limit estimated size to prevent fingerprinting through quota
+                    const limitedSize = Math.min(estimatedSize || 0, 5 * 1024 * 1024);
+                    
+                    try {
+                        return originalOpenDatabase.call(
+                            window,
+                            name,
+                            version,
+                            displayName,
+                            limitedSize
+                        );
+                    } catch (e) {
+                        // Web SQL is deprecated, return gracefully
+                        throw e;
+                    }
+                };
+            }
+        };
+
+        // 9. Broadcast Channel API protection
+        const spoofBroadcastChannel = () => {
+            if (typeof BroadcastChannel !== 'undefined') {
+                const OriginalBroadcastChannel = BroadcastChannel;
+                const channels = new Map();
+                
+                window.BroadcastChannel = function(name) {
+                    const channel = new OriginalBroadcastChannel(name);
+                    
+                    // Track channel usage
+                    if (!channels.has(name)) {
+                        channels.set(name, []);
+                    }
+                    channels.get(name).push(channel);
+                    
+                    return channel;
+                };
+                
+                // Note: Don't assign to prototype - it may be frozen in modern Chrome
+            }
+        };
+
+        // 10. SharedWorker storage protection
+        const spoofSharedWorker = () => {
+            if (typeof SharedWorker !== 'undefined') {
+                const OriginalSharedWorker = SharedWorker;
+                const workers = new Set();
+                
+                window.SharedWorker = function(scriptURL, options) {
+                    const urlString = typeof scriptURL === 'string' ? scriptURL : scriptURL.toString();
+                    workers.add(urlString);
+                    
+                    return new OriginalSharedWorker(scriptURL, options);
+                };
+                
+                // Note: Don't assign to prototype - it may be frozen in modern Chrome
+            }
+        };
+
+        // Initialize all storage protections
+        try {
+            spoofStorageEstimate();
+            spoofStoragePersist();
+            spoofIndexedDB();
+            spoofStorageQuota();
+            spoofCacheStorage();
+            spoofFileSystemAPI();
+            spoofCookieStore();
+            spoofWebSQL();
+            spoofBroadcastChannel();
+            spoofSharedWorker();
+        } catch (e) {
+            console.error('[STORAGE-CONSISTENCY] Failed to apply storage consistency:', e);
+            throw e; // Rethrow to make errors visible
+        }
+    };
+
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting storage consistency...');
+        spoofStorageAPIs();
+        console.log(DEBUG_PREFIX, '✓ Storage consistency applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply storage consistency:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=storage-consistency.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,13 @@
+/**
+ * Timing Consistency Module
+ * Dedicated timing fingerprint protection for 2024-2025
+ *
+ * Features:
+ * - Consistent Date.now() and performance.now() relationship
+ * - PerformanceEntry timing value protection
+ * - performance.measureUserAgentSpecificMemory() handling
+ * - event.timeStamp consistency in dispatched events
+ * - requestAnimationFrame timing patterns
+ */
+export declare const createTimingConsistencyScript: () => string;
+//# sourceMappingURL=timing-consistency.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,264 @@
+/**
+ * Timing Consistency Module
+ * Dedicated timing fingerprint protection for 2024-2025
+ *
+ * Features:
+ * - Consistent Date.now() and performance.now() relationship
+ * - PerformanceEntry timing value protection
+ * - performance.measureUserAgentSpecificMemory() handling
+ * - event.timeStamp consistency in dispatched events
+ * - requestAnimationFrame timing patterns
+ */
+export const createTimingConsistencyScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Timing Consistency for 2024-2025
+    const setupTimingConsistency = () => {
+        // Base timestamps for consistency
+        const pageLoadTime = Date.now();
+        const performanceOrigin = performance.timeOrigin || pageLoadTime;
+        
+        // Store original methods
+        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();
+        
+        // Seeded PRNG (mulberry32) for consistent values
+        const seededRandom = (seed) => {
+            let s = seed | 0;
+            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;
+        };
+
+        // 1. Date.now() and performance.now() consistency
+        // NOTE: We intentionally do NOT override Date.now() or performance.now() here.
+        // Enforcing monotonic increase or adding jitter is itself detectable.
+        // The performance-spoofing module handles platform-specific timing characteristics.
+        const ensureDatePerformanceConsistency = () => {
+            // No-op: timing functions should behave naturally
+        };
+
+        // 2. Protect PerformanceEntry timing values
+        const protectPerformanceEntries = () => {
+            const originalGetEntries = performance.getEntries.bind(performance);
+            const originalGetEntriesByName = performance.getEntriesByName.bind(performance);
+            const originalGetEntriesByType = performance.getEntriesByType.bind(performance);
+            
+            // Add consistent variations to timing entries
+            const adjustEntry = (entry) => {
+                if (!entry) return entry;
+                
+                const timingProps = [
+                    'startTime', 'duration', 'fetchStart', 'domainLookupStart',
+                    'domainLookupEnd', 'connectStart', 'secureConnectionStart',
+                    'connectEnd', 'requestStart', 'responseStart', 'responseEnd',
+                    'workerStart', 'redirectStart', 'redirectEnd', 'processingStart',
+                    'processingEnd', 'loadEventStart', 'loadEventEnd',
+                    'unloadEventStart', 'unloadEventEnd'
+                ];
+                
+                const adjusted = {};
+                
+                for (const key of Object.keys(entry)) {
+                    if (timingProps.includes(key) && typeof entry[key] === 'number' && entry[key] > 0) {
+                        // Add consistent micro-variation
+                        const variation = seededRandom(sessionSeed + entry[key]) * 0.001;
+                        adjusted[key] = entry[key] + variation;
+                    } else {
+                        adjusted[key] = entry[key];
+                    }
+                }
+                
+                // Preserve prototype
+                Object.setPrototypeOf(adjusted, Object.getPrototypeOf(entry));
+                
+                return adjusted;
+            };
+            
+            performance.getEntries = function() {
+                return originalGetEntries().map(adjustEntry);
+            };
+            
+            performance.getEntriesByName = function(name, type) {
+                return originalGetEntriesByName(name, type).map(adjustEntry);
+            };
+            
+            performance.getEntriesByType = function(type) {
+                return originalGetEntriesByType(type).map(adjustEntry);
+            };
+        };
+
+        // 3. Handle performance.measureUserAgentSpecificMemory()
+        const protectMemoryMeasurement = () => {
+            if (performance.measureUserAgentSpecificMemory) {
+                const originalMeasure = performance.measureUserAgentSpecificMemory.bind(performance);
+                
+                performance.measureUserAgentSpecificMemory = function() {
+                    return originalMeasure().then(result => {
+                        // Normalize memory values to be less fingerprintable
+                        const normalizedBytes = Math.round(result.bytes / (1024 * 1024)) * 1024 * 1024;
+                        
+                        return {
+                            bytes: normalizedBytes + Math.floor(seededRandom(sessionSeed) * 1024 * 100),
+                            breakdown: (result.breakdown || []).map(item => ({
+                                ...item,
+                                bytes: Math.round(item.bytes / 1024) * 1024
+                            }))
+                        };
+                    }).catch(() => {
+                        // Return a reasonable default if measurement fails
+                        return {
+                            bytes: 30 * 1024 * 1024 + Math.floor(seededRandom(sessionSeed) * 5 * 1024 * 1024),
+                            breakdown: []
+                        };
+                    });
+                };
+            }
+        };
+
+        // 4. Event timeStamp consistency
+        // NOTE: Overriding Event/CustomEvent constructors to force timeStamp breaks
+        // trusted event detection (real events have their own timestamps set by the browser).
+        // Removed: the original override replaced timeStamp on ALL events which broke timing analysis.
+        const ensureEventTimestampConsistency = () => {
+            // No-op: event timestamps should come from the browser naturally
+        };
+
+        // 5. requestAnimationFrame timing patterns
+        // NOTE: Removed RAF timing modification - adding jitter to rAF timestamps
+        // is detectable and breaks animation-dependent code.
+        const normalizeRAFTiming = () => {
+            // No-op: rAF timestamps should come from the browser naturally
+        };
+
+        // 6. setTimeout/setInterval timing normalization
+        // NOTE: Removed timer jitter - modifying setTimeout/setInterval delays breaks
+        // timing-dependent code (debouncing, polling, animations) and the consistent
+        // seeded offset is itself a fingerprint.
+        const normalizeTimerTiming = () => {
+            // No-op: timers should behave naturally
+        };
+
+        // 7. Performance Observer timing protection
+        // NOTE: Removed - this duplicates the PerformanceObserver override in
+        // performance-spoofing.ts. Double-wrapping creates detectable proxy chains.
+        const protectPerformanceObserver = () => {
+            // No-op: handled by performance-spoofing module
+        };
+
+        // 8. Idle callback timing
+        // NOTE: Removed - this duplicates the requestIdleCallback override in
+        // performance-spoofing.ts. Double-wrapping is detectable.
+        const normalizeIdleCallback = () => {
+            // No-op: handled by performance-spoofing module
+        };
+
+        // 9. Navigation Timing API protection
+        const protectNavigationTiming = () => {
+            if (performance.timing) {
+                const originalTiming = performance.timing;
+                const timingProxy = {};
+                
+                const timingProps = [
+                    'navigationStart', 'unloadEventStart', 'unloadEventEnd',
+                    'redirectStart', 'redirectEnd', 'fetchStart',
+                    'domainLookupStart', 'domainLookupEnd', 'connectStart',
+                    'connectEnd', 'secureConnectionStart', 'requestStart',
+                    'responseStart', 'responseEnd', 'domLoading',
+                    'domInteractive', 'domContentLoadedEventStart',
+                    'domContentLoadedEventEnd', 'domComplete',
+                    'loadEventStart', 'loadEventEnd'
+                ];
+                
+                timingProps.forEach(prop => {
+                    const originalValue = originalTiming[prop];
+                    if (typeof originalValue === 'number' && originalValue > 0) {
+                        Object.defineProperty(timingProxy, prop, {
+                            get: () => originalValue + seededRandom(sessionSeed + originalValue) * 0.5,
+                            configurable: true,
+                            enumerable: true
+                        });
+                    } else {
+                        Object.defineProperty(timingProxy, prop, {
+                            get: () => originalValue,
+                            configurable: true,
+                            enumerable: true
+                        });
+                    }
+                });
+                
+                // Add toJSON method
+                timingProxy.toJSON = function() {
+                    const json = {};
+                    timingProps.forEach(prop => {
+                        json[prop] = this[prop];
+                    });
+                    return json;
+                };
+                
+                Object.setPrototypeOf(timingProxy, PerformanceTiming.prototype);
+                
+                Object.defineProperty(performance, 'timing', {
+                    get: () => timingProxy,
+                    configurable: true
+                });
+            }
+        };
+
+        // 10. High Resolution Time protection
+        const protectHighResolutionTime = () => {
+            // Ensure performance.timeOrigin is consistent
+            if (performance.timeOrigin) {
+                const originalOrigin = performance.timeOrigin;
+                const adjustedOrigin = originalOrigin + seededRandom(sessionSeed) * 0.1;
+                
+                Object.defineProperty(performance, 'timeOrigin', {
+                    get: () => adjustedOrigin,
+                    configurable: true
+                });
+            }
+        };
+
+        // Initialize all timing protections
+        try {
+            ensureDatePerformanceConsistency();
+            protectPerformanceEntries();
+            protectMemoryMeasurement();
+            ensureEventTimestampConsistency();
+            normalizeRAFTiming();
+            normalizeTimerTiming();
+            protectPerformanceObserver();
+            normalizeIdleCallback();
+            protectNavigationTiming();
+            protectHighResolutionTime();
+        } catch (e) {
+            console.error('[TIMING-CONSISTENCY] Failed to apply timing consistency:', e);
+            throw e; // Rethrow to make errors visible
+        }
+    };
+
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting timing consistency...');
+        setupTimingConsistency();
+        console.log(DEBUG_PREFIX, '✓ Timing consistency applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply timing consistency:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=timing-consistency.js.map

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

@@ -0,0 +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"}