@fanboynz/network-scanner 2.0.25 → 2.0.27

package/README.md

@@ -223,7 +223,7 @@ When a page redirects to a new domain, first-party/third-party detection is base
 | `whois_timeout_multiplier` | Number | `1.5` | Timeout increase multiplier per retry |
 | `whois_use_fallback` | Boolean | `true` | Add TLD-specific fallback servers |
 | `whois_retry_on_timeout` | Boolean | `true` | Retry on timeout errors |
-| `whois_retry_on_error` | Boolean | `false` | Retry on connection/other errors |
+| `whois_retry_on_error` | Boolean | `true` | Retry on connection/other errors |
 | `dig`                | Array | - | Check dig output for ALL specified terms (AND logic) |
 | `dig-or`             | Array | - | Check dig output for ANY specified term (OR logic) |
 | `dig_subdomain`      | Boolean | `false` | Use subdomain for dig lookup instead of root domain |

package/lib/fingerprint.js

@@ -59,7 +59,7 @@ const PRECOMPILED_MOCKS = Object.freeze({
       postMessage: () => {},
       disconnect: () => {}
     }),
-    getManifest: () => Object.freeze({ name: "Chrome", version: "140.0.0.0" }),
+    getManifest: () => Object.freeze({ name: "Chrome", version: "141.0.0.0" }),
     getURL: (path) => `chrome-extension://invalid/${path}`,
     id: undefined
   }),
@@ -91,9 +91,9 @@ const BUILT_IN_PROPERTIES = new Set([
 // User agent collections with latest versions
 const USER_AGENT_COLLECTIONS = {
   chrome: [
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36"
   ],
   firefox: [
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:143.0) Gecko/20100101 Firefox/143.0",
@@ -535,7 +535,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
                 onMessage: { addListener: () => {}, removeListener: () => {} },
                 sendMessage: () => {},
                 connect: () => ({ onMessage: { addListener: () => {}, removeListener: () => {} }, postMessage: () => {}, disconnect: () => {} }),
-                getManifest: () => ({ name: "Chrome", version: "140.0.0.0" }),
+                getManifest: () => ({ name: "Chrome", version: "141.0.0.0" }),
                 getURL: (path) => `chrome-extension://invalid/${path}`,
                 id: undefined
               },

package/lib/nettools.js

@@ -357,7 +357,7 @@ async function whoisLookup(domain, timeout = 10000, whoisServer = null, debugMod
  * @param {number} whoisDelay - Delay in milliseconds before whois requests (default: 2000)
  * @returns {Promise<Object>} Object with success status and output/error
  */
-async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null, debugMode = false, retryOptions = {}, whoisDelay = 4000, logFunc = null) {
+async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null, debugMode = false, retryOptions = {}, whoisDelay = 8000, logFunc = null) {
   const {
     maxRetries = 3,
     timeoutMultiplier = 1.5,
@@ -367,7 +367,6 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
   } = retryOptions;
 
   let serversToTry = [];
-  let currentTimeout = timeout;
   
   // Build list of servers to try
   if (whoisServer) {
@@ -390,88 +389,124 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
   }
   
   let lastError = null;
-  let attemptCount = 0;
+  let totalAttempts = 0;
+  let serversAttempted = [];
   
   if (debugMode) {
     if (logFunc) {
       logFunc(`${messageColors.highlight('[whois-retry]')} Starting whois lookup for ${domain} with ${serversToTry.length} server(s) to try`);
       logFunc(`${messageColors.highlight('[whois-retry]')} Servers: [${serversToTry.map(s => s || 'default').join(', ')}]`);
-      logFunc(`${messageColors.highlight('[whois-retry]')} Retry settings: maxRetries=${maxRetries}, timeoutMultiplier=${timeoutMultiplier}, retryOnTimeout=${retryOnTimeout}, retryOnError=${retryOnError}`);
+      logFunc(`${messageColors.highlight('[whois-retry]')} Retry settings: maxRetries=${maxRetries} per server, timeoutMultiplier=${timeoutMultiplier}, retryOnTimeout=${retryOnTimeout}, retryOnError=${retryOnError}`);
     } else {
       console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Starting whois lookup for ${domain} with ${serversToTry.length} server(s) to try`));
       console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Servers: [${serversToTry.map(s => s || 'default').join(', ')}]`));
-      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Retry settings: maxRetries=${maxRetries}, timeoutMultiplier=${timeoutMultiplier}, retryOnTimeout=${retryOnTimeout}, retryOnError=${retryOnError}`));
+      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Retry settings: maxRetries=${maxRetries} per server, timeoutMultiplier=${timeoutMultiplier}, retryOnTimeout=${retryOnTimeout}, retryOnError=${retryOnError}`));
     }
   }
   
