@fanboynz/network-scanner 1.0.59 → 1.0.61

package/lib/cloudflare.js

@@ -11,36 +11,40 @@ const CLOUDFLARE_MODULE_VERSION = '2.1.0';
 
 /**
  * Timeout constants for various operations (in milliseconds)
+ * Optimized timeout constants for Puppeteer 22.x performance (in milliseconds)
+ * All values tuned for maximum scanning speed while maintaining functionality
  */
 const TIMEOUTS = {
-  QUICK_DETECTION: 3000,           // Quick Cloudflare detection check
   PAGE_EVALUATION: 8000,           // Standard page evaluation timeout
   PAGE_EVALUATION_SAFE: 10000,     // Safe page evaluation with extra buffer
-  CHALLENGE_COMPLETION: 3000,      // Challenge completion check
-  PHISHING_WAIT: 2000,            // Wait before checking phishing warning
   PHISHING_CLICK: 3000,           // Timeout for clicking phishing continue button
   PHISHING_NAVIGATION: 8000,       // Wait for navigation after phishing bypass
-  CHALLENGE_WAIT: 1000,           // Wait before checking verification challenge
-  CHALLENGE_SOLVING: 20000,        // Overall challenge solving timeout
-  JS_CHALLENGE: 15000,            // JS challenge completion wait
   JS_CHALLENGE_BUFFER: 18000,     // JS challenge with safety buffer
-  TURNSTILE_OPERATION: 8000,      // Turnstile iframe operations
   TURNSTILE_COMPLETION: 12000,    // Turnstile completion check
   TURNSTILE_COMPLETION_BUFFER: 15000, // Turnstile completion with buffer
-  SELECTOR_WAIT: 2000,            // Wait for selector to appear
-  SELECTOR_WAIT_BUFFER: 2500,     // Selector wait with safety buffer
-  ELEMENT_INTERACTION_DELAY: 500, // Delay before element interactions
   CLICK_TIMEOUT: 5000,            // Standard click operation timeout
   CLICK_TIMEOUT_BUFFER: 1000,     // Click timeout safety buffer
   NAVIGATION_TIMEOUT: 15000,      // Standard navigation timeout
   NAVIGATION_TIMEOUT_BUFFER: 2000, // Navigation timeout safety buffer
-  FALLBACK_TIMEOUT: 5000,         // Fallback timeout for failed operations
   ADAPTIVE_TIMEOUT_WITH_INDICATORS: 25000,    // Adaptive timeout when indicators found + explicit config
   ADAPTIVE_TIMEOUT_WITHOUT_INDICATORS: 20000, // Adaptive timeout with explicit config only
   ADAPTIVE_TIMEOUT_AUTO_WITH_INDICATORS: 15000,   // Adaptive timeout for auto-detected with indicators
   ADAPTIVE_TIMEOUT_AUTO_WITHOUT_INDICATORS: 10000 // Adaptive timeout for auto-detected without indicators
 };
 
