@divmain/jdm-asm 0.2.1 → 0.2.3

package/benchmarks/run.ts

@@ -1,913 +0,0 @@
-/**
- * Performance Benchmark Runner
- *
- * Runs performance benchmarks comparing zen-engine vs jdm-asm using Mitata.
- * Supports both single-threaded and multi-threaded (concurrent) benchmarks.
- */
-
-import { readFileSync } from 'node:fs';
-import { cpus } from 'node:os';
-import { styleText } from 'node:util';
-
-import { run, bench, group, summary } from 'mitata';
-import { ZenEngine } from '@gorules/zen-engine';
-import { compile, type CompilationResult } from '../src/compiler';
-import { ReusableWasmEvaluator, inferSchema } from '../tests/helpers/test-harness-wasm';
-import { simpleInput, moderateInput, complexInput } from './input-fixtures';
-import { WorkerPool, LatencyTracker } from './worker-pool';
-
-// Uses simple string equality and numeric outputs
-const simpleJdm = readFileSync('test-data/decision-tables/basic/merch-bags.json', 'utf-8');
-
-// Uses more complex expressions like sum(map(...)) and contains($, ...)
-const moderateJdm = readFileSync('test-data/decision-tables/basic/decision-table-shipping.json', 'utf-8');
-
-// Complex: Large decision table with 8000+ rules
-const complexJdm = readFileSync('test-data/decision-tables/basic/8k.json', 'utf-8');
-
-// Initialize zen-engine
-console.log('Initializing benchmark engines...\n');
-const zenEngine = new ZenEngine();
-
-// Create zen-engine decisions (done once, outside benchmarks)
-console.log('  Loading zen-engine decisions...');
-const zenSimple = zenEngine.createDecision(JSON.parse(simpleJdm));
-const zenModerate = zenEngine.createDecision(JSON.parse(moderateJdm));
-const zenComplex = zenEngine.createDecision(JSON.parse(complexJdm));
-
-// Compiled jdm-asm decisions (using ReusableWasmEvaluator for proper hot path benchmarking)
-let asmSimple: ReusableWasmEvaluator;
-let asmModerate: ReusableWasmEvaluator;
-let asmComplex: ReusableWasmEvaluator;
-
-// Store compilation results for worker pool initialization
-let compiledSimpleResult: CompilationResult;
-let compiledModerateResult: CompilationResult;
-let compiledComplexResult: CompilationResult;
-
-// Worker pools for concurrent benchmarks
-let workerPoolSimple: WorkerPool | null = null;
-let workerPoolModerate: WorkerPool | null = null;
-let workerPoolComplex: WorkerPool | null = null;
-
-// Round-trip latency trackers (fair comparison - main thread perspective)
-const rtLatencyTrackerSimple = new LatencyTracker();
-const rtLatencyTrackerModerate = new LatencyTracker();
-const rtLatencyTrackerComplex = new LatencyTracker();
-
-// Execution latency trackers (worker-side only, for analysis)
-const execLatencyTrackerSimple = new LatencyTracker();
-const execLatencyTrackerModerate = new LatencyTracker();
-const execLatencyTrackerComplex = new LatencyTracker();
-
-// zen-engine latency (individual call latency, not queued)
-const zenLatencyTrackerSimple = new LatencyTracker();
-const zenLatencyTrackerModerate = new LatencyTracker();
-const zenLatencyTrackerComplex = new LatencyTracker();
-
-// In-thread latency trackers (jdm-asm running in main thread, no workers)
-const inThreadLatencyTrackerSimple = new LatencyTracker();
-const inThreadLatencyTrackerModerate = new LatencyTracker();
-const inThreadLatencyTrackerComplex = new LatencyTracker();
-
-// Track if complex compiled successfully
-let complexCompiled = false;
-
-// Batch size for concurrent benchmarks
-const CONCURRENT_BATCH_SIZE = 1000;
-
-/**
- * Format a number with thousands separators
- */
-function formatNumber(n: number): string {
-  return n.toLocaleString('en-US');
-}
-
-/**
- * Format milliseconds as human-readable string
- */
-function formatMs(ms: number): string {
-  if (ms < 1000) {
-    return `${ms.toFixed(0)} ms`;
-  } else {
-    return `${(ms / 1000).toFixed(2)} s`;
-  }
-}
-
-// Warm up and verify
-console.log('\nRunning warm-up validation...\n');
-
-async function warmup() {
-  // Verify zen-engine
-  await zenSimple.evaluate(simpleInput);
-  console.log('  zen-engine simple: ready');
-
-  await zenModerate.evaluate(moderateInput);
-  console.log('  zen-engine moderate: ready');
-
-  // Complex might take longer, just log
-  try {
-    await zenComplex.evaluate(complexInput);
-    console.log('  zen-engine complex: ready');
-  } catch (_err) {
-    console.log('  zen-engine complex warm-up skipped (large file)');
-  }
-
-  // Compile jdm-asm and measure compilation times
-  console.log('\nCompiling jdm-asm modules...\n');
-
-  const simpleStart = performance.now();
-  compiledSimpleResult = await compile({
-    inputSchema: inferSchema(simpleInput),
-    outputSchema: inferSchema({}),
-    jdm: simpleJdm,
-    optimize: true,
-  });
-  const simpleCompileTime = performance.now() - simpleStart;
-  asmSimple = new ReusableWasmEvaluator(compiledSimpleResult);
-  await asmSimple.initialize();
-  asmSimple.run(simpleInput); // Verify output
-  console.log(`  Simple:   ${formatNumber(compiledSimpleResult.wasm.length).padStart(12)} bytes in ${formatMs(simpleCompileTime).padStart(8)}`);
-
-  const moderateStart = performance.now();
-  compiledModerateResult = await compile({
-    inputSchema: inferSchema(moderateInput),
-    outputSchema: inferSchema({}),
-    jdm: moderateJdm,
-    optimize: true,
-  });
-  const moderateCompileTime = performance.now() - moderateStart;
-  asmModerate = new ReusableWasmEvaluator(compiledModerateResult);
-  await asmModerate.initialize();
-  asmModerate.run(moderateInput); // Verify output
-  console.log(`  Moderate: ${formatNumber(compiledModerateResult.wasm.length).padStart(12)} bytes in ${formatMs(moderateCompileTime).padStart(8)}`);
-
-  try {
-    const complexStart = performance.now();
-    compiledComplexResult = await compile({
-      inputSchema: inferSchema(complexInput),
-      outputSchema: inferSchema({}),
-      jdm: complexJdm,
-      optimize: true,
-    });
-    const complexCompileTime = performance.now() - complexStart;
-    asmComplex = new ReusableWasmEvaluator(compiledComplexResult);
-    await asmComplex.initialize();
-    asmComplex.run(complexInput); // Verify output
-    complexCompiled = true;
-    console.log(`  Complex:  ${formatNumber(compiledComplexResult.wasm.length).padStart(12)} bytes in ${formatMs(complexCompileTime).padStart(8)}`);
-  } catch (e) {
-    console.log('  Complex compilation skipped:', (e as Error).message.slice(0, 80));
-    // Fallback to simple for benchmarking structure
-    asmComplex = asmSimple;
-  }
-
-  console.log('\nWarm-up complete\n');
-}
-
-/**
- * Initialize worker pools for concurrent benchmarks
- */
-async function initializeWorkerPools() {
-  const workerCount = cpus().length;
-  console.log(`\nInitializing worker pools (${workerCount} threads)...`);
-
-  console.log('  Initializing simple worker pool...');
-  workerPoolSimple = new WorkerPool(
-    new Uint8Array(compiledSimpleResult.wasm),
-    compiledSimpleResult.marshalCode
-  );
-  await workerPoolSimple.initialize();
-  console.log(`    Simple pool ready with ${workerPoolSimple.getWorkerCount()} workers`);
-
-  console.log('  Initializing moderate worker pool...');
-  workerPoolModerate = new WorkerPool(
-    new Uint8Array(compiledModerateResult.wasm),
-    compiledModerateResult.marshalCode
-  );
-  await workerPoolModerate.initialize();
-  console.log(`    Moderate pool ready with ${workerPoolModerate.getWorkerCount()} workers`);
-
-  if (complexCompiled) {
-    console.log('  Initializing complex worker pool...');
-    workerPoolComplex = new WorkerPool(
-      new Uint8Array(compiledComplexResult.wasm),
-      compiledComplexResult.marshalCode
-    );
-    await workerPoolComplex.initialize();
-    console.log(`    Complex pool ready with ${workerPoolComplex.getWorkerCount()} workers`);
-  }
-
-  console.log('Worker pools initialized\n');
-}
-
-/**
- * Shutdown worker pools
- */
-async function shutdownWorkerPools() {
-  if (workerPoolSimple) {
-    await workerPoolSimple.shutdown();
-    workerPoolSimple = null;
-  }
-  if (workerPoolModerate) {
-    await workerPoolModerate.shutdown();
-    workerPoolModerate = null;
-  }
-  if (workerPoolComplex) {
-    await workerPoolComplex.shutdown();
-    workerPoolComplex = null;
-  }
-}
-
-/**
- * Format nanoseconds as human-readable string
- */
-function formatNs(ns: number): string {
-  if (ns < 1000) {
-    return `${ns.toFixed(1)} ns`;
-  } else if (ns < 1_000_000) {
-    return `${(ns / 1000).toFixed(1)} µs`;
-  } else if (ns < 1_000_000_000) {
-    return `${(ns / 1_000_000).toFixed(1)} ms`;
-  } else {
-    return `${(ns / 1_000_000_000).toFixed(2)} s`;
-  }
-}
-
-/**
- * Print latency percentiles summary
- */
-function printLatencySummary() {
-  const workerCount = cpus().length;
-
-  console.log();
-  console.log(styleText('red', '=============== Per-Request Latency Percentiles ==============='));
-
-  // Round-trip latency section (fair comparison)
-  console.log();
-  console.log(styleText('green', 'Round-Trip Latency (concurrent, main thread perspective)'));
-  console.log('                                p50        p95        p99');
-
-  // jdm-asm simple round-trip
-  const rtSimpleReport = rtLatencyTrackerSimple.report();
-  console.log(
-    `jdm-asm simple (${workerCount} thr)`.padEnd(25) +
-    formatNs(rtSimpleReport.p50).padStart(10) +
-    formatNs(rtSimpleReport.p95).padStart(11) +
-    formatNs(rtSimpleReport.p99).padStart(11)
-  );
-
-  // zen-engine simple
-  const zenSimpleReport = zenLatencyTrackerSimple.report();
-  console.log(
-    'zen-engine simple'.padEnd(25) +
-    formatNs(zenSimpleReport.p50).padStart(10) +
-    formatNs(zenSimpleReport.p95).padStart(11) +
-    formatNs(zenSimpleReport.p99).padStart(11)
-  );
-
-  // jdm-asm moderate round-trip
-  const rtModerateReport = rtLatencyTrackerModerate.report();
-  console.log(
-    `jdm-asm moderate (${workerCount} thr)`.padEnd(25) +
-    formatNs(rtModerateReport.p50).padStart(10) +
-    formatNs(rtModerateReport.p95).padStart(11) +
-    formatNs(rtModerateReport.p99).padStart(11)
-  );
-
-  // zen-engine moderate
-  const zenModerateReport = zenLatencyTrackerModerate.report();
-  console.log(
-    'zen-engine moderate'.padEnd(25) +
-    formatNs(zenModerateReport.p50).padStart(10) +
-    formatNs(zenModerateReport.p95).padStart(11) +
-    formatNs(zenModerateReport.p99).padStart(11)
-  );
-
-  // jdm-asm complex round-trip (only if complex was compiled)
-  if (complexCompiled) {
-    const rtComplexReport = rtLatencyTrackerComplex.report();
-    if (rtComplexReport.p50 > 0) {
-      console.log(
-        `jdm-asm complex (${workerCount} thr)`.padEnd(25) +
-        formatNs(rtComplexReport.p50).padStart(10) +
-        formatNs(rtComplexReport.p95).padStart(11) +
-        formatNs(rtComplexReport.p99).padStart(11)
-      );
-
-      // zen-engine complex
-      const zenComplexReport = zenLatencyTrackerComplex.report();
-      console.log(
-        'zen-engine complex'.padEnd(25) +
-        formatNs(zenComplexReport.p50).padStart(10) +
-        formatNs(zenComplexReport.p95).padStart(11) +
-        formatNs(zenComplexReport.p99).padStart(11)
-      );
-    }
-  }
-
-  // In-thread latency section (jdm-asm in main thread, no workers)
-  console.log();
-  console.log(styleText('green', 'In-Thread Latency (jdm-asm in main thread, no worker overhead)'));
-  console.log('                                p50        p95        p99');
-
-  const inThreadSimpleReport = inThreadLatencyTrackerSimple.report();
-  console.log(
-    'jdm-asm simple'.padEnd(25) +
-    formatNs(inThreadSimpleReport.p50).padStart(10) +
-    formatNs(inThreadSimpleReport.p95).padStart(11) +
-    formatNs(inThreadSimpleReport.p99).padStart(11)
-  );
-
-  const inThreadModerateReport = inThreadLatencyTrackerModerate.report();
-  console.log(
-    'jdm-asm moderate'.padEnd(25) +
-    formatNs(inThreadModerateReport.p50).padStart(10) +
-    formatNs(inThreadModerateReport.p95).padStart(11) +
-    formatNs(inThreadModerateReport.p99).padStart(11)
-  );
-
-  if (complexCompiled) {
-    const inThreadComplexReport = inThreadLatencyTrackerComplex.report();
-    if (inThreadComplexReport.p50 > 0) {
-      console.log(
-        'jdm-asm complex'.padEnd(25) +
-        formatNs(inThreadComplexReport.p50).padStart(10) +
-        formatNs(inThreadComplexReport.p95).padStart(11) +
-        formatNs(inThreadComplexReport.p99).padStart(11)
-      );
-    }
-  }
-
-  console.log();
-}
-
-/**
- * Format throughput as human-readable string
- */
-function formatThroughput(decisionsPerSecond: number): string {
-  if (decisionsPerSecond >= 1_000_000) {
-    return `${(decisionsPerSecond / 1_000_000).toFixed(2)}M`;
-  } else if (decisionsPerSecond >= 1_000) {
-    return `${(decisionsPerSecond / 1_000).toFixed(1)}K`;
-  } else {
-    return `${decisionsPerSecond.toFixed(0)}`;
-  }
-}
-
-/**
- * Print throughput summary from benchmark results
- */
-function printThroughputSummary(results: unknown) {
-  const workerCount = cpus().length;
-
-  // Extract benchmark data from mitata results
-  // Mitata returns { benchmarks: [{ alias, runs: [{ name, stats: { avg } }] }, ...] }
-  const mitataResults = results as {
-    benchmarks?: Array<{
-      alias?: string;
-      group?: number;
-      runs?: Array<{
-        name?: string;
-        stats?: { avg?: number };
-      }>;
-    }>;
-  };
-  if (!mitataResults?.benchmarks || !Array.isArray(mitataResults.benchmarks)) {
-    console.log('\n(Throughput summary unavailable - results format not recognized)');
-    return;
-  }
-
-  // Build an array of benchmark results (since names can duplicate across groups)
-  const benchmarkResults: Array<{ name: string; group: number; avgNs: number }> = [];
-  for (const b of mitataResults.benchmarks) {
-    const name = b.alias ?? b.runs?.[0]?.name;
-    const avgNs = b.runs?.[0]?.stats?.avg ?? 0;
-    const group = b.group ?? 0;
-    if (avgNs > 0 && name) {
-      benchmarkResults.push({ name, group, avgNs });
-    }
-  }
-
-  // Helper to find benchmark by name and optionally group index
-  const findBenchmark = (name: string, groupIndex?: number): { avgNs: number } | null => {
-    const matches = benchmarkResults.filter(b => b.name === name);
-    if (matches.length === 0) return null;
-    if (groupIndex !== undefined && groupIndex < matches.length) {
-      return matches[groupIndex];
-    }
-    return matches[0];
-  };
-
-  // Helper to calculate throughput (avgNs is in nanoseconds)
-  const calcThroughput = (avgNs: number, batchSize: number): number => {
-    const avgSeconds = avgNs / 1_000_000_000;
-    return batchSize / avgSeconds;
-  };
-
-  console.log();
-  console.log(styleText('red', '======== Throughput Summary (decisions per second) ========'));
-
-  // Single-decision throughput (batch size = 1)
-  // Group 0 = Simple Rules, Group 1 = Moderate Rules
-  console.log();
-  console.log(styleText('green', 'Single-Decision (no concurrency)'));
-  console.log(`                      ${styleText('yellow', 'zen-engine')}       ${styleText('yellow', 'jdm-asm')}`);
-
-  const zenSimple = findBenchmark('zen-engine', 0);
-  const asmSimple = findBenchmark('jdm-asm', 0);
-  if (zenSimple && asmSimple) {
-    console.log(
-      'Simple Rules'.padEnd(18) +
-      (formatThroughput(calcThroughput(zenSimple.avgNs, 1)) + '/sec').padStart(14) +
-      (formatThroughput(calcThroughput(asmSimple.avgNs, 1)) + '/sec').padStart(14)
-    );
-  }
-
-  const zenModerate = findBenchmark('zen-engine', 1);
-  const asmModerate = findBenchmark('jdm-asm', 1);
-  if (zenModerate && asmModerate) {
-    console.log(
-      'Moderate Rules'.padEnd(18) +
-      (formatThroughput(calcThroughput(zenModerate.avgNs, 1)) + '/sec').padStart(14) +
-      (formatThroughput(calcThroughput(asmModerate.avgNs, 1)) + '/sec').padStart(14)
-    );
-  }
-
-  if (complexCompiled) {
-    const zenComplex = findBenchmark('zen-engine', 2);
-    const asmComplex = findBenchmark('jdm-asm', 2);
-    if (zenComplex && asmComplex) {
-      console.log(
-        'Complex Rules'.padEnd(18) +
-        (formatThroughput(calcThroughput(zenComplex.avgNs, 1)) + '/sec').padStart(14) +
-        (formatThroughput(calcThroughput(asmComplex.avgNs, 1)) + '/sec').padStart(14)
-      );
-    }
-  }
-
-  // Single-thread batch throughput
-  const zenSimpleBatch = findBenchmark(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch)`, 0);
-  const asmSimpleBatch = findBenchmark(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch)`, 0);
-  if (zenSimpleBatch && asmSimpleBatch) {
-    console.log();
-    console.log(styleText('green', `Single-Thread Batch (${CONCURRENT_BATCH_SIZE} simultaneous decisions)`));
-    console.log(`                      ${styleText('yellow', 'zen-engine')}       ${styleText('yellow', 'jdm-asm')}`);
-
-    console.log(
-      'Simple Rules'.padEnd(18) +
-      (formatThroughput(calcThroughput(zenSimpleBatch.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14) +
-      (formatThroughput(calcThroughput(asmSimpleBatch.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14)
-    );
-
-    const zenModerateBatch = findBenchmark(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch)`, 1);
-    const asmModerateBatch = findBenchmark(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch)`, 1);
-    if (zenModerateBatch && asmModerateBatch) {
-      console.log(
-        'Moderate Rules'.padEnd(18) +
-        (formatThroughput(calcThroughput(zenModerateBatch.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14) +
-        (formatThroughput(calcThroughput(asmModerateBatch.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14)
-      );
-    }
-
-    if (complexCompiled) {
-      const zenComplexBatch = findBenchmark(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch)`, 2);
-      const asmComplexBatch = findBenchmark(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch)`, 2);
-      if (zenComplexBatch && asmComplexBatch) {
-        console.log(
-          'Complex Rules'.padEnd(18) +
-          (formatThroughput(calcThroughput(zenComplexBatch.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14) +
-          (formatThroughput(calcThroughput(asmComplexBatch.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14)
-        );
-      }
-    }
-  }
-
-  // Multi-thread batch throughput
-  const zenSimpleMulti = findBenchmark(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch, main thread)`, 0);
-  const asmSimpleMulti = findBenchmark(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch, ${workerCount} threads)`, 0);
-  if (zenSimpleMulti && asmSimpleMulti) {
-    console.log();
-    console.log(styleText('green', `Multi-Thread Batch (${workerCount} threads, ${CONCURRENT_BATCH_SIZE} simultaneous decisions)`));
-    console.log(`                      ${styleText('yellow', 'zen-engine')}       ${styleText('yellow', 'jdm-asm')}`);
-
-    console.log(
-      'Simple Rules'.padEnd(18) +
-      (formatThroughput(calcThroughput(zenSimpleMulti.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14) +
-      (formatThroughput(calcThroughput(asmSimpleMulti.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14)
-    );
-
-    const zenModerateMulti = findBenchmark(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch, main thread)`, 1);
-    const asmModerateMulti = findBenchmark(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch, ${workerCount} threads)`, 1);
-    if (zenModerateMulti && asmModerateMulti) {
-      console.log(
-        'Moderate Rules'.padEnd(18) +
-        (formatThroughput(calcThroughput(zenModerateMulti.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14) +
-        (formatThroughput(calcThroughput(asmModerateMulti.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14)
-      );
-    }
-
-    if (complexCompiled) {
-      const zenComplexMulti = findBenchmark(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch, main thread)`, 2);
-      const asmComplexMulti = findBenchmark(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch, ${workerCount} threads)`, 2);
-      if (zenComplexMulti && asmComplexMulti) {
-        console.log(
-          'Complex Rules'.padEnd(18) +
-          (formatThroughput(calcThroughput(zenComplexMulti.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14) +
-          (formatThroughput(calcThroughput(asmComplexMulti.avgNs, CONCURRENT_BATCH_SIZE)) + '/sec').padStart(14)
-        );
-      }
-    }
-  }
-
-  console.log();
-}
-
-/**
- * Print the guide explaining how to interpret benchmark results
- */
-function printBenchmarkGuide(workerCount: number) {
-  console.log(`\
-${styleText('green', '========== Performance Benchmarks: zen-engine vs jdm-asm ==========')}
-
-This benchmark compares zen-engine (JavaScript/Rust) against jdm-asm
-(WebAssembly). Results are organized into several sections.
-
-${styleText('yellow', '1. Single-Decision Latency (Simple/Moderate/Complex Rules)')}
-   Measures time to evaluate ONE decision. This is raw execution speed
-   with no concurrency. Lower time = faster. Use this to compare the
-   baseline performance of each engine.
-
-${styleText('yellow', '2. Single-Thread Batch')}
-   Measures total time to evaluate ${CONCURRENT_BATCH_SIZE} decisions sequentially in the
-   main thread. Despite using Promise.all, jdm-asm is synchronous so
-   there is no parallelism - decisions run one after another. The
-   reported time is for the ENTIRE batch, not per-decision.
-
-${styleText('yellow', '3. Multi-Thread Batch')}
-   Measures total time to evaluate ${CONCURRENT_BATCH_SIZE} decisions using ${workerCount} worker
-   threads. jdm-asm distributes work across threads for true parallelism,
-   while zen-engine runs in the main thread (its async API provides no
-   parallelism). Compare to single-thread batch to see parallelization
-   benefits. Includes IPC overhead for jdm-asm workers.
-
-${styleText('yellow', '4. Latency Percentiles')}
-   Per-request latency distribution from the multi-thread batch runs.
-   Shows p50/p95/p99 latencies for individual requests within the batch.
-
-${styleText('yellow', '5. Throughput Summary')}
-   Decisions per second derived from the benchmark timings. Higher = better.
-
-${styleText('green', '========================== Test Scenarios ==========================')}
-
-  ${styleText('yellow', 'Simple:')} Airline bag fee lookup. 3 input fields (origin, destination,
-          class), 5 rules. Tests basic string matching with first-hit
-          policy - the lightest realistic workload.
-
-${styleText('yellow', 'Moderate:')} E-commerce shipping calculator. Nested input with cart items
-          and customer data. Uses sum() and map() to compute cart total,
-          contains() for tag checks. 12 rules across 4 region groups.
-          Represents typical business logic complexity.
-
- ${styleText('yellow', 'Complex:')} Stress test with ~8000 rules. 6 input fields across customer/
-          product domains. Heavy use of string functions (endsWith) and
-          comparisons. Tests rule engine scalability - how performance
-          degrades as decision tables grow.
-
-----------------------------------------------------------------------------`);
-}
-
-/**
- * Define single-threaded benchmarks
- */
-function defineSingleThreadedBenchmarks() {
-  // Define benchmark groups
-  summary(() => {
-    group('Simple Rules (5-10 fields)', () => {
-      bench('zen-engine', async () => {
-        return zenSimple.evaluate(simpleInput);
-      });
-
-      bench('jdm-asm', () => {
-        return asmSimple.run(simpleInput);
-      });
-    });
-  });
-
-  summary(() => {
-    group('Moderate Rules (20-30 fields)', () => {
-      bench('zen-engine', async () => {
-        return zenModerate.evaluate(moderateInput);
-      });
-
-      bench('jdm-asm', () => {
-        return asmModerate.run(moderateInput);
-      });
-    });
-  });
-
-  if (complexCompiled) {
-    summary(() => {
-      group('Complex Rules (40+ fields)', () => {
-        bench('zen-engine', async () => {
-          try {
-            return await zenComplex.evaluate(complexInput);
-          } catch {
-            return { result: 0 }; // Fallback
-          }
-        });
-
-        bench('jdm-asm', () => {
-          return asmComplex.run(complexInput);
-        });
-      });
-    });
-  } else {
-    console.log('Note: Complex benchmark skipped (jdm-asm compilation failed)\n');
-  }
-}
-
-/**
- * Define in-thread concurrent benchmarks (no worker threads)
- */
-function defineInThreadConcurrentBenchmarks() {
-  // Generate batch inputs (same input repeated for statistical significance)
-  const simpleBatchInputs = Array(CONCURRENT_BATCH_SIZE).fill(simpleInput);
-  const moderateBatchInputs = Array(CONCURRENT_BATCH_SIZE).fill(moderateInput);
-
-  summary(() => {
-    group(`Single-Thread Batch: Simple Rules (${CONCURRENT_BATCH_SIZE} decisions)`, () => {
-      bench(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch)`, async () => {
-        const results = await Promise.all(
-          simpleBatchInputs.map(async (input) => {
-            return zenSimple.evaluate(input);
-          })
-        );
-        return results.length;
-      });
-
-      bench(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch)`, async () => {
-        const results = await Promise.all(
-          simpleBatchInputs.map(async (input) => {
-            const startTime = process.hrtime.bigint();
-            const result = asmSimple.run(input);
-            const latencyNs = Number(process.hrtime.bigint() - startTime);
-            inThreadLatencyTrackerSimple.record(latencyNs);
-            return result;
-          })
-        );
-        return results.length;
-      });
-    });
-  });
-
-  summary(() => {
-    group(`Single-Thread Batch: Moderate Rules (${CONCURRENT_BATCH_SIZE} decisions)`, () => {
-      bench(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch)`, async () => {
-        const results = await Promise.all(
-          moderateBatchInputs.map(async (input) => {
-            return zenModerate.evaluate(input);
-          })
-        );
-        return results.length;
-      });
-
-      bench(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch)`, async () => {
-        const results = await Promise.all(
-          moderateBatchInputs.map(async (input) => {
-            const startTime = process.hrtime.bigint();
-            const result = asmModerate.run(input);
-            const latencyNs = Number(process.hrtime.bigint() - startTime);
-            inThreadLatencyTrackerModerate.record(latencyNs);
-            return result;
-          })
-        );
-        return results.length;
-      });
-    });
-  });
-
-  if (complexCompiled) {
-    const complexBatchInputs = Array(CONCURRENT_BATCH_SIZE).fill(complexInput);
-
-    summary(() => {
-      group(`Single-Thread Batch: Complex Rules (${CONCURRENT_BATCH_SIZE} decisions)`, () => {
-        bench(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch)`, async () => {
-          const results = await Promise.all(
-            complexBatchInputs.map(async (input) => {
-              try {
-                return await zenComplex.evaluate(input);
-              } catch {
-                return { result: 0 };
-              }
-            })
-          );
-          return results.length;
-        });
-
-        bench(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch)`, async () => {
-          const results = await Promise.all(
-            complexBatchInputs.map(async (input) => {
-              const startTime = process.hrtime.bigint();
-              const result = asmComplex.run(input);
-              const latencyNs = Number(process.hrtime.bigint() - startTime);
-              inThreadLatencyTrackerComplex.record(latencyNs);
-              return result;
-            })
-          );
-          return results.length;
-        });
-      });
-    });
-  }
-}
-
-/**
- * Define multi-threaded concurrent benchmarks (with worker threads)
- */
-function defineMultiThreadedConcurrentBenchmarks() {
-  const workerCount = cpus().length;
-
-  // Generate batch inputs (same input repeated for statistical significance)
-  const simpleBatchInputs = Array(CONCURRENT_BATCH_SIZE).fill(simpleInput);
-  const moderateBatchInputs = Array(CONCURRENT_BATCH_SIZE).fill(moderateInput);
-
-  summary(() => {
-    group(`Multi-Thread Batch: Simple Rules (${CONCURRENT_BATCH_SIZE} decisions, ${workerCount} threads)`, () => {
-      bench(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch, main thread)`, async () => {
-        const results = await Promise.all(
-          simpleBatchInputs.map(async (input) => {
-            const startTime = process.hrtime.bigint();
-            const result = await zenSimple.evaluate(input);
-            const latencyNs = Number(process.hrtime.bigint() - startTime);
-            zenLatencyTrackerSimple.record(latencyNs);
-            return result;
-          })
-        );
-        return results.length;
-      });
-
-      bench(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch, ${workerCount} threads)`, async () => {
-        const { roundTripLatencies, executionLatencies } = await workerPoolSimple!.evaluateBatch(simpleBatchInputs);
-        // Record latencies for percentile reporting
-        for (const latency of roundTripLatencies) {
-          rtLatencyTrackerSimple.record(latency);
-        }
-        for (const latency of executionLatencies) {
-          execLatencyTrackerSimple.record(latency);
-        }
-        return roundTripLatencies.length;
-      });
-    });
-  });
-
-  summary(() => {
-    group(`Multi-Thread Batch: Moderate Rules (${CONCURRENT_BATCH_SIZE} decisions, ${workerCount} threads)`, () => {
-      bench(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch, main thread)`, async () => {
-        const results = await Promise.all(
-          moderateBatchInputs.map(async (input) => {
-            const startTime = process.hrtime.bigint();
-            const result = await zenModerate.evaluate(input);
-            const latencyNs = Number(process.hrtime.bigint() - startTime);
-            zenLatencyTrackerModerate.record(latencyNs);
-            return result;
-          })
-        );
-        return results.length;
-      });
-
-      bench(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch, ${workerCount} threads)`, async () => {
-        const { roundTripLatencies, executionLatencies } = await workerPoolModerate!.evaluateBatch(moderateBatchInputs);
-        // Record latencies for percentile reporting
-        for (const latency of roundTripLatencies) {
-          rtLatencyTrackerModerate.record(latency);
-        }
-        for (const latency of executionLatencies) {
-          execLatencyTrackerModerate.record(latency);
-        }
-        return roundTripLatencies.length;
-      });
-    });
-  });
-
-  if (complexCompiled && workerPoolComplex) {
-    const complexBatchInputs = Array(CONCURRENT_BATCH_SIZE).fill(complexInput);
-
-    summary(() => {
-      group(`Multi-Thread Batch: Complex Rules (${CONCURRENT_BATCH_SIZE} decisions, ${workerCount} threads)`, () => {
-        bench(`zen-engine (${CONCURRENT_BATCH_SIZE}-decision batch, main thread)`, async () => {
-          const results = await Promise.all(
-            complexBatchInputs.map(async (input) => {
-              const startTime = process.hrtime.bigint();
-              try {
-                const result = await zenComplex.evaluate(input);
-                const latencyNs = Number(process.hrtime.bigint() - startTime);
-                zenLatencyTrackerComplex.record(latencyNs);
-                return result;
-              } catch {
-                return { result: 0 };
-              }
-            })
-          );
-          return results.length;
-        });
-
-        bench(`jdm-asm (${CONCURRENT_BATCH_SIZE}-decision batch, ${workerCount} threads)`, async () => {
-          const { roundTripLatencies, executionLatencies } = await workerPoolComplex!.evaluateBatch(complexBatchInputs);
-          // Record latencies for percentile reporting
-          for (const latency of roundTripLatencies) {
-            rtLatencyTrackerComplex.record(latency);
-          }
-          for (const latency of executionLatencies) {
-            execLatencyTrackerComplex.record(latency);
-          }
-          return roundTripLatencies.length;
-        });
-      });
-    });
-  }
-}
-
-/**
- * Define all benchmarks
- */
-async function defineBenchmarks(options: { concurrent: boolean }) {
-  const workerCount = cpus().length;
-
-  // Print the guide at the start
-  printBenchmarkGuide(workerCount);
-
-  defineSingleThreadedBenchmarks();
-
-  if (options.concurrent) {
-    // In-thread concurrent benchmarks (no worker overhead)
-    defineInThreadConcurrentBenchmarks();
-
-    // Multi-threaded concurrent benchmarks (with worker pool)
-    await initializeWorkerPools();
-    defineMultiThreadedConcurrentBenchmarks();
-  }
-
-  console.log('Running benchmarks...\n');
-}
-
-/**
- * Main benchmark runner
- */
-export async function runBenchmarks(options: { format?: 'mitata' | 'json'; json?: boolean; concurrent?: boolean } = {}) {
-  const concurrent = options.concurrent ?? true;
-  const wantJson = options.json || options.format === 'json';
-
-  try {
-    await warmup();
-    await defineBenchmarks({ concurrent });
-
-    // Always run with default format for nice console output
-    // Then run again with JSON to get structured results for throughput calculation
-    const runOptions: Parameters<typeof run>[0] = {
-      format: wantJson ? 'json' : (options.format || 'mitata'),
-    };
-
-    const results = await run(runOptions);
-
-    // Print latency percentiles if concurrent benchmarks were run
-    if (concurrent) {
-      printLatencySummary();
-    }
-
-    // Print throughput summary
-    printThroughputSummary(results);
-
-    // Shutdown worker pools
-    if (concurrent) {
-      await shutdownWorkerPools();
-    }
-
-    return results;
-  } catch (error) {
-    console.error();
-    console.error('Benchmark failed:', error);
-    // Ensure worker pools are cleaned up on error
-    await shutdownWorkerPools();
-    throw error;
-  }
-}
-
-// Run if executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const args = process.argv.slice(2);
-  const json = args.includes('--json');
-  const concurrent = !args.includes('--no-concurrent');
-
-  runBenchmarks({ json, concurrent })
-    .then((results) => {
-      if (json) {
-        console.log('\n' + JSON.stringify(results, null, 2));
-      }
-      process.exit(0);
-    })
-    .catch((error) => {
-      console.error(error);
-      process.exit(1);
-    });
-}