@axeptio/behavior-detection 1.0.3 → 1.1.1

package/dist/esm/strategies/timing.js

@@ -0,0 +1,308 @@
+/**
+ * Timing Analysis Strategy
+ * Detects bot-like timing patterns in user interactions
+ *
+ * Key detection signals:
+ * - Pre-action stillness (humans have micro-movements before clicking)
+ * - Action timing patterns (machine-precise intervals)
+ * - Inactivity patterns (bursts after long silence, no idle variance)
+ * - Actions while tab is hidden (bots ignore visibility)
+ */
+import { BaseStrategy } from '../strategy.js';
+import { calculateStatistics } from '../math-utils.js';
+export class TimingStrategy 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;
+        /** Time window to consider for pre-action stillness (ms) */
+        this.STILLNESS_WINDOW = 500;
+        /** Minimum distance to count as meaningful movement (px) */
+        this.MICRO_MOVEMENT_THRESHOLD = 1;
+        /** Maximum micro-movement to count (jitter vs intentional) (px) */
+        this.MAX_MICRO_MOVEMENT = 5;
+        /** Machine-precision threshold (intervals within this are suspicious) */
+        this.MACHINE_PRECISION_THRESHOLD = 5; // 5ms
+    }
+    start() {
+        if (this.isActive)
+            return;
+        this.isActive = true;
+        // Track mouse movement for stillness detection
+        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);
+                // Track micro-movements (1-5px range)
+                if (distance >= this.MICRO_MOVEMENT_THRESHOLD && distance <= this.MAX_MICRO_MOVEMENT) {
+                    this.microMovements.push({ timestamp: now, distance });
+                }
+                // Any meaningful movement updates the last move time
+                if (distance >= this.MICRO_MOVEMENT_THRESHOLD) {
+                    this.mouseStillness.lastMoveTime = now;
+                }
+            }
+            this.mouseStillness.position = currentPos;
+            // Clean up old micro-movements (keep only last STILLNESS_WINDOW)
+            const cutoff = now - this.STILLNESS_WINDOW;
+            this.microMovements = this.microMovements.filter(m => m.timestamp >= cutoff);
+        };
+        // Track clicks with timing context
+        this.clickListener = (e) => {
+            this.recordAction('click', e);
+        };
+        // Track keydown with timing context
+        this.keydownListener = () => {
+            this.recordAction('keydown');
+        };
+        // Track scroll with timing context
+        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();
+        // Calculate time since last mouse movement
+        const timeSinceMouseMove = this.mouseStillness.lastMoveTime > 0
+            ? now - this.mouseStillness.lastMoveTime
+            : -1;
+        // Count micro-movements in stillness window (already filtered in mouse listener)
+        this.mouseStillness.microMovementCount = this.microMovements.length;
+        this.actions.push({
+            type,
+            timestamp: now,
+            timeSinceMouseMove,
+            wasHidden: document.hidden,
+        });
+        // Notify detector
+        this.notifyEvent(0.7);
+        // Keep only last 100 actions for memory efficiency (shift is O(n) but rare)
+        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 undefined;
+        let score = 0;
+        let factors = 0;
+        // Cache filtered arrays to avoid repeated iteration
+        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++;
+        }
+        // 1. Pre-action stillness detection
+        if (clicks.length >= 2) {
+            const stillnessScore = this.scorePreActionStillness(clicks);
+            if (stillnessScore !== undefined) {
+                score += stillnessScore;
+                factors++;
+            }
+        }
+        // 2. Mouse-to-action delay analysis
+        if (clicksWithMouse.length >= 3) {
+            const mouseToClickScore = this.scoreMouseToClickDelayFromCache(clicksWithMouse);
+            if (mouseToClickScore !== undefined) {
+                score += mouseToClickScore;
+                factors++;
+            }
+        }
+        // 3. Action interval patterns
+        if (actionCount >= 5) {
+            const intervalScore = this.scoreActionIntervals();
+            if (intervalScore !== undefined) {
+                score += intervalScore;
+                factors++;
+            }
+        }
+        // 4. Hidden document actions
+        const hiddenScore = this.scoreHiddenActionsFromCount(hiddenCount, actionCount);
+        score += hiddenScore;
+        factors++;
+        return factors > 0 ? score / factors : undefined;
+    }
+    /**
+     * Score based on pre-action stillness
+     * Humans have micro-movements before clicking; bots are perfectly still
+     */
+    scorePreActionStillness(clicks) {
+        // Look at clicks with mouse data
+        const clicksWithMouseData = clicks.filter(c => c.timeSinceMouseMove >= 0);
+        if (clicksWithMouseData.length < 2)
+            return undefined;
+        // Count clicks with zero pre-action movement (100-500ms window)
+        const perfectlyStillClicks = clicksWithMouseData.filter(c => {
+            // Time since mouse move in the suspicious range (100-500ms of perfect stillness)
+            return c.timeSinceMouseMove >= 100 && c.timeSinceMouseMove <= 500 &&
+                this.mouseStillness.microMovementCount === 0;
+        }).length;
+        const stillRatio = perfectlyStillClicks / clicksWithMouseData.length;
+        // High ratio of perfectly still clicks = likely bot
+        // 0% still = very human (1.0)
+        // 50%+ still = suspicious (0.3)
+        // 100% still = very bot-like (0.1)
+        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.0;
+    }
+    /**
+     * Score mouse-to-click delay patterns (using pre-filtered cache)
+     */
+    scoreMouseToClickDelayFromCache(clicksWithMouse) {
+        const delays = clicksWithMouse.map(c => c.timeSinceMouseMove);
+        const stats = calculateStatistics(delays);
+        // Suspiciously fast clicks (< 10ms average)
+        if (stats.mean < 10)
+            return 0.1;
+        // Suspiciously consistent delays (CV < 0.2)
+        if (stats.cv < 0.2 && clicksWithMouse.length >= 5)
+            return 0.2;
+        // Normal human range (50-300ms with variation)
+        if (stats.mean >= 50 && stats.mean <= 300 && stats.cv >= 0.3)
+            return 1.0;
+        // Somewhat suspicious
+        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 undefined;
+        const intervals = [];
+        for (let i = 1; i < this.actions.length; i++) {
+            intervals.push(this.actions[i].timestamp - this.actions[i - 1].timestamp);
+        }
+        // Check for machine-precise intervals (multiples of common values)
+        const machineIntervals = [100, 200, 250, 500, 1000];
+        let preciseCount = 0;
+        for (const interval of intervals) {
+            for (const machineInterval of machineIntervals) {
+                // Check if interval is within threshold of machine interval or its multiples
+                const remainder = interval % machineInterval;
+                if (remainder < this.MACHINE_PRECISION_THRESHOLD ||
+                    (machineInterval - remainder) < this.MACHINE_PRECISION_THRESHOLD) {
+                    preciseCount++;
+                    break;
+                }
+            }
+        }
+        const preciseRatio = preciseCount / intervals.length;
+        // High ratio of machine-precise intervals = bot
+        if (preciseRatio >= 0.8)
+            return 0.1;
+        if (preciseRatio >= 0.6)
+            return 0.3;
+        if (preciseRatio >= 0.4)
+            return 0.5;
+        // Also check coefficient of variation (should be high for humans)
+        const stats = calculateStatistics(intervals);
+        if (stats.cv < 0.15)
+            return 0.2; // Too consistent
+        return 1.0;
+    }
+    /**
+     * Score based on actions while document was hidden (using pre-computed count)
+     */
+    scoreHiddenActionsFromCount(hiddenCount, totalCount) {
+        if (hiddenCount === 0)
+            return 1.0; // Perfect - no hidden actions
+        const hiddenRatio = hiddenCount / totalCount;
+        // Any hidden actions are suspicious
+        if (hiddenRatio > 0.5)
+            return 0.1; // Major bot indicator
+        if (hiddenRatio > 0.2)
+            return 0.3;
+        if (hiddenRatio > 0)
+            return 0.5;
+        return 1.0;
+    }
+    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,
+        };
+    }
+}

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

