raptiye 0.1.0

package/bench/bench-partition.js

@@ -0,0 +1,134 @@
+/**
+ * Benchmark: Network Partition and Split-Brain Safety.
+ * Tests:
+ * 1. Leader isolated (minority partition): verifies isolated leader cannot commit.
+ * 2. Majority partition elects new leader and commits new commands.
+ * 3. Follower isolated: majority continues committing without pause.
+ * 4. Partition heal: old leader demotes itself and reconciles log.
+ */
+
+import { ClusterSimulator } from '../src/sim/cluster.js';
+import { getEnvironmentMetadata, formatTable } from './harness.js';
+import { Role, EventType } from '../src/types.js';
+
+export async function runPartitionBenchmark() {
+  const scenarios = [];
+
+  // Scenario 1: Isolated Leader Safety
+  {
+    const cluster = new ClusterSimulator({ nodeCount: 3, seed: 1234 });
+    cluster.start();
+    cluster.advance(400);
+
+    const oldLeader = cluster.getLeader();
+    const oldLeaderId = oldLeader.id;
+    const followers = [1, 2, 3].filter(id => id !== oldLeaderId);
+
+    // Initial write committed
+    cluster.submit(new Uint8Array([1]));
+    cluster.advance(50);
+    const initialCommit = oldLeader.engine.commitIndex;
+
+    // Partition: [OldLeader] | [Follower1, Follower2]
+    cluster.partition([oldLeaderId], followers);
+
+    // Old leader attempts 5 writes while isolated
+    for (let i = 0; i < 5; i++) {
+      oldLeader.step({ type: EventType.SUBMIT, payload: new Uint8Array([10 + i]) });
+      cluster.advance(20);
+    }
+
+    const isolatedCommit = oldLeader.engine.commitIndex;
+    const isolatedCannotCommit = (isolatedCommit === initialCommit);
+
+    // Majority elects new leader
+    cluster.advance(400);
+    const newLeader = cluster.getLeader();
+    const newLeaderElected = (newLeader && newLeader.id !== oldLeaderId);
+
+    // New leader submits and commits writes
+    const newLeaderInitialCommit = newLeader.engine.commitIndex;
+    cluster.submit(new Uint8Array([99]));
+    cluster.advance(50);
+    const majorityCommitted = newLeader.engine.commitIndex > newLeaderInitialCommit;
+
+    // Heal partition
+    cluster.heal();
+    cluster.advance(500);
+
+    const oldLeaderDemoted = oldLeader.engine.role === Role.FOLLOWER;
+    const logsReconciled = oldLeader.storage.lastIndex() === newLeader.storage.lastIndex();
+
+    cluster.verify();
+
+    scenarios.push({
+      scenario: 'Leader Isolated & Heal',
+      isolatedCommitted: !isolatedCannotCommit,
+      majorityCommitted,
+      oldLeaderDemoted,
+      splitBrainPrevented: isolatedCannotCommit && majorityCommitted && oldLeaderDemoted,
+      passed: isolatedCannotCommit && newLeaderElected && majorityCommitted && oldLeaderDemoted && logsReconciled
+    });
+  }
+
+  // Scenario 2: Follower Isolated
+  {
+    const cluster = new ClusterSimulator({ nodeCount: 3, seed: 5678 });
+    cluster.start();
+    cluster.advance(400);
+
+    const leader = cluster.getLeader();
+    const followers = [1, 2, 3].filter(id => id !== leader.id);
+    const isolatedFollower = followers[0];
+
+    // Isolate single follower
+    cluster.partition([isolatedFollower], [leader.id, followers[1]]);
+
+    const beforeCommit = leader.engine.commitIndex;
+    for (let i = 0; i < 10; i++) {
+      cluster.submit(new Uint8Array([i]));
+      cluster.advance(20);
+    }
+
+    const majorityProgress = leader.engine.commitIndex >= beforeCommit + 10n;
+
+    // Heal and verify catchup
+    cluster.heal();
+    cluster.advance(500);
+
+    const followerCaughtUp = cluster.getNode(isolatedFollower).storage.lastIndex() === leader.storage.lastIndex();
+    cluster.verify();
+
+    scenarios.push({
+      scenario: 'Single Follower Isolated & Rejoin',
+      isolatedCommitted: false,
+      majorityCommitted: majorityProgress,
+      oldLeaderDemoted: false,
+      splitBrainPrevented: true,
+      passed: majorityProgress && followerCaughtUp
+    });
+  }
+
+  formatTable('Network Partition & Split-Brain Prevention Benchmark',
+    ['Scenario', 'Isolated Writes Stalled', 'Majority Committed', 'Old Leader Demoted', 'Safety Invariants'],
+    scenarios.map(s => [
+      s.scenario,
+      s.splitBrainPrevented ? 'YES (Safe)' : 'FAIL',
+      s.majorityCommitted ? 'YES' : 'FAIL',
+      s.oldLeaderDemoted ? 'YES' : 'N/A',
+      s.passed ? 'VERIFIED (PASS)' : 'FAIL'
+    ])
+  );
+
+  return {
+    benchmark: 'partition_and_split_brain_safety',
+    environment: getEnvironmentMetadata(),
+    scenarios
+  };
+}
+
+if (process.argv[1] && process.argv[1].endsWith('bench-partition.js')) {
+  runPartitionBenchmark().then(res => {
+    console.log('\nJSON Output:\n', JSON.stringify(res, null, 2));
+  });
+}

