fraud-sim 0.2.0 → 0.5.0

package/examples/adaptive-hardened-demo/index.js

@@ -0,0 +1,106 @@
+/**
+ * The adaptation demo: the same attacker against two different defences.
+ *
+ * Run the hardened target first:
+ *   npm run example:hardened-target      (terminal 1, port 4001)
+ *   npm run example:mock-target          (terminal 2, port 4000)
+ *   npm run example:adaptive-hardened    (terminal 3)
+ *
+ * Against the simple target the attacker wins on move one and never adapts —
+ * which tells you about that target's cold-start gap and nothing at all about
+ * the attacker. Against the hardened target it has to work, and the round log
+ * shows what it changed and why.
+ */
+
+import { run } from '../../src/index.js';
+import { httpAdapter } from '../../src/adapters/http.js';
+
+const SIMPLE = 'http://localhost:4000';
+const HARDENED = 'http://localhost:4001';
+const SEED = 7;
+
+const COLOUR = { BLOCK: '\x1b[31m', STEP_UP: '\x1b[33m', ALLOW: '\x1b[32m', ERROR: '\x1b[35m' };
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+
+async function attack(label, baseUrl) {
+  const target = httpAdapter({
+    baseUrl,
+    endpoints: { scoreLogin: '/score/login' },
+  });
+
+  // Clear the target's memory so each run starts from the same place.
+  try {
+    await fetch(`${baseUrl}/reset`, { method: 'POST' });
+  } catch {
+    console.error(`  Could not reach ${baseUrl} — is that target running?`);
+    return null;
+  }
+
+  console.log(`\n${'═'.repeat(72)}`);
+  console.log(`  ${label}  ${DIM}${baseUrl}${RESET}`);
+  console.log('═'.repeat(72));
+
+  let pendingReasoning = '';
+
+  const report = await run('adaptive-attacker', {
+    target,
+    options: { targetUserId: 'victim_001', maxRounds: 8, delayMs: 120 },
+    seed: SEED,
+    onEvent: (event) => {
+      if (event.type === 'attacker_adapts') {
+        pendingReasoning = event.reasoning;
+      } else if (event.type === 'response') {
+        const decision = event.response?.decision ?? 'ERROR';
+        const colour = COLOUR[decision] ?? '';
+        const codes = (event.response?.reasons ?? []).map((r) => r.code).join(', ') || '—';
+        const score = event.response?.riskScore;
+
+        console.log(
+          `\n  round ${String(event.round).padStart(2)}  ` +
+            `${colour}${decision.padEnd(8)}${RESET}` +
+            `${DIM}risk ${score != null ? score.toFixed(2) : '—'}${RESET}  ${codes}`
+        );
+        console.log(`          ${DIM}↳ ${pendingReasoning}${RESET}`);
+      }
+    },
+  });
+
+  const verdict =
+    report.outcome === 'attacker_succeeded'
+      ? `${COLOUR.ALLOW}attacker succeeded${RESET} on round ${report.attempts}`
+      : `${COLOUR.BLOCK}attacker defeated${RESET} after ${report.attempts} rounds`;
+
+  console.log(`\n  ${verdict}`);
+  console.log(
+    `  ${DIM}blocked ${report.blocked} · challenged ${report.stepUp} · allowed ${report.allowed}${RESET}`
+  );
+
+  return report;
+}
+
+const simple = await attack('SIMPLE TARGET', SIMPLE);
+const hardened = await attack('HARDENED TARGET', HARDENED);
+
+if (simple && hardened) {
+  console.log(`\n${'═'.repeat(72)}`);
+  console.log('  WHAT CHANGED');
+  console.log('═'.repeat(72));
+  console.log(`
+  Same scenario, same seed (${SEED}), two defences.
+
+  Simple target    ${simple.attempts} round(s) — ${simple.outcome}
+  Hardened target  ${hardened.attempts} round(s) — ${hardened.outcome}
+
+  The simple target allows an unrecognised device outright, so the attacker's
+  opening move works and no adaptation is ever needed or visible. The hardened
+  target only ever challenges an unrecognised device, so rotation can win back
+  a step-up but never an allow.
+
+  The gap the hardened target leaves: a device that was challenged is
+  remembered as seen, not as bad. An attacker that reuses it from a clean IP is
+  allowed through. The deterministic provider never tries that — it rotates its
+  fingerprint every round. Point a real LLM at it with --llm and see whether it
+  finds what the scripted attacker cannot.
+`);
+}

