@axeptio/behavior-detection 1.0.0

package/dist/cjs/strategies/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Detection Strategies - Modular behavior analysis
+ * Import only what you need for optimal bundle size
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resize = exports.Environment = exports.Keyboard = exports.Tap = exports.Click = exports.Scroll = exports.Mouse = exports.ResizeStrategy = exports.EnvironmentStrategy = exports.KeyboardStrategy = exports.TapStrategy = exports.ClickStrategy = exports.ScrollStrategy = exports.MouseStrategy = void 0;
+var mouse_1 = require("./mouse");
+Object.defineProperty(exports, "MouseStrategy", { enumerable: true, get: function () { return mouse_1.MouseStrategy; } });
+var scroll_1 = require("./scroll");
+Object.defineProperty(exports, "ScrollStrategy", { enumerable: true, get: function () { return scroll_1.ScrollStrategy; } });
+var click_1 = require("./click");
+Object.defineProperty(exports, "ClickStrategy", { enumerable: true, get: function () { return click_1.ClickStrategy; } });
+var tap_1 = require("./tap");
+Object.defineProperty(exports, "TapStrategy", { enumerable: true, get: function () { return tap_1.TapStrategy; } });
+var keyboard_1 = require("./keyboard");
+Object.defineProperty(exports, "KeyboardStrategy", { enumerable: true, get: function () { return keyboard_1.KeyboardStrategy; } });
+var environment_1 = require("./environment");
+Object.defineProperty(exports, "EnvironmentStrategy", { enumerable: true, get: function () { return environment_1.EnvironmentStrategy; } });
+var resize_1 = require("./resize");
+Object.defineProperty(exports, "ResizeStrategy", { enumerable: true, get: function () { return resize_1.ResizeStrategy; } });
+// Convenience: All strategies
+var mouse_2 = require("./mouse");
+Object.defineProperty(exports, "Mouse", { enumerable: true, get: function () { return mouse_2.MouseStrategy; } });
+var scroll_2 = require("./scroll");
+Object.defineProperty(exports, "Scroll", { enumerable: true, get: function () { return scroll_2.ScrollStrategy; } });
+var click_2 = require("./click");
+Object.defineProperty(exports, "Click", { enumerable: true, get: function () { return click_2.ClickStrategy; } });
+var tap_2 = require("./tap");
+Object.defineProperty(exports, "Tap", { enumerable: true, get: function () { return tap_2.TapStrategy; } });
+var keyboard_2 = require("./keyboard");
+Object.defineProperty(exports, "Keyboard", { enumerable: true, get: function () { return keyboard_2.KeyboardStrategy; } });
+var environment_2 = require("./environment");
+Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return environment_2.EnvironmentStrategy; } });
+var resize_2 = require("./resize");
+Object.defineProperty(exports, "Resize", { enumerable: true, get: function () { return resize_2.ResizeStrategy; } });

package/dist/cjs/strategies/keyboard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Keyboard Timing Detection Strategy
+ * Monitors typing in specific input fields
+ * Analyzes keydown/keyup timing and micro-variations
+ */
+import { BaseStrategy } from '../strategy';
+export declare class KeyboardStrategy extends BaseStrategy {
+    readonly name = "keyboard";
+    readonly defaultWeight = 0.1;
+    private events;
+    private targetSelectors;
+    private focusedElement;
+    private focusedElementSelector;
+    private lastEventTimestamp;
+    private sessionPauseThreshold;
+    private downListener;
+    private upListener;
+    private focusListeners;
+    private blurListeners;
+    private isActive;
+    constructor(options?: {
+        targetSelectors?: string[];
+    });
+    start(): void;
+    /**
+     * Add a new target selector at runtime
+     */
+    addTarget(selector: string): void;
+    private attachFocusListeners;
+    private attachFocusListenersForSelector;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    getDebugInfo(): {
+        eventCount: number;
+        downEvents: number;
+        upEvents: number;
+        backspaceCount: number;
+        pressDurations: number[];
+        focusedElement: string;
+        trackedElements: number;
+    };
+}

