@fanboynz/network-scanner 2.0.51 → 2.0.53

package/lib/fingerprint.js

@@ -54,9 +54,9 @@ const BUILT_IN_PROPERTIES = new Set([
 
 // User agent collections with latest versions
 const USER_AGENT_COLLECTIONS = Object.freeze(new Map([
-  ['chrome', "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.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/142.0.0.0 Safari/537.36"],
-  ['chrome_linux', "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36"],
+  ['chrome', "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.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/145.0.0.0 Safari/537.36"],
+  ['chrome_linux', "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36"],
   ['firefox', "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0) Gecko/20100101 Firefox/145.0"],
   ['firefox_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:145.0) Gecko/20100101 Firefox/145.0"],
   ['firefox_linux', "Mozilla/5.0 (X11; Linux x86_64; rv:145.0) Gecko/20100101 Firefox/145.0"],
@@ -64,6 +64,50 @@ const USER_AGENT_COLLECTIONS = Object.freeze(new Map([
 ]));
 
 // Timezone configuration with offsets
+
+// GPU pool — realistic vendor/renderer combos per OS (used for WebGL spoofing)
+const GPU_POOL = {
+  windows: [
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (Intel(R) UHD Graphics 770 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (Intel(R) Iris(R) Xe Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (NVIDIA GeForce GTX 1650 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (NVIDIA GeForce GTX 1060 6GB Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (NVIDIA GeForce RTX 4060 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (AMD Radeon RX 580 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (AMD Radeon(TM) Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (AMD Radeon RX 6600 XT Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+  ],
+  mac: [
+    { vendor: 'Apple', renderer: 'Apple M1' },
+    { vendor: 'Apple', renderer: 'Apple M1 Pro' },
+    { vendor: 'Apple', renderer: 'Apple M2' },
+    { vendor: 'Apple', renderer: 'Apple M3' },
+    { vendor: 'Intel Inc.', renderer: 'Intel(R) UHD Graphics 630' },
+    { vendor: 'Intel Inc.', renderer: 'Intel(R) Iris(TM) Plus Graphics 655' },
+    { vendor: 'Intel Inc.', renderer: 'Intel(R) Iris(TM) Plus Graphics' },
+  ],
+  linux: [
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (Intel(R) UHD Graphics 630, Mesa 23.2.1, OpenGL 4.6)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (Intel(R) UHD Graphics 770, Mesa 24.0.3, OpenGL 4.6)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (NVIDIA GeForce GTX 1080, NVIDIA 535.183.01, OpenGL 4.6.0)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (NVIDIA GeForce RTX 3070, NVIDIA 545.29.06, OpenGL 4.6.0)' },
+    { vendor: 'Google Inc. (ANGLE)', renderer: 'ANGLE (AMD Radeon RX 580, Mesa 23.2.1, OpenGL 4.6)' },
+  ]
+};
+
+/**
+ * Select a GPU from the pool based on user agent string.
+ * Called once per browser session so the GPU stays consistent across page loads.
+ */
+function selectGpuForUserAgent(userAgentString) {
+  let osKey = 'windows';
+  if (userAgentString && (userAgentString.includes('Macintosh') || userAgentString.includes('Mac OS X'))) osKey = 'mac';
+  else if (userAgentString && (userAgentString.includes('X11; Linux') || userAgentString.includes('Ubuntu'))) osKey = 'linux';
+  const pool = GPU_POOL[osKey];
+  return pool[Math.floor(Math.random() * pool.length)];
+}
 const TIMEZONE_CONFIG = {
   'America/New_York': { offset: 300, abbr: 'EST' },
   'America/Los_Angeles': { offset: 480, abbr: 'PST' },
@@ -267,7 +311,11 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
     if (forceDebug) console.log(`[debug] Applying stealth protection for ${currentUrl}`);
     
     try {
-      await page.evaluateOnNewDocument((userAgent, debugEnabled) => {
+      // Select GPU once per session — stays consistent across all page loads
+      const selectedGpu = selectGpuForUserAgent(ua);
+      if (forceDebug) console.log(`[debug] Selected GPU: ${selectedGpu.vendor} / ${selectedGpu.renderer}`);
+
+      await page.evaluateOnNewDocument((userAgent, debugEnabled, gpuConfig) => {
       
         // Apply inline error suppression first
         (function() {
@@ -394,7 +442,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           try {
             delete navigator.webdriver;
           } catch (e) {}
-          safeDefinePropertyLocal(navigator, 'webdriver', { get: () => undefined });
+          safeDefinePropertyLocal(navigator, 'webdriver', { get: () => false });
         }, 'webdriver removal');
 
         // Remove automation properties
@@ -427,83 +475,105 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         //
         safeExecute(() => {
           if (!window.chrome) {
-            window.chrome = {
-              runtime: {
-                onConnect: { addListener: () => {}, removeListener: () => {} },
-                onMessage: { addListener: () => {}, removeListener: () => {} },
-                sendMessage: () => {},
-                connect: () => ({ 
-                  onMessage: { addListener: () => {}, removeListener: () => {} }, 
-                  postMessage: () => {}, 
-                  disconnect: () => {} 
-                }),
-                getManifest: () => ({ 
-                  name: "Chrome", 
-                  version: "142.0.0.0",
-                  manifest_version: 3,
-                  description: "Chrome Browser"
-                }),
-                getURL: (path) => `chrome-extension://invalid/${path}`,
-                id: undefined,
-                getPlatformInfo: (callback) => callback({
-                  os: navigator.platform.includes('Win') ? 'win' : 
-                      navigator.platform.includes('Mac') ? 'mac' : 'linux',
-                  arch: 'x86-64',
-                  nacl_arch: 'x86-64'
-                })
-              },
-              storage: {
-                local: {
-                  get: (keys, callback) => callback && callback({}),
-                  set: (items, callback) => callback && callback(),
-                  remove: (keys, callback) => callback && callback(),
-                  clear: (callback) => callback && callback()
-                },
-                sync: {
-                  get: (keys, callback) => callback && callback({}),
-                  set: (items, callback) => callback && callback(),
-                  remove: (keys, callback) => callback && callback(),
-                  clear: (callback) => callback && callback()
-                }
-              },
-              loadTimes: () => {
-                const now = performance.now();
-                return {
-                  commitLoadTime: now - Math.random() * 1000,
-                  connectionInfo: 'http/1.1',
-                  finishDocumentLoadTime: now - Math.random() * 500,
-                  finishLoadTime: now - Math.random() * 100,
-                  navigationType: 'Navigation'
-                };
-              },
-              csi: () => ({
-                onloadT: Date.now(),
-                pageT: Math.random() * 1000,
-                startE: Date.now() - Math.random() * 2000
+            window.chrome = {};
+          }
+          
+          // Add runtime if missing — headless Chrome has chrome object but no runtime
+          if (!window.chrome.runtime) {
+            window.chrome.runtime = {
+              onConnect: { addListener: () => {}, removeListener: () => {} },
+              onMessage: { addListener: () => {}, removeListener: () => {} },
+              sendMessage: () => {},
+              connect: () => ({ 
+                onMessage: { addListener: () => {}, removeListener: () => {} }, 
+                postMessage: () => {}, 
+                disconnect: () => {} 
+              }),
+              getManifest: () => ({ 
+                name: "Chrome", 
+                version: "145.0.0.0",
+                manifest_version: 3,
+                description: "Chrome Browser"
+              }),
+              getURL: (path) => `chrome-extension://invalid/${path}`,
+              id: undefined,
+              getPlatformInfo: (callback) => callback({
+                os: navigator.platform.includes('Win') ? 'win' : 
+                    navigator.platform.includes('Mac') ? 'mac' : 'linux',
+                arch: 'x86-64',
+                nacl_arch: 'x86-64'
               })
             };
-            
-            // Make chrome object non-enumerable to match real Chrome
-            Object.defineProperty(window, 'chrome', {
-              value: window.chrome,
-              writable: false,
-              enumerable: false,
-              configurable: true
-            });
-            
-            // Add Chrome-specific globals that Cloudflare might check
-            if (!window.external) {
-              window.external = {
-                AddSearchProvider: () => {},
-                IsSearchProviderInstalled: () => 0
-              };
-            }
-            
-            // Ensure chrome.runtime appears as a native object
             Object.defineProperty(window.chrome.runtime, 'toString', {
               value: () => '[object Object]'
             });
           }
+          
+          // Add app if missing
+          if (!window.chrome.app) {
+            window.chrome.app = {
+              isInstalled: false,
+              InstallState: { DISABLED: 'disabled', INSTALLED: 'installed', NOT_INSTALLED: 'not_installed' },
+              RunningState: { CANNOT_RUN: 'cannot_run', READY_TO_RUN: 'ready_to_run', RUNNING: 'running' },
+              getDetails: () => null,
+              getIsInstalled: () => false
+            };
+          }
+
+          // Add storage if missing
+          if (!window.chrome.storage) {
+            window.chrome.storage = {
+              local: {
+                get: (keys, callback) => callback && callback({}),
+                set: (items, callback) => callback && callback(),
+                remove: (keys, callback) => callback && callback(),
+                clear: (callback) => callback && callback()
+              },
+              sync: {
+                get: (keys, callback) => callback && callback({}),
+                set: (items, callback) => callback && callback(),
+                remove: (keys, callback) => callback && callback(),
+                clear: (callback) => callback && callback()
+              }
+            };
+          }
+          
+          // Add loadTimes/csi if missing
+          if (!window.chrome.loadTimes) {
+            window.chrome.loadTimes = () => {
+              const now = performance.now();
+              return {
+                commitLoadTime: now - Math.random() * 1000,
+                connectionInfo: 'http/1.1',
+                finishDocumentLoadTime: now - Math.random() * 500,
+                finishLoadTime: now - Math.random() * 100,
+                navigationType: 'Navigation'
+              };
+            };
+          }
+          if (!window.chrome.csi) {
+            window.chrome.csi = () => ({
+              onloadT: Date.now(),
+              pageT: Math.random() * 1000,
+              startE: Date.now() - Math.random() * 2000
+            });
+          }
+
+          // Make chrome object non-enumerable to match real Chrome
+          Object.defineProperty(window, 'chrome', {
+            value: window.chrome,
+            writable: false,
+            enumerable: false,
+            configurable: true
+          });
+
+          // Add Chrome-specific globals that Cloudflare might check
+          if (!window.external) {
+            window.external = {
+              AddSearchProvider: () => {},
+              IsSearchProviderInstalled: () => 0
+            };
+          }
         }, 'Chrome runtime simulation');
 
         // Add realistic Chrome browser behavior
@@ -568,6 +638,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             plugins = [];
           }
           // Create proper array-like object with enumerable indices and length
+          // Create proper PluginArray-like object with required methods
           const pluginsArray = {};
           plugins.forEach((plugin, index) => {
             pluginsArray[index] = plugin;
@@ -581,6 +652,13 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             configurable: false
           });
 
+          // PluginArray methods that bot detectors check for
+          pluginsArray.item = function(i) { return plugins[i] || null; };
+          pluginsArray.namedItem = function(name) { return plugins.find(p => p.name === name) || null; };
+          pluginsArray.refresh = function() {};
+          pluginsArray[Symbol.iterator] = function*() { for (const p of plugins) yield p; };
+          pluginsArray[Symbol.toStringTag] = 'PluginArray';
+
           safeDefinePropertyLocal(navigator, 'plugins', { get: () => pluginsArray });
         }, 'plugins spoofing');
 
@@ -614,6 +692,71 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           spoofNavigatorProperties(navigator, vendorProps);
         }, 'vendor/product spoofing');
 
+        // navigator.userAgentData — Chrome's Client Hints JS API
+        // Detection scripts check this; headless may have it missing or inconsistent
+        safeExecute(() => {
+          if (!userAgent.includes('Chrome/')) return; // Only for Chrome UAs
+
+          const chromeMatch = userAgent.match(/Chrome\/(\d+)/);
+          const majorVersion = chromeMatch ? chromeMatch[1] : '145';
+
+          let platform = 'Windows';
+          let platformVersion = '15.0.0';
+          let architecture = 'x86';
+          let model = '';
+          let bitness = '64';
+          if (userAgent.includes('Macintosh') || userAgent.includes('Mac OS X')) {
+            platform = 'macOS';
+            platformVersion = '13.5.0';
+            architecture = 'arm';
+          } else if (userAgent.includes('X11; Linux')) {
+            platform = 'Linux';
+            platformVersion = '6.5.0';
+            architecture = 'x86';
+          }
+
+          const brands = [
+            { brand: 'Not:A-Brand', version: '99' },
+            { brand: 'Google Chrome', version: majorVersion },
+            { brand: 'Chromium', version: majorVersion }
+          ];
+
+          const uaData = {
+            brands: brands,
+            mobile: false,
+            platform: platform,
+            getHighEntropyValues: function(hints) {
+              const result = {
+                brands: brands,
+                mobile: false,
+                platform: platform,
+                architecture: architecture,
+                bitness: bitness,
+                model: model,
+                platformVersion: platformVersion,
+                fullVersionList: [
+                  { brand: 'Not:A-Brand', version: '99.0.0.0' },
+                  { brand: 'Google Chrome', version: majorVersion + '.0.7632.160' },
+                  { brand: 'Chromium', version: majorVersion + '.0.7632.160' }
+                ]
+              };
+              // Only return requested hints
+              const filtered = {};
+              for (const hint of hints) {
+                if (result.hasOwnProperty(hint)) filtered[hint] = result[hint];
+              }
+              return Promise.resolve(filtered);
+            },
+            toJSON: function() {
+              return { brands: brands, mobile: false, platform: platform };
+            }
+          };
+          Object.defineProperty(navigator, 'userAgentData', {
+            get: () => uaData,
+            configurable: true
+          });
+        }, 'navigator.userAgentData spoofing');
+
         // Enhanced OS fingerprinting protection based on actual user agent content
         //
         safeExecute(() => {
@@ -767,13 +910,18 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           };
         }, 'fingerprinting mocks');
 
+        // GPU identity — selected once per browser session, passed from Node.js
+        const GPU_VENDOR = gpuConfig.vendor;
+        const GPU_RENDERER = gpuConfig.renderer;
+        if (debugEnabled) console.log(`[fingerprint] GPU: ${GPU_VENDOR} / ${GPU_RENDERER}`);
+
         // WebGL spoofing
         //
         safeExecute(() => {
           // Enhanced WebGL fingerprinting protection
           const webglParams = {
-            37445: 'Intel Inc.',                    // VENDOR
-            37446: 'Intel(R) UHD Graphics 630',    // RENDERER (more realistic)
+            37445: GPU_VENDOR,                      // VENDOR
+            37446: GPU_RENDERER,                    // RENDERER
             7936: 'WebGL 1.0 (OpenGL ES 2.0 Chromium)', // VERSION
             35724: 'WebGL GLSL ES 1.0 (OpenGL ES GLSL ES 1.00 Chromium)', // SHADING_LANGUAGE_VERSION
             34076: 16384,                          // MAX_TEXTURE_SIZE
@@ -798,6 +946,14 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
               }
               return getParameter.call(this, parameter);
             };
+            // Intercept getExtension to control WEBGL_debug_renderer_info
+            const getExtension = WebGLRenderingContext.prototype.getExtension;
+            WebGLRenderingContext.prototype.getExtension = function(name) {
+              if (name === 'WEBGL_debug_renderer_info') {
+                return { UNMASKED_VENDOR_WEBGL: 37445, UNMASKED_RENDERER_WEBGL: 37446 };
+              }
+              return getExtension.call(this, name);
+            };
             // Spoof supported extensions
             const getSupportedExtensions = WebGLRenderingContext.prototype.getSupportedExtensions;
             WebGLRenderingContext.prototype.getSupportedExtensions = function() {
@@ -840,10 +996,72 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
               }
               return getParameter2.call(this, parameter);
             };
+            const getExtension2 = WebGL2RenderingContext.prototype.getExtension;
+            WebGL2RenderingContext.prototype.getExtension = function(name) {
+              if (name === 'WEBGL_debug_renderer_info') {
+                return { UNMASKED_VENDOR_WEBGL: 37445, UNMASKED_RENDERER_WEBGL: 37446 };
+              }
+              return getExtension2.call(this, name);
+            };
           }
         }, 'WebGL spoofing');
 
-        // Permissions API spoofing
+        // WebGL context patching — Proxy wrapper for real contexts + null-context safety
+        safeExecute(() => {
+          const webglSpoofParams = {
+            37445: GPU_VENDOR,
+            37446: GPU_RENDERER
+          };
+          const debugRendererExt = { UNMASKED_VENDOR_WEBGL: 37445, UNMASKED_RENDERER_WEBGL: 37446 };
+
+          const originalGetContext = HTMLCanvasElement.prototype.getContext;
+          HTMLCanvasElement.prototype.getContext = function(type, attrs) {
+            const ctx = originalGetContext.call(this, type, attrs);
+            if (type !== 'webgl' && type !== 'experimental-webgl' && type !== 'webgl2') return ctx;
+
+            const noop = () => {};
+
+            // Null context — return mock to prevent crashes
+            if (ctx === null) {
+              return new Proxy({}, {
+                get(_, prop) {
+                  if (prop === 'getShaderPrecisionFormat') return () => ({ rangeMin: 127, rangeMax: 127, precision: 23 });
+                  if (prop === 'getParameter') return (p) => webglSpoofParams[p] || 0;
+                  if (prop === 'getSupportedExtensions') return () => [];
+                  if (prop === 'getExtension') return (name) => {
+                    if (name === 'WEBGL_debug_renderer_info') return { UNMASKED_VENDOR_WEBGL: 37445, UNMASKED_RENDERER_WEBGL: 37446 };
+                    return null;
+                  };
+                  if (prop === 'canvas') return this;
+                  if (prop === 'drawingBufferWidth') return 1920;
+                  if (prop === 'drawingBufferHeight') return 1080;
+                  return noop;
+                }
+              });
+            }
+
+            // Real context — wrap in Proxy to intercept getParameter/getExtension
+            // Direct property assignment fails silently on native WebGL objects
+            return new Proxy(ctx, {
+              get(target, prop, receiver) {
+                if (prop === 'getParameter') {
+                  return function(param) {
+                    if (webglSpoofParams.hasOwnProperty(param)) return webglSpoofParams[param];
+                    return target.getParameter(param);
+                  };
+                }
+                if (prop === 'getExtension') {
+                  return function(name) {
+                    if (name === 'WEBGL_debug_renderer_info') return debugRendererExt;
+                    return target.getExtension(name);
+                  };
+                }
+                const val = Reflect.get(target, prop, receiver);
+                return typeof val === 'function' ? val.bind(target) : val;
+              }
+            });
+          };
+        }, 'WebGL context patching');        // Permissions API spoofing
         //
         safeExecute(() => {
           if (navigator.permissions?.query) {
@@ -895,6 +1113,118 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             };
           }
         }, 'media device spoofing');
+
+        // Window dimensions — headless Chrome reports 0 for outer dimensions
+        safeExecute(() => {
+          if (!window.outerWidth || window.outerWidth === 0 || window.outerWidth === window.innerWidth) {
+            Object.defineProperty(window, 'outerWidth', { get: () => window.innerWidth + 16, configurable: true });
+          }
+          if (!window.outerHeight || window.outerHeight === 0 || window.outerHeight === window.innerHeight) {
+            Object.defineProperty(window, 'outerHeight', { get: () => window.innerHeight + 88, configurable: true });
+          }
+          if (window.screenX === 0 && window.screenY === 0) {
+            const sX = Math.floor(Math.random() * 200);
+            const sY = Math.floor(Math.random() * 50) + 20;
+            Object.defineProperty(window, 'screenX', { get: () => sX });
+            Object.defineProperty(window, 'screenY', { get: () => sY });
+          }
+        }, 'window dimension spoofing');
+
+        // navigator.connection — missing or incomplete in headless
+        safeExecute(() => {
+          if (!navigator.connection) {
+            Object.defineProperty(navigator, 'connection', {
+              get: () => ({
+                effectiveType: '4g',
+                rtt: 50,
+                downlink: 10,
+                saveData: false,
+                type: 'wifi',
+                addEventListener: () => {},
+                removeEventListener: () => {}
+              })
+            });
+          }
+        }, 'connection API spoofing');
+
+        // navigator.pdfViewerEnabled — missing in headless, true in real Chrome
+        safeExecute(() => {
+          if (navigator.pdfViewerEnabled === undefined) {
+            Object.defineProperty(navigator, 'pdfViewerEnabled', {
+              get: () => true, configurable: true
+            });
+          }
+        }, 'pdfViewerEnabled spoofing');
+
+        // speechSynthesis — headless returns empty voices array
+        safeExecute(() => {
+          if (window.speechSynthesis) {
+            const origGetVoices = speechSynthesis.getVoices.bind(speechSynthesis);
+            speechSynthesis.getVoices = function() {
+              const voices = origGetVoices();
+              if (voices.length === 0) {
+                return [{
+                  default: true, lang: 'en-US', localService: true,
+                  name: 'Microsoft David - English (United States)', voiceURI: 'Microsoft David - English (United States)'
+                }, {
+                  default: false, lang: 'en-US', localService: true,
+                  name: 'Microsoft Zira - English (United States)', voiceURI: 'Microsoft Zira - English (United States)'
+                }];
+              }
+              return voices;
+            };
+          }
+        }, 'speechSynthesis spoofing');
+
+        // AudioContext — headless has distinct audio processing fingerprint
+        safeExecute(() => {
+          if (window.AudioContext || window.webkitAudioContext) {
+            const OrigAudioContext = window.AudioContext || window.webkitAudioContext;
+            const origCreateOscillator = OrigAudioContext.prototype.createOscillator;
+            const origCreateDynamicsCompressor = OrigAudioContext.prototype.createDynamicsCompressor;
+            
+            // Inject deterministic noise into audio output — consistent per session
+            const audioNoiseSeed = Math.random() * 0.01 - 0.005;
+            const compNoiseSeed = Math.random() * 0.1 - 0.05;
+            
+            OrigAudioContext.prototype.createOscillator = function() {
+              const osc = origCreateOscillator.call(this);
+              const origFreq = osc.frequency.value;
+              osc.frequency.value = origFreq + audioNoiseSeed;
+              return osc;
+            };
+            OrigAudioContext.prototype.createDynamicsCompressor = function() {
+              const comp = origCreateDynamicsCompressor.call(this);
+              const origThreshold = comp.threshold.value;
+              comp.threshold.value = origThreshold + compNoiseSeed;
+              return comp;
+            };
+          }
+        }, 'AudioContext fingerprint spoofing');
+
+        // Broken image dimensions — headless returns 0x0, real browsers show broken icon
+        safeExecute(() => {
+          // Patch Image constructor to intercept broken image detection
+          const OrigImage = window.Image;
+          window.Image = function(w, h) {
+            const img = arguments.length ? new OrigImage(w, h) : new OrigImage();
+            // After load attempt, if broken, fake dimensions
+            const origWidthDesc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'width');
+            const origHeightDesc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'height');
+            
+            // Monitor for broken state
+            img.addEventListener('error', function() {
+              // Force non-zero dimensions for broken images
+              Object.defineProperty(this, 'width', { get: () => 24, configurable: true });
+              Object.defineProperty(this, 'height', { get: () => 24, configurable: true });
+              Object.defineProperty(this, 'naturalWidth', { get: () => 24, configurable: true });
+              Object.defineProperty(this, 'naturalHeight', { get: () => 24, configurable: true });
+            });
+            return img;
+          };
+          window.Image.prototype = OrigImage.prototype;
+          Object.defineProperty(window, 'Image', { writable: true, configurable: true });
+        }, 'broken image dimension spoofing');
         
         // Fetch Request Headers Normalization
         //
@@ -938,21 +1268,9 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
 
         // CSS Media Query Spoofing
         //
-        safeExecute(() => {
-          const originalMatchMedia = window.matchMedia;
-          window.matchMedia = function(query) {
-            const result = originalMatchMedia.call(this, query);
-            // Add slight randomization to avoid fingerprinting for device queries
-            if (query.includes('device-width') || query.includes('device-height') || 
-                query.includes('aspect-ratio') || query.includes('color-gamut')) {
-              Object.defineProperty(result, 'matches', {
-                get: () => Math.random() > 0.1 ? originalMatchMedia.call(window, query).matches : !originalMatchMedia.call(window, query).matches,
-                configurable: true
-              });
-            }
-            return result;
-          };
-        }, 'CSS media query spoofing');
+        // CSS media query — pass through normally. Screen dimensions are already spoofed
+        // so matchMedia results will naturally reflect the spoofed values.
+        // No modification needed here.
 
         // Enhanced WebRTC Spoofing
         //
@@ -961,13 +1279,41 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             const OriginalRTC = window.RTCPeerConnection;
             window.RTCPeerConnection = function(...args) {
               const pc = new OriginalRTC(...args);
-              const originalCreateOffer = pc.createOffer;
-              pc.createOffer = function() {
-                return Promise.reject(new Error('WebRTC disabled'));
+              
+              // Intercept onicecandidate to strip local IP addresses
+              const origAddEventListener = pc.addEventListener.bind(pc);
+              pc.addEventListener = function(type, listener, ...rest) {
+                if (type === 'icecandidate') {
+                  const wrappedListener = function(event) {
+                    if (event.candidate && event.candidate.candidate) {
+                      // Strip candidates containing local/private IPs
+                      const c = event.candidate.candidate;
+                      if (c.includes('.local') || /(?:10|172\.(?:1[6-9]|2\d|3[01])|192\.168)\./.test(c)) {
+                        return; // suppress local IP candidates
+                      }
+                    }
+                    listener.call(this, event);
+                  };
+                  return origAddEventListener(type, wrappedListener, ...rest);
+                }
+                return origAddEventListener(type, listener, ...rest);
               };
+              
+              // Also intercept the property-based handler
+              let _onicecandidateHandler = null;
+              Object.defineProperty(pc, 'onicecandidate', {
+                get: () => _onicecandidateHandler,
+                set: (handler) => {
+                  _onicecandidateHandler = handler;
+                  // No-op — the addEventListener wrapper above handles filtering
+                },
+                configurable: true
+              });
+              
               return pc;
             };
             Object.setPrototypeOf(window.RTCPeerConnection, OriginalRTC);
+            window.RTCPeerConnection.prototype = OriginalRTC.prototype;
           }
         }, 'WebRTC spoofing');
 
@@ -1039,62 +1385,15 @@ 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
+            // Deterministic slight noise to text measurements
             const originalWidth = result.width;
+            const hash = text.length * 7 + (text.charCodeAt(0) || 0);
+            const noise = ((hash * 2654435761 >>> 0) % 100 - 50) / 500; // -0.1 to +0.1, deterministic per text
             return Object.create(result, {
-              width: { get: () => originalWidth + (Math.random() - 0.5) * 0.1 }
+              width: { get: () => originalWidth + noise }
             });
           };
 
-          // Comprehensive canvas fingerprinting protection
-          //
-          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
-                imageData.data[i] = Math.max(0, Math.min(255, imageData.data[i] + Math.floor(Math.random() * 3) - 1));
-                imageData.data[i + 1] = Math.max(0, Math.min(255, imageData.data[i + 1] + Math.floor(Math.random() * 3) - 1));
-                imageData.data[i + 2] = Math.max(0, Math.min(255, imageData.data[i + 2] + Math.floor(Math.random() * 3) - 1));
-              }
-            }
-            return imageData;
-          };
-          
-          // WebGL canvas context fingerprinting
-          const originalGetContext = HTMLCanvasElement.prototype.getContext;
-          HTMLCanvasElement.prototype.getContext = function(contextType, contextAttributes) {
-            const context = originalGetContext.call(this, contextType, contextAttributes);
-            
-            if (contextType === 'webgl' || contextType === 'webgl2' || contextType === 'experimental-webgl') {
-              // Override WebGL-specific fingerprinting methods
-              const originalGetShaderPrecisionFormat = context.getShaderPrecisionFormat;
-              context.getShaderPrecisionFormat = function(shaderType, precisionType) {
-                return {
-                  rangeMin: 127,
-                  rangeMax: 127,
-                  precision: 23
-                };
-              };
-              
-              const originalGetExtension = context.getExtension;
-              context.getExtension = function(name) {
-                // Block access to fingerprinting-sensitive extensions
-                if (name === 'WEBGL_debug_renderer_info') {
-                  return null;
-                }
-                return originalGetExtension.call(this, name);
-              };
-            }
-            
-            return context;
-          };
-
           // Override font detection methods
           //
           const originalOffsetWidth = Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'offsetWidth');
@@ -1104,7 +1403,10 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
             Object.defineProperty(HTMLElement.prototype, 'offsetWidth', {
               get: function() {
                 if (this.style && this.style.fontFamily) {
-                  return Math.floor(originalOffsetWidth.get.call(this) + (Math.random() - 0.5) * 2);
+                  const w = originalOffsetWidth.get.call(this);
+                  // Deterministic per font family — same font always gets same offset
+                  const fontHash = this.style.fontFamily.split('').reduce((a, c) => (a * 31 + c.charCodeAt(0)) & 0xffff, 0);
+                  return Math.floor(w + ((fontHash % 3) - 1));
                 }
                 return originalOffsetWidth.get.call(this);
               },
@@ -1125,24 +1427,75 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
         // Canvas fingerprinting protection
         //
         safeExecute(() => {
+          // Per-session seed — consistent within session, varies between sessions
+          const canvasSeed = Math.floor(Math.random() * 2147483647);
+          
+          // Simple seeded PRNG — deterministic for same input
+          function seededNoise(seed) {
+            let s = seed ^ 0x5DEECE66D;
+            s = (s * 1103515245 + 12345) & 0x7fffffff;
+            return s;
+          }
+
+          const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
+          CanvasRenderingContext2D.prototype.getImageData = function(sx, sy, sw, sh) {
+            const imageData = originalGetImageData.call(this, sx, sy, sw, sh);
+            if (imageData.data.length > 2000000) return imageData;
+            // Deterministic noise — same canvas content + position = same noise every call
+            for (let i = 0; i < imageData.data.length; i += 4) {
+              const n = seededNoise(canvasSeed ^ (i >> 2));
+              if ((n & 0xf) < 2) { // ~12.5% of pixels
+                const shift = (n >> 4 & 3) - 1; // -1, 0, or +1
+                imageData.data[i] = Math.max(0, Math.min(255, imageData.data[i] + shift));
+                imageData.data[i + 1] = Math.max(0, Math.min(255, imageData.data[i + 1] + shift));
+              }
+            }
+            return imageData;
+          };
+
           const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
           HTMLCanvasElement.prototype.toDataURL = function(...args) {
-            // Noise already applied by getImageData override
+            // Apply same deterministic noise by reading through spoofed getImageData
+            try {
+              const ctx = this.getContext('2d');
+              if (ctx && this.width > 0 && this.height > 0 && this.width * this.height < 500000) {
+                const imageData = ctx.getImageData(0, 0, this.width, this.height);
+                ctx.putImageData(imageData, 0, 0);
+              }
+            } catch (e) {} // WebGL or other context — skip
             return originalToDataURL.apply(this, args);
           };
+
+          const originalToBlob = HTMLCanvasElement.prototype.toBlob;
+          if (originalToBlob) {
+            HTMLCanvasElement.prototype.toBlob = function(callback, ...args) {
+              try {
+                const ctx = this.getContext('2d');
+                if (ctx && this.width > 0 && this.height > 0 && this.width * this.height < 500000) {
+                  const imageData = ctx.getImageData(0, 0, this.width, this.height);
+                  ctx.putImageData(imageData, 0, 0);
+                }
+              } catch (e) {}
+              return originalToBlob.call(this, callback, ...args);
+            };
+          }
         }, 'canvas fingerprinting protection');
 
         // Battery API spoofing
         //
         safeExecute(() => {
           if (navigator.getBattery) {
+            const batteryState = {
+              charging: Math.random() > 0.5,
+              chargingTime: Math.random() > 0.5 ? Infinity : Math.floor(Math.random() * 3600),
+              dischargingTime: Math.floor(Math.random() * 7200),
+              level: Math.round((Math.random() * 0.7 + 0.25) * 100) / 100,
+              addEventListener: () => {},
+              removeEventListener: () => {},
+              dispatchEvent: () => true
+            };
             navigator.getBattery = function() {
-              return Promise.resolve({
-                charging: Math.random() > 0.5,
-                chargingTime: Math.random() > 0.5 ? Infinity : Math.random() * 3600,
-                dischargingTime: Math.random() * 7200,
-                level: Math.random() * 0.99 + 0.01
-              });
+              return Promise.resolve(batteryState);
             };
           }
         }, 'battery API spoofing');
@@ -1265,7 +1618,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
           });
         }, 'location URL masking');
 
-      }, ua, forceDebug);
+      }, ua, forceDebug, selectedGpu);
     } catch (stealthErr) {
       if (stealthErr.message.includes('Session closed') || 
           stealthErr.message.includes('addScriptToEvaluateOnNewDocument timed out') ||

package/nwss.js

@@ -99,9 +99,9 @@ const CONCURRENCY_LIMITS = Object.freeze({
 
 // 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/142.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/142.0.0.0 Safari/537.36"],
-  ['chrome_linux', "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36"],
+  ['chrome', "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.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/145.0.0.0 Safari/537.36"],
+  ['chrome_linux', "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36"],
   ['firefox', "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0) Gecko/20100101 Firefox/145.0"],
   ['firefox_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:145.0) Gecko/20100101 Firefox/145.0"],
   ['firefox_linux', "Mozilla/5.0 (X11; Linux x86_64; rv:145.0) Gecko/20100101 Firefox/145.0"],
@@ -619,7 +619,7 @@ Redirect Handling Options:
   source: true/false                           Save page source HTML after load
   firstParty: true/false                       Allow first-party matches (default: false)
   thirdParty: true/false                       Allow third-party matches (default: true)
-  screenshot: true/false                       Capture screenshot on load failure
+  screenshot: true/false/\"force\"                Capture screenshot (true=on failure, \"force\"=always)
   headful: true/false                          Launch browser with GUI for this site
   fingerprint_protection: true/false/"random" Enable fingerprint spoofing: true/false/"random"
   adblock_rules: true/false                    Generate adblock filter rules with resource types for this site
@@ -1367,9 +1367,17 @@ function setupFrameHandling(page, forceDebug) {
     if (launchHeadless) {
       const puppeteerInfo = detectPuppeteerVersion();
       
+      // Check if any site needs fingerprint protection — use stealth-friendly headless mode
+      const needsStealth = sites.some(site => site.fingerprint_protection);
+      
       if (puppeteerInfo.useShellMode) {
-        headlessMode = 'shell'; // Use fast chrome-headless-shell for 22.x+
-        if (forceDebug) console.log(formatLogMessage('debug', `Using chrome-headless-shell (Puppeteer ${puppeteerInfo.version || 'v' + puppeteerInfo.majorVersion + '.x'})`));
+        if (needsStealth) {
+          headlessMode = 'new'; // Full Chrome in headless — harder to detect than chrome-headless-shell
+          if (forceDebug) console.log(formatLogMessage('debug', `Using headless=new for stealth (fingerprint_protection detected)`));
+        } else {
+          headlessMode = 'shell'; // Use fast chrome-headless-shell for 22.x+
+          if (forceDebug) console.log(formatLogMessage('debug', `Using chrome-headless-shell (Puppeteer ${puppeteerInfo.version || 'v' + puppeteerInfo.majorVersion + '.x'})`));
+        }
       } else {
         headlessMode = true; // Use regular headless for older versions
         if (forceDebug) console.log(formatLogMessage('debug', 'Could not detect Puppeteer version, using regular headless mode'));
@@ -1439,7 +1447,7 @@ function setupFrameHandling(page, forceDebug) {
         '--disable-features=SafeBrowsing',
         '--disable-dev-shm-usage',
         '--disable-sync',
-        '--disable-gpu',
+        '--use-gl=swiftshader',  // Software WebGL — prevents ad script crashes in headless
         '--mute-audio',
         '--disable-translate',
         '--window-size=1920,1080',
@@ -1494,7 +1502,9 @@ function setupFrameHandling(page, forceDebug) {
 
   // Log which headless mode is being used
   if (forceDebug && launchHeadless) {
-    console.log(formatLogMessage('debug', `Using chrome-headless-shell for maximum performance`));
+    const needsStealth = sites.some(site => site.fingerprint_protection);
+    const modeLabel = needsStealth ? 'headless=new (stealth mode)' : 'chrome-headless-shell (performance mode)';
+    console.log(formatLogMessage('debug', `Using ${modeLabel}`));
   }
 
   // Initial cleanup of any existing Chrome temp files - always comprehensive on startup
@@ -1652,6 +1662,11 @@ function setupFrameHandling(page, forceDebug) {
     let cdpSessionManager = null;
     // Use Map to track domains and their resource types for --adblock-rules or --dry-run
     const matchedDomains = (adblockRulesMode || siteConfig.adblock_rules || dryRunMode) ? new Map() : new Set();
+
+    // Local domain dedup scoped to THIS processUrl call only
+    // Prevents cross-config contamination from the global domain cache
+    const localDetectedDomains = new Set();
+    const isLocallyDetected = (domain) => localDetectedDomains.has(domain);
     
     // Initialize dry run matches collection
     if (dryRunMode) {
@@ -2159,14 +2174,14 @@ function setupFrameHandling(page, forceDebug) {
           }
                     
           await page.setExtraHTTPHeaders({
-            'Sec-CH-UA': '"Chromium";v="142", "Not=A?Brand";v="24", "Google Chrome";v="142"',
+            'Sec-CH-UA': '"Not:A-Brand";v="99", "Google Chrome";v="145", "Chromium";v="145"',
             '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': '"142.0.7444,69"',
-            'Sec-CH-UA-Full-Version-List': '"Chromium";v="142.0.7444,69", "Not=A?Brand";v="24.0.0.0", "Google Chrome";v="142.0.7444,69"'
+            'Sec-CH-UA-Full-Version': '"145.0.7632.160"',
+            'Sec-CH-UA-Full-Version-List': '"Not:A-Brand";v="99.0.0.0", "Google Chrome";v="145.0.7632.160", "Chromium";v="145.0.7632.160"'
           });
         }
       } catch (fingerprintErr) {
@@ -2430,6 +2445,7 @@ function setupFrameHandling(page, forceDebug) {
 
       // Mark full subdomain as detected for future reference
       markDomainAsDetected(cacheKey);
+      localDetectedDomains.add(cacheKey);
       
       // Also mark in smart cache with context (if cache is enabled)
       if (smartCache) {
@@ -2534,7 +2550,7 @@ function setupFrameHandling(page, forceDebug) {
               if (forceDebug) {
                 console.log(formatLogMessage('debug', `${messageColors.blocked('[adblock]')} ${checkedUrl} (${result.reason})`));
               }
-              request.abort();
+              request.abort('blockedbyclient');
               return;
             }
             adblockStats.allowed++;
@@ -2614,7 +2630,7 @@ function setupFrameHandling(page, forceDebug) {
             }
           }
           
-          request.abort();
+          request.abort('blockedbyclient');
           return;
         }
 
@@ -2724,7 +2740,7 @@ function setupFrameHandling(page, forceDebug) {
                 dryRunCallback: dryRunMode ? createEnhancedDryRunCallback(matchedDomains, forceDebug) : null,
                 matchedDomains,
                 addMatchedDomain,
-                isDomainAlreadyDetected,
+                isDomainAlreadyDetected: isLocallyDetected,
                 onWhoisResult: smartCache ? (domain, result) => smartCache.cacheNetTools(domain, 'whois', result) : undefined,
                 onDigResult: smartCache ? (domain, result, recordType) => smartCache.cacheNetTools(domain, 'dig', result, recordType) : undefined,
                 cachedWhois: smartCache ? smartCache.getCachedNetTools(reqDomain, 'whois') : null,
@@ -2773,8 +2789,8 @@ function setupFrameHandling(page, forceDebug) {
              }
             } else if (hasNetTools && !hasSearchString && !hasSearchStringAnd) {
              // If nettools are configured (whois/dig), perform checks on the domain
-             // Skip nettools check if full subdomain was already detected
-             if (isDomainAlreadyDetected(fullSubdomain)) {
+             // Skip nettools check if full subdomain was already detected in THIS scan
+             if (localDetectedDomains.has(fullSubdomain)) {
                if (forceDebug) {
                  console.log(formatLogMessage('debug', `Skipping nettools check for already detected subdomain: ${fullSubdomain}`));
                }
@@ -2833,7 +2849,7 @@ function setupFrameHandling(page, forceDebug) {
                dryRunCallback: dryRunMode ? createEnhancedDryRunCallback(matchedDomains, forceDebug) : null,
                matchedDomains,
                addMatchedDomain,
-               isDomainAlreadyDetected,
+               isDomainAlreadyDetected: isLocallyDetected,
                // Add cache callbacks if smart cache is available and caching is enabled
                onWhoisResult: smartCache ? (domain, result) => {
                  smartCache.cacheNetTools(domain, 'whois', result);
@@ -2863,8 +2879,8 @@ function setupFrameHandling(page, forceDebug) {
              }
            } else {
              // If searchstring or searchstring_and IS defined (with or without nettools), queue for content checking
-             // Skip searchstring check if full subdomain was already detected
-             if (isDomainAlreadyDetected(fullSubdomain)) {
+             // Skip searchstring check if full subdomain was already detected in THIS scan
+             if (localDetectedDomains.has(fullSubdomain)) {
                if (forceDebug) {
                  console.log(formatLogMessage('debug', `Skipping searchstring check for already detected subdomain: ${fullSubdomain}`));
                }
@@ -2920,7 +2936,7 @@ function setupFrameHandling(page, forceDebug) {
                    searchStringsAnd,
                    matchedDomains,
                    addMatchedDomain, // Pass the helper function
-                   isDomainAlreadyDetected,
+                   isDomainAlreadyDetected: isLocallyDetected,
                    onContentFetched: smartCache && !ignoreCache ? (url, content) => {
                      // Only cache if not bypassing cache
                      if (!shouldBypassCacheForUrl(url, siteConfig)) {
@@ -2956,7 +2972,7 @@ function setupFrameHandling(page, forceDebug) {
                    regexes,
                    matchedDomains,
                    addMatchedDomain,
-                   isDomainAlreadyDetected,
+                   isDomainAlreadyDetected: isLocallyDetected,
                    onContentFetched: smartCache && !ignoreCache ? (url, content) => {
                      // Only cache if not bypassing cache
                      if (!shouldBypassCacheForUrl(url, siteConfig)) {
@@ -3027,7 +3043,7 @@ function setupFrameHandling(page, forceDebug) {
          matchedDomains,
          addMatchedDomain, // Pass the helper function
          bypassCache: (url) => shouldBypassCacheForUrl(url, siteConfig),
-         isDomainAlreadyDetected,
+         isDomainAlreadyDetected: isLocallyDetected,
          onContentFetched: smartCache && !ignoreCache ? (url, content) => {
            // Only cache if not bypassing cache
            if (!shouldBypassCacheForUrl(url, siteConfig)) {
@@ -3374,8 +3390,16 @@ function setupFrameHandling(page, forceDebug) {
         
         // Mark page as processing during interactions
         updatePageUsage(page, true);
-        // Use enhanced interaction module
-        await performPageInteraction(page, currentUrl, interactionConfig, forceDebug);
+        // Use enhanced interaction module with hard abort timeout
+        const INTERACTION_HARD_TIMEOUT = 15000;
+        try {
+          await Promise.race([
+            performPageInteraction(page, currentUrl, interactionConfig, forceDebug),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('interaction hard timeout')), INTERACTION_HARD_TIMEOUT))
+          ]);
+        } catch (interactTimeoutErr) {
+          if (forceDebug) console.log(formatLogMessage('debug', `[interaction] Aborted after ${INTERACTION_HARD_TIMEOUT}ms: ${interactTimeoutErr.message}`));
+        }
       }
 
       const delayMs = DEFAULT_DELAY;
@@ -3799,6 +3823,20 @@ function setupFrameHandling(page, forceDebug) {
           });
         } catch (gcErr) { /* ignore */ }
 
+        // Force screenshot — always capture regardless of success/failure
+        if (siteConfig.screenshot === 'force' && page && !page.isClosed()) {
+          const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+          const safeUrl = currentUrl.replace(/https?:\/\//, '').replace(/[^a-zA-Z0-9]/g, '_').substring(0, 80);
+          const filename = `screenshots/${safeUrl}-${timestamp}.png`;
+          try {
+            if (!fs.existsSync('screenshots')) fs.mkdirSync('screenshots', { recursive: true });
+            await page.screenshot({ path: filename, type: 'png', fullPage: true });
+            console.log(formatLogMessage('info', `Screenshot saved: ${filename}`));
+          } catch (screenshotErr) {
+            console.warn(messageColors.warn(`[screenshot failed] ${currentUrl}: ${screenshotErr.message}`));
+          }
+        }
+
         try {
           await page.close();
           if (forceDebug) console.log(formatLogMessage('debug', `Page closed for ${currentUrl}`));

package/package.json

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