package/bench/bench-pipeline.js

@@ -0,0 +1,94 @@
+/**
+ * Benchmark: Replication Pipeline Depth.
+ * Measures throughput and latency across inflight window depths: 1, 2, 4, 8, 16, 32.
+ */
+
+import { Raptiye, MemoryNetwork, MemoryTransport, MemoryLog } from '../index.js';
+import { getEnvironmentMetadata, LatencyHistogram, formatTable } from './harness.js';
+
+export async function runPipelineBenchmark() {
+  const windowDepths = [1, 2, 4, 8, 16, 32];
+  const payload = new Uint8Array(128);
+  payload.fill(0x77);
+  const totalCommands = 10000;
+
+  const results = [];
+  const tableRows = [];
+
+  for (const maxInflightBatches of windowDepths) {
+    const net = new MemoryNetwork();
+    const node1 = new Raptiye({
+      id: 1,
+      peers: [2, 3],
+      storage: new MemoryLog(),
+      transport: new MemoryTransport(1, net),
+      election: { minTimeout: 50, maxTimeout: 100 },
+      heartbeatInterval: 20,
+      replication: { maxInflightBatches }
+    });
+    const node2 = new Raptiye({ id: 2, peers: [1, 3], storage: new MemoryLog(), transport: new MemoryTransport(2, net), election: { minTimeout: 50, maxTimeout: 100 }, heartbeatInterval: 20 });
+    const node3 = new Raptiye({ id: 3, peers: [1, 2], storage: new MemoryLog(), transport: new MemoryTransport(3, net), election: { minTimeout: 50, maxTimeout: 100 }, heartbeatInterval: 20 });
+    const nodes = [node1, node2, node3];
+
+    await Promise.all(nodes.map(n => n.start()));
+
+    let leader = null;
+    const startWait = Date.now();
+    while (!leader && Date.now() - startWait < 2000) {
+      leader = nodes.find(n => n.role() === 'LEADER');
+      if (!leader) await new Promise(r => setTimeout(r, 10));
+    }
+
+    const histogram = new LatencyHistogram();
+    const startHr = process.hrtime.bigint();
+
+    for (let i = 0; i < totalCommands; i++) {
+      const opStart = process.hrtime.bigint();
+      const seq = leader.submit(payload);
+      await leader.committed(seq);
+      const opEnd = process.hrtime.bigint();
+      histogram.record(Number(opEnd - opStart) / 1e6);
+    }
+
+    const endHr = process.hrtime.bigint();
+    const totalSec = Number(endHr - startHr) / 1e9;
+    const opsPerSec = Math.round(totalCommands / totalSec);
+    const summary = histogram.summary();
+
+    await Promise.all(nodes.map(n => n.shutdown()));
+
+    results.push({
+      maxInflightBatches,
+      opsPerSec,
+      p50Ms: Number(summary.p50.toFixed(4)),
+      p95Ms: Number(summary.p95.toFixed(4)),
+      p99Ms: Number(summary.p99.toFixed(4))
+    });
+
+    tableRows.push([
+      maxInflightBatches.toString(),
+      totalCommands.toLocaleString(),
+      opsPerSec.toLocaleString(),
+      `${summary.p50.toFixed(3)} ms`,
+      `${summary.p95.toFixed(3)} ms`,
+      `${summary.p99.toFixed(3)} ms`
+    ]);
+  }
+
+  formatTable('Replication Pipeline Window Benchmark',
+    ['Inflight Batches', 'Commands', 'Ops/sec', 'Commit p50', 'Commit p95', 'Commit p99'],
+    tableRows
+  );
+
+  return {
+    benchmark: 'pipeline_depth',
+    environment: getEnvironmentMetadata(),
+    results
+  };
+}
+
+if (process.argv[1] && process.argv[1].endsWith('bench-pipeline.js')) {
+  runPipelineBenchmark().then(res => {
+    console.log('\nJSON Output:\n', JSON.stringify(res, null, 2));
+  });
+}

