@surbee/cipher 0.1.0 → 0.2.0

package/dist/chunk-P2MIOVFQ.mjs

@@ -0,0 +1,1104 @@
+// src/checks/timing.ts
+var MIN_MS_PER_CHAR = 20;
+var MIN_RESPONSE_TIME_MS = 1e3;
+function checkImpossiblyFast(responses, context) {
+  if (!context?.actualDurationSeconds || !context?.expectedDurationSeconds) {
+    return {
+      checkId: "impossibly_fast",
+      passed: true,
+      score: 0,
+      details: "No timing data available"
+    };
+  }
+  const actualMs = context.actualDurationSeconds * 1e3;
+  const expectedMs = context.expectedDurationSeconds * 1e3;
+  let minPossibleMs = 0;
+  for (const response of responses) {
+    const questionChars = response.question.length;
+    const readingTime = questionChars * MIN_MS_PER_CHAR;
+    minPossibleMs += Math.max(readingTime, MIN_RESPONSE_TIME_MS);
+  }
+  const suspicionThreshold = minPossibleMs * 0.3;
+  if (actualMs < suspicionThreshold) {
+    return {
+      checkId: "impossibly_fast",
+      passed: false,
+      score: 1,
+      details: `Completed in ${context.actualDurationSeconds}s, minimum expected ${Math.round(minPossibleMs / 1e3)}s`,
+      data: { actualMs, minPossibleMs, threshold: suspicionThreshold }
+    };
+  }
+  const speedRatio = actualMs / expectedMs;
+  const score = speedRatio < 1 ? Math.max(0, 1 - speedRatio) * 0.7 : 0;
+  return {
+    checkId: "impossibly_fast",
+    passed: true,
+    score,
+    details: speedRatio < 0.5 ? "Faster than average" : void 0,
+    data: { actualMs, expectedMs, speedRatio }
+  };
+}
+function checkRapidCompletion(responses, context) {
+  if (!context?.actualDurationSeconds || !context?.expectedDurationSeconds) {
+    return {
+      checkId: "rapid_completion",
+      passed: true,
+      score: 0,
+      details: "No timing data available"
+    };
+  }
+  const ratio = context.actualDurationSeconds / context.expectedDurationSeconds;
+  if (ratio < 0.2) {
+    return {
+      checkId: "rapid_completion",
+      passed: false,
+      score: 1,
+      details: `Completed in ${Math.round(ratio * 100)}% of expected time`,
+      data: { ratio }
+    };
+  }
+  if (ratio < 0.4) {
+    return {
+      checkId: "rapid_completion",
+      passed: true,
+      score: 0.5,
+      details: "Faster than typical",
+      data: { ratio }
+    };
+  }
+  return {
+    checkId: "rapid_completion",
+    passed: true,
+    score: 0,
+    data: { ratio }
+  };
+}
+function checkUniformTiming(responses, metrics) {
+  const times = metrics?.responseTime || responses.map((r) => r.responseTimeMs).filter(Boolean);
+  if (times.length < 3) {
+    return {
+      checkId: "uniform_timing",
+      passed: true,
+      score: 0,
+      details: "Not enough timing data"
+    };
+  }
+  const mean = times.reduce((a, b) => a + b, 0) / times.length;
+  const variance = times.reduce((sum, t) => sum + Math.pow(t - mean, 2), 0) / times.length;
+  const stddev = Math.sqrt(variance);
+  const cv = stddev / mean;
+  if (cv < 0.1) {
+    return {
+      checkId: "uniform_timing",
+      passed: false,
+      score: 1,
+      details: "Response times are suspiciously uniform",
+      data: { cv, mean, stddev }
+    };
+  }
+  if (cv < 0.2) {
+    return {
+      checkId: "uniform_timing",
+      passed: true,
+      score: 0.5,
+      details: "Lower than typical timing variation",
+      data: { cv, mean, stddev }
+    };
+  }
+  return {
+    checkId: "uniform_timing",
+    passed: true,
+    score: 0,
+    data: { cv, mean, stddev }
+  };
+}
+function checkSuspiciousPauses(metrics) {
+  if (!metrics?.focusEvents || metrics.focusEvents.length < 2) {
+    return {
+      checkId: "suspicious_pauses",
+      passed: true,
+      score: 0,
+      details: "No focus event data"
+    };
+  }
+  const blurEvents = metrics.focusEvents.filter((e) => e.type === "blur" || e.type === "hidden");
+  const totalBlurTime = metrics.totalBlurDuration || 0;
+  const surveyDuration = metrics.duration || 1;
+  const blurRatio = totalBlurTime / surveyDuration;
+  if (blurRatio > 0.5) {
+    return {
+      checkId: "suspicious_pauses",
+      passed: false,
+      score: 0.9,
+      details: `${Math.round(blurRatio * 100)}% of time spent away from survey`,
+      data: { blurRatio, totalBlurTime, blurEvents: blurEvents.length }
+    };
+  }
+  if (blurRatio > 0.3) {
+    return {
+      checkId: "suspicious_pauses",
+      passed: true,
+      score: 0.5,
+      details: "Significant time away from survey",
+      data: { blurRatio, totalBlurTime }
+    };
+  }
+  return {
+    checkId: "suspicious_pauses",
+    passed: true,
+    score: 0,
+    data: { blurRatio }
+  };
+}
+function runTimingChecks(responses, metrics, context) {
+  return [
+    checkImpossiblyFast(responses, context),
+    checkRapidCompletion(responses, context),
+    checkUniformTiming(responses, metrics),
+    checkSuspiciousPauses(metrics)
+  ];
+}
+
+// src/checks/behavioral.ts
+function checkLowInteraction(metrics) {
+  if (!metrics) {
+    return {
+      checkId: "low_interaction",
+      passed: true,
+      score: 0,
+      details: "No behavioral data available"
+    };
+  }
+  const durationSeconds = (metrics.duration || 1) / 1e3;
+  const totalInteractions = metrics.mouseMovementCount + metrics.keypressCount + metrics.scrollEventCount;
+  const interactionsPerSecond = totalInteractions / durationSeconds;
+  if (interactionsPerSecond < 0.1) {
+    return {
+      checkId: "low_interaction",
+      passed: false,
+      score: 1,
+      details: "Almost no user interaction detected",
+      data: { interactionsPerSecond, totalInteractions, durationSeconds }
+    };
+  }
+  if (interactionsPerSecond < 0.5) {
+    return {
+      checkId: "low_interaction",
+      passed: true,
+      score: 0.6,
+      details: "Below average interaction rate",
+      data: { interactionsPerSecond }
+    };
+  }
+  return {
+    checkId: "low_interaction",
+    passed: true,
+    score: 0,
+    data: { interactionsPerSecond }
+  };
+}
+function checkExcessivePaste(metrics) {
+  if (!metrics) {
+    return {
+      checkId: "excessive_paste",
+      passed: true,
+      score: 0,
+      details: "No behavioral data available"
+    };
+  }
+  const { pasteEvents, keypressCount } = metrics;
+  if (pasteEvents > 0 && keypressCount === 0) {
+    return {
+      checkId: "excessive_paste",
+      passed: false,
+      score: 1,
+      details: "All content was pasted, no typing detected",
+      data: { pasteEvents, keypressCount }
+    };
+  }
+  const pasteRatio = keypressCount > 0 ? pasteEvents / keypressCount : 0;
+  if (pasteRatio > 0.5) {
+    return {
+      checkId: "excessive_paste",
+      passed: false,
+      score: 0.8,
+      details: "High paste-to-typing ratio",
+      data: { pasteRatio, pasteEvents }
+    };
+  }
+  if (pasteRatio > 0.2) {
+    return {
+      checkId: "excessive_paste",
+      passed: true,
+      score: 0.4,
+      details: "Some paste events detected",
+      data: { pasteRatio }
+    };
+  }
+  return {
+    checkId: "excessive_paste",
+    passed: true,
+    score: 0,
+    data: { pasteEvents }
+  };
+}
+function checkPointerSpikes(metrics) {
+  if (!metrics?.mouseMovements || metrics.mouseMovements.length < 10) {
+    return {
+      checkId: "pointer_spikes",
+      passed: true,
+      score: 0,
+      details: "Insufficient mouse data"
+    };
+  }
+  const velocities = metrics.mouseMovements.map((m) => m.velocity).filter((v) => v > 0);
+  if (velocities.length === 0) {
+    return {
+      checkId: "pointer_spikes",
+      passed: true,
+      score: 0,
+      details: "No velocity data"
+    };
+  }
+  const spikeThreshold = 50;
+  const spikes = velocities.filter((v) => v > spikeThreshold);
+  const spikeRatio = spikes.length / velocities.length;
+  if (spikeRatio > 0.3) {
+    return {
+      checkId: "pointer_spikes",
+      passed: false,
+      score: 0.9,
+      details: "Many unnatural mouse speed spikes detected",
+      data: { spikeRatio, spikeCount: spikes.length }
+    };
+  }
+  if (spikeRatio > 0.1) {
+    return {
+      checkId: "pointer_spikes",
+      passed: true,
+      score: 0.4,
+      details: "Some unusual mouse movements",
+      data: { spikeRatio }
+    };
+  }
+  return {
+    checkId: "pointer_spikes",
+    passed: true,
+    score: 0,
+    data: { spikeRatio }
+  };
+}
+function checkRoboticTyping(metrics) {
+  if (!metrics?.keystrokeDynamics || metrics.keystrokeDynamics.length < 10) {
+    return {
+      checkId: "robotic_typing",
+      passed: true,
+      score: 0,
+      details: "Insufficient keystroke data"
+    };
+  }
+  const dwellTimes = metrics.keystrokeDynamics.map((k) => k.dwell).filter((d) => d > 0 && d < 1e3);
+  if (dwellTimes.length < 5) {
+    return {
+      checkId: "robotic_typing",
+      passed: true,
+      score: 0,
+      details: "Not enough valid keystroke data"
+    };
+  }
+  const mean = dwellTimes.reduce((a, b) => a + b, 0) / dwellTimes.length;
+  const variance = dwellTimes.reduce((sum, t) => sum + Math.pow(t - mean, 2), 0) / dwellTimes.length;
+  const stddev = Math.sqrt(variance);
+  const cv = stddev / mean;
+  if (cv < 0.08) {
+    return {
+      checkId: "robotic_typing",
+      passed: false,
+      score: 1,
+      details: "Keystroke timing is machine-like uniform",
+      data: { cv, mean, stddev }
+    };
+  }
+  if (cv < 0.15) {
+    return {
+      checkId: "robotic_typing",
+      passed: true,
+      score: 0.5,
+      details: "Lower than typical keystroke variation",
+      data: { cv }
+    };
+  }
+  return {
+    checkId: "robotic_typing",
+    passed: true,
+    score: 0,
+    data: { cv }
+  };
+}
+function checkMouseTeleporting(metrics) {
+  if (!metrics?.mouseMovements || metrics.mouseMovements.length < 5) {
+    return {
+      checkId: "mouse_teleporting",
+      passed: true,
+      score: 0,
+      details: "Insufficient mouse data"
+    };
+  }
+  let teleportCount = 0;
+  const movements = metrics.mouseMovements;
+  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 distance = Math.sqrt(dx * dx + dy * dy);
+    const dt = curr.t - prev.t;
+    if (distance > 500 && dt < 10) {
+      teleportCount++;
+    }
+  }
+  const teleportRatio = teleportCount / movements.length;
+  if (teleportRatio > 0.2) {
+    return {
+      checkId: "mouse_teleporting",
+      passed: false,
+      score: 0.9,
+      details: "Frequent mouse teleportation detected",
+      data: { teleportCount, teleportRatio }
+    };
+  }
+  if (teleportRatio > 0.05) {
+    return {
+      checkId: "mouse_teleporting",
+      passed: true,
+      score: 0.4,
+      details: "Some mouse teleportation detected",
+      data: { teleportCount }
+    };
+  }
+  return {
+    checkId: "mouse_teleporting",
+    passed: true,
+    score: 0,
+    data: { teleportCount }
+  };
+}
+function checkNoCorrections(metrics) {
+  if (!metrics || metrics.keypressCount < 20) {
+    return {
+      checkId: "no_corrections",
+      passed: true,
+      score: 0,
+      details: "Insufficient typing data"
+    };
+  }
+  const { backspaceCount, keypressCount } = metrics;
+  const correctionRatio = backspaceCount / keypressCount;
+  if (backspaceCount === 0 && keypressCount > 50) {
+    return {
+      checkId: "no_corrections",
+      passed: false,
+      score: 0.8,
+      details: "No typing corrections despite significant text entry",
+      data: { backspaceCount, keypressCount }
+    };
+  }
+  if (correctionRatio < 0.01 && keypressCount > 30) {
+    return {
+      checkId: "no_corrections",
+      passed: true,
+      score: 0.5,
+      details: "Very few typing corrections",
+      data: { correctionRatio }
+    };
+  }
+  return {
+    checkId: "no_corrections",
+    passed: true,
+    score: 0,
+    data: { correctionRatio }
+  };
+}
+function checkHoverBehavior(metrics) {
+  if (!metrics?.mouseClicks || metrics.mouseClicks.length < 3) {
+    return {
+      checkId: "hover_behavior",
+      passed: true,
+      score: 0,
+      details: "Insufficient click data"
+    };
+  }
+  const clicksWithHover = metrics.mouseClicks.filter((c) => c.hadHover);
+  const hoverRatio = clicksWithHover.length / metrics.mouseClicks.length;
+  if (hoverRatio < 0.2) {
+    return {
+      checkId: "hover_behavior",
+      passed: false,
+      score: 0.8,
+      details: "Clicks without natural hover behavior",
+      data: { hoverRatio, totalClicks: metrics.mouseClicks.length }
+    };
+  }
+  if (hoverRatio < 0.4) {
+    return {
+      checkId: "hover_behavior",
+      passed: true,
+      score: 0.4,
+      details: "Lower than typical hover-before-click rate",
+      data: { hoverRatio }
+    };
+  }
+  return {
+    checkId: "hover_behavior",
+    passed: true,
+    score: 0,
+    data: { hoverRatio }
+  };
+}
+function checkScrollPatterns(metrics) {
+  if (!metrics?.scrollEvents || metrics.scrollEvents.length < 5) {
+    return {
+      checkId: "scroll_patterns",
+      passed: true,
+      score: 0,
+      details: "Insufficient scroll data"
+    };
+  }
+  const velocities = metrics.scrollEvents.map((s) => Math.abs(s.velocity)).filter((v) => v > 0);
+  if (velocities.length < 3) {
+    return {
+      checkId: "scroll_patterns",
+      passed: true,
+      score: 0
+    };
+  }
+  const mean = velocities.reduce((a, b) => a + b, 0) / velocities.length;
+  const variance = velocities.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / velocities.length;
+  const cv = Math.sqrt(variance) / mean;
+  if (cv < 0.1) {
+    return {
+      checkId: "scroll_patterns",
+      passed: false,
+      score: 0.7,
+      details: "Unnaturally uniform scroll pattern",
+      data: { cv }
+    };
+  }
+  return {
+    checkId: "scroll_patterns",
+    passed: true,
+    score: 0,
+    data: { cv }
+  };
+}
+function checkMouseAcceleration(metrics) {
+  if (!metrics?.mouseMovements || metrics.mouseMovements.length < 20) {
+    return {
+      checkId: "mouse_acceleration",
+      passed: true,
+      score: 0,
+      details: "Insufficient mouse data"
+    };
+  }
+  const velocities = metrics.mouseMovements.map((m) => m.velocity).filter((v) => v > 0);
+  if (velocities.length < 10) {
+    return {
+      checkId: "mouse_acceleration",
+      passed: true,
+      score: 0
+    };
+  }
+  const accelerations = [];
+  for (let i = 1; i < velocities.length; i++) {
+    accelerations.push(Math.abs(velocities[i] - velocities[i - 1]));
+  }
+  const meanAcc = accelerations.reduce((a, b) => a + b, 0) / accelerations.length;
+  const varianceAcc = accelerations.reduce((sum, a) => sum + Math.pow(a - meanAcc, 2), 0) / accelerations.length;
+  const cvAcc = Math.sqrt(varianceAcc) / meanAcc;
+  if (cvAcc < 0.2) {
+    return {
+      checkId: "mouse_acceleration",
+      passed: true,
+      score: 0.5,
+      details: "Lower than typical acceleration variation",
+      data: { cvAcc }
+    };
+  }
+  return {
+    checkId: "mouse_acceleration",
+    passed: true,
+    score: 0,
+    data: { cvAcc }
+  };
+}
+function runBehavioralChecks(metrics) {
+  return [
+    checkLowInteraction(metrics),
+    checkExcessivePaste(metrics),
+    checkPointerSpikes(metrics),
+    checkRoboticTyping(metrics),
+    checkMouseTeleporting(metrics),
+    checkNoCorrections(metrics),
+    checkHoverBehavior(metrics),
+    checkScrollPatterns(metrics),
+    checkMouseAcceleration(metrics)
+  ];
+}
+
+// src/checks/content.ts
+var GIBBERISH_PATTERNS = [
+  /^[a-z]{1,3}$/i,
+  // Single letters or very short
+  /(.)\1{4,}/,
+  // Repeated characters (aaaaa)
+  /^[^aeiou]{5,}$/i,
+  // No vowels in 5+ chars
+  /^(asdf|qwerty|zxcv|wasd)/i,
+  // Keyboard mashing
+  /^[0-9]+$/,
+  // Only numbers
+  /^(.+?)\1{2,}$/
+  // Repeated patterns (abcabcabc)
+];
+var LOW_EFFORT_RESPONSES = [
+  "n/a",
+  "na",
+  "none",
+  "nothing",
+  "idk",
+  "i dont know",
+  "i don't know",
+  "no comment",
+  "no",
+  "yes",
+  "ok",
+  "okay",
+  "good",
+  "fine",
+  "whatever",
+  "asdf",
+  "test",
+  ".",
+  "-",
+  "..."
+];
+function checkMinimalEffort(responses) {
+  const textResponses = responses.filter(
+    (r) => r.questionType === "text" || !r.questionType && r.answer.length > 0
+  );
+  if (textResponses.length === 0) {
+    return {
+      checkId: "minimal_effort",
+      passed: true,
+      score: 0,
+      details: "No text responses to analyze"
+    };
+  }
+  let lowEffortCount = 0;
+  let totalLength = 0;
+  for (const response of textResponses) {
+    const answer = response.answer.toLowerCase().trim();
+    totalLength += answer.length;
+    if (LOW_EFFORT_RESPONSES.includes(answer)) {
+      lowEffortCount++;
+      continue;
+    }
+    if (answer.length < 10) {
+      lowEffortCount++;
+      continue;
+    }
+    for (const pattern of GIBBERISH_PATTERNS) {
+      if (pattern.test(answer)) {
+        lowEffortCount++;
+        break;
+      }
+    }
+  }
+  const lowEffortRatio = lowEffortCount / textResponses.length;
+  const avgLength = totalLength / textResponses.length;
+  if (lowEffortRatio > 0.7) {
+    return {
+      checkId: "minimal_effort",
+      passed: false,
+      score: 1,
+      details: "Most responses are low effort or gibberish",
+      data: { lowEffortRatio, avgLength, lowEffortCount }
+    };
+  }
+  if (lowEffortRatio > 0.4) {
+    return {
+      checkId: "minimal_effort",
+      passed: true,
+      score: 0.6,
+      details: "Many responses appear low effort",
+      data: { lowEffortRatio, avgLength }
+    };
+  }
+  if (avgLength < 20) {
+    return {
+      checkId: "minimal_effort",
+      passed: true,
+      score: 0.4,
+      details: "Responses are quite short on average",
+      data: { avgLength }
+    };
+  }
+  return {
+    checkId: "minimal_effort",
+    passed: true,
+    score: 0,
+    data: { lowEffortRatio, avgLength }
+  };
+}
+function checkStraightLining(responses) {
+  const scaleResponses = responses.filter(
+    (r) => r.questionType === "rating" || r.questionType === "scale" || r.questionType === "multiple_choice"
+  );
+  if (scaleResponses.length < 4) {
+    return {
+      checkId: "straight_line_answers",
+      passed: true,
+      score: 0,
+      details: "Not enough scale/choice questions"
+    };
+  }
+  let maxConsecutive = 1;
+  let currentConsecutive = 1;
+  for (let i = 1; i < scaleResponses.length; i++) {
+    if (scaleResponses[i].answer === scaleResponses[i - 1].answer) {
+      currentConsecutive++;
+      maxConsecutive = Math.max(maxConsecutive, currentConsecutive);
+    } else {
+      currentConsecutive = 1;
+    }
+  }
+  const answers = scaleResponses.map((r) => r.answer);
+  const uniqueAnswers = new Set(answers);
+  const uniqueRatio = uniqueAnswers.size / scaleResponses.length;
+  if (uniqueRatio < 0.15) {
+    return {
+      checkId: "straight_line_answers",
+      passed: false,
+      score: 1,
+      details: "Nearly all answers are identical",
+      data: { uniqueRatio, uniqueAnswers: uniqueAnswers.size, total: scaleResponses.length }
+    };
+  }
+  if (maxConsecutive >= 5 || uniqueRatio < 0.25) {
+    return {
+      checkId: "straight_line_answers",
+      passed: false,
+      score: 0.8,
+      details: "Strong straight-lining pattern detected",
+      data: { maxConsecutive, uniqueRatio }
+    };
+  }
+  if (maxConsecutive >= 4) {
+    return {
+      checkId: "straight_line_answers",
+      passed: true,
+      score: 0.4,
+      details: "Some consecutive identical answers",
+      data: { maxConsecutive }
+    };
+  }
+  return {
+    checkId: "straight_line_answers",
+    passed: true,
+    score: 0,
+    data: { maxConsecutive, uniqueRatio }
+  };
+}
+function checkExcessiveTabSwitching(metrics) {
+  if (!metrics) {
+    return {
+      checkId: "excessive_tab_switching",
+      passed: true,
+      score: 0,
+      details: "No behavioral data"
+    };
+  }
+  const { tabSwitchCount, duration } = metrics;
+  const durationMinutes = (duration || 1) / 6e4;
+  const switchesPerMinute = tabSwitchCount / durationMinutes;
+  if (switchesPerMinute > 5) {
+    return {
+      checkId: "excessive_tab_switching",
+      passed: false,
+      score: 0.8,
+      details: "Excessive tab switching detected",
+      data: { switchesPerMinute, tabSwitchCount }
+    };
+  }
+  if (switchesPerMinute > 2) {
+    return {
+      checkId: "excessive_tab_switching",
+      passed: true,
+      score: 0.4,
+      details: "Above average tab switching",
+      data: { switchesPerMinute }
+    };
+  }
+  return {
+    checkId: "excessive_tab_switching",
+    passed: true,
+    score: 0,
+    data: { switchesPerMinute }
+  };
+}
+function checkWindowFocusLoss(metrics) {
+  if (!metrics) {
+    return {
+      checkId: "window_focus_loss",
+      passed: true,
+      score: 0,
+      details: "No behavioral data"
+    };
+  }
+  const { totalBlurDuration, duration } = metrics;
+  const blurRatio = totalBlurDuration / (duration || 1);
+  if (blurRatio > 0.6) {
+    return {
+      checkId: "window_focus_loss",
+      passed: false,
+      score: 0.8,
+      details: "Majority of time spent away from survey",
+      data: { blurRatio, totalBlurDuration }
+    };
+  }
+  if (blurRatio > 0.3) {
+    return {
+      checkId: "window_focus_loss",
+      passed: true,
+      score: 0.4,
+      details: "Significant time away from survey",
+      data: { blurRatio }
+    };
+  }
+  return {
+    checkId: "window_focus_loss",
+    passed: true,
+    score: 0,
+    data: { blurRatio }
+  };
+}
+function runContentChecks(responses, metrics) {
+  return [
+    checkMinimalEffort(responses),
+    checkStraightLining(responses),
+    checkExcessiveTabSwitching(metrics),
+    checkWindowFocusLoss(metrics)
+  ];
+}
+
+// src/checks/device.ts
+var BOT_USER_AGENTS = [
+  /headless/i,
+  /phantom/i,
+  /selenium/i,
+  /webdriver/i,
+  /puppeteer/i,
+  /playwright/i,
+  /crawl/i,
+  /spider/i,
+  /bot/i,
+  /scrape/i,
+  /curl/i,
+  /wget/i,
+  /python-requests/i,
+  /axios/i,
+  /node-fetch/i,
+  /go-http-client/i
+];
+var SUSPICIOUS_SCREENS = [
+  { width: 800, height: 600 },
+  { width: 1024, height: 768 },
+  { width: 1, height: 1 },
+  { width: 0, height: 0 }
+];
+function checkWebDriverDetected(device) {
+  if (!device) {
+    return {
+      checkId: "webdriver_detected",
+      passed: true,
+      score: 0,
+      details: "No device info available"
+    };
+  }
+  if (device.webDriver === true) {
+    return {
+      checkId: "webdriver_detected",
+      passed: false,
+      score: 1,
+      details: "WebDriver automation detected",
+      data: { webDriver: true }
+    };
+  }
+  return {
+    checkId: "webdriver_detected",
+    passed: true,
+    score: 0,
+    data: { webDriver: false }
+  };
+}
+function checkAutomationDetected(device) {
+  if (!device) {
+    return {
+      checkId: "automation_detected",
+      passed: true,
+      score: 0,
+      details: "No device info available"
+    };
+  }
+  if (device.automationDetected === true) {
+    return {
+      checkId: "automation_detected",
+      passed: false,
+      score: 1,
+      details: "Browser automation framework detected",
+      data: { automationDetected: true }
+    };
+  }
+  return {
+    checkId: "automation_detected",
+    passed: true,
+    score: 0,
+    data: { automationDetected: false }
+  };
+}
+function checkNoPlugins(device) {
+  if (!device) {
+    return {
+      checkId: "no_plugins",
+      passed: true,
+      score: 0,
+      details: "No device info available"
+    };
+  }
+  const { pluginCount } = device;
+  if (pluginCount === 0) {
+    const isMobile = device.touchSupport || device.maxTouchPoints > 0;
+    if (!isMobile) {
+      return {
+        checkId: "no_plugins",
+        passed: true,
+        score: 0.5,
+        details: "No browser plugins (common in automation)",
+        data: { pluginCount }
+      };
+    }
+  }
+  return {
+    checkId: "no_plugins",
+    passed: true,
+    score: 0,
+    data: { pluginCount }
+  };
+}
+function checkSuspiciousUserAgent(device) {
+  if (!device?.userAgent) {
+    return {
+      checkId: "suspicious_user_agent",
+      passed: true,
+      score: 0,
+      details: "No user agent available"
+    };
+  }
+  const { userAgent } = device;
+  for (const pattern of BOT_USER_AGENTS) {
+    if (pattern.test(userAgent)) {
+      return {
+        checkId: "suspicious_user_agent",
+        passed: false,
+        score: 1,
+        details: "Bot-like user agent detected",
+        data: { pattern: pattern.source }
+      };
+    }
+  }
+  if (userAgent.length < 20) {
+    return {
+      checkId: "suspicious_user_agent",
+      passed: true,
+      score: 0.5,
+      details: "Unusually short user agent",
+      data: { length: userAgent.length }
+    };
+  }
+  return {
+    checkId: "suspicious_user_agent",
+    passed: true,
+    score: 0
+  };
+}
+function checkDeviceFingerprintMismatch(device) {
+  if (!device) {
+    return {
+      checkId: "device_fingerprint_mismatch",
+      passed: true,
+      score: 0,
+      details: "No device info available"
+    };
+  }
+  const issues = [];
+  if (device.touchSupport && device.maxTouchPoints === 0) {
+    issues.push("Touch support claimed but no touch points");
+  }
+  if (device.screenWidth < device.screenAvailWidth || device.screenHeight < device.screenAvailHeight) {
+    issues.push("Available screen larger than total screen");
+  }
+  if (device.hardwareConcurrency > 128) {
+    issues.push("Impossible CPU core count");
+  }
+  if (device.deviceMemory > 256) {
+    issues.push("Impossible memory amount");
+  }
+  if (device.pixelRatio <= 0 || device.pixelRatio > 10) {
+    issues.push("Invalid pixel ratio");
+  }
+  if (issues.length >= 2) {
+    return {
+      checkId: "device_fingerprint_mismatch",
+      passed: false,
+      score: 0.8,
+      details: "Multiple device characteristic mismatches",
+      data: { issues }
+    };
+  }
+  if (issues.length === 1) {
+    return {
+      checkId: "device_fingerprint_mismatch",
+      passed: true,
+      score: 0.4,
+      details: issues[0],
+      data: { issues }
+    };
+  }
+  return {
+    checkId: "device_fingerprint_mismatch",
+    passed: true,
+    score: 0
+  };
+}
+function checkScreenAnomaly(device) {
+  if (!device) {
+    return {
+      checkId: "screen_anomaly",
+      passed: true,
+      score: 0,
+      details: "No device info available"
+    };
+  }
+  const { screenWidth, screenHeight } = device;
+  if (screenWidth <= 0 || screenHeight <= 0) {
+    return {
+      checkId: "screen_anomaly",
+      passed: false,
+      score: 1,
+      details: "Invalid screen dimensions",
+      data: { screenWidth, screenHeight }
+    };
+  }
+  for (const suspicious of SUSPICIOUS_SCREENS) {
+    if (screenWidth === suspicious.width && screenHeight === suspicious.height) {
+      return {
+        checkId: "screen_anomaly",
+        passed: true,
+        score: 0.4,
+        details: "Common automation screen size",
+        data: { screenWidth, screenHeight }
+      };
+    }
+  }
+  const aspectRatio = screenWidth / screenHeight;
+  if (aspectRatio < 0.3 || aspectRatio > 5) {
+    return {
+      checkId: "screen_anomaly",
+      passed: true,
+      score: 0.5,
+      details: "Unusual screen aspect ratio",
+      data: { aspectRatio }
+    };
+  }
+  return {
+    checkId: "screen_anomaly",
+    passed: true,
+    score: 0
+  };
+}
+function checkTimezoneValidation(device) {
+  if (!device) {
+    return {
+      checkId: "timezone_validation",
+      passed: true,
+      score: 0,
+      details: "No device info available"
+    };
+  }
+  const { timezone, timezoneOffset } = device;
+  if (!timezone) {
+    return {
+      checkId: "timezone_validation",
+      passed: true,
+      score: 0.3,
+      details: "No timezone information"
+    };
+  }
+  if (timezoneOffset < -840 || timezoneOffset > 720) {
+    return {
+      checkId: "timezone_validation",
+      passed: false,
+      score: 0.7,
+      details: "Invalid timezone offset",
+      data: { timezoneOffset }
+    };
+  }
+  return {
+    checkId: "timezone_validation",
+    passed: true,
+    score: 0,
+    data: { timezone, timezoneOffset }
+  };
+}
+function runDeviceChecks(device) {
+  return [
+    checkWebDriverDetected(device),
+    checkAutomationDetected(device),
+    checkNoPlugins(device),
+    checkSuspiciousUserAgent(device),
+    checkDeviceFingerprintMismatch(device),
+    checkScreenAnomaly(device),
+    checkTimezoneValidation(device)
+  ];
+}
+
+export {
+  checkImpossiblyFast,
+  checkRapidCompletion,
+  checkUniformTiming,
+  checkSuspiciousPauses,
+  runTimingChecks,
+  checkLowInteraction,
+  checkExcessivePaste,
+  checkPointerSpikes,
+  checkRoboticTyping,
+  checkMouseTeleporting,
+  checkNoCorrections,
+  checkHoverBehavior,
+  checkScrollPatterns,
+  checkMouseAcceleration,
+  runBehavioralChecks,
+  checkMinimalEffort,
+  checkStraightLining,
+  checkExcessiveTabSwitching,
+  checkWindowFocusLoss,
+  runContentChecks,
+  checkWebDriverDetected,
+  checkAutomationDetected,
+  checkNoPlugins,
+  checkSuspiciousUserAgent,
+  checkDeviceFingerprintMismatch,
+  checkScreenAnomaly,
+  checkTimezoneValidation,
+  runDeviceChecks
+};