overtake 1.0.4 → 1.0.5

package/README.md

@@ -19,10 +19,11 @@ const suite = benchmark('1M numbers', () => Array.from({ length: 1e6 }, (_, i) =
 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));
+suite.target('reduce').measure('sum', (_, arr) => {
+  arr.reduce((a, b) => a + b);
+});
 ```
 
 ```bash
@@ -85,9 +86,36 @@ benchmark('data', getData)
     const { serialize } = await import('node:v8');
     return { serialize };
   })
-  .measure('serialize', ({ serialize }, input) => serialize(input));
+  .measure('serialize', ({ serialize }, input) => {
+    serialize(input);
+  });
 ```
 
+### Importing Local Files
+
+**Important**: Dynamic imports inside target functions resolve relative to the worker location (`node_modules/overtake/build/worker.js`), not your project root. For local files, you must construct absolute paths:
+
+````typescript
+// ❌ WRONG - Relative path resolves from worker location
+.target('myImpl', async () => {
+  const { myFunc } = await import('./utils/myModule.js'); // Error: looks in node_modules/overtake/build/utils/
+  return { myFunc };
+})
+
+// ✅ CORRECT - Build absolute path inside the function
+.target('myImpl', async () => {
+  const { join } = await import('node:path');
+  const modulePath = join(process.cwd(), './utils/myModule.js');
+  const { myFunc } = await import(modulePath);
+  return { myFunc };
+})
+
+// ✅ ALSO CORRECT - For node_modules packages
+.target('lib', async () => {
+  const { someFunc } = await import('my-package');
+  return { someFunc };
+})
+
 ## Usage
 
 ### CLI Mode (Recommended)
@@ -99,12 +127,14 @@ When using `npx overtake`, a global `benchmark` function is provided:
 benchmark('small', () => generateSmallData())
   .feed('large', () => generateLargeData())
   .target('algorithm A')
-  .measure('process', (_, input) => processA(input))
+  .measure('process', (_, input) => {
+    processA(input);
+  })
   .target('algorithm B')
-  .measure('process', (_, input) => processB(input));
-
-// No .execute() needed - CLI handles it
-```
+  .measure('process', (_, input) => {
+    processB(input);
+  });
+````
 
 ```bash
 npx overtake benchmark.ts --format table
@@ -119,7 +149,9 @@ import { Benchmark, printTableReports } from 'overtake';
 
 const suite = new Benchmark('dataset', () => getData());
 
-suite.target('impl').measure('op', (_, input) => process(input));
+suite.target('impl').measure('op', (_, input) => {
+  process(input);
+});
 
 // Must explicitly execute
 const reports = await suite.execute({
@@ -167,7 +199,6 @@ suite
     // ctx contains setup return value
     const hash = createHash('sha256').update(input).digest();
     cache.set(input, hash);
-    return hash;
   });
 ```
 
@@ -184,29 +215,45 @@ suite
   .measure('process', ({ gcBlock }, input) => {
     const result = input.map((x) => x * x);
     gcBlock.add(result); // Prevent GC during measurement
-    return result;
   });
 ```
 
 ## Examples
 
-### Serialization Comparison
+### Compare Algorithms
 
 ```typescript
-// Compare V8 vs JSON serialization
-const suite = benchmark('10K strings', () => Array.from({ length: 10_000 }, (_, i) => `string-${i}`));
+// examples/quick-start.ts
+const sumBenchmark = benchmark('1M numbers', () => Array.from({ length: 1_000_000 }, (_, i) => i));
 
-suite
-  .target('V8', async () => {
-    const { serialize } = await import('node:v8');
-    return { serialize };
-  })
-  .measure('serialize', ({ serialize }, input) => serialize(input));
+sumBenchmark.target('for loop').measure('sum', (_, numbers) => {
+  let sum = 0;
+  for (let i = 0; i < numbers.length; i++) sum += numbers[i];
+});
 