-  for (const server of serversToTry) {
-    attemptCount++;
+  // Try each server with retry logic
+  for (let serverIndex = 0; serverIndex < serversToTry.length; serverIndex++) {
+    const server = serversToTry[serverIndex];
+    let currentTimeout = timeout;
+    let retryCount = 0;
+    serversAttempted.push(server);
     
     if (debugMode) {
       const serverName = server || 'default';
       if (logFunc) {
-        logFunc(`${messageColors.highlight('[whois-retry]')} Attempt ${attemptCount}/${serversToTry.length}: trying server ${serverName} (timeout: ${currentTimeout}ms)`);
+        logFunc(`${messageColors.highlight('[whois-retry]')} Server ${serverIndex + 1}/${serversToTry.length}: ${serverName} (max ${maxRetries} attempts)`);
       } else {
-        console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Attempt ${attemptCount}/${serversToTry.length}: trying server ${serverName} (timeout: ${currentTimeout}ms)`));
+        console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Server ${serverIndex + 1}/${serversToTry.length}: ${serverName} (max ${maxRetries} attempts)`));
       }
     }
     
-    // Add delay between retry attempts to prevent rate limiting
-    if (attemptCount > 1) {
-      if (whoisDelay > 0) {
-        if (debugMode) {
-          if (logFunc) {
-            logFunc(`${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay before retry attempt...`);
-          } else {
-            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay before retry attempt...`));
-          }
-        }
-        await new Promise(resolve => setTimeout(resolve, whoisDelay));
-      }
+    // Retry this server up to maxRetries times
+    while (retryCount < maxRetries) {
+      totalAttempts++;
+      const attemptNum = retryCount + 1;
       
-    } else if (whoisDelay > 0) {
-      // Add initial delay on first attempt if configured
       if (debugMode) {
+        const serverName = server || 'default';
         if (logFunc) {
-          logFunc(`${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay to prevent rate limiting...`);
+          logFunc(`${messageColors.highlight('[whois-retry]')} Attempt ${attemptNum}/${maxRetries} on server ${serverName} (timeout: ${currentTimeout}ms)`);
         } else {
-          console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay to prevent rate limiting...`));
+          console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Attempt ${attemptNum}/${maxRetries} on server ${serverName} (timeout: ${currentTimeout}ms)`));
         }
       }
-      await new Promise(resolve => setTimeout(resolve, whoisDelay));
-    } else if (debugMode) {
-      // Log when delay is skipped due to whoisDelay being 0
-      if (logFunc) {
-        logFunc(`${messageColors.highlight('[whois-retry]')} Skipping delay (whoisDelay: ${whoisDelay}ms)`);
-      } else {
-        console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Skipping delay (whoisDelay: ${whoisDelay}ms)`));
-      }
-   }
-    
-    try {
-      const result = await whoisLookup(domain, currentTimeout, server, debugMode, logFunc);
       
-      if (result.success) {
+      // Add progressive delay between retries (but not before first attempt on any server)
+      if (retryCount > 0 && whoisDelay > 0) {
+        // Progressive delay: base delay * retry attempt number + extra delay
+        // Attempt 2: base delay * 1 + 4000ms = 8000ms + 4000ms = 12000ms
+        // Attempt 3: base delay * 2 + 6000ms = 16000ms + 6000ms = 22000ms
+        // Attempt 4+: base delay * 3 + 6000ms = 24000ms + 6000ms = 30000ms (if maxRetries > 3)
+        const delayMultiplier = Math.min(retryCount, 3);
+        const baseDelay = whoisDelay * delayMultiplier;
+        
+        // Add extra delay based on retry attempt
+        let extraDelay = 0;
+        if (retryCount === 1) {
+          extraDelay = 4000; // Extra 4 seconds for 2nd attempt
+        } else if (retryCount >= 2) {
+          extraDelay = 6000; // Extra 6 seconds for 3rd+ attempts
+        }
+        
+        const actualDelay = baseDelay + extraDelay;
+        
+        if (debugMode) {
+          if (logFunc) {
+            logFunc(`${messageColors.highlight('[whois-retry]')} Adding ${actualDelay}ms progressive delay before retry ${retryCount + 1} (base: ${baseDelay}ms + extra: ${extraDelay}ms)...`);
+          } else {
+            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Adding ${actualDelay}ms progressive delay before retry ${retryCount + 1} (base: ${baseDelay}ms + extra: ${extraDelay}ms)...`));
+          }
+        }
+        await new Promise(resolve => setTimeout(resolve, actualDelay));
+      } else if (serverIndex > 0 && retryCount === 0 && whoisDelay > 0) {
+        // Add delay before trying a new server (but not the very first server)
         if (debugMode) {
           if (logFunc) {
-            logFunc(`${messageColors.highlight('[whois-retry]')} SUCCESS on attempt ${attemptCount}/${serversToTry.length} using server ${result.whoisServer || 'default'}`);
+            logFunc(`${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay before trying new server...`);
           } else {
-            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} SUCCESS on attempt ${attemptCount}/${serversToTry.length} using server ${result.whoisServer || 'default'}`));
+            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Adding ${whoisDelay}ms delay before trying new server...`));
           }
         }
+        await new Promise(resolve => setTimeout(resolve, whoisDelay));
+      } else if (debugMode && whoisDelay === 0) {
+        // Log when delay is skipped due to whoisDelay being 0
+        if (logFunc) {
+          logFunc(`${messageColors.highlight('[whois-retry]')} Skipping delay (whoisDelay: ${whoisDelay}ms)`);
+        } else {
+          console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Skipping delay (whoisDelay: ${whoisDelay}ms)`));
+        }
+      }
+      
+      try {
+        const result = await whoisLookup(domain, currentTimeout, server, debugMode, logFunc);
         
-        // Add retry info to result
-        return {
-          ...result,
-          retryInfo: {
-            totalAttempts: attemptCount,
-            maxAttempts: serversToTry.length,
-            serversAttempted: serversToTry.slice(0, attemptCount),
-            finalServer: result.whoisServer,
-            retriedAfterFailure: attemptCount > 1
+        if (result.success) {
+          if (debugMode) {
+            if (logFunc) {
+              logFunc(`${messageColors.highlight('[whois-retry]')} SUCCESS on attempt ${attemptNum}/${maxRetries} for server ${result.whoisServer || 'default'} (total attempts: ${totalAttempts})`);
+            } else {
+              console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} SUCCESS on attempt ${attemptNum}/${maxRetries} for server ${result.whoisServer || 'default'} (total attempts: ${totalAttempts})`));
+            }
           }
-        };
-      } else {
+          
+          // Add retry info to result
+          return {
+            ...result,
+            retryInfo: {
+              totalAttempts: totalAttempts,
+              maxAttempts: serversToTry.length * maxRetries,
+              serversAttempted: serversAttempted,
+              finalServer: result.whoisServer,
+              retriedAfterFailure: totalAttempts > 1,
+              serverRetries: retryCount,
+              serverIndex: serverIndex
+            }
+          };
+        }
+        
         // Determine if we should retry based on error type
         const shouldRetry = (result.isTimeout && retryOnTimeout) || (!result.isTimeout && retryOnError);
         
@@ -479,72 +514,85 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
           const serverName = result.whoisServer || 'default';
           const errorType = result.isTimeout ? 'TIMEOUT' : 'ERROR';
           if (logFunc) {
-            logFunc(`${messageColors.highlight('[whois-retry]')} ${errorType} on attempt ${attemptCount}/${serversToTry.length} with server ${serverName}: ${result.error}`);
+            logFunc(`${messageColors.highlight('[whois-retry]')} ${errorType} on attempt ${attemptNum}/${maxRetries} with server ${serverName}: ${result.error}`);
           } else {
-            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} ${errorType} on attempt ${attemptCount}/${serversToTry.length} with server ${serverName}: ${result.error}`));
+            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} ${errorType} on attempt ${attemptNum}/${maxRetries} with server ${serverName}: ${result.error}`));
           }
           
-          if (attemptCount < serversToTry.length) {
+          if (retryCount < maxRetries - 1) {
             if (shouldRetry) {
               if (logFunc) {
-                logFunc(`${messageColors.highlight('[whois-retry]')} Will retry with next server...`);
+                logFunc(`${messageColors.highlight('[whois-retry]')} Will retry attempt ${attemptNum + 1}/${maxRetries} on same server...`);
               } else {
-                console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Will retry with next server...`));
+                console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Will retry attempt ${attemptNum + 1}/${maxRetries} on same server...`));
               }
             } else {
               if (logFunc) {
-                logFunc(`${messageColors.highlight('[whois-retry]')} Skipping retry (retryOn${result.isTimeout ? 'Timeout' : 'Error'}=${shouldRetry})`);
+                logFunc(`${messageColors.highlight('[whois-retry]')} Skipping retry on same server (retryOn${result.isTimeout ? 'Timeout' : 'Error'}=${shouldRetry})`);
               } else {
-                console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Skipping retry (retryOn${result.isTimeout ? 'Timeout' : 'Error'}=${shouldRetry})`));
+                console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Skipping retry on same server (retryOn${result.isTimeout ? 'Timeout' : 'Error'}=${shouldRetry})`));
               }
             }
+          } else if (serverIndex < serversToTry.length - 1) {
+            if (logFunc) {
+              logFunc(`${messageColors.highlight('[whois-retry]')} Max retries reached for server, will try next server...`);
+            } else {
+              console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} Max retries reached for server, will try next server...`));
+            }
           }
         }
         
         lastError = result;
         
