@fanboynz/network-scanner 2.0.52 → 2.0.54

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,31 +996,89 @@ 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');
 
-        // WebGL null-context safety net � prevents ad script crashes in headless
+        // 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 (ctx !== null || (type !== 'webgl' && type !== 'experimental-webgl' && type !== 'webgl2')) return ctx;
-            // Return minimal mock so scripts calling getShaderPrecisionFormat etc. don't crash
+            if (type !== 'webgl' && type !== 'experimental-webgl' && type !== 'webgl2') return ctx;
+
             const noop = () => {};
-            return new Proxy({}, {
-              get(_, prop) {
-                if (prop === 'getShaderPrecisionFormat') return () => ({ rangeMin: 127, rangeMax: 127, precision: 23 });
-                if (prop === 'getParameter') return (p) => ({ 37445: 'Intel Inc.', 37446: 'Intel(R) UHD Graphics 630' }[p] || 0);
-                if (prop === 'getSupportedExtensions') return () => [];
-                if (prop === 'getExtension') return () => null;
-                if (prop === 'canvas') return this;
-                if (prop === 'drawingBufferWidth') return 1920;
-                if (prop === 'drawingBufferHeight') return 1080;
-                return noop;
+
+            // Null context — return mock to prevent crashes
+            if (ctx === null) {
+              const canvasEl = this; // capture the actual canvas element
+              const mock = new Proxy({}, {
+                get(target, 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 === 'getContextAttributes') return () => ({
+                    alpha: true, antialias: true, depth: true, failIfMajorPerformanceCaveat: false,
+                    desynchronized: false, premultipliedAlpha: true, preserveDrawingBuffer: false,
+                    powerPreference: 'default', stencil: false, xrCompatible: false
+                  });
+                  if (prop === 'isContextLost') return () => false;
+                  if (prop === 'canvas') return canvasEl;
+                  if (prop === 'drawingBufferWidth') return canvasEl.width || 1920;
+                  if (prop === 'drawingBufferHeight') return canvasEl.height || 1080;
+                  if (prop === 'drawingBufferColorSpace') return 'srgb';
+                  // Identity — let prototype chain handle constructor/toString/Symbol.toStringTag
+                  if (prop === 'constructor') return WebGLRenderingContext;
+                  if (prop === Symbol.toStringTag) return 'WebGLRenderingContext';
+                  // Common draw/state methods — return noop to prevent crashes
+                  return noop;
+                }
+              });
+              // Make mock pass instanceof checks
+              if (window.WebGLRenderingContext) {
+                Object.setPrototypeOf(mock, WebGLRenderingContext.prototype);
+              }
+              return mock;
+            }
+
+            // 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 null-context safety net');        // Permissions API spoofing
+        }, 'WebGL context patching');        // Permissions API spoofing
         //
         safeExecute(() => {
           if (navigator.permissions?.query) {
@@ -916,6 +1130,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
         //
@@ -959,21 +1285,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
         //
@@ -982,13 +1296,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');
 
@@ -1060,62 +1402,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');
@@ -1125,7 +1420,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);
               },
@@ -1146,24 +1444,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');
@@ -1286,7 +1635,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/lib/nettools.js

@@ -11,6 +11,20 @@ const execPromise = util.promisify(exec);
 // Cycling index for whois server rotation
 let whoisServerCycleIndex = 0;
 
+// Global dig result cache — shared across ALL handler instances and processUrl calls
+// Key: `${domain}-${recordType}`, Value: { result, timestamp }
+// DNS records don't change based on what terms you're searching for,
+// so we cache the raw dig output and let each handler check its own terms against it
+const globalDigResultCache = new Map();
+const GLOBAL_DIG_CACHE_TTL = 300000; // 5 minutes
+const GLOBAL_DIG_CACHE_MAX = 500;
+
+// Global whois result cache — shared across ALL handler instances and processUrl calls
+// Whois data is per root domain and doesn't change based on search terms
+const globalWhoisResultCache = new Map();
+const GLOBAL_WHOIS_CACHE_TTL = 900000; // 15 minutes (whois data changes less frequently)
+const GLOBAL_WHOIS_CACHE_MAX = 500;
+
 /**
  * Strips ANSI color codes from a string for clean file logging
  * @param {string} text - Text that may contain ANSI codes
@@ -26,27 +40,28 @@ function stripAnsiColors(text) {
  * @returns {Object} Object with isAvailable boolean and version/error info
  */
 function validateWhoisAvailability() {
+  if (validateWhoisAvailability._cached) return validateWhoisAvailability._cached;
   try {
     const result = execSync('whois --version 2>&1', { encoding: 'utf8' });
-    return {
+    validateWhoisAvailability._cached = {
       isAvailable: true,
       version: result.trim()
     };
   } catch (error) {
-    // Some systems don't have --version, try just whois
     try {
       execSync('which whois', { encoding: 'utf8' });
-      return {
+      validateWhoisAvailability._cached = {
         isAvailable: true,
         version: 'whois (version unknown)'
       };
     } catch (e) {
-      return {
+      validateWhoisAvailability._cached = {
         isAvailable: false,
         error: 'whois command not found'
       };
     }
   }
+  return validateWhoisAvailability._cached;
 }
 
 /**
@@ -54,18 +69,20 @@ function validateWhoisAvailability() {
  * @returns {Object} Object with isAvailable boolean and version/error info
  */
 function validateDigAvailability() {
+  if (validateDigAvailability._cached) return validateDigAvailability._cached;
   try {
     const result = execSync('dig -v 2>&1', { encoding: 'utf8' });
-    return {
+    validateDigAvailability._cached = {
       isAvailable: true,
       version: result.split('\n')[0].trim()
     };
   } catch (error) {
-    return {
+    validateDigAvailability._cached = {
       isAvailable: false,
       error: 'dig command not found'
     };
   }
+  return validateDigAvailability._cached;
 }
 
 /**
@@ -635,8 +652,8 @@ async function digLookup(domain = '', recordType = 'A', timeout = 5000) {
     // Clean domain
     const cleanDomain = domain.replace(/^https?:\/\//, '').replace(/\/.*$/, '').replace(/:\d+$/, '');
     
-    // Get short output first
-    const { stdout, stderr } = await execWithTimeout(`dig +short "${cleanDomain}" ${recordType}`, timeout);
+    // Single dig command — full output contains everything including the short answers
+    const { stdout: fullOutput, stderr } = await execWithTimeout(`dig "${cleanDomain}" ${recordType}`, timeout);
     
     if (stderr && stderr.trim()) {
       return {
@@ -647,13 +664,21 @@ async function digLookup(domain = '', recordType = 'A', timeout = 5000) {
       };
     }
     
-    // Also get full dig output for detailed analysis
-    const { stdout: fullOutput } = await execWithTimeout(`dig "${cleanDomain}" ${recordType}`, timeout);
+    // Extract short output from ANSWER SECTION of full dig output
+    const answerMatch = fullOutput.match(/;; ANSWER SECTION:\n([\s\S]*?)(?:\n;;|\n*$)/);
+    let shortOutput = '';
+    if (answerMatch) {
+      shortOutput = answerMatch[1]
+        .split('\n')
+        .map(line => line.split(/\s+/).pop())
+        .filter(Boolean)
+        .join('\n');
+    }
     
     return {
       success: true,
       output: fullOutput,
-      shortOutput: stdout.trim(),
+      shortOutput,
       domain: cleanDomain,
       recordType
     };
@@ -766,7 +791,6 @@ function createNetToolsHandler(config) {
     whoisDelay = 4000,
     whoisServer,
     whoisServerMode = 'random',
-    bufferedLogWrite = null,
     debugLogFile = null,
     digTerms,
     digOrTerms,
@@ -807,20 +831,10 @@ function createNetToolsHandler(config) {
     subdomain: digSubdomain
   });
 
-  // Add whois resolution caching to avoid redundant whois lookups
-  const whoisResultCache = new Map();
-  const WHOIS_CACHE_TTL = 900000; // 15 minutes cache TTL (whois data changes less frequently)
-  const MAX_CACHE_SIZE = 400; // Larger cache for whois due to longer TTL
-  // Size          Memory
-  // 100          ~900KB
-  // 200          1.8MB
-  // 300          2.6MB
-  // 400          3.4MB
-  // 500          4.2MB  
-  // Add DNS resolution caching to avoid redundant dig lookups
-  const digResultCache = new Map();
-  const DIG_CACHE_TTL = 300000; // 5 minutes cache TTL
-  const DIG_MAX_CACHE_SIZE = 400; // Smaller cache for dig due to shorter TTL
+  // Whois cache is global (globalWhoisResultCache) — shared across all handler instances
+  // Whois data is per root domain and doesn't change based on search terms
+  // Dig cache is global (globalDigResultCache) — shared across all handler instances
+  // DNS results are the same regardless of search terms
   
   return async function handleNetToolsCheck(domain, fullSubdomain) {
     // Use fullSubdomain parameter instead of originalDomain to maintain consistency
@@ -844,19 +858,17 @@ function createNetToolsHandler(config) {
 
     // Move the logToConsoleAndFile function declaration from later in the file to here:
     function logToConsoleAndFile(message) {
+      // Note: This function needs access to forceDebug, debugLogFile, and fs from the parent scope
+      // These are passed in via the config object to createNetToolsHandler
+      // forceDebug, debugLogFile, and fs are available in this closure
+
+      // Always log to console when in debug mode
       if (forceDebug) {
         console.log(formatLogMessage('debug', message));
       }
       
-      if (debugLogFile && bufferedLogWrite) {
-        try {
-          const timestamp = new Date().toISOString();
-          const cleanMessage = stripAnsiColors(message);
-          bufferedLogWrite(debugLogFile, `${timestamp} [debug nettools] ${cleanMessage}\n`);
-        } catch (logErr) {
-          // Silently fail file logging to avoid disrupting whois operations
-        }
-      } else if (debugLogFile && fs) {
+      // Also log to file if debug file logging is enabled
+      if (debugLogFile && fs) {
         try {
           const timestamp = new Date().toISOString();
           const cleanMessage = stripAnsiColors(message);
@@ -982,9 +994,9 @@ function createNetToolsHandler(config) {
         const now = Date.now();
         let whoisResult = null;
         
-        if (whoisResultCache.has(whoisCacheKey)) {
-          const cachedEntry = whoisResultCache.get(whoisCacheKey);
-          if (now - cachedEntry.timestamp < WHOIS_CACHE_TTL) {
+        if (globalWhoisResultCache.has(whoisCacheKey)) {
+          const cachedEntry = globalWhoisResultCache.get(whoisCacheKey);
+          if (now - cachedEntry.timestamp < GLOBAL_WHOIS_CACHE_TTL) {
             if (forceDebug) {
               const age = Math.round((now - cachedEntry.timestamp) / 1000);
               const serverInfo = (selectedServer && selectedServer !== '') ? ` (server: ${selectedServer})` : ' (default server)';
@@ -998,7 +1010,7 @@ function createNetToolsHandler(config) {
             });
           } else {
             // Cache expired, remove it
-            whoisResultCache.delete(whoisCacheKey);
+            globalWhoisResultCache.delete(whoisCacheKey);
             if (forceDebug) {
               logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cache expired for ${whoisRootDomain}, performing fresh lookup`);
             }
@@ -1030,7 +1042,7 @@ function createNetToolsHandler(config) {
                  !whoisResult.error.toLowerCase().includes('connection') &&
                  !whoisResult.error.toLowerCase().includes('network'))) {
               
-              whoisResultCache.set(whoisCacheKey, {
+              globalWhoisResultCache.set(whoisCacheKey, {
                 result: whoisResult,
                 timestamp: now
               });
@@ -1183,17 +1195,17 @@ function createNetToolsHandler(config) {
         }
         
         // Periodic whois cache cleanup to prevent memory leaks
-        if (whoisResultCache.size > MAX_CACHE_SIZE) {
+        if (globalWhoisResultCache.size > GLOBAL_WHOIS_CACHE_MAX) {
           const now = Date.now();
           let cleanedCount = 0;
-          for (const [key, entry] of whoisResultCache.entries()) {
-            if (now - entry.timestamp > WHOIS_CACHE_TTL) {
-              whoisResultCache.delete(key);
+          for (const [key, entry] of globalWhoisResultCache.entries()) {
+            if (now - entry.timestamp > GLOBAL_WHOIS_CACHE_TTL) {
+              globalWhoisResultCache.delete(key);
               cleanedCount++;
             }
           }
           if (forceDebug && cleanedCount > 0) {
-            logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${whoisResultCache.size}`);
+            logToConsoleAndFile(`${messageColors.highlight('[whois-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${globalWhoisResultCache.size}`);
           }
         }
       }
@@ -1216,16 +1228,16 @@ function createNetToolsHandler(config) {
           const now = Date.now();
           let digResult = null;
           
-          if (digResultCache.has(digCacheKey)) {
-            const cachedEntry = digResultCache.get(digCacheKey);
-            if (now - cachedEntry.timestamp < DIG_CACHE_TTL) {
+          if (globalDigResultCache.has(digCacheKey)) {
+            const cachedEntry = globalDigResultCache.get(digCacheKey);
+            if (now - cachedEntry.timestamp < GLOBAL_DIG_CACHE_TTL) {
               if (forceDebug) {
                 logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Using cached result for ${digDomain} (${digRecordType}) [age: ${Math.round((now - cachedEntry.timestamp) / 1000)}s]`);
               }
               digResult = cachedEntry.result;
             } else {
               // Cache expired, remove it
-              digResultCache.delete(digCacheKey);
+              globalDigResultCache.delete(digCacheKey);
             }
           }
           
@@ -1233,7 +1245,7 @@ function createNetToolsHandler(config) {
           digResult = await digLookup(digDomain, digRecordType, 5000); // 5 second timeout for dig
             
             // Cache the result for future use
-            digResultCache.set(digCacheKey, {
+            globalDigResultCache.set(digCacheKey, {
               result: digResult,
               timestamp: now
             });
@@ -1303,17 +1315,17 @@ function createNetToolsHandler(config) {
         }
         
         // Periodic dig cache cleanup to prevent memory leaks
-        if (digResultCache.size > DIG_MAX_CACHE_SIZE) {
+        if (globalDigResultCache.size > GLOBAL_DIG_CACHE_MAX) {
           const now = Date.now();
           let cleanedCount = 0;
-          for (const [key, entry] of digResultCache.entries()) {
-            if (now - entry.timestamp > DIG_CACHE_TTL) {
-              digResultCache.delete(key);
+          for (const [key, entry] of globalDigResultCache.entries()) {
+            if (now - entry.timestamp > GLOBAL_DIG_CACHE_TTL) {
+              globalDigResultCache.delete(key);
               cleanedCount++;
             }
           }
           if (forceDebug && cleanedCount > 0) {
-            logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${digResultCache.size}`);
+            logToConsoleAndFile(`${messageColors.highlight('[dig-cache]')} Cleaned ${cleanedCount} expired entries, cache size: ${globalDigResultCache.size}`);
           }
         }
       }
@@ -1387,12 +1399,7 @@ function createNetToolsHandler(config) {
           
           // Add whois server info to log if custom server was used
           const serverInfo = whoisServer ? ` (whois-server: ${selectWhoisServer(whoisServer)})` : '';
-          const logLine = `${timestamp} [match][${simplifiedUrl}] ${domain} (${matchType.join(' + ')})${serverInfo}\n`;
-          if (bufferedLogWrite) {
-            bufferedLogWrite(matchedUrlsLogFile, logLine);
-          } else {
-            fs.appendFileSync(matchedUrlsLogFile, logLine);
-          }
+          fs.appendFileSync(matchedUrlsLogFile, `${timestamp} [match][${simplifiedUrl}] ${domain} (${matchType.join(' + ')})${serverInfo}\n`);
         }
       }
       

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
@@ -1447,7 +1447,7 @@ function setupFrameHandling(page, forceDebug) {
         '--disable-features=SafeBrowsing',
         '--disable-dev-shm-usage',
         '--disable-sync',
-        '--use-gl=swiftshader',  // Software WebGL — prevents ad script crashes in headless
+        '--disable-gpu',  // WebGL null-context handled by fingerprint.js Proxy mock
         '--mute-audio',
         '--disable-translate',
         '--window-size=1920,1080',
@@ -2174,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) {
@@ -2515,7 +2515,7 @@ function setupFrameHandling(page, forceDebug) {
           if (forceDebug) {
             console.log(formatLogMessage('debug', `Blocking potential infinite iframe loop: ${checkedUrl}`));
           }
-          request.abort('blockedbyclient');
+          request.abort();
           return;
         }
 
@@ -2730,9 +2730,7 @@ function setupFrameHandling(page, forceDebug) {
                 whoisDelay: siteConfig.whois_delay !== undefined ? siteConfig.whois_delay : whois_delay,
                 whoisServer,
                 whoisServerMode: siteConfig.whois_server_mode || whois_server_mode,
-                bufferedLogWrite,
                 debugLogFile,
-                fs,
                 digTerms,
                 digOrTerms,
                 digRecordType,
@@ -2838,9 +2836,7 @@ function setupFrameHandling(page, forceDebug) {
                whoisDelay: siteConfig.whois_delay !== undefined ? siteConfig.whois_delay : whois_delay, // Site-specific or global fallback
 	       whoisServer, // Pass whois server configuration
                whoisServerMode: siteConfig.whois_server_mode || whois_server_mode,
-               bufferedLogWrite,
-               debugLogFile, // Pass debug log file for whois error logging
-               fs, // Pass fs module for file operations
+               debugLogFile,
                digTerms,
                digOrTerms,
                digRecordType,
@@ -3823,6 +3819,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.52",
+  "version": "2.0.54",
   "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": {