+// Fast timeout constants - optimized for speed
+const FAST_TIMEOUTS = {
+  QUICK_DETECTION: 2000,           // Fast Cloudflare detection
+  PHISHING_WAIT: 1000,            // Fast phishing check
+  CHALLENGE_WAIT: 500,            // Fast challenge detection
+  ELEMENT_INTERACTION_DELAY: 250, // Fast element interactions
+  SELECTOR_WAIT: 1500,            // Fast selector waits
+  TURNSTILE_OPERATION: 6000,      // Fast Turnstile operations
+  JS_CHALLENGE: 12000,            // Fast JS challenge completion
+  CHALLENGE_SOLVING: 15000,       // Fast overall challenge solving
+  CHALLENGE_COMPLETION: 3000      // Fast completion check
+};
+
 /**
  * Gets module version information
  * @returns {object} Version information object
@@ -94,28 +98,13 @@ function shouldProcessUrl(url, forceDebug = false) {
 }
 
 /**
- * Cross-version compatible timeout function for Puppeteer with timeout protection
+ * Fast timeout helper for Puppeteer 22.x compatibility 
+ * Replaces deprecated page.waitForTimeout() with standard Promise-based approach
  */
 async function waitForTimeout(page, timeout) {
-  try {
-    // Try newer Puppeteer method first
-    if (typeof page.waitForTimeout === 'function') {
-      await Promise.race([
-        page.waitForTimeout(timeout),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('waitForTimeout exceeded')), timeout + TIMEOUTS.FALLBACK_TIMEOUT))
-      ]);
-    } else if (typeof page.waitFor === 'function') {
-      await Promise.race([
-        page.waitFor(timeout),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('waitFor exceeded')), timeout + TIMEOUTS.FALLBACK_TIMEOUT))
-      ]);
-    } else {
-      await new Promise(resolve => setTimeout(resolve, timeout));
-    }
-  } catch (error) {
-    // If all else fails, use setTimeout
-    await new Promise(resolve => setTimeout(resolve, Math.min(timeout, TIMEOUTS.FALLBACK_TIMEOUT)));
-  }
+  // Use fast Promise-based timeout for Puppeteer 22.x compatibility
+  // This eliminates the deprecated API dependency and improves performance
+  return new Promise(resolve => setTimeout(resolve, timeout));
 }
 
 /**
@@ -226,7 +215,7 @@ async function quickCloudflareDetection(page, forceDebug = false) {
         url,
         bodySnippet: bodyText.substring(0, 200)
       };
-    }, TIMEOUTS.QUICK_DETECTION);
+    }, FAST_TIMEOUTS.QUICK_DETECTION);
     
     if (forceDebug && quickCheck.hasIndicators) {
       console.log(`[debug][cloudflare] Quick detection found Cloudflare indicators on ${quickCheck.url}`);
@@ -356,7 +345,7 @@ async function handlePhishingWarning(page, currentUrl, forceDebug = false) {
     if (forceDebug) console.log(`[debug][cloudflare] Checking for phishing warning on ${currentUrl}`);
     
     // Shorter wait with timeout protection
-    await waitForTimeout(page, TIMEOUTS.PHISHING_WAIT);
+    await waitForTimeout(page, FAST_TIMEOUTS.PHISHING_WAIT);
 
     const challengeInfo = await analyzeCloudflareChallenge(page);
     
@@ -424,7 +413,7 @@ async function handleVerificationChallenge(page, currentUrl, forceDebug = false)
     if (forceDebug) console.log(`[debug][cloudflare] Checking for verification challenge on ${currentUrl}`);
     
     // Reduced wait time
-    await waitForTimeout(page, TIMEOUTS.CHALLENGE_WAIT);
+    await waitForTimeout(page, FAST_TIMEOUTS.CHALLENGE_WAIT);
 
     const challengeInfo = await analyzeCloudflareChallenge(page);
     result.details = challengeInfo;
@@ -489,8 +478,8 @@ async function attemptChallengeSolveWithTimeout(page, currentUrl, challengeInfo,
     // Reduced timeout for challenge solving
     return await Promise.race([
       attemptChallengeSolve(page, currentUrl, challengeInfo, forceDebug),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Challenge solving timeout')), TIMEOUTS.CHALLENGE_SOLVING)
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('Challenge solving timeout')), FAST_TIMEOUTS.CHALLENGE_SOLVING)
       )
     ]);
   } catch (error) {
@@ -589,7 +578,7 @@ async function waitForJSChallengeCompletion(page, forceDebug = false) {
                  !document.querySelector('.cf-challenge-running') &&
                  !document.querySelector('[data-cf-challenge]');
         },
-        { timeout: TIMEOUTS.JS_CHALLENGE }
+        { timeout: FAST_TIMEOUTS.JS_CHALLENGE }
       ),
       new Promise((_, reject) => 
         setTimeout(() => reject(new Error('JS challenge timeout')), TIMEOUTS.JS_CHALLENGE_BUFFER)
@@ -616,8 +605,8 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
   };
 
   try {
-    // Reduced timeout for Turnstile operations
-    const turnstileTimeout = TIMEOUTS.TURNSTILE_OPERATION;
+    // Use fast timeout for Turnstile operations
+    const turnstileTimeout = FAST_TIMEOUTS.TURNSTILE_OPERATION;
     
     const turnstileSelectors = [
       'iframe[src*="challenges.cloudflare.com"]',
@@ -629,8 +618,8 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
     for (const selector of turnstileSelectors) {
       try {
         await Promise.race([
-          page.waitForSelector(selector, { timeout: TIMEOUTS.SELECTOR_WAIT }),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Selector timeout')), TIMEOUTS.SELECTOR_WAIT_BUFFER))
+          page.waitForSelector(selector, { timeout: FAST_TIMEOUTS.SELECTOR_WAIT }),
+          new Promise((_, reject) => setTimeout(() => reject(new Error('Selector timeout')), FAST_TIMEOUTS.SELECTOR_WAIT + 500))
         ]);
         
         const frames = await page.frames();
@@ -663,11 +652,11 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
       for (const selector of checkboxSelectors) {
         try {
           await Promise.race([
-            turnstileFrame.waitForSelector(selector, { timeout: TIMEOUTS.SELECTOR_WAIT }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Checkbox timeout')), TIMEOUTS.SELECTOR_WAIT_BUFFER))
+            turnstileFrame.waitForSelector(selector, { timeout: FAST_TIMEOUTS.SELECTOR_WAIT }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Checkbox timeout')), FAST_TIMEOUTS.SELECTOR_WAIT + 500))
           ]);
           
-          await waitForTimeout(page, TIMEOUTS.ELEMENT_INTERACTION_DELAY);
+          await waitForTimeout(page, FAST_TIMEOUTS.ELEMENT_INTERACTION_DELAY);
           await turnstileFrame.click(selector);
           
           if (forceDebug) console.log(`[debug][cloudflare] Clicked Turnstile checkbox: ${selector}`);
@@ -705,11 +694,11 @@ async function handleTurnstileChallenge(page, forceDebug = false) {
       for (const selector of containerSelectors) {
         try {
           await Promise.race([
-            page.waitForSelector(selector, { timeout: TIMEOUTS.SELECTOR_WAIT }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Container timeout')), TIMEOUTS.SELECTOR_WAIT_BUFFER))
+            page.waitForSelector(selector, { timeout: FAST_TIMEOUTS.SELECTOR_WAIT }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Container timeout')), FAST_TIMEOUTS.SELECTOR_WAIT + 500))
           ]);
           
-          await waitForTimeout(page, TIMEOUTS.ELEMENT_INTERACTION_DELAY);
+          await waitForTimeout(page, FAST_TIMEOUTS.ELEMENT_INTERACTION_DELAY);
           await page.click(selector);
           
           if (forceDebug) console.log(`[debug][cloudflare] Clicked Turnstile container: ${selector}`);
@@ -761,8 +750,8 @@ async function handleLegacyCheckbox(page, forceDebug = false) {
     for (const selector of legacySelectors) {
       try {
         await Promise.race([
-          page.waitForSelector(selector, { timeout: TIMEOUTS.SELECTOR_WAIT }),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Legacy selector timeout')), TIMEOUTS.SELECTOR_WAIT_BUFFER))
+          page.waitForSelector(selector, { timeout: FAST_TIMEOUTS.SELECTOR_WAIT }),
+          new Promise((_, reject) => setTimeout(() => reject(new Error('Legacy selector timeout')), FAST_TIMEOUTS.SELECTOR_WAIT + 500))
         ]);
         
         const checkbox = await page.$(selector);
@@ -814,7 +803,7 @@ async function checkChallengeCompletion(page) {
       return (noChallengeRunning && noChallengeContainer && noChallengePage) ||
              hasClearanceCookie ||
              hasTurnstileResponse;
-    }, TIMEOUTS.CHALLENGE_COMPLETION);
+    }, FAST_TIMEOUTS.CHALLENGE_COMPLETION);
     
     return { isCompleted };
   } catch (error) {

package/lib/flowproxy.js

@@ -17,15 +17,24 @@ const FLOWPROXY_MODULE_VERSION = '1.0.0';
 
 /**
  * Timeout constants for FlowProxy operations (in milliseconds)
+ * Optimized for Puppeteer 22.x performance while maintaining FlowProxy compatibility
  */
 const TIMEOUTS = {
+  PAGE_EVALUATION_SAFE: 10000,    // Safe page evaluation timeout
+  // FlowProxy-specific timeouts
   PAGE_LOAD_WAIT: 2000,           // Initial wait for page to load
   JS_CHALLENGE_DEFAULT: 15000,    // Default JavaScript challenge timeout
   RATE_LIMIT_DEFAULT: 30000,      // Default rate limit delay
   ADDITIONAL_DELAY_DEFAULT: 5000, // Default additional processing delay
   PAGE_TIMEOUT_DEFAULT: 45000,    // Default page timeout
   NAVIGATION_TIMEOUT_DEFAULT: 45000, // Default navigation timeout
-  FALLBACK_TIMEOUT: 5000          // Fallback timeout for failed operations
+};
+
+// Fast timeout constants - optimized for speed while respecting FlowProxy delays
+const FAST_TIMEOUTS = {
+  PAGE_LOAD_WAIT: 1500,           // Reduced from 2000ms
+  ADDITIONAL_DELAY_DEFAULT: 3000, // Reduced from 5000ms
+  FALLBACK_TIMEOUT: 3000          // Reduced from 5000ms
 };
 
 /**
@@ -93,35 +102,39 @@ function shouldProcessUrl(url, forceDebug = false) {
 }
 
 /**
- * Cross-version compatible timeout function for Puppeteer with timeout protection
- * Handles different Puppeteer versions that may have different timeout methods
+ * Fast timeout helper for Puppeteer 22.x compatibility 
+ * Replaces deprecated page.waitForTimeout() with standard Promise-based approach
  * 
  * @param {import('puppeteer').Page} page - Puppeteer page instance
  * @param {number} timeout - Timeout in milliseconds
  * @returns {Promise<void>}
- * 
- * @example
- * // Wait for 5 seconds
- * await waitForTimeout(page, 5000);
  */
 async function waitForTimeout(page, timeout) {
+  // Use fast Promise-based timeout for Puppeteer 22.x compatibility
+  return new Promise(resolve => setTimeout(resolve, timeout));
+}
+
+/**
+ * Safe page evaluation with timeout protection for FlowProxy analysis
+ */
+async function safePageEvaluate(page, func, timeout = TIMEOUTS.PAGE_EVALUATION_SAFE) {
   try {
-    // Try newer Puppeteer method first (v1.4.0+)
-    if (typeof page.waitForTimeout === 'function') {
-      await page.waitForTimeout(timeout);
-    } else if (typeof page.waitFor === 'function') {
-      // Fallback for older Puppeteer versions
-      await page.waitFor(timeout);
-    } else {
-      // Final fallback - use standard setTimeout
-      await new Promise(resolve => setTimeout(resolve, timeout));
-    }
+    return await Promise.race([
+      page.evaluate(func),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('FlowProxy page evaluation timeout')), timeout)
+      )
+    ]);
   } catch (error) {
-    // If all else fails, use setTimeout
-    await new Promise(resolve => setTimeout(resolve, timeout));
+    // Return safe defaults if evaluation fails
+    return {
+      isFlowProxyDetected: false,
+      error: error.message
+    };
   }
 }
 
