devn-bot-detector-client 0.1.0

package/dist/index.js

@@ -0,0 +1,1007 @@
+import { DEFAULT_SESSION_DURATION_MS, SITE_KEY_HEADER, API_PATHS, TELEMETRY_VERSION, utf8ByteLength, MAX_TELEMETRY_BYTES, DEFAULT_TELEMETRY_INTERVAL_MS } from 'devn-bot-detector-core';
+
+// src/BotDetector.ts
+
+// src/utils.ts
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function nowMs() {
+  return Date.now();
+}
+function perfNow() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function secureId(prefix, bytes = 16) {
+  const arr = new Uint8Array(bytes);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(arr);
+  } else {
+    throw new Error("Secure random generation is unavailable");
+  }
+  let hex = "";
+  for (let i = 0; i < arr.length; i++) {
+    hex += arr[i].toString(16).padStart(2, "0");
+  }
+  return `${prefix}_${hex}`;
+}
+function debugLog(enabled, ...args) {
+  if (enabled && typeof console !== "undefined" && typeof console.debug === "function") {
+    console.debug("[bot-detector-client]", ...args);
+  }
+}
+var IntervalTracker = class {
+  constructor() {
+    this.lastAt = null;
+    this.sum = 0;
+    this.count = 0;
+    this.min = null;
+    this.max = null;
+    this.sumSq = 0;
+  }
+  mark(t) {
+    if (this.lastAt != null) {
+      const interval = t - this.lastAt;
+      if (interval >= 0) {
+        this.sum += interval;
+        this.sumSq += interval * interval;
+        this.count += 1;
+        this.min = this.min == null ? interval : Math.min(this.min, interval);
+        this.max = this.max == null ? interval : Math.max(this.max, interval);
+      }
+    }
+    this.lastAt = t;
+  }
+  average() {
+    return this.count === 0 ? null : this.sum / this.count;
+  }
+  minInterval() {
+    return this.min;
+  }
+  maxInterval() {
+    return this.max;
+  }
+  variance() {
+    if (this.count < 2) return null;
+    const mean = this.sum / this.count;
+    return this.sumSq / this.count - mean * mean;
+  }
+  reset() {
+    this.lastAt = null;
+    this.sum = 0;
+    this.count = 0;
+    this.min = null;
+    this.max = null;
+    this.sumSq = 0;
+  }
+};
+
+// src/collectors/browser.ts
+function getWebglInfo() {
+  try {
+    if (typeof document === "undefined") return { renderer: null, vendor: null };
+    if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.includes("jsdom")) {
+      return { renderer: null, vendor: null };
+    }
+    const canvas = document.createElement("canvas");
+    if (typeof canvas.getContext !== "function") return { renderer: null, vendor: null };
+    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (!gl) return { renderer: null, vendor: null };
+    const ext = gl.getExtension("WEBGL_debug_renderer_info");
+    if (!ext) return { renderer: null, vendor: null };
+    const renderer = gl.getParameter(ext.UNMASKED_RENDERER_WEBGL);
+    const vendor = gl.getParameter(ext.UNMASKED_VENDOR_WEBGL);
+    return {
+      renderer: typeof renderer === "string" ? renderer.slice(0, 128) : null,
+      vendor: typeof vendor === "string" ? vendor.slice(0, 128) : null
+    };
+  } catch {
+    return { renderer: null, vendor: null };
+  }
+}
+function collectBrowserSignals() {
+  if (!isBrowser()) {
+    return {
+      userAgent: "",
+      language: "",
+      languagesLength: 0,
+      timezone: "UTC",
+      timezoneOffset: 0,
+      platform: "",
+      screenWidth: 0,
+      screenHeight: 0,
+      colorDepth: 0,
+      devicePixelRatio: 1,
+      hardwareConcurrency: null,
+      maxTouchPoints: 0,
+      cookieEnabled: false,
+      webdriver: false
+    };
+  }
+  const nav = navigator;
+  let timezone = "UTC";
+  try {
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+  }
+  const webgl = getWebglInfo();
+  const hasChrome = Boolean(window.chrome);
+  const pluginsCount = typeof nav.plugins !== "undefined" ? nav.plugins.length : 0;
+  const screenOrientation = typeof screen !== "undefined" && screen.orientation && screen.orientation.type ? screen.orientation.type : null;
+  return {
+    userAgent: (nav.userAgent || "").slice(0, 512),
+    language: (nav.language || "").slice(0, 32),
+    languagesLength: Array.isArray(nav.languages) ? nav.languages.length : 0,
+    timezone: timezone.slice(0, 64),
+    timezoneOffset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+    platform: (nav.platform || "").slice(0, 64),
+    screenWidth: typeof screen !== "undefined" ? screen.width || 0 : 0,
+    screenHeight: typeof screen !== "undefined" ? screen.height || 0 : 0,
+    colorDepth: typeof screen !== "undefined" ? screen.colorDepth || 0 : 0,
+    devicePixelRatio: typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
+    hardwareConcurrency: typeof nav.hardwareConcurrency === "number" ? nav.hardwareConcurrency : null,
+    maxTouchPoints: nav.maxTouchPoints || 0,
+    cookieEnabled: Boolean(nav.cookieEnabled),
+    webdriver: Boolean(nav.webdriver),
+    webglRenderer: webgl.renderer,
+    webglVendor: webgl.vendor,
+    hasChrome,
+    pluginsCount,
+    screenOrientation
+  };
+}
+
+// src/collectors/pointer.ts
+var IDLE_GAP_MS = 1500;
+var PointerCollector = class {
+  constructor() {
+    this.listening = false;
+    this.eventCount = 0;
+    this.movementDistance = 0;
+    this.directionChanges = 0;
+    this.idlePeriods = 0;
+    this.clickCount = 0;
+    this.activeDuration = 0;
+    this.lastX = null;
+    this.lastY = null;
+    this.lastAngle = null;
+    this.lastEventAt = null;
+    this.activityStartedAt = null;
+    this.intervals = new IntervalTracker();
+    this.onMove = (e) => {
+      const t = perfNow();
+      const x = e.clientX;
+      const y = e.clientY;
+      this.eventCount += 1;
+      this.intervals.mark(t);
+      if (this.lastEventAt != null && t - this.lastEventAt > IDLE_GAP_MS) {
+        this.idlePeriods += 1;
+        if (this.activityStartedAt != null) {
+          this.activeDuration += this.lastEventAt - this.activityStartedAt;
+        }
+        this.activityStartedAt = t;
+      } else if (this.activityStartedAt == null) {
+        this.activityStartedAt = t;
+      }
+      if (this.lastX != null && this.lastY != null) {
+        const dx = x - this.lastX;
+        const dy = y - this.lastY;
+        const dist = Math.hypot(dx, dy);
+        this.movementDistance += dist;
+        if (dist > 2) {
+          const angle = Math.atan2(dy, dx);
+          if (this.lastAngle != null) {
+            let delta = Math.abs(angle - this.lastAngle);
+            if (delta > Math.PI) delta = 2 * Math.PI - delta;
+            if (delta > 0.6) this.directionChanges += 1;
+          }
+          this.lastAngle = angle;
+        }
+      }
+      this.lastX = x;
+      this.lastY = y;
+      this.lastEventAt = t;
+    };
+    this.onClick = () => {
+      this.clickCount += 1;
+      this.eventCount += 1;
+    };
+  }
+  start() {
+    if (this.listening || !isBrowser()) return;
+    this.listening = true;
+    window.addEventListener("pointermove", this.onMove, { passive: true });
+    window.addEventListener("click", this.onClick, { passive: true });
+  }
+  stop() {
+    if (!this.listening || !isBrowser()) return;
+    this.listening = false;
+    window.removeEventListener("pointermove", this.onMove);
+    window.removeEventListener("click", this.onClick);
+    this.flushActive();
+  }
+  snapshot() {
+    this.flushActive();
+    return {
+      eventCount: this.eventCount,
+      movementDistance: Math.round(this.movementDistance),
+      averageInterval: this.intervals.average(),
+      minInterval: this.intervals.minInterval(),
+      maxInterval: this.intervals.maxInterval(),
+      directionChanges: this.directionChanges,
+      idlePeriods: this.idlePeriods,
+      activeDuration: Math.round(this.activeDuration),
+      clickCount: this.clickCount
+    };
+  }
+  reset() {
+    this.eventCount = 0;
+    this.movementDistance = 0;
+    this.directionChanges = 0;
+    this.idlePeriods = 0;
+    this.clickCount = 0;
+    this.activeDuration = 0;
+    this.lastX = null;
+    this.lastY = null;
+    this.lastAngle = null;
+    this.lastEventAt = null;
+    this.activityStartedAt = null;
+    this.intervals.reset();
+  }
+  flushActive() {
+    if (this.activityStartedAt != null && this.lastEventAt != null) {
+      this.activeDuration += this.lastEventAt - this.activityStartedAt;
+      this.activityStartedAt = this.lastEventAt;
+    }
+  }
+};
+
+// src/collectors/keyboard.ts
+var KeyboardCollector = class {
+  constructor() {
+    this.listening = false;
+    this.keydownCount = 0;
+    this.keyupCount = 0;
+    this.pasteCount = 0;
+    this.intervals = new IntervalTracker();
+    this.onKeyDown = () => {
+      this.keydownCount += 1;
+      this.intervals.mark(perfNow());
+    };
+    this.onKeyUp = () => {
+      this.keyupCount += 1;
+    };
+    this.onPaste = () => {
+      this.pasteCount += 1;
+    };
+  }
+  start() {
+    if (this.listening || !isBrowser()) return;
+    this.listening = true;
+    window.addEventListener("keydown", this.onKeyDown, { passive: true });
+    window.addEventListener("keyup", this.onKeyUp, { passive: true });
+    window.addEventListener("paste", this.onPaste, { passive: true });
+  }
+  stop() {
+    if (!this.listening || !isBrowser()) return;
+    this.listening = false;
+    window.removeEventListener("keydown", this.onKeyDown);
+    window.removeEventListener("keyup", this.onKeyUp);
+    window.removeEventListener("paste", this.onPaste);
+  }
+  snapshot() {
+    return {
+      keydownCount: this.keydownCount,
+      keyupCount: this.keyupCount,
+      averageInterval: this.intervals.average(),
+      minInterval: this.intervals.minInterval(),
+      maxInterval: this.intervals.maxInterval(),
+      timingVariance: this.intervals.variance(),
+      pasteCount: this.pasteCount
+    };
+  }
+  reset() {
+    this.keydownCount = 0;
+    this.keyupCount = 0;
+    this.pasteCount = 0;
+    this.intervals.reset();
+  }
+};
+
+// src/collectors/touch.ts
+var TouchCollector = class {
+  constructor() {
+    this.listening = false;
+    this.touchCount = 0;
+    this.multiTouchCount = 0;
+    this.activeDuration = 0;
+    this.touchStartedAt = null;
+    this.intervals = new IntervalTracker();
+    this.onStart = (e) => {
+      const t = perfNow();
+      this.touchCount += 1;
+      this.intervals.mark(t);
+      this.touchStartedAt = t;
+      const touches = e.touches?.length ?? 0;
+      if (touches > 1) this.multiTouchCount += 1;
+    };
+    this.onEnd = () => {
+      if (this.touchStartedAt != null) {
+        this.activeDuration += perfNow() - this.touchStartedAt;
+        this.touchStartedAt = null;
+      }
+    };
+  }
+  start() {
+    if (this.listening || !isBrowser()) return;
+    this.listening = true;
+    window.addEventListener("touchstart", this.onStart, { passive: true });
+    window.addEventListener("touchend", this.onEnd, { passive: true });
+    window.addEventListener("touchcancel", this.onEnd, { passive: true });
+  }
+  stop() {
+    if (!this.listening || !isBrowser()) return;
+    this.listening = false;
+    window.removeEventListener("touchstart", this.onStart);
+    window.removeEventListener("touchend", this.onEnd);
+    window.removeEventListener("touchcancel", this.onEnd);
+  }
+  snapshot() {
+    return {
+      touchCount: this.touchCount,
+      averageInterval: this.intervals.average(),
+      activeDuration: Math.round(this.activeDuration),
+      multiTouchCount: this.multiTouchCount
+    };
+  }
+  reset() {
+    this.touchCount = 0;
+    this.multiTouchCount = 0;
+    this.activeDuration = 0;
+    this.touchStartedAt = null;
+    this.intervals.reset();
+  }
+};
+
+// src/collectors/scroll.ts
+var ScrollCollector = class {
+  constructor() {
+    this.listening = false;
+    this.scrollCount = 0;
+    this.totalDistance = 0;
+    this.directionChanges = 0;
+    this.activeDuration = 0;
+    this.lastY = null;
+    this.lastDir = null;
+    this.lastAt = null;
+    this.activityStartedAt = null;
+    this.intervals = new IntervalTracker();
+    this.scheduled = false;
+    this.onScroll = () => {
+      if (this.scheduled) return;
+      this.scheduled = true;
+      const run = () => {
+        this.scheduled = false;
+        this.handleScroll();
+      };
+      if (typeof requestAnimationFrame === "function") {
+        requestAnimationFrame(run);
+      } else {
+        setTimeout(run, 16);
+      }
+    };
+  }
+  handleScroll() {
+    const t = perfNow();
+    const y = typeof window !== "undefined" ? window.scrollY || 0 : 0;
+    this.scrollCount += 1;
+    this.intervals.mark(t);
+    if (this.lastY != null) {
+      const dy = y - this.lastY;
+      this.totalDistance += Math.abs(dy);
+      const dir = dy === 0 ? 0 : dy > 0 ? 1 : -1;
+      if (dir !== 0 && this.lastDir != null && dir !== this.lastDir) {
+        this.directionChanges += 1;
+      }
+      if (dir !== 0) this.lastDir = dir;
+    }
+    if (this.activityStartedAt == null) this.activityStartedAt = t;
+    if (this.lastAt != null && t - this.lastAt > 800) {
+      this.activeDuration += this.lastAt - this.activityStartedAt;
+      this.activityStartedAt = t;
+    }
+    this.lastY = y;
+    this.lastAt = t;
+  }
+  start() {
+    if (this.listening || !isBrowser()) return;
+    this.listening = true;
+    window.addEventListener("scroll", this.onScroll, { passive: true });
+  }
+  stop() {
+    if (!this.listening || !isBrowser()) return;
+    this.listening = false;
+    window.removeEventListener("scroll", this.onScroll);
+    if (this.activityStartedAt != null && this.lastAt != null) {
+      this.activeDuration += this.lastAt - this.activityStartedAt;
+      this.activityStartedAt = this.lastAt;
+    }
+  }
+  snapshot() {
+    return {
+      scrollCount: this.scrollCount,
+      averageInterval: this.intervals.average(),
+      totalDistance: Math.round(this.totalDistance),
+      directionChanges: this.directionChanges,
+      activeDuration: Math.round(this.activeDuration)
+    };
+  }
+  reset() {
+    this.scrollCount = 0;
+    this.totalDistance = 0;
+    this.directionChanges = 0;
+    this.activeDuration = 0;
+    this.lastY = null;
+    this.lastDir = null;
+    this.lastAt = null;
+    this.activityStartedAt = null;
+    this.intervals.reset();
+  }
+};
+
+// src/collectors/focus.ts
+var FocusCollector = class {
+  constructor() {
+    this.listening = false;
+    this.focusCount = 0;
+    this.blurCount = 0;
+    this.onFocus = () => {
+      this.focusCount += 1;
+    };
+    this.onBlur = () => {
+      this.blurCount += 1;
+    };
+  }
+  start() {
+    if (this.listening || !isBrowser()) return;
+    this.listening = true;
+    window.addEventListener("focus", this.onFocus);
+    window.addEventListener("blur", this.onBlur);
+  }
+  stop() {
+    if (!this.listening || !isBrowser()) return;
+    this.listening = false;
+    window.removeEventListener("focus", this.onFocus);
+    window.removeEventListener("blur", this.onBlur);
+  }
+  snapshot() {
+    return {
+      focusCount: this.focusCount,
+      blurCount: this.blurCount
+    };
+  }
+  reset() {
+    this.focusCount = 0;
+    this.blurCount = 0;
+  }
+};
+
+// src/collectors/visibility.ts
+var VisibilityCollector = class {
+  constructor() {
+    this.listening = false;
+    this.visibilityChanges = 0;
+    this.visibleDuration = 0;
+    this.hiddenDuration = 0;
+    this.segmentStartedAt = nowMs();
+    this.currentlyHidden = false;
+    this.onChange = () => {
+      const t = nowMs();
+      const elapsed = t - this.segmentStartedAt;
+      if (this.currentlyHidden) this.hiddenDuration += elapsed;
+      else this.visibleDuration += elapsed;
+      this.currentlyHidden = document.visibilityState === "hidden";
+      this.segmentStartedAt = t;
+      this.visibilityChanges += 1;
+    };
+  }
+  start() {
+    if (this.listening || !isBrowser()) return;
+    this.listening = true;
+    this.currentlyHidden = document.visibilityState === "hidden";
+    this.segmentStartedAt = nowMs();
+    document.addEventListener("visibilitychange", this.onChange);
+  }
+  stop() {
+    if (!this.listening || !isBrowser()) return;
+    this.listening = false;
+    document.removeEventListener("visibilitychange", this.onChange);
+    this.flush();
+  }
+  snapshot() {
+    this.flush();
+    return {
+      visibilityChanges: this.visibilityChanges,
+      visibleDuration: Math.round(this.visibleDuration),
+      hiddenDuration: Math.round(this.hiddenDuration)
+    };
+  }
+  reset() {
+    this.visibilityChanges = 0;
+    this.visibleDuration = 0;
+    this.hiddenDuration = 0;
+    this.segmentStartedAt = nowMs();
+    this.currentlyHidden = isBrowser() ? document.visibilityState === "hidden" : false;
+  }
+  flush() {
+    const t = nowMs();
+    const elapsed = t - this.segmentStartedAt;
+    if (this.currentlyHidden) this.hiddenDuration += elapsed;
+    else this.visibleDuration += elapsed;
+    this.segmentStartedAt = t;
+  }
+};
+
+// src/collectors/interaction.ts
+var InteractionCollector = class {
+  constructor() {
+    this.listening = false;
+    this.pageLoadTime = nowMs();
+    this.firstInteractionTime = null;
+    this.clickCount = 0;
+    this.interactionCount = 0;
+    this.formInteractionCount = 0;
+    this.scrollCount = 0;
+    this.focusCount = 0;
+    this.markInteraction = () => {
+      if (this.firstInteractionTime == null) {
+        this.firstInteractionTime = nowMs();
+      }
+      this.interactionCount += 1;
+    };
+    this.onClick = () => {
+      this.clickCount += 1;
+      this.markInteraction();
+    };
+    this.onKey = () => {
+      this.markInteraction();
+    };
+    this.onTouch = () => {
+      this.markInteraction();
+    };
+    this.onScroll = () => {
+      this.scrollCount += 1;
+      this.markInteraction();
+    };
+    this.onFocusIn = (e) => {
+      this.focusCount += 1;
+      const target = e.target;
+      if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) {
+        this.formInteractionCount += 1;
+      }
+    };
+  }
+  start() {
+    if (this.listening || !isBrowser()) return;
+    this.listening = true;
+    this.pageLoadTime = nowMs();
+    window.addEventListener("click", this.onClick, { passive: true });
+    window.addEventListener("keydown", this.onKey, { passive: true });
+    window.addEventListener("touchstart", this.onTouch, { passive: true });
+    window.addEventListener("scroll", this.onScroll, { passive: true });
+    document.addEventListener("focusin", this.onFocusIn, { passive: true });
+  }
+  stop() {
+    if (!this.listening || !isBrowser()) return;
+    this.listening = false;
+    window.removeEventListener("click", this.onClick);
+    window.removeEventListener("keydown", this.onKey);
+    window.removeEventListener("touchstart", this.onTouch);
+    window.removeEventListener("scroll", this.onScroll);
+    document.removeEventListener("focusin", this.onFocusIn);
+  }
+  snapshot() {
+    return {
+      pageLoadTime: this.pageLoadTime,
+      firstInteractionTime: this.firstInteractionTime,
+      timeToFirstInteraction: this.firstInteractionTime != null ? this.firstInteractionTime - this.pageLoadTime : null,
+      clickCount: this.clickCount,
+      interactionCount: this.interactionCount,
+      formInteractionCount: this.formInteractionCount,
+      scrollCount: this.scrollCount,
+      focusCount: this.focusCount
+    };
+  }
+  reset() {
+    this.pageLoadTime = nowMs();
+    this.firstInteractionTime = null;
+    this.clickCount = 0;
+    this.interactionCount = 0;
+    this.formInteractionCount = 0;
+    this.scrollCount = 0;
+    this.focusCount = 0;
+  }
+};
+function createLocalSession(sessionDurationMs = DEFAULT_SESSION_DURATION_MS) {
+  const createdAt = nowMs();
+  return {
+    sessionId: secureId("ses"),
+    nonce: secureId("nonce", 12),
+    createdAt,
+    expiresAt: createdAt + sessionDurationMs
+  };
+}
+function isSessionExpired(session, now = nowMs()) {
+  return now >= session.expiresAt;
+}
+function rotateNonce(session) {
+  return {
+    ...session,
+    nonce: secureId("nonce", 12)
+  };
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var HttpTransport = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.siteKey = options.siteKey;
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.headersProvider = options.headers;
+    this.fetchFn = options.fetchFn ?? ((...args) => fetch(...args));
+    this.credentials = options.credentials ?? "omit";
+    this.retries = Math.max(0, options.retries ?? 0);
+    this.retryDelayMs = options.retryDelayMs ?? 300;
+  }
+  async post(path, body) {
+    return this.executeWithRetry("POST", path, body);
+  }
+  async get(path) {
+    return this.executeWithRetry("GET", path);
+  }
+  async resolveHeaders() {
+    if (!this.headersProvider) return {};
+    if (typeof this.headersProvider === "function") {
+      return await this.headersProvider() ?? {};
+    }
+    return this.headersProvider;
+  }
+  async executeWithRetry(method, path, body) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        return await this.request(method, path, body);
+      } catch (err) {
+        lastError = err;
+        if (attempt < this.retries) {
+          const delay = this.retryDelayMs * Math.pow(2, attempt);
+          await wait(delay);
+        }
+      }
+    }
+    throw lastError;
+  }
+  async request(method, path, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const customHeaders = await this.resolveHeaders();
+      const res = await this.fetchFn(`${this.baseUrl}${path}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          [SITE_KEY_HEADER]: this.siteKey,
+          ...customHeaders
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal,
+        credentials: this.credentials
+      });
+      const text = await res.text();
+      let data = null;
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          throw new Error(`Invalid JSON response (${res.status})`);
+        }
+      }
+      if (!res.ok) {
+        const message = typeof data === "object" && data !== null && "error" in data && typeof data.error?.message === "string" ? data.error.message : `HTTP ${res.status}`;
+        throw new Error(message);
+      }
+      return data;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/BotDetector.ts
+function resolveConfig(config) {
+  if (!config.siteKey) throw new Error("BotDetector requires siteKey");
+  if (!config.endpoint) throw new Error("BotDetector requires endpoint");
+  return {
+    siteKey: config.siteKey,
+    endpoint: config.endpoint.replace(/\/$/, ""),
+    autoStart: config.autoStart ?? true,
+    telemetryInterval: config.telemetryInterval ?? DEFAULT_TELEMETRY_INTERVAL_MS,
+    sessionDuration: config.sessionDuration ?? DEFAULT_SESSION_DURATION_MS,
+    collectPointer: config.collectPointer ?? true,
+    collectKeyboardTiming: config.collectKeyboardTiming ?? true,
+    collectTouch: config.collectTouch ?? true,
+    collectScroll: config.collectScroll ?? true,
+    collectFocus: config.collectFocus ?? true,
+    collectVisibility: config.collectVisibility ?? true,
+    collectBrowser: config.collectBrowser ?? true,
+    failOpen: config.failOpen ?? true,
+    maxTelemetryBytes: config.maxTelemetryBytes ?? MAX_TELEMETRY_BYTES,
+    debug: config.debug ?? false,
+    sampleRate: Math.max(0, Math.min(1, config.sampleRate ?? 1)),
+    headers: config.headers,
+    fetchFn: config.fetchFn,
+    credentials: config.credentials,
+    timeoutMs: config.timeoutMs,
+    retries: config.retries,
+    retryDelayMs: config.retryDelayMs,
+    onSessionCreated: config.onSessionCreated,
+    onCheck: config.onCheck,
+    onError: config.onError
+  };
+}
+var BotDetector = class {
+  constructor(config) {
+    this.pointer = new PointerCollector();
+    this.keyboard = new KeyboardCollector();
+    this.touch = new TouchCollector();
+    this.scroll = new ScrollCollector();
+    this.focus = new FocusCollector();
+    this.visibility = new VisibilityCollector();
+    this.interaction = new InteractionCollector();
+    this.session = null;
+    this.sequence = 0;
+    this.running = false;
+    this.paused = false;
+    this.destroyed = false;
+    this.flushTimer = null;
+    this.startPromise = null;
+    this.config = resolveConfig(config);
+    this.transport = new HttpTransport({
+      baseUrl: this.config.endpoint,
+      siteKey: this.config.siteKey,
+      headers: this.config.headers,
+      fetchFn: this.config.fetchFn,
+      credentials: this.config.credentials,
+      timeoutMs: this.config.timeoutMs,
+      retries: this.config.retries,
+      retryDelayMs: this.config.retryDelayMs
+    });
+    if (this.config.autoStart && isBrowser()) {
+      void this.start();
+    }
+  }
+  async start() {
+    if (this.destroyed) throw new Error("BotDetector has been destroyed");
+    if (this.running) return;
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = this.doStart();
+    try {
+      await this.startPromise;
+    } finally {
+      this.startPromise = null;
+    }
+  }
+  async doStart() {
+    if (!isBrowser()) {
+      debugLog(this.config.debug, "start() outside browser \u2014 collectors skipped");
+      return;
+    }
+    this.attachCollectors();
+    this.running = true;
+    await this.ensureSession();
+    this.scheduleFlush();
+    debugLog(this.config.debug, "started", { sessionId: this.session?.sessionId });
+  }
+  /** Temporarily pause active collectors (e.g. background tab or navigation). */
+  pause() {
+    if (!this.running || this.paused || this.destroyed) return;
+    this.detachCollectors();
+    this.paused = true;
+    debugLog(this.config.debug, "paused");
+  }
+  /** Resume collecting signals after pausing. */
+  resume() {
+    if (!this.running || !this.paused || this.destroyed) return;
+    this.attachCollectors();
+    this.paused = false;
+    debugLog(this.config.debug, "resumed");
+  }
+  isPaused() {
+    return this.paused;
+  }
+  isRunning() {
+    return this.running && !this.destroyed;
+  }
+  /**
+   * Collect telemetry and analyze risk via the configured endpoint.
+   * On network failure with failOpen=true, returns a monitor decision.
+   */
+  async check(options) {
+    if (this.destroyed) throw new Error("BotDetector has been destroyed");
+    if (!this.running) await this.start();
+    if (this.config.sampleRate < 1 && Math.random() > this.config.sampleRate) {
+      debugLog(this.config.debug, "skipped check due to sampleRate");
+      const sampled = this.fallbackResult("allow", 95);
+      this.config.onCheck?.(sampled);
+      return sampled;
+    }
+    try {
+      await this.ensureSession();
+      const session = this.session;
+      if (!session) throw new Error("No session");
+      this.sequence += 1;
+      const telemetry = this.getTelemetry();
+      const body = {
+        sessionId: session.sessionId,
+        sequence: this.sequence,
+        nonce: session.nonce,
+        timestamp: nowMs(),
+        hostname: isBrowser() ? location.hostname : "",
+        telemetry
+      };
+      if (options?.action) body.action = options.action;
+      if (options?.metadata) body.metadata = options.metadata;
+      debugLog(this.config.debug, "analyze request", {
+        sessionId: session.sessionId,
+        sequence: this.sequence,
+        action: options?.action
+      });
+      const result = await this.transport.post(API_PATHS.analyze, body);
+      this.session = rotateNonce(session);
+      this.config.onCheck?.(result);
+      return result;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.config.onError?.(errorObj);
+      debugLog(this.config.debug, "check failed", errorObj.message);
+      if (this.config.failOpen) {
+        const fallback = this.fallbackResult("monitor");
+        this.config.onCheck?.(fallback);
+        return fallback;
+      }
+      throw err;
+    }
+  }
+  /** Shorthand for check({ action, metadata }). */
+  async checkAction(action, metadata) {
+    return this.check({ action, metadata });
+  }
+  getSession() {
+    return this.session;
+  }
+  getTelemetry() {
+    const telemetry = {
+      version: TELEMETRY_VERSION,
+      ...this.config.collectBrowser ? { browser: collectBrowserSignals() } : {},
+      ...this.config.collectPointer ? { pointer: this.pointer.snapshot() } : {},
+      ...this.config.collectKeyboardTiming ? { keyboard: this.keyboard.snapshot() } : {},
+      ...this.config.collectTouch ? { touch: this.touch.snapshot() } : {},
+      ...this.config.collectScroll ? { scroll: this.scroll.snapshot() } : {},
+      ...this.config.collectFocus ? { focus: this.focus.snapshot() } : {},
+      ...this.config.collectVisibility ? { visibility: this.visibility.snapshot() } : {},
+      interaction: this.interaction.snapshot()
+    };
+    return this.enforceSize(telemetry);
+  }
+  reset() {
+    this.pointer.reset();
+    this.keyboard.reset();
+    this.touch.reset();
+    this.scroll.reset();
+    this.focus.reset();
+    this.visibility.reset();
+    this.interaction.reset();
+    this.sequence = 0;
+  }
+  /** Remove listeners, timers, and clear state. */
+  destroy() {
+    this.destroyed = true;
+    this.running = false;
+    this.clearFlush();
+    this.detachCollectors();
+    this.session = null;
+    this.reset();
+    debugLog(this.config.debug, "destroyed");
+  }
+  attachCollectors() {
+    if (this.config.collectPointer) this.pointer.start();
+    if (this.config.collectKeyboardTiming) this.keyboard.start();
+    if (this.config.collectTouch) this.touch.start();
+    if (this.config.collectScroll) this.scroll.start();
+    if (this.config.collectFocus) this.focus.start();
+    if (this.config.collectVisibility) this.visibility.start();
+    this.interaction.start();
+  }
+  detachCollectors() {
+    this.pointer.stop();
+    this.keyboard.stop();
+    this.touch.stop();
+    this.scroll.stop();
+    this.focus.stop();
+    this.visibility.stop();
+    this.interaction.stop();
+  }
+  async ensureSession() {
+    if (this.session && !isSessionExpired(this.session)) return;
+    try {
+      const response = await this.transport.post(API_PATHS.session, {
+        hostname: isBrowser() ? location.hostname : "",
+        userAgent: isBrowser() ? navigator.userAgent.slice(0, 512) : "",
+        timestamp: nowMs()
+      });
+      this.session = {
+        sessionId: response.sessionId,
+        nonce: response.nonce,
+        createdAt: nowMs(),
+        expiresAt: Date.parse(response.expiresAt) || nowMs() + this.config.sessionDuration
+      };
+      this.sequence = 0;
+      debugLog(this.config.debug, "session created", { sessionId: this.session.sessionId });
+      this.config.onSessionCreated?.(this.session);
+    } catch (err) {
+      debugLog(this.config.debug, "session API failed, using local session");
+      this.session = createLocalSession(this.config.sessionDuration);
+      this.sequence = 0;
+      this.config.onSessionCreated?.(this.session);
+      if (!this.config.failOpen) throw err;
+    }
+  }
+  scheduleFlush() {
+    this.clearFlush();
+    if (this.config.telemetryInterval <= 0) return;
+    this.flushTimer = setInterval(() => {
+      void this.getTelemetry();
+    }, this.config.telemetryInterval);
+  }
+  clearFlush() {
+    if (this.flushTimer != null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  enforceSize(telemetry) {
+    const fits = (value) => utf8ByteLength(JSON.stringify(value)) <= this.config.maxTelemetryBytes;
+    if (fits(telemetry)) return telemetry;
+    const candidates = [
+      {
+        version: TELEMETRY_VERSION,
+        interaction: telemetry.interaction,
+        browser: telemetry.browser
+      },
+      {
+        version: TELEMETRY_VERSION,
+        interaction: telemetry.interaction
+      },
+      { version: TELEMETRY_VERSION }
+    ];
+    for (const candidate of candidates) {
+      if (fits(candidate)) return candidate;
+    }
+    return { version: TELEMETRY_VERSION };
+  }
+  fallbackResult(decision, score) {
+    return {
+      requestId: `req_fallback_${nowMs()}`,
+      score: score ?? (decision === "monitor" ? 55 : decision === "allow" ? 90 : 50),
+      confidence: 0.3,
+      decision,
+      riskLevel: decision === "allow" ? "low" : "medium",
+      timestamp: nowMs()
+    };
+  }
+};
+
+export { BotDetector, FocusCollector, HttpTransport, InteractionCollector, KeyboardCollector, PointerCollector, ScrollCollector, TouchCollector, VisibilityCollector, collectBrowserSignals, createLocalSession, isSessionExpired };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map