-        // If this is the last server or we shouldn't retry this error type, break
-        if (attemptCount >= serversToTry.length || !shouldRetry) {
+        // If this is the last retry for this server or we shouldn't retry this error type, break to next server
+        if (retryCount >= maxRetries - 1 || !shouldRetry) {
           break;
         }
         
-        // Increase timeout for next attempt
+        // Increase timeout for next retry attempt on same server
+        retryCount++;
         currentTimeout = Math.round(currentTimeout * timeoutMultiplier);
-      }
-    } catch (error) {
-      if (debugMode) {
-        const serverName = server || 'default';
-        if (logFunc) {
-          logFunc(`${messageColors.highlight('[whois-retry]')} EXCEPTION on attempt ${attemptCount}/${serversToTry.length} with server ${serverName}: ${error.message}`);
-        } else {
-          console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} EXCEPTION on attempt ${attemptCount}/${serversToTry.length} with server ${serverName}: ${error.message}`));
+        
+      } catch (error) {
+        if (debugMode) {
+          const serverName = server || 'default';
+          if (logFunc) {
+            logFunc(`${messageColors.highlight('[whois-retry]')} EXCEPTION on attempt ${attemptNum}/${maxRetries} with server ${serverName}: ${error.message}`);
+          } else {
+            console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} EXCEPTION on attempt ${attemptNum}/${maxRetries} with server ${serverName}: ${error.message}`));
+          }
         }
