jumpy-lion 0.0.41 → 0.0.43

package/dist/fingerprinting/fingerprint-injector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fingerprint-injector.d.ts","sourceRoot":"","sources":["../../src/fingerprinting/fingerprint-injector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAGH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAI3E,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC;AAoBtC,UAAU,QAAQ;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;CACnB;AAED,UAAU,aAAa;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;IAEjD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,2BAA2B,CAAC,EAAE,OAAO,CAAC;IAEtC,sBAAsB,CAAC,EAAE,OAAO,CAAC;CACpC;AAMD,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,IAAI,CAAU;gBAEV,IAAI,EAAE,OAAO;IAKzB;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,IAAI,aAAa;WAwBtC,iBAAiB,CAC1B,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,6BAA6B,EAC1C,OAAO,CAAC,EAAE,aAAa,GACxB,OAAO,CAAC,IAAI,CAAC;YAKF,WAAW;YAaX,mBAAmB;YAInB,iBAAiB;YAcjB,mBAAmB;YAMnB,wBAAwB;IAKtC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAqCjB,YAAY,CACrB,6BAA6B,EAAE,6BAA6B,EAC5D,OAAO,CAAC,EAAE,aAAa,GACxB,OAAO,CAAC,IAAI,CAAC;CAyHnB"}
+{"version":3,"file":"fingerprint-injector.d.ts","sourceRoot":"","sources":["../../src/fingerprinting/fingerprint-injector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAGH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAG3E,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC;AAkCtC,UAAU,QAAQ;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,UAAU,mBAAmB;IACzB,2FAA2F;IAC3F,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,UAAU,aAAa;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iDAAiD;IACjD,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;IAEjD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,2BAA2B,CAAC,EAAE,OAAO,CAAC;IAEtC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,sEAAsE;IACtE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,sEAAsE;IACtE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,qEAAqE;IACrE,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,mBAAmB,CAAC;CACtC;AAMD,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,IAAI,CAAU;gBAEV,IAAI,EAAE,OAAO;IAIzB;;;;;;;OAOG;IACH,MAAM,CAAC,2BAA2B,IAAI,aAAa;IAmCnD;;;OAGG;IACH,MAAM,CAAC,mBAAmB,IAAI,aAAa;WAyB9B,iBAAiB,CAC1B,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,6BAA6B,EAC1C,OAAO,CAAC,EAAE,aAAa,GACxB,OAAO,CAAC,IAAI,CAAC;YAKF,WAAW;YAyDX,mBAAmB;YAInB,iBAAiB;YAcjB,mBAAmB;YAMnB,wBAAwB;IAKtC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAwHzB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA2CjB,YAAY,CACrB,6BAA6B,EAAE,6BAA6B,EAC5D,OAAO,CAAC,EAAE,aAAa,GACxB,OAAO,CAAC,IAAI,CAAC;CA4UnB"}

package/dist/fingerprinting/fingerprint-injector.js

@@ -61,46 +61,59 @@
  * ```
  */
 import { log } from 'crawlee';
-import { FingerprintInjector } from 'fingerprint-injector';
 import { gotScraping } from 'got-scraping';
-import { createStealthScript, createWebGLSpoofingScript, createAudioFingerprintSpoofingScript, createAdvancedCanvasProtectionScript, createClientRectSpoofingScript, createWebRTCSpoofingScript, createWebGPUSpoofingScript, createPlatformConsistencyScript, setupMouseMovementHumanization, setupRuntimeEnableBypass, createFontSpoofingScript, createPerformanceSpoofingScript, createLocaleSpoofingScript, createUAClientHintsSpoofingScript, } from './fingerprint-overrides/index.js';
+import { createCustomFingerprintInjection } from './custom-fingerprint-injector.js';
+import { createStealthScript, createWebGLSpoofingScript, createAudioFingerprintSpoofingScript, createAdvancedCanvasProtectionScript, createClientRectSpoofingScript, createWebRTCSpoofingScript, createWebGPUSpoofingScript, createPlatformConsistencyScript, setupMouseMovementHumanization, createRuntimeEnableBypassScript, createFontSpoofingScript, createPerformanceSpoofingScript, createLocaleSpoofingScript, createUAClientHintsSpoofingScript, 
+// Stealth utilities (must be injected first)
+createStealthUtilsScript, 
+// Prototype integrity (must be injected early)
+createPrototypeIntegrityScript, 
+// 2024-2025 New modules
+createCDPDetectionBypassScript, createStorageConsistencyScript, createTimingConsistencyScript, createKeyboardHumanizationScript, createScrollHumanizationScript, createDataDomeBypassScript, setupKeyboardHumanization, setupScrollHumanization, } from './fingerprint-overrides/index.js';
 export class CdpFingerprintInjector {
     constructor(page) {
-        Object.defineProperty(this, "injector", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "page", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.injector = new FingerprintInjector();
         this.page = page;
     }
     /**
      * Get recommended settings for Apify platform
      * These settings are optimized for running headful Chrome on Apify (Linux)
-     * but spoofed to appear as Windows for better anti-bot evasion
+     * but spoofed to appear as Windows for better anti-bot evasion.
+     *
+     * Note: Humanization is disabled by default for performance.
+     * Use getDataDomeSettings() or enable humanization manually for anti-bot sites.
      */
     static getApifyRecommendedSettings() {
         return {
+            debug: true, // Enable debug logging by default
             enableAdvancedStealth: true,
             bypassRuntimeEnable: true,
             platform: 'Win32', // Spoof as Windows instead of Linux for better evasion
             spoofWebGL: true,
             spoofAudioContext: true,
             spoofClientRects: true,
-            humanizeInteractions: true,
             detectTimezone: true, // Auto-detect timezone from proxy
             // New advanced spoofing options for 2025
             spoofFonts: true,
             spoofPerformance: true,
             spoofLocale: true,
             useFingerprintDefaults: true, // Use fingerprint-generator Windows values
+            // 2024-2025 DataDome bypass options
+            bypassCDPDetection: true,
+            spoofStorage: true,
+            spoofTiming: true,
+            enableDataDomeBypass: false, // Enable only when needed
+            // Humanization disabled by default for performance
+            humanization: {
+                mouse: false,
+                keyboard: false,
+                scroll: false,
+            },
             viewport: {
                 width: 1920,
                 height: 1080,
@@ -109,20 +122,85 @@ export class CdpFingerprintInjector {
             },
         };
     }
+    /**
+     * Get settings specifically optimized for DataDome-protected sites.
+     * Enables all humanization features for maximum anti-bot evasion.
+     */
+    static getDataDomeSettings() {
+        return {
+            ...this.getApifyRecommendedSettings(),
+            debug: true, // Enable debug logging by default
+            // DataDome-specific optimizations
+            enableDataDomeBypass: true,
+            bypassCDPDetection: true,
+            spoofStorage: true,
+            spoofTiming: true,
+            // Enable all humanization for DataDome bypass
+            humanization: {
+                mouse: true,
+                keyboard: true,
+                scroll: true,
+            },
+            // Ensure all fingerprint attributes are consistent
+            spoofWebGL: true,
+            spoofAudioContext: true,
+            spoofClientRects: true,
+            spoofFonts: true,
+            spoofPerformance: true,
+            spoofLocale: true,
+        };
+    }
     static async injectFingerprint(page, fingerprint, options) {
         const handler = new CdpFingerprintInjector(page);
         return handler.attachToPage(fingerprint, options);
     }
-    async setViewport(viewport) {
-        const defaultViewport = {
+    async setViewport(viewport, fingerprint) {
+        // IMPORTANT: In headful mode, don't override viewport - it creates weird compressed layouts
+        // The browser window already has natural dimensions from the OS
+        // Only override viewport in headless mode where window size needs to be set
+        // Check if we're in headless mode
+        // In headful mode, we skip viewport override to avoid layout issues
+        const isHeadless = process.env.APIFY_HEADLESS === '1' ||
+            process.env.CRAWLEE_HEADLESS === '1' ||
+            process.env.HEADLESS === 'true';
+        if (!isHeadless) {
+            log.info('⚠️ Headful mode detected - SKIPPING viewport override to preserve natural window behavior');
+            log.info('✅ Browser will use OS window dimensions - scrolling will work naturally');
+            return; // Skip viewport override in headful mode
+        }
+        // Only apply viewport override in headless mode
+        log.info('Headless mode detected - applying viewport override');
+        let defaultViewport = {
             width: 1920,
             height: 1080,
             deviceScaleFactor: 1,
             mobile: false,
         };
+        // Extract from fingerprint if available
+        if (fingerprint?.screen) {
+            // IMPORTANT: Set viewport height SMALLER than screen height to allow scrolling
+            // Reserve 150px for browser chrome, URL bar, and overflow space
+            const screenHeight = fingerprint.screen.height || 1080;
+            const viewportHeight = screenHeight - 150;
+            defaultViewport = {
+                width: fingerprint.screen.width || 1920,
+                height: viewportHeight,
+                deviceScaleFactor: fingerprint.screen.devicePixelRatio || 1,
+                mobile: false,
+            };
+            log.info('Viewport configured for scrolling', {
+                screenHeight,
+                viewportHeight,
+                reservedSpace: 150,
+                width: defaultViewport.width,
+                deviceScaleFactor: defaultViewport.deviceScaleFactor,
+            });
+        }
         const finalViewport = Object.assign(defaultViewport, viewport);
-        // CDP call to override device metrics
+        log.info('Final viewport settings (headless mode)', finalViewport);
+        // CDP call to override device metrics (headless mode only)
         await this.page.client.Emulation.setDeviceMetricsOverride(finalViewport);
+        log.info('setDeviceMetricsOverride completed (headless mode)');
     }
     async setExtraHTTPHeaders(headers) {
         await this.page.client.Network.setExtraHTTPHeaders({ headers });
@@ -150,18 +228,140 @@ export class CdpFingerprintInjector {
         const stealthScript = createStealthScript();
         await this.page.client.Page.addScriptToEvaluateOnNewDocument({ source: stealthScript });
     }
+    /**
+     * Create a debug script that logs fingerprint override status to the console
+     */
+    createDebugScript(options) {
+        return `
+(() => {
+    // CDP Fingerprint Override Debug Logs
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    
+    console.log(DEBUG_PREFIX, '=== Fingerprint Override Status ===');
+    console.log(DEBUG_PREFIX, 'Timestamp:', new Date().toISOString());
+    
+    // Check navigator properties
+    console.log(DEBUG_PREFIX, 'Navigator Checks:');
+    console.log(DEBUG_PREFIX, '  - platform:', navigator.platform);
+    console.log(DEBUG_PREFIX, '  - userAgent:', navigator.userAgent.substring(0, 80) + '...');
+    console.log(DEBUG_PREFIX, '  - webdriver:', navigator.webdriver);
+    console.log(DEBUG_PREFIX, '  - hardwareConcurrency:', navigator.hardwareConcurrency);
+    console.log(DEBUG_PREFIX, '  - deviceMemory:', navigator.deviceMemory);
+    console.log(DEBUG_PREFIX, '  - language:', navigator.language);
+    console.log(DEBUG_PREFIX, '  - languages:', navigator.languages);
+    console.log(DEBUG_PREFIX, '  - maxTouchPoints:', navigator.maxTouchPoints);
+    console.log(DEBUG_PREFIX, '  - pdfViewerEnabled:', navigator.pdfViewerEnabled);
+    console.log(DEBUG_PREFIX, '  - plugins.length:', navigator.plugins?.length);
+    
+    // Check screen properties
+    console.log(DEBUG_PREFIX, 'Screen Checks:');
+    console.log(DEBUG_PREFIX, '  - colorDepth:', screen.colorDepth);
+    console.log(DEBUG_PREFIX, '  - pixelDepth:', screen.pixelDepth);
+    console.log(DEBUG_PREFIX, '  - availWidth:', screen.availWidth);
+    console.log(DEBUG_PREFIX, '  - availHeight:', screen.availHeight);
+    console.log(DEBUG_PREFIX, '  - devicePixelRatio:', window.devicePixelRatio);
+    
+    // Check window properties
+    console.log(DEBUG_PREFIX, 'Window Checks:');
+    console.log(DEBUG_PREFIX, '  - outerWidth:', window.outerWidth);
+    console.log(DEBUG_PREFIX, '  - outerHeight:', window.outerHeight);
+    console.log(DEBUG_PREFIX, '  - screenX:', window.screenX);
+    console.log(DEBUG_PREFIX, '  - screenY:', window.screenY);
+    
+    // Check chrome object
+    console.log(DEBUG_PREFIX, 'Chrome Object:');
+    console.log(DEBUG_PREFIX, '  - chrome exists:', typeof window.chrome !== 'undefined');
+    console.log(DEBUG_PREFIX, '  - chrome.runtime exists:', typeof window.chrome?.runtime !== 'undefined');
+    
+    // Check WebGL
+    try {
+        const canvas = document.createElement('canvas');
+        const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+        if (gl) {
+            const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+            if (debugInfo) {
+                console.log(DEBUG_PREFIX, 'WebGL Checks:');
+                console.log(DEBUG_PREFIX, '  - vendor:', gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL));
+                console.log(DEBUG_PREFIX, '  - renderer:', gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL));
+            } else {
+                console.log(DEBUG_PREFIX, 'WebGL debug extension not available');
+            }
+        } else {
+            console.log(DEBUG_PREFIX, 'WebGL context not available');
+        }
+    } catch (e) {
+        console.log(DEBUG_PREFIX, 'WebGL check failed:', e.message);
+    }
+    
+    // Check automation markers
+    console.log(DEBUG_PREFIX, 'Automation Marker Checks:');
+    console.log(DEBUG_PREFIX, '  - $cdc_ properties:', Object.keys(window).filter(k => k.startsWith('$cdc_') || k.startsWith('cdc_')).length === 0 ? 'CLEAN' : 'DETECTED');
+    console.log(DEBUG_PREFIX, '  - webdriver properties:', Object.keys(window).filter(k => k.toLowerCase().includes('webdriver')).length === 0 ? 'CLEAN' : 'DETECTED');
+    
+    // Check permissions API
+    if (navigator.permissions) {
+        navigator.permissions.query({ name: 'notifications' }).then(result => {
+            console.log(DEBUG_PREFIX, 'Permissions:');
+            console.log(DEBUG_PREFIX, '  - notifications:', result.state);
+        }).catch(e => {
+            console.log(DEBUG_PREFIX, 'Permissions check failed:', e.message);
+        });
+    }
+    
+    // Check storage estimate
+    if (navigator.storage && navigator.storage.estimate) {
+        navigator.storage.estimate().then(estimate => {
+            console.log(DEBUG_PREFIX, 'Storage:');
+            console.log(DEBUG_PREFIX, '  - quota:', Math.round(estimate.quota / 1024 / 1024 / 1024) + ' GB');
+            console.log(DEBUG_PREFIX, '  - usage:', Math.round(estimate.usage / 1024) + ' KB');
+        }).catch(e => {
+            console.log(DEBUG_PREFIX, 'Storage check failed:', e.message);
+        });
+    }
+    
+    // Log applied options
+    console.log(DEBUG_PREFIX, 'Applied Options:');
+    console.log(DEBUG_PREFIX, '  - platform:', '${options.platform || "auto"}');
+    console.log(DEBUG_PREFIX, '  - enableAdvancedStealth:', ${options.enableAdvancedStealth !== false});
+    console.log(DEBUG_PREFIX, '  - bypassCDPDetection:', ${options.bypassCDPDetection !== false});
+    console.log(DEBUG_PREFIX, '  - spoofStorage:', ${options.spoofStorage !== false});
+    console.log(DEBUG_PREFIX, '  - spoofTiming:', ${options.spoofTiming !== false});
+    console.log(DEBUG_PREFIX, '  - enableDataDomeBypass:', ${options.enableDataDomeBypass || false});
+    console.log(DEBUG_PREFIX, '  - humanization.mouse:', ${options.humanization?.mouse || false});
+    console.log(DEBUG_PREFIX, '  - humanization.keyboard:', ${options.humanization?.keyboard || false});
+    console.log(DEBUG_PREFIX, '  - humanization.scroll:', ${options.humanization?.scroll || false});
+    
+    console.log(DEBUG_PREFIX, '=== End Fingerprint Override Status ===');
+    
+    // Store debug info globally for later inspection
+    window.__CDP_FINGERPRINT_DEBUG__ = {
+        timestamp: new Date().toISOString(),
+        platform: navigator.platform,
+        webdriver: navigator.webdriver,
+        deviceMemory: navigator.deviceMemory,
+        hardwareConcurrency: navigator.hardwareConcurrency,
+        appliedOptions: {
+            platform: '${options.platform || "auto"}',
+            enableAdvancedStealth: ${options.enableAdvancedStealth !== false},
+            bypassCDPDetection: ${options.bypassCDPDetection !== false},
+            enableDataDomeBypass: ${options.enableDataDomeBypass || false},
+        }
+    };
+})();
+`;
+    }
     /**
      * Extract relevant data from fingerprint for overrides
      */
     extractFingerprintData(fingerprint) {
         const webglConfig = {};
         const platformConfig = {};
-        // Extract WebGL data if available
-        if (fingerprint.webgl) {
-            webglConfig.vendor = fingerprint.webgl.vendor;
-            webglConfig.renderer = fingerprint.webgl.renderer;
-            webglConfig.vendorUnmasked = fingerprint.webgl.vendorUnmasked;
-            webglConfig.rendererUnmasked = fingerprint.webgl.rendererUnmasked;
+        // Extract WebGL data from videoCard if available
+        if (fingerprint.videoCard) {
+            webglConfig.vendor = fingerprint.videoCard.vendor;
+            webglConfig.renderer = fingerprint.videoCard.renderer;
+            webglConfig.vendorUnmasked = fingerprint.videoCard.vendor;
+            webglConfig.rendererUnmasked = fingerprint.videoCard.renderer;
         }
         // Extract platform data if available
         if (fingerprint.navigator) {
@@ -174,6 +374,12 @@ export class CdpFingerprintInjector {
             platformConfig.language = fingerprint.navigator.language;
             platformConfig.languages = fingerprint.navigator.languages;
             platformConfig.oscpu = fingerprint.navigator.oscpu;
+            // Extract userAgent and related properties from generated fingerprint
+            platformConfig.userAgent = fingerprint.navigator.userAgent;
+            platformConfig.appVersion = fingerprint.navigator.appVersion;
+            platformConfig.appName = fingerprint.navigator.appName;
+            platformConfig.appCodeName = fingerprint.navigator.appCodeName;
+            platformConfig.product = fingerprint.navigator.product;
         }
         if (fingerprint.screen) {
             platformConfig.devicePixelRatio = fingerprint.screen.devicePixelRatio;
@@ -191,21 +397,37 @@ export class CdpFingerprintInjector {
         if (timezone) {
             await this.setTimezoneOverride(timezone);
         }
-        // Enable the Page domain so we can attach scripts
-        await this.page.client.Page.enable();
-        // "Enhance" the fingerprint so we can inject it
-        const enhancedFingerprint = this.injector._enhanceFingerprint(fingerprint);
-        // Filter out only headers we can actually inject
-        const filteredHeaders = this.injector.onlyInjectableHeaders(headers, 'chrome');
-        // Main script from fingerprint-injector
-        // @ts-expect-error Using private
-        const fingerprintScript = this.injector.getInjectableFingerprintFunction(enhancedFingerprint);
-        // Prepare all scripts to inject
-        const scriptsToInject = [fingerprintScript];
+        // NOTE: Page.enable() is required for addScriptToEvaluateOnNewDocument to work
+        // We enable it lazily just before script injection to minimize detection surface
+        await this.page.ensurePageEnabled();
+        // Filter headers to only include those that can be injected via CDP
+        const filteredHeaders = {};
+        const allowedHeaders = ['accept', 'accept-encoding', 'accept-language', 'user-agent', 'referer', 'sec-ch-ua', 'sec-ch-ua-mobile', 'sec-ch-ua-platform'];
+        for (const [key, value] of Object.entries(headers)) {
+            if (allowedHeaders.includes(key.toLowerCase()) && typeof value === 'string') {
+                filteredHeaders[key] = value;
+            }
+        }
+        // Create custom fingerprint injection scripts
+        log.info('Creating custom fingerprint injection scripts');
+        const customFingerprintScripts = createCustomFingerprintInjection(fingerprint, {
+            debug: options?.debug !== false,
+            throwOnError: true
+        });
+        // Prepare all scripts to inject - stealth utils and runtime bypass MUST be first
+        // These scripts set up protections BEFORE page JavaScript runs
+        const scriptsToInject = [
+            createStealthUtilsScript(), // Must be first - provides guards and toString spoofing
+            createPrototypeIntegrityScript(), // Second - provides native-like property descriptor masking
+            createRuntimeEnableBypassScript(), // Third - protects against CDP detection via Error stack analysis
+            ...customFingerprintScripts, // Custom fingerprint injection replacing fingerprint-injector
+        ];
         // Always inject base stealth protections
         await this.injectStealthProtections();
         // Extract fingerprint data if we should use it
-        const shouldUseFingerprintData = options?.useFingerprintDefaults !== false;
+        // When useFingerprintDefaults is true (or undefined), use hardcoded defaults
+        // When useFingerprintDefaults is false, use the generated fingerprint data
+        const shouldUseFingerprintData = options?.useFingerprintDefaults === false;
         const { webglConfig, platformConfig } = shouldUseFingerprintData
             ? this.extractFingerprintData(fingerprint)
             : { webglConfig: undefined, platformConfig: undefined };
@@ -243,34 +465,220 @@ export class CdpFingerprintInjector {
             if (options?.spoofLocale !== false) {
                 scriptsToInject.push(createLocaleSpoofingScript());
             }
+            // 2024-2025 New protections
+            // CDP Detection Bypass
+            if (options?.bypassCDPDetection !== false) {
+                scriptsToInject.push(createCDPDetectionBypassScript());
+            }
+            // Storage consistency
+            if (options?.spoofStorage !== false) {
+                scriptsToInject.push(createStorageConsistencyScript());
+            }
+            // Timing consistency
+            if (options?.spoofTiming !== false) {
+                scriptsToInject.push(createTimingConsistencyScript());
+            }
+            // DataDome-specific bypass
+            if (options?.enableDataDomeBypass) {
+                scriptsToInject.push(createDataDomeBypassScript());
+            }
+            // Keyboard humanization (browser context) - disabled by default
+            if (options?.humanization?.keyboard) {
+                scriptsToInject.push(createKeyboardHumanizationScript());
+            }
+            // Scroll humanization (browser context) - disabled by default
+            if (options?.humanization?.scroll) {
+                scriptsToInject.push(createScrollHumanizationScript());
+            }
         }
         // Apply platform consistency script
         if (options?.platform) {
             scriptsToInject.push(createPlatformConsistencyScript(options.platform, shouldUseFingerprintData ? platformConfig : undefined));
         }
-        // Inject all scripts
-        await Promise.all([
-            this.setViewport(options?.viewport),
-            this.setExtraHTTPHeaders(filteredHeaders),
-            ...scriptsToInject.map(async (script) => this.page.client.Page.addScriptToEvaluateOnNewDocument({ source: script })),
-        ]);
-        // Setup mouse movement humanization if requested
-        if (options?.humanizeInteractions) {
+        // CRITICAL: Clean scripts to remove CDP detection patterns
+        // Remove sourceURL comments that reveal CDP injection
+        const cleanScript = (script) => {
+            return script
+                // Remove sourceURL patterns that reveal CDP injection
+                .replace(/\/\/# sourceURL=[^\n]*/g, '')
+                .replace(/\/\/@ sourceURL=[^\n]*/g, '')
+                // Remove sourceMappingURL patterns
+                .replace(/\/\/# sourceMappingURL=[^\n]*/g, '')
+                // Remove puppeteer/playwright markers
+                .replace(/__puppeteer_evaluation_script__/g, 'anonymous')
+                .replace(/__playwright_evaluation_script__/g, 'anonymous')
+                // Remove CDP-specific comments
+                .replace(/\/\*\s*__CDP_[A-Z_]+__\s*\*\//g, '');
+        };
+        // BUNDLE ALL SCRIPTS INTO ONE to minimize CDP interactions
+        // Each addScriptToEvaluateOnNewDocument call is a detection opportunity
+        log.info(`Bundling ${scriptsToInject.length} fingerprint scripts into single injection`);
+        const bundledScript = scriptsToInject
+            .map(script => cleanScript(script))
+            .join('\n\n// --- Next Module ---\n\n');
+        // Validate bundled script for syntax errors
+        try {
+            new Function(bundledScript);
+            log.info('✓ Bundled script passed syntax validation');
+        }
+        catch (error) {
+            log.error('✗ Bundled script has syntax error:', { error });
+            // Fall back to individual script validation to find the culprit
+            scriptsToInject.forEach((script, index) => {
+                try {
+                    new Function(script);
+                }
+                catch (e) {
+                    const scriptPreview = script.substring(0, 300);
+                    log.error(`✗ Error in script ${index + 1}:`, { error: e, scriptPreview });
+                }
+            });
+            throw new Error(`Bundled script has syntax error: ${error}`);
+        }
+        // Inject SINGLE bundled script - reduces CDP detection surface
+        try {
+            log.info('Injecting single bundled fingerprint script (minimizes CDP detection)');
+            await Promise.all([
+                this.setViewport(options?.viewport, fingerprint),
+                this.setExtraHTTPHeaders(filteredHeaders),
+                // Single script injection instead of many - reduces CDP detection surface
+                (async () => {
+                    try {
+                        await this.page.client.Page.addScriptToEvaluateOnNewDocument({
+                            source: bundledScript
+                        });
+                        log.info('✓ Bundled script injected successfully');
+                    }
+                    catch (error) {
+                        const scriptPreview = bundledScript.substring(0, 200).split('\n')[0];
+                        log.error('✗ Failed to inject bundled script:', {
+                            error,
+                            scriptPreview,
+                        });
+                        throw error; // Rethrow to fail the entire injection
+                    }
+                })(),
+            ]);
+            log.info('✓ Fingerprint injection complete (single bundled script)');
+        }
+        catch (error) {
+            log.error('✗ Failed to inject fingerprint scripts:', { error });
+            throw error; // Rethrow to make injection failures visible
+        }
+        // Setup mouse movement humanization if requested (disabled by default)
+        // Support both legacy humanizeInteractions and new humanization.mouse
+        const enableMouseHumanization = options?.humanization?.mouse || options?.humanizeInteractions;
+        if (enableMouseHumanization) {
             await setupMouseMovementHumanization(this.page.client);
         }
-        // Additional CDP-level protections
-        if (options?.bypassRuntimeEnable) {
-            await setupRuntimeEnableBypass(this.page.client);
+        // NOTE: setupRuntimeEnableBypass REMOVED - it uses Runtime.evaluate which is itself a detection vector!
+        // The bypass script is now included in the bundled stealth scripts injected via addScriptToEvaluateOnNewDocument
+        // This runs BEFORE page JavaScript, avoiding Runtime domain activation
+        // 2024-2025: CDP-level keyboard humanization (disabled by default)
+        if (options?.humanization?.keyboard) {
+            await setupKeyboardHumanization(this.page.client);
+        }
+        // 2024-2025: CDP-level scroll humanization (disabled by default)
+        if (options?.humanization?.scroll) {
+            await setupScrollHumanization(this.page.client);
+        }
+        // Inject debug script for browser console verification (always inject for debugging)
+        if (options?.debug !== false) {
+            const debugScript = this.createDebugScript(options || {});
+            await this.page.client.Page.addScriptToEvaluateOnNewDocument({ source: debugScript });
         }
         log.info('Enhanced fingerprint attached with settings:', {
             proxy: options?.proxyUrl,
             timezone,
             advancedStealth: options?.enableAdvancedStealth !== false,
-            humanizeInteractions: options?.humanizeInteractions,
             bypassRuntimeEnable: options?.bypassRuntimeEnable,
             platform: options?.platform,
             useFingerprintDefaults: options?.useFingerprintDefaults,
+            // 2024-2025 new options
+            bypassCDPDetection: options?.bypassCDPDetection !== false,
+            spoofStorage: options?.spoofStorage !== false,
+            spoofTiming: options?.spoofTiming !== false,
+            enableDataDomeBypass: options?.enableDataDomeBypass,
+            // Humanization options
+            humanization: {
+                mouse: enableMouseHumanization || false,
+                keyboard: options?.humanization?.keyboard || false,
+                scroll: options?.humanization?.scroll || false,
+            },
+            // Viewport info
+            viewport: options?.viewport,
+            fingerprintScreen: fingerprint?.screen ? {
+                width: fingerprint.screen.width,
+                height: fingerprint.screen.height,
+                devicePixelRatio: fingerprint.screen.devicePixelRatio,
+            } : undefined,
         });
+        // Add a debug script to log viewport info in the browser console
+        const viewportDebugScript = `
+            (() => {
+                console.log('[VIEWPORT-DEBUG] Initial window dimensions:', {
+                    innerWidth: window.innerWidth,
+                    innerHeight: window.innerHeight,
+                    outerWidth: window.outerWidth,
+                    outerHeight: window.outerHeight,
+                    screenWidth: screen.width,
+                    screenHeight: screen.height,
+                    availWidth: screen.availWidth,
+                    availHeight: screen.availHeight,
+                    devicePixelRatio: window.devicePixelRatio,
+                    scrollY: window.scrollY,
+                    scrollHeight: document.documentElement?.scrollHeight || 'N/A',
+                    clientHeight: document.documentElement?.clientHeight || 'N/A'
+                });
+                
+                // Check consistency
+                const inconsistencies = [];
+                if (window.innerWidth !== screen.width && Math.abs(window.innerWidth - screen.width) > 50) {
+                    inconsistencies.push(\`innerWidth (\${window.innerWidth}) != screen.width (\${screen.width})\`);
+                }
+                if (window.innerHeight !== screen.height && Math.abs(window.innerHeight - screen.height) > 100) {
+                    inconsistencies.push(\`innerHeight (\${window.innerHeight}) != screen.height (\${screen.height})\`);
+                }
+                
+                if (inconsistencies.length > 0) {
+                    console.warn('[VIEWPORT-DEBUG] ⚠️ INCONSISTENCIES DETECTED:', inconsistencies);
+                } else {
+                    console.log('[VIEWPORT-DEBUG] ✅ Dimensions appear consistent');
+                }
+                
+                // Test scrolling after DOM is ready
+                const checkScroll = () => {
+                    if (document.documentElement) {
+                        const scrollHeight = document.documentElement.scrollHeight;
+                        const clientHeight = document.documentElement.clientHeight;
+                        const canScroll = scrollHeight > clientHeight;
+                        
+                        console.log('[VIEWPORT-DEBUG] After load:', {
+                            scrollHeight,
+                            clientHeight,
+                            canScroll,
+                            overflow: scrollHeight - clientHeight,
+                            bodyHeight: document.body?.scrollHeight,
+                            innerHeight: window.innerHeight,
+                            screenHeight: screen.height
+                        });
+                        
+                        if (canScroll) {
+                            console.log('[VIEWPORT-DEBUG] ✅ SCROLLING ENABLED - Page has', scrollHeight - clientHeight, 'px overflow');
+                        } else {
+                            console.log('[VIEWPORT-DEBUG] ⚠️ NO OVERFLOW - Cannot scroll (scrollHeight === clientHeight)');
+                        }
+                    }
+                };
+                
+                if (document.readyState === 'loading') {
+                    document.addEventListener('DOMContentLoaded', checkScroll);
+                } else {
+                    setTimeout(checkScroll, 1000);
+                }
+            })();
+        `;
+        await this.page.client.Page.addScriptToEvaluateOnNewDocument({ source: viewportDebugScript });
     }
 }
 //# sourceMappingURL=fingerprint-injector.js.map