package/bench/bench-recovery.js

@@ -0,0 +1,134 @@
+/**
+ * Benchmark: Follower Catch-up and Recovery Throughput.
+ * Measures recovery when a follower falls behind by 1K and 100K entries.
+ * Reports entries/sec, MB/sec, time-to-ready, RSS, and heap.
+ */
+
+import { ConsensusEngine } from '../src/core/engine.js';
+import { MemoryLog } from '../src/storage/memory-log.js';
+import { getEnvironmentMetadata, formatTable } from './harness.js';
+import { Role, EventType, EffectType, MessageType } from '../src/types.js';
+
+export async function runRecoveryBenchmark() {
+  const behindCounts = [1000, 100000];
+  const payloadSize = 64; // 64 bytes per entry
+  const payload = new Uint8Array(payloadSize);
+  payload.fill(0x33);
+
+  const results = [];
+  const tableRows = [];
+
+  for (const entriesBehind of behindCounts) {
+    const leaderLog = new MemoryLog();
+    const followerLog = new MemoryLog();
+
+    // Populate leader log
+    for (let i = 1; i <= entriesBehind; i++) {
+      leaderLog.append({
+        term: 1n,
+        index: BigInt(i),
+        payload
+      });
+    }
+
+    const leader = new ConsensusEngine({
+      id: 1,
+      peers: [2],
+      storage: leaderLog,
+      maxBatchEntries: 1024,
+      maxBatchBytes: 1024 * 128
+    });
+    leader.role = Role.LEADER;
+    leader.currentTerm = 1n;
+    leader._initPeerProgress();
+    leader.nextIndex.set(2, 1n); // Follower needs to catch up from index 1
+
+    // Follower has 0 entries
+    const follower = new ConsensusEngine({
+      id: 2,
+      peers: [1],
+      storage: followerLog
+    });
+    follower.currentTerm = 1n;
+
+    if (global.gc) global.gc();
+    const memBefore = process.memoryUsage();
+    const startHr = process.hrtime.bigint();
+
+    // Catch up loop: Leader streams AppendRequests to Follower until follower.lastIndex == entriesBehind
+    let roundtrips = 0;
+    let nextAppendMsg = null;
+
+    // Initial replication request
+    const initEffects = [];
+    leader._replicateToPeer(2, initEffects, false);
+    nextAppendMsg = initEffects.find(e => e.type === EffectType.SEND && e.to === 2)?.message;
+
+    while (nextAppendMsg && followerLog.lastIndex() < BigInt(entriesBehind)) {
+      roundtrips++;
+
+      // Step follower with AppendRequest
+      const followerEffects = follower.step({
+        type: EventType.MESSAGE,
+        message: nextAppendMsg
+      });
+
+      const respMsg = followerEffects.find(e => e.type === EffectType.SEND && e.to === 1)?.message;
+      if (!respMsg) break;
+
+      // Step leader with AppendResponse
+      const leaderEffects = leader.step({
+        type: EventType.MESSAGE,
+        message: respMsg
+      });
+
+      nextAppendMsg = leaderEffects.find(e => e.type === EffectType.SEND && e.to === 2)?.message;
+    }
+
+    const endHr = process.hrtime.bigint();
+    const memAfter = process.memoryUsage();
+
+    const timeToReadyMs = Number(endHr - startHr) / 1e6;
+    const timeToReadySec = timeToReadyMs / 1000;
+    const entriesPerSec = Math.round(entriesBehind / timeToReadySec);
+    const mbPerSec = Number(((entriesBehind * payloadSize) / (1024 * 1024) / timeToReadySec).toFixed(2));
+
+    const res = {
+      entriesBehind,
+      roundtrips,
+      timeToReadyMs: Number(timeToReadyMs.toFixed(2)),
+      entriesPerSec,
+      mbPerSec,
+      heapUsedMB: Math.round(memAfter.heapUsed / (1024 * 1024)),
+      rssMB: Math.round(memAfter.rss / (1024 * 1024))
+    };
+    results.push(res);
+
+    tableRows.push([
+      entriesBehind.toLocaleString(),
+      roundtrips.toLocaleString(),
+      `${timeToReadyMs.toFixed(2)} ms`,
+      entriesPerSec.toLocaleString(),
+      `${mbPerSec} MB/s`,
+      `${res.heapUsedMB} MB`,
+      `${res.rssMB} MB`
+    ]);
+  }
+
+  formatTable('Follower Catch-up & Recovery Benchmark',
+    ['Entries Behind', 'Batches', 'Time to Ready', 'Entries/sec', 'Recovery MB/s', 'Heap (MB)', 'RSS (MB)'],
+    tableRows
+  );
+
+  return {
+    benchmark: 'follower_recovery',
+    environment: getEnvironmentMetadata(),
+    results
+  };
+}
+
+if (process.argv[1] && process.argv[1].endsWith('bench-recovery.js')) {
+  runRecoveryBenchmark().then(res => {
+    console.log('\nJSON Output:\n', JSON.stringify(res, null, 2));
+  });
+}

