@fanboynz/network-scanner 2.0.47 → 2.0.49

package/lib/adblock.js

@@ -312,10 +312,17 @@ function parseRule(rule, isWhitelist) {
 
   // Domain rules: ||domain.com^ or ||domain.com
   if (pattern.startsWith('||')) {
-    parsed.isDomain = true;
     const domain = pattern.substring(2).replace(/\^.*$/, '').replace(/\*$/, '');
-    parsed.domain = domain;
-    parsed.matcher = createDomainMatcher(domain);
+    const afterDomain = pattern.substring(2 + domain.length);
+    if (!afterDomain || afterDomain === '^') {
+      // Pure domain rule: ||domain.com^ or ||domain.com
+      parsed.isDomain = true;
+      parsed.domain = domain;
+      parsed.matcher = createDomainMatcher(domain);
+    } else {
+      // Domain + path rule: ||domain.com^*path or ||domain.com/path
+      parsed.matcher = createPatternMatcher(pattern);
+    }
   }
   // Regex rules: /pattern/
   else if (pattern.startsWith('/') && pattern.endsWith('/')) {
@@ -339,11 +346,12 @@ function parseRule(rule, isWhitelist) {
  */
 function createDomainMatcher(domain) {
   const lowerDomain = domain.toLowerCase();
+  const dotDomain = '.' + lowerDomain;
   return (url, hostname) => {
     const lowerHostname = hostname.toLowerCase();
     // Exact match or subdomain match
-    return lowerHostname === lowerDomain || 
-           lowerHostname.endsWith('.' + lowerDomain);
+    return lowerHostname === lowerDomain ||
+           lowerHostname.endsWith(dotDomain);
   };
 }
 
@@ -378,10 +386,11 @@ function createPatternMatcher(pattern) {
 function createMatcher(rules, options = {}) {
   const { enableLogging = false, caseSensitive = false } = options;
   
-  // Create URL parsing cache (scoped to this matcher instance)
-  const urlCache = new URLCache(1000);
+  const urlCache = new URLCache(8000);
   let cacheHits = 0;
   let cacheMisses = 0;
+  const hasPartyRules = rules.thirdPartyRules.length > 0 || rules.firstPartyRules.length > 0;
+  const resultCache = new URLCache(8000);  // Cache full shouldBlock results
   
   return {
     rules,
@@ -395,6 +404,15 @@ function createMatcher(rules, options = {}) {
      */
     shouldBlock(url, sourceUrl = '', resourceType = '') {
       try {
+        // Check result cache — same URL+source+type always produces same result
+        const resultKey = url + '\0' + sourceUrl + '\0' + resourceType;
+        const cachedResult = resultCache.get(resultKey);
+        if (cachedResult) {
+          cacheHits++;
+          return cachedResult;
+        }
+        cacheMisses++;
+
         // OPTIMIZATION: Check cache first for URL parsing (60% faster)
         let cachedData = urlCache.get(url);
         let hostname, lowerHostname;
@@ -416,22 +434,21 @@ function createMatcher(rules, options = {}) {
           cacheMisses++;
         }
         
-        // OPTIMIZATION #1: Only calculate third-party status if we have rules that need it
-        const hasPartyRules = rules.thirdPartyRules.length > 0 || rules.firstPartyRules.length > 0;
-        const isThirdParty = (sourceUrl && hasPartyRules)
-          ? isThirdPartyRequest(url, sourceUrl)
-          : false;
-        
-        // OPTIMIZATION #2: Calculate hostname parts once and reuse (avoid duplicate split operations)
+        // Calculate hostname parts once and reuse
         const hostnameParts = lowerHostname.split('.');
+
+        // Precompute parent domains once, reused for whitelist and block checks
+        const parentDomains = [];
+        const partsLen = hostnameParts.length;
+        for (let i = 1; i < partsLen; i++) {
+          parentDomains.push(hostnameParts.slice(i).join('.'));
+        }
     
-        // V8 OPT: Extract and cache source page domain for $domain option checking
+        // Extract and cache source page domain for $domain and third-party checks
         let sourceDomain = null;
-        let cachedSourceData = null;
 
         if (sourceUrl) {
-          // Check if sourceUrl is in cache (avoid duplicate URL parsing)
-          cachedSourceData = urlCache.get(sourceUrl);
+          const cachedSourceData = urlCache.get(sourceUrl);
           
           if (cachedSourceData) {
             sourceDomain = cachedSourceData.lowerHostname;
@@ -454,6 +471,11 @@ function createMatcher(rules, options = {}) {
           }
         }
 
+        // Calculate third-party status using already-parsed hostnames
+        const isThirdParty = (sourceDomain && hasPartyRules)
+          ? getBaseDomain(lowerHostname) !== getBaseDomain(sourceDomain)
+          : false;
+
         // === WHITELIST CHECK (exception rules take precedence) ===
         
         // Fast path: Check exact domain in Map (O(1))
@@ -463,21 +485,23 @@ function createMatcher(rules, options = {}) {
             console.log(`[Adblock] Whitelisted: ${url} (${rule.raw})`);
           }
           if (matchesDomainRestrictions(rule, sourceDomain)) {
-            return { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+            const r = { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+            resultCache.set(resultKey, r);
+            return r;
           }
         }
         
         // Check parent domains for subdomain matches (e.g., sub.example.com -> example.com)
-        const partsLen = hostnameParts.length;  // V8: Cache array length
-        for (let i = 1; i < partsLen; i++) {
-          const parentDomain = hostnameParts.slice(i).join('.');
-          rule = rules.whitelistMap.get(parentDomain);  // V8: Single Map lookup
+        for (let i = 0; i < parentDomains.length; i++) {
+          rule = rules.whitelistMap.get(parentDomains[i]);
           if (rule) {
             if (enableLogging) {
               console.log(`[Adblock] Whitelisted: ${url} (${rule.raw})`);
             }
             if (matchesDomainRestrictions(rule, sourceDomain)) {
-              return { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+              const r = { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+              resultCache.set(resultKey, r);
+              return r;
             }
           }
         }
@@ -490,7 +514,9 @@ function createMatcher(rules, options = {}) {
             if (enableLogging) {
               console.log(`[Adblock] Whitelisted: ${url} (${rule.raw})`);
             }
-            return { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+              const r = { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+              resultCache.set(resultKey, r);
+              return r;
           }
         }
 
@@ -503,20 +529,23 @@ function createMatcher(rules, options = {}) {
             console.log(`[Adblock] Blocked domain: ${url} (${rule.raw})`);
           }
           if (matchesDomainRestrictions(rule, sourceDomain)) {
-            return { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+            const r = { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+            resultCache.set(resultKey, r);
+            return r;
           }
         }
         
         // Check parent domains for subdomain matches (e.g., ads.example.com -> example.com)
-        for (let i = 1; i < partsLen; i++) {  // V8: Reuse cached length
-          const parentDomain = hostnameParts.slice(i).join('.');
-          rule = rules.domainMap.get(parentDomain);  // V8: Single Map lookup
+        for (let i = 0; i < parentDomains.length; i++) {
+          rule = rules.domainMap.get(parentDomains[i]);
           if (rule) {
             if (enableLogging) {
               console.log(`[Adblock] Blocked domain: ${url} (${rule.raw})`);
             }
             if (matchesDomainRestrictions(rule, sourceDomain)) {
-              return { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+              const r = { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+              resultCache.set(resultKey, r);
+              return r;
             }
           }
         }
@@ -529,7 +558,9 @@ function createMatcher(rules, options = {}) {
             if (enableLogging) {
               console.log(`[Adblock] Blocked domain: ${url} (${rule.raw})`);
             }
-            return { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+            const r = { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+            resultCache.set(resultKey, r);
+            return r;
           }
         }
 
@@ -542,11 +573,9 @@ function createMatcher(rules, options = {}) {
               if (enableLogging) {
                 console.log(`[Adblock] Blocked third-party: ${url} (${rule.raw})`);
               }
-              return { 
-                blocked: true, 
-                rule: rule.raw, 
-                reason: 'third_party_rule' 
-              };
+              const r = { blocked: true, rule: rule.raw, reason: 'third_party_rule' };
+              resultCache.set(resultKey, r);
+              return r;
             }
           }
         }
@@ -560,11 +589,9 @@ function createMatcher(rules, options = {}) {
               if (enableLogging) {
                 console.log(`[Adblock] Blocked first-party: ${url} (${rule.raw})`);
               }
-              return {
-                blocked: true,
-                rule: rule.raw,
-                reason: 'first_party_rule'
-              };
+              const r = { blocked: true, rule: rule.raw, reason: 'first_party_rule' };
+              resultCache.set(resultKey, r);
+              return r;
             }
           }
         }
@@ -578,11 +605,9 @@ function createMatcher(rules, options = {}) {
               if (enableLogging) {
                 console.log(`[Adblock] Blocked script: ${url} (${rule.raw})`);
               }
-              return { 
-                blocked: true, 
-                rule: rule.raw, 
-                reason: 'script_rule' 
-              };
+              const r = { blocked: true, rule: rule.raw, reason: 'script_rule' };
+              resultCache.set(resultKey, r);
+              return r;
             }
           }
         }
@@ -595,11 +620,9 @@ function createMatcher(rules, options = {}) {
             if (enableLogging) {
               console.log(`[Adblock] Blocked path: ${url} (${rule.raw})`);
             }
-            return { 
-              blocked: true, 
-              rule: rule.raw, 
-              reason: 'path_rule' 
-            };
+            const r = { blocked: true, rule: rule.raw, reason: 'path_rule' };
+            resultCache.set(resultKey, r);
+            return r;
           }
         }
 
@@ -611,20 +634,16 @@ function createMatcher(rules, options = {}) {
             if (enableLogging) {
               console.log(`[Adblock] Blocked regex: ${url} (${rule.raw})`);
             }
-            return { 
-              blocked: true, 
-              rule: rule.raw, 
-              reason: 'regex_rule' 
-            };
+            const r = { blocked: true, rule: rule.raw, reason: 'regex_rule' };
+            resultCache.set(resultKey, r);
+            return r;
           }
         }
 
         // No match - allow request
-        return { 
-          blocked: false, 
-          rule: null, 
-          reason: 'no_match' 
-        };
+        const r = { blocked: false, rule: null, reason: 'no_match' };
+        resultCache.set(resultKey, r);
+        return r;
 
       } catch (err) {
         if (enableLogging) {
@@ -796,27 +815,6 @@ function matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDoma
   }
 }
 
-/**
- * Determine if request is third-party
- * @param {string} requestUrl - URL being requested
- * @param {string} sourceUrl - URL of the page making the request
- * @returns {boolean} True if third-party request
- */
-function isThirdPartyRequest(requestUrl, sourceUrl) {
-  try {
-    const requestHostname = new URL(requestUrl).hostname;
-    const sourceHostname = new URL(sourceUrl).hostname;
-    
-    // Extract base domain (handle subdomains)
-    const requestDomain = getBaseDomain(requestHostname);
-    const sourceDomain = getBaseDomain(sourceHostname);
-    
-    return requestDomain !== sourceDomain;
-  } catch (err) {
-    return false;
-  }
-}
-
 /**
  * Extract base domain from hostname
  * @param {string} hostname - Full hostname
@@ -833,6 +831,5 @@ function getBaseDomain(hostname) {
 
 module.exports = {
   parseAdblockRules,
-  isThirdPartyRequest,
   getBaseDomain
 };

package/lib/cdp.js

@@ -175,30 +175,26 @@ async function createCDPSession(page, currentUrl, options = {}) {
     
     // Enable network domain - required for network event monitoring  
     await cdpSession.send('Network.enable');
-    
+
+    // Parse current URL hostname once, reused across all request events
+    let currentHostname = 'unknown';
+    try { currentHostname = new URL(currentUrl).hostname; } catch (_) {}
+
     // Set up network request monitoring
     // This captures ALL network requests at the browser engine level
     cdpSession.on('Network.requestWillBeSent', (params) => {
-      const { url: requestUrl, method } = params.request;
-      const initiator = params.initiator ? params.initiator.type : 'unknown';
-      
-      // Extract hostname for logging context (handles URL parsing errors gracefully)
-      const hostnameForLog = (() => {
+      if (forceDebug) {
+        const { url: requestUrl, method } = params.request;
+        const initiator = params.initiator ? params.initiator.type : 'unknown';
+        let hostnameForLog = currentHostname;
         try {
-          const currentHostname = new URL(currentUrl).hostname;
           const requestHostname = new URL(requestUrl).hostname;
-          return currentHostname !== requestHostname 
-            ? `${currentHostname}?${requestHostname}`
-            : currentHostname;
-        } catch (_) { 
-          return 'unknown-host';
-        }
-      })();
-      
- // Log the request with context only if debug mode is enabled
- if (forceDebug) {
-   console.log(formatLogMessage('debug', `[cdp][${hostnameForLog}] ${method} ${requestUrl} (initiator: ${initiator})`));
- }
+          if (currentHostname !== requestHostname) {
+            hostnameForLog = `${currentHostname}?${requestHostname}`;
+          }
+        } catch (_) {}
+        console.log(formatLogMessage('debug', `[cdp][${hostnameForLog}] ${method} ${requestUrl} (initiator: ${initiator})`));
+      }
     });
 
     if (forceDebug) {

package/lib/dry-run.js

@@ -174,7 +174,7 @@ function generateAdblockRule(domain, resourceType = null) {
   if (!domain) return '';
   
   if (resourceType && resourceType !== 'other') {
-    return `||${domain}^${resourceType}`;
+    return `||${domain}^$${resourceType}`;
   }
   return `||${domain}^`;
 }

package/lib/fingerprint.js

@@ -7,6 +7,22 @@
 const DEFAULT_PLATFORM = 'Win32';
 const DEFAULT_TIMEZONE = 'America/New_York';
 
+// Deterministic random generator seeded by domain string
+// Same domain always produces the same sequence of values
+function seededRandom(seed) {
+  let h = 0;
+  for (let i = 0; i < seed.length; i++) {
+    h = ((h << 5) - h + seed.charCodeAt(i)) | 0;
+  }
+  return () => {
+    h = (h * 1664525 + 1013904223) | 0;
+    return (h >>> 0) / 4294967296;
+  };
+}
+
+// Cache fingerprints per domain so reloads and multi-page visits stay consistent
+const _fingerprintCache = new Map();
+
 // Type-specific property spoofing functions for monomorphic optimization
 function spoofNavigatorProperties(navigator, properties, options = {}) {
   if (!navigator || typeof navigator !== 'object') return false;
@@ -111,8 +127,18 @@ function getRealisticScreenResolution() {
 
 /**
  * Generates randomized but realistic browser fingerprint values
+ * When domain is provided, values are deterministic per-domain (consistent across reloads)
  */
-function generateRealisticFingerprint(userAgent) {
+function generateRealisticFingerprint(userAgent, domain = '') {
+  // Return cached fingerprint if same domain visited again
+  if (domain) {
+    const cached = _fingerprintCache.get(domain);
+    if (cached) return cached;
+  }
+
+  // Use seeded random for consistency, or Math.random if no domain
+  const rand = domain ? seededRandom(domain) : Math.random;
+
   // Determine OS from user agent
   let osType = 'windows';
   if (userAgent.includes('Macintosh') || userAgent.includes('Mac OS X')) {
@@ -162,11 +188,11 @@ function generateRealisticFingerprint(userAgent) {
   };
   
   const profile = profiles[osType];
-  const resolution = profile.resolutions[Math.floor(Math.random() * profile.resolutions.length)];
+  const resolution = profile.resolutions[Math.floor(rand() * profile.resolutions.length)];
   
-  return {
-    deviceMemory: profile.deviceMemory[Math.floor(Math.random() * profile.deviceMemory.length)],
-    hardwareConcurrency: profile.hardwareConcurrency[Math.floor(Math.random() * profile.hardwareConcurrency.length)],
+  const fingerprint = {
+    deviceMemory: profile.deviceMemory[Math.floor(rand() * profile.deviceMemory.length)],
+    hardwareConcurrency: profile.hardwareConcurrency[Math.floor(rand() * profile.hardwareConcurrency.length)],
     screen: {
       width: resolution.width,
       height: resolution.height,
@@ -181,6 +207,11 @@ function generateRealisticFingerprint(userAgent) {
     cookieEnabled: true,
     doNotTrack: null // Most users don't enable DNT
   };
+  
+  // Cache for this domain
+  if (domain) _fingerprintCache.set(domain, fingerprint);
+
+  return fingerprint;
 }
 
 /**
@@ -1009,8 +1040,10 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           CanvasRenderingContext2D.prototype.measureText = function(text) {
             const result = originalMeasureText.call(this, text);
             // Add slight noise to text measurements to prevent precise fingerprinting
-            result.width += (Math.random() - 0.5) * 0.1;
-            return result;
+            const originalWidth = result.width;
+            return Object.create(result, {
+              width: { get: () => originalWidth + (Math.random() - 0.5) * 0.1 }
+            });
           };
 
           // Comprehensive canvas fingerprinting protection
@@ -1018,6 +1051,10 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
           CanvasRenderingContext2D.prototype.getImageData = function(sx, sy, sw, sh) {
             const imageData = originalGetImageData.call(this, sx, sy, sw, sh);
+            // Skip noise on large canvases (>500K pixels) � too expensive for minimal fingerprint benefit
+            if (imageData.data.length > 2000000) {
+              return imageData;
+            }
             // Add subtle noise to pixel data
             for (let i = 0; i < imageData.data.length; i += 4) {
               if (Math.random() < 0.1) { // 10% chance to modify each pixel
@@ -1090,14 +1127,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         safeExecute(() => {
           const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
           HTMLCanvasElement.prototype.toDataURL = function(...args) {
-            const context = this.getContext('2d');
-            if (context) {
-              const imageData = context.getImageData(0, 0, this.width, this.height);
-              for (let i = 0; i < imageData.data.length; i += 4) {
-                imageData.data[i] = imageData.data[i] + Math.floor(Math.random() * 3) - 1;
-              }
-              context.putImageData(imageData, 0, 0);
-            }
+            // Noise already applied by getImageData override
             return originalToDataURL.apply(this, args);
           };
         }, 'canvas fingerprinting protection');
@@ -1129,7 +1159,9 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           }
           
           // Spoof mouse timing patterns to prevent behavioral fingerprinting
+          const listenerMap = new WeakMap();
           const originalAddEventListener = EventTarget.prototype.addEventListener;
+          const originalRemoveEventListener = EventTarget.prototype.removeEventListener;
           EventTarget.prototype.addEventListener = function(type, listener, options) {
             if (type === 'mousemove' && typeof listener === 'function') {
               const wrappedListener = function(event) {
@@ -1137,10 +1169,21 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
                 const delay = Math.random() * 2; // 0-2ms variation
                 setTimeout(() => listener.call(this, event), delay);
               };
+              listenerMap.set(listener, wrappedListener);
               return originalAddEventListener.call(this, type, wrappedListener, options);
             }
             return originalAddEventListener.call(this, type, listener, options);
           };
+          EventTarget.prototype.removeEventListener = function(type, listener, options) {
+            if (type === 'mousemove' && typeof listener === 'function') {
+              const wrapped = listenerMap.get(listener);
+              if (wrapped) {
+                listenerMap.delete(listener);
+                return originalRemoveEventListener.call(this, type, wrapped, options);
+              }
+            }
+            return originalRemoveEventListener.call(this, type, listener, options);
+          };
           
           // Spoof PointerEvent if available
           //
@@ -1323,7 +1366,11 @@ async function applyFingerprintProtection(page, siteConfig, forceDebug, currentU
     return;
   }
   
- const spoof = fingerprintSetting === 'random' ? generateRealisticFingerprint(currentUserAgent) : {
+  // Extract root domain for consistent per-site fingerprinting
+  let siteDomain = '';
+  try { siteDomain = new URL(currentUrl).hostname; } catch (_) {}
+
+  const spoof = fingerprintSetting === 'random' ? generateRealisticFingerprint(currentUserAgent, siteDomain) : {
     deviceMemory: 8, 
     hardwareConcurrency: 4,
     screen: { width: 1920, height: 1080, availWidth: 1920, availHeight: 1040, colorDepth: 24, pixelDepth: 24 },
@@ -1377,15 +1424,17 @@ async function applyFingerprintProtection(page, siteConfig, forceDebug, currentU
       // Platform, memory, and hardware spoofing combined for better V8 optimization
       // (moved into navigatorProps above);
 
+      const connectionInfo = {
+        effectiveType: ['slow-2g', '2g', '3g', '4g'][Math.floor(Math.random() * 4)],
+        type: Math.random() > 0.5 ? 'cellular' : 'wifi',
+        saveData: Math.random() > 0.8,
+        downlink: 1.5 + Math.random() * 8,
+        rtt: 50 + Math.random() * 200
+      };
+
       // Connection type spoofing
       safeDefinePropertyLocal(navigator, 'connection', {
-        get: () => ({
-          effectiveType: ['slow-2g', '2g', '3g', '4g'][Math.floor(Math.random() * 4)],
-          type: Math.random() > 0.5 ? 'cellular' : 'wifi',
-          saveData: Math.random() > 0.8,
-          downlink: 1.5 + Math.random() * 8,
-          rtt: 50 + Math.random() * 200
-        })
+        get: () => connectionInfo
       });
       
       // Screen properties spoofing
@@ -1509,7 +1558,9 @@ async function simulateHumanBehavior(page, forceDebug) {
         let currentPattern = patterns[Math.floor(Math.random() * patterns.length)];
         let patternChangeCounter = 0;
         
-        const moveInterval = setInterval(() => {
+        let moveTimeout;
+        function scheduleMove() {
+          moveTimeout = setTimeout(() => {
           const now = Date.now();
           const timeDelta = now - lastMoveTime;
           
@@ -1556,12 +1607,15 @@ async function simulateHumanBehavior(page, forceDebug) {
             lastMoveTime = now;
 
           } catch (e) {}
-        }, 50 + Math.random() * 100); // More frequent, realistic timing (50-150ms)
+            scheduleMove();
+          }, 50 + Math.random() * 100);
+        }
+        scheduleMove();
         
         // Stop after 45 seconds with gradual slowdown
         setTimeout(() => {
           try { 
-            clearInterval(moveInterval);
+            clearTimeout(moveTimeout);
             if (debugEnabled) console.log('[fingerprint] Enhanced mouse simulation completed');
           } catch (e) {}
         }, 45000);

package/lib/grep.js

@@ -3,9 +3,6 @@
 
 const fs = require('fs');
 const { spawnSync } = require('child_process');
-const crypto = require('crypto');
-const path = require('path');
-const os = require('os');
 const { colorize, colors, messageColors, tags, formatLogMessage } = require('./colorize');
 
 // === Constants ===
@@ -21,53 +18,9 @@ const GREP_DEFAULTS = {
   GREP_SUCCESS_STATUS: 0,
   GREP_NOT_FOUND_STATUS: 1,
   CURL_SUCCESS_STATUS: 0,
-  VERSION_LINE_INDEX: 0,
-  RANDOM_STRING_LENGTH: 9,
-  TEMP_DIR_PREFIX: 'grep_search_'
+  VERSION_LINE_INDEX: 0
 };
 
-/**
- * Creates a temporary directory and file with content for grep processing
- * Uses mkdtempSync to avoid race conditions from filename collisions
- * @param {string} content - The content to write to temp file
- * @param {string} prefix - Prefix for temp filename
- * @returns {object} Object containing tempDir and tempFile paths
- */
-function createTempFile(content, prefix = 'scanner_grep') {
-  const tempDir = os.tmpdir();
-  
-  // Create a unique temporary directory to avoid race conditions
-  const uniqueTempDir = fs.mkdtempSync(path.join(tempDir, GREP_DEFAULTS.TEMP_DIR_PREFIX));
-  
-  // Use cryptographically secure random ID for additional uniqueness
-  const uniqueId = crypto.randomBytes(8).toString('hex');
-  const tempFile = path.join(uniqueTempDir, `${prefix}_${uniqueId}.tmp`);
-  
-  try {
-    // Write atomically with error handling
-    fs.writeFileSync(tempFile, content, { 
-      encoding: 'utf8',
-      mode: 0o600 // Restrict permissions for security
-    });
-    
-    return { tempDir: uniqueTempDir, tempFile };
-  } catch (error) {
-    // Clean up temp directory on write failure
-    try {
-      if (fs.existsSync(tempFile)) {
-        fs.unlinkSync(tempFile);
-      }
-      if (fs.existsSync(uniqueTempDir)) {
-        fs.rmdirSync(uniqueTempDir);
-      }
-    } catch (cleanupErr) {
-      // Ignore cleanup errors, report original error
-    }
-
-    throw new Error(`Failed to create temp file: ${error.message}`);
-  }
-}
-
 /**
  * Searches content using grep with the provided patterns
  * @param {string} content - The content to search
@@ -86,15 +39,8 @@ async function grepContent(content, searchPatterns, options = {}) {
   if (!content || searchPatterns.length === 0) {
     return { found: false, matchedPattern: null, allMatches: [] };
   }
-
-  let tempFile = null;
-  let tempDir = null;
-  
+ 
   try {
-    // Create temporary directory and file with content
-    const tempResult = createTempFile(content, 'grep_search');
-    tempDir = tempResult.tempDir;
-    tempFile = tempResult.tempFile;
     
     const allMatches = [];
     let firstMatch = null;
@@ -111,12 +57,12 @@ async function grepContent(content, searchPatterns, options = {}) {
       if (wholeWord) grepArgs.push('-w');
       if (!regex) grepArgs.push('-F'); // Fixed strings (literal)
       
-      // Add pattern and file
-      grepArgs.push(pattern, tempFile);
+      grepArgs.push(pattern);
       
       try {
         const result = spawnSync('grep', grepArgs, {
           encoding: 'utf8',
+          input: content,
           timeout: GREP_DEFAULTS.GREP_TIMEOUT,
           maxBuffer: GREP_DEFAULTS.MAX_BUFFER_SIZE
         });
@@ -147,22 +93,6 @@ async function grepContent(content, searchPatterns, options = {}) {
     
   } catch (error) {
     throw new Error(`Grep search failed: ${error.message}`);
-  } finally {
-    // Clean up temporary file and directory
-    if (tempFile) {
-      try {
-        fs.unlinkSync(tempFile);
-      } catch (cleanupErr) {
-        console.warn(formatLogMessage('warn', `[grep] Failed to cleanup temp file ${tempFile}: ${cleanupErr.message}`));
-      }
-    }
-    if (tempDir) {
-      try {
-        fs.rmdirSync(tempDir);
-      } catch (cleanupErr) {
-        console.warn(formatLogMessage('warn', `[grep] Failed to cleanup temp directory ${tempDir}: ${cleanupErr.message}`));
-      }
-    }
   }
 }
 
@@ -418,6 +348,5 @@ module.exports = {
   grepContent,
   downloadAndGrep,
   createGrepHandler,
-  validateGrepAvailability,
-  createTempFile
+  validateGrepAvailability
 };

package/lib/interaction.js

@@ -94,7 +94,7 @@ const SCROLLING = {
   DEFAULT_AMOUNT: 3,           // Default number of scroll actions
   DEFAULT_SMOOTHNESS: 5,       // Default smoothness (higher = more increments)
   SCROLL_DELTA: 200,           // Pixels to scroll per action
-  PAUSE_BETWEEN: 200,          // Milliseconds between scroll actions
+  PAUSE_BETWEEN: 50,          // Milliseconds between scroll actions
   SMOOTH_INCREMENT_DELAY: 20   // Milliseconds between smooth scroll increments
 };
 
@@ -796,39 +796,13 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
 
     // Validate page state before starting interaction
     try {
-      // Optimized timeout calculation - shorter for better performance
-      const siteTimeout = options.siteTimeout || 20000; // Reduced default
-      const bodyTimeout = Math.min(Math.max(siteTimeout / 8, 2000), 5000); // 2-5 seconds (reduced)
-      
-      await page.waitForSelector('body', { timeout: bodyTimeout });
-      
-      // Additional check: ensure page is not closed/crashed
       if (page.isClosed()) {
         if (forceDebug) {
           console.log(`[interaction] Page is closed for ${currentUrl}, skipping interaction`);
         }
         return;
       }
-
-      const bodyExists = await page.$('body');
-      if (!bodyExists) {
-        if (forceDebug) {
-          console.log(`[interaction] Body element not found for ${currentUrl}, skipping interaction`);
-        }
-        return;
-      }
-      await bodyExists.dispose();
-    } catch (bodyCheckErr) {
-      if (forceDebug) {
-        console.log(`[interaction] Page not ready for interaction on ${currentUrl} (waited ${Math.min(Math.max((options.siteTimeout || 20000) / 8, 2000), 5000)}ms): ${bodyCheckErr.message}`);
-        // For very slow sites, we might want to try a minimal interaction anyway
-        if (Math.min(Math.max((options.siteTimeout || 20000) / 8, 2000), 5000) >= 4000 && !bodyCheckErr.message.includes('closed')) {
-          console.log(`[interaction] Attempting minimal mouse movement only for slow-loading ${currentUrl}`);
-          return await performMinimalInteraction(page, currentUrl, options, forceDebug);
-        }
-      }
-      return;
-    }
+    } catch { return; }
 
     // Use cached viewport for better performance
     const viewport = await getCachedViewport(page);

package/nwss.js

@@ -744,6 +744,17 @@ const globalBlockedRegexes = Array.isArray(globalBlocked)
   ? globalBlocked.map(pattern => new RegExp(pattern))
   : [];
 
+// Pre-split ignoreDomains into exact Set (O(1) lookup) and wildcard array
+const _ignoreDomainsExact = new Set();
+const _ignoreDomainsWildcard = [];
+for (const pattern of ignoreDomains) {
+  if (pattern.includes('*')) {
+    _ignoreDomainsWildcard.push(pattern);
+  } else {
+    _ignoreDomainsExact.add(pattern);
+  }
+}
+
 // Apply global configuration overrides with validation
 // Priority: Command line args > config.json > defaults
 const MAX_CONCURRENT_SITES = (() => {
@@ -1131,20 +1142,32 @@ function shouldBypassCacheForUrl(url, siteConfig) {
 // Cache compiled wildcard regexes to avoid recompilation on every request
 const _wildcardRegexCache = new Map();
 function matchesIgnoreDomain(domain, ignorePatterns) {
-  return ignorePatterns.some(pattern => {
-    if (pattern.includes('*')) {
-      let compiled = _wildcardRegexCache.get(pattern);
-      if (!compiled) {
-        const regexPattern = pattern
-          .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')  // Escape all regex specials including *
-          .replace(/\\\*/g, '.*');                    // Convert escaped \* back to .*
-        compiled = new RegExp(`^${regexPattern}$`);
-        _wildcardRegexCache.set(pattern, compiled);
-      }
-      return compiled.test(domain);
+  // Fast path: exact match or suffix match against Set (O(n) for parts, but no regex)
+  if (_ignoreDomainsExact.size > 0) {
+    if (_ignoreDomainsExact.has(domain)) return true;
+    // Check parent domains: sub.ads.example.com → ads.example.com → example.com
+    const parts = domain.split('.');
+    for (let i = 1; i < parts.length; i++) {
+      if (_ignoreDomainsExact.has(parts.slice(i).join('.'))) return true;
     }
-    return domain.endsWith(pattern);
-  });
+  }
+
+  // Slow path: wildcard patterns only
+  const wildcards = _ignoreDomainsWildcard;
+  const len = wildcards.length;
+  for (let i = 0; i < len; i++) {
+    const pattern = wildcards[i];
+    let compiled = _wildcardRegexCache.get(pattern);
+    if (!compiled) {
+      const regexPattern = pattern
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/\\\*/g, '.*');
+      compiled = new RegExp(`^${regexPattern}$`);
+      _wildcardRegexCache.set(pattern, compiled);
+    }
+    if (compiled.test(domain)) return true;
+  }
+  return false;
 }
 
 function setupFrameHandling(page, forceDebug) {
@@ -2442,8 +2465,16 @@ function setupFrameHandling(page, forceDebug) {
 
       page.on('request', request => {
         const checkedUrl = request.url();
-        const fullSubdomain = safeGetDomain(checkedUrl, true);  // Full hostname for cache
-        const checkedRootDomain = safeGetDomain(checkedUrl, false);
+        // Parse URL once, derive all domain variants from single parse
+        let fullSubdomain = '';
+        let checkedRootDomain = '';
+        try {
+          const parsedUrl = new URL(checkedUrl);
+          fullSubdomain = parsedUrl.hostname;
+          const pslResult = psl.parse(fullSubdomain);
+          checkedRootDomain = pslResult.domain || fullSubdomain;
+        } catch (e) {}
+
         // Check against ALL first-party domains (original + all redirects)
         const isFirstParty = checkedRootDomain && firstPartyDomains.has(checkedRootDomain);
         
@@ -2516,20 +2547,19 @@ function setupFrameHandling(page, forceDebug) {
         }
         const reqUrl = checkedUrl;
         
-        const reqDomain = safeGetDomain(reqUrl, perSiteSubDomains); // Output domain based on config
+        const reqDomain = perSiteSubDomains ? fullSubdomain : checkedRootDomain;
 
-        if (allBlockedRegexes.some(re => re.test(reqUrl))) {
-         if (forceDebug) {
-           // Find which specific pattern matched using already-compiled regexes
-            let matchedPattern = '(unknown)';
-            let patternSource = 'global';
-            for (let i = 0; i < allBlockedRegexes.length; i++) {
-              if (allBlockedRegexes[i].test(reqUrl)) {
-                matchedPattern = allBlockedRegexes[i].source;
-                patternSource = i < blockedRegexes.length ? 'site' : 'global';
-                break;
-              }
-            }
+        let blockedMatchIndex = -1;
+        for (let i = 0; i < allBlockedRegexes.length; i++) {
+          if (allBlockedRegexes[i].test(reqUrl)) {
+            blockedMatchIndex = i;
+            break;
+          }
+        }
+        if (blockedMatchIndex !== -1) {
+          if (forceDebug) {
+            const matchedPattern = allBlockedRegexes[blockedMatchIndex].source;
+            const patternSource = blockedMatchIndex < blockedRegexes.length ? 'site' : 'global';
             console.log(formatLogMessage('debug', `${messageColors.blocked('[blocked]')}[${simplifiedCurrentUrl}] ${reqUrl} blocked by ${patternSource} pattern: ${matchedPattern}`));
             
             // Also log to file (buffered)

package/package.json

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