@axeptio/behavior-detection 1.1.1 → 1.2.0

package/dist/behavior-detector.d.ts

@@ -15,6 +15,9 @@ export declare class BehaviorDetector {
     private confidenceScore;
     private readonly CONFIDENCE_TARGET;
     private readonly CONFIDENCE_DECAY;
+    private scoreMemory;
+    private scoreFloor;
+    private lastEventTime;
     constructor(tickOptions?: TickOptions);
     /**
      * Add a detection strategy

package/dist/cjs/index.cjs

@@ -46,6 +46,7 @@ module.exports = __toCommonJS(index_exports);
 // dist/esm/behavior-detector.js
 var BehaviorDetector = class {
   constructor(tickOptions) {
+    var _a, _b, _c, _d;
     this.strategies = /* @__PURE__ */ new Map();
     this.isTracking = false;
     this.isPausedByVisibility = false;
@@ -56,12 +57,21 @@ var BehaviorDetector = class {
     this.confidenceScore = 0;
     this.CONFIDENCE_TARGET = 1;
     this.CONFIDENCE_DECAY = 0.95;
+    this.scoreFloor = 1;
+    this.lastEventTime = 0;
     if (tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.interval) {
       this.tickIntervalMs = tickOptions.interval;
     }
     if ((tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.pauseOnHidden) !== void 0) {
       this.pauseOnHidden = tickOptions.pauseOnHidden;
     }
+    const mem = tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.scoreMemory;
+    this.scoreMemory = {
+      enabled: (_a = mem === null || mem === void 0 ? void 0 : mem.enabled) !== null && _a !== void 0 ? _a : true,
+      inactivityThreshold: (_b = mem === null || mem === void 0 ? void 0 : mem.inactivityThreshold) !== null && _b !== void 0 ? _b : 2e3,
+      maxRecovery: (_c = mem === null || mem === void 0 ? void 0 : mem.maxRecovery) !== null && _c !== void 0 ? _c : 0.1,
+      recoveryPerEvent: (_d = mem === null || mem === void 0 ? void 0 : mem.recoveryPerEvent) !== null && _d !== void 0 ? _d : 0.02
+    };
   }
   /**
    * Add a detection strategy
@@ -90,6 +100,10 @@ var BehaviorDetector = class {
     this.confidenceScore *= this.CONFIDENCE_DECAY;
     const contribution = event.weight * strategyWeight;
     this.confidenceScore = Math.min(this.CONFIDENCE_TARGET, this.confidenceScore + contribution);
+    this.lastEventTime = Date.now();
+    if (this.scoreMemory.enabled) {
+      this.scoreFloor = Math.min(1, this.scoreFloor + this.scoreMemory.recoveryPerEvent);
+    }
   }
   /**
    * Remove a detection strategy
@@ -170,6 +184,8 @@ var BehaviorDetector = class {
    */
   reset() {
     this.confidenceScore = 0;
+    this.scoreFloor = 1;
+    this.lastEventTime = 0;
     for (const [_, config] of this.strategies) {
       config.strategy.reset();
     }
@@ -179,8 +195,19 @@ var BehaviorDetector = class {
    */
   async score(options = {}) {
     const breakdown = this.calculateStrategyScore();
+    let effectiveScore = breakdown.overall;
+    if (this.scoreMemory.enabled && this.lastEventTime > 0) {
+      if (effectiveScore < this.scoreFloor) {
+        this.scoreFloor = effectiveScore;
+      }
+      const timeSinceEvent = Date.now() - this.lastEventTime;
+      if (timeSinceEvent > this.scoreMemory.inactivityThreshold) {
+        const cap = this.scoreFloor + this.scoreMemory.maxRecovery;
+        effectiveScore = Math.min(effectiveScore, cap);
+      }
+    }
     const result = {
-      score: breakdown.overall
+      score: effectiveScore
     };
     if (options.breakdown) {
       result.breakdown = breakdown;
@@ -398,7 +425,7 @@ var MouseStrategy = class extends BaseStrategy {
     this.lastPosition = null;
     this.lastAngle = 0;
     this.cumulativeAngle = 0;
-    this.rollingWindowMs = 5e3;
+    this.rollingWindowMs = 3e4;
     this.listener = null;
     this.leaveListener = null;
     this.enterListener = null;
@@ -681,7 +708,7 @@ var ScrollStrategy = class extends BaseStrategy {
     this.velocitySeries = [];
     this.lastScrollY = null;
     this.lastTimestamp = 0;
-    this.rollingWindowMs = 5e3;
+    this.rollingWindowMs = 3e4;
     this.documentHeight = 1;
     this.listener = null;
     this.isActive = false;

package/dist/esm/behavior-detector.d.ts

@@ -15,6 +15,9 @@ export declare class BehaviorDetector {
     private confidenceScore;
     private readonly CONFIDENCE_TARGET;
     private readonly CONFIDENCE_DECAY;
+    private scoreMemory;
+    private scoreFloor;
+    private lastEventTime;
     constructor(tickOptions?: TickOptions);
     /**
      * Add a detection strategy

package/dist/esm/behavior-detector.js

@@ -4,6 +4,7 @@
  */
 export class BehaviorDetector {
     constructor(tickOptions) {
+        var _a, _b, _c, _d;
         // Strategy mode
         this.strategies = new Map();
         this.isTracking = false;
@@ -16,12 +17,22 @@ export class BehaviorDetector {
         this.confidenceScore = 0;
         this.CONFIDENCE_TARGET = 1.0; // Target confidence for reliable classification
         this.CONFIDENCE_DECAY = 0.95; // Per event decay to prevent infinite growth
+        this.scoreFloor = 1.0;
+        this.lastEventTime = 0;
         if (tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.interval) {
             this.tickIntervalMs = tickOptions.interval;
         }
         if ((tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.pauseOnHidden) !== undefined) {
             this.pauseOnHidden = tickOptions.pauseOnHidden;
         }
+        // Score memory defaults
+        const mem = tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.scoreMemory;
+        this.scoreMemory = {
+            enabled: (_a = mem === null || mem === void 0 ? void 0 : mem.enabled) !== null && _a !== void 0 ? _a : true,
+            inactivityThreshold: (_b = mem === null || mem === void 0 ? void 0 : mem.inactivityThreshold) !== null && _b !== void 0 ? _b : 2000,
+            maxRecovery: (_c = mem === null || mem === void 0 ? void 0 : mem.maxRecovery) !== null && _c !== void 0 ? _c : 0.1,
+            recoveryPerEvent: (_d = mem === null || mem === void 0 ? void 0 : mem.recoveryPerEvent) !== null && _d !== void 0 ? _d : 0.02,
+        };
     }
     /**
      * Add a detection strategy
@@ -55,6 +66,11 @@ export class BehaviorDetector {
         // eventWeight (0-1) * strategyWeight (e.g. 0.3 for mouse) = contribution
         const contribution = event.weight * strategyWeight;
         this.confidenceScore = Math.min(this.CONFIDENCE_TARGET, this.confidenceScore + contribution);
+        // Score memory: track activity and slowly raise the floor
+        this.lastEventTime = Date.now();
+        if (this.scoreMemory.enabled) {
+            this.scoreFloor = Math.min(1.0, this.scoreFloor + this.scoreMemory.recoveryPerEvent);
+        }
     }
     /**
      * Remove a detection strategy
@@ -144,6 +160,8 @@ export class BehaviorDetector {
      */
     reset() {
         this.confidenceScore = 0;
+        this.scoreFloor = 1.0;
+        this.lastEventTime = 0;
         for (const [_, config] of this.strategies) {
             config.strategy.reset();
         }
@@ -153,8 +171,22 @@ export class BehaviorDetector {
      */
     async score(options = {}) {
         const breakdown = this.calculateStrategyScore();
+        let effectiveScore = breakdown.overall;
+        // Score memory: cap recovery during inactivity
+        if (this.scoreMemory.enabled && this.lastEventTime > 0) {
+            // Track the lowest score observed
+            if (effectiveScore < this.scoreFloor) {
+                this.scoreFloor = effectiveScore;
+            }
+            // If inactive, prevent the score from recovering freely
+            const timeSinceEvent = Date.now() - this.lastEventTime;
+            if (timeSinceEvent > this.scoreMemory.inactivityThreshold) {
+                const cap = this.scoreFloor + this.scoreMemory.maxRecovery;
+                effectiveScore = Math.min(effectiveScore, cap);
+            }
+        }
         const result = {
-            score: breakdown.overall,
+            score: effectiveScore,
         };
         if (options.breakdown) {
             result.breakdown = breakdown;

package/dist/esm/index.d.ts

@@ -32,7 +32,7 @@
  * ```
  */
 export { BehaviorDetector } from './behavior-detector.js';
-export type { DetectionStrategy, StrategyConfig } from './strategy.js';
+export type { DetectionStrategy, StrategyConfig, ScoreMemoryOptions } from './strategy.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/strategies/mouse.js

@@ -20,7 +20,7 @@ export class MouseStrategy extends BaseStrategy {
         this.lastPosition = null;
         this.lastAngle = 0;
         this.cumulativeAngle = 0;
-        this.rollingWindowMs = 5000;
+        this.rollingWindowMs = 30000;
         this.listener = null;
         this.leaveListener = null;
         this.enterListener = null;

package/dist/esm/strategies/scroll.js

@@ -14,7 +14,7 @@ export class ScrollStrategy extends BaseStrategy {
         this.velocitySeries = [];
         this.lastScrollY = null;
         this.lastTimestamp = 0;
-        this.rollingWindowMs = 5000;
+        this.rollingWindowMs = 30000;
         this.documentHeight = 1;
         this.listener = null;
         this.isActive = false;

package/dist/esm/strategy.d.ts

@@ -104,4 +104,37 @@ export interface TickOptions {
      * Default: true (recommended for better performance and battery life)
      */
     pauseOnHidden?: boolean;
+    /**
+     * Score memory options to prevent score recovery during inactivity.
+     * When enabled, the detector remembers the lowest score observed and prevents
+     * the score from jumping back up when behavioral data expires from rolling windows.
+     * Default: enabled with sensible defaults
+     */
+    scoreMemory?: ScoreMemoryOptions;
+}
+export interface ScoreMemoryOptions {
+    /**
+     * Enable score memory (default: true)
+     * When enabled, the detector tracks the lowest score observed and caps
+     * score recovery during periods of inactivity.
+     */
+    enabled: boolean;
+    /**
+     * Milliseconds of inactivity before the score cap kicks in (default: 2000)
+     * If no strategy events are received for this duration, the score cannot
+     * recover freely — it's capped near the lowest observed score.
+     */
+    inactivityThreshold?: number;
+    /**
+     * Maximum score increase allowed above the floor during inactivity (default: 0.1)
+     * During inactivity, effective score = min(rawScore, floor + maxRecovery)
+     */
+    maxRecovery?: number;
+    /**
+     * How much the floor rises per strategy event (default: 0.02)
+     * Each incoming event nudges the floor upward, allowing genuine human
+     * activity to eventually recover the score. At 0.02, it takes ~15 events
+     * to recover 0.3 points of score.
+     */
+    recoveryPerEvent?: number;
 }

package/dist/index.d.ts

@@ -32,7 +32,7 @@
  * ```
  */
 export { BehaviorDetector } from './behavior-detector.js';
-export type { DetectionStrategy, StrategyConfig } from './strategy.js';
+export type { DetectionStrategy, StrategyConfig, ScoreMemoryOptions } from './strategy.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/strategy.d.ts

@@ -104,4 +104,37 @@ export interface TickOptions {
      * Default: true (recommended for better performance and battery life)
      */
     pauseOnHidden?: boolean;
+    /**
+     * Score memory options to prevent score recovery during inactivity.
+     * When enabled, the detector remembers the lowest score observed and prevents
+     * the score from jumping back up when behavioral data expires from rolling windows.
+     * Default: enabled with sensible defaults
+     */
+    scoreMemory?: ScoreMemoryOptions;
+}
+export interface ScoreMemoryOptions {
+    /**
+     * Enable score memory (default: true)
+     * When enabled, the detector tracks the lowest score observed and caps
+     * score recovery during periods of inactivity.
+     */
+    enabled: boolean;
+    /**
+     * Milliseconds of inactivity before the score cap kicks in (default: 2000)
+     * If no strategy events are received for this duration, the score cannot
+     * recover freely — it's capped near the lowest observed score.
+     */
+    inactivityThreshold?: number;
+    /**
+     * Maximum score increase allowed above the floor during inactivity (default: 0.1)
+     * During inactivity, effective score = min(rawScore, floor + maxRecovery)
+     */
+    maxRecovery?: number;
+    /**
+     * How much the floor rises per strategy event (default: 0.02)
+     * Each incoming event nudges the floor upward, allowing genuine human
+     * activity to eventually recover the score. At 0.02, it takes ~15 events
+     * to recover 0.3 points of score.
+     */
+    recoveryPerEvent?: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axeptio/behavior-detection",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Lightweight behavior detection library to assess human likelihood of user sessions",
   "type": "module",
   "main": "./dist/cjs/index.cjs",