package/dist/cjs/strategies/keyboard.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Keyboard Timing Detection Strategy
+ * Monitors typing in specific input fields
+ * Analyzes keydown/keyup timing and micro-variations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardStrategy = void 0;
+const strategy_1 = require("../strategy");
+const math_utils_1 = require("../math-utils");
+class KeyboardStrategy extends strategy_1.BaseStrategy {
+    constructor(options) {
+        super();
+        this.name = 'keyboard';
+        this.defaultWeight = 0.10;
+        this.events = [];
+        this.targetSelectors = ['input[type="text"]', 'input[type="email"]', 'textarea'];
+        this.focusedElement = null;
+        this.focusedElementSelector = '';
+        this.lastEventTimestamp = 0;
+        this.sessionPauseThreshold = 1000;
+        this.downListener = null;
+        this.upListener = null;
+        this.focusListeners = new Map();
+        this.blurListeners = new Map();
+        this.isActive = false;
+        if (options === null || options === void 0 ? void 0 : options.targetSelectors) {
+            this.targetSelectors = options.targetSelectors;
+        }
+    }
+    start() {
+        if (this.isActive)
+            return;
+        this.isActive = true;
+        // Attach focus/blur listeners to all matching elements
+        this.attachFocusListeners();
+        // Key event listeners (only track when an input is focused)
+        this.downListener = (e) => {
+            if (!this.focusedElement)
+                return; // No input focused
+            const now = Date.now();
+            const keyEvent = e;
+            // Clear events if pause > 1s (new typing session)
+            if (this.lastEventTimestamp > 0 && now - this.lastEventTimestamp > this.sessionPauseThreshold) {
+                this.events = [];
+            }
+            this.events.push({
+                key: keyEvent.key,
+                type: 'down',
+                timestamp: now,
+                targetElement: this.focusedElementSelector,
+            });
+            // Notify detector - keystrokes are valuable events
+            this.notifyEvent(0.8);
+            this.lastEventTimestamp = now;
+        };
+        this.upListener = (e) => {
+            if (!this.focusedElement)
+                return; // No input focused
+            const now = Date.now();
+            const keyEvent = e;
+            // Clear events if pause > 1s (new typing session)
+            if (this.lastEventTimestamp > 0 && now - this.lastEventTimestamp > this.sessionPauseThreshold) {
+                this.events = [];
+            }
+            this.events.push({
+                key: keyEvent.key,
+                type: 'up',
+                timestamp: now,
+                targetElement: this.focusedElementSelector,
+            });
+            this.lastEventTimestamp = now;
+        };
+        document.addEventListener('keydown', this.downListener);
+        document.addEventListener('keyup', this.upListener);
+    }
+    /**
+     * Add a new target selector at runtime
+     */
+    addTarget(selector) {
+        if (!this.targetSelectors.includes(selector)) {
+            this.targetSelectors.push(selector);
+            if (this.isActive) {
+                this.attachFocusListenersForSelector(selector);
+            }
+        }
+    }
+    attachFocusListeners() {
+        this.targetSelectors.forEach(selector => {
+            this.attachFocusListenersForSelector(selector);
+        });
+    }
+    attachFocusListenersForSelector(selector) {
+        const elements = document.querySelectorAll(selector);
+        elements.forEach(element => {
+            if (this.focusListeners.has(element))
+                return; // Already attached
+            const focusListener = () => {
+                this.focusedElement = element;
+                this.focusedElementSelector = selector;
+            };
+            const blurListener = () => {
+                this.focusedElement = null;
+                this.focusedElementSelector = '';
+            };
+            element.addEventListener('focus', focusListener);
+            element.addEventListener('blur', blurListener);
+            this.focusListeners.set(element, focusListener);
+            this.blurListeners.set(element, blurListener);
+        });
+    }
+    stop() {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        if (this.downListener) {
+            document.removeEventListener('keydown', this.downListener);
+            this.downListener = null;
+        }
+        if (this.upListener) {
+            document.removeEventListener('keyup', this.upListener);
+            this.upListener = null;
+        }
+        // Remove focus/blur listeners
+        this.focusListeners.forEach((listener, element) => {
+            element.removeEventListener('focus', listener);
+        });
+        this.focusListeners.clear();
+        this.blurListeners.forEach((listener, element) => {
+            element.removeEventListener('blur', listener);
+        });
+        this.blurListeners.clear();
+        this.focusedElement = null;
+    }
+    reset() {
+        this.events = [];
+        this.focusedElement = null;
+        this.focusedElementSelector = '';
+        this.lastEventTimestamp = 0;
+    }
+    score() {
+        if (this.events.length < 6)
+            return undefined; // Need at least 3 key pairs
+        const downEvents = this.events.filter(e => e.type === 'down');
+        if (downEvents.length < 3)
+            return undefined;
+        let score = 0;
+        let factors = 0;
+        // 1. Analyze keystroke intervals (time between keydown events)
+        const keystrokeIntervals = [];
+        for (let i = 1; i < downEvents.length; i++) {
+            keystrokeIntervals.push(downEvents[i].timestamp - downEvents[i - 1].timestamp);
+        }
+        const keystrokeAnalysis = (0, math_utils_1.analyzeIntervals)(keystrokeIntervals);
+        if (keystrokeAnalysis) {
+            const { statistics, allIdentical } = keystrokeAnalysis;
+            // Keyboard-specific heuristics for keystroke timing
+            if (allIdentical) {
+                return 0.1; // All identical - bot!
+            }
+            const keystrokeScore = (0, math_utils_1.scoreCoefficientOfVariation)(statistics.cv);
+            score += keystrokeScore;
+            factors++;
+            // Early return if bot detected
+            if (keystrokeScore <= 0.1)
+                return keystrokeScore;
+        }
+        // 2. Analyze press durations (keydown-to-keyup duration)
+        const pressDurations = [];
+        for (let i = 0; i < this.events.length - 1; i++) {
+            if (this.events[i].type === 'down' && this.events[i + 1].type === 'up' &&
+                this.events[i].key === this.events[i + 1].key) {
+                pressDurations.push(this.events[i + 1].timestamp - this.events[i].timestamp);
+            }
+        }
+        const pressDurationAnalysis = (0, math_utils_1.analyzeIntervals)(pressDurations);
+        if (pressDurationAnalysis) {
+            const { statistics, allIdentical } = pressDurationAnalysis;
+            // Keyboard-specific heuristics for press duration
+            if (allIdentical) {
+                return 0.1; // All identical - bot!
+            }
+            // Check for suspiciously fast key releases (bots often have <5ms press duration)
+            if (statistics.mean < 5) {
+                score += 0.1; // Too fast = bot (instant release)
+                factors++;
+            }
+            else {
+                const pressDurationScore = (0, math_utils_1.scoreCoefficientOfVariation)(statistics.cv);
+                score += pressDurationScore;
+                factors++;
+                // Early return if bot detected
+                if (pressDurationScore <= 0.1)
+                    return pressDurationScore;
+            }
+        }
+        // 3. Bonus for backspace usage (human error correction)
+        const backspaceCount = this.events.filter(e => e.key === 'Backspace').length;
+        if (backspaceCount > 0) {
+            // Natural human behavior - making corrections
+            const backspaceRatio = backspaceCount / downEvents.length;
+            if (backspaceRatio > 0.05 && backspaceRatio < 0.3) {
+                score += 1.0; // Reasonable error correction
+                factors++;
+            }
+            else if (backspaceRatio > 0) {
+                score += 0.8; // Some backspaces
+                factors++;
+            }
+        }
+        return factors > 0 ? score / factors : undefined;
+    }
+    getDebugInfo() {
+        // Calculate press durations for visualization
+        const pressDurations = [];
+        for (let i = 0; i < this.events.length - 1; i++) {
+            if (this.events[i].type === 'down' && this.events[i + 1].type === 'up' &&
+                this.events[i].key === this.events[i + 1].key) {
+                pressDurations.push(this.events[i + 1].timestamp - this.events[i].timestamp);
+            }
+        }
+        return {
+            eventCount: this.events.length,
+            downEvents: this.events.filter(e => e.type === 'down').length,
+            upEvents: this.events.filter(e => e.type === 'up').length,
+            backspaceCount: this.events.filter(e => e.key === 'Backspace').length,
+            pressDurations, // For graphing
+            focusedElement: this.focusedElementSelector,
+            trackedElements: this.focusListeners.size,
+        };
+    }
+}
+exports.KeyboardStrategy = KeyboardStrategy;

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

