@axeptio/behavior-detection 1.0.3 → 1.1.0

package/dist/esm/browser.js

@@ -140,7 +140,6 @@ class BehaviorDetectionAPI {
      */
     start() {
         if (!this.detector) {
-            console.warn('BehaviorDetector: Call init() before start()');
             return;
         }
         this.detector.start();
@@ -162,7 +161,6 @@ class BehaviorDetectionAPI {
      */
     async score() {
         if (!this.detector) {
-            console.warn('BehaviorDetector: Call init() before score()');
             return null;
         }
         return this.detector.score({ breakdown: true });

package/dist/esm/index.d.ts

@@ -33,6 +33,6 @@
  */
 export { BehaviorDetector } from './behavior-detector.js';
 export type { DetectionStrategy, StrategyConfig } from './strategy.js';
-export { Mouse, Scroll, Click, Tap, Keyboard, Environment, Resize, MouseStrategy, ScrollStrategy, ClickStrategy, TapStrategy, KeyboardStrategy, EnvironmentStrategy, ResizeStrategy, } from './strategies/index.js';
+export { Mouse, Scroll, Click, Tap, Keyboard, Environment, Resize, Timing, Visibility, MouseStrategy, ScrollStrategy, ClickStrategy, TapStrategy, KeyboardStrategy, EnvironmentStrategy, ResizeStrategy, TimingStrategy, VisibilityStrategy, } from './strategies/index.js';
 export type { BehaviorSettings, ScoreOptions, ScoreResult, ScoreBreakdown, TrackedEvent, EventType, ScoringFunction, } from './types.js';
 export { DEFAULT_SETTINGS } from './types.js';

package/dist/esm/index.js

@@ -32,5 +32,5 @@
  * ```
  */
 export { BehaviorDetector } from './behavior-detector.js';
-export { Mouse, Scroll, Click, Tap, Keyboard, Environment, Resize, MouseStrategy, ScrollStrategy, ClickStrategy, TapStrategy, KeyboardStrategy, EnvironmentStrategy, ResizeStrategy, } from './strategies/index.js';
+export { Mouse, Scroll, Click, Tap, Keyboard, Environment, Resize, Timing, Visibility, MouseStrategy, ScrollStrategy, ClickStrategy, TapStrategy, KeyboardStrategy, EnvironmentStrategy, ResizeStrategy, TimingStrategy, VisibilityStrategy, } from './strategies/index.js';
 export { DEFAULT_SETTINGS } from './types.js';

package/dist/esm/strategies/click.d.ts

@@ -1,6 +1,11 @@
 /**
  * Click Behavior Detection Strategy
  * Monitors specific elements for click positioning patterns
+ *
+ * Enhanced detection:
+ * - Click-mouse position delta (bots using .click() have mismatched positions)
+ * - Pre-click mouse trajectory analysis
+ * - Time between last mousemove and click
  */
 import { BaseStrategy } from '../strategy.js';
 export declare class ClickStrategy extends BaseStrategy {
@@ -35,5 +40,8 @@ export declare class ClickStrategy extends BaseStrategy {
         };
         inViewport: number;
         trackedElements: number;
+        mouseClickDeltas: number[];
+        timeSinceMouseMoves: number[];
+        untrustedClicks: number;
     };
 }

package/dist/esm/strategies/click.js

@@ -1,6 +1,11 @@
 /**
  * Click Behavior Detection Strategy
  * Monitors specific elements for click positioning patterns
+ *
+ * Enhanced detection:
+ * - Click-mouse position delta (bots using .click() have mismatched positions)
+ * - Pre-click mouse trajectory analysis
+ * - Time between last mousemove and click
  */
 import { BaseStrategy } from '../strategy.js';
 export class ClickStrategy extends BaseStrategy {
@@ -22,12 +27,13 @@ export class ClickStrategy extends BaseStrategy {
         if (this.isActive)
             return;
         this.isActive = true;
-        // Track mouse position globally
+        // Track mouse position globally with timestamp
         this.mouseListener = (e) => {
             const mouseEvent = e;
             this.lastMousePosition = {
                 x: mouseEvent.clientX,
                 y: mouseEvent.clientY,
+                timestamp: Date.now(),
             };
         };
         document.addEventListener('mousemove', this.mouseListener, { passive: true });
@@ -59,12 +65,23 @@ export class ClickStrategy extends BaseStrategy {
             const listener = (e) => {
                 var _a, _b;
                 const clickEvent = e;
+                const now = Date.now();
                 const rect = element.getBoundingClientRect();
                 // Check if element is in viewport
                 const inViewport = (rect.top >= 0 &&
                     rect.left >= 0 &&
                     rect.bottom <= window.innerHeight &&
                     rect.right <= window.innerWidth);
+                // Calculate mouse-click position delta
+                // Bots using element.click() have click event coordinates different from mouse position
+                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;
+                }
                 // Analyze click position
                 let position;
                 if (!this.lastMousePosition) {
@@ -103,7 +120,10 @@ export class ClickStrategy extends BaseStrategy {
                     rect,
                     inViewport,
                     position,
-                    timestamp: Date.now(),
+                    timestamp: now,
+                    mouseClickDelta,
+                    timeSinceMouseMove,
+                    isTrusted: clickEvent.isTrusted,
                 });
                 // Notify detector - clicks are high-value events
                 this.notifyEvent(1.0);
@@ -132,26 +152,102 @@ export class ClickStrategy extends BaseStrategy {
         this.lastMousePosition = null;
     }
     score() {
-        if (this.events.length === 0)
+        const eventCount = this.events.length;
+        if (eventCount === 0)
             return undefined;
-        let totalScore = 0;
+        // Pre-compute counts in a single pass
+        let positionScore = 0;
+        let clicksWithDelta = 0;
+        let mismatchCount = 0;
+        let clicksWithTiming = 0;
+        let suspiciousTimingCount = 0;
+        let untrustedCount = 0;
         for (const click of this.events) {
+            // Position scoring
             switch (click.position) {
                 case 'no-mouse-data':
-                    totalScore += 0.0; // Bot - no mouse movement
+                    positionScore += 0.0;
                     break;
                 case 'outside':
-                    totalScore += 0.0; // Bot - mouse not over target
+                    positionScore += 0.0;
                     break;
                 case 'dead-center':
-                    totalScore += 0.5; // Suspicious - too perfect
+                    positionScore += 0.5;
                     break;
                 case 'over-element':
-                    totalScore += 1.0; // Human - natural click
+                    positionScore += 1.0;
                     break;
             }
+            // Delta scoring
+            if (click.mouseClickDelta >= 0) {
+                clicksWithDelta++;
+                if (click.mouseClickDelta > 5)
+                    mismatchCount++;
+            }
+            // Timing scoring
+            if (click.timeSinceMouseMove >= 0) {
+                clicksWithTiming++;
+                if (click.timeSinceMouseMove < 10 || click.timeSinceMouseMove > 2000) {
+                    suspiciousTimingCount++;
+                }
+            }
+            // Trusted scoring
+            if (!click.isTrusted)
+                untrustedCount++;
+        }
+        let score = 0;
+        let factors = 0;
+        // 1. Position-based scoring
+        score += positionScore / eventCount;
+        factors++;
+        // 2. Mouse-click delta scoring
+        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.0;
+            score += deltaScore;
+            factors++;
+        }
+        // 3. Mouse-to-click timing
+        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.0;
+            score += timingScore;
+            factors++;
+        }
+        // 4. Trusted event scoring
+        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.0;
+            score += trustedScore;
+            factors++;
         }
-        return totalScore / this.events.length;
+        return factors > 0 ? score / factors : undefined;
     }
     getDebugInfo() {
         return {
@@ -164,6 +260,9 @@ export class ClickStrategy extends BaseStrategy {
             },
             inViewport: this.events.filter(e => e.inViewport).length,
             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,
         };
     }
 }

package/dist/esm/strategies/environment.d.ts

@@ -1,8 +1,29 @@
 /**
  * Environment Fingerprinting Strategy
  * Captures browser environment on initialization and tick updates
+ * Includes critical automation/bot detection signals
  */
 import { BaseStrategy } from '../strategy.js';
+interface AutomationIndicators {
+    /** navigator.webdriver === true (most reliable indicator) */
+    isWebdriver: boolean;
+    /** HeadlessChrome or Headless in user agent */
+    hasHeadlessUA: boolean;
+    /** window.chrome exists but window.chrome.runtime is undefined */
+    hasChromelessRuntime: boolean;
+    /** WebGL renderer is SwiftShader or software renderer */
+    hasSoftwareRenderer: boolean;
+    /** No plugins on desktop browser (suspicious) */
+    hasNoPlugins: boolean;
+    /** Automation framework globals detected */
+    hasAutomationGlobals: boolean;
+    /** List of detected automation globals */
+    detectedGlobals: string[];
+    /** CDP (Chrome DevTools Protocol) injection detected */
+    hasCDPInjection: boolean;
+    /** Detected CDP injection keys */
+    detectedCDPKeys: string[];
+}
 interface EnvironmentData {
     screenWidth: number;
     screenHeight: number;
@@ -29,6 +50,10 @@ interface EnvironmentData {
     featureInconsistency: boolean;
     isMobile: boolean;
     timestamp: number;
+    /** Automation/bot detection indicators */
+    automation: AutomationIndicators;
+    /** WebGL renderer string (for debugging) */
+    webglRenderer?: string;
 }
 export declare class EnvironmentStrategy extends BaseStrategy {
     readonly name = "environment";
@@ -40,6 +65,10 @@ export declare class EnvironmentStrategy extends BaseStrategy {
     onTick(_timestamp: number): void;
     score(): number | undefined;
     private isMobileDevice;
+    /**
+     * Detect automation indicators
+     */
+    private detectAutomation;
     private captureEnvironment;
     getDebugInfo(): EnvironmentData | null;
     /**
@@ -48,5 +77,15 @@ export declare class EnvironmentStrategy extends BaseStrategy {
      * Returns null if environment hasn't been captured yet
      */
     isMobile(): boolean | null;
+    /**
+     * Get automation detection results
+     * Returns null if environment hasn't been captured yet
+     */
+    getAutomationIndicators(): AutomationIndicators | 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(): boolean | null;
 }
 export {};

package/dist/esm/strategies/environment.js

@@ -1,9 +1,35 @@
 /**
  * Environment Fingerprinting Strategy
  * Captures browser environment on initialization and tick updates
+ * Includes critical automation/bot detection signals
  */
 import { BaseStrategy } from '../strategy.js';
 import { inverseSigmoid, gaussian } from '../math-utils.js';
+/**
+ * Automation framework globals that indicate bot activity
+ * These are injected by various testing/automation frameworks
+ */
+const 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',
+];
 export class EnvironmentStrategy extends BaseStrategy {
     constructor() {
         super(...arguments);
@@ -28,6 +54,40 @@ export class EnvironmentStrategy extends BaseStrategy {
         if (!this.data)
             return undefined;
         const env = this.data;
+        const auto = env.automation;
+        // ============================================
+        // IMMEDIATE DISQUALIFICATION - HIGH CONFIDENCE BOT SIGNALS
+        // ============================================
+        // P0: navigator.webdriver === true (HIGHEST PRIORITY)
+        // This is the most reliable automation indicator
+        if (auto.isWebdriver) {
+            return 0.05;
+        }
+        // P0: Automation framework globals detected
+        if (auto.hasAutomationGlobals) {
+            return 0.1;
+        }
+        // P0: CDP injection detected (Chrome DevTools Protocol)
+        if (auto.hasCDPInjection) {
+            return 0.1;
+        }
+        // P2: Headless browser detection
+        // Multiple headless indicators = very likely bot
+        const headlessIndicatorCount = [
+            auto.hasHeadlessUA,
+            auto.hasChromelessRuntime,
+            auto.hasSoftwareRenderer,
+        ].filter(Boolean).length;
+        if (headlessIndicatorCount >= 2) {
+            return 0.15;
+        }
+        // Single strong headless indicator
+        if (auto.hasHeadlessUA) {
+            return 0.2;
+        }
+        // ============================================
+        // WEIGHTED SCORING FOR OTHER SIGNALS
+        // ============================================
         let score = 0;
         let factors = 0;
         // Suspicious indicators
@@ -44,10 +104,27 @@ export class EnvironmentStrategy extends BaseStrategy {
         ].filter(Boolean).length;
         score += featureCount / 4;
         factors++;
-        // Plugins
-        score += inverseSigmoid(env.plugins, -2, -0.5);
-        score += (env.plugins > 0 ? 1.0 : 0.1);
-        factors += 2;
+        // Plugins (only suspicious on desktop)
+        if (!env.isMobile) {
+            score += inverseSigmoid(env.plugins, -2, -0.5);
+            score += (env.plugins > 0 ? 1.0 : 0.1);
+            factors += 2;
+            // No plugins on desktop Chrome = suspicious (but not conclusive)
+            if (auto.hasNoPlugins && env.vendor.includes('Google')) {
+                score += 0.3;
+                factors++;
+            }
+        }
+        // Chromeless runtime (window.chrome but no chrome.runtime)
+        if (auto.hasChromelessRuntime) {
+            score += 0.3;
+            factors++;
+        }
+        // Software renderer (SwiftShader)
+        if (auto.hasSoftwareRenderer) {
+            score += 0.4;
+            factors++;
+        }
         // Device
         score += gaussian(env.devicePixelRatio, 2, 1.5);
         score += (env.colorDepth === 24 || env.colorDepth === 32) ? 1.0 : 0.4;
@@ -61,13 +138,92 @@ export class EnvironmentStrategy extends BaseStrategy {
         const smallScreen = window.innerWidth < 768 && window.innerHeight < 1024;
         return (hasTouchScreen && smallScreen) || mobileUA;
     }
+    /**
+     * Detect automation indicators
+     */
+    detectAutomation() {
+        const isMobile = this.isMobileDevice();
+        // 1. navigator.webdriver - HIGHEST PRIORITY
+        const isWebdriver = navigator.webdriver === true;
+        // 2. Headless UA detection
+        const ua = navigator.userAgent;
+        const hasHeadlessUA = /HeadlessChrome|Headless/i.test(ua);
+        // 3. Chrome without runtime (headless Chrome indicator)
+        const win = window;
+        const hasChromelessRuntime = !!(win.chrome &&
+            typeof win.chrome === 'object' &&
+            !win.chrome.runtime);
+        // 4. Automation framework globals
+        const detectedGlobals = [];
+        for (const global of AUTOMATION_GLOBALS) {
+            if (global in win) {
+                detectedGlobals.push(global);
+            }
+        }
+        const hasAutomationGlobals = detectedGlobals.length > 0;
+        // 5. CDP (Chrome DevTools Protocol) injection detection
+        // CDP injects properties matching pattern: cdc_ or __cdc_
+        const detectedCDPKeys = [];
+        try {
+            for (const key of Object.keys(win)) {
+                if (/^cdc_|^__cdc_/.test(key)) {
+                    detectedCDPKeys.push(key);
+                }
+            }
+        }
+        catch (_a) {
+            // Some environments throw on Object.keys(window)
+        }
+        const hasCDPInjection = detectedCDPKeys.length > 0;
+        // 6. No plugins on desktop (suspicious)
+        const hasNoPlugins = !isMobile && navigator.plugins.length === 0;
+        // 7. Software renderer detection (SwiftShader, ANGLE without GPU)
+        let hasSoftwareRenderer = false;
+        try {
+            const canvas = document.createElement('canvas');
+            const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+            if (gl) {
+                const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+                if (debugInfo) {
+                    const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+                    // SwiftShader = headless Chrome software renderer
+                    // ANGLE without real GPU = suspicious
+                    hasSoftwareRenderer = /SwiftShader|Software|LLVMpipe/i.test(renderer);
+                    // Store for debugging
+                    this._webglRenderer = renderer;
+                }
+            }
+        }
+        catch (_b) {
+            // WebGL not available
+        }
+        return {
+            isWebdriver,
+            hasHeadlessUA,
+            hasChromelessRuntime,
+            hasSoftwareRenderer,
+            hasNoPlugins,
+            hasAutomationGlobals,
+            detectedGlobals,
+            hasCDPInjection,
+            detectedCDPKeys,
+        };
+    }
     captureEnvironment() {
         try {
             // WebGL detection
             let hasWebGL = false;
+            let webglRenderer;
             try {
                 const canvas = document.createElement('canvas');
-                hasWebGL = !!(canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
+                const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+                hasWebGL = !!gl;
+                if (gl) {
+                    const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+                    if (debugInfo) {
+                        webglRenderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+                    }
+                }
             }
             catch (e) {
                 hasWebGL = false;
@@ -97,6 +253,8 @@ export class EnvironmentStrategy extends BaseStrategy {
             const featureInconsistency = (navigator.plugins.length === 0 && navigator.mimeTypes.length === 0) ||
                 !hasWebGL ||
                 !hasStorage;
+            // Detect automation indicators
+            const automation = this.detectAutomation();
             this.data = {
                 screenWidth,
                 screenHeight,
@@ -123,10 +281,12 @@ export class EnvironmentStrategy extends BaseStrategy {
                 featureInconsistency,
                 isMobile,
                 timestamp: Date.now(),
+                automation,
+                webglRenderer,
             };
         }
-        catch (error) {
-            console.warn('Failed to capture environment:', error);
+        catch (_a) {
+            // Silent fail - environment capture is best effort
         }
     }
     getDebugInfo() {
@@ -141,4 +301,25 @@ export class EnvironmentStrategy 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);
+    }
 }

package/dist/esm/strategies/index.d.ts

@@ -9,6 +9,8 @@ export { TapStrategy } from './tap.js';
 export { KeyboardStrategy } from './keyboard.js';
 export { EnvironmentStrategy } from './environment.js';
 export { ResizeStrategy } from './resize.js';
+export { TimingStrategy } from './timing.js';
+export { VisibilityStrategy } from './visibility.js';
 export { MouseStrategy as Mouse } from './mouse.js';
 export { ScrollStrategy as Scroll } from './scroll.js';
 export { ClickStrategy as Click } from './click.js';
@@ -16,3 +18,5 @@ export { TapStrategy as Tap } from './tap.js';
 export { KeyboardStrategy as Keyboard } from './keyboard.js';
 export { EnvironmentStrategy as Environment } from './environment.js';
 export { ResizeStrategy as Resize } from './resize.js';
+export { TimingStrategy as Timing } from './timing.js';
+export { VisibilityStrategy as Visibility } from './visibility.js';

package/dist/esm/strategies/index.js

@@ -9,6 +9,8 @@ export { TapStrategy } from './tap.js';
 export { KeyboardStrategy } from './keyboard.js';
 export { EnvironmentStrategy } from './environment.js';
 export { ResizeStrategy } from './resize.js';
+export { TimingStrategy } from './timing.js';
+export { VisibilityStrategy } from './visibility.js';
 // Convenience: All strategies
 export { MouseStrategy as Mouse } from './mouse.js';
 export { ScrollStrategy as Scroll } from './scroll.js';
@@ -17,3 +19,5 @@ export { TapStrategy as Tap } from './tap.js';
 export { KeyboardStrategy as Keyboard } from './keyboard.js';
 export { EnvironmentStrategy as Environment } from './environment.js';
 export { ResizeStrategy as Resize } from './resize.js';
+export { TimingStrategy as Timing } from './timing.js';
+export { VisibilityStrategy as Visibility } from './visibility.js';

package/dist/esm/strategies/mouse.d.ts

@@ -2,8 +2,27 @@
  * Mouse Movement Detection Strategy
  * Autonomous module that manages its own mouse event listeners and state
  * Tracks distance and angle to detect unnatural jumps and sharp turns
+ *
+ * Enhanced detection:
+ * - Pre-click stillness (micro-movements before clicks)
+ * - Entry point analysis (where mouse enters viewport)
+ * - Velocity consistency
  */
 import { BaseStrategy, type TimeSeriesPoint } from '../strategy.js';
+interface MousePosition {
+    x: number;
+    y: number;
+    timestamp: number;
+}
+interface EntryPoint {
+    x: number;
+    y: number;
+    timestamp: number;
+    /** Distance from nearest edge (0 = at edge) */
+    edgeDistance: number;
+    /** Which edge: 'top' | 'bottom' | 'left' | 'right' | 'corner' | 'center' */
+    entryEdge: 'top' | 'bottom' | 'left' | 'right' | 'corner' | 'center';
+}
 export declare class MouseStrategy extends BaseStrategy {
     readonly name = "mouse";
     readonly defaultWeight = 0.3;
@@ -15,8 +34,15 @@ export declare class MouseStrategy extends BaseStrategy {
     private rollingWindowMs;
     private listener;
     private leaveListener;
+    private enterListener;
     private isActive;
     private screenDiagonal;
+    /** Entry points tracking */
+    private entryPoints;
+    /** Micro-movements in last 500ms (for stillness detection) */
+    private microMovements;
+    /** Stillness window in ms */
+    private readonly STILLNESS_WINDOW;
     constructor(options?: {
         rollingWindow?: number;
     });
@@ -26,14 +52,40 @@ export declare class MouseStrategy extends BaseStrategy {
     score(): number | undefined;
     /**
      * Mouse-specific pattern detection
-     * Detects bot-like patterns: constant velocity, linear paths
+     * Detects bot-like patterns: constant velocity, linear paths, suspicious entry points
      */
     private detectMousePatterns;
+    /**
+     * Score based on viewport entry points
+     * Humans enter from edges with momentum; bots often start at (0,0) or center
+     */
+    private scoreEntryPoints;
+    /**
+     * Score based on micro-movements (tremor detection)
+     * Humans have natural hand tremor causing 1-5px jitter
+     * Bots have perfect stillness or no micro-movements
+     */
+    private scoreMicroMovements;
+    /**
+     * Get micro-movement count for external use (e.g., by ClickStrategy)
+     */
+    getMicroMovementCount(): number;
+    /**
+     * Get last position for external use
+     */
+    getLastPosition(): {
+        x: number;
+        y: number;
+    } | null;
     getDebugInfo(): {
         eventCount: number;
         rollingWindow: number;
         isActive: boolean;
         distanceSeries: TimeSeriesPoint[];
         angleSeries: TimeSeriesPoint[];
+        entryPoints: EntryPoint[];
+        microMovementCount: number;
+        lastPosition: MousePosition | null;
     };
 }
+export {};