-suite.target('JSON').measure('serialize', (_, input) => JSON.stringify(input));
+sumBenchmark.target('reduce').measure('sum', (_, numbers) => {
+  numbers.reduce((a, b) => a + b, 0);
+});
+```
+
+### Import Local Modules
+
+```typescript
+// examples/imports.ts - Correct way to import local files
+.target('local files', async () => {
+  const { join } = await import('node:path');
+  const modulePath = join(process.cwd(), './build/myModule.js');
+  const { myFunction } = await import(modulePath);
+  return { myFunction };
+})
 ```
 
-**[📁 More examples in `/examples`](./examples/)**
+**[📁 See all examples](./examples/):**
+
+- `quick-start.ts` - Minimal benchmark example
+- `complete.ts` - All features (setup/teardown, pre/post hooks, multiple feeds)
+- `imports.ts` - Import patterns and memory management
+- `custom-reports.ts` - Statistics and custom report types
 
 ## CLI Options
 

package/bin/overtake.js

@@ -1,2 +1,2 @@
-#!/usr/bin/env -S node --experimental-vm-modules --no-warnings
+#!/usr/bin/env -S node --experimental-vm-modules --no-warnings --expose-gc
 import '../build/cli.js';

package/build/cli.cjs

@@ -96,7 +96,8 @@ commander.name(name).description(description).version(version).argument('<path>'
             };
             const script = new _nodevm.SourceTextModule(code, {
                 context: (0, _nodevm.createContext)({
-                    benchmark
+                    benchmark,
+                    Buffer
                 })
             });
             const imports = new Map();

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 { 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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"}
+{"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({\n            benchmark,\n            Buffer,\n          }),\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","Buffer","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

@@ -51,7 +51,8 @@ commander.name(name).description(description).version(version).argument('<path>'
             };
             const script = new SourceTextModule(code, {
                 context: createContext({
-                    benchmark
+                    benchmark,
+                    Buffer
                 })
             });
             const imports = new Map();

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 { 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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"}
+{"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({\n            benchmark,\n            Buffer,\n          }),\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","Buffer","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":"AAAA,SAASA,aAAa,EAAEC,MAAM,QAAQ,cAAc;AACpD,SAASC,eAAe,EAAEC,aAAa,EAAEC,gBAAgB,QAAQ,UAAU;AAC3E,SAASC,IAAI,EAAEC,QAAQ,QAAQ,mBAAmB;AAClD,SAASC,SAAS,QAAQ,YAAY;AACtC,SAASC,OAAO,EAAEC,MAAM,QAAQ,YAAY;AAC5C,SAASC,IAAI,QAAQ,OAAO;AAC5B,SAASC,SAAS,EAAEC,iBAAiB,EAAEC,gBAAgB,EAAEC,kBAAkB,EAAEC,oBAAoB,EAAEC,eAAe,QAAQ,aAAa;AACvI,SAASC,YAAY,QAAQ,aAAa;AAE1C,MAAMC,UAAUlB,cAAc,YAAYmB,GAAG;AAC7C,MAAM,EAAEC,IAAI,EAAEC,WAAW,EAAEC,OAAO,EAAE,GAAGJ,QAAQ;AAE/C,MAAMK,YAAY,IAAIf;AAEtB,MAAMgB,YAAY,OAAOC;IACvB,MAAMC,SAAS,MAAMnB,UAAUkB,MAAM;QACnCE,UAAU;QACVC,KAAK;YACHC,QAAQ;gBACNC,QAAQ;gBACRC,KAAK;gBACLC,eAAe;YACjB;YACAC,QAAQ;QACV;QACAC,QAAQ;YACNC,MAAM;QACR;IACF;IACA,OAAOT,OAAOD,IAAI;AACpB;AAEAF,UACGH,IAAI,CAACA,MACLC,WAAW,CAACA,aACZC,OAAO,CAACA,SACRc,QAAQ,CAAC,UAAU,mCACnBC,SAAS,CAAC,IAAI5B,OAAO,uCAAuC,4CAA4C6B,OAAO,CAACrB,cAAcsB,OAAO,CAACxB,uBACtIsB,SAAS,CAAC,IAAI5B,OAAO,2BAA2B,+BAA+B8B,OAAO,CAACvB,iBAAiBwB,SAAS,CAACC,WAClHJ,SAAS,CAAC,IAAI5B,OAAO,yBAAyB,iBAAiB8B,OAAO,CAAC,UAAUD,OAAO,CAAC;IAAC;IAAU;IAAQ;IAAS;CAAQ,GAC7HD,SAAS,CAAC,IAAI5B,OAAO,kCAAkC,2CAA2C+B,SAAS,CAACC,WAC5GJ,SAAS,CAAC,IAAI5B,OAAO,kCAAkC,uDAAuD+B,SAAS,CAACC,WACxHJ,SAAS,CAAC,IAAI5B,OAAO,kCAAkC,4CAA4C+B,SAAS,CAACC,WAC7GJ,SAAS,CAAC,IAAI5B,OAAO,4BAA4B,uCAAuC+B,SAAS,CAACC,WAClGJ,SAAS,CAAC,IAAI5B,OAAO,4BAA4B,uCAAuC+B,SAAS,CAACC,WAClGC,MAAM,CAAC,OAAOC,MAAMC;IACnB,MAAMC,QAAQ,MAAMnC,KAAKiC,MAAM;QAAEG,UAAU;QAAMC,KAAKC,QAAQD,GAAG;IAAG,GAAGE,KAAK,CAAC,IAAM,EAAE;IACrF,KAAK,MAAMC,QAAQL,MAAO;QACxB,MAAMM,QAAQ,MAAM9C,KAAK6C,MAAMD,KAAK,CAAC,IAAM;QAC3C,IAAIE,SAASA,MAAMC,MAAM,IAAI;YAC3B,MAAMC,UAAU,MAAM/C,SAAS4C,MAAM;YACrC,MAAMzB,OAAO,MAAMD,UAAU6B;YAC7B,IAAIC;YACJ,MAAMC,YAAY,CAAC,GAAGC;gBACpB,IAAIF,UAAU;oBACZ,MAAM,IAAIG,MAAM;gBAClB;gBACAH,WAAW3C,UAAU+C,MAAM,IAAIF;gBAC/B,OAAOF;YACT;YACA,MAAMK,SAAS,IAAIvD,iBAAiBqB,MAAM;gBACxCmC,SAASzD,cAAc;oBACrBoD;oBACAM;gBACF;YACF;YACA,MAAMC,UAAU,IAAIC;YACpB,MAAMJ,OAAOK,IAAI,CAAC,OAAOC,WAAmBC;gBAC1C,IAAIJ,QAAQK,GAAG,CAACF,YAAY;oBAC1B,OAAOH,QAAQM,GAAG,CAACH;gBACrB;gBACA,MAAMI,MAAM,MAAM,MAAM,CAACpE,OAAOqE,SAAS,CAACL,aAAaA,YAAY/C,QAAQqD,OAAO,CAACN;gBACnF,MAAMO,cAAcC,OAAOC,IAAI,CAACL;gBAChC,MAAMM,WAAW,IAAIzE,gBACnBsE,aACA;oBACEA,YAAYI,OAAO,CAAC,CAACC,MAAQF,SAASG,SAAS,CAACD,KAAKR,GAAG,CAACQ,IAAI;gBAC/D,GACA;oBAAEE,YAAYd;oBAAWL,SAASM,kBAAkBN,OAAO;gBAAC;gBAG9DE,QAAQkB,GAAG,CAACf,WAAWU;gBACvB,OAAOA;YACT;YACA,MAAMhB,OAAOsB,QAAQ;YAErB,IAAI3B,UAAU;gBACZ,MAAM4B,UAAU,MAAM5B,SAAS6B,OAAO,CAACvC;gBACvC,OAAQA,eAAewC,MAAM;oBAC3B,KAAK;wBACH;4BACEvE,iBAAiBqE;wBACnB;wBACA;oBACF,KAAK;wBACH;4BACErE,iBAAiBqE,SAAS;wBAC5B;wBACA;oBACF,KAAK;wBACH;4BACEtE,kBAAkBsE;wBACpB;wBACA;oBACF;wBACEpE,mBAAmBoE;gBACvB;YACF;QACF;IACF;AACF;AAEF3D,UAAU8D,KAAK,CAACrC,QAAQsC,IAAI"}

package/build/runner.cjs

@@ -36,6 +36,8 @@ const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data, warmup
         await pre?.(context, data);
         const result = runRaw(context, data);
         await post?.(context, data);
+        global.gc?.();
+        global.gc?.();
         const run = result instanceof Promise ? runAsync(runRaw) : runSync(runRaw);
         const start = Date.now();
         while(Date.now() - start < 1_000){
@@ -45,6 +47,8 @@ const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data, warmup
             await pre?.(context, data);
             await run(context, data);
             await post?.(context, data);
+            global.gc?.();
+            global.gc?.();
         }
         let i = 0;
         let mean = 0n;
@@ -54,6 +58,8 @@ const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data, warmup
             await pre?.(context, data);
             const duration = await run(context, data);
             await post?.(context, data);
+            global.gc?.();
+            global.gc?.();
             durations[i++] = duration;
             const delta = duration - mean;
             mean += delta / BigInt(i);

package/build/runner.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/runner.ts"],"sourcesContent":["import { Options, Control } from './types.js';\n\nconst COMPLETE_VALUE = 100_00;\n\nconst runSync = (run: Function) => {\n  return (...args: unknown[]) => {\n    const start = process.hrtime.bigint();\n    run(...args);\n    return process.hrtime.bigint() - start;\n  };\n};\n\nconst runAsync = (run: Function) => {\n  return async (...args: unknown[]) => {\n    const start = process.hrtime.bigint();\n    await run(...args);\n    return process.hrtime.bigint() - start;\n  };\n};\n\nexport const benchmark = async <TContext, TInput>({\n  setup,\n  teardown,\n  pre,\n  run: runRaw,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n}: Required<Options<TContext, TInput>>) => {\n  const durations = new BigUint64Array(durationsSAB);\n  const control = new Int32Array(controlSAB);\n\n  control[Control.INDEX] = 0;\n  control[Control.PROGRESS] = 0;\n  control[Control.COMPLETE] = 255;\n\n  const context = (await setup?.()) as TContext;\n  const maxCycles = durations.length;\n\n  try {\n    await pre?.(context, data!);\n    const result = runRaw(context, data!);\n    await post?.(context, data!);\n    const run = result instanceof Promise ? runAsync(runRaw) : runSync(runRaw);\n    const start = Date.now();\n    while (Date.now() - start < 1_000) {\n      Math.sqrt(Math.random());\n    }\n    for (let i = 0; i < warmupCycles; i++) {\n      await pre?.(context, data!);\n      await run(context, data);\n      await post?.(context, data!);\n    }\n\n    let i = 0;\n    let mean = 0n;\n    let m2 = 0n;\n\n    while (true) {\n      if (i >= maxCycles) break;\n\n      await pre?.(context, data!);\n      const duration = await run(context, data);\n      await post?.(context, data!);\n\n      durations[i++] = duration;\n      const delta = duration - mean;\n      mean += delta / BigInt(i);\n      m2 += delta * (duration - mean);\n\n      const progress = Math.max(i / maxCycles) * COMPLETE_VALUE;\n      control[Control.PROGRESS] = progress;\n\n      if (i >= minCycles) {\n        const variance = Number(m2) / (i - 1);\n        const stddev = Math.sqrt(variance);\n        if (stddev <= Number(absThreshold)) {\n          break;\n        }\n\n        const meanNum = Number(mean);\n        const cov = stddev / (meanNum || 1);\n        if (cov <= relThreshold) {\n          break;\n        }\n      }\n    }\n\n    control[Control.INDEX] = i;\n    control[Control.COMPLETE] = 0;\n  } catch (e) {\n    console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);\n    control[Control.COMPLETE] = 1;\n  } finally {\n    try {\n      await teardown?.(context);\n    } catch (e) {\n      control[Control.COMPLETE] = 2;\n      console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);\n    }\n  }\n\n  return control[Control.COMPLETE];\n};\n"],"names":["benchmark","COMPLETE_VALUE","runSync","run","args","start","process","hrtime","bigint","runAsync","setup","teardown","pre","runRaw","post","data","warmupCycles","minCycles","absThreshold","relThreshold","durationsSAB","controlSAB","durations","BigUint64Array","control","Int32Array","Control","INDEX","PROGRESS","COMPLETE","context","maxCycles","length","result","Promise","Date","now","Math","sqrt","random","i","mean","m2","duration","delta","BigInt","progress","max","variance","Number","stddev","meanNum","cov","e","console","error","stack"],"mappings":"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"}
+{"version":3,"sources":["../src/runner.ts"],"sourcesContent":["import { Options, Control } from './types.js';\n\nconst COMPLETE_VALUE = 100_00;\n\nconst runSync = (run: Function) => {\n  return (...args: unknown[]) => {\n    const start = process.hrtime.bigint();\n    run(...args);\n    return process.hrtime.bigint() - start;\n  };\n};\n\nconst runAsync = (run: Function) => {\n  return async (...args: unknown[]) => {\n    const start = process.hrtime.bigint();\n    await run(...args);\n    return process.hrtime.bigint() - start;\n  };\n};\n\nexport const benchmark = async <TContext, TInput>({\n  setup,\n  teardown,\n  pre,\n  run: runRaw,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n}: Required<Options<TContext, TInput>>) => {\n  const durations = new BigUint64Array(durationsSAB);\n  const control = new Int32Array(controlSAB);\n\n  control[Control.INDEX] = 0;\n  control[Control.PROGRESS] = 0;\n  control[Control.COMPLETE] = 255;\n\n  const context = (await setup?.()) as TContext;\n  const maxCycles = durations.length;\n\n  try {\n    await pre?.(context, data!);\n    const result = runRaw(context, data!);\n    await post?.(context, data!);\n    global.gc?.();\n    global.gc?.();\n\n    const run = result instanceof Promise ? runAsync(runRaw) : runSync(runRaw);\n    const start = Date.now();\n    while (Date.now() - start < 1_000) {\n      Math.sqrt(Math.random());\n    }\n    for (let i = 0; i < warmupCycles; i++) {\n      await pre?.(context, data!);\n      await run(context, data);\n      await post?.(context, data!);\n      global.gc?.();\n      global.gc?.();\n    }\n\n    let i = 0;\n    let mean = 0n;\n    let m2 = 0n;\n\n    while (true) {\n      if (i >= maxCycles) break;\n\n      await pre?.(context, data!);\n      const duration = await run(context, data);\n      await post?.(context, data!);\n      global.gc?.();\n      global.gc?.();\n\n      durations[i++] = duration;\n      const delta = duration - mean;\n      mean += delta / BigInt(i);\n      m2 += delta * (duration - mean);\n\n      const progress = Math.max(i / maxCycles) * COMPLETE_VALUE;\n      control[Control.PROGRESS] = progress;\n\n      if (i >= minCycles) {\n        const variance = Number(m2) / (i - 1);\n        const stddev = Math.sqrt(variance);\n        if (stddev <= Number(absThreshold)) {\n          break;\n        }\n\n        const meanNum = Number(mean);\n        const cov = stddev / (meanNum || 1);\n        if (cov <= relThreshold) {\n          break;\n        }\n      }\n    }\n\n    control[Control.INDEX] = i;\n    control[Control.COMPLETE] = 0;\n  } catch (e) {\n    console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);\n    control[Control.COMPLETE] = 1;\n  } finally {\n    try {\n      await teardown?.(context);\n    } catch (e) {\n      control[Control.COMPLETE] = 2;\n      console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);\n    }\n  }\n\n  return control[Control.COMPLETE];\n};\n"],"names":["benchmark","COMPLETE_VALUE","runSync","run","args","start","process","hrtime","bigint","runAsync","setup","teardown","pre","runRaw","post","data","warmupCycles","minCycles","absThreshold","relThreshold","durationsSAB","controlSAB","durations","BigUint64Array","control","Int32Array","Control","INDEX","PROGRESS","COMPLETE","context","maxCycles","length","result","global","gc","Promise","Date","now","Math","sqrt","random","i","mean","m2","duration","delta","BigInt","progress","max","variance","Number","stddev","meanNum","cov","e","console","error","stack"],"mappings":"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"}

package/build/runner.js

@@ -26,6 +26,8 @@ export const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data,
         await pre?.(context, data);
         const result = runRaw(context, data);
         await post?.(context, data);
+        global.gc?.();
+        global.gc?.();
         const run = result instanceof Promise ? runAsync(runRaw) : runSync(runRaw);
         const start = Date.now();
         while(Date.now() - start < 1_000){
@@ -35,6 +37,8 @@ export const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data,
             await pre?.(context, data);
             await run(context, data);
             await post?.(context, data);
+            global.gc?.();
+            global.gc?.();
         }
         let i = 0;
         let mean = 0n;
@@ -44,6 +48,8 @@ export const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data,
             await pre?.(context, data);
             const duration = await run(context, data);
             await post?.(context, data);
+            global.gc?.();
+            global.gc?.();
             durations[i++] = duration;
             const delta = duration - mean;
             mean += delta / BigInt(i);

package/build/runner.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/runner.ts"],"sourcesContent":["import { Options, Control } from './types.js';\n\nconst COMPLETE_VALUE = 100_00;\n\nconst runSync = (run: Function) => {\n  return (...args: unknown[]) => {\n    const start = process.hrtime.bigint();\n    run(...args);\n    return process.hrtime.bigint() - start;\n  };\n};\n\nconst runAsync = (run: Function) => {\n  return async (...args: unknown[]) => {\n    const start = process.hrtime.bigint();\n    await run(...args);\n    return process.hrtime.bigint() - start;\n  };\n};\n\nexport const benchmark = async <TContext, TInput>({\n  setup,\n  teardown,\n  pre,\n  run: runRaw,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n}: Required<Options<TContext, TInput>>) => {\n  const durations = new BigUint64Array(durationsSAB);\n  const control = new Int32Array(controlSAB);\n\n  control[Control.INDEX] = 0;\n  control[Control.PROGRESS] = 0;\n  control[Control.COMPLETE] = 255;\n\n  const context = (await setup?.()) as TContext;\n  const maxCycles = durations.length;\n\n  try {\n    await pre?.(context, data!);\n    const result = runRaw(context, data!);\n    await post?.(context, data!);\n    const run = result instanceof Promise ? runAsync(runRaw) : runSync(runRaw);\n    const start = Date.now();\n    while (Date.now() - start < 1_000) {\n      Math.sqrt(Math.random());\n    }\n    for (let i = 0; i < warmupCycles; i++) {\n      await pre?.(context, data!);\n      await run(context, data);\n      await post?.(context, data!);\n    }\n\n    let i = 0;\n    let mean = 0n;\n    let m2 = 0n;\n\n    while (true) {\n      if (i >= maxCycles) break;\n\n      await pre?.(context, data!);\n      const duration = await run(context, data);\n      await post?.(context, data!);\n\n      durations[i++] = duration;\n      const delta = duration - mean;\n      mean += delta / BigInt(i);\n      m2 += delta * (duration - mean);\n\n      const progress = Math.max(i / maxCycles) * COMPLETE_VALUE;\n      control[Control.PROGRESS] = progress;\n\n      if (i >= minCycles) {\n        const variance = Number(m2) / (i - 1);\n        const stddev = Math.sqrt(variance);\n        if (stddev <= Number(absThreshold)) {\n          break;\n        }\n\n        const meanNum = Number(mean);\n        const cov = stddev / (meanNum || 1);\n        if (cov <= relThreshold) {\n          break;\n        }\n      }\n    }\n\n    control[Control.INDEX] = i;\n    control[Control.COMPLETE] = 0;\n  } catch (e) {\n    console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);\n    control[Control.COMPLETE] = 1;\n  } finally {\n    try {\n      await teardown?.(context);\n    } catch (e) {\n      control[Control.COMPLETE] = 2;\n      console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);\n    }\n  }\n\n  return control[Control.COMPLETE];\n};\n"],"names":["Control","COMPLETE_VALUE","runSync","run","args","start","process","hrtime","bigint","runAsync","benchmark","setup","teardown","pre","runRaw","post","data","warmupCycles","minCycles","absThreshold","relThreshold","durationsSAB","controlSAB","durations","BigUint64Array","control","Int32Array","INDEX","PROGRESS","COMPLETE","context","maxCycles","length","result","Promise","Date","now","Math","sqrt","random","i","mean","m2","duration","delta","BigInt","progress","max","variance","Number","stddev","meanNum","cov","e","console","error","stack"],"mappings":"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"}
+{"version":3,"sources":["../src/runner.ts"],"sourcesContent":["import { Options, Control } from './types.js';\n\nconst COMPLETE_VALUE = 100_00;\n\nconst runSync = (run: Function) => {\n  return (...args: unknown[]) => {\n    const start = process.hrtime.bigint();\n    run(...args);\n    return process.hrtime.bigint() - start;\n  };\n};\n\nconst runAsync = (run: Function) => {\n  return async (...args: unknown[]) => {\n    const start = process.hrtime.bigint();\n    await run(...args);\n    return process.hrtime.bigint() - start;\n  };\n};\n\nexport const benchmark = async <TContext, TInput>({\n  setup,\n  teardown,\n  pre,\n  run: runRaw,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n}: Required<Options<TContext, TInput>>) => {\n  const durations = new BigUint64Array(durationsSAB);\n  const control = new Int32Array(controlSAB);\n\n  control[Control.INDEX] = 0;\n  control[Control.PROGRESS] = 0;\n  control[Control.COMPLETE] = 255;\n\n  const context = (await setup?.()) as TContext;\n  const maxCycles = durations.length;\n\n  try {\n    await pre?.(context, data!);\n    const result = runRaw(context, data!);\n    await post?.(context, data!);\n    global.gc?.();\n    global.gc?.();\n\n    const run = result instanceof Promise ? runAsync(runRaw) : runSync(runRaw);\n    const start = Date.now();\n    while (Date.now() - start < 1_000) {\n      Math.sqrt(Math.random());\n    }\n    for (let i = 0; i < warmupCycles; i++) {\n      await pre?.(context, data!);\n      await run(context, data);\n      await post?.(context, data!);\n      global.gc?.();\n      global.gc?.();\n    }\n\n    let i = 0;\n    let mean = 0n;\n    let m2 = 0n;\n\n    while (true) {\n      if (i >= maxCycles) break;\n\n      await pre?.(context, data!);\n      const duration = await run(context, data);\n      await post?.(context, data!);\n      global.gc?.();\n      global.gc?.();\n\n      durations[i++] = duration;\n      const delta = duration - mean;\n      mean += delta / BigInt(i);\n      m2 += delta * (duration - mean);\n\n      const progress = Math.max(i / maxCycles) * COMPLETE_VALUE;\n      control[Control.PROGRESS] = progress;\n\n      if (i >= minCycles) {\n        const variance = Number(m2) / (i - 1);\n        const stddev = Math.sqrt(variance);\n        if (stddev <= Number(absThreshold)) {\n          break;\n        }\n\n        const meanNum = Number(mean);\n        const cov = stddev / (meanNum || 1);\n        if (cov <= relThreshold) {\n          break;\n        }\n      }\n    }\n\n    control[Control.INDEX] = i;\n    control[Control.COMPLETE] = 0;\n  } catch (e) {\n    console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);\n    control[Control.COMPLETE] = 1;\n  } finally {\n    try {\n      await teardown?.(context);\n    } catch (e) {\n      control[Control.COMPLETE] = 2;\n      console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);\n    }\n  }\n\n  return control[Control.COMPLETE];\n};\n"],"names":["Control","COMPLETE_VALUE","runSync","run","args","start","process","hrtime","bigint","runAsync","benchmark","setup","teardown","pre","runRaw","post","data","warmupCycles","minCycles","absThreshold","relThreshold","durationsSAB","controlSAB","durations","BigUint64Array","control","Int32Array","INDEX","PROGRESS","COMPLETE","context","maxCycles","length","result","global","gc","Promise","Date","now","Math","sqrt","random","i","mean","m2","duration","delta","BigInt","progress","max","variance","Number","stddev","meanNum","cov","e","console","error","stack"],"mappings":"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"}

package/build/worker.cjs

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+Object.defineProperty(exports, "exitCode", {
+    enumerable: true,
+    get: function() {
+        return exitCode;
+    }
+});
 const _nodeworker_threads = require("node:worker_threads");
 const _runnercjs = require("./runner.cjs");
 const { setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, durationsSAB, controlSAB } = _nodeworker_threads.workerData;

package/build/worker.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["import { workerData } from 'node:worker_threads';\nimport { benchmark } from './runner.js';\nimport { SetupFn, TeardownFn, StepFn, WorkerOptions } from './types.js';\n\nconst {\n  setupCode,\n  teardownCode,\n  preCode,\n  runCode,\n  postCode,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n}: WorkerOptions = workerData;\n\nconst setup: SetupFn<unknown> = setupCode && Function(`return ${setupCode};`)();\nconst teardown: TeardownFn<unknown> = teardownCode && Function(`return ${teardownCode};`)();\n\nconst pre: StepFn<unknown, unknown> = preCode && Function(`return ${preCode};`)();\nconst run: StepFn<unknown, unknown> = runCode && Function(`return ${runCode};`)();\nconst post: StepFn<unknown, unknown> = postCode && Function(`return ${postCode};`)();\n\nconst exitCode = await benchmark({\n  setup,\n  teardown,\n  pre,\n  run,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n});\n\nprocess.exit(exitCode);\n"],"names":["setupCode","teardownCode","preCode","runCode","postCode","data","warmupCycles","minCycles","absThreshold","relThreshold","durationsSAB","controlSAB","workerData","setup","Function","teardown","pre","run","post","exitCode","benchmark","process","exit"],"mappings":";;;;oCAA2B;2BACD;AAG1B,MAAM,EACJA,SAAS,EACTC,YAAY,EACZC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRC,IAAI,EAEJC,YAAY,EACZC,SAAS,EACTC,YAAY,EACZC,YAAY,EAEZC,YAAY,EACZC,UAAU,EACX,GAAkBC,8BAAU;AAE7B,MAAMC,QAA0Bb,aAAac,SAAS,CAAC,OAAO,EAAEd,UAAU,CAAC,CAAC;AAC5E,MAAMe,WAAgCd,gBAAgBa,SAAS,CAAC,OAAO,EAAEb,aAAa,CAAC,CAAC;AAExF,MAAMe,MAAgCd,WAAWY,SAAS,CAAC,OAAO,EAAEZ,QAAQ,CAAC,CAAC;AAC9E,MAAMe,MAAgCd,WAAWW,SAAS,CAAC,OAAO,EAAEX,QAAQ,CAAC,CAAC;AAC9E,MAAMe,OAAiCd,YAAYU,SAAS,CAAC,OAAO,EAAEV,SAAS,CAAC,CAAC;AAEjF,MAAMe,WAAW,MAAMC,IAAAA,oBAAS,EAAC;IAC/BP;IACAE;IACAC;IACAC;IACAC;IACAb;IAEAC;IACAC;IACAC;IACAC;IAEAC;IACAC;AACF;AAEAU,QAAQC,IAAI,CAACH"}
+{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["import { workerData } from 'node:worker_threads';\nimport { benchmark } from './runner.js';\nimport { SetupFn, TeardownFn, StepFn, WorkerOptions } from './types.js';\n\nconst {\n  setupCode,\n  teardownCode,\n  preCode,\n  runCode,\n  postCode,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n}: WorkerOptions = workerData;\n\nconst setup: SetupFn<unknown> = setupCode && Function(`return ${setupCode};`)();\nconst teardown: TeardownFn<unknown> = teardownCode && Function(`return ${teardownCode};`)();\n\nconst pre: StepFn<unknown, unknown> = preCode && Function(`return ${preCode};`)();\nconst run: StepFn<unknown, unknown> = runCode && Function(`return ${runCode};`)();\nconst post: StepFn<unknown, unknown> = postCode && Function(`return ${postCode};`)();\n\nexport const exitCode = await benchmark({\n  setup,\n  teardown,\n  pre,\n  run,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n});\n\nprocess.exit(exitCode);\n"],"names":["exitCode","setupCode","teardownCode","preCode","runCode","postCode","data","warmupCycles","minCycles","absThreshold","relThreshold","durationsSAB","controlSAB","workerData","setup","Function","teardown","pre","run","post","benchmark","process","exit"],"mappings":";;;;+BA4BaA;;;eAAAA;;;oCA5Bc;2BACD;AAG1B,MAAM,EACJC,SAAS,EACTC,YAAY,EACZC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRC,IAAI,EAEJC,YAAY,EACZC,SAAS,EACTC,YAAY,EACZC,YAAY,EAEZC,YAAY,EACZC,UAAU,EACX,GAAkBC,8BAAU;AAE7B,MAAMC,QAA0Bb,aAAac,SAAS,CAAC,OAAO,EAAEd,UAAU,CAAC,CAAC;AAC5E,MAAMe,WAAgCd,gBAAgBa,SAAS,CAAC,OAAO,EAAEb,aAAa,CAAC,CAAC;AAExF,MAAMe,MAAgCd,WAAWY,SAAS,CAAC,OAAO,EAAEZ,QAAQ,CAAC,CAAC;AAC9E,MAAMe,MAAgCd,WAAWW,SAAS,CAAC,OAAO,EAAEX,QAAQ,CAAC,CAAC;AAC9E,MAAMe,OAAiCd,YAAYU,SAAS,CAAC,OAAO,EAAEV,SAAS,CAAC,CAAC;AAE1E,MAAML,WAAW,MAAMoB,IAAAA,oBAAS,EAAC;IACtCN;IACAE;IACAC;IACAC;IACAC;IACAb;IAEAC;IACAC;IACAC;IACAC;IAEAC;IACAC;AACF;AAEAS,QAAQC,IAAI,CAACtB"}

package/build/worker.d.ts

@@ -1 +1 @@
-export {};
+export declare const exitCode: number;

package/build/worker.js

@@ -6,7 +6,7 @@ const teardown = teardownCode && Function(`return ${teardownCode};`)();
 const pre = preCode && Function(`return ${preCode};`)();
 const run = runCode && Function(`return ${runCode};`)();
 const post = postCode && Function(`return ${postCode};`)();
-const exitCode = await benchmark({
+export const exitCode = await benchmark({
     setup,
     teardown,
     pre,

package/build/worker.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["import { workerData } from 'node:worker_threads';\nimport { benchmark } from './runner.js';\nimport { SetupFn, TeardownFn, StepFn, WorkerOptions } from './types.js';\n\nconst {\n  setupCode,\n  teardownCode,\n  preCode,\n  runCode,\n  postCode,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n}: WorkerOptions = workerData;\n\nconst setup: SetupFn<unknown> = setupCode && Function(`return ${setupCode};`)();\nconst teardown: TeardownFn<unknown> = teardownCode && Function(`return ${teardownCode};`)();\n\nconst pre: StepFn<unknown, unknown> = preCode && Function(`return ${preCode};`)();\nconst run: StepFn<unknown, unknown> = runCode && Function(`return ${runCode};`)();\nconst post: StepFn<unknown, unknown> = postCode && Function(`return ${postCode};`)();\n\nconst exitCode = await benchmark({\n  setup,\n  teardown,\n  pre,\n  run,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n});\n\nprocess.exit(exitCode);\n"],"names":["workerData","benchmark","setupCode","teardownCode","preCode","runCode","postCode","data","warmupCycles","minCycles","absThreshold","relThreshold","durationsSAB","controlSAB","setup","Function","teardown","pre","run","post","exitCode","process","exit"],"mappings":"AAAA,SAASA,UAAU,QAAQ,sBAAsB;AACjD,SAASC,SAAS,QAAQ,cAAc;AAGxC,MAAM,EACJC,SAAS,EACTC,YAAY,EACZC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRC,IAAI,EAEJC,YAAY,EACZC,SAAS,EACTC,YAAY,EACZC,YAAY,EAEZC,YAAY,EACZC,UAAU,EACX,GAAkBb;AAEnB,MAAMc,QAA0BZ,aAAaa,SAAS,CAAC,OAAO,EAAEb,UAAU,CAAC,CAAC;AAC5E,MAAMc,WAAgCb,gBAAgBY,SAAS,CAAC,OAAO,EAAEZ,aAAa,CAAC,CAAC;AAExF,MAAMc,MAAgCb,WAAWW,SAAS,CAAC,OAAO,EAAEX,QAAQ,CAAC,CAAC;AAC9E,MAAMc,MAAgCb,WAAWU,SAAS,CAAC,OAAO,EAAEV,QAAQ,CAAC,CAAC;AAC9E,MAAMc,OAAiCb,YAAYS,SAAS,CAAC,OAAO,EAAET,SAAS,CAAC,CAAC;AAEjF,MAAMc,WAAW,MAAMnB,UAAU;IAC/Ba;IACAE;IACAC;IACAC;IACAC;IACAZ;IAEAC;IACAC;IACAC;IACAC;IAEAC;IACAC;AACF;AAEAQ,QAAQC,IAAI,CAACF"}
+{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["import { workerData } from 'node:worker_threads';\nimport { benchmark } from './runner.js';\nimport { SetupFn, TeardownFn, StepFn, WorkerOptions } from './types.js';\n\nconst {\n  setupCode,\n  teardownCode,\n  preCode,\n  runCode,\n  postCode,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n}: WorkerOptions = workerData;\n\nconst setup: SetupFn<unknown> = setupCode && Function(`return ${setupCode};`)();\nconst teardown: TeardownFn<unknown> = teardownCode && Function(`return ${teardownCode};`)();\n\nconst pre: StepFn<unknown, unknown> = preCode && Function(`return ${preCode};`)();\nconst run: StepFn<unknown, unknown> = runCode && Function(`return ${runCode};`)();\nconst post: StepFn<unknown, unknown> = postCode && Function(`return ${postCode};`)();\n\nexport const exitCode = await benchmark({\n  setup,\n  teardown,\n  pre,\n  run,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n\n  durationsSAB,\n  controlSAB,\n});\n\nprocess.exit(exitCode);\n"],"names":["workerData","benchmark","setupCode","teardownCode","preCode","runCode","postCode","data","warmupCycles","minCycles","absThreshold","relThreshold","durationsSAB","controlSAB","setup","Function","teardown","pre","run","post","exitCode","process","exit"],"mappings":"AAAA,SAASA,UAAU,QAAQ,sBAAsB;AACjD,SAASC,SAAS,QAAQ,cAAc;AAGxC,MAAM,EACJC,SAAS,EACTC,YAAY,EACZC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRC,IAAI,EAEJC,YAAY,EACZC,SAAS,EACTC,YAAY,EACZC,YAAY,EAEZC,YAAY,EACZC,UAAU,EACX,GAAkBb;AAEnB,MAAMc,QAA0BZ,aAAaa,SAAS,CAAC,OAAO,EAAEb,UAAU,CAAC,CAAC;AAC5E,MAAMc,WAAgCb,gBAAgBY,SAAS,CAAC,OAAO,EAAEZ,aAAa,CAAC,CAAC;AAExF,MAAMc,MAAgCb,WAAWW,SAAS,CAAC,OAAO,EAAEX,QAAQ,CAAC,CAAC;AAC9E,MAAMc,MAAgCb,WAAWU,SAAS,CAAC,OAAO,EAAEV,QAAQ,CAAC,CAAC;AAC9E,MAAMc,OAAiCb,YAAYS,SAAS,CAAC,OAAO,EAAET,SAAS,CAAC,CAAC;AAEjF,OAAO,MAAMc,WAAW,MAAMnB,UAAU;IACtCa;IACAE;IACAC;IACAC;IACAC;IACAZ;IAEAC;IACAC;IACAC;IACAC;IAEAC;IACAC;AACF,GAAG;AAEHQ,QAAQC,IAAI,CAACF"}

package/examples/complete.ts

@@ -29,7 +29,7 @@ v8Target
     // executed before measurement
   })
   .post(async (_ctx, _input) => {
-    // executed before measurement
+    // executed after measurement
   });
 
 v8Target
@@ -64,11 +64,11 @@ jsonTarget
     // executed before measurement
   })
   .post(async (_ctx, _input) => {
-    // executed before measurement
+    // executed after measurement
   });
 
 jsonTarget
-  .measure('parsse', ({ parse, serialized }) => {
+  .measure('parse', ({ parse, serialized }) => {
     parse(serialized);
   })
   .pre(async (ctx, input) => {

package/examples/custom-reports.ts

@@ -0,0 +1,22 @@
+// Demonstrates custom report types and statistics
+// CLI mode: npx overtake examples/custom-reports.ts -f table -r ops mean median p95 p99
+// Programmatic mode: node examples/custom-reports.js
+
+import { Benchmark, printTableReports } from '../build/index.js';
+
+const performanceSuite = new Benchmark('10K numbers', () => Array.from({ length: 10_000 }, () => Math.random() * 1000));
+
+// Compare different rounding methods
+performanceSuite.target('rounding methods').measure('Math.floor', (_, numbers) => {
+  for (const n of numbers) Math.floor(n);
+});
+
+// Execute with custom statistics
+const reports = await performanceSuite.execute({
+  workers: 4,
+  minCycles: 100,
+  maxCycles: 500,
+  reportTypes: ['ops', 'mean', 'median', 'p50', 'p95', 'p99', 'min', 'max'] as const,
+});
+
+printTableReports(reports);

package/examples/imports.ts

@@ -0,0 +1,51 @@
+// Demonstrates correct import patterns for worker context
+// Run: npx overtake examples/imports.ts
+
+const importExamples = benchmark('test data', () => Buffer.from('hello world'));
+
+// Node built-in modules work normally
+importExamples
+  .target('node built-ins', async () => {
+    const { createHash } = await import('node:crypto');
+    return { createHash };
+  })
+  .measure('sha256 hash', ({ createHash }, buffer) => {
+    createHash('sha256').update(buffer).digest('hex');
+  });
+
+// IMPORTANT: Local files need absolute paths
+// Relative imports resolve from node_modules/overtake/build/, not your project
+const localFilesTarget = importExamples.target('local files', async () => {
+  const { join } = await import('node:path');
+
+  // Build absolute path to your local module
+  const localModulePath = join(process.cwd(), './build/types.js');
+  const { DEFAULT_CYCLES, Control } = await import(localModulePath);
+
+  return {
+    DEFAULT_CYCLES,
+    Control,
+    // You can also define functions here
+    processData: (data: Buffer) => data.length,
+  };
+});
+
+localFilesTarget.measure('use imported constant', ({ DEFAULT_CYCLES }) => {
+  DEFAULT_CYCLES > 100;
+});
+
+localFilesTarget.measure('use local function', ({ processData }, buffer) => {
+  processData(buffer);
+});
+
+// Memory management pattern - prevent GC during measurements
+importExamples
+  .target('memory management', () => {
+    const gcBlock = new Set();
+    return { gcBlock };
+  })
+  .measure('without GC', ({ gcBlock }, buffer) => {
+    const result = Buffer.concat([buffer, buffer]);
+    gcBlock.add(result); // Keep reference alive
+    result.length;
+  });

package/examples/quick-start.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",

package/src/cli.ts

@@ -59,7 +59,10 @@ commander
           return instance;
         };
         const script = new SourceTextModule(code, {
-          context: createContext({ benchmark }),
+          context: createContext({
+            benchmark,
+            Buffer,
+          }),
         });
         const imports = new Map();
         await script.link(async (specifier: string, referencingModule) => {

package/src/runner.ts

@@ -48,6 +48,9 @@ export const benchmark = async <TContext, TInput>({
     await pre?.(context, data!);
     const result = runRaw(context, data!);
     await post?.(context, data!);
+    global.gc?.();
+    global.gc?.();
+
     const run = result instanceof Promise ? runAsync(runRaw) : runSync(runRaw);
     const start = Date.now();
     while (Date.now() - start < 1_000) {
@@ -57,6 +60,8 @@ export const benchmark = async <TContext, TInput>({
       await pre?.(context, data!);
       await run(context, data);
       await post?.(context, data!);
+      global.gc?.();
+      global.gc?.();
     }
 
     let i = 0;
@@ -69,6 +74,8 @@ export const benchmark = async <TContext, TInput>({
       await pre?.(context, data!);
       const duration = await run(context, data);
       await post?.(context, data!);
+      global.gc?.();
+      global.gc?.();
 
       durations[i++] = duration;
       const delta = duration - mean;

package/src/worker.ts

@@ -26,7 +26,7 @@ const pre: StepFn<unknown, unknown> = preCode && Function(`return ${preCode};`)(
 const run: StepFn<unknown, unknown> = runCode && Function(`return ${runCode};`)();
 const post: StepFn<unknown, unknown> = postCode && Function(`return ${postCode};`)();
 
-const exitCode = await benchmark({
+export const exitCode = await benchmark({
   setup,
   teardown,
   pre,

package/CLAUDE.md

@@ -1,145 +0,0 @@
-# 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/examples/array-copy.ts

@@ -1,17 +0,0 @@
-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));
-
-copySuite.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];
-  }
-});
-
-copySuite.target('copyWithin').measure('copy half', (_, input) => {
-  const n = input?.length ?? 0;
-  const mid = n / 2;
-  input.copyWithin(mid, 0, mid);
-});

package/examples/object-merge.ts

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

package/examples/serialization.ts

@@ -1,22 +0,0 @@
-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));
-  });