+        
+        lastError = {
+          success: false,
+          error: error.message,
+          domain: domain,
+          whoisServer: server,
+          isTimeout: error.message.includes('timeout'),
+          duration: 0
+        };
+        
+        // For exceptions, only retry if it's a retryable error type
+        const isRetryableException = error.message.includes('timeout') || 
+                                   error.message.includes('ECONNRESET') || 
+                                   error.message.includes('ENOTFOUND');
+        
+        if (retryCount >= maxRetries - 1 || !isRetryableException) {
+          break;
+        }
+        
+        retryCount++;
+        currentTimeout = Math.round(currentTimeout * timeoutMultiplier);
       }
-      
-      lastError = {
-        success: false,
-        error: error.message,
-        domain: domain,
-        whoisServer: server,
-        isTimeout: error.message.includes('timeout'),
-        duration: 0
-      };
-      
-      // Continue to next server unless this is the last one
-      if (attemptCount >= serversToTry.length) {
-        break;
-      }
-      
-      currentTimeout = Math.round(currentTimeout * timeoutMultiplier);
     }
   }
   
   // All attempts failed
   if (debugMode) {
     if (logFunc) {
-      logFunc(`${messageColors.highlight('[whois-retry]')} FINAL FAILURE: All ${attemptCount} attempts failed for ${domain}`);
+      logFunc(`${messageColors.highlight('[whois-retry]')} FINAL FAILURE: All ${totalAttempts} attempts failed for ${domain} across ${serversAttempted.length} server(s)`);
     } else {
-      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} FINAL FAILURE: All ${attemptCount} attempts failed for ${domain}`));
+      console.log(formatLogMessage('debug', `${messageColors.highlight('[whois-retry]')} FINAL FAILURE: All ${totalAttempts} attempts failed for ${domain} across ${serversAttempted.length} server(s)`));
     }
     if (lastError) {
       if (logFunc) {
@@ -559,11 +607,11 @@ async function whoisLookupWithRetry(domain, timeout = 10000, whoisServer = null,
   return {
     ...lastError,
     retryInfo: {
-      totalAttempts: attemptCount,
-      maxAttempts: serversToTry.length,
-      serversAttempted: serversToTry.slice(0, attemptCount),
+      totalAttempts: totalAttempts,
+      maxAttempts: serversToTry.length * maxRetries,
+      serversAttempted: serversAttempted,
       finalServer: lastError?.whoisServer || null,
-      retriedAfterFailure: attemptCount > 1,
+      retriedAfterFailure: totalAttempts > 1,
       allAttemptsFailed: true
     }
   };
@@ -1357,4 +1405,4 @@ module.exports = {
   getCommonWhoisServers,
   suggestWhoisServers,
   execWithTimeout // Export for testing
-};
+};

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v2.0.25 ===
+// === Network scanner script (nwss.js) v2.0.27 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -56,7 +56,7 @@ function fastTimeout(ms) {
 }
 
 // --- Configuration Constants ---
-const TIMEOUTS = {
+const TIMEOUTS = Object.freeze({
   DEFAULT_PAGE: 35000,                // Standard page load timeout (35s)
   DEFAULT_NAVIGATION: 25000,          // Navigation operation timeout
   DEFAULT_NAVIGATION_REDUCED: 20000,  // Reduced timeout for faster failures
@@ -71,21 +71,32 @@ const TIMEOUTS = {
   CURL_HANDLER_DELAY: 3000,           // Wait for async curl operations
   PROTOCOL_TIMEOUT: 180000,           // Chrome DevTools Protocol timeout
   REDIRECT_JS_TIMEOUT: 5000           // JavaScript redirect detection timeout
-};
+});
 
-const CACHE_LIMITS = {
+const CACHE_LIMITS = Object.freeze({
   DISK_CACHE_SIZE: 52428800, // 50MB
   MEDIA_CACHE_SIZE: 52428800, // 50MB
   DEFAULT_CACHE_PATH: '.cache',
   DEFAULT_MAX_SIZE: 5000
-};
+});
 
-const CONCURRENCY_LIMITS = {
+const CONCURRENCY_LIMITS = Object.freeze({
   MIN: 1,
   MAX: 50,
   DEFAULT: 6,
   HIGH_CONCURRENCY_THRESHOLD: 12  // Auto-enable aggressive caching above this
-};
+});
+
+// V8 Optimization: Use Map for user agent lookups instead of object
+const USER_AGENTS = Object.freeze(new Map([
+  ['chrome', "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36"],
+  ['chrome_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36"],
+  ['chrome_linux', "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36"],
+  ['firefox', "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:142.0) Gecko/20100101 Firefox/143.0"],
+  ['firefox_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:142.0) Gecko/20100101 Firefox/143.0"],
+  ['firefox_linux', "Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/143.0"],
+  ['safari', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15"]
+]));
 
 const REALTIME_CLEANUP_THRESHOLD = 8; // Default pages to keep for realtime cleanup
 
@@ -132,7 +143,7 @@ const { navigateWithRedirectHandling, handleRedirectTimeout } = require('./lib/r
 const { monitorBrowserHealth, isBrowserHealthy, isQuicklyResponsive, performGroupWindowCleanup, performRealtimeWindowCleanup, trackPageForRealtime, updatePageUsage, cleanupPageBeforeReload } = require('./lib/browserhealth');
 
 // --- Script Configuration & Constants --- 
-const VERSION = '2.0.25'; // Script version
+const VERSION = '2.0.27'; // Script version
 
 // get startTime
 const startTime = Date.now();
@@ -1211,6 +1222,9 @@ function setupFrameHandling(page, forceDebug) {
       '/usr/bin/chromium',
       '/snap/bin/chromium'
     ];
+    // V8 Optimization: Freeze the Chrome paths array since it's constant
+    Object.freeze(systemChromePaths);
+
 
     let executablePath = null;
     for (const chromePath of systemChromePaths) {
@@ -1387,12 +1401,28 @@ function setupFrameHandling(page, forceDebug) {
    * @returns {Promise<object>} A promise that resolves to an object containing scan results.
    */
   async function processUrl(currentUrl, siteConfig, browserInstance) {
-    const allowFirstParty = siteConfig.firstParty === true || siteConfig.firstParty === 1;
-    const allowThirdParty = siteConfig.thirdParty === undefined || siteConfig.thirdParty === true || siteConfig.thirdParty === 1;
-    const perSiteSubDomains = siteConfig.subDomains === 1 ? true : subDomainsMode;
-    const siteLocalhostIP = siteConfig.localhost || null;
-    const cloudflarePhishBypass = siteConfig.cloudflare_phish === true;
-    const cloudflareBypass = siteConfig.cloudflare_bypass === true;
+    // V8 Optimization: Single destructuring to avoid multiple property lookups
+    const {
+      firstParty,
+      thirdParty,
+      subDomains,
+      localhost,
+      cloudflare_phish,
+      cloudflare_bypass,
+      flowproxy_detection,
+      privoxy,
+      pihole,
+      even_blocked,
+      comments,
+      bypass_cache
+    } = siteConfig;
+    
+    const allowFirstParty = firstParty === true || firstParty === 1;
+    const allowThirdParty = thirdParty === undefined || thirdParty === true || thirdParty === 1;
+    const perSiteSubDomains = subDomains === 1 ? true : subDomainsMode;
+    const siteLocalhostIP = localhost || null;
+    const cloudflarePhishBypass = cloudflare_phish === true;
+    const cloudflareBypass = cloudflare_bypass === true;
     // Add redirect and same-page loop protection
     const MAX_REDIRECT_DEPTH = siteConfig.max_redirects || 10;
     const redirectHistory = new Set();
@@ -1401,14 +1431,14 @@ function setupFrameHandling(page, forceDebug) {
     const MAX_SAME_PAGE_LOADS = 3;
     let currentPageUrl = currentUrl;
 
-    const sitePrivoxy = siteConfig.privoxy === true;
-    const sitePihole = siteConfig.pihole === true;
-    const flowproxyDetection = siteConfig.flowproxy_detection === true;
+    const sitePrivoxy = privoxy === true;
+    const sitePihole = pihole === true;
+    const flowproxyDetection = flowproxy_detection === true;
     
-    const evenBlocked = siteConfig.even_blocked === true;
+    const evenBlocked = even_blocked === true;
     // Log site-level comments if debug mode is enabled
-    if (forceDebug && siteConfig.comments) {
-      const siteComments = Array.isArray(siteConfig.comments) ? siteConfig.comments : [siteConfig.comments];
+    if (forceDebug && comments) {
+      const siteComments = Array.isArray(comments) ? comments : [comments];
       console.log(formatLogMessage('debug', `Site comments for ${currentUrl}: ${siteComments.length} item(s)`));
       siteComments.forEach((comment, idx) => 
         console.log(formatLogMessage('debug', `  Site comment ${idx + 1}: ${comment}`))
@@ -1416,11 +1446,11 @@ function setupFrameHandling(page, forceDebug) {
     }
 
    // Log bypass_cache setting if enabled
-   if (forceDebug && siteConfig.bypass_cache === true) {
+   if (forceDebug && bypass_cache === true) {
      console.log(formatLogMessage('debug', `Cache bypass enabled for all URLs in site: ${currentUrl}`));
    }
 
-    if (siteConfig.firstParty === 0 && siteConfig.thirdParty === 0) {
+    if (firstParty === 0 && thirdParty === 0) {
       console.warn(`⚠ Skipping ${currentUrl} because both firstParty and thirdParty are disabled.`);
       return { url: currentUrl, rules: [], success: false, skipped: true };
     }
@@ -1475,14 +1505,14 @@ function setupFrameHandling(page, forceDebug) {
     let finalUrlAfterRedirect = null;
 
     // Enhanced error types for Puppeteer 23.x compatibility
-    const CRITICAL_BROWSER_ERRORS = [
+    const CRITICAL_BROWSER_ERRORS = Object.freeze([
       'Protocol error',
       'Target closed',
       'Browser has been closed',
       'Browser protocol broken',
       'Browser process exited',
       'Browser disconnected'
-    ];
+    ]);
 
     try {
 
@@ -1907,29 +1937,30 @@ function setupFrameHandling(page, forceDebug) {
         
         // Client Hints protection for Chrome user agents
         if (siteConfig.userAgent && siteConfig.userAgent.toLowerCase().includes('chrome')) {
+          const userAgentKey = siteConfig.userAgent.toLowerCase();
           let platform = 'Windows';
           let platformVersion = '15.0.0';
           let arch = 'x86';
           
-          if (siteConfig.userAgent.toLowerCase() === 'chrome_mac') {
+          if (userAgentKey === 'chrome_mac') {
             platform = 'macOS';
-            platformVersion = '13.5.0';
+            platformVersion = '13.5.0'; 
             arch = 'arm';
-          } else if (siteConfig.userAgent.toLowerCase() === 'chrome_linux') {
+          } else if (userAgentKey === 'chrome_linux') {
             platform = 'Linux';
             platformVersion = '6.5.0';
             arch = 'x86';
           }
-          
+                    
           await page.setExtraHTTPHeaders({
-            'Sec-CH-UA': '"Chromium";v="140", "Not=A?Brand";v="24", "Google Chrome";v="140"',
+            'Sec-CH-UA': '"Chromium";v="141", "Not=A?Brand";v="24", "Google Chrome";v="141"',
             'Sec-CH-UA-Platform': `"${platform}"`,
             'Sec-CH-UA-Platform-Version': `"${platformVersion}"`,
             'Sec-CH-UA-Mobile': '?0',
             'Sec-CH-UA-Arch': `"${arch}"`,
             'Sec-CH-UA-Bitness': '"64"',
-            'Sec-CH-UA-Full-Version': '"140.0.7339.208"',
-            'Sec-CH-UA-Full-Version-List': '"Chromium";v="140.0.7339.208", "Not=A?Brand";v="24.0.0.0", "Google Chrome";v="140.0.7339.208"'
+            'Sec-CH-UA-Full-Version': '"141.0.7390.55"',
+            'Sec-CH-UA-Full-Version-List': '"Chromium";v="141.0.7390.55", "Not=A?Brand";v="24.0.0.0", "Google Chrome";v="141.0.7390.55"'
           });
         }
       } catch (fingerprintErr) {
@@ -1959,16 +1990,7 @@ function setupFrameHandling(page, forceDebug) {
    // Get user agent for curl if needed
    let curlUserAgent = '';
    if (useCurl && siteConfig.userAgent) {
-     const userAgents = {
-       chrome: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
-       chrome_mac: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
-       chrome_linux: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
-       firefox: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:142.0) Gecko/20100101 Firefox/143.0",
-       firefox_mac: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:142.0) Gecko/20100101 Firefox/143.0",
-       firefox_linux: "Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/143.0",
-       safari: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15"
-     };
-     curlUserAgent = userAgents[siteConfig.userAgent.toLowerCase()] || '';
+     curlUserAgent = USER_AGENTS.get(siteConfig.userAgent.toLowerCase()) || '';
    }
 
    if (useCurl && forceDebug) {
@@ -3487,20 +3509,29 @@ function setupFrameHandling(page, forceDebug) {
 // Temporarily store the pLimit function  
   const originalLimit = limit;
 
-  // Create a flat list of all URL tasks with their site configs for true concurrency
-  const allTasks = [];
+  // V8 Optimization: Calculate total URLs first to pre-allocate array
+  let totalUrls = 0;
   for (const site of sites) {
     const urlsToProcess = Array.isArray(site.url) ? site.url : [site.url];
-    urlsToProcess.forEach(url => {
-      allTasks.push({
+    totalUrls += urlsToProcess.length;
+  }
+  
+  // Pre-allocate array with exact size to prevent multiple reallocations
+  const allTasks = new Array(totalUrls);
+  let taskIndex = 0;
+  
+  // Populate the pre-allocated array
+  for (const site of sites) {
+    const urlsToProcess = Array.isArray(site.url) ? site.url : [site.url];
+    for (const url of urlsToProcess) {
+      allTasks[taskIndex++] = {
         url,
         config: { ...site, _originalUrl: url }, // Preserve original URL for CDP domain checking
-        taskId: allTasks.length // For tracking
-      });
-    });
+        taskId: taskIndex - 1 // For tracking
+      };
+    }
   }
-  
-  const totalUrls = allTasks.length;
+
 
   let results = [];
   let processedUrlCount = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "2.0.25",
+  "version": "2.0.27",
   "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": {