overtake 1.0.2 → 1.0.3

package/CLAUDE.md

@@ -0,0 +1,145 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Overtake is a high-precision JavaScript/TypeScript benchmarking library that uses worker thread isolation and statistical convergence to provide accurate performance measurements. It solves common benchmarking problems like JIT optimization interference and cross-benchmark contamination.
+
+## Development Commands
+
+```bash
+# Build the project (uses inop for transpilation + tsc for declarations only)
+npm run build
+# or with pnpm
+pnpm build
+
+# Run tests (uses Jest with SWC transpilation - no test files currently exist)
+npm test
+
+# Execute benchmarks via CLI
+npx overtake "examples/*.ts" -f table -r ops mean p95
+
+# Run a single benchmark file
+npx overtake examples/quick-start.ts
+
+# Start the CLI directly (requires argument)
+npm start examples/quick-start.ts
+
+# Format code with Prettier (via pre-commit hook)
+npx prettier --write "src/**/*.ts" "examples/**/*.ts"
+
+# Note: Package manager is pnpm@10.14.0 (see packageManager field in package.json)
+```
+
+## Architecture
+
+### Core Components
+
+1. **Benchmark Class** (`src/index.ts`): Main API with fluent interface for defining benchmarks using feed → target → measure pattern
+2. **Executor** (`src/executor.ts`): Worker thread pool management using async queues and SharedArrayBuffer for zero-copy communication
+3. **Worker** (`src/worker.ts`): Isolated execution environment with fresh V8 context per benchmark
+4. **Runner** (`src/runner.ts`): Handles warmup cycles, statistical convergence detection, and timing collection
+5. **Reporter** (`src/reporter.ts`): Statistical analysis and result formatting (ops/sec, percentiles, mean/median/mode)
+
+### Key Design Patterns
+
+- **Worker Thread Isolation**: Each benchmark runs in separate thread to prevent contamination
+- **SharedArrayBuffer Communication**: Zero-copy data transfer for high-precision bigint timing
+- **Statistical Convergence**: Automatic cycle adjustment based on configurable confidence thresholds
+- **Dynamic Code Execution**: Function serialization across threads with VM module sandboxing
+
+### API Structure
+
+```typescript
+// Fluent API pattern
+benchmark('name', feedFunction)
+  .target('implementation')
+  .measure('operation', measureFunction)
+  .execute() // Returns Promise<Report[]>
+```
+
+## Technical Requirements
+
+- Node.js >=22 (uses modern features like VM modules)
+- ES modules only (no CommonJS)
+- TypeScript with ESNext target
+- Uses SWC for transpilation (not tsc for builds)
+
+## Important Implementation Notes
+
+- **CRITICAL**: All imports must be dynamic inside target callbacks since they run in worker threads:
+  ```typescript
+  // CORRECT - dynamic import inside target
+  .target('V8', async () => {
+    const { serialize } = await import('node:v8');
+    return { serialize };
+  })
+  
+  // WRONG - static import at top level
+  import { serialize } from 'node:v8';
+  .target('V8', () => ({ serialize }))
+  ```
+- Timing uses `process.hrtime.bigint()` for nanosecond precision
+- Worker threads communicate via SharedArrayBuffer to minimize overhead
+- Build process uses `inop` tool for transpilation followed by tsc for declarations only
+- Test files should match `*.spec.ts` or `*.test.ts` patterns (currently no tests exist)
+
+## API Usage Modes
+
+### CLI Mode (Global `benchmark` function)
+- Used when running via `npx overtake file.ts`
+- CLI provides global `benchmark` function automatically
+- No imports needed, no `.execute()` call required
+- Results printed based on CLI flags
+
+Example (examples/quick-start.ts):
+```typescript
+const suite = benchmark('name', () => data);
+suite.target('impl').measure('op', (ctx, input) => { /* ... */ });
+```
+
+### Programmatic Mode (Import Benchmark class)
+- Used for standalone scripts with custom execution
+- Must import Benchmark class and printer functions
+- Must call `.execute()` and handle results
+
+Example (examples/complete.ts):
+```typescript
+import { Benchmark, printJSONReports } from '../build/index.js';
+const suite = new Benchmark('name', () => data);
+// ... define targets and measures
+const reports = await suite.execute({ /* options */ });
+printJSONReports(reports, 2);
+```
+
+## Common Issues and Solutions
+
+### TypeScript Transpilation
+- CLI uses SWC's `transform` function to strip TypeScript types
+- If you see "Missing initializer in const declaration", it means TypeScript wasn't transpiled
+- The transpiler in `src/cli.ts` must use `transform`, not `parse`/`print`
+
+### Benchmarks Not Running
+- CLI mode: Ensure using global `benchmark` function (no import)
+- Programmatic mode: Must call `.execute()` and handle results
+- Check that worker count doesn't exceed CPU cores
+
+### Memory Management Patterns
+- Use `gcBlock` Set to prevent garbage collection during measurements:
+  ```typescript
+  .target('name', () => {
+    const gcBlock = new Set(); // Prevents GC
+    return { gcBlock };
+  })
+  .measure('op', ({ gcBlock }, input) => {
+    gcBlock.add(result); // Keep reference alive
+  })
+  ```
+
+## Code Quality Tools
+
+- **Formatter**: Prettier (config in `.prettierrc`) - runs automatically on commit via husky pre-commit hook
+- **Test Runner**: Jest with SWC transpilation (config in `jest.config.js`)
+- **TypeScript Config**: Strict mode enabled, targets ESNext with NodeNext modules
+- **No linter or type-check commands**: Add these if needed in the future

package/README.md

@@ -1,284 +1,262 @@
 # Overtake
 
-High-precision performance benchmarking library for Node.js with isolated worker thread execution and statistical convergence.
+⚡ The fastest, most accurate JavaScript benchmarking library. Worker-isolated, statistically-rigorous, zero-overhead.
 
 [![Build Status][github-image]][github-url]
 [![NPM version][npm-image]][npm-url]
 [![Downloads][downloads-image]][npm-url]
 
-<!--[![Coverage Status][codecov-image]][codecov-url]-->
-<!--[![Maintainability][codeclimate-image]][codeclimate-url]-->
-<!--[![Snyk][snyk-image]][snyk-url]-->
+```bash
+npm install -D overtake
+```
 
-## Table of Contents
+## 5-Second Quick Start
 