package/bench/bench-replication.js

@@ -0,0 +1,107 @@
+/**
+ * Benchmark: 3-Node Quorum Replication Across Payload Sizes.
+ * Tests payloads: 16 B, 64 B, 256 B, 1 KB, 4 KB, 64 KB, 1 MB.
+ * Measures commands/sec, MB/sec, commit p50, p95, p99.
+ */
+
+import { Raptiye, MemoryNetwork, MemoryTransport, MemoryLog } from '../index.js';
+import { getEnvironmentMetadata, LatencyHistogram, formatTable } from './harness.js';
+
+export async function runReplicationBenchmark() {
+  const payloadSizes = [
+    { name: '16 B', bytes: 16, iterations: 10000 },
+    { name: '64 B', bytes: 64, iterations: 10000 },
+    { name: '256 B', bytes: 256, iterations: 10000 },
+    { name: '1 KB', bytes: 1024, iterations: 8000 },
+    { name: '4 KB', bytes: 4096, iterations: 5000 },
+    { name: '64 KB', bytes: 64 * 1024, iterations: 1000 },
+    { name: '1 MB', bytes: 1024 * 1024, iterations: 100 }
+  ];
+
+  const results = [];
+  const tableRows = [];
+
+  for (const { name, bytes, iterations } of payloadSizes) {
+    const net = new MemoryNetwork();
+    const node1 = new Raptiye({ id: 1, peers: [2, 3], storage: new MemoryLog(), transport: new MemoryTransport(1, net), election: { minTimeout: 50, maxTimeout: 100 }, heartbeatInterval: 20 });
+    const node2 = new Raptiye({ id: 2, peers: [1, 3], storage: new MemoryLog(), transport: new MemoryTransport(2, net), election: { minTimeout: 50, maxTimeout: 100 }, heartbeatInterval: 20 });
+    const node3 = new Raptiye({ id: 3, peers: [1, 2], storage: new MemoryLog(), transport: new MemoryTransport(3, net), election: { minTimeout: 50, maxTimeout: 100 }, heartbeatInterval: 20 });
+    const nodes = [node1, node2, node3];
+
+    await Promise.all(nodes.map(n => n.start()));
+
+    // Wait for leader
+    let leader = null;
+    const startWait = Date.now();
+    while (!leader && Date.now() - startWait < 2000) {
+      leader = nodes.find(n => n.role() === 'LEADER');
+      if (!leader) await new Promise(r => setTimeout(r, 10));
+    }
+
+    const payload = new Uint8Array(bytes);
+    payload.fill(0xAB);
+
+    const histogram = new LatencyHistogram();
+    const startHr = process.hrtime.bigint();
+
+    for (let i = 0; i < iterations; i++) {
+      const opStart = process.hrtime.bigint();
+      const seq = leader.submit(payload);
+      await leader.committed(seq);
+      const opEnd = process.hrtime.bigint();
+      const latencyMs = Number(opEnd - opStart) / 1e6;
+      histogram.record(latencyMs);
+    }
+
+    const endHr = process.hrtime.bigint();
+    const totalTimeSec = Number(endHr - startHr) / 1e9;
+    const opsPerSec = Math.round(iterations / totalTimeSec);
+    const mbPerSec = Number(((iterations * bytes) / (1024 * 1024) / totalTimeSec).toFixed(2));
+    const summary = histogram.summary();
+
+    const stats = leader.stats();
+
+    await Promise.all(nodes.map(n => n.shutdown()));
+
+    const res = {
+      payloadSize: name,
+      bytes,
+      iterations,
+      opsPerSec,
+      mbPerSec,
+      commitP50Ms: Number(summary.p50.toFixed(4)),
+      commitP95Ms: Number(summary.p95.toFixed(4)),
+      commitP99Ms: Number(summary.p99.toFixed(4)),
+      copiesPerByte: stats.copiesPerReplicatedByte
+    };
+    results.push(res);
+
+    tableRows.push([
+      name,
+      iterations.toLocaleString(),
+      opsPerSec.toLocaleString(),
+      `${mbPerSec} MB/s`,
+      `${summary.p50.toFixed(3)} ms`,
+      `${summary.p95.toFixed(3)} ms`,
+      `${summary.p99.toFixed(3)} ms`,
+      stats.copiesPerReplicatedByte.toFixed(2)
+    ]);
+  }
+
+  formatTable('3-Node Replication Benchmark',
+    ['Payload', 'Iterations', 'Ops/sec', 'Throughput', 'Commit p50', 'Commit p95', 'Commit p99', 'Copies/Byte'],
+    tableRows
+  );
+
+  return {
+    benchmark: '3_node_replication',
+    environment: getEnvironmentMetadata(),
+    results
+  };
+}
+
+if (process.argv[1] && process.argv[1].endsWith('bench-replication.js')) {
+  runReplicationBenchmark().then(res => {
+    console.log('\nJSON Output:\n', JSON.stringify(res, null, 2));
+  });
+}

