Everything about Venoly, readable by machines

guard anti_spam on message lock strict {

  rule rapid_fire when user.messages_last_minute > 20 {
    action warn("User sending " + str(user.messages_last_minute) + " msgs/min");
    action flag("rapid_fire", "High message rate");
  }

  rule spam_burst when user.messages_last_minute > 40 {
    action block("spam", "Automated spam detected");
    action log("BLOCKED spam from user " + str(user.id));
  }
}

{ "actions": [
    { "action": "block", "args": ["spam", "Automated spam detected"] },
    { "action": "log",   "args": ["BLOCKED spam from user 4821"] }
] }

Sandbox   the input context is structuredClone()'d + Object.freeze()'d — a policy
          cannot mutate it or reach outside it; no filesystem, network, process,
          eval or code generation; no random, no clock → fully deterministic.

Lock level    Max cycles    Timeout      Max stack
standard        100,000       5,000 ms        512
strict           50,000       2,000 ms        256
paranoid         10,000       1,000 ms        128
              (the strictest lock across a program's guards is enforced)

// intact:
{ "ok": true,  "total": 14213, "brokenAt": null }

// if any past entry was altered, the chain breaks at that point:
{ "ok": false, "total": 14213, "brokenAt": 9042, "reason": "entry_hash_mismatch" }

{ "verified": true }

// if something was changed outside the normal edit path, the exact failure is named:
{ "verified": false, "reason": "tampered" }          // HMAC signature mismatch
{ "verified": false, "reason": "content_modified" }  // message body hash mismatch
{ "verified": false, "reason": "unsigned" }          // no signature on record

Aegis  (bot / automation timing)
  Keep the last 50 request timestamps per IP/user; score = coefficient of
  variation of the inter-arrival gaps = (stdDev / mean) × 100, clamped 0–100.
  Robotically even traffic → low CoV; natural human jitter → high. Fed to Venilator.

Sentinel  (login risk — additive per attempt)
  new device +30 · country change within 1 h +35 · 5+ failures in 15 min +20
  score ≥ 50 → recorded as "challenge"   score ≥ 80 → recorded as "block"
  (advisory: logged on the account's login events, not yet enforced)

Cipher  (audit ledger)
  entry_hash = SHA-256( canonical JSON of
    { prevHash, seq, actor, scope, action, target, payload, createdAt } )
  genesis = 64 zeros. verify() recomputes every link and returns the exact
  seq where the chain breaks (prev_hash_mismatch | entry_hash_mismatch).

Warden  (message integrity)
  HMAC-SHA-256( messageId | authorId | SHA-256(content) | createdAt ),
  keyed by a server secret — the service refuses an insecure default in production.

const GENESIS = "0".repeat(64);

function hashEntry(e) {                       // storage abstracted; hashing is real
  const canonical = JSON.stringify({
    prevHash: e.prevHash, seq: e.seq, actorId: e.actorId ?? null,
    scope: e.scope, action: e.action, target: e.target ?? null,
    payload: e.payload ?? {}, createdAt: e.createdAt,
  });
  return sha256(canonical);                   // no secret → anyone with the export can recompute
}

function verify(entries) {                    // entries ordered by seq
  let prev = GENESIS;
  for (const e of entries) {
    if (e.prevHash !== prev)          return { ok: false, brokenAt: e.seq, reason: "prev_hash_mismatch" };
    if (hashEntry(e) !== e.entryHash) return { ok: false, brokenAt: e.seq, reason: "entry_hash_mismatch" };
    prev = e.entryHash;
  }
  return { ok: true, total: entries.length, brokenAt: null };
}

function sign(m) {                            // key loaded from env; no insecure default in prod
  const canonical = m.messageId + "|" + m.authorId + "|" + sha256(m.content) + "|" + m.createdAt;
  return hmacSha256(canonical, SERVER_SECRET); // symmetric → server-verifiable, not client-verifiable
}

function verifyMessage(m, record) {
  if (!record)                                  return { verified: false, reason: "unsigned" };
  if (record.signature   !== sign(m))           return { verified: false, reason: "tampered" };
  if (record.contentHash !== sha256(m.content)) return { verified: false, reason: "content_modified" };
  return { verified: true };
}

function timingScore(timestamps) {            // the last ~50 request times
  if (timestamps.length < 5) return 50;       // not enough data
  const gaps = [];
  for (let i = 0; i < timestamps.length - 1; i++)
    gaps.push(Math.abs(timestamps[i] - timestamps[i + 1]));
  const mean = gaps.reduce((a, b) => a + b, 0) / gaps.length;
  const variance = gaps.reduce((a, b) => a + (b - mean) ** 2, 0) / gaps.length;
  const cv = (Math.sqrt(variance) / mean) * 100;   // coefficient of variation
  return Math.min(Math.max(cv, 0), 100);      // ~0 = robotically even, high = human jitter
}

function scoreLogin({ knownDevice, countryJumpUnderAnHour, impossibleTravel, failuresLast15m }) {
  let risk = 0; const reasons = [];
  if (!knownDevice)            { risk += 30; reasons.push("new_device"); }
  if (countryJumpUnderAnHour)  { risk += 35; reasons.push("country_jump"); }
  if (impossibleTravel)        { risk += 25; reasons.push("geo_velocity_impossible"); }
  if (failuresLast15m >= 5)    { risk += 20; reasons.push("credential_stuffing"); }
  risk = Math.min(risk, 100);
  return { riskScore: risk, reasons, decision: risk >= 80 ? "block" : risk >= 50 ? "challenge" : "allow" };
}

// Sandbox: deep-freeze the input, then run bytecode under the strictest lock level.
const LOCK_LEVELS = {
  standard: { maxCycles: 100000, timeoutMs: 5000, maxStackDepth: 512 },
  strict:   { maxCycles:  50000, timeoutMs: 2000, maxStackDepth: 256 },
  paranoid: { maxCycles:  10000, timeoutMs: 1000, maxStackDepth: 128 },
};

execute(context) {
  const limits = LOCK_LEVELS[this.strictestLockLevel()];   // strictest across all guards
  const frozen = deepFreeze(structuredClone(context));     // a policy cannot mutate its input
  const vm = new VM(this.compiledProgram, { context: frozen, limits });
  return vm.run();                                         // -> { actions: [...] }
}

// VM: stack machine. Deterministic — same context + policy => same actions, always.
run() {
  this.limiter.reset();
  while (!this.halted && this.ip < this.bytecode.length) {
    this.limiter.tick();                          // ++cycles; throws past maxCycles
    switch (this.bytecode[this.ip]) {
      case Opcode.HALT:       this.halted = true; break;
      case Opcode.LOAD_CONST: this.push(this.constants[this.bytecode[this.ip + 1]]); this.ip += 2; break;
      case Opcode.LOAD_VAR:   this.push(this.resolveVariable(this.constants[this.bytecode[this.ip + 1]]) ?? 0); this.ip += 2; break;
      case Opcode.CMP_GT:        { const b = this.pop(), a = this.pop(); this.push(a > b); this.ip++; break; }
      case Opcode.JUMP_IF_FALSE: { const t = this.bytecode[this.ip + 1]; this.ip = this.pop() ? this.ip + 2 : t; break; }
      case Opcode.ACTION:     this.executeAction(this.actions[this.bytecode[this.ip + 1]]); this.ip += 2; break;
      // ... NOP, POP, CMP_LT/GTE/LTE/EQ/NEQ, LOGIC_AND/OR/NOT, JUMP, JUMP_IF_TRUE, LOG, RATE_CHECK, GUARD_* ...
    }
  }
  return { actions: this.executedActions };
}