@@ -0,0 +1,64 @@
+/**
+ * Visibility Strategy
+ * Detects bot-like behavior based on tab visibility and focus patterns
+ *
+ * Key detection signals:
+ * - Actions while document.hidden === true (bots ignore visibility)
+ * - No pause when tab loses focus
+ * - Activity resumes too quickly after tab regains focus
+ * - Focus patterns: humans focus inputs before typing
+ */
+import { BaseStrategy } from '../strategy.js';
+export declare class VisibilityStrategy extends BaseStrategy {
+    readonly name = "visibility";
+    readonly defaultWeight = 0.1;
+    private events;
+    private focusTypingPairs;
+    private actionsWhileHidden;
+    private lastVisibilityChange;
+    private resumeDelays;
+    private isActive;
+    private visibilityListener;
+    private focusListener;
+    private blurListener;
+    private clickListener;
+    private keydownListener;
+    private inputFocusListener;
+    private lastFocusedInput;
+    private hasTypedInFocusedInput;
+    private lastActionTime;
+    private preHideActionTime;
+    start(): void;
+    private recordAction;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    /**
+     * Score based on actions while document was hidden
+     * Humans can't interact with hidden tabs; bots can
+     */
+    private scoreHiddenActions;
+    /**
+     * Score based on how quickly activity resumes after tab becomes visible
+     * Humans need time to refocus (100-500ms minimum)
+     * Bots often resume instantly (< 50ms)
+     */
+    private scoreResumeDelays;
+    /**
+     * 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
+     */
+    private scoreFocusTyping;
+    getDebugInfo(): {
+        eventCount: number;
+        actionsWhileHidden: number;
+        visibilityChanges: number;
+        focusChanges: number;
+        resumeDelays: number[];
+        focusTypingPairs: {
+            delay: number;
+            element: string;
+        }[];
+    };
+}

