@axeptio/behavior-detection 1.0.3 → 1.1.1

package/dist/cjs/index.cjs

@@ -35,7 +35,11 @@ __export(index_exports, {
   Scroll: () => ScrollStrategy,
   ScrollStrategy: () => ScrollStrategy,
   Tap: () => TapStrategy,
-  TapStrategy: () => TapStrategy
+  TapStrategy: () => TapStrategy,
+  Timing: () => TimingStrategy,
+  TimingStrategy: () => TimingStrategy,
+  Visibility: () => VisibilityStrategy,
+  VisibilityStrategy: () => VisibilityStrategy
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -397,8 +401,12 @@ var MouseStrategy = class extends BaseStrategy {
     this.rollingWindowMs = 5e3;
     this.listener = null;
     this.leaveListener = null;
+    this.enterListener = null;
     this.isActive = false;
     this.screenDiagonal = 1;
+    this.entryPoints = [];
+    this.microMovements = [];
+    this.STILLNESS_WINDOW = 500;
     if ((options === null || options === void 0 ? void 0 : options.rollingWindow) !== void 0)
       this.rollingWindowMs = options.rollingWindow;
   }
@@ -412,11 +420,18 @@ var MouseStrategy = class extends BaseStrategy {
     this.listener = (e) => {
       const mouseEvent = e;
       const now = Date.now();
-      const currentPos = { x: mouseEvent.clientX, y: mouseEvent.clientY };
+      const currentPos = { x: mouseEvent.clientX, y: mouseEvent.clientY, timestamp: now };
       if (this.lastPosition) {
         const dx = currentPos.x - this.lastPosition.x;
         const dy = currentPos.y - this.lastPosition.y;
         const pixelDistance = Math.sqrt(dx * dx + dy * dy);
+        if (pixelDistance >= 1 && pixelDistance <= 5) {
+          this.microMovements.push({ dx, dy, timestamp: now });
+          const cutoffMicro = now - this.STILLNESS_WINDOW;
+          while (this.microMovements.length > 0 && this.microMovements[0].timestamp < cutoffMicro) {
+            this.microMovements.shift();
+          }
+        }
         const normalizedDistance = pixelDistance / this.screenDiagonal;
         if (normalizedDistance > 1e-3) {
           const rawAngle = Math.atan2(dy, dx);
@@ -440,12 +455,62 @@ var MouseStrategy = class extends BaseStrategy {
       this.lastPosition = currentPos;
     };
     document.addEventListener("mousemove", this.listener, { passive: true });
+    this.enterListener = (e) => {
+      const mouseEvent = e;
+      const now = Date.now();
+      const x = mouseEvent.clientX;
+      const y = mouseEvent.clientY;
+      const width2 = window.innerWidth;
+      const height2 = window.innerHeight;
+      const distTop = y;
+      const distBottom = height2 - y;
+      const distLeft = x;
+      const distRight = width2 - x;
+      const minEdgeDist = Math.min(distTop, distBottom, distLeft, distRight);
+      let entryEdge;
+      const edgeThreshold = 50;
+      if (minEdgeDist < edgeThreshold) {
+        if (distTop <= minEdgeDist)
+          entryEdge = "top";
+        else if (distBottom <= minEdgeDist)
+          entryEdge = "bottom";
+        else if (distLeft <= minEdgeDist)
+          entryEdge = "left";
+        else
+          entryEdge = "right";
+      } else if (x > width2 * 0.35 && x < width2 * 0.65 && y > height2 * 0.35 && y < height2 * 0.65) {
+        entryEdge = "center";
+      } else if (distTop < edgeThreshold * 2 && distLeft < edgeThreshold * 2 || distTop < edgeThreshold * 2 && distRight < edgeThreshold * 2 || distBottom < edgeThreshold * 2 && distLeft < edgeThreshold * 2 || distBottom < edgeThreshold * 2 && distRight < edgeThreshold * 2) {
+        entryEdge = "corner";
+      } else {
+        if (distTop < distBottom && distTop < distLeft && distTop < distRight)
+          entryEdge = "top";
+        else if (distBottom < distLeft && distBottom < distRight)
+          entryEdge = "bottom";
+        else if (distLeft < distRight)
+          entryEdge = "left";
+        else
+          entryEdge = "right";
+      }
+      this.entryPoints.push({
+        x,
+        y,
+        timestamp: now,
+        edgeDistance: minEdgeDist,
+        entryEdge
+      });
+      if (this.entryPoints.length > 20) {
+        this.entryPoints.shift();
+      }
+    };
+    document.addEventListener("mouseenter", this.enterListener, { passive: true });
     this.leaveListener = () => {
       this.distanceSeries = [];
       this.angleSeries = [];
       this.lastPosition = null;
       this.lastAngle = 0;
       this.cumulativeAngle = 0;
+      this.microMovements = [];
     };
     document.addEventListener("mouseleave", this.leaveListener, { passive: true });
   }
@@ -461,6 +526,10 @@ var MouseStrategy = class extends BaseStrategy {
       document.removeEventListener("mouseleave", this.leaveListener);
       this.leaveListener = null;
     }
+    if (this.enterListener) {
+      document.removeEventListener("mouseenter", this.enterListener);
+      this.enterListener = null;
+    }
   }
   reset() {
     this.distanceSeries = [];
@@ -468,6 +537,8 @@ var MouseStrategy = class extends BaseStrategy {
     this.lastPosition = null;
     this.lastAngle = 0;
     this.cumulativeAngle = 0;
+    this.entryPoints = [];
+    this.microMovements = [];
   }
   score() {
     if (this.distanceSeries.length < 10)
@@ -476,7 +547,7 @@ var MouseStrategy = class extends BaseStrategy {
   }
   /**
    * Mouse-specific pattern detection
-   * Detects bot-like patterns: constant velocity, linear paths
+   * Detects bot-like patterns: constant velocity, linear paths, suspicious entry points
    */
   detectMousePatterns() {
     if (this.distanceSeries.length < 10)
@@ -499,15 +570,103 @@ var MouseStrategy = class extends BaseStrategy {
       score += gaussian(avgChange, 0.15, 0.12);
       factors++;
     }
+    const entryScore = this.scoreEntryPoints();
+    if (entryScore !== void 0) {
+      score += entryScore;
+      factors++;
+    }
+    const microScore = this.scoreMicroMovements();
+    if (microScore !== void 0) {
+      score += microScore;
+      factors++;
+    }
     return factors > 0 ? score / factors : void 0;
   }
+  /**
+   * Score based on viewport entry points
+   * Humans enter from edges with momentum; bots often start at (0,0) or center
+   */
+  scoreEntryPoints() {
+    if (this.entryPoints.length < 2)
+      return void 0;
+    let suspiciousCount = 0;
+    let centerCount = 0;
+    let cornerCount = 0;
+    let originCount = 0;
+    for (const entry of this.entryPoints) {
+      if (entry.x < 5 && entry.y < 5) {
+        originCount++;
+        suspiciousCount++;
+      } else if (entry.entryEdge === "center") {
+        centerCount++;
+        suspiciousCount++;
+      } else if (entry.entryEdge === "corner") {
+        cornerCount++;
+        if (entry.edgeDistance < 10)
+          suspiciousCount++;
+      }
+    }
+    const total = this.entryPoints.length;
+    const suspiciousRatio = suspiciousCount / total;
+    if (originCount >= 2 || originCount / total >= 0.5)
+      return 0.1;
+    if (centerCount / total >= 0.5)
+      return 0.2;
+    if (suspiciousRatio >= 0.7)
+      return 0.3;
+    if (suspiciousRatio >= 0.5)
+      return 0.5;
+    if (suspiciousRatio >= 0.3)
+      return 0.7;
+    return 1;
+  }
+  /**
+   * Score based on micro-movements (tremor detection)
+   * Humans have natural hand tremor causing 1-5px jitter
+   * Bots have perfect stillness or no micro-movements
+   */
+  scoreMicroMovements() {
+    if (this.distanceSeries.length < 20)
+      return void 0;
+    const microCount = this.microMovements.length;
+    const oldestEvent = this.distanceSeries[0];
+    const newestEvent = this.distanceSeries[this.distanceSeries.length - 1];
+    const durationMs = newestEvent.timestamp - oldestEvent.timestamp;
+    if (durationMs < 1e3)
+      return void 0;
+    const microPerSecond = microCount / durationMs * 1e3;
+    if (microCount === 0)
+      return 0.3;
+    if (microPerSecond < 1)
+      return 0.5;
+    if (microPerSecond < 5)
+      return 0.7;
+    if (microPerSecond >= 5 && microPerSecond <= 30)
+      return 1;
+    return 0.8;
+  }
+  /**
+   * Get micro-movement count for external use (e.g., by ClickStrategy)
+   */
+  getMicroMovementCount() {
+    return this.microMovements.length;
+  }
+  /**
+   * Get last position for external use
+   */
+  getLastPosition() {
+    return this.lastPosition ? { x: this.lastPosition.x, y: this.lastPosition.y } : null;
+  }
   getDebugInfo() {
     return {
       eventCount: this.distanceSeries.length,
       rollingWindow: this.rollingWindowMs,
       isActive: this.isActive,
       distanceSeries: this.distanceSeries,
-      angleSeries: this.angleSeries
+      angleSeries: this.angleSeries,
+      entryPoints: this.entryPoints,
+      microMovementCount: this.microMovements.length,
+      lastPosition: this.lastPosition
     };
   }
 };
@@ -654,7 +813,8 @@ var ClickStrategy = class extends BaseStrategy {
       const mouseEvent = e;
       this.lastMousePosition = {
         x: mouseEvent.clientX,
-        y: mouseEvent.clientY
+        y: mouseEvent.clientY,
+        timestamp: Date.now()
       };
     };
     document.addEventListener("mousemove", this.mouseListener, { passive: true });
@@ -684,8 +844,17 @@ var ClickStrategy = class extends BaseStrategy {
       const listener = (e) => {
         var _a, _b;
         const clickEvent = e;
+        const now = Date.now();
         const rect = element.getBoundingClientRect();
         const inViewport = rect.top >= 0 && rect.left >= 0 && rect.bottom <= window.innerHeight && rect.right <= window.innerWidth;
+        let mouseClickDelta = 0;
+        let timeSinceMouseMove = -1;
+        if (this.lastMousePosition) {
+          const dx = clickEvent.clientX - this.lastMousePosition.x;
+          const dy = clickEvent.clientY - this.lastMousePosition.y;
+          mouseClickDelta = Math.sqrt(dx * dx + dy * dy);
+          timeSinceMouseMove = now - this.lastMousePosition.timestamp;
+        }
         let position;
         if (!this.lastMousePosition) {
           position = "no-mouse-data";
@@ -714,7 +883,10 @@ var ClickStrategy = class extends BaseStrategy {
           rect,
           inViewport,
           position,
-          timestamp: Date.now()
+          timestamp: now,
+          mouseClickDelta,
+          timeSinceMouseMove,
+          isTrusted: clickEvent.isTrusted
         });
         this.notifyEvent(1);
       };
@@ -740,26 +912,93 @@ var ClickStrategy = class extends BaseStrategy {
     this.lastMousePosition = null;
   }
   score() {
-    if (this.events.length === 0)
+    const eventCount = this.events.length;
+    if (eventCount === 0)
       return void 0;
-    let totalScore = 0;
+    let positionScore = 0;
+    let clicksWithDelta = 0;
+    let mismatchCount = 0;
+    let clicksWithTiming = 0;
+    let suspiciousTimingCount = 0;
+    let untrustedCount = 0;
     for (const click of this.events) {
       switch (click.position) {
         case "no-mouse-data":
-          totalScore += 0;
+          positionScore += 0;
           break;
         case "outside":
-          totalScore += 0;
+          positionScore += 0;
           break;
         case "dead-center":
-          totalScore += 0.5;
+          positionScore += 0.5;
           break;
         case "over-element":
-          totalScore += 1;
+          positionScore += 1;
           break;
       }
+      if (click.mouseClickDelta >= 0) {
+        clicksWithDelta++;
+        if (click.mouseClickDelta > 5)
+          mismatchCount++;
+      }
+      if (click.timeSinceMouseMove >= 0) {
+        clicksWithTiming++;
+        if (click.timeSinceMouseMove < 10 || click.timeSinceMouseMove > 2e3) {
+          suspiciousTimingCount++;
+        }
+      }
+      if (!click.isTrusted)
+        untrustedCount++;
+    }
+    let score = 0;
+    let factors = 0;
+    score += positionScore / eventCount;
+    factors++;
+    if (clicksWithDelta >= 2) {
+      const mismatchRatio = mismatchCount / clicksWithDelta;
+      let deltaScore;
+      if (mismatchRatio >= 0.8)
+        deltaScore = 0.1;
+      else if (mismatchRatio >= 0.5)
+        deltaScore = 0.3;
+      else if (mismatchRatio >= 0.3)
+        deltaScore = 0.5;
+      else if (mismatchRatio > 0)
+        deltaScore = 0.7;
+      else
+        deltaScore = 1;
+      score += deltaScore;
+      factors++;
     }
-    return totalScore / this.events.length;
+    if (clicksWithTiming >= 2) {
+      const suspiciousRatio = suspiciousTimingCount / clicksWithTiming;
+      let timingScore;
+      if (suspiciousRatio >= 0.8)
+        timingScore = 0.2;
+      else if (suspiciousRatio >= 0.5)
+        timingScore = 0.4;
+      else if (suspiciousRatio >= 0.3)
+        timingScore = 0.6;
+      else if (suspiciousRatio > 0)
+        timingScore = 0.8;
+      else
+        timingScore = 1;
+      score += timingScore;
+      factors++;
+    }
+    if (eventCount >= 2) {
+      const untrustedRatio = untrustedCount / eventCount;
+      let trustedScore;
+      if (untrustedRatio >= 0.5)
+        trustedScore = 0.1;
+      else if (untrustedRatio > 0)
+        trustedScore = 0.3;
+      else
+        trustedScore = 1;
+      score += trustedScore;
+      factors++;
+    }
+    return factors > 0 ? score / factors : void 0;
   }
   getDebugInfo() {
     return {
@@ -771,7 +1010,10 @@ var ClickStrategy = class extends BaseStrategy {
         overElement: this.events.filter((e) => e.position === "over-element").length
       },
       inViewport: this.events.filter((e) => e.inViewport).length,
-      trackedElements: this.clickListeners.size
+      trackedElements: this.clickListeners.size,
+      mouseClickDeltas: this.events.map((e) => e.mouseClickDelta),
+      timeSinceMouseMoves: this.events.map((e) => e.timeSinceMouseMove),
+      untrustedClicks: this.events.filter((e) => !e.isTrusted).length
     };
   }
 };
@@ -1168,6 +1410,54 @@ var KeyboardStrategy = class extends BaseStrategy {
 };
 
 // dist/esm/strategies/environment.js
+var AUTOMATION_GLOBALS = [
+  "__nightmare",
+  "_phantom",
+  "callPhantom",
+  "__selenium_evaluate",
+  "__webdriver_evaluate",
+  "__driver_evaluate",
+  "__webdriver_script_function",
+  "__lastWatirAlert",
+  "__lastWatirConfirm",
+  "__lastWatirPrompt",
+  "_Selenium_IDE_Recorder",
+  "domAutomation",
+  "domAutomationController",
+  "webdriver",
+  "_webdriver_script_fn",
+  "__webdriver_script_func",
+  "__fxdriver_evaluate",
+  "__fxdriver_unwrapped",
+  "__selenium_unwrapped"
+];
+function getWebGLRenderer(gl) {
+  const renderer = gl.getParameter(gl.RENDERER);
+  if (renderer && !/^(WebKit WebGL|Mozilla|Google Inc\.)$/i.test(renderer)) {
+    return renderer;
+  }
+  const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+  if (debugInfo) {
+    return gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+  }
+  return renderer !== null && renderer !== void 0 ? renderer : void 0;
+}
+function withWebGLContext(fn) {
+  try {
+    const canvas = document.createElement("canvas");
+    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (!gl)
+      return { hasWebGL: false, result: void 0 };
+    try {
+      return { hasWebGL: true, result: fn(gl) };
+    } finally {
+      const loseCtx = gl.getExtension("WEBGL_lose_context");
+      loseCtx === null || loseCtx === void 0 ? void 0 : loseCtx.loseContext();
+    }
+  } catch (_a) {
+    return { hasWebGL: false, result: void 0 };
+  }
+}
 var EnvironmentStrategy = class extends BaseStrategy {
   constructor() {
     super(...arguments);
@@ -1184,12 +1474,35 @@ var EnvironmentStrategy = class extends BaseStrategy {
     this.data = null;
   }
   onTick(_timestamp) {
-    this.captureEnvironment();
+    if (!this.data) {
+      this.captureEnvironment();
+    }
   }
   score() {
     if (!this.data)
       return void 0;
     const env = this.data;
+    const auto = env.automation;
+    if (auto.isWebdriver) {
+      return 0.05;
+    }
+    if (auto.hasAutomationGlobals) {
+      return 0.1;
+    }
+    if (auto.hasCDPInjection) {
+      return 0.1;
+    }
+    const headlessIndicatorCount = [
+      auto.hasHeadlessUA,
+      auto.hasChromelessRuntime,
+      auto.hasSoftwareRenderer
+    ].filter(Boolean).length;
+    if (headlessIndicatorCount >= 2) {
+      return 0.15;
+    }
+    if (auto.hasHeadlessUA) {
+      return 0.2;
+    }
     let score = 0;
     let factors = 0;
     score += env.suspiciousDimensions ? 0.1 : 1;
@@ -1204,9 +1517,23 @@ var EnvironmentStrategy = class extends BaseStrategy {
     ].filter(Boolean).length;
     score += featureCount / 4;
     factors++;
-    score += inverseSigmoid(env.plugins, -2, -0.5);
-    score += env.plugins > 0 ? 1 : 0.1;
-    factors += 2;
+    if (!env.isMobile) {
+      score += inverseSigmoid(env.plugins, -2, -0.5);
+      score += env.plugins > 0 ? 1 : 0.1;
+      factors += 2;
+      if (auto.hasNoPlugins && env.vendor.includes("Google")) {
+        score += 0.3;
+        factors++;
+      }
+    }
+    if (auto.hasChromelessRuntime) {
+      score += 0.3;
+      factors++;
+    }
+    if (auto.hasSoftwareRenderer) {
+      score += 0.4;
+      factors++;
+    }
     score += gaussian(env.devicePixelRatio, 2, 1.5);
     score += env.colorDepth === 24 || env.colorDepth === 32 ? 1 : 0.4;
     factors += 2;
@@ -1218,15 +1545,58 @@ var EnvironmentStrategy = class extends BaseStrategy {
     const smallScreen = window.innerWidth < 768 && window.innerHeight < 1024;
     return hasTouchScreen && smallScreen || mobileUA;
   }
-  captureEnvironment() {
+  /**
+   * Detect automation indicators
+   */
+  detectAutomation() {
+    const isMobile = this.isMobileDevice();
+    const isWebdriver = navigator.webdriver === true;
+    const ua = navigator.userAgent;
+    const hasHeadlessUA = /HeadlessChrome|Headless/i.test(ua);
+    const win = window;
+    const hasChromelessRuntime = !!(win.chrome && typeof win.chrome === "object" && !win.chrome.runtime);
+    const detectedGlobals = [];
+    for (const global of AUTOMATION_GLOBALS) {
+      if (global in win) {
+        detectedGlobals.push(global);
+      }
+    }
+    const hasAutomationGlobals = detectedGlobals.length > 0;
+    const detectedCDPKeys = [];
     try {
-      let hasWebGL = false;
-      try {
-        const canvas = document.createElement("canvas");
-        hasWebGL = !!(canvas.getContext("webgl") || canvas.getContext("experimental-webgl"));
-      } catch (e) {
-        hasWebGL = false;
+      for (const key of Object.keys(win)) {
+        if (/^cdc_|^__cdc_/.test(key)) {
+          detectedCDPKeys.push(key);
+        }
       }
+    } catch (_a) {
+    }
+    const hasCDPInjection = detectedCDPKeys.length > 0;
+    const hasNoPlugins = !isMobile && navigator.plugins.length === 0;
+    let hasSoftwareRenderer = false;
+    const webglResult = withWebGLContext((gl) => getWebGLRenderer(gl));
+    if (webglResult.hasWebGL && webglResult.result) {
+      const renderer = webglResult.result;
+      hasSoftwareRenderer = /SwiftShader|Software|LLVMpipe/i.test(renderer);
+      this._webglRenderer = renderer;
+    }
+    return {
+      isWebdriver,
+      hasHeadlessUA,
+      hasChromelessRuntime,
+      hasSoftwareRenderer,
+      hasNoPlugins,
+      hasAutomationGlobals,
+      detectedGlobals,
+      hasCDPInjection,
+      detectedCDPKeys
+    };
+  }
+  captureEnvironment() {
+    try {
+      const webgl = withWebGLContext((gl) => getWebGLRenderer(gl));
+      const hasWebGL = webgl.hasWebGL;
+      const webglRenderer = webgl.result;
       const hasWebRTC = !!(window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection);
       const isMobile = this.isMobileDevice();
       const windowWidth = window.innerWidth;
@@ -1238,6 +1608,7 @@ var EnvironmentStrategy = class extends BaseStrategy {
       const suspiciousRatio = windowScreenRatio === 1 || windowScreenRatio < 0.1 || windowScreenRatio > 1;
       const hasStorage = typeof localStorage !== "undefined" && typeof sessionStorage !== "undefined";
       const featureInconsistency = navigator.plugins.length === 0 && navigator.mimeTypes.length === 0 || !hasWebGL || !hasStorage;
+      const automation = this.detectAutomation();
       this.data = {
         screenWidth,
         screenHeight,
@@ -1263,10 +1634,11 @@ var EnvironmentStrategy = class extends BaseStrategy {
         suspiciousDimensions,
         featureInconsistency,
         isMobile,
-        timestamp: Date.now()
+        timestamp: Date.now(),
+        automation,
+        webglRenderer
       };
-    } catch (error) {
-      console.warn("Failed to capture environment:", error);
+    } catch (_a) {
     }
   }
   getDebugInfo() {
@@ -1281,6 +1653,24 @@ var EnvironmentStrategy = class extends BaseStrategy {
     var _a, _b;
     return (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.isMobile) !== null && _b !== void 0 ? _b : null;
   }
+  /**
+   * Get automation detection results
+   * Returns null if environment hasn't been captured yet
+   */
+  getAutomationIndicators() {
+    var _a, _b;
+    return (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.automation) !== null && _b !== void 0 ? _b : null;
+  }
+  /**
+   * Quick check if any strong automation indicator is present
+   * Returns true if likely a bot, false if likely human, null if not checked yet
+   */
+  isLikelyBot() {
+    if (!this.data)
+      return null;
+    const auto = this.data.automation;
+    return auto.isWebdriver || auto.hasAutomationGlobals || auto.hasCDPInjection || auto.hasHeadlessUA;
+  }
 };
 
 // dist/esm/strategies/resize.js
@@ -1366,6 +1756,520 @@ var ResizeStrategy = class extends BaseStrategy {
   }
 };
 
+// dist/esm/strategies/timing.js
+var TimingStrategy = class extends BaseStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "timing";
+    this.defaultWeight = 0.15;
+    this.actions = [];
+    this.mouseStillness = {
+      position: null,
+      lastMoveTime: 0,
+      microMovementCount: 0
+    };
+    this.microMovements = [];
+    this.isActive = false;
+    this.mouseListener = null;
+    this.clickListener = null;
+    this.keydownListener = null;
+    this.scrollListener = null;
+    this.STILLNESS_WINDOW = 500;
+    this.MICRO_MOVEMENT_THRESHOLD = 1;
+    this.MAX_MICRO_MOVEMENT = 5;
+    this.MACHINE_PRECISION_THRESHOLD = 5;
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.mouseListener = (e) => {
+      const mouseEvent = e;
+      const now = Date.now();
+      const currentPos = { x: mouseEvent.clientX, y: mouseEvent.clientY };
+      if (this.mouseStillness.position) {
+        const dx = currentPos.x - this.mouseStillness.position.x;
+        const dy = currentPos.y - this.mouseStillness.position.y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        if (distance >= this.MICRO_MOVEMENT_THRESHOLD && distance <= this.MAX_MICRO_MOVEMENT) {
+          this.microMovements.push({ timestamp: now, distance });
+        }
+        if (distance >= this.MICRO_MOVEMENT_THRESHOLD) {
+          this.mouseStillness.lastMoveTime = now;
+        }
+      }
+      this.mouseStillness.position = currentPos;
+      const cutoff = now - this.STILLNESS_WINDOW;
+      this.microMovements = this.microMovements.filter((m) => m.timestamp >= cutoff);
+    };
+    this.clickListener = (e) => {
+      this.recordAction("click", e);
+    };
+    this.keydownListener = () => {
+      this.recordAction("keydown");
+    };
+    this.scrollListener = () => {
+      this.recordAction("scroll");
+    };
+    document.addEventListener("mousemove", this.mouseListener, { passive: true });
+    document.addEventListener("click", this.clickListener, { passive: true });
+    document.addEventListener("keydown", this.keydownListener, { passive: true });
+    document.addEventListener("scroll", this.scrollListener, { passive: true });
+  }
+  recordAction(type, _event) {
+    const now = Date.now();
+    const timeSinceMouseMove = this.mouseStillness.lastMoveTime > 0 ? now - this.mouseStillness.lastMoveTime : -1;
+    this.mouseStillness.microMovementCount = this.microMovements.length;
+    this.actions.push({
+      type,
+      timestamp: now,
+      timeSinceMouseMove,
+      wasHidden: document.hidden
+    });
+    this.notifyEvent(0.7);
+    if (this.actions.length > 100) {
+      this.actions.shift();
+    }
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.mouseListener) {
+      document.removeEventListener("mousemove", this.mouseListener);
+      this.mouseListener = null;
+    }
+    if (this.clickListener) {
+      document.removeEventListener("click", this.clickListener);
+      this.clickListener = null;
+    }
+    if (this.keydownListener) {
+      document.removeEventListener("keydown", this.keydownListener);
+      this.keydownListener = null;
+    }
+    if (this.scrollListener) {
+      document.removeEventListener("scroll", this.scrollListener);
+      this.scrollListener = null;
+    }
+  }
+  reset() {
+    this.actions = [];
+    this.microMovements = [];
+    this.mouseStillness = {
+      position: null,
+      lastMoveTime: 0,
+      microMovementCount: 0
+    };
+  }
+  score() {
+    const actionCount = this.actions.length;
+    if (actionCount < 3)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    const clicks = [];
+    const clicksWithMouse = [];
+    let hiddenCount = 0;
+    for (const action of this.actions) {
+      if (action.type === "click") {
+        clicks.push(action);
+        if (action.timeSinceMouseMove >= 0) {
+          clicksWithMouse.push(action);
+        }
+      }
+      if (action.wasHidden)
+        hiddenCount++;
+    }
+    if (clicks.length >= 2) {
+      const stillnessScore = this.scorePreActionStillness(clicks);
+      if (stillnessScore !== void 0) {
+        score += stillnessScore;
+        factors++;
+      }
+    }
+    if (clicksWithMouse.length >= 3) {
+      const mouseToClickScore = this.scoreMouseToClickDelayFromCache(clicksWithMouse);
+      if (mouseToClickScore !== void 0) {
+        score += mouseToClickScore;
+        factors++;
+      }
+    }
+    if (actionCount >= 5) {
+      const intervalScore = this.scoreActionIntervals();
+      if (intervalScore !== void 0) {
+        score += intervalScore;
+        factors++;
+      }
+    }
+    const hiddenScore = this.scoreHiddenActionsFromCount(hiddenCount, actionCount);
+    score += hiddenScore;
+    factors++;
+    return factors > 0 ? score / factors : void 0;
+  }
+  /**
+   * Score based on pre-action stillness
+   * Humans have micro-movements before clicking; bots are perfectly still
+   */
+  scorePreActionStillness(clicks) {
+    const clicksWithMouseData = clicks.filter((c) => c.timeSinceMouseMove >= 0);
+    if (clicksWithMouseData.length < 2)
+      return void 0;
+    const perfectlyStillClicks = clicksWithMouseData.filter((c) => {
+      return c.timeSinceMouseMove >= 100 && c.timeSinceMouseMove <= 500 && this.mouseStillness.microMovementCount === 0;
+    }).length;
+    const stillRatio = perfectlyStillClicks / clicksWithMouseData.length;
+    if (stillRatio >= 0.9)
+      return 0.1;
+    if (stillRatio >= 0.7)
+      return 0.3;
+    if (stillRatio >= 0.5)
+      return 0.5;
+    if (stillRatio >= 0.3)
+      return 0.7;
+    return 1;
+  }
+  /**
+   * Score mouse-to-click delay patterns (using pre-filtered cache)
+   */
+  scoreMouseToClickDelayFromCache(clicksWithMouse) {
+    const delays = clicksWithMouse.map((c) => c.timeSinceMouseMove);
+    const stats = calculateStatistics(delays);
+    if (stats.mean < 10)
+      return 0.1;
+    if (stats.cv < 0.2 && clicksWithMouse.length >= 5)
+      return 0.2;
+    if (stats.mean >= 50 && stats.mean <= 300 && stats.cv >= 0.3)
+      return 1;
+    if (stats.cv < 0.4)
+      return 0.6;
+    return 0.8;
+  }
+  /**
+   * Score action intervals for machine-like precision
+   * Detects exact intervals: 100ms, 500ms, 1000ms
+   */
+  scoreActionIntervals() {
+    if (this.actions.length < 5)
+      return void 0;
+    const intervals = [];
+    for (let i = 1; i < this.actions.length; i++) {
+      intervals.push(this.actions[i].timestamp - this.actions[i - 1].timestamp);
+    }
+    const machineIntervals = [100, 200, 250, 500, 1e3];
+    let preciseCount = 0;
+    for (const interval of intervals) {
+      for (const machineInterval of machineIntervals) {
+        const remainder = interval % machineInterval;
+        if (remainder < this.MACHINE_PRECISION_THRESHOLD || machineInterval - remainder < this.MACHINE_PRECISION_THRESHOLD) {
+          preciseCount++;
+          break;
+        }
+      }
+    }
+    const preciseRatio = preciseCount / intervals.length;
+    if (preciseRatio >= 0.8)
+      return 0.1;
+    if (preciseRatio >= 0.6)
+      return 0.3;
+    if (preciseRatio >= 0.4)
+      return 0.5;
+    const stats = calculateStatistics(intervals);
+    if (stats.cv < 0.15)
+      return 0.2;
+    return 1;
+  }
+  /**
+   * Score based on actions while document was hidden (using pre-computed count)
+   */
+  scoreHiddenActionsFromCount(hiddenCount, totalCount) {
+    if (hiddenCount === 0)
+      return 1;
+    const hiddenRatio = hiddenCount / totalCount;
+    if (hiddenRatio > 0.5)
+      return 0.1;
+    if (hiddenRatio > 0.2)
+      return 0.3;
+    if (hiddenRatio > 0)
+      return 0.5;
+    return 1;
+  }
+  getDebugInfo() {
+    const clicks = this.actions.filter((a) => a.type === "click");
+    const intervals = [];
+    for (let i = 1; i < this.actions.length; i++) {
+      intervals.push(this.actions[i].timestamp - this.actions[i - 1].timestamp);
+    }
+    return {
+      actionCount: this.actions.length,
+      clickCount: clicks.length,
+      keydownCount: this.actions.filter((a) => a.type === "keydown").length,
+      scrollCount: this.actions.filter((a) => a.type === "scroll").length,
+      hiddenActionCount: this.actions.filter((a) => a.wasHidden).length,
+      microMovementCount: this.microMovements.length,
+      intervals: intervals.slice(-20),
+      // Last 20 intervals
+      lastStillnessDuration: this.mouseStillness.lastMoveTime > 0 ? Date.now() - this.mouseStillness.lastMoveTime : null
+    };
+  }
+};
+
+// dist/esm/strategies/visibility.js
+var VisibilityStrategy = class extends BaseStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "visibility";
+    this.defaultWeight = 0.1;
+    this.events = [];
+    this.focusTypingPairs = [];
+    this.actionsWhileHidden = 0;
+    this.lastVisibilityChange = null;
+    this.resumeDelays = [];
+    this.isActive = false;
+    this.visibilityListener = null;
+    this.focusListener = null;
+    this.blurListener = null;
+    this.clickListener = null;
+    this.keydownListener = null;
+    this.inputFocusListener = null;
+    this.lastFocusedInput = null;
+    this.hasTypedInFocusedInput = false;
+    this.lastActionTime = 0;
+    this.preHideActionTime = 0;
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.visibilityListener = () => {
+      const now = Date.now();
+      const wasHidden = document.hidden;
+      if (this.lastVisibilityChange && !wasHidden) {
+        if (this.lastActionTime > 0 && this.preHideActionTime > 0) {
+          const timeSinceLastAction = now - this.lastActionTime;
+          if (timeSinceLastAction < 50) {
+            this.actionsWhileHidden++;
+          }
+        }
+        this.lastVisibilityChange = { hidden: false, timestamp: now };
+      } else if (wasHidden) {
+        this.preHideActionTime = this.lastActionTime;
+        this.lastVisibilityChange = { hidden: true, timestamp: now };
+      }
+      this.events.push({
+        type: "visibility_change",
+        timestamp: now,
+        wasHidden
+      });
+    };
+    this.focusListener = () => {
+      this.events.push({
+        type: "focus_change",
+        timestamp: Date.now(),
+        wasHidden: document.hidden,
+        wasFocused: true
+      });
+    };
+    this.blurListener = () => {
+      this.events.push({
+        type: "focus_change",
+        timestamp: Date.now(),
+        wasHidden: document.hidden,
+        wasFocused: false
+      });
+    };
+    this.clickListener = (e) => {
+      this.recordAction("click", e);
+    };
+    this.keydownListener = (e) => {
+      this.recordAction("keydown", e);
+      if (this.lastFocusedInput && !this.hasTypedInFocusedInput) {
+        const now = Date.now();
+        const delay = now - this.lastFocusedInput.timestamp;
+        this.focusTypingPairs.push({
+          focusTime: this.lastFocusedInput.timestamp,
+          firstKeypressTime: now,
+          delay,
+          element: this.lastFocusedInput.element
+        });
+        this.hasTypedInFocusedInput = true;
+      }
+    };
+    this.inputFocusListener = (e) => {
+      const target = e.target;
+      if (target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA")) {
+        this.lastFocusedInput = {
+          element: target.tagName.toLowerCase(),
+          timestamp: Date.now()
+        };
+        this.hasTypedInFocusedInput = false;
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityListener);
+    window.addEventListener("focus", this.focusListener);
+    window.addEventListener("blur", this.blurListener);
+    document.addEventListener("click", this.clickListener, { passive: true });
+    document.addEventListener("keydown", this.keydownListener, { passive: true });
+    document.addEventListener("focusin", this.inputFocusListener, { passive: true });
+  }
+  recordAction(_type, _event) {
+    const now = Date.now();
+    this.lastActionTime = now;
+    if (document.hidden) {
+      this.actionsWhileHidden++;
+      this.events.push({
+        type: "action_while_hidden",
+        timestamp: now,
+        wasHidden: true
+      });
+      this.notifyEvent(1);
+    }
+    if (this.lastVisibilityChange && !this.lastVisibilityChange.hidden) {
+      const resumeDelay = now - this.lastVisibilityChange.timestamp;
+      if (resumeDelay > 0 && resumeDelay < 1e4 && this.resumeDelays.length < 20) {
+        const lastRecordedDelay = this.resumeDelays[this.resumeDelays.length - 1];
+        if (lastRecordedDelay === void 0 || Math.abs(resumeDelay - lastRecordedDelay) > 100) {
+          this.resumeDelays.push(resumeDelay);
+        }
+      }
+    }
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.visibilityListener) {
+      document.removeEventListener("visibilitychange", this.visibilityListener);
+      this.visibilityListener = null;
+    }
+    if (this.focusListener) {
+      window.removeEventListener("focus", this.focusListener);
+      this.focusListener = null;
+    }
+    if (this.blurListener) {
+      window.removeEventListener("blur", this.blurListener);
+      this.blurListener = null;
+    }
+    if (this.clickListener) {
+      document.removeEventListener("click", this.clickListener);
+      this.clickListener = null;
+    }
+    if (this.keydownListener) {
+      document.removeEventListener("keydown", this.keydownListener);
+      this.keydownListener = null;
+    }
+    if (this.inputFocusListener) {
+      document.removeEventListener("focusin", this.inputFocusListener);
+      this.inputFocusListener = null;
+    }
+  }
+  reset() {
+    this.events = [];
+    this.focusTypingPairs = [];
+    this.actionsWhileHidden = 0;
+    this.lastVisibilityChange = null;
+    this.resumeDelays = [];
+    this.lastFocusedInput = null;
+    this.hasTypedInFocusedInput = false;
+    this.lastActionTime = 0;
+    this.preHideActionTime = 0;
+  }
+  score() {
+    if (this.events.length < 2)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    const hiddenActionScore = this.scoreHiddenActions();
+    if (hiddenActionScore !== void 0) {
+      score += hiddenActionScore;
+      factors++;
+    }
+    const resumeScore = this.scoreResumeDelays();
+    if (resumeScore !== void 0) {
+      score += resumeScore;
+      factors++;
+    }
+    const focusTypingScore = this.scoreFocusTyping();
+    if (focusTypingScore !== void 0) {
+      score += focusTypingScore;
+      factors++;
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  /**
+   * Score based on actions while document was hidden
+   * Humans can't interact with hidden tabs; bots can
+   */
+  scoreHiddenActions() {
+    if (this.actionsWhileHidden === 0)
+      return 1;
+    if (this.actionsWhileHidden >= 5)
+      return 0.1;
+    if (this.actionsWhileHidden >= 3)
+      return 0.2;
+    if (this.actionsWhileHidden >= 1)
+      return 0.3;
+    return 1;
+  }
+  /**
+   * Score based on how quickly activity resumes after tab becomes visible
+   * Humans need time to refocus (100-500ms minimum)
+   * Bots often resume instantly (< 50ms)
+   */
+  scoreResumeDelays() {
+    if (this.resumeDelays.length < 2)
+      return void 0;
+    const fastResumeCount = this.resumeDelays.filter((d) => d < 50).length;
+    const fastResumeRatio = fastResumeCount / this.resumeDelays.length;
+    if (fastResumeRatio >= 0.8)
+      return 0.1;
+    if (fastResumeRatio >= 0.5)
+      return 0.3;
+    if (fastResumeRatio >= 0.3)
+      return 0.5;
+    if (fastResumeRatio > 0)
+      return 0.7;
+    return 1;
+  }
+  /**
+   * Score based on focus-to-keypress timing
+   * Humans focus inputs before typing (natural delay 100-500ms)
+   * Bots often type without focusing or with instant delay
+   */
+  scoreFocusTyping() {
+    if (this.focusTypingPairs.length < 2)
+      return void 0;
+    let suspiciousCount = 0;
+    for (const pair of this.focusTypingPairs) {
+      if (pair.delay < 20) {
+        suspiciousCount++;
+      }
+    }
+    const suspiciousRatio = suspiciousCount / this.focusTypingPairs.length;
+    if (suspiciousRatio >= 0.8)
+      return 0.2;
+    if (suspiciousRatio >= 0.5)
+      return 0.4;
+    if (suspiciousRatio >= 0.3)
+      return 0.6;
+    if (suspiciousRatio > 0)
+      return 0.8;
+    return 1;
+  }
+  getDebugInfo() {
+    return {
+      eventCount: this.events.length,
+      actionsWhileHidden: this.actionsWhileHidden,
+      visibilityChanges: this.events.filter((e) => e.type === "visibility_change").length,
+      focusChanges: this.events.filter((e) => e.type === "focus_change").length,
+      resumeDelays: this.resumeDelays,
+      focusTypingPairs: this.focusTypingPairs.map((p) => ({
+        delay: p.delay,
+        element: p.element
+      }))
+    };
+  }
+};
+
 // dist/esm/types.js
 var DEFAULT_SETTINGS = {
   sampleRates: {
@@ -1418,5 +2322,9 @@ var DEFAULT_SETTINGS = {
   Scroll,
   ScrollStrategy,
   Tap,
-  TapStrategy
+  TapStrategy,
+  Timing,
+  TimingStrategy,
+  Visibility,
+  VisibilityStrategy
 });