@@ -0,0 +1,39 @@
+/**
+ * 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
+ */
+import { BaseStrategy, type TimeSeriesPoint } from '../strategy';
+export declare class MouseStrategy extends BaseStrategy {
+    readonly name = "mouse";
+    readonly defaultWeight = 0.3;
+    private distanceSeries;
+    private angleSeries;
+    private lastPosition;
+    private lastAngle;
+    private cumulativeAngle;
+    private rollingWindowMs;
+    private listener;
+    private leaveListener;
+    private isActive;
+    private screenDiagonal;
+    constructor(options?: {
+        rollingWindow?: number;
+    });
+    start(): void;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    /**
+     * Mouse-specific pattern detection
+     * Detects bot-like patterns: constant velocity, linear paths
+     */
+    private detectMousePatterns;
+    getDebugInfo(): {
+        eventCount: number;
+        rollingWindow: number;
+        isActive: boolean;
+        distanceSeries: TimeSeriesPoint[];
+        angleSeries: TimeSeriesPoint[];
+    };
+}

package/dist/cjs/strategies/mouse.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseStrategy = void 0;
+const strategy_1 = require("../strategy");
+const math_utils_1 = require("../math-utils");
+class MouseStrategy extends strategy_1.BaseStrategy {
+    constructor(options) {
+        super();
+        this.name = 'mouse';
+        this.defaultWeight = 0.30;
+        this.distanceSeries = [];
+        this.angleSeries = [];
+        this.lastPosition = null;
+        this.lastAngle = 0;
+        this.cumulativeAngle = 0;
+        this.rollingWindowMs = 5000;
+        this.listener = null;
+        this.leaveListener = null;
+        this.isActive = false;
+        this.screenDiagonal = 1;
+        if ((options === null || options === void 0 ? void 0 : options.rollingWindow) !== undefined)
+            this.rollingWindowMs = options.rollingWindow;
+    }
+    start() {
+        if (this.isActive)
+            return;
+        this.isActive = true;
+        // Calculate screen diagonal for normalization (distance relative to screen size)
+        const width = window.innerWidth;
+        const height = window.innerHeight;
+        this.screenDiagonal = Math.sqrt(width * width + height * height);
+        this.listener = (e) => {
+            const mouseEvent = e;
+            const now = Date.now();
+            const currentPos = { x: mouseEvent.clientX, y: mouseEvent.clientY };
+            // Calculate distance and angle from previous position
+            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);
+                // Normalize distance to screen diagonal (0-1 range)
+                // A full diagonal movement = 1.0, a 10px movement on 2000px screen = 0.005
+                const normalizedDistance = pixelDistance / this.screenDiagonal;
+                // Only record if movement is meaningful (> 0.001 = ~2px on 2000px screen)
+                if (normalizedDistance > 0.001) {
+                    const rawAngle = Math.atan2(dy, dx); // -PI to PI
+                    // Unwrap angle to avoid discontinuities (e.g., circles)
+                    let angleDiff = rawAngle - this.lastAngle;
+                    // Normalize difference to -PI to PI
+                    while (angleDiff > Math.PI)
+                        angleDiff -= 2 * Math.PI;
+                    while (angleDiff < -Math.PI)
+                        angleDiff += 2 * Math.PI;
+                    this.cumulativeAngle += angleDiff;
+                    this.lastAngle = rawAngle;
+                    // Store normalized distance (not raw pixels)
+                    this.distanceSeries.push({ value: normalizedDistance, timestamp: now });
+                    this.angleSeries.push({ value: this.cumulativeAngle, timestamp: now });
+                    // Notify detector for confidence tracking
+                    this.notifyEvent(Math.min(1, normalizedDistance * 100));
+                }
+                // Apply rolling window efficiently: remove old events from start
+                // Since events are chronological, we only check from the beginning
+                const cutoff = now - this.rollingWindowMs;
+                while (this.distanceSeries.length > 0 && this.distanceSeries[0].timestamp < cutoff) {
+                    this.distanceSeries.shift();
+                    this.angleSeries.shift(); // Keep both arrays in sync
+                }
+            }
+            this.lastPosition = currentPos;
+        };
+        document.addEventListener('mousemove', this.listener, { passive: true });
+        // Clear data when mouse leaves the window (discontinuous tracking)
+        this.leaveListener = () => {
+            this.distanceSeries = [];
+            this.angleSeries = [];
+            this.lastPosition = null;
+            this.lastAngle = 0;
+            this.cumulativeAngle = 0;
+        };
+        document.addEventListener('mouseleave', this.leaveListener, { passive: true });
+    }
+    stop() {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        if (this.listener) {
+            document.removeEventListener('mousemove', this.listener);
+            this.listener = null;
+        }
+        if (this.leaveListener) {
+            document.removeEventListener('mouseleave', this.leaveListener);
+            this.leaveListener = null;
+        }
+    }
+    reset() {
+        this.distanceSeries = [];
+        this.angleSeries = [];
+        this.lastPosition = null;
+        this.lastAngle = 0;
+        this.cumulativeAngle = 0;
+    }
+    score() {
+        if (this.distanceSeries.length < 10)
+            return undefined;
+        // Mouse-specific pattern detection (optimized for normalized continuous data)
+        // Generic smoothness detector is calibrated for discrete events, not continuous movement
+        return this.detectMousePatterns();
+    }
+    /**
+     * Mouse-specific pattern detection
+     * Detects bot-like patterns: constant velocity, linear paths
+     */
+    detectMousePatterns() {
+        if (this.distanceSeries.length < 10)
+            return undefined;
+        let score = 0;
+        let factors = 0;
+        // 1. VELOCITY CONSISTENCY - Bots often move at constant speed
+        const distances = this.distanceSeries.map(p => p.value);
+        if (distances.length >= 3) {
+            const stats = (0, math_utils_1.calculateStatistics)(distances);
+            // Real human movement has high variation (CV ~0.8-1.2)
+            // page.mouse.move() with steps has lower CV (~0.4-0.6)
+            // Narrower gaussian to be strict
+            score += (0, math_utils_1.gaussian)(stats.cv, 0.9, 0.35);
+            factors++;
+        }
+        // 2. DIRECTION CHANGES - Bots often have too few or too many sharp turns
+        const angles = this.angleSeries.map(p => p.value);
+        if (angles.length >= 3) {
+            const angleChanges = [];
+            for (let i = 1; i < angles.length; i++) {
+                angleChanges.push(Math.abs(angles[i] - angles[i - 1]));
+            }
+            const avgChange = angleChanges.reduce((a, b) => a + b, 0) / angleChanges.length;
+            // Real humans have moderate but varied direction changes
+            // page.mouse.move() linear interpolation has very small, consistent changes
+            score += (0, math_utils_1.gaussian)(avgChange, 0.15, 0.12);
+            factors++;
+        }
+        return factors > 0 ? score / factors : undefined;
+    }
+    getDebugInfo() {
+        return {
+            eventCount: this.distanceSeries.length,
+            rollingWindow: this.rollingWindowMs,
+            isActive: this.isActive,
+            distanceSeries: this.distanceSeries,
+            angleSeries: this.angleSeries,
+        };
+    }
+}
+exports.MouseStrategy = MouseStrategy;

