jumpy-lion 0.0.41 → 0.0.42

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.js

@@ -1,84 +1,143 @@
 /**
- * Runtime.enable Bypass
- * Prevents CDP detection through console.log(Error) technique
+ * Runtime.enable Bypass Script
+ * Prevents CDP detection through console.log(Error) technique and stack trace analysis.
+ *
+ * IMPORTANT: This is now a SCRIPT to be injected via addScriptToEvaluateOnNewDocument,
+ * NOT via Runtime.evaluate (which would defeat the purpose since Runtime.evaluate IS detectable!)
  */
-export const setupRuntimeEnableBypass = async (client) => {
-    // Intercept Runtime.enable calls to prevent detection
-    await client.send('Runtime.evaluate', {
-        expression: `
+/**
+ * Creates the runtime enable bypass script that should be bundled with other stealth scripts.
+ * This script runs BEFORE page JavaScript and patches Error/console to hide CDP markers.
+ */
+export const createRuntimeEnableBypassScript = () => `
 (() => {
-    // Store the original CDP send method if accessible
-    if (window.__CDP_CLIENT__) {
-        const originalSend = window.__CDP_CLIENT__.send;
-        window.__CDP_CLIENT__.send = function(method, params) {
-            // Block or modify Runtime.enable calls
-            if (method === 'Runtime.enable') {
-                console.log('Runtime.enable blocked');
-                return Promise.resolve({});
-            }
-            return originalSend.apply(this, arguments);
-        };
-    }
+    'use strict';
+    const DEBUG_PREFIX = '[RUNTIME-ENABLE-BYPASS]';
     
-    // Additional protection against CDP detection
-    const originalError = Error;
-    let errorCounter = 0;
-    
-    window.Error = new Proxy(originalError, {
-        construct(target, args) {
-            const error = Reflect.construct(target, args);
+    try {
+        // =============================================================================
+        // PART 1: Error stack trace sanitization
+        // CDP detection often works by examining Error.stack for automation markers
+        // =============================================================================
+        
+        const originalError = Error;
+        const originalErrorToString = Error.prototype.toString;
+        const originalErrorStackDesc = Object.getOwnPropertyDescriptor(Error.prototype, 'stack');
+        
+        // Patterns that reveal CDP/automation
+        const CDP_MARKERS = [
+            '__puppeteer_evaluation_script__',
+            '__playwright_evaluation_script__',
+            'CDP_',
+            'chrome-extension://',
+            'devtools://',
+            'pptr:',
+            'Runtime.evaluate',
+        ];
+        
+        const sanitizeStack = (stack) => {
+            if (!stack || typeof stack !== 'string') return stack;
             
-            // Detect CDP serialization attempts
-            const stack = new originalError().stack;
-            if (stack && stack.includes('__puppeteer_evaluation_script__')) {
-                // This is likely a CDP evaluation, modify behavior
-                Object.defineProperty(error, 'stack', {
-                    get() {
-                        return 'Error\\n    at <anonymous>:1:1';
-                    },
-                    configurable: false
-                });
+            let sanitized = stack;
+            for (const marker of CDP_MARKERS) {
+                if (sanitized.includes(marker)) {
+                    // Replace with generic anonymous reference
+                    // Simple string replacement (markers don't contain regex special chars)
+                    while (sanitized.includes(marker)) {
+                        sanitized = sanitized.split(marker).join('anonymous');
+                    }
+                }
             }
-            
-            return error;
+            return sanitized;
+        };
+        
+        // Override Error.prepareStackTrace if it exists (V8 specific)
+        if (typeof Error.prepareStackTrace === 'function') {
+            const originalPrepareStackTrace = Error.prepareStackTrace;
+            Error.prepareStackTrace = function(error, structuredStackTrace) {
+                const stack = originalPrepareStackTrace.call(this, error, structuredStackTrace);
+                return sanitizeStack(stack);
+            };
         }
-    });
-    
-    // Protect against console-based CDP detection
-    const protectedConsole = new Proxy(console, {
-        get(target, prop) {
-            const original = target[prop];
+        
+        // Override Error.prototype.stack getter
+        if (originalErrorStackDesc && originalErrorStackDesc.get) {
+            Object.defineProperty(Error.prototype, 'stack', {
+                get: function() {
+                    const stack = originalErrorStackDesc.get.call(this);
+                    return sanitizeStack(stack);
+                },
+                set: originalErrorStackDesc.set,
+                configurable: true,
+                enumerable: false
+            });
+        }
+        
+        console.log(DEBUG_PREFIX, '✓ Error stack trace sanitization applied');
+        
+        // =============================================================================
+        // PART 2: Console protection
+        // Some CDP detection works by examining how Error objects are serialized in console
+        // =============================================================================
+        
+        const originalConsole = window.console;
+        const consoleMethodsToProtect = ['log', 'warn', 'error', 'info', 'debug', 'trace'];
+        
+        consoleMethodsToProtect.forEach(method => {
+            const original = originalConsole[method];
             if (typeof original === 'function') {
-                return new Proxy(original, {
-                    apply(fn, thisArg, args) {
-                        // Filter out Error objects that might be used for CDP detection
-                        const filteredArgs = args.map(arg => {
-                            if (arg instanceof Error && arg.stack) {
-                                // Check if this might be a CDP detection attempt
-                                const stackString = arg.stack.toString();
-                                if (stackString.includes('Error.captureStackTrace') || 
-                                    stackString.includes('__puppeteer_evaluation_script__')) {
-                                    return arg.toString();
-                                }
-                            }
-                            return arg;
-                        });
-                        return Reflect.apply(fn, thisArg, filteredArgs);
-                    }
-                });
+                originalConsole[method] = function(...args) {
+                    // Sanitize Error objects before logging
+                    const sanitizedArgs = args.map(arg => {
+                        if (arg instanceof Error) {
+                            // Clone the error with sanitized stack
+                            const sanitizedError = new Error(arg.message);
+                            sanitizedError.name = arg.name;
+                            // stack will be auto-sanitized by our getter
+                            return sanitizedError;
+                        }
+                        return arg;
+                    });
+                    return original.apply(this, sanitizedArgs);
+                };
+                // Hide the patch
+                originalConsole[method].toString = () => \`function \${method}() { [native code] }\`;
             }
-            return original;
-        }
-    });
-    
-    try {
-        Object.defineProperty(window, 'console', {
-            value: protectedConsole,
-            writable: false,
-            configurable: false
         });
-    } catch (e) {}
-})();`,
-    });
-};
+        
+        console.log(DEBUG_PREFIX, '✓ Console protection applied');
+        
+        // =============================================================================
+        // PART 3: Protect against CDP WebSocket detection
+        // Some advanced detection tries to find the CDP websocket connection
+        // =============================================================================
+        
+        // Override WebSocket to hide CDP connections
+        const originalWebSocket = window.WebSocket;
+        window.WebSocket = function(url, protocols) {
+            // Check if this looks like a CDP connection
+            if (url && typeof url === 'string') {
+                const lowerUrl = url.toLowerCase();
+                if (lowerUrl.includes('devtools') || 
+                    lowerUrl.includes('/json') ||
+                    lowerUrl.includes('ws://localhost:') ||
+                    lowerUrl.includes('ws://127.0.0.1:')) {
+                    // This might be a CDP detection attempt, proceed but mark it
+                    // We can't block it as that would break legitimate websockets
+                }
+            }
+            return new originalWebSocket(url, protocols);
+        };
+        
+        window.WebSocket.prototype = originalWebSocket.prototype;
+        Object.defineProperty(window.WebSocket, 'name', { value: 'WebSocket' });
+        window.WebSocket.toString = () => 'function WebSocket() { [native code] }';
+        
+        console.log(DEBUG_PREFIX, '✓ WebSocket protection applied');
+        
+    } catch (error) {
+        console.error(DEBUG_PREFIX, 'Failed to apply bypass:', error.message);
+    }
+})();
+`;
 //# sourceMappingURL=runtime-enable-bypass.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"runtime-enable-bypass.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,KAAK,EAAE,MAAW,EAAiB,EAAE;IACzE,sDAAsD;IACtD,MAAM,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE;QAClC,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyEd;KACD,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"runtime-enable-bypass.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkI5D,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/scroll-humanization.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Scroll Humanization Module
+ * Simulates realistic scroll behavior for 2024-2025
+ *
+ * Features:
+ * - Natural scroll momentum physics
+ * - Reading-speed based scroll patterns
+ * - Scroll pause at content sections
+ * - Touch-like vs mouse wheel differentiation
+ * - CDP-level scroll enhancement
+ */
+/**
+ * Scroll configuration
+ */
+interface ScrollConfig {
+    /** Base scroll speed in pixels per scroll event */
+    baseScrollAmount: number;
+    /** Variance in scroll amount */
+    scrollVariance: number;
+    /** Deceleration factor for momentum scrolling */
+    deceleration: number;
+    /** Minimum velocity before stopping */
+    minVelocity: number;
+    /** Reading pause probability (0-1) */
+    readingPauseProbability: number;
+    /** Reading pause duration range in ms [min, max] */
+    readingPauseDuration: [number, number];
+    /** Delay between scroll events in ms */
+    eventDelay: number;
+}
+/**
+ * Generate human-like scroll positions using momentum physics
+ */
+export declare const generateScrollPath: (startY: number, targetY: number, config?: Partial<ScrollConfig>) => {
+    y: number;
+    delay: number;
+}[];
+/**
+ * Create a script that enhances scroll events in the browser
+ */
+export declare const createScrollHumanizationScript: () => string;
+/**
+ * CDP-level human-like scroll function
+ */
+export declare const humanScroll: (client: unknown, targetY: number, config?: Partial<ScrollConfig>) => Promise<void>;
+/**
+ * Scroll to element with human-like behavior
+ */
+export declare const humanScrollToElement: (client: unknown, selector: string, config?: Partial<ScrollConfig>) => Promise<void>;
+/**
+ * Setup scroll humanization at CDP level
+ */
+export declare const setupScrollHumanization: (client: unknown) => Promise<void>;
+export {};
+//# sourceMappingURL=scroll-humanization.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/scroll-humanization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-humanization.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/scroll-humanization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,UAAU,YAAY;IAClB,mDAAmD;IACnD,gBAAgB,EAAE,MAAM,CAAC;IACzB,gCAAgC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC;IACrB,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,uBAAuB,EAAE,MAAM,CAAC;IAChC,oDAAoD;IACpD,oBAAoB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;CACtB;AAYD;;GAEG;AACH,eAAO,MAAM,kBAAkB,WACnB,MAAM,WACL,MAAM,WACP,OAAO,CAAC,YAAY,CAAC,KAC9B;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAyD9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,8BAA8B,QAAO,MA0NjD,CAAC;AAOF;;GAEG;AACH,eAAO,MAAM,WAAW,WACZ,OAAO,WACN,MAAM,WACP,OAAO,CAAC,YAAY,CAAC,KAC9B,OAAO,CAAC,IAAI,CA0Dd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,WACrB,OAAO,YACL,MAAM,WACR,OAAO,CAAC,YAAY,CAAC,KAC9B,OAAO,CAAC,IAAI,CAuCd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,WAAkB,OAAO,KAAG,OAAO,CAAC,IAAI,CAY3E,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/scroll-humanization.js

@@ -0,0 +1,380 @@
+/**
+ * Scroll Humanization Module
+ * Simulates realistic scroll behavior for 2024-2025
+ *
+ * Features:
+ * - Natural scroll momentum physics
+ * - Reading-speed based scroll patterns
+ * - Scroll pause at content sections
+ * - Touch-like vs mouse wheel differentiation
+ * - CDP-level scroll enhancement
+ */
+const DEFAULT_SCROLL_CONFIG = {
+    baseScrollAmount: 100,
+    scrollVariance: 30,
+    deceleration: 0.95,
+    minVelocity: 5,
+    readingPauseProbability: 0.15,
+    readingPauseDuration: [500, 2000],
+    eventDelay: 16, // ~60fps
+};
+/**
+ * Generate human-like scroll positions using momentum physics
+ */
+export const generateScrollPath = (startY, targetY, config = {}) => {
+    const cfg = { ...DEFAULT_SCROLL_CONFIG, ...config };
+    const path = [];
+    const direction = targetY > startY ? 1 : -1;
+    const totalDistance = Math.abs(targetY - startY);
+    // Initial velocity based on distance
+    let velocity = Math.min(cfg.baseScrollAmount * 2, totalDistance / 10);
+    let currentY = startY;
+    while (Math.abs(targetY - currentY) > cfg.minVelocity) {
+        // Apply deceleration as we approach target
+        const remainingDistance = Math.abs(targetY - currentY);
+        const decelerationFactor = remainingDistance < 200 ?
+            cfg.deceleration * 0.8 : cfg.deceleration;
+        velocity *= decelerationFactor;
+        // Add variance to make it look natural
+        const variance = (Math.random() - 0.5) * cfg.scrollVariance;
+        const scrollAmount = (velocity + variance) * direction;
+        currentY += scrollAmount;
+        // Clamp to target
+        if (direction > 0) {
+            currentY = Math.min(currentY, targetY);
+        }
+        else {
+            currentY = Math.max(currentY, targetY);
+        }
+        // Add slight variation to timing
+        const delay = cfg.eventDelay + (Math.random() - 0.5) * 8;
+        path.push({ y: Math.round(currentY), delay: Math.round(delay) });
+        // Occasionally pause as if reading
+        if (Math.random() < cfg.readingPauseProbability && path.length > 3) {
+            const pauseDuration = cfg.readingPauseDuration[0] +
+                Math.random() * (cfg.readingPauseDuration[1] - cfg.readingPauseDuration[0]);
+            path.push({ y: Math.round(currentY), delay: Math.round(pauseDuration) });
+            // Reset velocity after pause (user starts scrolling again)
+            velocity = cfg.baseScrollAmount;
+        }
+        // Ensure we don't get stuck in an infinite loop
+        if (velocity < cfg.minVelocity) {
+            break;
+        }
+    }
+    // Final position
+    path.push({ y: targetY, delay: cfg.eventDelay });
+    return path;
+};
+/**
+ * Create a script that enhances scroll events in the browser
+ */
+export const createScrollHumanizationScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Scroll Humanization for 2024-2025
+    const humanizeScroll = () => {
+        console.log('[SCROLL-DEBUG] Initializing scroll humanization');
+        
+        // Track scroll state
+        let lastScrollTime = 0;
+        let scrollVelocity = 0;
+        let isScrolling = false;
+        let scrollTimeout = null;
+        
+        // Generate consistent scroll variations
+        const generateScrollId = () => {
+            return Math.random().toString(36).substr(2, 9);
+        };
+        
+        // Store original wheel event constructor
+        const OriginalWheelEvent = WheelEvent;
+        
+        // Override WheelEvent to add realistic properties
+        window.WheelEvent = function(type, eventInitDict = {}) {
+            const enhancedInit = { ...eventInitDict };
+            
+            // Add realistic delta values if not set
+            if (enhancedInit.deltaY === undefined) {
+                enhancedInit.deltaY = 100 + (Math.random() - 0.5) * 30;
+            }
+            
+            // Add variance to existing delta
+            if (typeof enhancedInit.deltaY === 'number') {
+                enhancedInit.deltaY += (Math.random() - 0.5) * 10;
+            }
+            
+            // Ensure proper delta mode (0 = pixels, 1 = lines, 2 = pages)
+            if (enhancedInit.deltaMode === undefined) {
+                enhancedInit.deltaMode = 0; // Pixels is most common
+            }
+            
+            return new OriginalWheelEvent(type, enhancedInit);
+        };
+        
+        // Note: Don't assign to prototype - it may be frozen in modern Chrome
+        // The Proxy wrapper handles prototype access via get trap if needed
+        console.log('[SCROLL-DEBUG] WheelEvent override installed');
+        
+        // Enhanced scroll behavior tracking
+        const trackScrollBehavior = () => {
+            console.log('[SCROLL-DEBUG] Setting up scroll behavior tracking');
+            const originalScrollTo = window.scrollTo;
+            const originalScrollBy = window.scrollBy;
+            const originalScrollIntoView = Element.prototype.scrollIntoView;
+            
+            let scrollCallCount = 0;
+            
+            // Override scrollTo to add human-like behavior
+            window.scrollTo = function(options) {
+                scrollCallCount++;
+                console.log('[SCROLL-DEBUG] scrollTo called', { 
+                    callCount: scrollCallCount, 
+                    options,
+                    scrollY: window.scrollY 
+                });
+                // Don't interfere with normal scrolling - just pass through
+                // The humanization happens at the wheel event level
+                return originalScrollTo.apply(this, arguments);
+            };
+            
+            // Override scrollBy similarly
+            window.scrollBy = function(options) {
+                scrollCallCount++;
+                console.log('[SCROLL-DEBUG] scrollBy called', { 
+                    callCount: scrollCallCount, 
+                    options: typeof options === 'object' ? options : { x: arguments[0], y: arguments[1] },
+                    scrollY: window.scrollY 
+                });
+                
+                // Create a copy of options to avoid modifying the original
+                if (typeof options === 'object' && options !== null) {
+                    const modifiedOptions = { ...options };
+                    // Add slight variance to scroll amount
+                    if (modifiedOptions.top !== undefined) {
+                        modifiedOptions.top += (Math.random() - 0.5) * 2;
+                    }
+                    if (modifiedOptions.left !== undefined) {
+                        modifiedOptions.left += (Math.random() - 0.5) * 2;
+                    }
+                    return originalScrollBy.call(this, modifiedOptions);
+                }
+                
+                return originalScrollBy.apply(this, arguments);
+            };
+            
+            // Override scrollIntoView
+            Element.prototype.scrollIntoView = function(options) {
+                scrollCallCount++;
+                console.log('[SCROLL-DEBUG] scrollIntoView called', { 
+                    callCount: scrollCallCount, 
+                    element: this.tagName,
+                    options 
+                });
+                // Just pass through to original - don't break scrolling
+                return originalScrollIntoView.call(this, options);
+            };
+            
+            console.log('[SCROLL-DEBUG] Scroll overrides installed');
+        };
+        
+        // Simulate natural scroll momentum
+        const addScrollMomentum = () => {
+            let momentumId = null;
+            let currentVelocity = 0;
+            let wheelEventCount = 0;
+            
+            console.log('[SCROLL-DEBUG] Setting up scroll momentum');
+            
+            window.addEventListener('wheel', (event) => {
+                wheelEventCount++;
+                console.log('[SCROLL-DEBUG] Wheel event', { 
+                    count: wheelEventCount,
+                    deltaY: event.deltaY,
+                    scrollY: window.scrollY,
+                    maxScrollY: document.documentElement.scrollHeight - window.innerHeight
+                });
+                
+                // Calculate scroll velocity
+                const now = performance.now();
+                const timeDelta = now - lastScrollTime;
+                
+                if (timeDelta > 0 && timeDelta < 500) {
+                    currentVelocity = event.deltaY / timeDelta;
+                }
+                
+                lastScrollTime = now;
+                
+                // Cancel any existing momentum
+                if (momentumId) {
+                    cancelAnimationFrame(momentumId);
+                }
+                
+                // Start momentum scrolling
+                const applyMomentum = () => {
+                    if (Math.abs(currentVelocity) < 0.1) {
+                        console.log('[SCROLL-DEBUG] Momentum stopped (velocity too low)');
+                        return;
+                    }
+                    
+                    currentVelocity *= 0.95; // Deceleration
+                    window.scrollBy(0, currentVelocity * 16);
+                    
+                    momentumId = requestAnimationFrame(applyMomentum);
+                };
+                
+                // Only apply momentum on natural scroll end
+                // (not when user is actively scrolling)
+                clearTimeout(scrollTimeout);
+                scrollTimeout = setTimeout(() => {
+                    if (Math.abs(currentVelocity) > 0.5) {
+                        console.log('[SCROLL-DEBUG] Starting momentum scroll', { velocity: currentVelocity });
+                        applyMomentum();
+                    }
+                }, 100);
+            }, { passive: true });
+            
+            console.log('[SCROLL-DEBUG] Wheel event listener attached');
+        };
+        
+        // Track and enhance touch scroll events
+        const enhanceTouchScroll = () => {
+            let touchStartY = 0;
+            let touchStartTime = 0;
+            
+            window.addEventListener('touchstart', (event) => {
+                if (event.touches.length === 1) {
+                    touchStartY = event.touches[0].clientY;
+                    touchStartTime = performance.now();
+                }
+            }, { passive: true });
+            
+            window.addEventListener('touchend', (event) => {
+                const touchDuration = performance.now() - touchStartTime;
+                const touchEndY = event.changedTouches[0]?.clientY || touchStartY;
+                const distance = touchStartY - touchEndY;
+                
+                // Calculate velocity for momentum
+                if (touchDuration > 0) {
+                    scrollVelocity = distance / touchDuration;
+                }
+            }, { passive: true });
+        };
+        
+        // Initialize scroll humanization
+        console.log('[SCROLL-DEBUG] Starting scroll humanization initialization');
+        trackScrollBehavior();
+        addScrollMomentum();
+        enhanceTouchScroll();
+        console.log('[SCROLL-DEBUG] Scroll humanization fully initialized');
+        
+        // Log document ready state
+        console.log('[SCROLL-DEBUG] Document ready state:', document.readyState);
+        console.log('[SCROLL-DEBUG] Body scrollHeight:', document.body?.scrollHeight || 'N/A');
+        console.log('[SCROLL-DEBUG] Document scrollHeight:', document.documentElement?.scrollHeight || 'N/A');
+        console.log('[SCROLL-DEBUG] Window innerHeight:', window.innerHeight);
+    };
+
+    // Don't catch errors - let them bubble up so we can see them
+    humanizeScroll();
+    
+    // Also log when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => {
+            console.log('[SCROLL-DEBUG] DOM loaded - scrollHeight:', document.documentElement?.scrollHeight || 'N/A');
+        });
+    }
+})();`;
+};
+/**
+ * Helper sleep function
+ */
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * CDP-level human-like scroll function
+ */
+export const humanScroll = async (client, targetY, config = {}) => {
+    const inputClient = client;
+    // Get current scroll position
+    const result = await inputClient.Runtime.evaluate({
+        expression: 'window.scrollY',
+        returnByValue: true,
+    });
+    const startY = result.result.value;
+    // Generate scroll path
+    const path = generateScrollPath(startY, targetY, config);
+    // Get viewport dimensions for mouse position
+    const viewportResult = await inputClient.Runtime.evaluate({
+        expression: 'JSON.stringify({ width: window.innerWidth, height: window.innerHeight })',
+        returnByValue: true,
+    });
+    const viewport = JSON.parse(viewportResult.result.value);
+    // Position mouse in center of viewport
+    const mouseX = viewport.width / 2;
+    const mouseY = viewport.height / 2;
+    // Execute scroll path
+    let lastY = startY;
+    for (const point of path) {
+        const deltaY = point.y - lastY;
+        if (deltaY !== 0) {
+            // Dispatch wheel event
+            await inputClient.Input.dispatchMouseEvent({
+                type: 'mouseWheel',
+                x: mouseX,
+                y: mouseY,
+                deltaX: 0,
+                deltaY: deltaY,
+            });
+        }
+        lastY = point.y;
+        // Wait for delay
+        await sleep(point.delay);
+    }
+};
+/**
+ * Scroll to element with human-like behavior
+ */
+export const humanScrollToElement = async (client, selector, config = {}) => {
+    const runtimeClient = client;
+    // Get element position
+    const result = await runtimeClient.Runtime.evaluate({
+        expression: `
+            (() => {
+                const element = document.querySelector('${selector.replace(/'/g, "\\'")}');
+                if (!element) return null;
+                const rect = element.getBoundingClientRect();
+                return {
+                    top: rect.top + window.scrollY,
+                    height: rect.height
+                };
+            })()
+        `,
+        returnByValue: true,
+    });
+    const elementInfo = result.result.value;
+    if (!elementInfo) {
+        throw new Error(`Element not found: ${selector}`);
+    }
+    // Calculate target scroll position (element centered in viewport)
+    const viewportResult = await runtimeClient.Runtime.evaluate({
+        expression: 'window.innerHeight',
+        returnByValue: true,
+    });
+    const viewportHeight = viewportResult.result.value;
+    const targetY = elementInfo.top - (viewportHeight / 2) + (elementInfo.height / 2);
+    await humanScroll(client, Math.max(0, targetY), config);
+};
+/**
+ * Setup scroll humanization at CDP level
+ */
+export const setupScrollHumanization = async (client) => {
+    const runtimeClient = client;
+    // NOTE: Using addScriptToEvaluateOnNewDocument instead of Runtime.evaluate
+    // Runtime.evaluate is a CDP detection vector
+    await runtimeClient.Page.addScriptToEvaluateOnNewDocument({
+        source: createScrollHumanizationScript()
+    });
+};
+//# sourceMappingURL=scroll-humanization.js.map