-- [Why Overtake?](#why-overtake)
-- [Features](#features)
-- [Installing](#installing)
-- [Quick Start](#quick-start)
-- [API Guide](#api-guide)
-- [Examples](#examples)
-- [CLI Usage](#cli-usage)
-- [License](#license)
+```typescript
+// benchmark.ts
+const suite = benchmark('1M numbers', () => Array.from({ length: 1e6 }, (_, i) => i));
 
-## Why Overtake?
+suite.target('for loop').measure('sum', (_, arr) => {
+  let sum = 0;
+  for (let i = 0; i < arr.length; i++) sum += arr[i];
+  return sum;
+});
+
+suite.target('reduce').measure('sum', (_, arr) => arr.reduce((a, b) => a + b));
+```
 
-Traditional JavaScript benchmarking tools often suffer from:
+```bash
+npx overtake benchmark.ts
+
+# Output:
+# for loop sum
+#   1M numbers: 1,607 ops/s
+#
+# reduce sum
+#   1M numbers: 238 ops/s (6.7x slower)
+```
 
-- **JIT optimization interference** - Code runs differently in benchmarks vs production
-- **Memory pressure artifacts** - GC pauses and memory allocation affect timing
-- **Cross-benchmark contamination** - Previous tests affect subsequent measurements
-- **Insufficient sample sizes** - Results vary wildly between runs
+## Why Overtake?
 
-Overtake solves these problems by:
+**The Problem**: JavaScript benchmarks lie. JIT optimizations, garbage collection, and shared state make results meaningless.
 
-- **Worker thread isolation** - Each benchmark runs in a separate thread with fresh V8 context
-- **Statistical convergence** - Automatically runs until results are statistically stable
-- **Zero-copy result collection** - Uses SharedArrayBuffer to eliminate serialization overhead
-- **Proper warmup cycles** - Ensures JIT optimization before measurement
-- **Concurrent execution** - Runs multiple benchmarks in parallel for faster results
+**The Solution**: Overtake runs every benchmark in an isolated worker thread with a fresh V8 context. No contamination. No lies.
 
-## Features
+| Feature                 | Overtake                   | Benchmark.js      | Tinybench         |
+| ----------------------- | -------------------------- | ----------------- | ----------------- |
+| Worker isolation        | ✅ Each benchmark isolated | ❌ Shared context | ❌ Shared context |
+| Active maintenance      | ✅ 2025                    | ❌ Archived 2017  | ✅ 2025           |
+| Statistical convergence | ✅ Auto-adjusts cycles     | ⚠️ Manual config  | ⚠️ Manual config  |
+| Zero-copy timing        | ✅ SharedArrayBuffer       | ❌ Serialization  | ❌ Serialization  |
+| TypeScript support      | ✅ Built-in                | ❌ Manual setup   | ⚠️ Needs config   |
 
-- 🚀 **Worker thread isolation** for accurate measurements
-- 📊 **Statistical convergence** with configurable confidence thresholds
-- 🔄 **Automatic warmup cycles** to stabilize JIT optimization
-- 💻 **TypeScript support** with transpilation built-in
-- 🎯 **Multiple comparison targets** in a single benchmark
-- 📈 **Rich statistics** including percentiles, mean, median, mode
-- 🖥️ **CLI and programmatic API**
-- ⚡ **Zero-copy communication** using SharedArrayBuffer
+## Core Concepts
 
-## Installing
+- **Feed**: Input data to benchmark (`'1M numbers'` → array of 1 million numbers)
+- **Target**: Implementation variant (`'for loop'` vs `'reduce'`)
+- **Measure**: Operation to time (`'sum'` operation)
+- **Isolation**: Each benchmark runs in a separate worker thread with fresh V8 context
 
-Using pnpm:
+## Installation
 
 ```bash
-$ pnpm add -D overtake
+# npm
+npm install -D overtake
+
+# pnpm
+pnpm add -D overtake
+
+# yarn
+yarn add -D overtake
 ```
 
-Using npm:
+## ⚠️ Critical: Dynamic Imports Required
 
-```bash
-$ npm install -D overtake
+**Benchmarks run in isolated workers. Modules MUST be imported dynamically:**
+
+```typescript
+// ❌ WRONG - Static import won't work in worker
+import { serialize } from 'node:v8';
+benchmark('data', getData).target('v8', () => ({ serialize })); // serialize is undefined!
+
+// ✅ CORRECT - Dynamic import inside target
+benchmark('data', getData)
+  .target('v8', async () => {
+    const { serialize } = await import('node:v8');
+    return { serialize };
+  })
+  .measure('serialize', ({ serialize }, input) => serialize(input));
 ```
 
-## Quick Start
+## Usage
 
-### Basic Benchmark
+### CLI Mode (Recommended)
 
-Compare different implementations of the same operation:
+When using `npx overtake`, a global `benchmark` function is provided:
 
 ```typescript
-// benchmark.ts
-const suite = benchmark('Process 1000 items')
-  .target('for loop')
-  .measure('sum', (_, input) => {
-    let sum = 0;
-    for (let i = 0; i < 1000; i++) {
-      sum += i;
-    }
-    return sum;
-  });
-
-suite.target('reduce').measure('sum', (_, input) => {
-  return Array.from({ length: 1000 }, (_, i) => i).reduce((a, b) => a + b, 0);
-});
+// benchmark.ts - No imports needed!
+benchmark('small', () => generateSmallData())
+  .feed('large', () => generateLargeData())
+  .target('algorithm A')
+  .measure('process', (_, input) => processA(input))
+  .target('algorithm B')
+  .measure('process', (_, input) => processB(input));
+
+// No .execute() needed - CLI handles it
 ```
 
-Run with CLI:
-
 ```bash
-npx overtake benchmark.ts -f table
+npx overtake benchmark.ts --format table
 ```
 
-## API Guide
-
-### Core Concepts
+### Programmatic Mode
 
-1. **Benchmark**: The main container for your performance tests
-2. **Feed**: Different input data sets to test with
-3. **Target**: Different implementations to compare (e.g., "for loop" vs "reduce")
-4. **Measure**: Specific operations to measure for each target
-
-### Creating Benchmarks
+For custom integration, import the Benchmark class:
 
 ```typescript
-// Create a benchmark with optional initial feed
-const suite = benchmark('Test name', () => generateInputData());
+import { Benchmark, printTableReports } from 'overtake';
 
-// Add more input variations
-suite.feed('small dataset', () => generateSmallData()).feed('large dataset', () => generateLargeData());
+const suite = new Benchmark('dataset', () => getData());
 
-// Define implementations to compare
-suite.target('implementation A').measure('operation', (ctx, input) => {
-  // Your code here
-});
+suite.target('impl').measure('op', (_, input) => process(input));
 
-suite.target('implementation B').measure('operation', (ctx, input) => {
-  // Alternative implementation
+// Must explicitly execute
+const reports = await suite.execute({
+  workers: 4,
+  reportTypes: ['ops', 'mean', 'p95'],
 });
+
+printTableReports(reports);
 ```
 
-### Setup and Teardown
+## API Reference
+
+### Creating Benchmarks
 
 ```typescript
-suite
-  .target('with setup', async () => {
-    // Setup: runs once before measurements
-    const connection = await createConnection();
-    return { connection };
+// Create with initial feed
+benchmark('initial data', () => data)
+  .feed('more data', () => moreData) // Add more datasets
+
+  // Define what to compare
+  .target('implementation A')
+  .measure('operation', (ctx, input) => {
+    /* ... */
   })
-  .measure('query', async (ctx, input) => {
-    // ctx contains the setup return value
-    await ctx.connection.query(input);
-  })
-  .teardown(async (ctx) => {
-    // Cleanup: runs once after measurements
-    await ctx.connection.close();
+
+  .target('implementation B')
+  .measure('operation', (ctx, input) => {
+    /* ... */
   });
 ```
 
-### Pre and Post Hooks
+### Targets with Setup
 
 ```typescript
+const suite = benchmark('data', () => Buffer.from('test data'));
+
 suite
-  .target('with hooks')
-  .measure('process', (ctx, input) => {
-    processData(input);
-  })
-  .pre((ctx, input) => {
-    // Runs before EACH measurement
-    prepareData(input);
+  .target('with setup', async () => {
+    // Setup runs once before measurements
+    const { createHash } = await import('node:crypto');
+    const cache = new Map();
+    return { createHash, cache }; // Available as ctx in measure
   })
-  .post((ctx, input) => {
-    // Runs after EACH measurement
-    cleanupData(input);
+  .measure('hash', ({ createHash, cache }, input) => {
+    // ctx contains setup return value
+    const hash = createHash('sha256').update(input).digest();
+    cache.set(input, hash);
+    return hash;
   });
 ```
 
-## Examples
-
-### Example 1: Array Operations Comparison
-
-This example compares different methods for copying array elements:
+### Preventing Garbage Collection
 
 ```typescript
-// array-copy.ts
-const suite = benchmark('1M array of strings', () => Array.from({ length: 1_000_000 }, (_, idx) => `${idx}`))
-  .feed('1M array of numbers', () => Array.from({ length: 1_000_000 }, (_, idx) => idx))
-  .feed('1M typed array', () => new Uint32Array(1_000_000).map((_, idx) => idx));
-
-suite.target('for loop').measure('copy half', (_, input) => {
-  const n = input?.length ?? 0;
-  const mid = n / 2;
-  for (let i = 0; i < mid; i++) {
-    input[i + mid] = input[i];
-  }
-});
+const suite = benchmark('data', () => [1, 2, 3, 4, 5]);
 
-suite.target('copyWithin').measure('copy half', (_, input) => {
-  const n = input?.length ?? 0;
-  const mid = n / 2;
-  input.copyWithin(mid, 0, mid);
-});
+suite
+  .target('no GC', () => {
+    const gcBlock = new Set(); // Keeps references alive
+    return { gcBlock };
+  })
+  .measure('process', ({ gcBlock }, input) => {
+    const result = input.map((x) => x * x);
+    gcBlock.add(result); // Prevent GC during measurement
+    return result;
+  });
 ```
 
-**Key insights from results:**
-
-- `copyWithin` is ~5x faster for typed arrays
-- `for loop` performs consistently across all array types
-- Regular arrays have different performance characteristics than typed arrays
-
-### Example 2: Object Merging Strategies
+## Examples
 
-Compare different approaches to merge arrays of objects:
+### Serialization Comparison
 
 ```typescript
-// object-merge.ts
-import { Benchmark, printTableReports } from 'overtake';
+// Compare V8 vs JSON serialization
+const suite = benchmark('10K strings', () => Array.from({ length: 10_000 }, (_, i) => `string-${i}`));
 
-const benchmark = new Benchmark('1K objects', () => Array.from({ length: 1_000 }, (_, idx) => ({ [idx]: idx })));
-
-benchmark.target('spread operator').measure('merge', (_, input) => {
-  return input.reduce((acc, obj) => ({ ...acc, ...obj }), {});
-});
+suite
+  .target('V8', async () => {
+    const { serialize } = await import('node:v8');
+    return { serialize };
+  })
+  .measure('serialize', ({ serialize }, input) => serialize(input));
 
-benchmark.target('Object.assign in reduce').measure('merge', (_, input) => {
-  return input.reduce((acc, obj) => {
-    Object.assign(acc, obj);
-    return acc;
-  }, {});
-});
+suite.target('JSON').measure('serialize', (_, input) => JSON.stringify(input));
+```
 
-benchmark.target('Object.assign spread').measure('merge', (_, input) => {
-  return Object.assign({}, ...input);
-});
+**[📁 More examples in `/examples`](./examples/)**
 
-const reports = await benchmark.execute({
-  reportTypes: ['ops', 'mean'],
-  maxCycles: 10_000,
-});
+## CLI Options
 
-printTableReports(reports);
+```bash
+npx overtake <pattern> [options]
 ```
 
-**Key insights:**
+| Option           | Short | Description                              | Default   |
+| ---------------- | ----- | ---------------------------------------- | --------- |
+| `--format`       | `-f`  | Output format: `simple`, `table`, `json` | `simple`  |
+| `--report-types` | `-r`  | Stats to show: `ops`, `mean`, `p95`, etc | `['ops']` |
+| `--workers`      | `-w`  | Concurrent workers                       | CPU count |
+| `--min-cycles`   |       | Minimum iterations                       | 50        |
+| `--max-cycles`   |       | Maximum iterations                       | 1000      |
 
-- Spread operator in reduce is ~50% slower due to object recreation
-- `Object.assign` with spread is most concise and performant
-- Mutating approaches (assign in reduce) offer similar performance
+### Example Commands
 
-## CLI Usage
+```bash
+# Run all benchmarks with table output
+npx overtake "**/*.bench.ts" -f table
 
-### Basic Command
+# Show detailed statistics
+npx overtake bench.ts -r ops mean p95 p99
 
-```bash
-npx overtake <pattern> [options]
+# Output JSON for CI
+npx overtake bench.ts -f json > results.json
 ```
 
-### Options
+## Troubleshooting
 
-| Option               | Description                                                                                             | Default   |
-| -------------------- | ------------------------------------------------------------------------------------------------------- | --------- |
-| `-f, --format`       | Output format: `simple`, `table`, `json`, `pjson`                                                       | `simple`  |
-| `-r, --report-types` | Statistics to display: `ops`, `mean`, `median`, `mode`, `min`, `max`, `p50`, `p75`, `p90`, `p95`, `p99` | `['ops']` |
-| `-w, --workers`      | Number of concurrent worker threads                                                                     | CPU count |
-| `--warmup-cycles`    | Number of warmup iterations before measurement                                                          | 20        |
-| `--min-cycles`       | Minimum measurement cycles                                                                              | 50        |
-| `--max-cycles`       | Maximum measurement cycles                                                                              | 1000      |
-| `--abs-threshold`    | Absolute error threshold in nanoseconds                                                                 | 1000      |
-| `--rel-threshold`    | Relative error threshold (0-1)                                                                          | 0.02      |
+### "Cannot find module" in worker
 
-### Examples
+**Solution**: Use dynamic imports inside target callbacks (see [Critical section](#️-critical-dynamic-imports-required))
 
-```bash
-# Run all benchmarks in a directory
-npx overtake "src/**/*.bench.ts" -f table
+### No output from benchmark
 
-# Show detailed statistics
-npx overtake benchmark.ts -r ops mean median p95 p99
+**Solution**: In CLI mode, don't import Benchmark or call `.execute()`. Use the global `benchmark` function.
 
-# Increase precision with more cycles
-npx overtake benchmark.ts --min-cycles 100 --max-cycles 10000
+### Results vary between runs
 
-# Output JSON for CI/CD integration
-npx overtake benchmark.ts -f json > results.json
-```
+**Solution**: Increase `--min-cycles` for more samples, or use the `gcBlock` pattern to prevent garbage collection.
+
+**[🐛 Report issues](https://github.com/3axap4eHko/overtake/issues)**
 
 ## License
 
-License [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)
-Copyright (c) 2021-present Ivan Zakharchanka
+[Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0) © 2021-2025 Ivan Zakharchanka
 
 [npm-url]: https://www.npmjs.com/package/overtake
 [downloads-image]: https://img.shields.io/npm/dw/overtake.svg?maxAge=43200
 [npm-image]: https://img.shields.io/npm/v/overtake.svg?maxAge=43200
 [github-url]: https://github.com/3axap4eHko/overtake/actions/workflows/cicd.yml
 [github-image]: https://github.com/3axap4eHko/overtake/actions/workflows/cicd.yml/badge.svg
-[codecov-url]: https://codecov.io/gh/3axap4eHko/overtake
-[codecov-image]: https://codecov.io/gh/3axap4eHko/overtake/branch/master/graph/badge.svg?token=JZ8QCGH6PI
-[codeclimate-url]: https://codeclimate.com/github/3axap4eHko/overtake/maintainability
-[codeclimate-image]: https://api.codeclimate.com/v1/badges/0ba20f27f6db2b0fec8c/maintainability
-[snyk-url]: https://snyk.io/test/npm/overtake/latest
-[snyk-image]: https://img.shields.io/snyk/vulnerabilities/github/3axap4eHko/overtake.svg?maxAge=43200

package/build/cli.cjs

@@ -55,21 +55,18 @@ const require1 = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__f
 const { name, description, version } = require1('../package.json');
 const commander = new _commander.Command();
 const transpile = async (code)=>{
-    const ast = await (0, _core.parse)(code, {
-        syntax: 'typescript',
-        dynamicImport: true,
-        target: 'esnext'
-    });
-    const output = await (0, _core.print)(ast, {
-        module: {
-            type: 'es6'
-        },
+    const output = await (0, _core.transform)(code, {
+        filename: 'benchmark.ts',
         jsc: {
-            target: 'esnext',
             parser: {
-                syntax: 'typescript'
+                syntax: 'typescript',
+                tsx: false,
+                dynamicImport: true
             },
-            experimental: {}
+            target: 'esnext'
+        },
+        module: {
+            type: 'es6'
         }
     });
     return output.code;

package/build/cli.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["import { createRequire, Module } from 'node:module';\nimport { SyntheticModule, createContext, SourceTextModule } from 'node:vm';\nimport { stat, readFile } from 'node:fs/promises';\nimport { parse, print } from '@swc/core';\nimport { Command, Option } from 'commander';\nimport { glob } from 'glob';\nimport { Benchmark, printTableReports, printJSONReports, printSimpleReports, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS } from './index.js';\nimport { REPORT_TYPES } from './types.js';\n\nconst require = createRequire(import.meta.url);\nconst { name, description, version } = require('../package.json');\n\nconst commander = new Command();\n\nconst transpile = async (code: string): Promise<string> => {\n  const ast = await parse(code, {\n    syntax: 'typescript',\n    dynamicImport: true,\n    target: 'esnext',\n  });\n\n  const output = await print(ast, {\n    module: {\n      type: 'es6',\n    },\n    jsc: {\n      target: 'esnext',\n      parser: {\n        syntax: 'typescript',\n      },\n      experimental: {},\n    },\n  });\n  return output.code;\n};\n\ncommander\n  .name(name)\n  .description(description)\n  .version(version)\n  .argument('<path>', 'glob pattern to find benchmarks')\n  .addOption(new Option('-r, --report-types [reportTypes...]', 'statistic types to include in the report').choices(REPORT_TYPES).default(DEFAULT_REPORT_TYPES))\n  .addOption(new Option('-w, --workers [workers]', 'number of concurent workers').default(DEFAULT_WORKERS).argParser(parseInt))\n  .addOption(new Option('-f, --format [format]', 'output format').default('simple').choices(['simple', 'json', 'pjson', 'table']))\n  .addOption(new Option('--abs-threshold [absThreshold]', 'absolute error threshold in nanoseconds').argParser(parseInt))\n  .addOption(new Option('--rel-threshold [relThreshold]', 'relative error threshold (fraction between 0 and 1)').argParser(parseInt))\n  .addOption(new Option('--warmup-cycles [warmupCycles]', 'number of warmup cycles before measuring').argParser(parseInt))\n  .addOption(new Option('--max-cycles [maxCycles]', 'maximum measurement cycles per feed').argParser(parseInt))\n  .addOption(new Option('--min-cycles [minCycles]', 'minimum measurement cycles per feed').argParser(parseInt))\n  .action(async (path, executeOptions) => {\n    const files = await glob(path, { absolute: true, cwd: process.cwd() }).catch(() => []);\n    for (const file of files) {\n      const stats = await stat(file).catch(() => false as const);\n      if (stats && stats.isFile()) {\n        const content = await readFile(file, 'utf8');\n        const code = await transpile(content);\n        let instance: Benchmark<unknown> | undefined;\n        const benchmark = (...args: Parameters<(typeof Benchmark)['create']>) => {\n          if (instance) {\n            throw new Error('Only one benchmark per file is supported');\n          }\n          instance = Benchmark.create(...args);\n          return instance;\n        };\n        const script = new SourceTextModule(code, {\n          context: createContext({ benchmark }),\n        });\n        const imports = new Map();\n        await script.link(async (specifier: string, referencingModule) => {\n          if (imports.has(specifier)) {\n            return imports.get(specifier);\n          }\n          const mod = await import(Module.isBuiltin(specifier) ? specifier : require.resolve(specifier));\n          const exportNames = Object.keys(mod);\n          const imported = new SyntheticModule(\n            exportNames,\n            () => {\n              exportNames.forEach((key) => imported.setExport(key, mod[key]));\n            },\n            { identifier: specifier, context: referencingModule.context },\n          );\n\n          imports.set(specifier, imported);\n          return imported;\n        });\n        await script.evaluate();\n\n        if (instance) {\n          const reports = await instance.execute(executeOptions);\n          switch (executeOptions.format) {\n            case 'json':\n              {\n                printJSONReports(reports);\n              }\n              break;\n            case 'pjson':\n              {\n                printJSONReports(reports, 2);\n              }\n              break;\n            case 'table':\n              {\n                printTableReports(reports);\n              }\n              break;\n            default:\n              printSimpleReports(reports);\n          }\n        }\n      }\n    }\n  });\n\ncommander.parse(process.argv);\n"],"names":["require","createRequire","name","description","version","commander","Command","transpile","code","ast","parse","syntax","dynamicImport","target","output","print","module","type","jsc","parser","experimental","argument","addOption","Option","choices","REPORT_TYPES","default","DEFAULT_REPORT_TYPES","DEFAULT_WORKERS","argParser","parseInt","action","path","executeOptions","files","glob","absolute","cwd","process","catch","file","stats","stat","isFile","content","readFile","instance","benchmark","args","Error","Benchmark","create","script","SourceTextModule","context","createContext","imports","Map","link","specifier","referencingModule","has","get","mod","Module","isBuiltin","resolve","exportNames","Object","keys","imported","SyntheticModule","forEach","key","setExport","identifier","set","evaluate","reports","execute","format","printJSONReports","printTableReports","printSimpleReports","argv"],"mappings":"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"}
+{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["import { createRequire, Module } from 'node:module';\nimport { SyntheticModule, createContext, SourceTextModule } from 'node:vm';\nimport { stat, readFile } from 'node:fs/promises';\nimport { transform } from '@swc/core';\nimport { Command, Option } from 'commander';\nimport { glob } from 'glob';\nimport { Benchmark, printTableReports, printJSONReports, printSimpleReports, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS } from './index.js';\nimport { REPORT_TYPES } from './types.js';\n\nconst require = createRequire(import.meta.url);\nconst { name, description, version } = require('../package.json');\n\nconst commander = new Command();\n\nconst transpile = async (code: string): Promise<string> => {\n  const output = await transform(code, {\n    filename: 'benchmark.ts',\n    jsc: {\n      parser: {\n        syntax: 'typescript',\n        tsx: false,\n        dynamicImport: true,\n      },\n      target: 'esnext',\n    },\n    module: {\n      type: 'es6',\n    },\n  });\n  return output.code;\n};\n\ncommander\n  .name(name)\n  .description(description)\n  .version(version)\n  .argument('<path>', 'glob pattern to find benchmarks')\n  .addOption(new Option('-r, --report-types [reportTypes...]', 'statistic types to include in the report').choices(REPORT_TYPES).default(DEFAULT_REPORT_TYPES))\n  .addOption(new Option('-w, --workers [workers]', 'number of concurent workers').default(DEFAULT_WORKERS).argParser(parseInt))\n  .addOption(new Option('-f, --format [format]', 'output format').default('simple').choices(['simple', 'json', 'pjson', 'table']))\n  .addOption(new Option('--abs-threshold [absThreshold]', 'absolute error threshold in nanoseconds').argParser(parseInt))\n  .addOption(new Option('--rel-threshold [relThreshold]', 'relative error threshold (fraction between 0 and 1)').argParser(parseInt))\n  .addOption(new Option('--warmup-cycles [warmupCycles]', 'number of warmup cycles before measuring').argParser(parseInt))\n  .addOption(new Option('--max-cycles [maxCycles]', 'maximum measurement cycles per feed').argParser(parseInt))\n  .addOption(new Option('--min-cycles [minCycles]', 'minimum measurement cycles per feed').argParser(parseInt))\n  .action(async (path, executeOptions) => {\n    const files = await glob(path, { absolute: true, cwd: process.cwd() }).catch(() => []);\n    for (const file of files) {\n      const stats = await stat(file).catch(() => false as const);\n      if (stats && stats.isFile()) {\n        const content = await readFile(file, 'utf8');\n        const code = await transpile(content);\n        let instance: Benchmark<unknown> | undefined;\n        const benchmark = (...args: Parameters<(typeof Benchmark)['create']>) => {\n          if (instance) {\n            throw new Error('Only one benchmark per file is supported');\n          }\n          instance = Benchmark.create(...args);\n          return instance;\n        };\n        const script = new SourceTextModule(code, {\n          context: createContext({ benchmark }),\n        });\n        const imports = new Map();\n        await script.link(async (specifier: string, referencingModule) => {\n          if (imports.has(specifier)) {\n            return imports.get(specifier);\n          }\n          const mod = await import(Module.isBuiltin(specifier) ? specifier : require.resolve(specifier));\n          const exportNames = Object.keys(mod);\n          const imported = new SyntheticModule(\n            exportNames,\n            () => {\n              exportNames.forEach((key) => imported.setExport(key, mod[key]));\n            },\n            { identifier: specifier, context: referencingModule.context },\n          );\n\n          imports.set(specifier, imported);\n          return imported;\n        });\n        await script.evaluate();\n\n        if (instance) {\n          const reports = await instance.execute(executeOptions);\n          switch (executeOptions.format) {\n            case 'json':\n              {\n                printJSONReports(reports);\n              }\n              break;\n            case 'pjson':\n              {\n                printJSONReports(reports, 2);\n              }\n              break;\n            case 'table':\n              {\n                printTableReports(reports);\n              }\n              break;\n            default:\n              printSimpleReports(reports);\n          }\n        }\n      }\n    }\n  });\n\ncommander.parse(process.argv);\n"],"names":["require","createRequire","name","description","version","commander","Command","transpile","code","output","transform","filename","jsc","parser","syntax","tsx","dynamicImport","target","module","type","argument","addOption","Option","choices","REPORT_TYPES","default","DEFAULT_REPORT_TYPES","DEFAULT_WORKERS","argParser","parseInt","action","path","executeOptions","files","glob","absolute","cwd","process","catch","file","stats","stat","isFile","content","readFile","instance","benchmark","args","Error","Benchmark","create","script","SourceTextModule","context","createContext","imports","Map","link","specifier","referencingModule","has","get","mod","Module","isBuiltin","resolve","exportNames","Object","keys","imported","SyntheticModule","forEach","key","setExport","identifier","set","evaluate","reports","execute","format","printJSONReports","printTableReports","printSimpleReports","parse","argv"],"mappings":"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"}

package/build/cli.js

@@ -1,7 +1,7 @@
 import { createRequire, Module } from 'node:module';
 import { SyntheticModule, createContext, SourceTextModule } from 'node:vm';
 import { stat, readFile } from 'node:fs/promises';
-import { parse, print } from '@swc/core';
+import { transform } from '@swc/core';
 import { Command, Option } from 'commander';
 import { glob } from 'glob';
 import { Benchmark, printTableReports, printJSONReports, printSimpleReports, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS } from "./index.js";
@@ -10,21 +10,18 @@ const require = createRequire(import.meta.url);
 const { name, description, version } = require('../package.json');
 const commander = new Command();
 const transpile = async (code)=>{
-    const ast = await parse(code, {
-        syntax: 'typescript',
-        dynamicImport: true,
-        target: 'esnext'
-    });
-    const output = await print(ast, {
-        module: {
-            type: 'es6'
-        },
+    const output = await transform(code, {
+        filename: 'benchmark.ts',
         jsc: {
-            target: 'esnext',
             parser: {
-                syntax: 'typescript'
+                syntax: 'typescript',
+                tsx: false,
+                dynamicImport: true
             },
-            experimental: {}
+            target: 'esnext'
+        },
+        module: {
+            type: 'es6'
         }
     });
     return output.code;

package/build/cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["import { createRequire, Module } from 'node:module';\nimport { SyntheticModule, createContext, SourceTextModule } from 'node:vm';\nimport { stat, readFile } from 'node:fs/promises';\nimport { parse, print } from '@swc/core';\nimport { Command, Option } from 'commander';\nimport { glob } from 'glob';\nimport { Benchmark, printTableReports, printJSONReports, printSimpleReports, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS } from './index.js';\nimport { REPORT_TYPES } from './types.js';\n\nconst require = createRequire(import.meta.url);\nconst { name, description, version } = require('../package.json');\n\nconst commander = new Command();\n\nconst transpile = async (code: string): Promise<string> => {\n  const ast = await parse(code, {\n    syntax: 'typescript',\n    dynamicImport: true,\n    target: 'esnext',\n  });\n\n  const output = await print(ast, {\n    module: {\n      type: 'es6',\n    },\n    jsc: {\n      target: 'esnext',\n      parser: {\n        syntax: 'typescript',\n      },\n      experimental: {},\n    },\n  });\n  return output.code;\n};\n\ncommander\n  .name(name)\n  .description(description)\n  .version(version)\n  .argument('<path>', 'glob pattern to find benchmarks')\n  .addOption(new Option('-r, --report-types [reportTypes...]', 'statistic types to include in the report').choices(REPORT_TYPES).default(DEFAULT_REPORT_TYPES))\n  .addOption(new Option('-w, --workers [workers]', 'number of concurent workers').default(DEFAULT_WORKERS).argParser(parseInt))\n  .addOption(new Option('-f, --format [format]', 'output format').default('simple').choices(['simple', 'json', 'pjson', 'table']))\n  .addOption(new Option('--abs-threshold [absThreshold]', 'absolute error threshold in nanoseconds').argParser(parseInt))\n  .addOption(new Option('--rel-threshold [relThreshold]', 'relative error threshold (fraction between 0 and 1)').argParser(parseInt))\n  .addOption(new Option('--warmup-cycles [warmupCycles]', 'number of warmup cycles before measuring').argParser(parseInt))\n  .addOption(new Option('--max-cycles [maxCycles]', 'maximum measurement cycles per feed').argParser(parseInt))\n  .addOption(new Option('--min-cycles [minCycles]', 'minimum measurement cycles per feed').argParser(parseInt))\n  .action(async (path, executeOptions) => {\n    const files = await glob(path, { absolute: true, cwd: process.cwd() }).catch(() => []);\n    for (const file of files) {\n      const stats = await stat(file).catch(() => false as const);\n      if (stats && stats.isFile()) {\n        const content = await readFile(file, 'utf8');\n        const code = await transpile(content);\n        let instance: Benchmark<unknown> | undefined;\n        const benchmark = (...args: Parameters<(typeof Benchmark)['create']>) => {\n          if (instance) {\n            throw new Error('Only one benchmark per file is supported');\n          }\n          instance = Benchmark.create(...args);\n          return instance;\n        };\n        const script = new SourceTextModule(code, {\n          context: createContext({ benchmark }),\n        });\n        const imports = new Map();\n        await script.link(async (specifier: string, referencingModule) => {\n          if (imports.has(specifier)) {\n            return imports.get(specifier);\n          }\n          const mod = await import(Module.isBuiltin(specifier) ? specifier : require.resolve(specifier));\n          const exportNames = Object.keys(mod);\n          const imported = new SyntheticModule(\n            exportNames,\n            () => {\n              exportNames.forEach((key) => imported.setExport(key, mod[key]));\n            },\n            { identifier: specifier, context: referencingModule.context },\n          );\n\n          imports.set(specifier, imported);\n          return imported;\n        });\n        await script.evaluate();\n\n        if (instance) {\n          const reports = await instance.execute(executeOptions);\n          switch (executeOptions.format) {\n            case 'json':\n              {\n                printJSONReports(reports);\n              }\n              break;\n            case 'pjson':\n              {\n                printJSONReports(reports, 2);\n              }\n              break;\n            case 'table':\n              {\n                printTableReports(reports);\n              }\n              break;\n            default:\n              printSimpleReports(reports);\n          }\n        }\n      }\n    }\n  });\n\ncommander.parse(process.argv);\n"],"names":["createRequire","Module","SyntheticModule","createContext","SourceTextModule","stat","readFile","parse","print","Command","Option","glob","Benchmark","printTableReports","printJSONReports","printSimpleReports","DEFAULT_REPORT_TYPES","DEFAULT_WORKERS","REPORT_TYPES","require","url","name","description","version","commander","transpile","code","ast","syntax","dynamicImport","target","output","module","type","jsc","parser","experimental","argument","addOption","choices","default","argParser","parseInt","action","path","executeOptions","files","absolute","cwd","process","catch","file","stats","isFile","content","instance","benchmark","args","Error","create","script","context","imports","Map","link","specifier","referencingModule","has","get","mod","isBuiltin","resolve","exportNames","Object","keys","imported","forEach","key","setExport","identifier","set","evaluate","reports","execute","format","argv"],"mappings":"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"}
+{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["import { createRequire, Module } from 'node:module';\nimport { SyntheticModule, createContext, SourceTextModule } from 'node:vm';\nimport { stat, readFile } from 'node:fs/promises';\nimport { transform } from '@swc/core';\nimport { Command, Option } from 'commander';\nimport { glob } from 'glob';\nimport { Benchmark, printTableReports, printJSONReports, printSimpleReports, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS } from './index.js';\nimport { REPORT_TYPES } from './types.js';\n\nconst require = createRequire(import.meta.url);\nconst { name, description, version } = require('../package.json');\n\nconst commander = new Command();\n\nconst transpile = async (code: string): Promise<string> => {\n  const output = await transform(code, {\n    filename: 'benchmark.ts',\n    jsc: {\n      parser: {\n        syntax: 'typescript',\n        tsx: false,\n        dynamicImport: true,\n      },\n      target: 'esnext',\n    },\n    module: {\n      type: 'es6',\n    },\n  });\n  return output.code;\n};\n\ncommander\n  .name(name)\n  .description(description)\n  .version(version)\n  .argument('<path>', 'glob pattern to find benchmarks')\n  .addOption(new Option('-r, --report-types [reportTypes...]', 'statistic types to include in the report').choices(REPORT_TYPES).default(DEFAULT_REPORT_TYPES))\n  .addOption(new Option('-w, --workers [workers]', 'number of concurent workers').default(DEFAULT_WORKERS).argParser(parseInt))\n  .addOption(new Option('-f, --format [format]', 'output format').default('simple').choices(['simple', 'json', 'pjson', 'table']))\n  .addOption(new Option('--abs-threshold [absThreshold]', 'absolute error threshold in nanoseconds').argParser(parseInt))\n  .addOption(new Option('--rel-threshold [relThreshold]', 'relative error threshold (fraction between 0 and 1)').argParser(parseInt))\n  .addOption(new Option('--warmup-cycles [warmupCycles]', 'number of warmup cycles before measuring').argParser(parseInt))\n  .addOption(new Option('--max-cycles [maxCycles]', 'maximum measurement cycles per feed').argParser(parseInt))\n  .addOption(new Option('--min-cycles [minCycles]', 'minimum measurement cycles per feed').argParser(parseInt))\n  .action(async (path, executeOptions) => {\n    const files = await glob(path, { absolute: true, cwd: process.cwd() }).catch(() => []);\n    for (const file of files) {\n      const stats = await stat(file).catch(() => false as const);\n      if (stats && stats.isFile()) {\n        const content = await readFile(file, 'utf8');\n        const code = await transpile(content);\n        let instance: Benchmark<unknown> | undefined;\n        const benchmark = (...args: Parameters<(typeof Benchmark)['create']>) => {\n          if (instance) {\n            throw new Error('Only one benchmark per file is supported');\n          }\n          instance = Benchmark.create(...args);\n          return instance;\n        };\n        const script = new SourceTextModule(code, {\n          context: createContext({ benchmark }),\n        });\n        const imports = new Map();\n        await script.link(async (specifier: string, referencingModule) => {\n          if (imports.has(specifier)) {\n            return imports.get(specifier);\n          }\n          const mod = await import(Module.isBuiltin(specifier) ? specifier : require.resolve(specifier));\n          const exportNames = Object.keys(mod);\n          const imported = new SyntheticModule(\n            exportNames,\n            () => {\n              exportNames.forEach((key) => imported.setExport(key, mod[key]));\n            },\n            { identifier: specifier, context: referencingModule.context },\n          );\n\n          imports.set(specifier, imported);\n          return imported;\n        });\n        await script.evaluate();\n\n        if (instance) {\n          const reports = await instance.execute(executeOptions);\n          switch (executeOptions.format) {\n            case 'json':\n              {\n                printJSONReports(reports);\n              }\n              break;\n            case 'pjson':\n              {\n                printJSONReports(reports, 2);\n              }\n              break;\n            case 'table':\n              {\n                printTableReports(reports);\n              }\n              break;\n            default:\n              printSimpleReports(reports);\n          }\n        }\n      }\n    }\n  });\n\ncommander.parse(process.argv);\n"],"names":["createRequire","Module","SyntheticModule","createContext","SourceTextModule","stat","readFile","transform","Command","Option","glob","Benchmark","printTableReports","printJSONReports","printSimpleReports","DEFAULT_REPORT_TYPES","DEFAULT_WORKERS","REPORT_TYPES","require","url","name","description","version","commander","transpile","code","output","filename","jsc","parser","syntax","tsx","dynamicImport","target","module","type","argument","addOption","choices","default","argParser","parseInt","action","path","executeOptions","files","absolute","cwd","process","catch","file","stats","isFile","content","instance","benchmark","args","Error","create","script","context","imports","Map","link","specifier","referencingModule","has","get","mod","isBuiltin","resolve","exportNames","Object","keys","imported","forEach","key","setExport","identifier","set","evaluate","reports","execute","format","parse","argv"],"mappings":"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"}

package/examples/array-copy.ts

@@ -1,8 +1,8 @@
-const suite = benchmark('1M array of strings', () => Array.from({ length: 1_000_000 }, (_, idx) => `${idx}`))
+const copySuite = benchmark('1M array of strings', () => Array.from({ length: 1_000_000 }, (_, idx) => `${idx}`))
   .feed('1M array of numbers', () => Array.from({ length: 1_000_000 }, (_, idx) => idx))
   .feed('1M typed array', () => new Uint32Array(1_000_000).map((_, idx) => idx));
 
-suite.target('for loop').measure('copy half', (_, input) => {
+copySuite.target('for loop').measure('copy half', (_, input) => {
   const n = input?.length ?? 0;
   const mid = n / 2;
   for (let i = 0; i < mid; i++) {
@@ -10,7 +10,7 @@ suite.target('for loop').measure('copy half', (_, input) => {
   }
 });
 
-suite.target('copyWithin').measure('copy half', (_, input) => {
+copySuite.target('copyWithin').measure('copy half', (_, input) => {
   const n = input?.length ?? 0;
   const mid = n / 2;
   input.copyWithin(mid, 0, mid);

package/examples/complete.ts

@@ -0,0 +1,95 @@
+import { Benchmark, DEFAULT_REPORT_TYPES, printJSONReports } from '../build/index.js';
+import { randomUUID, randomInt } from 'node:crypto';
+
+const length = 10 ** 4;
+// creates a benchmark suite with 3 data feeds of objects, strings and numbers
+const suite = new Benchmark('1M array of objects', () =>
+  Array.from({ length }, (_, idx) => ({
+    string: randomUUID(),
+    number: randomInt(length),
+    boolean: idx % 3 === 0,
+  })),
+)
+  .feed('1M array of strings', () => Array.from({ length }, () => randomUUID()))
+  .feed('1M array of numbers', () => Array.from({ length }, () => randomInt(length)));
+
+// create a specific benchmark target this way v8Target type is aware of
+// serialize, deserialize and serialized properties inside the context
+const v8Target = suite.target('v8', async () => {
+  const { serialize, deserialize } = await import('node:v8');
+  const serialized: Buffer = Buffer.from([]);
+  return { serialize, deserialize, serialized };
+});
+
+v8Target
+  .measure('serialize', ({ serialize }, input) => {
+    serialize(input);
+  })
+  .pre(async (_ctx, _input) => {
+    // executed before measurement
+  })
+  .post(async (_ctx, _input) => {
+    // executed before measurement
+  });
+
+v8Target
+  .measure('deserialize', ({ deserialize, serialized }) => {
+    deserialize(serialized);
+  })
+  .pre(async (ctx, input) => {
+    // since there is no serialized data pre hook prepares it
+    // it serializes before each measurement
+    ctx.serialized = ctx.serialize(input);
+  })
+  .post(async (ctx) => {
+    // clean it up to avoid GC trigger during measurement
+    ctx.serialized = undefined as unknown as Buffer;
+  });
+
+v8Target.teardown(async () => {
+  // teardown the benchmark if needed free up resources, clean and etc
+});
+
+const jsonTarget = suite.target('json', () => {
+  const { parse, stringify } = JSON;
+  const serialized: string = '';
+  return { parse, stringify, serialized };
+});
+
+jsonTarget
+  .measure('stringify', ({ stringify }, input) => {
+    stringify(input);
+  })
+  .pre(async (_ctx, _input) => {
+    // executed before measurement
+  })
+  .post(async (_ctx, _input) => {
+    // executed before measurement
+  });
+
+jsonTarget
+  .measure('parsse', ({ parse, serialized }) => {
+    parse(serialized);
+  })
+  .pre(async (ctx, input) => {
+    ctx.serialized = ctx.stringify(input);
+  })
+  .post(async (ctx) => {
+    ctx.serialized = '';
+  });
+
+jsonTarget.teardown(async () => {
+  // teardown the benchmark if needed free up resources, clean and etc
+});
+
+const reports = await suite.execute({
+  workers: 10,
+  warmupCycles: 20,
+  maxCycles: 100,
+  minCycles: 100,
+  absThreshold: 1_000,
+  relThreshold: 0.02,
+  reportTypes: DEFAULT_REPORT_TYPES,
+});
+
+printJSONReports(reports, 2);

package/examples/object-merge.ts

@@ -1,39 +1,39 @@
 import { Benchmark, printSimpleReports } from '../build/index.js';
 
-const benchmark = new Benchmark('1K array of objects', () => Array.from({ length: 1_000 }, (_, idx) => ({ [idx]: idx })));
+const objectMergeSuite = new Benchmark('1K array of objects', () => Array.from({ length: 1_000 }, (_, idx) => ({ [idx]: idx })));
 
-benchmark.target('reduce destructure').measure('data', (_, input) => {
+objectMergeSuite.target('reduce destructure').measure('data', (_, input) => {
   input.reduce((acc, obj) => {
     return { ...acc, ...obj };
   }, {});
 });
 
-benchmark.target('reduce assign').measure('data', (_, input) => {
+objectMergeSuite.target('reduce assign').measure('data', (_, input) => {
   input.reduce((acc, obj) => {
     Object.assign(acc, obj);
     return acc;
   }, {});
 });
 
-benchmark.target('forEach assign').measure('data', (_, input) => {
+objectMergeSuite.target('forEach assign').measure('data', (_, input) => {
   const result = {};
   input.forEach((obj) => {
     Object.assign(result, obj);
   });
 });
 
-benchmark.target('for assign').measure('data', (_, input) => {
+objectMergeSuite.target('for assign').measure('data', (_, input) => {
   const result = {};
   for (let i = 0; i < input.length; i++) {
     Object.assign(result, input[i]);
   }
 });
 
-benchmark.target('assign').measure('data', (_, input) => {
+objectMergeSuite.target('assign').measure('data', (_, input) => {
   Object.assign({}, ...input);
 });
 
-const reports = await benchmark.execute({
+const reports = await objectMergeSuite.execute({
   reportTypes: ['ops'],
   maxCycles: 10_000,
 });

package/examples/quick-start.ts

@@ -0,0 +1,16 @@
+// run using the following command
+// npx overtake examples/quick-start.ts
+
+const sumSuite = benchmark('1M array', () => Array.from({ length: 1_000_000 }, (_, idx) => idx));
+
+sumSuite.target('for loop').measure('sum', (_, input) => {
+  const n = input.length;
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    sum += input[i];
+  }
+});
+
+sumSuite.target('reduce').measure('sum', (_, input) => {
+  input.reduce((a, b) => a + b, 0);
+});

package/examples/serialization.ts

@@ -0,0 +1,22 @@
+import { randomUUID } from 'node:crypto';
+
+const serializeSuite = benchmark('1K strings', () => Array.from({ length: 10_000 }, () => randomUUID()));
+
+const v8Target = serializeSuite.target('V8', async () => {
+  const { serialize, deserialize } = await import('node:v8');
+  const gcBlock = new Set();
+  return { serialize, deserialize, gcBlock };
+});
+
+v8Target.measure('serialize', ({ serialize, gcBlock }, input) => {
+  gcBlock.add(serialize(input));
+});
+
+serializeSuite
+  .target('JSON', () => {
+    const gcBlock = new Set();
+    return { gcBlock };
+  })
+  .measure('serialize', ({ gcBlock }, input) => {
+    gcBlock.add(JSON.stringify(input));
+  });

package/package.json

@@ -1,10 +1,23 @@
 {
   "name": "overtake",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "NodeJS performance benchmark",
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
   "type": "module",
+  "types": "build/index.d.ts",
+  "main": "build/index.cjs",
+  "module": "build/index.js",
+  "exports": {
+    "types": "./build/index.d.ts",
+    "require": "./build/index.cjs",
+    "import": "./build/index.js"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "build/index.d.ts"
+      ]
+    }
+  },
   "bin": {
     "overtake": "bin/overtake.js"
   },

package/src/cli.ts

@@ -1,7 +1,7 @@
 import { createRequire, Module } from 'node:module';
 import { SyntheticModule, createContext, SourceTextModule } from 'node:vm';
 import { stat, readFile } from 'node:fs/promises';
-import { parse, print } from '@swc/core';
+import { transform } from '@swc/core';
 import { Command, Option } from 'commander';
 import { glob } from 'glob';
 import { Benchmark, printTableReports, printJSONReports, printSimpleReports, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS } from './index.js';
@@ -13,22 +13,18 @@ const { name, description, version } = require('../package.json');
 const commander = new Command();
 
 const transpile = async (code: string): Promise<string> => {
-  const ast = await parse(code, {
-    syntax: 'typescript',
-    dynamicImport: true,
-    target: 'esnext',
-  });
-
-  const output = await print(ast, {
-    module: {
-      type: 'es6',
-    },
+  const output = await transform(code, {
+    filename: 'benchmark.ts',
     jsc: {
-      target: 'esnext',
       parser: {
         syntax: 'typescript',
+        tsx: false,
+        dynamicImport: true,
       },
-      experimental: {},
+      target: 'esnext',
+    },
+    module: {
+      type: 'es6',
     },
   });
   return output.code;