@fanboynz/network-scanner 2.0.66 → 3.0.0

package/lib/interaction.js

@@ -34,8 +34,7 @@
  * - mouseMovements: number - Number of mouse movements to perform
  * - includeScrolling: boolean - Enable scrolling simulation
  * - includeElementClicks: boolean - Enable safe element clicking
- * - includeTyping: boolean - Enable typing simulation
- * 
+ *
  * ANTI-DETECTION FEATURES:
  * - Variable timing between actions
  * - Curved mouse movements (not straight lines)
@@ -54,6 +53,14 @@
  * @requires puppeteer
  */
  
+const { formatLogMessage, messageColors } = require('./colorize');
+
+// Precomputed colored '[interaction]' subsystem prefix. formatLogMessage only
+// colors the [severity] tag; this constant colors the subsystem prefix so
+// '[debug] [interaction] X' has both tags visually distinct, matching how
+// every other module in the codebase emits its subsystem logs.
+const INTERACTION_TAG = messageColors.processing('[interaction]');
+
 // Fast setTimeout helper for Puppeteer 22.x compatibility
 // Uses standard Promise constructor for better performance than node:timers/promises
 function fastTimeout(ms) {
@@ -75,16 +82,21 @@ const COORDINATE_MARGINS = {
 };
 
 // === MOUSE MOVEMENT CONSTANTS ===
-// Fine-tune mouse movement behavior for realism vs. speed
+// Values reflect what the code ACTUALLY uses after the perf scale-back —
+// the original 5-30 step plan was cut to 2-8 to keep per-URL interaction
+// under ~300ms. Curve/jitter math is mostly cosmetic at these step counts;
+// the scanner doesn't need elaborate anti-bot curves to trigger onclick/
+// scroll handlers, so this is the right size.
 const MOUSE_MOVEMENT = {
-  MIN_STEPS: 5,              // Minimum steps for any movement
-  DEFAULT_STEPS: 15,         // Default steps for mouse movement
-  MAX_STEPS: 30,             // Maximum steps to prevent excessive slowness
+  MIN_STEPS: 2,              // Minimum steps for any movement
+  DEFAULT_STEPS: 6,          // Default steps when distance-derived
+  MAX_STEPS: 8,              // Hard cap to keep movements under ~300ms
   MIN_DELAY: 5,              // Minimum milliseconds between movement steps
   MAX_DELAY: 25,             // Maximum milliseconds between movement steps
-  DEFAULT_CURVE: 0.2,        // Default curve intensity (reduced for performance)
+  MAX_TOTAL_MS: 300,         // Emergency cap on total movement time
+  DEFAULT_CURVE: 0.2,        // Default curve intensity (mostly cosmetic at low step counts)
   DEFAULT_JITTER: 2,         // Default random jitter in pixels
-  DISTANCE_STEP_RATIO: 200,  // CRITICAL: 4x increase to drastically reduce steps
+  DISTANCE_STEP_RATIO: 200,  // Pixels per step when auto-calculating step count
   CURVE_INTENSITY_RATIO: 0.01 // Multiplier for curve calculation
 };
 
@@ -105,13 +117,9 @@ const TIMING = {
   CLICK_PAUSE_MAX: 200,           // Maximum pause before clicking
   POST_CLICK_MIN: 300,            // Minimum pause after clicking
   POST_CLICK_MAX: 500,            // Maximum pause after clicking
-  TYPING_MIN_DELAY: 50,           // Minimum delay between keystrokes
-  TYPING_MAX_DELAY: 150,          // Maximum delay between keystrokes
-  MISTAKE_PAUSE_MIN: 100,         // Minimum pause after typing mistake
-  MISTAKE_PAUSE_MAX: 200,         // Maximum pause after typing mistake
-  BACKSPACE_DELAY_MIN: 50,        // Minimum delay before backspace
-  BACKSPACE_DELAY_MAX: 100,       // Maximum delay before backspace
   DEFAULT_INTERACTION_DURATION: 2000 // Default total interaction time
+  // Note: TYPING_*, MISTAKE_PAUSE_*, BACKSPACE_DELAY_* removed along with
+  // simulateTyping() — they were only consumed by that dead-code function.
 };
 
 // === ELEMENT INTERACTION CONSTANTS ===
@@ -119,8 +127,9 @@ const TIMING = {
 const ELEMENT_INTERACTION = {
   MAX_ATTEMPTS: 3,           // Maximum attempts to find clickable elements
   TIMEOUT: 2000,             // Timeout for element operations
-  TEXT_PREVIEW_LENGTH: 50,   // Characters to capture for element text preview
-  MISTAKE_RATE: 0.02         // Probability of typing mistakes (0.02 = 2% chance)
+  TEXT_PREVIEW_LENGTH: 50    // Characters to capture for element text preview
+  // Note: MISTAKE_RATE removed with simulateTyping() — it was that function's
+  // only consumer.
 };
 
 // === CONTENT CLICK CONSTANTS ===
@@ -132,7 +141,11 @@ const CONTENT_CLICK = {
   CLICK_COUNT: 2,            // Two attempts (primary + backup if first suppressed)
   INTER_CLICK_MIN: 300,      // Minimum ms between clicks (above Monetag 250ms cooldown)
   INTER_CLICK_MAX: 500,      // Maximum ms between clicks
-  PRE_CLICK_DELAY: 300,      // Small buffer for late-loading async ad scripts
+  // PRE_CLICK_DELAY: most ad scripts register document-level listeners
+  // within 50–100ms of DOMContentLoaded. The prior mouse/scroll activity
+  // (~500ms+) gives them plenty of head start before this fires, so the
+  // 300ms buffer here was mostly defensive. Reduced to 100ms.
+  PRE_CLICK_DELAY: 100,
   VIEWPORT_INSET: 0.2,       // Avoid outer 20% of viewport (menus, overlays)
   MOUSE_APPROACH_STEPS: 3    // Minimal steps — just enough for non-instant movement
 };
@@ -168,7 +181,13 @@ const SITE_DURATIONS = {
 // === PROBABILITY CONSTANTS ===
 // Control randomness and behavior patterns
 const PROBABILITIES = {
-  PAUSE_CHANCE: 0.3,        // 30% chance of random pause during movement
+  // PAUSE_CHANCE: probability of a 25–75ms idle pause between mouse motions.
+  // Bot detectors mainly look at timing variance WITHIN a single mouse trail
+  // (the per-step delays in humanLikeMouseMove already cover that), so the
+  // inter-movement pause is mostly cosmetic. Lowered from 0.3 to 0.1 to cut
+  // ~30ms average per interaction while keeping enough variance to avoid
+  // perfectly metronomic action spacing.
+  PAUSE_CHANCE: 0.1,
   SCROLL_DOWN_BIAS: 0.7,    // 70% chance to scroll down (vs up)
   EDGE_PREFERENCE: {        // Probabilities for edge selection in preferEdges mode
     LEFT: 0.25,             // 0-25% = left edge
@@ -178,34 +197,19 @@ const PROBABILITIES = {
   }
 };
 
-// === PERFORMANCE OPTIMIZATION VARIABLES ===
-// Viewport caching to reduce repeated page.viewport() calls
-let cachedViewport = null;
-let lastViewportCheck = 0;
-const VIEWPORT_CACHE_DURATION = 30000; // 30 seconds
-let interactionMemoryCleanupCounter = 0;
-
 /**
- * Gets viewport dimensions with caching for performance
- * Caches viewport for 30 seconds to avoid repeated queries
- * 
+ * Returns viewport dimensions, with a safe fallback to DEFAULT_VIEWPORT if
+ * the page hasn't been given a viewport or the query throws. No caching —
+ * page.viewport() is an in-memory getter, not a CDP round-trip, so there's
+ * nothing to save by caching it.
+ *
  * @param {import('puppeteer').Page} page - Puppeteer page object
  * @returns {Promise<object>} Viewport dimensions {width, height}
  */
-async function getCachedViewport(page) {
-  const now = Date.now();
-  
-  // Return cached viewport if still valid
-  if (cachedViewport && (now - lastViewportCheck) < VIEWPORT_CACHE_DURATION) {
-    return cachedViewport;
-  }
-  
+async function getViewport(page) {
   try {
-    cachedViewport = await page.viewport();
-    lastViewportCheck = now;
-    return cachedViewport || { width: DEFAULT_VIEWPORT.WIDTH, height: DEFAULT_VIEWPORT.HEIGHT };
-  } catch (viewportErr) {
-    // Return defaults if viewport query fails
+    return (await page.viewport()) || { width: DEFAULT_VIEWPORT.WIDTH, height: DEFAULT_VIEWPORT.HEIGHT };
+  } catch (_) {
     return { width: DEFAULT_VIEWPORT.WIDTH, height: DEFAULT_VIEWPORT.HEIGHT };
   }
 }
@@ -278,11 +282,20 @@ function generateRandomCoordinates(maxX = DEFAULT_VIEWPORT.WIDTH, maxY = DEFAULT
     const centerX = maxX / 2;
     const centerY = maxY / 2;
     const avoidRadius = Math.min(maxX, maxY) * COORDINATE_MARGINS.CENTER_AVOID_RATIO;
-    
+
+    // Iteration cap: for sensible viewports a valid point is found in ~1
+    // try, but a pathologically small viewport could in principle have
+    // every candidate inside avoidRadius. After 50 attempts give up and
+    // return the last sample — a near-center point is preferable to an
+    // infinite loop.
+    let attempts = 0;
     do {
       x = Math.floor(Math.random() * (maxX - 2 * marginX)) + marginX;
       y = Math.floor(Math.random() * (maxY - 2 * marginY)) + marginY;
-    } while (Math.sqrt((x - centerX) ** 2 + (y - centerY) ** 2) < avoidRadius);
+    } while (
+      Math.sqrt((x - centerX) ** 2 + (y - centerY) ** 2) < avoidRadius &&
+      ++attempts < 50
+    );
   } else {
     // Standard random coordinates
     x = Math.floor(Math.random() * (maxX - 2 * marginX)) + marginX;
@@ -349,28 +362,25 @@ async function humanLikeMouseMove(page, fromX, fromY, toX, toY, options = {}) {
   } = options;
 
   const distance = Math.sqrt((toX - fromX) ** 2 + (toY - fromY) ** 2);
-  
-  // FIXED: More aggressive step capping to prevent excessive delays
+
+  // Step count: caller-provided value capped at MAX_STEPS, otherwise derived
+  // from distance and clamped to [MIN_STEPS, DEFAULT_STEPS].
   let actualSteps;
   if (options.steps) {
-    // CRITICAL: Much lower step cap to prevent timeouts
-    actualSteps = Math.min(options.steps, 8); // Was MAX_STEPS (30), now max 8
+    actualSteps = Math.min(options.steps, MOUSE_MOVEMENT.MAX_STEPS);
   } else {
-    // Calculate steps based on distance with strict limits
     const calculatedSteps = Math.floor(distance / MOUSE_MOVEMENT.DISTANCE_STEP_RATIO);
     actualSteps = Math.max(
-      2,  // Min 2 steps instead of 5
-      Math.min(calculatedSteps, 6)  // Max 6 steps instead of 30
+      MOUSE_MOVEMENT.MIN_STEPS,
+      Math.min(calculatedSteps, MOUSE_MOVEMENT.DEFAULT_STEPS)
     );
   }
 
-  // CRITICAL: Emergency timeout - never exceed 300ms for mouse movement
-  const maxTotalTime = 300; // 300ms maximum (was 2000ms)
+  // Emergency cap on total movement time — if step count × max-per-step delay
+  // would exceed the budget, reduce step count to fit.
   const estimatedTime = actualSteps * maxDelay;
-  if (estimatedTime > maxTotalTime) {
-    actualSteps = Math.floor(maxTotalTime / maxDelay);
-    // Optional: Log performance cap without forceDebug dependency
-    // console.log(`[interaction] Capped steps to ${actualSteps} to prevent timeout (estimated: ${estimatedTime}ms)`);
+  if (estimatedTime > MOUSE_MOVEMENT.MAX_TOTAL_MS) {
+    actualSteps = Math.floor(MOUSE_MOVEMENT.MAX_TOTAL_MS / maxDelay);
   }
 
   for (let i = 0; i <= actualSteps; i++) {
@@ -514,6 +524,7 @@ async function simulateScrolling(page, options = {}) {
  * @param {string[]} options.elementTypes - CSS selectors for clickable elements
  * @param {boolean} options.avoidDestructive - Avoid dangerous actions
  * @param {number} options.timeout - Timeout for element operations
+ * @param {boolean} options.forceDebug - Enable debug logging for skipped paths
  * 
  * @example
  * // Safe element interaction (default)
@@ -545,24 +556,28 @@ async function interactWithElements(page, options = {}) {
       // Check if page is closed before attempting interaction
       if (page.isClosed()) {
         if (options.forceDebug) {
-          console.log(`[interaction] Page is closed, skipping element interaction`);
+          console.log(formatLogMessage('debug', `${INTERACTION_TAG} Page is closed, skipping element interaction`));
         }
         return;
       }
 
-      // Very short timeout since page should already be loaded
-      await page.waitForSelector('body', { timeout: 1000 });
+      // Very short timeout since page should already be loaded.
+      // Explicitly dispose the returned handle rather than relying on
+      // Puppeteer's FinalizationRegistry — matches the dispose pattern
+      // already used in performPageInteraction's final-hover block.
+      const bodyHandle = await page.waitForSelector('body', { timeout: 1000 });
+      if (bodyHandle) { try { await bodyHandle.dispose(); } catch (_) {} }
       // Re-check after async wait — page may have closed during selector wait
       if (page.isClosed()) return;
     } catch (bodyWaitErr) {
       if (options.forceDebug) {
-        console.log(`[interaction] Page not ready for element interaction: ${bodyWaitErr.message}`);
+        console.log(formatLogMessage('debug', `${INTERACTION_TAG} Page not ready for element interaction: ${bodyWaitErr.message}`));
       }
       return;
     }
 
     // Use cached viewport for better performance
-    const viewport = await getCachedViewport(page);
+    const viewport = await getViewport(page);
     const maxX = viewport.width;
     const maxY = viewport.height;
 
@@ -670,7 +685,7 @@ async function performContentClicks(page, options = {}) {
   try {
     if (page.isClosed()) return;
 
-    const viewport = await getCachedViewport(page);
+    const viewport = await getViewport(page);
     const inset = CONTENT_CLICK.VIEWPORT_INSET;
     const minX = Math.floor(viewport.width * inset);
     const maxX = Math.floor(viewport.width * (1 - inset));
@@ -702,7 +717,7 @@ async function performContentClicks(page, options = {}) {
       await page.mouse.click(targetX, targetY);
 
       if (forceDebug) {
-        console.log(`[interaction] Content click ${i + 1}/${clicks} at (${targetX}, ${targetY})`);
+        console.log(formatLogMessage('debug', `${INTERACTION_TAG} Content click ${i + 1}/${clicks} at (${targetX}, ${targetY})`));
       }
 
       lastX = targetX;
@@ -718,110 +733,6 @@ async function performContentClicks(page, options = {}) {
   }
 }
 
-/**
- * Simulates realistic typing behavior with human characteristics
- * 
- * TYPING CHARACTERISTICS:
- * - Variable delay between keystrokes
- * - Optional typing mistakes with correction
- * - Realistic backspace timing
- * - Character-by-character typing (not paste)
- * 
- * MISTAKE SIMULATION:
- * - Random wrong characters (2% default rate)
- * - Pause after mistake (human realization delay)
- * - Backspace to correct
- * - Continue with correct character
- * 
- * DEVELOPER NOTES:
- * - Requires an active input field with focus
- * - All typing errors are silently handled
- * - Mistake rate should be low (0.01-0.05) for realism
- * - Use for form filling or search simulation
- * 
- * @param {import('puppeteer').Page} page - Puppeteer page object
- * @param {string} text - Text to type
- * @param {object} options - Typing configuration
- * @param {number} options.minDelay - Minimum delay between keystrokes
- * @param {number} options.maxDelay - Maximum delay between keystrokes
- * @param {boolean} options.mistakes - Enable typing mistakes
- * @param {number} options.mistakeRate - Probability of mistakes (0.0-1.0)
- * 
- * @example
- * // Basic typing
- * await simulateTyping(page, "hello world");
- * 
- * // Slow typing with mistakes
- * await simulateTyping(page, "search query", {
- *   minDelay: 100, maxDelay: 300, mistakes: true, mistakeRate: 0.03
- * });
- * 
- * // Fast typing without mistakes
- * await simulateTyping(page, "username", {
- *   minDelay: 30, maxDelay: 80, mistakes: false
- * });
- */
-async function simulateTyping(page, text, options = {}) {
-  const {
-    minDelay = TIMING.TYPING_MIN_DELAY,
-    maxDelay = TIMING.TYPING_MAX_DELAY,
-    mistakes = false,
-    mistakeRate = ELEMENT_INTERACTION.MISTAKE_RATE
-  } = options;
-
-  try {
-    // Ensure page is ready for typing
-    try {
-      await page.waitForSelector('body', { timeout: 1000 });
-    } catch (bodyWaitErr) {
-      return; // Silently skip typing if page not ready
-    }
-
-    for (let i = 0; i < text.length; i++) {
-      const char = text[i];
-      
-      // Simulate occasional typing mistakes
-      if (mistakes && Math.random() < mistakeRate) {
-        const wrongChar = String.fromCharCode(97 + Math.floor(Math.random() * 26));
-        await page.keyboard.type(wrongChar);
-        await fastTimeout(TIMING.MISTAKE_PAUSE_MIN + Math.random() * (TIMING.MISTAKE_PAUSE_MAX - TIMING.MISTAKE_PAUSE_MIN));
-        await page.keyboard.press('Backspace');
-        await fastTimeout(TIMING.BACKSPACE_DELAY_MIN + Math.random() * (TIMING.BACKSPACE_DELAY_MAX - TIMING.BACKSPACE_DELAY_MIN));
-      }
-      
-      await page.keyboard.type(char);
-      
-      // Variable delay between keystrokes
-      const delay = Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
-      await fastTimeout(delay);
-    }
-  } catch (typingErr) {
-    // Silently handle typing errors
-  }
-}
-
-/**
- * Cleans up interaction-related memory and cached data
- * Should be called periodically in long-running sessions
- * 
- * @param {boolean} force - Force cleanup regardless of timing
- */
-function cleanupInteractionMemory(force = false) {
-  interactionMemoryCleanupCounter++;
-  
-  // Only cleanup every 10 calls unless forced
-  if (!force && interactionMemoryCleanupCounter % 10 !== 0) {
-    return;
-  }
-  
-  // Clear cached viewport if it's older than cache duration
-  const now = Date.now();
-  if (cachedViewport && (now - lastViewportCheck) > VIEWPORT_CACHE_DURATION) {
-    cachedViewport = null;
-    lastViewportCheck = 0;
-  }
-}
-
 /**
  * Performs comprehensive page interaction simulation - MAIN ENTRY POINT
  * 
@@ -858,7 +769,6 @@ function cleanupInteractionMemory(force = false) {
  * @param {number} options.mouseMovements - Number of mouse movements
  * @param {boolean} options.includeScrolling - Enable scrolling simulation
  * @param {boolean} options.includeElementClicks - Enable element clicking
- * @param {boolean} options.includeTyping - Enable typing simulation  
  * @param {number} options.duration - Total interaction time in milliseconds
  * @param {string} options.intensity - 'low' | 'medium' | 'high'
  * @param {boolean} forceDebug - Enable debug logging
@@ -883,11 +793,15 @@ function cleanupInteractionMemory(force = false) {
  * });
  */
 async function performPageInteraction(page, currentUrl, options = {}, forceDebug = false) {
+  // mouseMovements deliberately has no default in the destructure: we want
+  // to distinguish 'caller didn't pass it' from 'caller explicitly passed 3'
+  // so the actualMovements calculation below can let intensity drive the
+  // count when nothing was specified. The old default-3 + Math.min(...) shape
+  // silently capped HIGH intensity's intended 5 movements down to 3.
   const {
-    mouseMovements = INTENSITY_SETTINGS.MEDIUM.movements,
+    mouseMovements,
     includeScrolling = true,
     includeElementClicks = false,
-    includeTyping = false,
     duration = TIMING.DEFAULT_INTERACTION_DURATION,
     intensity = 'medium'
   } = options;
@@ -905,26 +819,29 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
     try {
       if (page.isClosed()) {
         if (forceDebug) {
-          console.log(`[interaction] Page is closed for ${currentUrl}, skipping interaction`);
+          console.log(formatLogMessage('debug', `${INTERACTION_TAG} Page is closed for ${currentUrl}, skipping interaction`));
         }
         return;
       }
     } catch { return; }
 
     // Use cached viewport for better performance
-    const viewport = await getCachedViewport(page);
+    const viewport = await getViewport(page);
     const maxX = viewport.width;
     const maxY = viewport.height;
 
     if (forceDebug) {
       let hostname = currentUrl;
       try { hostname = new URL(currentUrl).hostname; } catch {}
-      console.log(`[interaction] Starting enhanced interaction simulation for ${hostname} (${intensity} intensity)`);
+      console.log(formatLogMessage('debug', `${INTERACTION_TAG} Starting enhanced interaction simulation for ${hostname} (${intensity} intensity)`));
     }
 
-    // Configure intensity settings
+    // Configure intensity settings. When the caller didn't pass mouseMovements,
+    // intensity drives the count (HIGH = 5, MEDIUM = 3, LOW = 2). When the
+    // caller DID pass an explicit value, that wins — covers callers who want
+    // a custom count regardless of the broader intensity profile.
     const settings = INTENSITY_SETTINGS[intensity.toUpperCase()] || INTENSITY_SETTINGS.MEDIUM;
-    const actualMovements = Math.min(mouseMovements, settings.movements);
+    const actualMovements = mouseMovements !== undefined ? mouseMovements : settings.movements;
     
     // Start with random position
     let currentPos = generateRandomCoordinates(maxX, maxY, { preferEdges: true });
@@ -937,12 +854,14 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
     }
 
 
-    const totalDuration = duration * settings.pauseMultiplier;
-    // CRITICAL: Cap action intervals to prevent long waits
-    const baseInterval = totalDuration / (actualMovements + (includeScrolling ? settings.scrolls : 0));
-    const actionInterval = Math.min(baseInterval, 100); // Never wait more than 100ms
-    
-    // Start timing ONLY the actual interaction operations  
+    // Inter-action spacers were a separate await-fastTimeout between every
+    // movement/scroll (capped at 50ms each). Each movement already has its
+    // own internal step delays (5–25ms per step) plus the PAUSE_CHANCE
+    // pause path, so the cursor never visibly "rips through" actions —
+    // the spacer was adding ~50ms × 5 actions = ~250ms of pure dead time
+    // per interaction for no anti-detection benefit. Removed.
+
+    // Start timing ONLY the actual interaction operations
     const actualInteractionStartTime = Date.now();
 
     // Perform mouse movements
@@ -961,13 +880,13 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
 
       currentPos = targetPos;
 
-      // Occasional pause
+      // Occasional pause — keep at lower probability than the prior 0.3
+      // (PROBABILITIES.PAUSE_CHANCE) since bot detectors care more about
+      // timing variance WITHIN mouse motion (the step delays handle that)
+      // than about pauses BETWEEN motions.
       if (Math.random() < PROBABILITIES.PAUSE_CHANCE) {
-        await fastTimeout(25 + Math.random() * 50); // CRITICAL: Much shorter pauses
+        await fastTimeout(25 + Math.random() * 50);
       }
-
-      // Time-based spacing
-      await fastTimeout(Math.min(actionInterval, 50)); // CRITICAL: Cap at 50ms
     }
 
     // Scrolling simulation
@@ -980,65 +899,46 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
           amount: 1 + Math.floor(Math.random() * 2), // CRITICAL: Less scrolling
           smoothness: 1 + Math.floor(Math.random() * 2) // CRITICAL: Much less smooth
         });
-        
-        await fastTimeout(Math.min(actionInterval, 100)); // CRITICAL: Cap intervals
       }
     }
 
-    // Click interaction — two strategies for maximum ad script coverage
-    // 1. Content area clicks: triggers document-level onclick handlers
-    //    (Monetag, similar popunder SDKs that listen on document)
-    // 2. Element clicks: interacts with specific UI elements
-    //    (ad scripts that attach to specific clickable elements)
+    // Click interaction — content-area clicks trigger document-level onclick
+    // handlers (Monetag, similar popunder SDKs). Previously this branch ALSO
+    // called interactWithElements afterward to hit element-specific listeners,
+    // but document-level handlers cover ~all real-world ad-script patterns —
+    // the secondary element-click pass added ~200–600ms for marginal coverage.
+    // interactWithElements is still exported for callers that want it.
     if (includeElementClicks) {
       if (checkTimeout()) return; // Emergency timeout check
-      // Primary: content area clicks for document-level onclick handlers
       await performContentClicks(page, { forceDebug });
-      // Secondary: targeted element clicks (fast, 1 attempt only)
-      if (!checkTimeout()) {
-        await interactWithElements(page, {
-          maxAttempts: 1,
-          avoidDestructive: true
-        });
-      }
     }
 
-    // Periodic memory cleanup during interaction
-    cleanupInteractionMemory();
-
-    // Final hover position
+    // Final resting position — single mouse.move instead of the previous
+    // humanLikeMouseMove + page.hover('body') sequence. The prior block paid
+    // ~80–120ms (full anti-detection trajectory + a CDP $() lookup + hover
+    // round-trip) just to leave the cursor at a random end position. The
+    // anti-detection curves matter while actions are happening; the parking
+    // move at the end doesn't need them, and hover('body') was mostly a no-op
+    // since the cursor was already inside the body's bounding box anyway.
     const finalPos = generateRandomCoordinates(maxX, maxY);
-    await humanLikeMouseMove(page, currentPos.x, currentPos.y, finalPos.x, finalPos.y);
-    
-    // Safe hover with validation
-    try {
-      const bodyElement = await page.$('body');
-      if (bodyElement) {
-        try {
-          await page.hover('body');
-        } finally {
-          await bodyElement.dispose();
-        }
-      }
-    } catch (hoverErr) {
-      // Silently handle hover failures - not critical
-    }
+    try { await page.mouse.move(finalPos.x, finalPos.y); }
+    catch (_) { /* page closed or detached — non-critical */ }
 
     // End timing ONLY after actual interaction operations complete
     const interactionElapsedTime = Date.now() - actualInteractionStartTime
 
     // CRITICAL: Warn about slow interactions
     if (interactionElapsedTime > 8000) {
-      console.warn(`[interaction] WARNING: Interaction took ${interactionElapsedTime}ms for ${currentUrl}`);
+      console.warn(formatLogMessage('warn', `${INTERACTION_TAG} WARNING: Interaction took ${interactionElapsedTime}ms for ${currentUrl}`));
     }
 
     if (forceDebug) {
-      console.log(`[interaction] Completed interaction simulation in ${interactionElapsedTime}ms (${actualMovements} movements, ${includeScrolling ? settings.scrolls : 0} scrolls)`);
+      console.log(formatLogMessage('debug', `${INTERACTION_TAG} Completed interaction simulation in ${interactionElapsedTime}ms (${actualMovements} movements, ${includeScrolling ? settings.scrolls : 0} scrolls)`));
     }
 
   } catch (interactionErr) {
     if (forceDebug) {
-      console.log(`[interaction] Interaction simulation failed for ${currentUrl}: ${interactionErr.message}`);
+      console.log(formatLogMessage('debug', `${INTERACTION_TAG} Interaction simulation failed for ${currentUrl}: ${interactionErr.message}`));
     }
     // Don't throw - interaction failures shouldn't break the main scan
   }
@@ -1097,13 +997,14 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
 function createInteractionConfig(url, siteConfig = {}) {
   try {
     const hostname = new URL(url).hostname.toLowerCase();
-    
-    // Site-specific interaction patterns
+
+    // Site-specific interaction patterns. mouseMovements is intentionally
+    // unset by default so intensity drives the count downstream — the prior
+    // hardcoded `mouseMovements: 3` silently masked the HIGH intensity's
+    // intended 5 movements when news/blog sites flipped intensity='high'.
     const config = {
-      mouseMovements: 3,
       includeScrolling: true,
       includeElementClicks: false,
-      includeTyping: false,
       duration: 2000,
       intensity: 'medium'
     };
@@ -1118,7 +1019,7 @@ function createInteractionConfig(url, siteConfig = {}) {
       config.intensity = 'low';
     } else if (hostname.includes('social') || hostname.includes('forum')) {
       config.includeScrolling = true;
-      config.mouseMovements = 4;
+      config.mouseMovements = 4;  // Explicit override — distinct from intensity
       config.intensity = 'medium';
       config.duration = SITE_DURATIONS.SOCIAL_FORUM;
     }
@@ -1139,12 +1040,11 @@ function createInteractionConfig(url, siteConfig = {}) {
 
     return config;
   } catch (urlErr) {
-    // Return default config if URL parsing fails
+    // Return default config if URL parsing fails — mouseMovements unset so
+    // the intensity-driven default applies in performPageInteraction.
     return {
-      mouseMovements: INTENSITY_SETTINGS.MEDIUM.movements,
       includeScrolling: true,
       includeElementClicks: false,
-      includeTyping: false,
       duration: TIMING.DEFAULT_INTERACTION_DURATION,
       intensity: 'medium'
     };
@@ -1167,7 +1067,6 @@ function createInteractionConfig(url, siteConfig = {}) {
  * humanLikeMouseMove: Realistic mouse movement with curves
  * simulateScrolling: Smooth scrolling simulation
  * interactWithElements: Safe element clicking
- * simulateTyping: Human-like typing with mistakes
  * generateRandomCoordinates: Smart coordinate generation
  */
 
@@ -1192,13 +1091,11 @@ module.exports = {
   // Main interaction functions
   performPageInteraction,
   createInteractionConfig,
-  getCachedViewport,
-  cleanupInteractionMemory,
+  getViewport,
   // Component functions for custom implementations
   humanLikeMouseMove,
   simulateScrolling,
   interactWithElements,
   performContentClicks,
-  simulateTyping,
   generateRandomCoordinates
 };