@keverdjs/fraud-sdk-react 1.0.0 → 1.1.2

package/dist/index.js

@@ -274,247 +274,363 @@ var KeverdDeviceCollector = class {
   }
 };
 
-// src/collectors/keverd-behavioral-collector.ts
-var KeverdBehavioralCollector = class {
-  constructor() {
-    this.keystrokes = [];
-    this.mouseMovements = [];
-    this.lastKeyDownTime = /* @__PURE__ */ new Map();
+// src/collectors/kinematic-engine.ts
+var VELOCITY_SPIKE_THRESHOLD = 2.5;
+var WINDOW_LIMIT = 200;
+var KinematicEngine = class {
+  constructor(options = {}) {
+    this.featureVectors = [];
+    this.pointerQueue = [];
+    this.lastVelocity = 0;
+    this.lastAcceleration = 0;
+    this.lastAngle = 0;
+    this.lastPoint = null;
+    this.secondLastPoint = null;
+    this.rafId = null;
+    this.maxSwipeVelocity = 0;
+    this.isActive = false;
+    this.mouseMoveHandler = (event) => this.enqueuePoint(event, "move");
+    this.mouseDownHandler = (event) => this.enqueuePoint(event, "down");
+    this.mouseUpHandler = (event) => this.enqueuePoint(event, "up");
+    this.onEvent = options.onEvent;
+    this.maskValue = options.maskValue ?? -1;
+  }
+  start() {
+    if (this.isActive || typeof document === "undefined") return;
+    document.addEventListener("mousemove", this.mouseMoveHandler, { passive: true });
+    document.addEventListener("mousedown", this.mouseDownHandler, { passive: true });
+    document.addEventListener("mouseup", this.mouseUpHandler, { passive: true });
+    this.isActive = true;
+  }
+  stop() {
+    if (!this.isActive || typeof document === "undefined") return;
+    document.removeEventListener("mousemove", this.mouseMoveHandler);
+    document.removeEventListener("mousedown", this.mouseDownHandler);
+    document.removeEventListener("mouseup", this.mouseUpHandler);
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+    this.isActive = false;
+  }
+  getVectors() {
+    return this.featureVectors;
+  }
+  getSuspiciousSwipeVelocity() {
+    return this.maxSwipeVelocity;
+  }
+  reset() {
+    this.featureVectors = [];
+    this.pointerQueue = [];
+    this.lastVelocity = 0;
+    this.lastAcceleration = 0;
+    this.lastAngle = 0;
+    this.lastPoint = null;
+    this.secondLastPoint = null;
+    this.maxSwipeVelocity = 0;
+  }
+  enqueuePoint(event, type) {
+    const point = {
+      x: event.clientX,
+      y: event.clientY,
+      timestamp: performance.now(),
+      type
+    };
+    this.pointerQueue.push(point);
+    if (this.pointerQueue.length > WINDOW_LIMIT) {
+      this.pointerQueue.shift();
+    }
+    if (this.onEvent) {
+      this.onEvent(type === "move" ? "mousemove" : type === "down" ? "mousedown" : "mouseup");
+    }
+    this.scheduleProcess();
+  }
+  scheduleProcess() {
+    if (this.rafId !== null) return;
+    this.rafId = requestAnimationFrame(() => {
+      this.rafId = null;
+      this.processQueue();
+      if (this.pointerQueue.length > 0) {
+        this.scheduleProcess();
+      }
+    });
+  }
+  processQueue() {
+    while (this.pointerQueue.length > 0) {
+      const point = this.pointerQueue.shift();
+      this.computeFeatures(point);
+      this.secondLastPoint = this.lastPoint;
+      this.lastPoint = point;
+    }
+  }
+  computeFeatures(point) {
+    if (!this.lastPoint) {
+      this.lastPoint = point;
+      this.lastAngle = 0;
+      return;
+    }
+    const dt = point.timestamp - this.lastPoint.timestamp;
+    if (dt <= 0) {
+      return;
+    }
+    const dx = point.x - this.lastPoint.x;
+    const dy = point.y - this.lastPoint.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const velocity = distance / dt;
+    const acceleration = (velocity - this.lastVelocity) / dt;
+    const jerk = (acceleration - this.lastAcceleration) / dt;
+    const angle = Math.atan2(dy, dx);
+    const angularVelocity = this.normalizeAngle(angle - this.lastAngle) / dt;
+    const curvature = this.calculateCurvature(point);
+    this.featureVectors.push({
+      timestamp: point.timestamp,
+      velocity,
+      acceleration,
+      jerk,
+      curvature,
+      angularVelocity
+    });
+    this.maxSwipeVelocity = Math.max(this.maxSwipeVelocity, velocity);
+    if (velocity > VELOCITY_SPIKE_THRESHOLD) {
+      this.featureVectors.push({
+        timestamp: point.timestamp,
+        velocity,
+        acceleration,
+        jerk,
+        curvature,
+        angularVelocity: angularVelocity * 1.2
+      });
+    }
+    if (this.featureVectors.length > WINDOW_LIMIT) {
+      this.featureVectors.splice(0, this.featureVectors.length - WINDOW_LIMIT);
+    }
+    this.lastVelocity = velocity;
+    this.lastAcceleration = acceleration;
+    this.lastAngle = angle;
+  }
+  calculateCurvature(point) {
+    if (!this.lastPoint || !this.secondLastPoint) return 0;
+    const p0 = this.secondLastPoint;
+    const p1 = this.lastPoint;
+    const p2 = point;
+    const chordLength = Math.hypot(p2.x - p0.x, p2.y - p0.y);
+    const pathLength = Math.hypot(p1.x - p0.x, p1.y - p0.y) + Math.hypot(p2.x - p1.x, p2.y - p1.y);
+    if (chordLength === 0) return 0;
+    return (pathLength - chordLength) / chordLength;
+  }
+  normalizeAngle(angleDiff) {
+    while (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
+    while (angleDiff < -Math.PI) angleDiff += 2 * Math.PI;
+    return angleDiff;
+  }
+};
+
+// src/collectors/keystroke-monitor.ts
+var MAX_BUFFER = 200;
+var KeystrokeMonitor = class {
+  constructor(options = {}) {
+    this.keyDownTimes = /* @__PURE__ */ new Map();
     this.lastKeyUpTime = null;
+    this.lastKeyDownTime = null;
+    this.featureVectors = [];
+    this.dwellTimes = [];
+    this.flightTimes = [];
+    this.digraphLatencies = [];
     this.isActive = false;
-    this.sessionStartTime = Date.now();
-    this.typingDwellTimes = [];
-    this.typingFlightTimes = [];
-    this.swipeVelocities = [];
-    this.sessionEvents = [];
-    this.touchStartPositions = /* @__PURE__ */ new Map();
     this.keyDownHandler = (event) => this.handleKeyDown(event);
     this.keyUpHandler = (event) => this.handleKeyUp(event);
-    this.mouseMoveHandler = (event) => this.handleMouseMove(event);
-    this.touchStartHandler = (event) => this.handleTouchStart(event);
-    this.touchEndHandler = (event) => this.handleTouchEnd(event);
+    this.onEvent = options.onEvent;
   }
-  /**
-   * Start collecting behavioral data
-   */
   start() {
-    if (this.isActive) return;
-    if (typeof document !== "undefined") {
-      document.addEventListener("keydown", this.keyDownHandler, { passive: true });
-      document.addEventListener("keyup", this.keyUpHandler, { passive: true });
-      document.addEventListener("mousemove", this.mouseMoveHandler, { passive: true });
-      document.addEventListener("touchstart", this.touchStartHandler, { passive: true });
-      document.addEventListener("touchend", this.touchEndHandler, { passive: true });
-    }
+    if (this.isActive || typeof document === "undefined") return;
+    document.addEventListener("keydown", this.keyDownHandler, { passive: true, capture: true });
+    document.addEventListener("keyup", this.keyUpHandler, { passive: true, capture: true });
     this.isActive = true;
-    this.sessionStartTime = Date.now();
   }
-  /**
-   * Stop collecting behavioral data
-   */
   stop() {
-    if (!this.isActive) return;
-    if (typeof document !== "undefined") {
-      document.removeEventListener("keydown", this.keyDownHandler);
-      document.removeEventListener("keyup", this.keyUpHandler);
-      document.removeEventListener("mousemove", this.mouseMoveHandler);
-      document.removeEventListener("touchstart", this.touchStartHandler);
-      document.removeEventListener("touchend", this.touchEndHandler);
-    }
+    if (!this.isActive || typeof document === "undefined") return;
+    document.removeEventListener("keydown", this.keyDownHandler, true);
+    document.removeEventListener("keyup", this.keyUpHandler, true);
     this.isActive = false;
   }
-  /**
-   * Get collected behavioral data
-   */
-  getData() {
-    const dwellTimes = this.typingDwellTimes.slice(-20);
-    const flightTimes = this.typingFlightTimes.slice(-20);
-    const avgSwipeVelocity = this.swipeVelocities.length > 0 ? this.swipeVelocities.reduce((a, b) => a + b, 0) / this.swipeVelocities.length : 0;
-    const sessionEntropy = this.calculateSessionEntropy();
-    return {
-      typing_dwell_ms: dwellTimes.length > 0 ? dwellTimes : [],
-      typing_flight_ms: flightTimes.length > 0 ? flightTimes : [],
-      swipe_velocity: avgSwipeVelocity > 0 ? avgSwipeVelocity : 0,
-      session_entropy: sessionEntropy >= 0 ? sessionEntropy : 0
-    };
+  getVectors() {
+    return this.featureVectors;
+  }
+  getDwellTimes(limit = 50) {
+    return this.dwellTimes.slice(-limit);
+  }
+  getFlightTimes(limit = 50) {
+    return this.flightTimes.slice(-limit);
   }
-  /**
-   * Reset collected data
-   */
   reset() {
-    this.keystrokes = [];
-    this.mouseMovements = [];
-    this.lastKeyDownTime.clear();
+    this.keyDownTimes.clear();
     this.lastKeyUpTime = null;
-    this.typingDwellTimes = [];
-    this.typingFlightTimes = [];
-    this.swipeVelocities = [];
-    this.sessionEvents = [];
-    this.touchStartPositions.clear();
-    this.sessionStartTime = Date.now();
+    this.lastKeyDownTime = null;
+    this.featureVectors = [];
+    this.dwellTimes = [];
+    this.flightTimes = [];
+    this.digraphLatencies = [];
   }
-  /**
-   * Handle keydown event
-   */
   handleKeyDown(event) {
-    if (this.shouldIgnoreKey(event)) return;
+    if (!this.isTargetField(event)) return;
     const now = performance.now();
-    this.lastKeyDownTime.set(event.key, now);
-    const keystroke = {
-      key: event.key,
-      timestamp: now,
-      type: "keydown"
-    };
-    this.keystrokes.push(keystroke);
-    this.sessionEvents.push({ type: "keydown", timestamp: now });
+    if (this.lastKeyUpTime !== null) {
+      const flight = now - this.lastKeyUpTime;
+      this.flightTimes.push(flight);
+      this.appendVector({ dwellTime: -1, flightTime: flight, digraphLatency: -1, timestamp: now });
+    }
+    if (this.lastKeyDownTime !== null) {
+      const digraphLatency = now - this.lastKeyDownTime;
+      this.digraphLatencies.push(digraphLatency);
+      this.appendVector({ dwellTime: -1, flightTime: -1, digraphLatency, timestamp: now });
+    }
+    this.lastKeyDownTime = now;
+    this.keyDownTimes.set(event.code, now);
+    if (this.onEvent) this.onEvent("keydown");
   }
-  /**
-   * Handle keyup event
-   */
   handleKeyUp(event) {
-    if (this.shouldIgnoreKey(event)) return;
+    if (!this.isTargetField(event)) return;
     const now = performance.now();
-    const keyDownTime = this.lastKeyDownTime.get(event.key);
-    if (keyDownTime !== void 0) {
-      const dwellTime = now - keyDownTime;
-      this.typingDwellTimes.push(dwellTime);
-      this.lastKeyDownTime.delete(event.key);
-    }
-    if (this.lastKeyUpTime !== null) {
-      const flightTime = now - this.lastKeyUpTime;
-      this.typingFlightTimes.push(flightTime);
+    const start = this.keyDownTimes.get(event.code);
+    if (start !== void 0) {
+      const dwell = now - start;
+      this.dwellTimes.push(dwell);
+      this.appendVector({ dwellTime: dwell, flightTime: -1, digraphLatency: -1, timestamp: now });
+      this.keyDownTimes.delete(event.code);
     }
     this.lastKeyUpTime = now;
-    const keystroke = {
-      key: event.key,
-      timestamp: now,
-      type: "keyup"
-    };
-    this.keystrokes.push(keystroke);
-    this.sessionEvents.push({ type: "keyup", timestamp: now });
+    if (this.onEvent) this.onEvent("keyup");
   }
-  /**
-   * Handle mouse move event
-   */
-  handleMouseMove(event) {
-    const mouseEvent = {
-      x: event.clientX,
-      y: event.clientY,
-      timestamp: performance.now(),
-      type: "move"
-    };
-    if (this.mouseMovements.length > 0) {
-      const lastEvent = this.mouseMovements[this.mouseMovements.length - 1];
-      const timeDelta = mouseEvent.timestamp - lastEvent.timestamp;
-      if (timeDelta > 0) {
-        const distance = Math.sqrt(
-          Math.pow(mouseEvent.x - lastEvent.x, 2) + Math.pow(mouseEvent.y - lastEvent.y, 2)
-        );
-        mouseEvent.velocity = distance / timeDelta;
-      }
+  appendVector(vector) {
+    this.featureVectors.push(vector);
+    if (this.featureVectors.length > MAX_BUFFER) {
+      this.featureVectors.splice(0, this.featureVectors.length - MAX_BUFFER);
     }
-    this.mouseMovements.push(mouseEvent);
-    this.sessionEvents.push({ type: "mousemove", timestamp: mouseEvent.timestamp });
   }
-  /**
-   * Handle touch start (for swipe detection)
-   */
-  handleTouchStart(event) {
-    const now = performance.now();
-    for (let i = 0; i < event.touches.length; i++) {
-      const touch = event.touches[i];
-      this.touchStartPositions.set(touch.identifier, {
-        x: touch.clientX,
-        y: touch.clientY,
-        timestamp: now
-      });
-    }
-    this.sessionEvents.push({
-      type: "touchstart",
-      timestamp: now
-    });
+  isTargetField(event) {
+    const target = event.target;
+    if (!target) return false;
+    const isEditable = target.isContentEditable || ["INPUT", "TEXTAREA"].includes(target.tagName);
+    return isEditable;
   }
-  /**
-   * Handle touch end (calculate swipe velocity)
-   */
-  handleTouchEnd(event) {
-    const now = performance.now();
-    for (let i = 0; i < event.changedTouches.length; i++) {
-      const touch = event.changedTouches[i];
-      const startPos = this.touchStartPositions.get(touch.identifier);
-      if (startPos) {
-        const timeDelta = now - startPos.timestamp;
-        if (timeDelta > 0 && timeDelta < 1e3) {
-          const distance = Math.sqrt(
-            Math.pow(touch.clientX - startPos.x, 2) + Math.pow(touch.clientY - startPos.y, 2)
-          );
-          if (distance > 10) {
-            const velocity = distance / timeDelta;
-            this.swipeVelocities.push(velocity);
-          }
-        }
-        this.touchStartPositions.delete(touch.identifier);
+};
+
+// src/collectors/keverd-behavioral-collector.ts
+var WINDOW_SIZE = 50;
+var MASK_VALUE = -1;
+var FEATURE_NAMES = [
+  "velocity",
+  "acceleration",
+  "jerk",
+  "curvature",
+  "angularVelocity",
+  "dwell",
+  "flight",
+  "digraphLatency"
+];
+var KeverdBehavioralCollector = class {
+  constructor() {
+    this.isActive = false;
+    this.sessionEvents = [];
+    this.trackEvent = (event) => {
+      this.sessionEvents.push({ type: event, timestamp: performance.now() });
+      if (this.sessionEvents.length > 500) {
+        this.sessionEvents.shift();
       }
+    };
+    this.kinematicEngine = new KinematicEngine({ onEvent: this.trackEvent });
+    this.keystrokeMonitor = new KeystrokeMonitor({ onEvent: this.trackEvent });
+  }
+  start() {
+    if (this.isActive) return;
+    this.kinematicEngine.start();
+    this.keystrokeMonitor.start();
+    this.isActive = true;
+  }
+  stop() {
+    if (!this.isActive) return;
+    this.kinematicEngine.stop();
+    this.keystrokeMonitor.stop();
+    this.isActive = false;
+  }
+  reset() {
+    this.sessionEvents = [];
+    this.kinematicEngine.reset();
+    this.keystrokeMonitor.reset();
+  }
+  getData() {
+    const kinematicVectors = this.kinematicEngine.getVectors();
+    const keystrokeVectors = this.keystrokeMonitor.getVectors();
+    const merged = [
+      ...kinematicVectors.map((v) => ({
+        timestamp: v.timestamp,
+        values: [
+          v.velocity,
+          v.acceleration,
+          v.jerk,
+          v.curvature,
+          v.angularVelocity,
+          MASK_VALUE,
+          MASK_VALUE,
+          MASK_VALUE
+        ]
+      })),
+      ...keystrokeVectors.map((v) => ({
+        timestamp: v.timestamp,
+        values: [
+          MASK_VALUE,
+          MASK_VALUE,
+          MASK_VALUE,
+          MASK_VALUE,
+          MASK_VALUE,
+          v.dwellTime,
+          v.flightTime,
+          v.digraphLatency
+        ]
+      }))
+    ].sort((a, b) => a.timestamp - b.timestamp);
+    const sequence = this.buildSequence(merged);
+    const suspiciousSwipeVelocity = this.kinematicEngine.getSuspiciousSwipeVelocity();
+    const entropy = this.calculateSessionEntropy();
+    const dwellTimes = this.keystrokeMonitor.getDwellTimes();
+    const flightTimes = this.keystrokeMonitor.getFlightTimes();
+    return {
+      typing_dwell_ms: dwellTimes,
+      typing_flight_ms: flightTimes,
+      swipe_velocity: suspiciousSwipeVelocity,
+      suspicious_swipe_velocity: suspiciousSwipeVelocity,
+      session_entropy: entropy,
+      behavioral_vectors: sequence
+    };
+  }
+  buildSequence(vectors) {
+    const padded = [];
+    const startIndex = Math.max(0, vectors.length - WINDOW_SIZE);
+    const window2 = vectors.slice(startIndex);
+    for (const vector of window2) {
+      padded.push(vector.values);
     }
-    this.sessionEvents.push({
-      type: "touchend",
-      timestamp: now
-    });
+    while (padded.length < WINDOW_SIZE) {
+      padded.unshift(new Array(FEATURE_NAMES.length).fill(MASK_VALUE));
+    }
+    return {
+      featureNames: [...FEATURE_NAMES],
+      windowSize: WINDOW_SIZE,
+      maskValue: MASK_VALUE,
+      sequence: padded
+    };
   }
-  /**
-   * Calculate session entropy based on event diversity
-   */
   calculateSessionEntropy() {
     if (this.sessionEvents.length === 0) return 0;
-    const eventTypeCounts = {};
-    for (const event of this.sessionEvents) {
-      eventTypeCounts[event.type] = (eventTypeCounts[event.type] || 0) + 1;
-    }
-    const totalEvents = this.sessionEvents.length;
-    let entropy = 0;
-    for (const count of Object.values(eventTypeCounts)) {
-      const probability = count / totalEvents;
-      if (probability > 0) {
-        entropy -= probability * Math.log2(probability);
-      }
-    }
-    return entropy;
-  }
-  /**
-   * Check if key should be ignored
-   */
-  shouldIgnoreKey(event) {
-    const ignoredKeys = [
-      "Shift",
-      "Control",
-      "Alt",
-      "Meta",
-      "CapsLock",
-      "Tab",
-      "Escape",
-      "Enter",
-      "ArrowLeft",
-      "ArrowRight",
-      "ArrowUp",
-      "ArrowDown",
-      "Home",
-      "End",
-      "PageUp",
-      "PageDown",
-      "F1",
-      "F2",
-      "F3",
-      "F4",
-      "F5",
-      "F6",
-      "F7",
-      "F8",
-      "F9",
-      "F10",
-      "F11",
-      "F12"
-    ];
-    return ignoredKeys.includes(event.key);
+    const counts = {};
+    this.sessionEvents.forEach((evt) => {
+      counts[evt.type] = (counts[evt.type] || 0) + 1;
+    });
+    const total = this.sessionEvents.length;
+    return Object.values(counts).reduce((entropy, count) => {
+      const probability = count / total;
+      return probability > 0 ? entropy - probability * Math.log2(probability) : entropy;
+    }, 0);
   }
 };
 
@@ -541,7 +657,6 @@ var KeverdSDK = class {
       throw new Error("Keverd SDK: apiKey is required");
     }
     this.config = {
-      endpoint: config.endpoint || this.getDefaultEndpoint(),
       debug: false,
       ...config
     };
@@ -549,10 +664,10 @@ var KeverdSDK = class {
     this.sessionId = this.generateSessionId();
     this.isInitialized = true;
     if (this.config.debug) {
-      console.log("[Keverd SDK] Initialized successfully", {
-        endpoint: this.config.endpoint
-      });
+      console.log("[Keverd SDK] Initialized successfully");
     }
+    this.startSession().catch(() => {
+    });
   }
   /**
    * Get visitor data (fingerprint and risk assessment)
@@ -587,6 +702,17 @@ var KeverdSDK = class {
       throw keverdError;
     }
   }
+  /**
+   * Extract origin and referrer from browser
+   */
+  getOriginHeaders() {
+    if (typeof window === "undefined") {
+      return {};
+    }
+    const origin = window.location.origin || void 0;
+    const referrer = document.referrer || void 0;
+    return { origin, referrer };
+  }
   /**
    * Send fingerprint request to backend
    */
@@ -594,13 +720,19 @@ var KeverdSDK = class {
     if (!this.config) {
       throw new Error("SDK not initialized");
     }
-    const endpoint = this.config.endpoint || this.getDefaultEndpoint();
-    const url = `${endpoint}/fingerprint/score`;
+    const url = `${this.getDefaultEndpoint()}/fingerprint/score`;
     const headers = {
       "Content-Type": "application/json",
       "X-SDK-Source": "react"
       // Identify SDK source for backend analytics
     };
+    const { origin, referrer } = this.getOriginHeaders();
+    if (origin) {
+      headers["X-Origin-URL"] = origin;
+    }
+    if (referrer) {
+      headers["X-Referrer-URL"] = referrer;
+    }
     const apiKey = this.config.apiKey;
     if (apiKey) {
       headers["x-keverd-key"] = apiKey;
@@ -610,10 +742,17 @@ var KeverdSDK = class {
     if (options?.tag === "sandbox") {
       headers["X-Sandbox"] = "true";
     }
+    const requestBody = {
+      ...request,
+      session: {
+        ...request.session || {},
+        sessionId: this.sessionId || request.session?.sessionId
+      }
+    };
     const response = await fetch(url, {
       method: "POST",
       headers,
-      body: JSON.stringify(request)
+      body: JSON.stringify(requestBody)
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => "Unknown error");
@@ -651,7 +790,7 @@ var KeverdSDK = class {
    * Get default endpoint
    */
   getDefaultEndpoint() {
-    return "https://app.keverd.com";
+    return "https://api.keverd.com";
   }
   /**
    * Generate a session ID
@@ -659,10 +798,204 @@ var KeverdSDK = class {
   generateSessionId() {
     return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
   }
+  /**
+   * Start a new session (called automatically on init, but can be called manually)
+   */
+  async startSession(userId, deviceHash, metadata) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    if (!this.sessionId) {
+      this.sessionId = this.generateSessionId();
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/start`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const deviceInfo = this.deviceCollector.collect();
+      await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          session_id: this.sessionId,
+          user_id: userId || this.config.userId,
+          device_hash: deviceHash || deviceInfo.fingerprint,
+          session_metadata: metadata || {},
+          user_agent: navigator.userAgent,
+          browser: this._detectBrowser(),
+          os: this._detectOS(),
+          platform: "web",
+          sdk_type: "web",
+          sdk_source: "react"
+        })
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session started: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to start session on server:", error);
+      }
+    }
+  }
+  /**
+   * End the current session
+   */
+  async endSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/${this.sessionId}/end`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session ended: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to end session on server:", error);
+      }
+    }
+  }
+  /**
+   * Pause the current session (e.g., when app goes to background)
+   */
+  async pauseSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/${this.sessionId}/pause`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session paused: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to pause session on server:", error);
+      }
+    }
+  }
+  /**
+   * Resume a paused session (e.g., when app comes to foreground)
+   */
+  async resumeSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/${this.sessionId}/resume`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session resumed: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to resume session on server:", error);
+      }
+    }
+  }
+  /**
+   * Get current session status
+   */
+  async getSessionStatus() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return null;
+    }
+    try {
+      const url = `${this.getDefaultEndpoint()}/dashboard/sessions/${this.sessionId}/status`;
+      const headers = {};
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const response = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to get session status:", error);
+      }
+      return null;
+    }
+  }
+  /**
+   * Helper methods for browser/OS detection
+   */
+  _detectBrowser() {
+    const ua = navigator.userAgent;
+    if (ua.includes("Chrome") && !ua.includes("Edg")) return "Chrome";
+    if (ua.includes("Firefox")) return "Firefox";
+    if (ua.includes("Safari") && !ua.includes("Chrome")) return "Safari";
+    if (ua.includes("Edg")) return "Edge";
+    return "Unknown";
+  }
+  _detectOS() {
+    const ua = navigator.userAgent;
+    if (ua.includes("Windows")) return "Windows";
+    if (ua.includes("Mac")) return "macOS";
+    if (ua.includes("Linux")) return "Linux";
+    if (ua.includes("Android")) return "Android";
+    if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) return "iOS";
+    return "Unknown";
+  }
   /**
    * Destroy the SDK instance
    */
-  destroy() {
+  async destroy() {
+    if (this.sessionId) {
+      await this.endSession();
+    }
     const wasDebug = this.config?.debug;
     this.behavioralCollector.stop();
     this.isInitialized = false;
@@ -694,14 +1027,14 @@ function KeverdProvider({ loadOptions, children }) {
     if (!sdk.isReady()) {
       sdk.init({
         apiKey: loadOptions.apiKey,
-        endpoint: loadOptions.endpoint,
         debug: loadOptions.debug || false
       });
       setIsReady(true);
     }
     return () => {
       if (sdk.isReady()) {
-        sdk.destroy();
+        sdk.destroy().catch(() => {
+        });
         setIsReady(false);
       }
     };