+
 /**
  * Analyzes the current page to detect flowProxy protection with comprehensive detection logic
  * 
@@ -158,7 +171,7 @@ async function analyzeFlowProxyProtection(page) {
     }
 
     // Continue with comprehensive FlowProxy detection for valid HTTP(S) URLs
-    return await page.evaluate(() => {
+    return await safePageEvaluate(page, () => {
       const title = document.title || '';
       const bodyText = document.body ? document.body.textContent : '';
       const url = window.location.href;
@@ -327,7 +340,7 @@ async function handleFlowProxyProtection(page, currentUrl, siteConfig, forceDebu
     
     // Wait for initial page load before analyzing
     // FlowProxy protection pages need time to fully render their elements
-    await waitForTimeout(page, TIMEOUTS.PAGE_LOAD_WAIT);
+    await waitForTimeout(page, FAST_TIMEOUTS.PAGE_LOAD_WAIT);
 
     // Perform comprehensive FlowProxy detection
     const detectionInfo = await analyzeFlowProxyProtection(page);
@@ -371,7 +384,8 @@ async function handleFlowProxyProtection(page, currentUrl, siteConfig, forceDebu
         try {
           // Wait for challenge completion indicators to disappear
           // These conditions indicate the JS challenge has finished
-          await page.waitForFunction(
+          await Promise.race([
+            page.waitForFunction(
             () => {
               const bodyText = document.body ? document.body.textContent : '';
               return !bodyText.includes('Processing') && 
@@ -381,7 +395,11 @@ async function handleFlowProxyProtection(page, currentUrl, siteConfig, forceDebu
                      !document.querySelector('.processing-indicator');
             },
             { timeout: jsWaitTime }
-          );
+            ),
+            new Promise((_, reject) => 
+              setTimeout(() => reject(new Error('JS challenge timeout')), jsWaitTime + 5000)
+            )
+          ]);
           
           if (forceDebug) console.log(`[debug][flowproxy] JavaScript challenge appears to have completed`);
         } catch (timeoutErr) {
@@ -393,7 +411,7 @@ async function handleFlowProxyProtection(page, currentUrl, siteConfig, forceDebu
 
       // IMPLEMENT ADDITIONAL DELAY - Final step to ensure all processing completes
       // FlowProxy may need extra time even after challenges complete
-      const additionalDelay = siteConfig.flowproxy_additional_delay || TIMEOUTS.ADDITIONAL_DELAY_DEFAULT;
+      const additionalDelay = siteConfig.flowproxy_additional_delay || FAST_TIMEOUTS.ADDITIONAL_DELAY_DEFAULT;
       if (forceDebug) console.log(`[debug][flowproxy] Implementing additional ${additionalDelay}ms delay for flowProxy processing`);
       await waitForTimeout(page, additionalDelay);
 

package/lib/interaction.js

@@ -53,6 +53,12 @@
  * @version 1.0
  * @requires puppeteer
  */