package/dist/esm/strategies/visibility.js

@@ -0,0 +1,295 @@
+/**
+ * Visibility Strategy
+ * Detects bot-like behavior based on tab visibility and focus patterns
+ *
+ * Key detection signals:
+ * - Actions while document.hidden === true (bots ignore visibility)
+ * - No pause when tab loses focus
+ * - Activity resumes too quickly after tab regains focus
+ * - Focus patterns: humans focus inputs before typing
+ */
+import { BaseStrategy } from '../strategy.js';
+export class VisibilityStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'visibility';
+        this.defaultWeight = 0.10;
+        this.events = [];
+        this.focusTypingPairs = [];
+        this.actionsWhileHidden = 0;
+        this.lastVisibilityChange = null;
+        this.resumeDelays = [];
+        this.isActive = false;
+        // Listeners
+        this.visibilityListener = null;
+        this.focusListener = null;
+        this.blurListener = null;
+        this.clickListener = null;
+        this.keydownListener = null;
+        this.inputFocusListener = null;
+        // State
+        this.lastFocusedInput = null;
+        this.hasTypedInFocusedInput = false;
+        this.lastActionTime = 0;
+        this.preHideActionTime = 0;
+    }
+    start() {
+        if (this.isActive)
+            return;
+        this.isActive = true;
+        // Track visibility changes
+        this.visibilityListener = () => {
+            const now = Date.now();
+            const wasHidden = document.hidden;
+            // Track time between visibility changes
+            if (this.lastVisibilityChange && !wasHidden) {
+                // Tab just became visible again
+                // Check if there was activity right before becoming visible
+                // Humans need time to refocus after tab switch
+                if (this.lastActionTime > 0 && this.preHideActionTime > 0) {
+                    const timeSinceLastAction = now - this.lastActionTime;
+                    // If action was very recent (< 50ms), suspicious
+                    if (timeSinceLastAction < 50) {
+                        this.actionsWhileHidden++;
+                    }
+                }
+                // Track resume delay (time until first action after visibility)
+                // Will be calculated when next action occurs
+                this.lastVisibilityChange = { hidden: false, timestamp: now };
+            }
+            else if (wasHidden) {
+                // Tab just became hidden - record pre-hide action time
+                this.preHideActionTime = this.lastActionTime;
+                this.lastVisibilityChange = { hidden: true, timestamp: now };
+            }
+            this.events.push({
+                type: 'visibility_change',
+                timestamp: now,
+                wasHidden,
+            });
+        };
+        // Track window focus
+        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,
+            });
+        };
+        // Track actions while hidden
+        this.clickListener = (e) => {
+            this.recordAction('click', e);
+        };
+        this.keydownListener = (e) => {
+            this.recordAction('keydown', e);
+            // Track focus-to-keypress timing
+            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;
+            }
+        };
+        // Track input focus for focus-typing analysis
+        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;
+        // Check if action occurred while document was hidden
+        if (document.hidden) {
+            this.actionsWhileHidden++;
+            this.events.push({
+                type: 'action_while_hidden',
+                timestamp: now,
+                wasHidden: true,
+            });
+            // Notify detector - this is a strong bot signal
+            this.notifyEvent(1.0);
+        }
+        // Track resume delay after visibility change
+        if (this.lastVisibilityChange && !this.lastVisibilityChange.hidden) {
+            const resumeDelay = now - this.lastVisibilityChange.timestamp;
+            // Only count if this is the first action after becoming visible
+            // and the delay is reasonable (< 10 seconds)
+            if (resumeDelay > 0 && resumeDelay < 10000 && this.resumeDelays.length < 20) {
+                // Check if we haven't already recorded a delay for this visibility change
+                const lastRecordedDelay = this.resumeDelays[this.resumeDelays.length - 1];
+                if (lastRecordedDelay === undefined || 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() {
+        // Need some visibility events to score
+        if (this.events.length < 2)
+            return undefined;
+        let score = 0;
+        let factors = 0;
+        // 1. Actions while hidden (strongest signal)
+        const hiddenActionScore = this.scoreHiddenActions();
+        if (hiddenActionScore !== undefined) {
+            score += hiddenActionScore;
+            factors++;
+        }
+        // 2. Resume delay analysis
+        const resumeScore = this.scoreResumeDelays();
+        if (resumeScore !== undefined) {
+            score += resumeScore;
+            factors++;
+        }
+        // 3. Focus-typing pattern
+        const focusTypingScore = this.scoreFocusTyping();
+        if (focusTypingScore !== undefined) {
+            score += focusTypingScore;
+            factors++;
+        }
+        return factors > 0 ? score / factors : undefined;
+    }
+    /**
+     * Score based on actions while document was hidden
+     * Humans can't interact with hidden tabs; bots can
+     */
+    scoreHiddenActions() {
+        if (this.actionsWhileHidden === 0)
+            return 1.0; // Perfect
+        // Any action while hidden is highly suspicious
+        if (this.actionsWhileHidden >= 5)
+            return 0.1;
+        if (this.actionsWhileHidden >= 3)
+            return 0.2;
+        if (this.actionsWhileHidden >= 1)
+            return 0.3;
+        return 1.0;
+    }
+    /**
+     * 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 undefined;
+        // Count suspiciously fast resumes (< 50ms)
+        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.0;
+    }
+    /**
+     * 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 undefined;
+        let suspiciousCount = 0;
+        for (const pair of this.focusTypingPairs) {
+            // Instant typing after focus (< 20ms) is suspicious
+            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.0;
+    }
+    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,
+            })),
+        };
+    }
+}

package/dist/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/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;
     };
 }