package/examples/basic-credential-stuffing/index.js

@@ -26,9 +26,11 @@ console.log('\n=== Credential stuffing simulation ===\n');
 const report = await run('credential-stuffing', {
   target,
   options: {
-    targetUserId: 'victim_user_001',
+    // A credential dump is a list of victims. Spraying across accounts is
+    // what lets the target's "one IP, many users" rule fire at all.
+    targetUserIds: Array.from({ length: 12 }, (_, i) => `victim_user_${i + 1}`),
     attackerCount: 10,
-    attemptsPerIp: 3,
+    attemptsPerIp: 25,
     delayMs: 50,
   },
   onEvent: (e) => {

package/examples/express-hardened-target/server.js

@@ -0,0 +1,230 @@
+/**
+ * Hardened mock fraud target — the one that makes an attacker work for it.
+ *
+ * The basic example target (`examples/express-mock-target`) has a gap the
+ * adaptive attacker walks straight through: a first login from an unknown
+ * device scores below the challenge threshold, so the attacker wins on move one
+ * and never has to adapt. That is a fine demonstration of a cold-start weakness
+ * and a poor demonstration of an adaptive adversary.
+ *
+ * This target closes that gap. Its central rule is simple and strict:
+ *
+ *   **An unrecognised device is never allowed outright — only challenged.**
+ *
+ * That single decision is what defeats an attacker whose whole strategy is
+ * rotation. Rotating the IP can get you from BLOCK back to STEP_UP; nothing you
+ * rotate gets you to ALLOW, because rotating *creates* the unrecognised device
+ * that triggers the challenge.
+ *
+ * Supporting rules:
+ *   - **IP reputation** — ~57% of address space is treated as known-abusive, so
+ *     an attacker's exit is usually burned and it has to keep looking.
+ *   - **Device recidivism** — a fingerprint present on a blocked attempt is
+ *     refused permanently, so a burned device cannot come back.
+ *   - **Rotation and velocity** — many networks or many attempts against one
+ *     account in a short window add score, so a long campaign gets harder.
+ *
+ * ── The gap this target deliberately leaves ───────────────────────────
+ * A device that was only *challenged* is remembered as seen, not as bad. Replay
+ * it from a clean IP and you get an ALLOW. The shipped deterministic attacker
+ * never finds this, because it rotates its fingerprint every single round. An
+ * attacker that reasons "step-up is not a block — reuse that device" beats this
+ * target immediately.
+ *
+ * That asymmetry is the point of running both targets. Against the simple
+ * target the difference between a scripted and an adaptive adversary does not
+ * show up, because everything wins on move one. Here it does: the same scenario
+ * is defeated with the deterministic provider and can succeed with a capable
+ * LLM behind it.
+ *
+ * Run: `npm run example:hardened-target`   → http://localhost:4001
+ * Then: `npm run example:adaptive-hardened`
+ *
+ * Still a teaching implementation, not a production engine. In particular,
+ * challenging every unrecognised device is a real trade: it stops this attacker
+ * and it puts a step-up in front of every customer who buys a new phone.
+ */
+
+
+import express from 'express';
+
+const app = express();
+app.use(express.json());
+
+// ── configuration ───────────────────────────────────────────────────────
+
+const WEIGHTS = {
+  NEW_DEVICE: 0.35,
+  IP_KNOWN_ABUSIVE: 0.55,
+  IP_ROTATION_PATTERN: 0.3,
+  LOGIN_VELOCITY_USER: 0.35,
+};
+
+const THRESHOLDS = { allowMax: 0.35, blockMin: 0.6 };
+
+/**
+ * Synthetic IP reputation. Roughly 57% of the first-octet space is treated as
+ * known-abusive — high, but not unrealistic for a list that includes hosting
+ * and proxy ranges, and high enough that an attacker's opening exit usually
+ * fails. These are invented ranges for the demo, not real reputation data.
+ */
+const ABUSIVE_OCTET_RANGES = [
+  [1, 50],
+  [100, 140],
+  [200, 254],
+];
+
+/** Distinct networks per user before rotation itself becomes the signal. */
+const ROTATION_LIMIT = 6;
+
+/** Attempts per user, in-window, before velocity fires. */
+const VELOCITY_LIMIT = 8;
+
+// ── state ───────────────────────────────────────────────────────────────
+
+const seen = {
+  attemptsByUser: new Map(), // userId → count in window
+  networksByUser: new Map(), // userId → Set<first octet>
+  devicesByUser: new Map(), // userId → Set<fingerprint>
+  blockedDevices: new Set(), // fingerprints refused on sight
+  blockedIps: new Set(),
+};
+
+// Decay the windowed counters, as a real engine's TTLs would.
+setInterval(() => {
+  for (const [user, count] of seen.attemptsByUser) {
+    const next = Math.floor(count * 0.5);
+    if (next === 0) seen.attemptsByUser.delete(user);
+    else seen.attemptsByUser.set(user, next);
+  }
+  seen.networksByUser.clear();
+}, 60000);
+
+// ── scoring ─────────────────────────────────────────────────────────────
+
+function isAbusive(ip) {
+  const octet = Number(String(ip).split('.')[0]);
+  if (!Number.isInteger(octet)) return false;
+  return ABUSIVE_OCTET_RANGES.some(([lo, hi]) => octet >= lo && octet <= hi);
+}
+
+function isBrowserAgent(ua) {
+  return typeof ua === 'string' && /Mozilla\/5\.0/.test(ua);
+}
+
+app.post('/score/login', (req, res) => {
+  const { user_id, ip_address, device_fingerprint, user_agent } = req.body ?? {};
+  const reasons = [];
+  let score = 0;
+  let forceBlock = false;
+
+  const add = (code, weight, hard = false) => {
+    reasons.push({ code, weight });
+    score += weight;
+    if (hard) forceBlock = true;
+  };
+
+  // A tool user agent is not a person. Refused outright, which is why the
+  // adaptive attacker's browser-agent baseline is the right opening move.
+  if (!isBrowserAgent(user_agent)) {
+    add('UA_NOT_BROWSER', 1, true);
+  }
+
+  // A fingerprint that was present on a blocked attempt does not get a second
+  // chance — so a working device cannot simply be replayed.
+  if (device_fingerprint && seen.blockedDevices.has(device_fingerprint)) {
+    add('DEVICE_RECIDIVIST', 1, true);
+  }
+
+  if (ip_address && seen.blockedIps.has(ip_address)) {
+    add('IP_PREVIOUSLY_BLOCKED', 1, true);
+  }
+
+  if (isAbusive(ip_address)) {
+    add('IP_KNOWN_ABUSIVE', WEIGHTS.IP_KNOWN_ABUSIVE);
+  }
+
+  const attempts = (seen.attemptsByUser.get(user_id) ?? 0) + 1;
+  seen.attemptsByUser.set(user_id, attempts);
+  if (attempts > VELOCITY_LIMIT) {
+    add('LOGIN_VELOCITY_USER', WEIGHTS.LOGIN_VELOCITY_USER);
+  }
+
+  // Rotation as a signal. One person does not reach an account from four
+  // unrelated networks in a few minutes; an attacker burning through exits
+  // does exactly that.
+  const networks = seen.networksByUser.get(user_id) ?? new Set();
+  networks.add(String(ip_address).split('.')[0]);
+  seen.networksByUser.set(user_id, networks);
+  if (networks.size > ROTATION_LIMIT) {
+    add('IP_ROTATION_PATTERN', WEIGHTS.IP_ROTATION_PATTERN);
+  }
+
+  const devices = seen.devicesByUser.get(user_id) ?? new Set();
+  if (device_fingerprint && !devices.has(device_fingerprint)) {
+    add('NEW_DEVICE', WEIGHTS.NEW_DEVICE);
+    devices.add(device_fingerprint);
+    seen.devicesByUser.set(user_id, devices);
+  }
+
+  const riskScore = Math.min(score, 1);
+  const decision =
+    forceBlock || riskScore >= THRESHOLDS.blockMin
+      ? 'BLOCK'
+      : riskScore >= THRESHOLDS.allowMax
+        ? 'STEP_UP'
+        : 'ALLOW';
+
+  // Remember what we refused. This is the memory that makes rotation the only
+  // way forward, and eventually makes rotation itself expensive.
+  if (decision === 'BLOCK') {
+    if (device_fingerprint) seen.blockedDevices.add(device_fingerprint);
+    if (ip_address) seen.blockedIps.add(ip_address);
+  }
+
+  res.json({ decision, risk_score: riskScore, reasons });
+});
+
+// Withdrawals and actions reuse the simple target's posture — this example
+// exists to harden the *login* path, which is where adaptation happens.
+app.post('/score/withdrawal', (req, res) => {
+  const { transaction } = req.body ?? {};
+  const reasons = [];
+  let score = 0;
+
+  if (transaction?.is_new_payee) {
+    reasons.push({ code: 'NEW_PAYEE_FIRST_TXN', weight: 0.3 });
+    score += 0.3;
+  }
+  if (transaction?.is_new_payee && transaction.amount > 5000000) {
+    reasons.push({ code: 'NEW_PAYEE_HIGH_AMOUNT', weight: 0.45 });
+    score += 0.45;
+  }
+
+  const decision = score >= 0.6 ? 'BLOCK' : score >= 0.35 ? 'STEP_UP' : 'ALLOW';
+  res.json({ decision, risk_score: Math.min(score, 1), reasons });
+});
+
+app.post('/score/action', (req, res) => {
+  res.json({ decision: 'ALLOW', risk_score: 0, reasons: [] });
+});
+
+app.post('/event/:type', (req, res) => res.json({ ok: true }));
+
+/** Test-only, as in the simple target — see its /reset for why. */
+app.post('/reset', (req, res) => {
+  seen.attemptsByUser.clear();
+  seen.networksByUser.clear();
+  seen.devicesByUser.clear();
+  seen.blockedDevices.clear();
+  seen.blockedIps.clear();
+  res.json({ ok: true });
+});
+
+app.get('/health', (req, res) => res.json({ status: 'ok', profile: 'hardened' }));
+
+const PORT = process.env.PORT || 4001;
+app.listen(PORT, () => {
+  console.log(`Hardened mock fraud target listening on http://localhost:${PORT}`);
+  console.log('Try: npm run example:adaptive-hardened in another terminal');
+});

package/examples/express-mock-target/server.js

@@ -5,6 +5,9 @@
  * meaningful block rates. This is NOT FriskLayer — it's a stripped-down
  * pedagogical example showing the kind of system fraud-sim tests against.
  *
+ * Covers all three scoring endpoints (`/score/login`, `/score/withdrawal`,
+ * `/score/action`), so every shipped scenario can run against it.
+ *
  * Run: `npm run example:mock-target`
  * Then point a scenario at http://localhost:4000
  */
@@ -21,11 +24,22 @@ const seen = {
   loginsByIp: new Map(),        // ip → number
   payeesByUser: new Map(),      // userId → Set<payeeAccount>
   newPayeesByUser: new Map(),   // userId → number of new payees in last 30 min
+  cardAuthsByUser: new Map(),   // userId → number of card auths in window
+  binsByUser: new Map(),        // userId → Map<bin, count>
+  signupsByDevice: new Map(),   // deviceFp → number of signups
+  signupsBySubnet: new Map(),   // /24 → number of signups
+  payoutAccounts: new Map(),    // payoutAccount → Set<userId>
+  sessionOrigin: new Map(),     // sessionId → { device, ip }
 };
 
 // Decay counters every minute
 setInterval(() => {
-  for (const map of [seen.loginsByUser, seen.loginsByIp, seen.newPayeesByUser]) {
+  for (const map of [
+    seen.loginsByUser,
+    seen.loginsByIp,
+    seen.newPayeesByUser,
+    seen.cardAuthsByUser,
+  ]) {
     for (const [key, count] of map) {
       const next = Math.floor(count * 0.5);
       if (next === 0) map.delete(key);
@@ -64,6 +78,14 @@ app.post('/score/login', (req, res) => {
     seen.devicesByUser.set(user_id, userDevices);
   }
 
+  // Remember where this session began, so later activity can be compared to it.
+  if (req.body?.session_id) {
+    seen.sessionOrigin.set(req.body.session_id, {
+      device: device_fingerprint,
+      ip: ip_address,
+    });
+  }
+
   const decision = score >= 0.65 ? 'BLOCK' : score >= 0.35 ? 'STEP_UP' : 'ALLOW';
 
   res.json({
@@ -74,10 +96,24 @@ app.post('/score/login', (req, res) => {
 });
 
 app.post('/score/withdrawal', (req, res) => {
-  const { user_id, transaction } = req.body ?? {};
+  const { user_id, transaction, session_id, device_fingerprint, ip_address } = req.body ?? {};
   const reasons = [];
   let score = 0;
 
+  // Rule: session continuity at the point money moves — the check that catches
+  // a hijacked session, which never produced a login event of its own.
+  if (session_id) {
+    const origin = seen.sessionOrigin.get(session_id);
+    if (origin && origin.device !== device_fingerprint) {
+      reasons.push({ code: 'DEVICE_SESSION_MISMATCH', weight: 0.5 });
+      score += 0.5;
+    }
+    if (origin && origin.ip !== ip_address) {
+      reasons.push({ code: 'IP_SESSION_MISMATCH', weight: 0.3 });
+      score += 0.3;
+    }
+  }
+
   // Rule: new payee
   if (transaction?.is_new_payee) {
     reasons.push({ code: 'NEW_PAYEE_FIRST_TXN', weight: 0.2 });
@@ -108,11 +144,126 @@ app.post('/score/withdrawal', (req, res) => {
   });
 });
 
+/**
+ * Generic action scoring — signups, promo claims, card authorisations, and
+ * in-session activity. The `card-testing`, `promo-abuse` and `session-hijack`
+ * scenarios need this endpoint; without it they cannot run at all.
+ *
+ * As with the rules above, these are pedagogical: enough structure for a
+ * scenario to produce a meaningful result, not a real detection engine.
+ */
+app.post('/score/action', (req, res) => {
+  const { user_id, action_type, ip_address, device_fingerprint, session_id, details } =
+    req.body ?? {};
+  const reasons = [];
+  let score = 0;
+
+  const subnet = String(ip_address ?? '').split('.').slice(0, 3).join('.');
+
+  if (action_type === 'card_auth') {
+    // Rule: micro-authorisation velocity. Card testers probe fast and cheap.
+    const authCount = (seen.cardAuthsByUser.get(user_id) ?? 0) + 1;
+    seen.cardAuthsByUser.set(user_id, authCount);
+    if (authCount > 8) {
+      reasons.push({ code: 'CARD_AUTH_VELOCITY', weight: 0.4 });
+      score += 0.4;
+    }
+
+    // Rule: BIN concentration. A genuine merchant sees many BINs; a stolen
+    // list drawn from one breach sees very few.
+    const bins = seen.binsByUser.get(user_id) ?? new Map();
+    const bin = details?.card_bin ?? 'unknown';
+    bins.set(bin, (bins.get(bin) ?? 0) + 1);
+    seen.binsByUser.set(user_id, bins);
+    const busiestBin = Math.max(...bins.values());
+    if (busiestBin > 5 && bins.size <= 4) {
+      reasons.push({ code: 'BIN_CONCENTRATION', weight: 0.35 });
+      score += 0.35;
+    }
+
+    // Rule: trivial amount, card not present — the shape of a probe.
+    if (details?.entry_mode === 'card_not_present' && (details?.amount ?? 0) < 10000) {
+      reasons.push({ code: 'MICRO_AUTH_CNP', weight: 0.2 });
+      score += 0.2;
+    }
+  }
+
+  if (action_type === 'signup' || action_type === 'promo_claim') {
+    // Rule: device reuse across accounts.
+    const perDevice = (seen.signupsByDevice.get(device_fingerprint) ?? 0) + 1;
+    seen.signupsByDevice.set(device_fingerprint, perDevice);
+    if (perDevice > 3) {
+      reasons.push({ code: 'DEVICE_MANY_ACCOUNTS', weight: 0.45 });
+      score += 0.45;
+    }
+
+    // Rule: subnet clustering.
+    const perSubnet = (seen.signupsBySubnet.get(subnet) ?? 0) + 1;
+    seen.signupsBySubnet.set(subnet, perSubnet);
+    if (perSubnet > 6) {
+      reasons.push({ code: 'SUBNET_MANY_SIGNUPS', weight: 0.3 });
+      score += 0.3;
+    }
+
+    // Rule: payout concentration — many accounts, one destination.
+    const payout = details?.payout_account;
+    if (payout) {
+      const users = seen.payoutAccounts.get(payout) ?? new Set();
+      users.add(user_id);
+      seen.payoutAccounts.set(payout, users);
+      if (users.size > 4) {
+        reasons.push({ code: 'PAYOUT_CONCENTRATION', weight: 0.4 });
+        score += 0.4;
+      }
+    }
+  }
+
+  // Rule: session continuity. The device and network a session was opened from
+  // should be the ones it continues from.
+  if (session_id) {
+    const origin = seen.sessionOrigin.get(session_id);
+    if (!origin) {
+      seen.sessionOrigin.set(session_id, { device: device_fingerprint, ip: ip_address });
+    } else {
+      if (origin.device !== device_fingerprint) {
+        reasons.push({ code: 'DEVICE_SESSION_MISMATCH', weight: 0.5 });
+        score += 0.5;
+      }
+      if (origin.ip !== ip_address) {
+        reasons.push({ code: 'IP_SESSION_MISMATCH', weight: 0.3 });
+        score += 0.3;
+      }
+    }
+  }
+
+  const decision = score >= 0.65 ? 'BLOCK' : score >= 0.35 ? 'STEP_UP' : 'ALLOW';
+
+  res.json({
+    decision,
+    risk_score: Math.min(score, 1.0),
+    reasons,
+  });
+});
+
 app.post('/event/:type', (req, res) => {
   // Accept and discard — this mock doesn't process side events
   res.json({ ok: true });
 });
 
+/**
+ * Clear all in-memory state.
+ *
+ * Test-only. A real fraud system has no such endpoint — but when running
+ * several scenarios in sequence against one instance, counters and device
+ * history from an earlier scenario leak into a later one and make each
+ * scenario look guiltier than it is. Reset between scenarios to measure each
+ * attack independently.
+ */
+app.post('/reset', (req, res) => {
+  for (const map of Object.values(seen)) map.clear();
+  res.json({ ok: true });
+});
+
 app.get('/health', (req, res) => res.json({ status: 'ok' }));
 
 const PORT = process.env.PORT || 4000;

package/package.json

@@ -1,20 +1,42 @@
 {
   "name": "fraud-sim",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "Realistic synthetic attack traffic for testing fintech fraud detection systems",
   "type": "module",
   "main": "src/index.js",
   "exports": {
-    ".": "./src/index.js",
-    "./adapters": "./src/adapters/index.js",
-    "./streaming": "./src/streaming/index.js",
-    "./llm": "./src/llm/index.js"
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./adapters": {
+      "types": "./types/adapters/index.d.ts",
+      "default": "./src/adapters/index.js"
+    },
+    "./streaming": {
+      "types": "./types/streaming/index.d.ts",
+      "default": "./src/streaming/index.js"
+    },
+    "./llm": {
+      "types": "./types/llm/index.d.ts",
+      "default": "./src/llm/index.js"
+    },
+    "./utils": {
+      "types": "./types/utils/index.d.ts",
+      "default": "./src/utils/index.js"
+    },
+    "./reporting": {
+      "types": "./types/reporting/index.d.ts",
+      "default": "./src/reporting/index.js"
+    }
   },
   "engines": {
     "node": ">=20"
   },
   "files": [
+    "bin/",
     "src/",
+    "types/",
     "examples/",
     "README.md",
     "LICENSE",
@@ -29,8 +51,12 @@
     "example:basic": "node examples/basic-credential-stuffing/index.js",
     "example:drain": "node examples/account-drain-demo/index.js",
     "example:mock-target": "node examples/express-mock-target/server.js",
+    "example:hardened-target": "node examples/express-hardened-target/server.js",
     "example:adaptive-target": "node examples/adaptive-attacker-demo/demo-target.js",
-    "example:adaptive": "node examples/adaptive-attacker-demo/index.js"
+    "example:adaptive": "node examples/adaptive-attacker-demo/index.js",
+    "build:types": "tsc",
+    "prepublishOnly": "npm run build:types && npm run lint && npm run test:all",
+    "example:adaptive-hardened": "node examples/adaptive-hardened-demo/index.js"
   },
   "keywords": [
     "fraud",
@@ -45,7 +71,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/arthurr-beep/fraudsim.git"
+    "url": "git+https://github.com/arthurr-beep/fraudsim.git"
   },
   "bugs": {
     "url": "https://github.com/arthurr-beep/fraudsim/issues"
@@ -53,8 +79,14 @@
   "homepage": "https://github.com/arthurr-beep/fraudsim#readme",
   "devDependencies": {
     "@eslint/js": "^9.39.5",
+    "@types/node": "^20.19.43",
     "eslint": "^9.39.5",
     "express": "^4.21.0",
-    "globals": "^17.11.0"
+    "globals": "^17.11.0",
+    "typescript": "^5.9.3"
+  },
+  "types": "./types/index.d.ts",
+  "bin": {
+    "fraud-sim": "bin/fraud-sim.js"
   }
 }