ब्राउज़र                                  आपका सर्वर
┌──────────────────────────┐            ┌──────────────────────┐
│ कलेक्टर (सिंगलटन)       │  POST      │ Express मिडलवेयर    │
│  ├─ 28 डिटेक्शन मॉड्यूल │  सिग्नल   │  ├─ NonceManager     │
│  ├─ BehaviorTracker      │  + नॉन्स  │  ├─ RateLimiter      │
│  ├─ HoneypotTraps        │───────────▶│  ├─ TamperDetector   │
│  ├─ स्टैक ट्रेस ट्रैप   │            │  ├─ computeVerdict() │
│  └─ IframeContext         │            │  └─ Proof-of-Work   │
│                         │  फैसला     │                        │
│  ↓ collect() →          │  + प्रूफ  │  रिटर्न करता है:     │
│  DetectionResult[]      │◀───────────│  { verdict, score,    │
└──────────────────────────┘            │    confidence, proof, │
                                        │    tamperScore }      │
                                        └──────────────────────┘
                                              │
                                              ▼
                                        सत्र-गेटेड एंडपॉइंट
                                        (लॉगिन, चेकआउट, आदि)
                                        प्रूफ को मान्य करता है
                                        एक्सेस देने से पहले

npm install
npm run build

<script src="/path/to/botdetect.min.js"></script>
<script>
  BotDetect.collector.enableTraps();
  BotDetect.collector.enableBehavioralTracking();
  BotDetect.collector.enableHoneypots();
</script>

cd server
npm install express cors express-session
node example-integration.js

async function onLogin() {
  const { nonce } = await (await fetch('/api/botdetect/nonce')).json();
  BotDetect.collector.setNonce(nonce);

  const signals = await BotDetect.collector.collect();

  const resp = await fetch('/api/botdetect/verify', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ signals, nonce })
  });
  const { verdict, score, proof, friction } = await resp.json();

  document.getElementById('botdetect-proof').value = proof;
  document.getElementById('login-form').submit();
}

app.post('/api/login', (req, res) => {
  const bd = req.session.botdetect;
  if (!bd) return res.status(403).json({ error: 'no_verification' });
  if (bd.verdict === 'bot') return res.status(403).json({ error: 'access_denied' });
  if (bd.verdict === 'suspicious') return challengeCaptcha(req, res);
  res.json({ success: true });
});

import Collector from './collector/Collector';
// या वैश्विक के माध्यम से: BotDetect.collector

import Detector from './detector/Detector';

interface DetectionResult {
  name: string;      // मॉड्यूल नाम
  score: number;     // 0.0 – 1.0
  weight: number;    // 1 – 10 (महत्व)
  detail?: string;   // मानव-पठनीय विवरण
}

interface DetectionVerdict {
  verdict: 'bot' | 'suspicious' | 'human';
  score: number;       // 0.0 – 1.0
  confidence: number;  // 0.0 – 1.0
  signals: DetectionResult[];
  threshold: number;
  friction: 'monitor' | 'challenge' | 'block';
}

interface CollectorConfig {
  detectionTimeoutMs: number;   // प्रति-मॉड्यूल टाइमआउट (डिफ़ॉल्ट: 3000)
  enableTraps: boolean;
  enableBehavioralTracking: boolean;
  enableHoneypots: boolean;
  thresholds: { strict: number; balanced: number; relaxed: number };
}

const { createBotDetectEndpoint } = require('./server');

const { router, generateProofOfWork, cleanup } = createBotDetectEndpoint({
  secretSalt: process.env.BOTDETECT_SALT,
  scoring: {
    threshold: 'balanced',       // 'strict' | 'balanced' | 'relaxed' | number
    minSignals: 2,
    signalBoostThreshold: 0.8,
    frictionThresholds: { monitor: 0.2, challenge: 0.5, block: 0.8 }
  },
  nonce: { ttl: 300000 },              // 5-मिनट नॉन्स समाप्ति
  noScript: { timeout: 10000 },         // 10s नो-स्क्रिप्ट विंडो
  rateLimit: { maxRequests: 10, windowMs: 60000 },
  noScriptPaths: ['/api/login', '/api/checkout', '/api/register']
});

app.use('/api', router);

{
  "verdict": "human",
  "score": 0.125,
  "confidence": 0.85,
  "tamperScore": 0,
  "friction": "monitor",
  "threshold": 0.5,
  "proof": "a1b2c3d4e5f6..."
}

const { computeVerdict, RateLimiter, NonceManager } = require('./scoring');

const verdict = computeVerdict(signals, {
  threshold: 'balanced',
  minSignals: 2,
  signalBoostThreshold: 0.8,
  frictionThresholds: { monitor: 0.2, challenge: 0.5, block: 0.8 }
});

// अगर सिग्नल छेड़छाड़ का पता चला तो verdict.tamperScore > 0

const collector = Collector.getInstance({
  detectionTimeoutMs: 1000,    // तेज़ UX के लिए कम करें
  enableTraps: true,
  enableBehavioralTracking: true,
  enableHoneypots: true,
  thresholds: {
    strict: 0.3,     // आक्रामक (लॉगिन, चेकआउट)
    balanced: 0.5,   // डिफ़ॉल्ट
    relaxed: 0.7     // अनुमति देने वाला (सामग्री ब्राउज़िंग)
  }
});

const detector = Detector.getInstance({
  threshold: 'balanced',      // 'strict' | 'balanced' | 'relaxed' | number
  minSignals: 2,              // बूस्ट से पहले न्यूनतम सिग्नल
  signalBoostThreshold: 0.8,  // इससे ऊपर के सिग्नल को अतिरिक्त भार मिलता है
  failPolicy: 'open',         // 'open' = त्रुटि पर मानव, 'closed' = त्रुटि पर बॉट
  frictionThresholds: {
    monitor: 0.2,
    challenge: 0.5,
    block: 0.8
  }
});

createBotDetectEndpoint({
  secretSalt: process.env.BOTDETECT_SALT,  // गुप्त रखें
  scoring: { threshold: 'balanced' },
  nonce: { ttl: 300000, cleanupInterval: 60000 },
  noScript: { timeout: 10000 },
  rateLimit: { maxRequests: 10, windowMs: 60000 },
  requestFingerprint: true,                // PoW को अनुरोध विशेषताओं से बांधें
  noScriptPaths: ['/api/login', '/api/checkout']
});

npm test              # 74 Jest परीक्षण 6 सूट में
npm run typecheck     # TypeScript सख्त मोड
npm run lint          # ESLint
npm run build         # Webpack उत्पादन बंडल