package/bench/bench-single-node.js

@@ -0,0 +1,77 @@
+/**
+ * Benchmark: Single-node core overhead without network/storage noise.
+ * Measures submit ops/sec, ns/op, allocations/op, and bytes allocated/op.
+ */
+
+import { ConsensusEngine, MemoryLog, Role, EventType } from '../index.js';
+import { getEnvironmentMetadata, formatTable } from './harness.js';
+
+export async function runSingleNodeBenchmark() {
+  const iterations = 200000;
+  const payload = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+
+  const log = new MemoryLog();
+  const engine = new ConsensusEngine({
+    id: 1,
+    peers: [],
+    storage: log
+  });
+
+  // Become leader (single-node election)
+  engine.step({ type: EventType.ELECTION_TIMEOUT });
+
+  // Warmup
+  for (let i = 0; i < 10000; i++) {
+    engine.step({ type: EventType.SUBMIT, payload });
+  }
+
+  // Force GC if available or record baseline memory
+  if (global.gc) global.gc();
+  const memBefore = process.memoryUsage();
+  const startHr = process.hrtime.bigint();
+
+  for (let i = 0; i < iterations; i++) {
+    engine.step({ type: EventType.SUBMIT, payload });
+  }
+
+  const endHr = process.hrtime.bigint();
+  const memAfter = process.memoryUsage();
+
+  const totalTimeNs = Number(endHr - startHr);
+  const totalTimeSec = totalTimeNs / 1e9;
+  const opsPerSec = Math.round(iterations / totalTimeSec);
+  const nsPerOp = Math.round(totalTimeNs / iterations);
+
+  const heapDiffBytes = Math.max(0, memAfter.heapUsed - memBefore.heapUsed);
+  const bytesPerOp = Math.round(heapDiffBytes / iterations);
+
+  const result = {
+    benchmark: 'single_node_core_overhead',
+    environment: getEnvironmentMetadata(),
+    iterations,
+    totalTimeMs: totalTimeNs / 1e6,
+    opsPerSec,
+    nsPerOp,
+    bytesAllocatedPerOp: bytesPerOp,
+    heapUsedMB: Math.round(memAfter.heapUsed / (1024 * 1024))
+  };
+
+  formatTable('Single-Node Core Overhead Benchmark',
+    ['Iterations', 'Ops/sec', 'ns/op', 'Allocated B/op', 'Heap Used (MB)'],
+    [[
+      iterations.toLocaleString(),
+      opsPerSec.toLocaleString(),
+      `${nsPerOp} ns`,
+      `${bytesPerOp} B`,
+      `${result.heapUsedMB} MB`
+    ]]
+  );
+
+  return result;
+}
+
+if (process.argv[1] && process.argv[1].endsWith('bench-single-node.js')) {
+  runSingleNodeBenchmark().then(res => {
+    console.log('\nJSON Output:\n', JSON.stringify(res, null, 2));
+  });
+}