+ 
+// Fast setTimeout helper for Puppeteer 22.x compatibility
+// Uses standard Promise constructor for better performance than node:timers/promises
+function fastTimeout(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
 
 // === VIEWPORT AND COORDINATE CONSTANTS ===
 // These control the default viewport assumptions and coordinate generation
@@ -336,7 +342,7 @@ async function humanLikeMouseMove(page, fromX, fromY, toX, toY, options = {}) {
     // Variable delay between movements
     if (i < actualSteps) {
       const delay = Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
-      await new Promise(resolve => setTimeout(resolve, delay));
+      await fastTimeout(delay);
     }
   }
 }
@@ -396,7 +402,7 @@ async function simulateScrolling(page, options = {}) {
       }
       
       if (i < amount - 1) {
-        await new Promise(resolve => setTimeout(resolve, pauseBetween));
+        await fastTimeout(pauseBetween);
       }
     }
   } catch (scrollErr) {
@@ -514,12 +520,12 @@ async function interactWithElements(page, options = {}) {
           await humanLikeMouseMove(page, currentPos.x, currentPos.y, element.x, element.y);
           
           // Brief pause before clicking
-          await new Promise(resolve => setTimeout(resolve, TIMING.CLICK_PAUSE_MIN + Math.random() * TIMING.CLICK_PAUSE_MAX));
+          await fastTimeout(TIMING.CLICK_PAUSE_MIN + Math.random() * TIMING.CLICK_PAUSE_MAX);
           
           await page.mouse.click(element.x, element.y);
           
           // Brief pause after clicking
-          await new Promise(resolve => setTimeout(resolve, TIMING.POST_CLICK_MIN + Math.random() * TIMING.POST_CLICK_MAX));
+          await fastTimeout(TIMING.POST_CLICK_MIN + Math.random() * TIMING.POST_CLICK_MAX);
         }
       } catch (elementErr) {
         // Continue to next attempt if this one fails
@@ -590,16 +596,16 @@ async function simulateTyping(page, text, options = {}) {
       if (mistakes && Math.random() < mistakeRate) {
         const wrongChar = String.fromCharCode(97 + Math.floor(Math.random() * 26));
         await page.keyboard.type(wrongChar);
-        await new Promise(resolve => setTimeout(resolve, TIMING.MISTAKE_PAUSE_MIN + Math.random() * TIMING.MISTAKE_PAUSE_MAX));
+        await fastTimeout(TIMING.MISTAKE_PAUSE_MIN + Math.random() * TIMING.MISTAKE_PAUSE_MAX);
         await page.keyboard.press('Backspace');
-        await new Promise(resolve => setTimeout(resolve, TIMING.BACKSPACE_DELAY_MIN + Math.random() * TIMING.BACKSPACE_DELAY_MAX));
+        await fastTimeout(TIMING.BACKSPACE_DELAY_MIN + Math.random() * TIMING.BACKSPACE_DELAY_MAX);
       }
       
       await page.keyboard.type(char);
       
       // Variable delay between keystrokes
       const delay = Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
-      await new Promise(resolve => setTimeout(resolve, delay));
+      await fastTimeout(delay);
     }
   } catch (typingErr) {
     // Silently handle typing errors
@@ -715,11 +721,11 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
 
       // Occasional pause
       if (Math.random() < PROBABILITIES.PAUSE_CHANCE) {
-        await new Promise(resolve => setTimeout(resolve, TIMING.CLICK_PAUSE_MIN + Math.random() * TIMING.POST_CLICK_MIN));
+        await fastTimeout(TIMING.CLICK_PAUSE_MIN + Math.random() * TIMING.POST_CLICK_MIN);
       }
 
       // Time-based spacing
-      await new Promise(resolve => setTimeout(resolve, actionInterval));
+      await fastTimeout(actionInterval);
     }
 
     // Scrolling simulation