package/dist/cjs/strategies/resize.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Resize Behavior Detection Strategy
+ */
+import { BaseStrategy } from '../strategy';
+export declare class ResizeStrategy extends BaseStrategy {
+    readonly name = "resize";
+    readonly defaultWeight = 0.02;
+    private events;
+    private listener;
+    private isActive;
+    private lastMousePosition;
+    private mouseListener;
+    start(): void;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    getDebugInfo(): {
+        eventCount: number;
+        withMouseData: number;
+    };
+}

package/dist/cjs/strategies/resize.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Resize Behavior Detection Strategy
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResizeStrategy = void 0;
+const strategy_1 = require("../strategy");
+const math_utils_1 = require("../math-utils");
+class ResizeStrategy extends strategy_1.BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'resize';
+        this.defaultWeight = 0.02;
+        this.events = [];
+        this.listener = null;
+        this.isActive = false;
+        this.lastMousePosition = null;
+        this.mouseListener = null;
+    }
+    start() {
+        if (this.isActive)
+            return;
+        this.isActive = true;
+        // Track mouse for resize detection
+        this.mouseListener = (e) => {
+            const mouseEvent = e;
+            this.lastMousePosition = {
+                x: mouseEvent.clientX,
+                y: mouseEvent.clientY,
+            };
+        };
+        document.addEventListener('mousemove', this.mouseListener, { passive: true });
+        // Track resizes
+        this.listener = () => {
+            var _a, _b;
+            const mouseX = (_a = this.lastMousePosition) === null || _a === void 0 ? void 0 : _a.x;
+            const mouseY = (_b = this.lastMousePosition) === null || _b === void 0 ? void 0 : _b.y;
+            let mouseNearEdge = false;
+            if (mouseX !== undefined && mouseY !== undefined) {
+                const edgeThreshold = 50;
+                mouseNearEdge = (mouseX < edgeThreshold ||
+                    mouseX > window.innerWidth - edgeThreshold ||
+                    mouseY < edgeThreshold ||
+                    mouseY > window.innerHeight - edgeThreshold);
+            }
+            this.events.push({
+                width: window.innerWidth,
+                height: window.innerHeight,
+                mouseX,
+                mouseY,
+                mouseNearEdge,
+                timestamp: Date.now(),
+            });
+        };
+        window.addEventListener('resize', this.listener);
+    }
+    stop() {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        if (this.listener) {
+            window.removeEventListener('resize', this.listener);
+            this.listener = null;
+        }
+        if (this.mouseListener) {
+            document.removeEventListener('mousemove', this.mouseListener);
+            this.mouseListener = null;
+        }
+    }
+    reset() {
+        this.events = [];
+    }
+    score() {
+        if (this.events.length === 0)
+            return undefined;
+        let score = 0;
+        let factors = 0;
+        // Frequency
+        score += (0, math_utils_1.inverseSigmoid)(this.events.length, 5, 0.5);
+        factors++;
+        // Mouse near edge
+        const withMouse = this.events.filter(e => e.mouseX !== undefined);
+        if (withMouse.length > 0) {
+            const nearEdge = withMouse.filter(e => e.mouseNearEdge).length;
+            score += (0, math_utils_1.sigmoid)(nearEdge / withMouse.length, 0.5, 8);
+            factors++;
+        }
+        return factors > 0 ? score / factors : undefined;
+    }
+    getDebugInfo() {
+        return {
+            eventCount: this.events.length,
+            withMouseData: this.events.filter(e => e.mouseX !== undefined).length,
+        };
+    }
+}
+exports.ResizeStrategy = ResizeStrategy;

package/dist/cjs/strategies/scroll.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Scroll Behavior Detection Strategy
+ * Autonomous module managing scroll event listeners
+ * Tracks normalized scroll distance and velocity patterns
+ */
+import { BaseStrategy, type TimeSeriesPoint } from '../strategy';
+export declare class ScrollStrategy extends BaseStrategy {
+    readonly name = "scroll";
+    readonly defaultWeight = 0.15;
+    private distanceSeries;
+    private velocitySeries;
+    private lastScrollY;
+    private lastTimestamp;
+    private rollingWindowMs;
+    private documentHeight;
+    private listener;
+    private isActive;
+    constructor(options?: {
+        rollingWindow?: number;
+    });
+    start(): void;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    /**
+     * Scroll-specific pattern detection
+     * Detects bot-like patterns: constant deltas, instant jumps, too smooth
+     */
+    private detectScrollPatterns;
+    getDebugInfo(): {
+        eventCount: number;
+        rollingWindow: number;
+        isActive: boolean;
+        distanceSeries: TimeSeriesPoint[];
+        velocitySeries: TimeSeriesPoint[];
+    };
+}