package/bench/bench-slow-follower.js

@@ -0,0 +1,96 @@
+/**
+ * Benchmark: Slow Follower Isolation.
+ * Verifies that a slow follower (high RTT) does not drag down cluster quorum throughput.
+ */
+
+import { ClusterSimulator } from '../src/sim/cluster.js';
+import { getEnvironmentMetadata, formatTable } from './harness.js';
+
+export async function runSlowFollowerBenchmark() {
+  const cluster = new ClusterSimulator({
+    nodeCount: 3,
+    seed: 42,
+    packetDelayMin: 1,
+    packetDelayMax: 2
+  });
+
+  cluster.start();
+  cluster.advance(500);
+
+  const leader = cluster.getLeader();
+  const leaderId = leader.id;
+  const followers = [1, 2, 3].filter(id => id !== leaderId);
+  const fastFollowerId = followers[0];
+  const slowFollowerId = followers[1];
+
+  // Intercept delivery to slow follower to simulate 200ms delay
+  const originalDeliver = cluster.deliverMessage.bind(cluster);
+  cluster.deliverMessage = (from, to, msg) => {
+    if ((from === leaderId && to === slowFollowerId) || (from === slowFollowerId && to === leaderId)) {
+      cluster.clock.setTimeout(() => {
+        const receiver = cluster.getNode(to);
+        if (receiver && receiver.alive) {
+          receiver.step({ type: 'MESSAGE', message: msg });
+        }
+      }, 200); // 200ms slow follower RTT
+    } else {
+      originalDeliver(from, to, msg);
+    }
+  };
+
+  const payload = new Uint8Array([1, 2, 3, 4]);
+  const commandsToSubmit = 500;
+  const startVirtualTime = cluster.clock.now;
+
+  for (let i = 0; i < commandsToSubmit; i++) {
+    cluster.submit(payload);
+    // Advance virtual clock by 3ms to let fast follower ACK
+    cluster.advance(3);
+  }
+
+  const endVirtualTime = cluster.clock.now;
+  const totalVirtualSec = (endVirtualTime - startVirtualTime) / 1000;
+  const quorumOpsPerSec = Math.round(commandsToSubmit / totalVirtualSec);
+
+  const fastFollower = cluster.getNode(fastFollowerId);
+  const slowFollower = cluster.getNode(slowFollowerId);
+
+  const leaderCommit = leader.engine.commitIndex;
+  const fastMatch = leader.engine.matchIndex.get(fastFollowerId);
+  const slowMatch = leader.engine.matchIndex.get(slowFollowerId);
+
+  // Fast follower and leader should have committed almost all entries
+  const quorumHealthy = fastMatch >= BigInt(commandsToSubmit);
+
+  formatTable('Slow Follower Quorum Isolation Benchmark',
+    ['Fast Peer RTT', 'Slow Peer RTT', 'Commands', 'Quorum Ops/sec', 'Leader Commit', 'Fast Peer Match', 'Slow Peer Match'],
+    [[
+      '2 ms',
+      '200 ms',
+      commandsToSubmit.toString(),
+      quorumOpsPerSec.toLocaleString(),
+      leaderCommit.toString(),
+      fastMatch.toString(),
+      slowMatch.toString()
+    ]]
+  );
+
+  return {
+    benchmark: 'slow_follower_isolation',
+    environment: getEnvironmentMetadata(),
+    fastPeerRttMs: 2,
+    slowPeerRttMs: 200,
+    commandsSubmitted: commandsToSubmit,
+    quorumOpsPerSec,
+    leaderCommit: Number(leaderCommit),
+    fastPeerMatch: Number(fastMatch),
+    slowPeerMatch: Number(slowMatch),
+    quorumHealthy
+  };
+}
+
+if (process.argv[1] && process.argv[1].endsWith('bench-slow-follower.js')) {
+  runSlowFollowerBenchmark().then(res => {
+    console.log('\nJSON Output:\n', JSON.stringify(res, null, 2));
+  });
+}