@niksbanna/bot-detector 1.0.0

package/dist/bot-detector.cjs.js

@@ -0,0 +1,2629 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.js
+var index_exports = {};
+__export(index_exports, {
+  AudioContextSignal: () => AudioContextSignal,
+  BotDetector: () => BotDetector,
+  CanvasSignal: () => CanvasSignal,
+  DOMContentTimingSignal: () => DOMContentTimingSignal,
+  HeadlessSignal: () => HeadlessSignal,
+  InteractionTimingSignal: () => InteractionTimingSignal,
+  KeyboardPatternSignal: () => KeyboardPatternSignal,
+  MouseMovementSignal: () => MouseMovementSignal,
+  NavigatorAnomalySignal: () => NavigatorAnomalySignal,
+  PageLoadSignal: () => PageLoadSignal,
+  PermissionsSignal: () => PermissionsSignal,
+  PhantomJSSignal: () => PhantomJSSignal,
+  PlaywrightSignal: () => PlaywrightSignal,
+  PluginsSignal: () => PluginsSignal,
+  PuppeteerSignal: () => PuppeteerSignal,
+  ScoringEngine: () => ScoringEngine,
+  ScreenSignal: () => ScreenSignal,
+  ScrollBehaviorSignal: () => ScrollBehaviorSignal,
+  SeleniumSignal: () => SeleniumSignal,
+  Signal: () => Signal,
+  Signals: () => Signals,
+  Verdict: () => Verdict,
+  VerdictEngine: () => VerdictEngine,
+  WebDriverSignal: () => WebDriverSignal,
+  WebGLSignal: () => WebGLSignal,
+  createDetector: () => createDetector,
+  default: () => index_default,
+  defaultInstantSignals: () => defaultInstantSignals,
+  defaultInteractionSignals: () => defaultInteractionSignals,
+  defaultSignals: () => defaultSignals,
+  detect: () => detect,
+  detectInstant: () => detectInstant
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/Signal.js
+var Signal = class {
+  /**
+   * Creates a new Signal instance.
+   * @param {Object} [options={}] - Configuration options for this signal.
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this._lastResult = null;
+  }
+  /**
+   * Get the signal's unique identifier.
+   * @returns {string}
+   */
+  get id() {
+    return this.constructor.id;
+  }
+  /**
+   * Get the signal's category.
+   * @returns {string}
+   */
+  get category() {
+    return this.constructor.category;
+  }
+  /**
+   * Get the signal's weight.
+   * @returns {number}
+   */
+  get weight() {
+    var _a;
+    return (_a = this.options.weight) != null ? _a : this.constructor.weight;
+  }
+  /**
+   * Get the signal's description.
+   * @returns {string}
+   */
+  get description() {
+    return this.constructor.description;
+  }
+  /**
+   * Check if this signal requires interaction.
+   * @returns {boolean}
+   */
+  get requiresInteraction() {
+    return this.constructor.requiresInteraction;
+  }
+  /**
+   * Get the last detection result.
+   * @returns {SignalResult|null}
+   */
+  get lastResult() {
+    return this._lastResult;
+  }
+  /**
+   * Perform the detection check.
+   * Must be overridden by subclasses.
+   * 
+   * @abstract
+   * @returns {Promise<SignalResult>} Detection result
+   * @throws {Error} If not implemented by subclass
+   */
+  async detect() {
+    throw new Error(`Signal.detect() must be implemented by ${this.constructor.name}`);
+  }
+  /**
+   * Run detection and cache the result.
+   * @returns {Promise<SignalResult>}
+   */
+  async run() {
+    try {
+      this._lastResult = await this.detect();
+      return this._lastResult;
+    } catch (error) {
+      this._lastResult = {
+        triggered: false,
+        value: null,
+        confidence: 0,
+        error: error.message
+      };
+      return this._lastResult;
+    }
+  }
+  /**
+   * Reset the signal state.
+   */
+  reset() {
+    this._lastResult = null;
+  }
+  /**
+   * Create a result object with defaults.
+   * @param {boolean} triggered - Whether the signal was triggered
+   * @param {*} [value=null] - Optional value associated with the detection
+   * @param {number} [confidence=1] - Confidence level (0-1)
+   * @returns {SignalResult}
+   */
+  createResult(triggered, value = null, confidence = 1) {
+    return {
+      triggered: Boolean(triggered),
+      value,
+      confidence: Math.max(0, Math.min(1, confidence))
+    };
+  }
+};
+/**
+ * Unique identifier for this signal.
+ * @type {string}
+ */
+__publicField(Signal, "id", "base-signal");
+/**
+ * Category this signal belongs to.
+ * Categories: 'environment', 'behavior', 'fingerprint', 'timing', 'automation'
+ * @type {string}
+ */
+__publicField(Signal, "category", "uncategorized");
+/**
+ * Weight of this signal in the scoring calculation.
+ * Range: 0.1 (low importance) to 1.0 (high importance)
+ * @type {number}
+ */
+__publicField(Signal, "weight", 0.5);
+/**
+ * Human-readable description of what this signal detects.
+ * @type {string}
+ */
+__publicField(Signal, "description", "Base signal class");
+/**
+ * Whether this signal requires user interaction before it can detect.
+ * @type {boolean}
+ */
+__publicField(Signal, "requiresInteraction", false);
+
+// src/core/ScoringEngine.js
+var ScoringEngine = class {
+  /**
+   * Creates a new ScoringEngine instance.
+   * @param {Object} [options={}] - Configuration options
+   * @param {Object.<string, number>} [options.weightOverrides={}] - Override weights by signal ID
+   * @param {number} [options.maxScore=100] - Maximum possible score
+   */
+  constructor(options = {}) {
+    this.weightOverrides = options.weightOverrides || {};
+    this.maxScore = options.maxScore || 100;
+    this._results = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get the effective weight for a signal.
+   * @param {string} signalId - Signal identifier
+   * @param {number} defaultWeight - Default weight from signal definition
+   * @returns {number}
+   */
+  getWeight(signalId, defaultWeight) {
+    var _a;
+    return (_a = this.weightOverrides[signalId]) != null ? _a : defaultWeight;
+  }
+  /**
+   * Add a signal result to the scoring calculation.
+   * @param {string} signalId - Signal identifier
+   * @param {Object} result - Signal detection result
+   * @param {boolean} result.triggered - Whether signal was triggered
+   * @param {number} result.confidence - Confidence level (0-1)
+   * @param {number} weight - Signal weight (0.1-1.0)
+   */
+  addResult(signalId, result, weight) {
+    const effectiveWeight = this.getWeight(signalId, weight);
+    this._results.set(signalId, {
+      ...result,
+      weight: effectiveWeight,
+      contribution: result.triggered ? effectiveWeight * result.confidence : 0
+    });
+  }
+  /**
+   * Calculate the final score from all added results.
+   * Formula: (sum of contributions / sum of weights) * maxScore
+   * 
+   * @returns {number} Score between 0 and maxScore
+   */
+  calculate() {
+    if (this._results.size === 0) {
+      return 0;
+    }
+    let totalWeight = 0;
+    let totalContribution = 0;
+    for (const [, data] of this._results) {
+      totalWeight += data.weight;
+      totalContribution += data.contribution;
+    }
+    if (totalWeight === 0) {
+      return 0;
+    }
+    const score = totalContribution / totalWeight * this.maxScore;
+    return Math.round(score * 100) / 100;
+  }
+  /**
+   * Get detailed breakdown of score contributions.
+   * @returns {Array<Object>} Array of signal contributions
+   */
+  getBreakdown() {
+    const breakdown = [];
+    for (const [signalId, data] of this._results) {
+      breakdown.push({
+        signalId,
+        triggered: data.triggered,
+        confidence: data.confidence,
+        weight: data.weight,
+        contribution: data.contribution,
+        percentOfScore: this.calculate() > 0 ? (data.contribution / this.calculate() * 100).toFixed(1) : "0.0"
+      });
+    }
+    return breakdown.sort((a, b) => b.contribution - a.contribution);
+  }
+  /**
+   * Get all triggered signals.
+   * @returns {Array<string>} Array of triggered signal IDs
+   */
+  getTriggeredSignals() {
+    const triggered = [];
+    for (const [signalId, data] of this._results) {
+      if (data.triggered) {
+        triggered.push(signalId);
+      }
+    }
+    return triggered;
+  }
+  /**
+   * Get the number of triggered signals.
+   * @returns {number}
+   */
+  getTriggeredCount() {
+    let count = 0;
+    for (const [, data] of this._results) {
+      if (data.triggered) count++;
+    }
+    return count;
+  }
+  /**
+   * Reset all stored results.
+   */
+  reset() {
+    this._results.clear();
+  }
+};
+
+// src/core/VerdictEngine.js
+var Verdict = {
+  HUMAN: "human",
+  SUSPICIOUS: "suspicious",
+  BOT: "bot"
+};
+var _VerdictEngine = class _VerdictEngine {
+  /**
+   * Creates a new VerdictEngine instance.
+   * @param {Object} [options={}] - Configuration options
+   * @param {number} [options.humanThreshold=20] - Max score for human verdict
+   * @param {number} [options.suspiciousThreshold=50] - Max score for suspicious verdict
+   * @param {Array<string>} [options.instantBotSignals=[]] - Signal IDs that instantly flag as bot
+   */
+  constructor(options = {}) {
+    var _a, _b;
+    this.humanThreshold = (_a = options.humanThreshold) != null ? _a : _VerdictEngine.DEFAULT_THRESHOLDS.human;
+    this.suspiciousThreshold = (_b = options.suspiciousThreshold) != null ? _b : _VerdictEngine.DEFAULT_THRESHOLDS.suspicious;
+    this.instantBotSignals = new Set(options.instantBotSignals || []);
+  }
+  /**
+   * Get the verdict based on score and triggered signals.
+   * @param {number} score - Calculated score (0-100)
+   * @param {Array<string>} triggeredSignals - List of triggered signal IDs
+   * @returns {VerdictResult}
+   */
+  getVerdict(score, triggeredSignals = []) {
+    for (const signalId of triggeredSignals) {
+      if (this.instantBotSignals.has(signalId)) {
+        return {
+          verdict: Verdict.BOT,
+          score,
+          confidence: "high",
+          reason: `Instant bot signal triggered: ${signalId}`,
+          triggeredCount: triggeredSignals.length
+        };
+      }
+    }
+    let verdict;
+    let confidence;
+    let reason;
+    if (score < this.humanThreshold) {
+      verdict = Verdict.HUMAN;
+      confidence = score < 10 ? "high" : "medium";
+      reason = "Low bot score";
+    } else if (score < this.suspiciousThreshold) {
+      verdict = Verdict.SUSPICIOUS;
+      confidence = "medium";
+      reason = "Moderate bot indicators detected";
+    } else {
+      verdict = Verdict.BOT;
+      confidence = score >= 75 ? "high" : "medium";
+      reason = "High accumulation of bot indicators";
+    }
+    return {
+      verdict,
+      score,
+      confidence,
+      reason,
+      triggeredCount: triggeredSignals.length
+    };
+  }
+  /**
+   * Check if signal should instantly flag as bot.
+   * @param {string} signalId - Signal identifier
+   * @returns {boolean}
+   */
+  isInstantBotSignal(signalId) {
+    return this.instantBotSignals.has(signalId);
+  }
+  /**
+   * Add a signal to the instant bot list.
+   * @param {string} signalId - Signal identifier
+   */
+  addInstantBotSignal(signalId) {
+    this.instantBotSignals.add(signalId);
+  }
+  /**
+   * Update thresholds.
+   * @param {Object} thresholds - New threshold values
+   * @param {number} [thresholds.human] - New human threshold
+   * @param {number} [thresholds.suspicious] - New suspicious threshold
+   */
+  setThresholds(thresholds) {
+    if (thresholds.human !== void 0) {
+      this.humanThreshold = thresholds.human;
+    }
+    if (thresholds.suspicious !== void 0) {
+      this.suspiciousThreshold = thresholds.suspicious;
+    }
+  }
+};
+/**
+ * Default threshold configuration.
+ * @type {Object}
+ */
+__publicField(_VerdictEngine, "DEFAULT_THRESHOLDS", {
+  human: 20,
+  // score < 20 = human
+  suspicious: 50
+  // 20 <= score < 50 = suspicious
+  // score >= 50 = bot
+});
+var VerdictEngine = _VerdictEngine;
+
+// src/core/BotDetector.js
+var BotDetector = class _BotDetector {
+  /**
+   * Creates a new BotDetector instance.
+   * @param {Object} [options={}] - Configuration options
+   * @param {Array<Signal>} [options.signals=[]] - Initial signals to register
+   * @param {Object.<string, number>} [options.weightOverrides={}] - Override signal weights
+   * @param {number} [options.humanThreshold=20] - Score threshold for human verdict
+   * @param {number} [options.suspiciousThreshold=50] - Score threshold for suspicious verdict
+   * @param {Array<string>} [options.instantBotSignals=[]] - Signal IDs that instantly flag as bot
+   * @param {boolean} [options.includeDefaults=true] - Include built-in signal detectors
+   * @param {number} [options.detectionTimeout=5000] - Timeout for detection in ms
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this._signals = /* @__PURE__ */ new Map();
+    this._scoringEngine = new ScoringEngine({
+      weightOverrides: options.weightOverrides
+    });
+    this._verdictEngine = new VerdictEngine({
+      humanThreshold: options.humanThreshold,
+      suspiciousThreshold: options.suspiciousThreshold,
+      instantBotSignals: options.instantBotSignals
+    });
+    this._lastDetection = null;
+    this._detectionTimeout = options.detectionTimeout || 5e3;
+    this._isRunning = false;
+    if (options.signals) {
+      for (const signal of options.signals) {
+        this.registerSignal(signal);
+      }
+    }
+  }
+  /**
+   * Register a signal detector.
+   * @param {Signal} signal - Signal instance to register
+   * @returns {BotDetector} this instance for chaining
+   * @throws {Error} If signal with same ID already registered
+   */
+  registerSignal(signal) {
+    if (!(signal instanceof Signal)) {
+      throw new Error("Signal must be an instance of Signal class");
+    }
+    const id = signal.id;
+    if (this._signals.has(id)) {
+      throw new Error(`Signal with ID "${id}" is already registered`);
+    }
+    this._signals.set(id, signal);
+    return this;
+  }
+  /**
+   * Register multiple signals at once.
+   * @param {Array<Signal>} signals - Array of signal instances
+   * @returns {BotDetector} this instance for chaining
+   */
+  registerSignals(signals) {
+    for (const signal of signals) {
+      this.registerSignal(signal);
+    }
+    return this;
+  }
+  /**
+   * Unregister a signal by ID.
+   * @param {string} signalId - Signal ID to remove
+   * @returns {boolean} True if signal was removed
+   */
+  unregisterSignal(signalId) {
+    return this._signals.delete(signalId);
+  }
+  /**
+   * Get a registered signal by ID.
+   * @param {string} signalId - Signal ID
+   * @returns {Signal|undefined}
+   */
+  getSignal(signalId) {
+    return this._signals.get(signalId);
+  }
+  /**
+   * Get all registered signals.
+   * @returns {Array<Signal>}
+   */
+  getSignals() {
+    return Array.from(this._signals.values());
+  }
+  /**
+   * Get signals by category.
+   * @param {string} category - Category name
+   * @returns {Array<Signal>}
+   */
+  getSignalsByCategory(category) {
+    return this.getSignals().filter((s) => s.category === category);
+  }
+  /**
+   * Run all signal detectors and calculate verdict.
+   * @param {Object} [options={}] - Detection options
+   * @param {boolean} [options.skipInteractionSignals=false] - Skip signals requiring interaction
+   * @returns {Promise<DetectionResult>}
+   */
+  async detect(options = {}) {
+    if (this._isRunning) {
+      throw new Error("Detection is already running");
+    }
+    this._isRunning = true;
+    this._scoringEngine.reset();
+    const startTime = performance.now();
+    const signalResults = /* @__PURE__ */ new Map();
+    try {
+      const signalsToRun = this.getSignals().filter((signal) => {
+        if (options.skipInteractionSignals && signal.requiresInteraction) {
+          return false;
+        }
+        return true;
+      });
+      const detectionPromises = signalsToRun.map(async (signal) => {
+        const result = await Promise.race([
+          signal.run(),
+          new Promise(
+            (resolve) => setTimeout(() => resolve({
+              triggered: false,
+              value: null,
+              confidence: 0,
+              error: "timeout"
+            }), this._detectionTimeout)
+          )
+        ]);
+        return { signal, result };
+      });
+      const results = await Promise.all(detectionPromises);
+      for (const { signal, result } of results) {
+        signalResults.set(signal.id, {
+          ...result,
+          category: signal.category,
+          weight: signal.weight,
+          description: signal.description
+        });
+        this._scoringEngine.addResult(signal.id, result, signal.weight);
+      }
+      const score = this._scoringEngine.calculate();
+      const triggeredSignals = this._scoringEngine.getTriggeredSignals();
+      const verdict = this._verdictEngine.getVerdict(score, triggeredSignals);
+      const detectionTime = performance.now() - startTime;
+      this._lastDetection = {
+        ...verdict,
+        signals: Object.fromEntries(signalResults),
+        breakdown: this._scoringEngine.getBreakdown(),
+        timestamp: Date.now(),
+        detectionTimeMs: Math.round(detectionTime),
+        totalSignals: signalsToRun.length,
+        triggeredSignals
+      };
+      return this._lastDetection;
+    } finally {
+      this._isRunning = false;
+    }
+  }
+  /**
+   * Get the last detection result.
+   * @returns {DetectionResult|null}
+   */
+  getLastDetection() {
+    return this._lastDetection;
+  }
+  /**
+   * Get the current score (from last detection).
+   * @returns {number}
+   */
+  getScore() {
+    var _a, _b;
+    return (_b = (_a = this._lastDetection) == null ? void 0 : _a.score) != null ? _b : 0;
+  }
+  /**
+   * Get triggered signals from last detection.
+   * @returns {Array<string>}
+   */
+  getTriggeredSignals() {
+    var _a, _b;
+    return (_b = (_a = this._lastDetection) == null ? void 0 : _a.triggeredSignals) != null ? _b : [];
+  }
+  /**
+   * Check if detection is currently running.
+   * @returns {boolean}
+   */
+  isRunning() {
+    return this._isRunning;
+  }
+  /**
+   * Reset the detector state.
+   */
+  reset() {
+    this._scoringEngine.reset();
+    this._lastDetection = null;
+    for (const signal of this._signals.values()) {
+      signal.reset();
+    }
+  }
+  /**
+   * Update configuration options.
+   * @param {Object} options - New options
+   */
+  configure(options) {
+    if (options.humanThreshold !== void 0 || options.suspiciousThreshold !== void 0) {
+      this._verdictEngine.setThresholds({
+        human: options.humanThreshold,
+        suspicious: options.suspiciousThreshold
+      });
+    }
+    if (options.detectionTimeout !== void 0) {
+      this._detectionTimeout = options.detectionTimeout;
+    }
+  }
+  /**
+   * Create a detector with default signals.
+   * @param {Object} [options={}] - Configuration options
+   * @returns {BotDetector}
+   */
+  static withDefaults(options = {}) {
+    return new _BotDetector(options);
+  }
+};
+
+// src/signals/environment/WebDriverSignal.js
+var WebDriverSignal = class extends Signal {
+  async detect() {
+    if (navigator.webdriver === true) {
+      return this.createResult(true, { webdriver: true }, 1);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(navigator, "webdriver");
+    if (descriptor) {
+      if (descriptor.get || !descriptor.configurable) {
+        return this.createResult(true, {
+          webdriver: "modified",
+          descriptor: {
+            configurable: descriptor.configurable,
+            enumerable: descriptor.enumerable,
+            hasGetter: !!descriptor.get
+          }
+        }, 0.8);
+      }
+    }
+    try {
+      const proto = Object.getPrototypeOf(navigator);
+      const protoDescriptor = Object.getOwnPropertyDescriptor(proto, "webdriver");
+      if (protoDescriptor && protoDescriptor.get) {
+        const value = protoDescriptor.get.call(navigator);
+        if (value === true) {
+          return this.createResult(true, { webdriver: true, source: "prototype" }, 1);
+        }
+      }
+    } catch (e) {
+    }
+    return this.createResult(false);
+  }
+};
+__publicField(WebDriverSignal, "id", "webdriver");
+__publicField(WebDriverSignal, "category", "environment");
+__publicField(WebDriverSignal, "weight", 1);
+__publicField(WebDriverSignal, "description", "Detects navigator.webdriver automation flag");
+
+// src/signals/environment/HeadlessSignal.js
+var HeadlessSignal = class extends Signal {
+  async detect() {
+    const indicators = [];
+    let confidence = 0;
+    const ua = navigator.userAgent || "";
+    if (ua.includes("HeadlessChrome")) {
+      indicators.push("headless-ua");
+      confidence = Math.max(confidence, 1);
+    }
+    if (ua.includes("Chrome") && !ua.includes("Chromium")) {
+      if (typeof window.chrome === "undefined") {
+        indicators.push("missing-chrome-object");
+        confidence = Math.max(confidence, 0.6);
+      } else if (!window.chrome.runtime) {
+        indicators.push("missing-chrome-runtime");
+        confidence = Math.max(confidence, 0.4);
+      }
+    }
+    if (navigator.plugins && navigator.plugins.length === 0) {
+      indicators.push("no-plugins");
+      confidence = Math.max(confidence, 0.5);
+    }
+    if (!navigator.languages || navigator.languages.length === 0) {
+      indicators.push("no-languages");
+      confidence = Math.max(confidence, 0.6);
+    }
+    if (window.outerWidth === 0 && window.outerHeight === 0) {
+      indicators.push("zero-outer-dimensions");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (typeof navigator.connection === "undefined" && ua.includes("Chrome")) {
+      indicators.push("missing-connection-api");
+      confidence = Math.max(confidence, 0.3);
+    }
+    try {
+      if (typeof Notification !== "undefined" && Notification.permission === "denied" && window.outerWidth === 0) {
+        indicators.push("notification-headless-pattern");
+        confidence = Math.max(confidence, 0.5);
+      }
+    } catch (e) {
+    }
+    if (window.callPhantom || window._phantom) {
+      indicators.push("phantomjs");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.__nightmare) {
+      indicators.push("nightmare");
+      confidence = Math.max(confidence, 1);
+    }
+    const triggered = indicators.length > 0;
+    if (indicators.length >= 3) {
+      confidence = Math.min(1, confidence + 0.2);
+    }
+    return this.createResult(triggered, { indicators }, confidence);
+  }
+};
+__publicField(HeadlessSignal, "id", "headless");
+__publicField(HeadlessSignal, "category", "environment");
+__publicField(HeadlessSignal, "weight", 0.8);
+__publicField(HeadlessSignal, "description", "Detects headless browser indicators");
+
+// src/signals/environment/NavigatorAnomalySignal.js
+var NavigatorAnomalySignal = class extends Signal {
+  async detect() {
+    const anomalies = [];
+    let totalScore = 0;
+    let checksPerformed = 0;
+    const ua = navigator.userAgent || "";
+    const platform = navigator.platform || "";
+    checksPerformed++;
+    if (platform.includes("Win") && !ua.includes("Windows")) {
+      anomalies.push("platform-ua-mismatch-windows");
+      totalScore += 1;
+    } else if (platform.includes("Mac") && !ua.includes("Mac")) {
+      anomalies.push("platform-ua-mismatch-mac");
+      totalScore += 1;
+    } else if (platform.includes("Linux") && !ua.includes("Linux") && !ua.includes("Android")) {
+      anomalies.push("platform-ua-mismatch-linux");
+      totalScore += 1;
+    }
+    checksPerformed++;
+    if (!platform || platform === "" || platform === "undefined") {
+      anomalies.push("empty-platform");
+      totalScore += 1;
+    }
+    checksPerformed++;
+    if (navigator.language && navigator.languages) {
+      if (!navigator.languages.includes(navigator.language)) {
+        anomalies.push("language-mismatch");
+        totalScore += 0.5;
+      }
+    }
+    checksPerformed++;
+    if (ua.includes("Chrome") && navigator.vendor !== "Google Inc.") {
+      anomalies.push("vendor-mismatch-chrome");
+      totalScore += 0.5;
+    } else if (ua.includes("Firefox") && navigator.vendor !== "") {
+      anomalies.push("vendor-mismatch-firefox");
+      totalScore += 0.5;
+    } else if (ua.includes("Safari") && !ua.includes("Chrome") && navigator.vendor !== "Apple Computer, Inc.") {
+      anomalies.push("vendor-mismatch-safari");
+      totalScore += 0.5;
+    }
+    checksPerformed++;
+    if (typeof navigator.hardwareConcurrency !== "undefined") {
+      if (navigator.hardwareConcurrency === 0 || navigator.hardwareConcurrency > 128) {
+        anomalies.push("suspicious-hardware-concurrency");
+        totalScore += 0.5;
+      }
+    }
+    checksPerformed++;
+    if (typeof navigator.deviceMemory !== "undefined") {
+      if (navigator.deviceMemory === 0 || navigator.deviceMemory > 512) {
+        anomalies.push("suspicious-device-memory");
+        totalScore += 0.5;
+      }
+    }
+    checksPerformed++;
+    const isMobileUA = /Android|iPhone|iPad|iPod|Mobile/i.test(ua);
+    const hasTouchPoints = navigator.maxTouchPoints > 0;
+    if (!isMobileUA && navigator.maxTouchPoints > 5) {
+      anomalies.push("desktop-high-touch-points");
+      totalScore += 0.3;
+    }
+    checksPerformed++;
+    try {
+      const desc = Object.getOwnPropertyDescriptor(Navigator.prototype, "userAgent");
+      if (desc && desc.get && desc.get.toString().includes("native code") === false) {
+        anomalies.push("spoofed-user-agent");
+        totalScore += 1;
+      }
+    } catch (e) {
+    }
+    const triggered = anomalies.length > 0;
+    const confidence = Math.min(1, totalScore / Math.max(1, checksPerformed));
+    return this.createResult(triggered, { anomalies }, confidence);
+  }
+};
+__publicField(NavigatorAnomalySignal, "id", "navigator-anomaly");
+__publicField(NavigatorAnomalySignal, "category", "environment");
+__publicField(NavigatorAnomalySignal, "weight", 0.7);
+__publicField(NavigatorAnomalySignal, "description", "Detects navigator property inconsistencies");
+
+// src/signals/environment/PermissionsSignal.js
+var PermissionsSignal = class extends Signal {
+  async detect() {
+    const anomalies = [];
+    if (!navigator.permissions) {
+      return this.createResult(false, { supported: false }, 0);
+    }
+    try {
+      const notificationStatus = await navigator.permissions.query({ name: "notifications" });
+      if (typeof Notification !== "undefined") {
+        const directPermission = Notification.permission;
+        if (directPermission === "granted" && notificationStatus.state !== "granted" || directPermission === "denied" && notificationStatus.state !== "denied" || directPermission === "default" && notificationStatus.state !== "prompt") {
+          anomalies.push("notification-permission-mismatch");
+        }
+      }
+      try {
+        const geoStatus = await navigator.permissions.query({ name: "geolocation" });
+        if (geoStatus.state === "denied" && window.outerWidth === 0) {
+          anomalies.push("geo-denied-headless");
+        }
+      } catch (e) {
+      }
+      try {
+        await navigator.permissions.query({ name: "camera" });
+      } catch (e) {
+        if (e.name === "TypeError") {
+          anomalies.push("camera-permission-error");
+        }
+      }
+    } catch (e) {
+      if (e.name !== "TypeError") {
+        anomalies.push("permissions-query-error");
+      }
+    }
+    const triggered = anomalies.length > 0;
+    const confidence = Math.min(1, anomalies.length * 0.4);
+    return this.createResult(triggered, { anomalies }, confidence);
+  }
+};
+__publicField(PermissionsSignal, "id", "permissions");
+__publicField(PermissionsSignal, "category", "environment");
+__publicField(PermissionsSignal, "weight", 0.5);
+__publicField(PermissionsSignal, "description", "Detects Permissions API anomalies");
+
+// src/signals/behavior/MouseMovementSignal.js
+var MouseMovementSignal = class extends Signal {
+  constructor(options = {}) {
+    super(options);
+    this._movements = [];
+    this._isTracking = false;
+    this._trackingDuration = options.trackingDuration || 3e3;
+    this._minMovements = options.minMovements || 5;
+    this._boundHandler = null;
+  }
+  /**
+   * Start tracking mouse movements.
+   * @returns {Promise<void>}
+   */
+  startTracking() {
+    if (this._isTracking) return;
+    this._movements = [];
+    this._isTracking = true;
+    this._boundHandler = (e) => {
+      this._movements.push({
+        x: e.clientX,
+        y: e.clientY,
+        t: performance.now()
+      });
+    };
+    document.addEventListener("mousemove", this._boundHandler, { passive: true });
+  }
+  /**
+   * Stop tracking mouse movements.
+   */
+  stopTracking() {
+    if (!this._isTracking) return;
+    this._isTracking = false;
+    if (this._boundHandler) {
+      document.removeEventListener("mousemove", this._boundHandler);
+      this._boundHandler = null;
+    }
+  }
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    if (this._movements.length === 0) {
+      this.startTracking();
+      await new Promise((resolve) => setTimeout(resolve, this._trackingDuration));
+      this.stopTracking();
+    }
+    const movements = this._movements;
+    if (movements.length < this._minMovements) {
+      anomalies.push("no-mouse-movement");
+      confidence = Math.max(confidence, 0.6);
+      return this.createResult(true, { anomalies, movements: movements.length }, confidence);
+    }
+    const analysis = this._analyzeMovements(movements);
+    if (analysis.teleportCount > 0) {
+      anomalies.push("mouse-teleportation");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (analysis.linearPathRatio > 0.9) {
+      anomalies.push("linear-path");
+      confidence = Math.max(confidence, 0.8);
+    }
+    if (analysis.velocityVariance < 0.01 && movements.length > 10) {
+      anomalies.push("constant-velocity");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (analysis.accelerationChanges === 0 && movements.length > 10) {
+      anomalies.push("no-acceleration-variance");
+      confidence = Math.max(confidence, 0.6);
+    }
+    if (analysis.timingVariance < 1 && movements.length > 10) {
+      anomalies.push("robotic-timing");
+      confidence = Math.max(confidence, 0.8);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      movementCount: movements.length,
+      analysis
+    }, confidence);
+  }
+  /**
+   * Analyze movement patterns for anomalies.
+   * @param {Array} movements - Array of movement points
+   * @returns {Object} Analysis results
+   */
+  _analyzeMovements(movements) {
+    if (movements.length < 3) {
+      return {
+        teleportCount: 0,
+        linearPathRatio: 0,
+        velocityVariance: 0,
+        accelerationChanges: 0,
+        timingVariance: 0
+      };
+    }
+    let teleportCount = 0;
+    const velocities = [];
+    const angles = [];
+    const timeIntervals = [];
+    for (let i = 1; i < movements.length; i++) {
+      const prev = movements[i - 1];
+      const curr = movements[i];
+      const dx = curr.x - prev.x;
+      const dy = curr.y - prev.y;
+      const dt = curr.t - prev.t;
+      if (dt === 0) continue;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      const velocity = distance / dt;
+      velocities.push(velocity);
+      angles.push(Math.atan2(dy, dx));
+      timeIntervals.push(dt);
+      if (distance > 300 && dt < 10) {
+        teleportCount++;
+      }
+    }
+    const avgVelocity = velocities.reduce((a, b) => a + b, 0) / velocities.length;
+    const velocityVariance = velocities.reduce((acc, v) => acc + Math.pow(v - avgVelocity, 2), 0) / velocities.length;
+    let angleConsistency = 0;
+    if (angles.length > 1) {
+      let consistentAngles = 0;
+      for (let i = 1; i < angles.length; i++) {
+        const angleDiff = Math.abs(angles[i] - angles[i - 1]);
+        if (angleDiff < 0.1) consistentAngles++;
+      }
+      angleConsistency = consistentAngles / (angles.length - 1);
+    }
+    const avgInterval = timeIntervals.reduce((a, b) => a + b, 0) / timeIntervals.length;
+    const timingVariance = timeIntervals.reduce((acc, t) => acc + Math.pow(t - avgInterval, 2), 0) / timeIntervals.length;
+    let accelerationChanges = 0;
+    for (let i = 1; i < velocities.length; i++) {
+      if ((velocities[i] - velocities[i - 1]) * (velocities[i - 1] - (velocities[i - 2] || 0)) < 0) {
+        accelerationChanges++;
+      }
+    }
+    return {
+      teleportCount,
+      linearPathRatio: angleConsistency,
+      velocityVariance,
+      accelerationChanges,
+      timingVariance
+    };
+  }
+  reset() {
+    super.reset();
+    this.stopTracking();
+    this._movements = [];
+  }
+};
+__publicField(MouseMovementSignal, "id", "mouse-movement");
+__publicField(MouseMovementSignal, "category", "behavior");
+__publicField(MouseMovementSignal, "weight", 0.9);
+__publicField(MouseMovementSignal, "description", "Detects non-human mouse movement patterns");
+__publicField(MouseMovementSignal, "requiresInteraction", true);
+
+// src/signals/behavior/KeyboardPatternSignal.js
+var KeyboardPatternSignal = class extends Signal {
+  constructor(options = {}) {
+    super(options);
+    this._keystrokes = [];
+    this._isTracking = false;
+    this._trackingDuration = options.trackingDuration || 5e3;
+    this._minKeystrokes = options.minKeystrokes || 10;
+    this._boundKeydownHandler = null;
+    this._boundKeyupHandler = null;
+  }
+  /**
+   * Start tracking keyboard events.
+   */
+  startTracking() {
+    if (this._isTracking) return;
+    this._keystrokes = [];
+    this._isTracking = true;
+    this._boundKeydownHandler = (e) => {
+      this._keystrokes.push({
+        type: "down",
+        key: e.key,
+        code: e.code,
+        t: performance.now()
+      });
+    };
+    this._boundKeyupHandler = (e) => {
+      this._keystrokes.push({
+        type: "up",
+        key: e.key,
+        code: e.code,
+        t: performance.now()
+      });
+    };
+    document.addEventListener("keydown", this._boundKeydownHandler, { passive: true });
+    document.addEventListener("keyup", this._boundKeyupHandler, { passive: true });
+  }
+  /**
+   * Stop tracking keyboard events.
+   */
+  stopTracking() {
+    if (!this._isTracking) return;
+    this._isTracking = false;
+    if (this._boundKeydownHandler) {
+      document.removeEventListener("keydown", this._boundKeydownHandler);
+      this._boundKeydownHandler = null;
+    }
+    if (this._boundKeyupHandler) {
+      document.removeEventListener("keyup", this._boundKeyupHandler);
+      this._boundKeyupHandler = null;
+    }
+  }
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    if (this._keystrokes.length === 0) {
+      this.startTracking();
+      await new Promise((resolve) => setTimeout(resolve, this._trackingDuration));
+      this.stopTracking();
+    }
+    const keystrokes = this._keystrokes;
+    const keydowns = keystrokes.filter((k) => k.type === "down");
+    if (keydowns.length < this._minKeystrokes) {
+      return this.createResult(false, {
+        reason: "insufficient-data",
+        keystrokes: keydowns.length
+      }, 0);
+    }
+    const analysis = this._analyzeKeystrokes(keystrokes);
+    if (analysis.avgInterKeystrokeTime < 50 && keydowns.length > 20) {
+      anomalies.push("inhuman-speed");
+      confidence = Math.max(confidence, 0.9);
+    }
+    if (analysis.timingVariance < 5 && keydowns.length > 15) {
+      anomalies.push("robotic-timing");
+      confidence = Math.max(confidence, 0.8);
+    }
+    if (analysis.missingKeyups > keydowns.length * 0.5) {
+      anomalies.push("missing-keyups");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (analysis.holdTimeVariance < 2 && analysis.holdTimes.length > 10) {
+      anomalies.push("constant-hold-time");
+      confidence = Math.max(confidence, 0.6);
+    }
+    if (analysis.sequentialKeys > keydowns.length * 0.8 && keydowns.length > 10) {
+      anomalies.push("sequential-input");
+      confidence = Math.max(confidence, 0.5);
+    }
+    if (analysis.rhythmScore < 0.1 && keydowns.length > 20) {
+      anomalies.push("no-rhythm-variation");
+      confidence = Math.max(confidence, 0.6);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      keystrokeCount: keydowns.length,
+      analysis
+    }, confidence);
+  }
+  /**
+   * Analyze keystroke patterns.
+   * @param {Array} keystrokes - Array of keystroke events
+   * @returns {Object} Analysis results
+   */
+  _analyzeKeystrokes(keystrokes) {
+    const keydowns = keystrokes.filter((k) => k.type === "down");
+    const keyups = keystrokes.filter((k) => k.type === "up");
+    if (keydowns.length < 2) {
+      return {
+        avgInterKeystrokeTime: Infinity,
+        timingVariance: Infinity,
+        missingKeyups: 0,
+        holdTimeVariance: Infinity,
+        holdTimes: [],
+        sequentialKeys: 0,
+        rhythmScore: 1
+      };
+    }
+    const interTimes = [];
+    for (let i = 1; i < keydowns.length; i++) {
+      interTimes.push(keydowns[i].t - keydowns[i - 1].t);
+    }
+    const avgInterKeystrokeTime = interTimes.reduce((a, b) => a + b, 0) / interTimes.length;
+    const timingVariance = interTimes.reduce((acc, t) => acc + Math.pow(t - avgInterKeystrokeTime, 2), 0) / interTimes.length;
+    const holdTimes = [];
+    for (const down of keydowns) {
+      const up = keyups.find((u) => u.key === down.key && u.t > down.t);
+      if (up) {
+        holdTimes.push(up.t - down.t);
+      }
+    }
+    const avgHoldTime = holdTimes.length > 0 ? holdTimes.reduce((a, b) => a + b, 0) / holdTimes.length : 0;
+    const holdTimeVariance = holdTimes.length > 0 ? holdTimes.reduce((acc, t) => acc + Math.pow(t - avgHoldTime, 2), 0) / holdTimes.length : Infinity;
+    const missingKeyups = keydowns.length - holdTimes.length;
+    let sequentialKeys = 0;
+    for (let i = 1; i < keydowns.length; i++) {
+      const prevCode = keydowns[i - 1].key.charCodeAt(0);
+      const currCode = keydowns[i].key.charCodeAt(0);
+      if (Math.abs(currCode - prevCode) === 1) {
+        sequentialKeys++;
+      }
+    }
+    let rhythmScore = 0;
+    if (interTimes.length > 5) {
+      const sortedTimes = [...interTimes].sort((a, b) => a - b);
+      const median = sortedTimes[Math.floor(sortedTimes.length / 2)];
+      const deviations = interTimes.filter((t) => Math.abs(t - median) > median * 0.3).length;
+      rhythmScore = deviations / interTimes.length;
+    }
+    return {
+      avgInterKeystrokeTime,
+      timingVariance,
+      missingKeyups,
+      holdTimeVariance,
+      holdTimes,
+      sequentialKeys,
+      rhythmScore
+    };
+  }
+  reset() {
+    super.reset();
+    this.stopTracking();
+    this._keystrokes = [];
+  }
+};
+__publicField(KeyboardPatternSignal, "id", "keyboard-pattern");
+__publicField(KeyboardPatternSignal, "category", "behavior");
+__publicField(KeyboardPatternSignal, "weight", 0.8);
+__publicField(KeyboardPatternSignal, "description", "Detects non-human keystroke patterns");
+__publicField(KeyboardPatternSignal, "requiresInteraction", true);
+
+// src/signals/behavior/InteractionTimingSignal.js
+var InteractionTimingSignal = class extends Signal {
+  constructor(options = {}) {
+    super(options);
+    this._pageLoadTime = performance.now();
+    this._firstInteractionTime = null;
+    this._interactions = [];
+    this._isTracking = false;
+    this._trackingDuration = options.trackingDuration || 5e3;
+    this._boundHandler = null;
+  }
+  /**
+   * Start tracking interactions.
+   */
+  startTracking() {
+    if (this._isTracking) return;
+    this._interactions = [];
+    this._isTracking = true;
+    const interactionEvents = ["click", "mousedown", "touchstart", "keydown", "scroll"];
+    this._boundHandler = (e) => {
+      const now = performance.now();
+      if (this._firstInteractionTime === null) {
+        this._firstInteractionTime = now;
+      }
+      this._interactions.push({
+        type: e.type,
+        t: now,
+        timeSinceLoad: now - this._pageLoadTime
+      });
+    };
+    for (const event of interactionEvents) {
+      document.addEventListener(event, this._boundHandler, { passive: true, capture: true });
+    }
+  }
+  /**
+   * Stop tracking interactions.
+   */
+  stopTracking() {
+    if (!this._isTracking) return;
+    this._isTracking = false;
+    const interactionEvents = ["click", "mousedown", "touchstart", "keydown", "scroll"];
+    if (this._boundHandler) {
+      for (const event of interactionEvents) {
+        document.removeEventListener(event, this._boundHandler, { capture: true });
+      }
+      this._boundHandler = null;
+    }
+  }
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    if (!this._isTracking && this._interactions.length === 0) {
+      this.startTracking();
+      await new Promise((resolve) => setTimeout(resolve, this._trackingDuration));
+      this.stopTracking();
+    }
+    const interactions = this._interactions;
+    if (interactions.length === 0) {
+      return this.createResult(false, {
+        reason: "no-interactions"
+      }, 0);
+    }
+    const firstInteraction = interactions[0];
+    if (firstInteraction.timeSinceLoad < 100) {
+      anomalies.push("instant-interaction");
+      confidence = Math.max(confidence, 0.9);
+    } else if (firstInteraction.timeSinceLoad < 300) {
+      anomalies.push("very-fast-interaction");
+      confidence = Math.max(confidence, 0.6);
+    }
+    if (interactions.length > 3) {
+      const intervals = [];
+      for (let i = 1; i < interactions.length; i++) {
+        intervals.push(interactions[i].t - interactions[i - 1].t);
+      }
+      const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+      const variance = intervals.reduce((acc, t) => acc + Math.pow(t - avgInterval, 2), 0) / intervals.length;
+      if (variance < 10 && interactions.length > 5) {
+        anomalies.push("robotic-intervals");
+        confidence = Math.max(confidence, 0.8);
+      }
+      const burstThreshold = 50;
+      let burstCount = 0;
+      for (const interval of intervals) {
+        if (interval < burstThreshold) burstCount++;
+      }
+      if (burstCount > intervals.length * 0.7) {
+        anomalies.push("burst-interactions");
+        confidence = Math.max(confidence, 0.7);
+      }
+    }
+    const typeSequence = interactions.map((i) => i.type).join(",");
+    if (interactions.length >= 6) {
+      const halfLength = Math.floor(interactions.length / 2);
+      const firstHalf = interactions.slice(0, halfLength).map((i) => i.type).join(",");
+      const secondHalf = interactions.slice(halfLength, halfLength * 2).map((i) => i.type).join(",");
+      if (firstHalf === secondHalf && firstHalf.length > 0) {
+        anomalies.push("repeated-sequence");
+        confidence = Math.max(confidence, 0.6);
+      }
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      interactionCount: interactions.length,
+      timeToFirstInteraction: firstInteraction.timeSinceLoad,
+      firstInteractionType: firstInteraction.type
+    }, confidence);
+  }
+  reset() {
+    super.reset();
+    this.stopTracking();
+    this._pageLoadTime = performance.now();
+    this._firstInteractionTime = null;
+    this._interactions = [];
+  }
+};
+__publicField(InteractionTimingSignal, "id", "interaction-timing");
+__publicField(InteractionTimingSignal, "category", "behavior");
+__publicField(InteractionTimingSignal, "weight", 0.6);
+__publicField(InteractionTimingSignal, "description", "Detects suspicious interaction timing");
+__publicField(InteractionTimingSignal, "requiresInteraction", true);
+
+// src/signals/behavior/ScrollBehaviorSignal.js
+var ScrollBehaviorSignal = class extends Signal {
+  constructor(options = {}) {
+    super(options);
+    this._scrollEvents = [];
+    this._isTracking = false;
+    this._trackingDuration = options.trackingDuration || 3e3;
+    this._boundHandler = null;
+  }
+  /**
+   * Start tracking scroll events.
+   */
+  startTracking() {
+    if (this._isTracking) return;
+    this._scrollEvents = [];
+    this._isTracking = true;
+    this._boundHandler = () => {
+      this._scrollEvents.push({
+        scrollY: window.scrollY,
+        scrollX: window.scrollX,
+        t: performance.now()
+      });
+    };
+    window.addEventListener("scroll", this._boundHandler, { passive: true });
+  }
+  /**
+   * Stop tracking scroll events.
+   */
+  stopTracking() {
+    if (!this._isTracking) return;
+    this._isTracking = false;
+    if (this._boundHandler) {
+      window.removeEventListener("scroll", this._boundHandler);
+      this._boundHandler = null;
+    }
+  }
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    if (this._scrollEvents.length === 0) {
+      this.startTracking();
+      await new Promise((resolve) => setTimeout(resolve, this._trackingDuration));
+      this.stopTracking();
+    }
+    const events = this._scrollEvents;
+    if (events.length < 3) {
+      return this.createResult(false, {
+        reason: "insufficient-scroll-data",
+        scrollEvents: events.length
+      }, 0);
+    }
+    const analysis = this._analyzeScrollPatterns(events);
+    if (analysis.instantJumps > 0) {
+      anomalies.push("instant-scroll-jumps");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (analysis.velocityVariance < 0.1 && events.length > 10) {
+      anomalies.push("constant-scroll-velocity");
+      confidence = Math.max(confidence, 0.6);
+    }
+    if (analysis.momentumEvents === 0 && events.length > 5) {
+      anomalies.push("no-scroll-momentum");
+      confidence = Math.max(confidence, 0.5);
+    }
+    if (analysis.intervalVariance < 5 && events.length > 10) {
+      anomalies.push("robotic-scroll-timing");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (analysis.scrollDirections === 1 && Math.abs(analysis.totalScrollY) > 1e3) {
+      if (analysis.velocityVariance < 1) {
+        anomalies.push("one-dimensional-scroll");
+        confidence = Math.max(confidence, 0.4);
+      }
+    }
+    if (analysis.exactPositionScrolls > 2) {
+      anomalies.push("exact-position-scrolls");
+      confidence = Math.max(confidence, 0.6);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      scrollEventCount: events.length,
+      analysis
+    }, confidence);
+  }
+  /**
+   * Analyze scroll patterns for anomalies.
+   * @param {Array} events - Array of scroll events
+   * @returns {Object} Analysis results
+   */
+  _analyzeScrollPatterns(events) {
+    if (events.length < 2) {
+      return {
+        instantJumps: 0,
+        velocityVariance: 0,
+        momentumEvents: 0,
+        intervalVariance: 0,
+        scrollDirections: 0,
+        totalScrollY: 0,
+        exactPositionScrolls: 0
+      };
+    }
+    let instantJumps = 0;
+    let momentumEvents = 0;
+    const velocities = [];
+    const intervals = [];
+    let hasVertical = false;
+    let hasHorizontal = false;
+    let exactPositionScrolls = 0;
+    const commonPositions = [0, 100, 200, 300, 400, 500, 600, 800, 1e3];
+    for (let i = 1; i < events.length; i++) {
+      const prev = events[i - 1];
+      const curr = events[i];
+      const dy = curr.scrollY - prev.scrollY;
+      const dx = curr.scrollX - prev.scrollX;
+      const dt = curr.t - prev.t;
+      intervals.push(dt);
+      if (Math.abs(dy) > 0) hasVertical = true;
+      if (Math.abs(dx) > 0) hasHorizontal = true;
+      if (dt === 0) continue;
+      const velocity = Math.sqrt(dy * dy + dx * dx) / dt;
+      velocities.push(velocity);
+      const distance = Math.abs(dy) + Math.abs(dx);
+      if (distance > 200 && dt < 20) {
+        instantJumps++;
+      }
+      if (i > 1 && velocities.length > 1) {
+        const prevVelocity = velocities[velocities.length - 2];
+        if (velocity < prevVelocity * 0.9 && velocity > 0) {
+          momentumEvents++;
+        }
+      }
+      if (commonPositions.includes(Math.round(curr.scrollY))) {
+        exactPositionScrolls++;
+      }
+    }
+    const avgVelocity = velocities.length > 0 ? velocities.reduce((a, b) => a + b, 0) / velocities.length : 0;
+    const velocityVariance = velocities.length > 0 ? velocities.reduce((acc, v) => acc + Math.pow(v - avgVelocity, 2), 0) / velocities.length : 0;
+    const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+    const intervalVariance = intervals.reduce((acc, t) => acc + Math.pow(t - avgInterval, 2), 0) / intervals.length;
+    let scrollDirections = 0;
+    if (hasVertical) scrollDirections++;
+    if (hasHorizontal) scrollDirections++;
+    const totalScrollY = events[events.length - 1].scrollY - events[0].scrollY;
+    return {
+      instantJumps,
+      velocityVariance,
+      momentumEvents,
+      intervalVariance,
+      scrollDirections,
+      totalScrollY,
+      exactPositionScrolls
+    };
+  }
+  reset() {
+    super.reset();
+    this.stopTracking();
+    this._scrollEvents = [];
+  }
+};
+__publicField(ScrollBehaviorSignal, "id", "scroll-behavior");
+__publicField(ScrollBehaviorSignal, "category", "behavior");
+__publicField(ScrollBehaviorSignal, "weight", 0.5);
+__publicField(ScrollBehaviorSignal, "description", "Detects programmatic scroll patterns");
+__publicField(ScrollBehaviorSignal, "requiresInteraction", true);
+
+// src/signals/fingerprint/PluginsSignal.js
+var PluginsSignal = class extends Signal {
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    const plugins = navigator.plugins;
+    const mimeTypes = navigator.mimeTypes;
+    if (!plugins) {
+      anomalies.push("no-plugins-object");
+      confidence = Math.max(confidence, 0.6);
+      return this.createResult(true, { anomalies }, confidence);
+    }
+    if (plugins.length === 0) {
+      anomalies.push("empty-plugins");
+      confidence = Math.max(confidence, 0.5);
+    }
+    const ua = navigator.userAgent || "";
+    if (ua.includes("Chrome") && !ua.includes("Chromium")) {
+      const hasChromePdf = Array.from(plugins).some((p) => p.name.includes("PDF") || p.name.includes("Chromium PDF"));
+      if (!hasChromePdf && plugins.length === 0) {
+        anomalies.push("chrome-missing-pdf-plugin");
+        confidence = Math.max(confidence, 0.4);
+      }
+    }
+    if (plugins.length > 0 && mimeTypes) {
+      let totalMimeTypes = 0;
+      for (let i = 0; i < plugins.length; i++) {
+        totalMimeTypes += plugins[i].length || 0;
+      }
+      if (mimeTypes.length === 0 && totalMimeTypes > 0) {
+        anomalies.push("mimetypes-mismatch");
+        confidence = Math.max(confidence, 0.5);
+      }
+    }
+    if (plugins.length > 1) {
+      const names = Array.from(plugins).map((p) => p.name);
+      const uniqueNames = new Set(names);
+      if (uniqueNames.size < names.length) {
+        anomalies.push("duplicate-plugins");
+        confidence = Math.max(confidence, 0.6);
+      }
+    }
+    try {
+      const desc = Object.getOwnPropertyDescriptor(Navigator.prototype, "plugins");
+      if (desc && desc.get) {
+        const nativeToString = desc.get.toString();
+        if (!nativeToString.includes("[native code]")) {
+          anomalies.push("plugins-getter-overridden");
+          confidence = Math.max(confidence, 0.7);
+        }
+      }
+    } catch (e) {
+    }
+    const isMobile = /Android|iPhone|iPad|iPod|Mobile/i.test(ua);
+    if (!isMobile && plugins.length === 1) {
+      anomalies.push("minimal-plugins");
+      confidence = Math.max(confidence, 0.3);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      pluginCount: plugins.length,
+      mimeTypeCount: (mimeTypes == null ? void 0 : mimeTypes.length) || 0
+    }, confidence);
+  }
+};
+__publicField(PluginsSignal, "id", "plugins");
+__publicField(PluginsSignal, "category", "fingerprint");
+__publicField(PluginsSignal, "weight", 0.6);
+__publicField(PluginsSignal, "description", "Detects browser plugin anomalies");
+
+// src/signals/fingerprint/WebGLSignal.js
+var WebGLSignal = class extends Signal {
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    const canvas = document.createElement("canvas");
+    let gl = null;
+    try {
+      gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    } catch (e) {
+      anomalies.push("webgl-error");
+      confidence = Math.max(confidence, 0.5);
+    }
+    if (!gl) {
+      anomalies.push("webgl-unavailable");
+      confidence = Math.max(confidence, 0.4);
+      return this.createResult(true, { anomalies }, confidence);
+    }
+    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+    let vendor = "";
+    let renderer = "";
+    if (debugInfo) {
+      vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) || "";
+      renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || "";
+    }
+    if (!vendor && !renderer) {
+      anomalies.push("no-webgl-renderer-info");
+      confidence = Math.max(confidence, 0.6);
+    }
+    const suspiciousRenderers = [
+      "swiftshader",
+      "llvmpipe",
+      "software",
+      "mesa",
+      "google swiftshader",
+      "vmware",
+      "virtualbox"
+    ];
+    const rendererLower = renderer.toLowerCase();
+    for (const sus of suspiciousRenderers) {
+      if (rendererLower.includes(sus)) {
+        anomalies.push(`suspicious-renderer-${sus.replace(/\s+/g, "-")}`);
+        confidence = Math.max(confidence, 0.7);
+        break;
+      }
+    }
+    if (vendor && renderer) {
+      if (rendererLower.includes("nvidia") && !vendor.toLowerCase().includes("nvidia")) {
+        anomalies.push("vendor-renderer-mismatch");
+        confidence = Math.max(confidence, 0.6);
+      }
+      if ((rendererLower.includes("amd") || rendererLower.includes("radeon")) && !vendor.toLowerCase().includes("amd") && !vendor.toLowerCase().includes("ati")) {
+        anomalies.push("vendor-renderer-mismatch");
+        confidence = Math.max(confidence, 0.6);
+      }
+    }
+    const extensions = gl.getSupportedExtensions() || [];
+    if (extensions.length < 5) {
+      anomalies.push("few-webgl-extensions");
+      confidence = Math.max(confidence, 0.4);
+    }
+    const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+    const maxViewportDims = gl.getParameter(gl.MAX_VIEWPORT_DIMS);
+    if (maxTextureSize < 1024 || maxTextureSize > 65536) {
+      anomalies.push("unrealistic-max-texture");
+      confidence = Math.max(confidence, 0.5);
+    }
+    try {
+      gl.clearColor(0, 0, 0, 1);
+      gl.clear(gl.COLOR_BUFFER_BIT);
+      const pixels = new Uint8Array(4);
+      gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+      if (pixels[3] !== 255) {
+        anomalies.push("webgl-render-failure");
+        confidence = Math.max(confidence, 0.6);
+      }
+    } catch (e) {
+      anomalies.push("webgl-render-error");
+      confidence = Math.max(confidence, 0.5);
+    }
+    const loseContext = gl.getExtension("WEBGL_lose_context");
+    if (loseContext) {
+      loseContext.loseContext();
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      vendor,
+      renderer,
+      extensionCount: extensions.length,
+      maxTextureSize
+    }, confidence);
+  }
+};
+__publicField(WebGLSignal, "id", "webgl");
+__publicField(WebGLSignal, "category", "fingerprint");
+__publicField(WebGLSignal, "weight", 0.7);
+__publicField(WebGLSignal, "description", "Detects WebGL rendering anomalies");
+
+// src/signals/fingerprint/CanvasSignal.js
+var CanvasSignal = class extends Signal {
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = 200;
+      canvas.height = 50;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        anomalies.push("canvas-context-unavailable");
+        confidence = Math.max(confidence, 0.5);
+        return this.createResult(true, { anomalies }, confidence);
+      }
+      ctx.textBaseline = "alphabetic";
+      ctx.font = "14px Arial";
+      ctx.fillStyle = "#f60";
+      ctx.fillRect(0, 0, 200, 50);
+      ctx.fillStyle = "#069";
+      ctx.fillText("Bot Detection Test \u{1F916}", 2, 15);
+      ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+      ctx.fillText("Canvas Fingerprint", 4, 30);
+      ctx.beginPath();
+      ctx.arc(100, 25, 10, 0, Math.PI * 2, true);
+      ctx.closePath();
+      ctx.fill();
+      const dataUrl1 = canvas.toDataURL();
+      ctx.clearRect(0, 0, 200, 50);
+      ctx.fillStyle = "#f60";
+      ctx.fillRect(0, 0, 200, 50);
+      ctx.fillStyle = "#069";
+      ctx.fillText("Bot Detection Test \u{1F916}", 2, 15);
+      ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+      ctx.fillText("Canvas Fingerprint", 4, 30);
+      ctx.beginPath();
+      ctx.arc(100, 25, 10, 0, Math.PI * 2, true);
+      ctx.closePath();
+      ctx.fill();
+      const dataUrl2 = canvas.toDataURL();
+      if (dataUrl1 !== dataUrl2) {
+        anomalies.push("canvas-randomized");
+        confidence = Math.max(confidence, 0.6);
+      }
+      if (dataUrl1.length < 1e3) {
+        anomalies.push("canvas-possibly-blank");
+        confidence = Math.max(confidence, 0.4);
+      }
+      const blankCanvas = document.createElement("canvas");
+      blankCanvas.width = 200;
+      blankCanvas.height = 50;
+      const blankUrl = blankCanvas.toDataURL();
+      if (dataUrl1 === blankUrl) {
+        anomalies.push("canvas-rendering-blocked");
+        confidence = Math.max(confidence, 0.7);
+      }
+      try {
+        const toDataURLStr = canvas.toDataURL.toString();
+        if (!toDataURLStr.includes("[native code]")) {
+          anomalies.push("toDataURL-overridden");
+          confidence = Math.max(confidence, 0.8);
+        }
+      } catch (e) {
+      }
+      const imageData = ctx.getImageData(0, 0, 200, 50);
+      const pixels = imageData.data;
+      let allSame = true;
+      const firstPixel = [pixels[0], pixels[1], pixels[2], pixels[3]];
+      for (let i = 4; i < pixels.length; i += 4) {
+        if (pixels[i] !== firstPixel[0] || pixels[i + 1] !== firstPixel[1] || pixels[i + 2] !== firstPixel[2]) {
+          allSame = false;
+          break;
+        }
+      }
+      if (allSame) {
+        anomalies.push("uniform-pixel-data");
+        confidence = Math.max(confidence, 0.6);
+      }
+    } catch (e) {
+      anomalies.push("canvas-error");
+      confidence = Math.max(confidence, 0.4);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, { anomalies }, confidence);
+  }
+};
+__publicField(CanvasSignal, "id", "canvas");
+__publicField(CanvasSignal, "category", "fingerprint");
+__publicField(CanvasSignal, "weight", 0.5);
+__publicField(CanvasSignal, "description", "Detects canvas fingerprint anomalies");
+
+// src/signals/fingerprint/AudioContextSignal.js
+var AudioContextSignal = class extends Signal {
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    const AudioContext = window.AudioContext || window.webkitAudioContext;
+    if (!AudioContext) {
+      anomalies.push("audio-context-unavailable");
+      confidence = Math.max(confidence, 0.4);
+      return this.createResult(true, { anomalies }, confidence);
+    }
+    let audioContext = null;
+    let oscillator = null;
+    let analyser = null;
+    try {
+      audioContext = new AudioContext();
+      const sampleRate = audioContext.sampleRate;
+      if (sampleRate !== 44100 && sampleRate !== 48e3 && sampleRate !== 96e3) {
+        anomalies.push("unusual-sample-rate");
+        confidence = Math.max(confidence, 0.3);
+      }
+      oscillator = audioContext.createOscillator();
+      analyser = audioContext.createAnalyser();
+      if (!oscillator || !analyser) {
+        anomalies.push("audio-nodes-unavailable");
+        confidence = Math.max(confidence, 0.5);
+      } else {
+        const fftSize = analyser.fftSize;
+        if (fftSize !== 2048) {
+        }
+        const destination = audioContext.destination;
+        if (!destination || destination.maxChannelCount === 0) {
+          anomalies.push("no-audio-destination");
+          confidence = Math.max(confidence, 0.6);
+        }
+        if (destination && destination.maxChannelCount < 2) {
+          anomalies.push("mono-audio-only");
+          confidence = Math.max(confidence, 0.3);
+        }
+      }
+      try {
+        const audioCtxStr = AudioContext.toString();
+        if (!audioCtxStr.includes("[native code]")) {
+          anomalies.push("audio-context-overridden");
+          confidence = Math.max(confidence, 0.7);
+        }
+      } catch (e) {
+      }
+      try {
+        if (audioContext.state === "suspended") {
+          await audioContext.resume().catch(() => {
+          });
+        }
+        if (audioContext.state === "running") {
+          const oscillatorNode = audioContext.createOscillator();
+          const gainNode = audioContext.createGain();
+          const scriptProcessor = audioContext.createScriptProcessor ? audioContext.createScriptProcessor(4096, 1, 1) : null;
+          if (scriptProcessor) {
+            oscillatorNode.type = "triangle";
+            oscillatorNode.frequency.value = 1e4;
+            gainNode.gain.value = 0;
+            oscillatorNode.connect(gainNode);
+            gainNode.connect(scriptProcessor);
+            scriptProcessor.connect(audioContext.destination);
+            oscillatorNode.start(0);
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            oscillatorNode.stop();
+            oscillatorNode.disconnect();
+            gainNode.disconnect();
+            scriptProcessor.disconnect();
+          }
+        }
+      } catch (e) {
+        anomalies.push("audio-fingerprint-blocked");
+        confidence = Math.max(confidence, 0.4);
+      }
+      const OfflineAudioContext = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+      if (!OfflineAudioContext) {
+        anomalies.push("offline-audio-context-unavailable");
+        confidence = Math.max(confidence, 0.3);
+      }
+    } catch (e) {
+      anomalies.push("audio-context-error");
+      confidence = Math.max(confidence, 0.4);
+    } finally {
+      if (oscillator) {
+        try {
+          oscillator.disconnect();
+        } catch (e) {
+        }
+      }
+      if (analyser) {
+        try {
+          analyser.disconnect();
+        } catch (e) {
+        }
+      }
+      if (audioContext) {
+        try {
+          audioContext.close();
+        } catch (e) {
+        }
+      }
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, { anomalies }, confidence);
+  }
+};
+__publicField(AudioContextSignal, "id", "audio-context");
+__publicField(AudioContextSignal, "category", "fingerprint");
+__publicField(AudioContextSignal, "weight", 0.5);
+__publicField(AudioContextSignal, "description", "Detects AudioContext anomalies");
+
+// src/signals/fingerprint/ScreenSignal.js
+var ScreenSignal = class extends Signal {
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    const screen = window.screen;
+    if (!screen) {
+      anomalies.push("no-screen-object");
+      confidence = Math.max(confidence, 0.6);
+      return this.createResult(true, { anomalies }, confidence);
+    }
+    const width = screen.width;
+    const height = screen.height;
+    const availWidth = screen.availWidth;
+    const availHeight = screen.availHeight;
+    const colorDepth = screen.colorDepth;
+    const pixelDepth = screen.pixelDepth;
+    const outerWidth = window.outerWidth;
+    const outerHeight = window.outerHeight;
+    const innerWidth = window.innerWidth;
+    const innerHeight = window.innerHeight;
+    if (outerWidth === 0 || outerHeight === 0) {
+      anomalies.push("zero-outer-dimensions");
+      confidence = Math.max(confidence, 0.8);
+    }
+    if (innerWidth === 0 || innerHeight === 0) {
+      anomalies.push("zero-inner-dimensions");
+      confidence = Math.max(confidence, 0.7);
+    }
+    const ua = navigator.userAgent || "";
+    const isMobile = /Android|iPhone|iPad|iPod|Mobile/i.test(ua);
+    if (!isMobile && (width < 640 || height < 480)) {
+      anomalies.push("very-small-screen");
+      confidence = Math.max(confidence, 0.5);
+    }
+    if (width > 7680 || height > 4320) {
+      anomalies.push("unrealistic-screen-size");
+      confidence = Math.max(confidence, 0.4);
+    }
+    const headlessDefaults = [
+      { w: 800, h: 600 },
+      { w: 1024, h: 768 },
+      { w: 1920, h: 1080 }
+    ];
+    for (const def of headlessDefaults) {
+      if (width === def.w && height === def.h && outerWidth === def.w && outerHeight === def.h) {
+        anomalies.push("headless-default-dimensions");
+        confidence = Math.max(confidence, 0.5);
+        break;
+      }
+    }
+    if (availWidth > width || availHeight > height) {
+      anomalies.push("available-exceeds-total");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (outerWidth > width || outerHeight > height) {
+      anomalies.push("window-exceeds-screen");
+      confidence = Math.max(confidence, 0.6);
+    }
+    if (colorDepth !== 24 && colorDepth !== 32 && colorDepth !== 30 && colorDepth !== 48) {
+      anomalies.push("unusual-color-depth");
+      confidence = Math.max(confidence, 0.3);
+    }
+    if (colorDepth !== pixelDepth) {
+      anomalies.push("depth-mismatch");
+      confidence = Math.max(confidence, 0.3);
+    }
+    const dpr = window.devicePixelRatio;
+    if (dpr === 0 || dpr === void 0) {
+      anomalies.push("missing-device-pixel-ratio");
+      confidence = Math.max(confidence, 0.5);
+    } else if (dpr < 0.5 || dpr > 5) {
+      anomalies.push("unusual-device-pixel-ratio");
+      confidence = Math.max(confidence, 0.4);
+    }
+    if (screen.orientation) {
+      const orientationType = screen.orientation.type;
+      const orientationAngle = screen.orientation.angle;
+      if (orientationType.includes("landscape") && width < height) {
+        anomalies.push("orientation-dimension-mismatch");
+        confidence = Math.max(confidence, 0.4);
+      }
+      if (orientationType.includes("portrait") && width > height) {
+        anomalies.push("orientation-dimension-mismatch");
+        confidence = Math.max(confidence, 0.4);
+      }
+    }
+    if (innerWidth === outerWidth && innerHeight === outerHeight && outerWidth > 0 && outerHeight > 0) {
+      anomalies.push("no-browser-chrome");
+      confidence = Math.max(confidence, 0.5);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      dimensions: {
+        screen: { width, height },
+        available: { width: availWidth, height: availHeight },
+        window: {
+          outer: { width: outerWidth, height: outerHeight },
+          inner: { width: innerWidth, height: innerHeight }
+        },
+        colorDepth,
+        devicePixelRatio: dpr
+      }
+    }, confidence);
+  }
+};
+__publicField(ScreenSignal, "id", "screen");
+__publicField(ScreenSignal, "category", "fingerprint");
+__publicField(ScreenSignal, "weight", 0.4);
+__publicField(ScreenSignal, "description", "Detects unusual screen dimensions");
+
+// src/signals/timing/PageLoadSignal.js
+var PageLoadSignal = class extends Signal {
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    if (!window.performance || !performance.timing) {
+      if (performance.getEntriesByType) {
+        const navEntries = performance.getEntriesByType("navigation");
+        if (navEntries.length > 0) {
+          return this._analyzeNavigationTiming(navEntries[0]);
+        }
+      }
+      anomalies.push("no-performance-api");
+      confidence = Math.max(confidence, 0.3);
+      return this.createResult(true, { anomalies }, confidence);
+    }
+    const timing = performance.timing;
+    const navigationStart = timing.navigationStart;
+    const domContentLoaded = timing.domContentLoadedEventEnd - navigationStart;
+    const domComplete = timing.domComplete - navigationStart;
+    const loadComplete = timing.loadEventEnd - navigationStart;
+    const dnsLookup = timing.domainLookupEnd - timing.domainLookupStart;
+    const tcpConnection = timing.connectEnd - timing.connectStart;
+    const serverResponse = timing.responseEnd - timing.requestStart;
+    const domProcessing = timing.domComplete - timing.domLoading;
+    if (domContentLoaded > 0 && domContentLoaded < 10) {
+      anomalies.push("instant-dom-content-loaded");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (dnsLookup === 0 && tcpConnection === 0 && serverResponse < 5) {
+      anomalies.push("zero-network-timing");
+      confidence = Math.max(confidence, 0.4);
+    }
+    if (domContentLoaded < 0 || domComplete < 0 || loadComplete < 0) {
+      anomalies.push("negative-timing");
+      confidence = Math.max(confidence, 0.8);
+    }
+    if (timing.domContentLoadedEventEnd > 0 && timing.loadEventEnd > 0) {
+      if (timing.domContentLoadedEventEnd > timing.loadEventEnd) {
+        anomalies.push("timing-order-violation");
+        confidence = Math.max(confidence, 0.7);
+      }
+    }
+    if (domProcessing > 3e4) {
+      anomalies.push("excessive-dom-processing");
+      confidence = Math.max(confidence, 0.3);
+    }
+    const scriptsLoadedTime = timing.domContentLoadedEventStart - timing.responseEnd;
+    if (scriptsLoadedTime > 0 && scriptsLoadedTime < 5) {
+      anomalies.push("instant-script-execution");
+      confidence = Math.max(confidence, 0.4);
+    }
+    const perfNow1 = performance.now();
+    const perfNow2 = performance.now();
+    if (perfNow1 === perfNow2 && perfNow1 > 0) {
+      anomalies.push("frozen-performance-now");
+      confidence = Math.max(confidence, 0.6);
+    }
+    const dateNow1 = Date.now();
+    const perfNow3 = performance.now();
+    const dateNow2 = Date.now();
+    if (Math.abs(dateNow2 - dateNow1 - (performance.now() - perfNow3)) > 100) {
+      anomalies.push("timing-inconsistency");
+      confidence = Math.max(confidence, 0.5);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      timings: {
+        domContentLoaded,
+        domComplete,
+        loadComplete,
+        dnsLookup,
+        tcpConnection,
+        serverResponse,
+        domProcessing
+      }
+    }, confidence);
+  }
+  /**
+   * Analyze Navigation Timing Level 2 API data.
+   * @param {PerformanceNavigationTiming} entry - Navigation timing entry
+   * @returns {SignalResult}
+   */
+  _analyzeNavigationTiming(entry) {
+    const anomalies = [];
+    let confidence = 0;
+    const domContentLoaded = entry.domContentLoadedEventEnd;
+    const loadComplete = entry.loadEventEnd;
+    const dnsLookup = entry.domainLookupEnd - entry.domainLookupStart;
+    const serverResponse = entry.responseEnd - entry.requestStart;
+    if (domContentLoaded > 0 && domContentLoaded < 10) {
+      anomalies.push("instant-dom-content-loaded");
+      confidence = Math.max(confidence, 0.7);
+    }
+    if (dnsLookup === 0 && serverResponse === 0) {
+      anomalies.push("zero-network-timing");
+      confidence = Math.max(confidence, 0.4);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      timings: {
+        domContentLoaded,
+        loadComplete,
+        dnsLookup,
+        serverResponse
+      }
+    }, confidence);
+  }
+};
+__publicField(PageLoadSignal, "id", "page-load");
+__publicField(PageLoadSignal, "category", "timing");
+__publicField(PageLoadSignal, "weight", 0.5);
+__publicField(PageLoadSignal, "description", "Detects suspicious page load timing");
+
+// src/signals/timing/DOMContentTimingSignal.js
+var DOMContentTimingSignal = class extends Signal {
+  constructor(options = {}) {
+    super(options);
+    this._domContentLoadedTime = null;
+    this._documentReadyState = document.readyState;
+    this._captureTime = performance.now();
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => {
+        this._domContentLoadedTime = performance.now();
+      });
+    }
+  }
+  async detect() {
+    const anomalies = [];
+    let confidence = 0;
+    const now = performance.now();
+    const readyState = document.readyState;
+    let resourceCount = 0;
+    let totalResourceTime = 0;
+    let externalScriptCount = 0;
+    if (performance.getEntriesByType) {
+      const resources = performance.getEntriesByType("resource");
+      resourceCount = resources.length;
+      for (const resource of resources) {
+        totalResourceTime += resource.duration;
+        if (resource.initiatorType === "script" && resource.name.startsWith("http")) {
+          externalScriptCount++;
+        }
+      }
+    }
+    if (resourceCount === 0 && readyState === "complete") {
+      anomalies.push("no-resources-loaded");
+      confidence = Math.max(confidence, 0.4);
+    }
+    if (this._domContentLoadedTime && this._domContentLoadedTime < 50 && resourceCount === 0) {
+      anomalies.push("instant-ready-no-resources");
+      confidence = Math.max(confidence, 0.6);
+    }
+    if (document.hidden && this._documentReadyState === "loading") {
+      anomalies.push("hidden-at-load");
+      confidence = Math.max(confidence, 0.3);
+    }
+    if (typeof document.visibilityState === "undefined") {
+      anomalies.push("no-visibility-api");
+      confidence = Math.max(confidence, 0.4);
+    }
+    try {
+      const startMutation = performance.now();
+      const testDiv = document.createElement("div");
+      testDiv.id = "__bot_detection_test__";
+      document.body.appendChild(testDiv);
+      const afterAppend = performance.now();
+      document.body.removeChild(testDiv);
+      const afterRemove = performance.now();
+      const appendTime = afterAppend - startMutation;
+      const removeTime = afterRemove - afterAppend;
+      if (appendTime === 0 && removeTime === 0) {
+        anomalies.push("instant-dom-operations");
+        confidence = Math.max(confidence, 0.5);
+      }
+    } catch (e) {
+      if (!document.body) {
+        anomalies.push("no-document-body");
+        confidence = Math.max(confidence, 0.4);
+      }
+    }
+    if (typeof MutationObserver === "undefined") {
+      anomalies.push("no-mutation-observer");
+      confidence = Math.max(confidence, 0.5);
+    }
+    if (typeof requestAnimationFrame === "undefined") {
+      anomalies.push("no-request-animation-frame");
+      confidence = Math.max(confidence, 0.5);
+    }
+    if (performance.getEntriesByType) {
+      const paintEntries = performance.getEntriesByType("paint");
+      const firstPaint = paintEntries.find((e) => e.name === "first-paint");
+      if (!firstPaint && readyState === "complete" && now > 1e3) {
+        anomalies.push("no-first-paint");
+        confidence = Math.max(confidence, 0.4);
+      }
+      const fcp = paintEntries.find((e) => e.name === "first-contentful-paint");
+      if (!fcp && readyState === "complete" && now > 1e3) {
+        anomalies.push("no-first-contentful-paint");
+        confidence = Math.max(confidence, 0.4);
+      }
+    }
+    if (typeof IntersectionObserver === "undefined") {
+      anomalies.push("no-intersection-observer");
+      confidence = Math.max(confidence, 0.4);
+    }
+    const triggered = anomalies.length > 0;
+    return this.createResult(triggered, {
+      anomalies,
+      metrics: {
+        readyState,
+        resourceCount,
+        externalScriptCount,
+        domContentLoadedTime: this._domContentLoadedTime,
+        documentHidden: document.hidden
+      }
+    }, confidence);
+  }
+};
+__publicField(DOMContentTimingSignal, "id", "dom-content-timing");
+__publicField(DOMContentTimingSignal, "category", "timing");
+__publicField(DOMContentTimingSignal, "weight", 0.4);
+__publicField(DOMContentTimingSignal, "description", "Analyzes DOM content loaded timing patterns");
+
+// src/signals/automation/PuppeteerSignal.js
+var PuppeteerSignal = class extends Signal {
+  async detect() {
+    const indicators = [];
+    let confidence = 0;
+    if (window.__puppeteer_evaluation_script__) {
+      indicators.push("puppeteer-evaluation-script");
+      confidence = Math.max(confidence, 1);
+    }
+    const puppeteerGlobals = [
+      "__puppeteer_evaluation_script__",
+      "__puppeteer",
+      "puppeteer"
+    ];
+    for (const global of puppeteerGlobals) {
+      if (global in window) {
+        indicators.push(`global-${global}`);
+        confidence = Math.max(confidence, 1);
+      }
+    }
+    const ua = navigator.userAgent || "";
+    if (ua.includes("HeadlessChrome")) {
+      indicators.push("headless-chrome-ua");
+      confidence = Math.max(confidence, 0.9);
+    }
+    if (window.cdc_adoQpoasnfa76pfcZLmcfl_Array || window.cdc_adoQpoasnfa76pfcZLmcfl_Promise || window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol) {
+      indicators.push("cdp-artifacts");
+      confidence = Math.max(confidence, 1);
+    }
+    try {
+      const evalTest = window.eval.toString();
+      if (evalTest.includes("puppeteer")) {
+        indicators.push("eval-puppeteer");
+        confidence = Math.max(confidence, 0.9);
+      }
+    } catch (e) {
+    }
+    try {
+      throw new Error("stack trace test");
+    } catch (e) {
+      const stack = e.stack || "";
+      if (stack.includes("puppeteer") || stack.includes("pptr")) {
+        indicators.push("stack-trace-puppeteer");
+        confidence = Math.max(confidence, 0.8);
+      }
+    }
+    if (window.innerWidth === 800 && window.innerHeight === 600) {
+      indicators.push("default-viewport");
+      confidence = Math.max(confidence, 0.3);
+    }
+    if (navigator.webdriver === true) {
+      indicators.push("webdriver-flag");
+      confidence = Math.max(confidence, 0.9);
+    }
+    const suspiciousBindings = Object.keys(window).filter((key) => {
+      return key.startsWith("__") && typeof window[key] === "function";
+    });
+    if (suspiciousBindings.length > 3) {
+      indicators.push("suspicious-bindings");
+      confidence = Math.max(confidence, 0.5);
+    }
+    if (typeof window.chrome !== "undefined") {
+      if (!window.chrome.runtime || !window.chrome.runtime.id) {
+        indicators.push("incomplete-chrome-object");
+        confidence = Math.max(confidence, 0.4);
+      }
+    }
+    const triggered = indicators.length > 0;
+    return this.createResult(triggered, { indicators }, confidence);
+  }
+};
+__publicField(PuppeteerSignal, "id", "puppeteer");
+__publicField(PuppeteerSignal, "category", "automation");
+__publicField(PuppeteerSignal, "weight", 1);
+__publicField(PuppeteerSignal, "description", "Detects Puppeteer automation artifacts");
+
+// src/signals/automation/PlaywrightSignal.js
+var PlaywrightSignal = class extends Signal {
+  async detect() {
+    const indicators = [];
+    let confidence = 0;
+    if (window.__playwright) {
+      indicators.push("playwright-namespace");
+      confidence = Math.max(confidence, 1);
+    }
+    const playwrightGlobals = [
+      "__playwright",
+      "__pw_manual",
+      "__pwInitScripts",
+      "playwright"
+    ];
+    for (const global of playwrightGlobals) {
+      if (global in window) {
+        indicators.push(`global-${global}`);
+        confidence = Math.max(confidence, 1);
+      }
+    }
+    if (window.__playwright__binding__) {
+      indicators.push("playwright-binding");
+      confidence = Math.max(confidence, 1);
+    }
+    const ua = navigator.userAgent || "";
+    if (ua.includes("Playwright") || ua.includes("HeadlessChrome")) {
+      indicators.push("playwright-ua-marker");
+      confidence = Math.max(confidence, ua.includes("Playwright") ? 1 : 0.7);
+    }
+    if (navigator.webdriver === true) {
+      indicators.push("webdriver-flag");
+      confidence = Math.max(confidence, 0.8);
+    }
+    try {
+      const windowKeys = Object.keys(window);
+      const pwBindings = windowKeys.filter((k) => k.startsWith("__pw"));
+      if (pwBindings.length > 0) {
+        indicators.push("pw-bindings");
+        confidence = Math.max(confidence, 1);
+      }
+    } catch (e) {
+    }
+    if (typeof window.__pw_date_intercepted !== "undefined") {
+      indicators.push("date-interception");
+      confidence = Math.max(confidence, 0.9);
+    }
+    if (window.__pw_geolocation__) {
+      indicators.push("geolocation-mock");
+      confidence = Math.max(confidence, 0.9);
+    }
+    if (window.__pw_permissions__) {
+      indicators.push("permissions-override");
+      confidence = Math.max(confidence, 0.9);
+    }
+    if (window.__cdpSession__) {
+      indicators.push("cdp-session");
+      confidence = Math.max(confidence, 0.8);
+    }
+    try {
+      throw new Error("stack trace test");
+    } catch (e) {
+      const stack = e.stack || "";
+      if (stack.includes("playwright") || stack.includes("__pw")) {
+        indicators.push("stack-trace-playwright");
+        confidence = Math.max(confidence, 0.8);
+      }
+    }
+    try {
+      const date = /* @__PURE__ */ new Date();
+      const localeString = date.toLocaleString();
+      if (window.__pwTimezone__) {
+        indicators.push("timezone-mock");
+        confidence = Math.max(confidence, 0.8);
+      }
+    } catch (e) {
+    }
+    const triggered = indicators.length > 0;
+    return this.createResult(triggered, { indicators }, confidence);
+  }
+};
+__publicField(PlaywrightSignal, "id", "playwright");
+__publicField(PlaywrightSignal, "category", "automation");
+__publicField(PlaywrightSignal, "weight", 1);
+__publicField(PlaywrightSignal, "description", "Detects Playwright automation artifacts");
+
+// src/signals/automation/SeleniumSignal.js
+var SeleniumSignal = class extends Signal {
+  async detect() {
+    const indicators = [];
+    let confidence = 0;
+    if (navigator.webdriver === true) {
+      indicators.push("webdriver-flag");
+      confidence = Math.max(confidence, 1);
+    }
+    const seleniumGlobals = [
+      "_selenium",
+      "callSelenium",
+      "_Selenium_IDE_Recorder",
+      "__selenium_evaluate",
+      "__selenium_unwrap",
+      "__webdriver_evaluate",
+      "__webdriver_unwrap",
+      "__webdriver_script_function",
+      "__webdriver_script_func",
+      "__fxdriver_evaluate",
+      "__fxdriver_unwrap",
+      "webdriver"
+    ];
+    for (const global of seleniumGlobals) {
+      if (global in window) {
+        indicators.push(`global-${global}`);
+        confidence = Math.max(confidence, 1);
+      }
+    }
+    const seleniumDocProps = [
+      "__webdriver_script_fn",
+      "__driver_evaluate",
+      "__webdriver_evaluate",
+      "__selenium_evaluate",
+      "__fxdriver_evaluate",
+      "__driver_unwrap",
+      "__webdriver_unwrap",
+      "__selenium_unwrap",
+      "__fxdriver_unwrap"
+    ];
+    for (const prop of seleniumDocProps) {
+      if (prop in document) {
+        indicators.push(`document-${prop}`);
+        confidence = Math.max(confidence, 1);
+      }
+    }
+    const windowKeys = Object.keys(window);
+    const cdcVars = windowKeys.filter(
+      (key) => key.startsWith("$cdc_") || key.startsWith("$wdc_") || key.startsWith("$chrome_asyncScriptInfo")
+    );
+    if (cdcVars.length > 0) {
+      indicators.push("chromedriver-variables");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.webdriverCallback || document.documentElement.getAttribute("webdriver")) {
+      indicators.push("geckodriver-artifacts");
+      confidence = Math.max(confidence, 1);
+    }
+    try {
+      const docElement = document.documentElement;
+      if (docElement.hasAttribute("webdriver") || docElement.getAttribute("selenium") || docElement.getAttribute("driver")) {
+        indicators.push("document-webdriver-attr");
+        confidence = Math.max(confidence, 1);
+      }
+    } catch (e) {
+    }
+    if (window.selenium || window.sideex) {
+      indicators.push("selenium-ide");
+      confidence = Math.max(confidence, 1);
+    }
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(Navigator.prototype, "webdriver");
+      if (descriptor) {
+        if (descriptor.get) {
+          const getterStr = descriptor.get.toString();
+          if (!getterStr.includes("[native code]")) {
+            indicators.push("webdriver-getter-modified");
+            confidence = Math.max(confidence, 0.7);
+          }
+        }
+      }
+    } catch (e) {
+    }
+    if (window.domAutomation || window.domAutomationController) {
+      indicators.push("dom-automation");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.awesomium) {
+      indicators.push("awesomium");
+      confidence = Math.max(confidence, 0.9);
+    }
+    if (window.external && window.external.toString().includes("Selenium")) {
+      indicators.push("external-selenium");
+      confidence = Math.max(confidence, 1);
+    }
+    const triggered = indicators.length > 0;
+    return this.createResult(triggered, { indicators }, confidence);
+  }
+};
+__publicField(SeleniumSignal, "id", "selenium");
+__publicField(SeleniumSignal, "category", "automation");
+__publicField(SeleniumSignal, "weight", 1);
+__publicField(SeleniumSignal, "description", "Detects Selenium WebDriver artifacts");
+
+// src/signals/automation/PhantomJSSignal.js
+var PhantomJSSignal = class extends Signal {
+  async detect() {
+    const indicators = [];
+    let confidence = 0;
+    if (window.callPhantom) {
+      indicators.push("callPhantom");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window._phantom) {
+      indicators.push("_phantom");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.phantom) {
+      indicators.push("phantom");
+      confidence = Math.max(confidence, 1);
+    }
+    const ua = navigator.userAgent || "";
+    if (ua.includes("PhantomJS")) {
+      indicators.push("phantomjs-ua");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.__phantomas) {
+      indicators.push("phantomas");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.__casper) {
+      indicators.push("casperjs");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.casper) {
+      indicators.push("casper-global");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.slimer) {
+      indicators.push("slimerjs");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.__nightmare) {
+      indicators.push("nightmare");
+      confidence = Math.max(confidence, 1);
+    }
+    if (window.nightmare) {
+      indicators.push("nightmare-global");
+      confidence = Math.max(confidence, 1);
+    }
+    try {
+      const funcString = Function.prototype.toString.call(Function);
+      if (funcString.includes("phantom") || funcString.includes("Phantom")) {
+        indicators.push("function-prototype-phantom");
+        confidence = Math.max(confidence, 0.8);
+      }
+    } catch (e) {
+    }
+    try {
+      throw new Error("test");
+    } catch (e) {
+      const stack = e.stack || "";
+      if (stack.includes("phantom")) {
+        indicators.push("stack-trace-phantom");
+        confidence = Math.max(confidence, 0.9);
+      }
+    }
+    if (navigator.plugins && navigator.plugins.length === 0) {
+      if (indicators.length > 0) {
+        indicators.push("no-plugins-phantom");
+        confidence = Math.max(confidence, 0.5);
+      }
+    }
+    const phantomProps = [
+      "__PHANTOM__",
+      "PHANTOM",
+      "Buffer",
+      // PhantomJS exposes Node.js Buffer
+      "process"
+      // May expose Node.js process
+    ];
+    for (const prop of phantomProps) {
+      if (prop in window && prop !== "Buffer" && prop !== "process") {
+        indicators.push(`phantom-prop-${prop.toLowerCase()}`);
+        confidence = Math.max(confidence, 0.9);
+      }
+    }
+    if (ua.includes("QtWebKit")) {
+      indicators.push("qtwebkit");
+      confidence = Math.max(confidence, 0.7);
+    }
+    const triggered = indicators.length > 0;
+    return this.createResult(triggered, { indicators }, confidence);
+  }
+};
+__publicField(PhantomJSSignal, "id", "phantomjs");
+__publicField(PhantomJSSignal, "category", "automation");
+__publicField(PhantomJSSignal, "weight", 1);
+__publicField(PhantomJSSignal, "description", "Detects PhantomJS automation artifacts");
+
+// src/index.js
+var Signals = {
+  // Environment signals
+  WebDriverSignal,
+  HeadlessSignal,
+  NavigatorAnomalySignal,
+  PermissionsSignal,
+  // Behavioral signals
+  MouseMovementSignal,
+  KeyboardPatternSignal,
+  InteractionTimingSignal,
+  ScrollBehaviorSignal,
+  // Fingerprint signals
+  PluginsSignal,
+  WebGLSignal,
+  CanvasSignal,
+  AudioContextSignal,
+  ScreenSignal,
+  // Timing signals
+  PageLoadSignal,
+  DOMContentTimingSignal,
+  // Automation framework signals
+  PuppeteerSignal,
+  PlaywrightSignal,
+  SeleniumSignal,
+  PhantomJSSignal
+};
+var defaultInstantSignals = [
+  new WebDriverSignal(),
+  new HeadlessSignal(),
+  new NavigatorAnomalySignal(),
+  new PermissionsSignal(),
+  new PluginsSignal(),
+  new WebGLSignal(),
+  new CanvasSignal(),
+  new AudioContextSignal(),
+  new ScreenSignal(),
+  new PageLoadSignal(),
+  new DOMContentTimingSignal(),
+  new PuppeteerSignal(),
+  new PlaywrightSignal(),
+  new SeleniumSignal(),
+  new PhantomJSSignal()
+];
+var defaultInteractionSignals = [
+  new MouseMovementSignal(),
+  new KeyboardPatternSignal(),
+  new InteractionTimingSignal(),
+  new ScrollBehaviorSignal()
+];
+var defaultSignals = [...defaultInstantSignals, ...defaultInteractionSignals];
+function createDetector(options = {}) {
+  const {
+    includeInteractionSignals = true,
+    instantBotSignals = ["webdriver", "puppeteer", "playwright", "selenium", "phantomjs"],
+    ...detectorOptions
+  } = options;
+  const signals = includeInteractionSignals ? [...defaultInstantSignals, ...defaultInteractionSignals.map((s) => {
+    const SignalClass = s.constructor;
+    return new SignalClass(s.options);
+  })] : defaultInstantSignals.map((s) => {
+    const SignalClass = s.constructor;
+    return new SignalClass(s.options);
+  });
+  return new BotDetector({
+    signals,
+    instantBotSignals,
+    ...detectorOptions
+  });
+}
+async function detect(options = {}) {
+  const detector = createDetector({
+    includeInteractionSignals: !options.skipInteractionSignals
+  });
+  return detector.detect(options);
+}
+async function detectInstant() {
+  return detect({ skipInteractionSignals: true });
+}
+var index_default = {
+  BotDetector,
+  createDetector,
+  detect,
+  detectInstant,
+  Signal,
+  Signals,
+  Verdict
+};
+//# sourceMappingURL=bot-detector.cjs.js.map