@@ -732,7 +738,7 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
           smoothness: 3 + Math.floor(Math.random() * 4)
         });
         
-        await new Promise(resolve => setTimeout(resolve, actionInterval));
+        await fastTimeout(actionInterval);
       }
     }
 

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v1.0.60 ===
+// === Network scanner script (nwss.js) v1.0.61 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -35,13 +35,20 @@ const { performPageInteraction, createInteractionConfig } = require('./lib/inter
 const { createGlobalHelpers, getTotalDomainsSkipped, getDetectedDomainsCount } = require('./lib/domain-cache');
 const { createSmartCache } = require('./lib/smart-cache'); // Smart cache system
 const { clearPersistentCache } = require('./lib/smart-cache');
+
+// Fast setTimeout helper for Puppeteer 22.x compatibility
+// Uses standard Promise constructor for better performance than node:timers/promises
+function fastTimeout(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
 // Enhanced redirect handling
 const { navigateWithRedirectHandling, handleRedirectTimeout } = require('./lib/redirect');
 // Ensure web browser is working correctly
 const { monitorBrowserHealth, isBrowserHealthy } = require('./lib/browserhealth');
 
-// --- Script Configuration & Constants ---
-const VERSION = '1.0.60'; // Script version
+// --- Script Configuration & Constants --- 
+const VERSION = '1.0.61'; // Script version
 
 // get startTime
 const startTime = Date.now();
@@ -382,7 +389,7 @@ Global config.json options:
   ignore_similar: true/false                      Ignore domains similar to already found domains (default: true)
   ignore_similar_threshold: 80                    Similarity threshold percentage for ignore_similar (default: 80)
   ignore_similar_ignored_domains: true/false      Ignore domains similar to ignoreDomains list (default: true)
-  max_concurrent_sites: 6                        Maximum concurrent site processing (1-50, default: 6)
+  max_concurrent_sites: 8                        Maximum concurrent site processing (1-50, default: 8)
   resource_cleanup_interval: 180                  Browser restart interval in URLs processed (1-1000, default: 180)
 
 Per-site config.json options:
@@ -1040,6 +1047,11 @@ function setupFrameHandling(page, forceDebug) {
       executablePath: executablePath,
       // Force temporary user data directory for complete cleanup control
       userDataDir: tempUserDataDir,
+      // Puppeteer 22.x headless mode optimization
+      // 'shell' = chrome-headless-shell (performance optimized)
+      // true = new unified headless mode (full Chrome features)
+      // false = headful mode (GUI visible)
+      headless: launchHeadless ? 'shell' : false, // Use shell for maximum performance
       args: [
         // Disk space controls - 50MB cache limits
         '--disk-cache-size=52428800', // 50MB disk cache (50 * 1024 * 1024)
@@ -1047,6 +1059,17 @@ function setupFrameHandling(page, forceDebug) {
         '--disable-application-cache',
         '--disable-offline-load-stale-cache',
         '--disable-background-downloads',
+        // PERFORMANCE: Additional Puppeteer 22.x optimizations
+        '--disable-features=VizDisplayCompositor,AudioServiceOutOfProcess',
+        '--disable-ipc-flooding-protection',
+        '--disable-renderer-backgrounding',
+        '--disable-backgrounding-occluded-windows',
+        '--disable-features=TranslateUI,BlinkGenPropertyTrees',
+        '--disable-features=Translate,BackForwardCache,AcceptCHFrame',
+        '--aggressive-cache-discard',
+        '--memory-pressure-off',
+        '--max_old_space_size=2048',
+        '--disable-features=VizDisplayCompositor',
         '--no-first-run',
         '--disable-default-apps',
         '--disable-component-extensions-with-background-pages',
@@ -1070,18 +1093,13 @@ function setupFrameHandling(page, forceDebug) {
         '--ignore-certificate-errors-ca-list',
         '--disable-web-security',
         '--allow-running-insecure-content',
-	    '--disable-background-timer-throttling',
-	    '--disable-backgrounding-occluded-windows',
-	    '--disable-renderer-backgrounding',
-	    '--disable-features=TranslateUI',
-	    '--disable-features=VizDisplayCompositor',
-	    '--run-all-compositor-stages-before-draw',
-	    '--disable-threaded-animation',
-	    '--disable-threaded-scrolling',
-	    '--disable-checker-imaging',
-	    '--disable-image-animation-resync'
+        '--disable-features=HttpsFirstBalancedModeAutoEnable',
+        '--run-all-compositor-stages-before-draw',
+        '--disable-threaded-animation',
+        '--disable-threaded-scrolling',
+        '--disable-checker-imaging',
+        '--disable-image-animation-resync'
         ],
-        headless: launchHeadless ? 'shell' : false,
         protocolTimeout: 60000  // 60 seconds
     });
     
@@ -1251,9 +1269,9 @@ function setupFrameHandling(page, forceDebug) {
       page = await browserInstance.newPage();
       
       // Set aggressive timeouts for problematic operations
-      page.setDefaultTimeout(Math.min(timeout, 20000));  // Use site timeout or 20s max
-      page.setDefaultNavigationTimeout(Math.min(timeout, 25000));  // Use site timeout or 25s max
-      // Note: timeout variable from siteConfig.timeout || 30000 is overridden for stability
+      page.setDefaultTimeout(Math.min(timeout, 15000));  // Reduced for Puppeteer 22.x
+      page.setDefaultNavigationTimeout(Math.min(timeout, 18000));  // Reduced for faster fails
+      // Aggressive timeouts prevent hanging in Puppeteer 22.x
       
       page.on('console', (msg) => {
         if (forceDebug && msg.type() === 'error') console.log(`[debug] Console error: ${msg.text()}`);
@@ -1268,8 +1286,8 @@ function setupFrameHandling(page, forceDebug) {
       // Apply flowProxy timeouts if detection is enabled
       if (flowproxyDetection) {
         const flowproxyTimeouts = getFlowProxyTimeouts(siteConfig);
-        page.setDefaultTimeout(flowproxyTimeouts.pageTimeout);
-        page.setDefaultNavigationTimeout(flowproxyTimeouts.navigationTimeout);
+        page.setDefaultTimeout(Math.min(flowproxyTimeouts.pageTimeout, 25000));
+        page.setDefaultNavigationTimeout(Math.min(flowproxyTimeouts.navigationTimeout, 30000));
         if (forceDebug) {
           console.log(formatLogMessage('debug', `Applied flowProxy timeouts - page: ${flowproxyTimeouts.pageTimeout}ms, nav: ${flowproxyTimeouts.navigationTimeout}ms`));
         }
@@ -2077,21 +2095,23 @@ function setupFrameHandling(page, forceDebug) {
 
       try {
         // Use custom goto options if provided, otherwise default to 'load'
-		// load                  Wait for all resources (default)
-		// domcontentloaded      Wait for DOM only
-		// networkidle0          Wait until 0 network requests for 500ms
-		// networkidle2          Wait until ≤2 network requests for 500ms
+        // load                  Wait for all resources (default)
+        // domcontentloaded      Wait for DOM only
+        // networkidle0          Wait until 0 network requests for 500ms
+        // networkidle2          Wait until ≤2 network requests for 500ms
+        
+        // Note: For Puppeteer 22.x compatibility, avoid deprecated timeout patterns
+        // Use explicit Promise-based timeouts instead of page.waitForTimeout()
 
         // Use faster defaults for sites with long timeouts to improve responsiveness
         const isFastSite = timeout <= 15000;
-        const defaultWaitUntil = isFastSite ? 'load' : 'domcontentloaded';
+        const defaultWaitUntil = 'domcontentloaded'; // Always use faster option in Puppeteer 22.x
         const defaultGotoOptions = {
           waitUntil: defaultWaitUntil,
-          timeout: timeout
+          timeout: Math.min(timeout, 20000) // Cap timeout for faster failures
         };
         const gotoOptions = siteConfig.goto_options 
-          ? { ...defaultGotoOptions, ...siteConfig.goto_options }
-          : defaultGotoOptions;
+          ? { ...defaultGotoOptions, ...siteConfig.goto_options } : defaultGotoOptions;
 
         // Enhanced navigation with redirect handling - passes existing gotoOptions
         const navigationResult = await navigateWithRedirectHandling(page, currentUrl, siteConfig, gotoOptions, forceDebug, formatLogMessage);
@@ -2171,7 +2191,8 @@ function setupFrameHandling(page, forceDebug) {
         // Wait for iframes to load and log them
         if (forceDebug) {
           try {
-            await new Promise(resolve => setTimeout(resolve, 2000)); // Give iframes time to load
+            // Use fast timeout helper for compatibility  
+            await fastTimeout(2000); // Give iframes time to load
             const frames = page.frames();
             console.log(formatLogMessage('debug', `Total frames found: ${frames.length}`));
             frames.forEach((frame, index) => {
@@ -2214,25 +2235,29 @@ function setupFrameHandling(page, forceDebug) {
 
       const delayMs = siteConfig.delay || 4000;
       
-      // Optimize network idle and delay times for better responsiveness
+      // Aggressive optimization for Puppeteer 22.x responsiveness
       const isFastSite = timeout <= 15000;
-      const networkIdleTime = isFastSite ? 4000 : 2000;  // Faster idle for slow sites
-      const networkIdleTimeout = isFastSite ? timeout : Math.min(timeout / 2, 12000);
-      const actualDelay = isFastSite ? delayMs : Math.min(delayMs, 2000);  // Cap delay for slow sites
+      const networkIdleTime = 2000;  // Reduced for all sites
+      const networkIdleTimeout = Math.min(timeout / 2, 8000);  // Much shorter timeout
+      const actualDelay = Math.min(delayMs, 1500);  // Reduced delay for all sites
       
       await page.waitForNetworkIdle({ 
         idleTime: networkIdleTime, 
         timeout: networkIdleTimeout 
       });
-      await new Promise(resolve => setTimeout(resolve, actualDelay));
+      // Use fast timeout helper for Puppeteer 22.x compatibility with better performance
+      await fastTimeout(actualDelay);
 
       // Apply additional delay for flowProxy if detected
       if (flowproxyDetection) {
-        const additionalDelay = siteConfig.flowproxy_additional_delay || 5000;
+        const additionalDelay = Math.min(siteConfig.flowproxy_additional_delay || 3000, 3000);
         if (forceDebug) console.log(formatLogMessage('debug', `Applying flowProxy additional delay: ${additionalDelay}ms`));
-        await new Promise(resolve => setTimeout(resolve, additionalDelay));
+        await fastTimeout(additionalDelay);
       }
 
+      // Replace deprecated page.waitForTimeout patterns with fast timeout helper
+      // This ensures compatibility with Puppeteer 22.x where waitForTimeout was removed
+
       for (let i = 1; i < (siteConfig.reload || 1); i++) {
        if (siteConfig.clear_sitedata === true) {
          try {
@@ -2256,16 +2281,16 @@ function setupFrameHandling(page, forceDebug) {
            console.warn(messageColors.warn(`[clear_sitedata before reload failed] ${currentUrl}: ${reloadClearErr.message}`));
          }
        }
-        await page.reload({ waitUntil: 'domcontentloaded', timeout: timeout });
-        await new Promise(resolve => setTimeout(resolve, delayMs));
+        await page.reload({ waitUntil: 'domcontentloaded', timeout: Math.min(timeout, 15000) });
+        await fastTimeout(delayMs);
       }
 
       if (siteConfig.forcereload === true) {
         if (forceDebug) console.log(formatLogMessage('debug', `Forcing extra reload (cache disabled) for ${currentUrl}`));
         try {
           await page.setCacheEnabled(false);
-          await page.reload({ waitUntil: 'domcontentloaded', timeout: timeout });
-          await new Promise(resolve => setTimeout(resolve, delayMs));
+          await page.reload({ waitUntil: 'domcontentloaded', timeout: Math.min(timeout, 12000) });
+          await fastTimeout(delayMs);
           await page.setCacheEnabled(true);
         } catch (forceReloadErr) {
           console.warn(messageColors.warn(`[forcereload failed] ${currentUrl}: ${forceReloadErr.message}`));
@@ -2299,7 +2324,8 @@ function setupFrameHandling(page, forceDebug) {
         });
         
         // Wait a moment for async nettools/searchstring operations to complete
-        await new Promise(resolve => setTimeout(resolve, 3000)); // Increased for nettools operations
+        // Use fast timeout helper for Puppeteer 22.x compatibility
+        await fastTimeout(3000); // Increased for nettools operations
         
         outputDryRunResults(currentUrl, enhancedMatches, dryRunNetTools, pageTitle);
         
@@ -2451,12 +2477,12 @@ function setupFrameHandling(page, forceDebug) {
     // Also check if browser was unhealthy during recent processing
     const recentResults = results.slice(-3);
     const hasRecentFailures = recentResults.filter(r => !r.success).length >= 2;
-    const shouldRestartFromFailures = hasRecentFailures && urlsSinceLastCleanup > 5;
+    const shouldRestartFromFailures = hasRecentFailures && urlsSinceLastCleanup > 3; // More aggressive restart
 
     const siteUrlCount = siteGroup.urls.length;
     
     // Check if processing this entire site would exceed cleanup interval OR health check suggests restart
-    const wouldExceedLimit = urlsSinceLastCleanup + siteUrlCount >= RESOURCE_CLEANUP_INTERVAL;
+    const wouldExceedLimit = urlsSinceLastCleanup + siteUrlCount >= Math.min(RESOURCE_CLEANUP_INTERVAL, 100); // More frequent restarts
     const isNotLastSite = siteIndex < siteGroups.length - 1;
     
     // Restart browser if we've processed enough URLs, health check suggests it, and this isn't the last site
@@ -2509,7 +2535,7 @@ function setupFrameHandling(page, forceDebug) {
       
       // Reset cleanup counter and add delay
       urlsSinceLastCleanup = 0;
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await fastTimeout(1000);
     }
     
     if (forceDebug) {
@@ -2547,7 +2573,7 @@ function setupFrameHandling(page, forceDebug) {
         }
         browser = await createBrowser();
         urlsSinceLastCleanup = 0; // Reset counter
-        await new Promise(resolve => setTimeout(resolve, 2000)); // Give browser time to stabilize
+        await fastTimeout(2000); // Give browser time to stabilize
       } catch (emergencyRestartErr) {
         if (forceDebug) console.log(formatLogMessage('debug', `Emergency restart failed: ${emergencyRestartErr.message}`));
       }
@@ -2704,7 +2730,7 @@ function setupFrameHandling(page, forceDebug) {
     forceDebug,
     comprehensive: true 
   });
-  await new Promise(resolve => setTimeout(resolve, 1000)); // Give filesystem time to sync
+  await fastTimeout(1000); // Give filesystem time to sync
 
   // Calculate timing, success rates, and provide summary information
   if (forceDebug) console.log(formatLogMessage('debug', `Calculating timing statistics...`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "1.0.59",
+  "version": "1.0.61",
   "description": "A Puppeteer-based network scanner for analyzing web traffic, generating adblock filter rules, and identifying third-party requests. Features include fingerprint spoofing, Cloudflare bypass, content analysis with curl/grep, and multiple output formats.",
   "main": "nwss.js",
   "scripts": {
@@ -13,7 +13,7 @@
     "lru-cache": "^10.4.3",
     "p-limit": "^4.0.0",
     "psl": "^1.15.0",
-    "puppeteer": "^23.11.1"
+    "puppeteer": ">=20.0.0 <23.0.0"
   },
   "keywords": [
     "puppeteer",