overtake 1.4.0 → 2.0.1

package/build/utils.js

@@ -1,22 +1,32 @@
-import { transform, parseSync } from '@swc/core';
-export const isqrt = (n)=>{
-    if (n < 0n) throw new RangeError('Square root of negative');
-    if (n < 2n) return n;
+import { parseSync } from '@swc/core';
+async function resolve(s, c, n) {
+    try {
+        return await n(s, c);
+    }
+    catch (e) {
+        if (s.endsWith('.js'))
+            try {
+                return await n(s.slice(0, -3) + '.ts', c);
+            }
+            catch { }
+        throw e;
+    }
+}
+export const resolveHookUrl = 'data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`);
+export const isqrt = (n) => {
+    if (n < 0n)
+        throw new RangeError('Square root of negative');
+    if (n < 2n)
+        return n;
     let x = n;
-    let y = x + 1n >> 1n;
-    while(y < x){
+    let y = (x + 1n) >> 1n;
+    while (y < x) {
         x = y;
-        y = x + n / x >> 1n;
+        y = (x + n / x) >> 1n;
     }
     return x;
 };
-export const abs = (value)=>{
-    if (value < 0n) {
-        return -value;
-    }
-    return value;
-};
-export const cmp = (a, b)=>{
+export const cmp = (a, b) => {
     if (a > b) {
         return 1;
     }
@@ -25,108 +35,66 @@ export const cmp = (a, b)=>{
     }
     return 0;
 };
-export const max = (a, b)=>{
+export const max = (a, b) => {
     if (a > b) {
         return a;
     }
     return b;
 };
-export const divMod = (a, b)=>{
-    return {
-        quotient: a / b,
-        remainder: a % b
-    };
-};
 export function div(a, b, decimals = 2) {
-    if (b === 0n) throw new RangeError('Division by zero');
+    if (b === 0n)
+        throw new RangeError('Division by zero');
     const scale = 10n ** BigInt(decimals);
-    const scaled = a * scale / b;
+    const scaled = (a * scale) / b;
     const intPart = scaled / scale;
     const fracPart = scaled % scale;
     return `${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
 }
 export function divs(a, b, scale) {
-    if (b === 0n) throw new RangeError('Division by zero');
-    return a * scale / b;
-}
-export class ScaledBigInt {
-    value;
-    scale;
-    constructor(value, scale){
-        this.value = value;
-        this.scale = scale;
-    }
-    add(value) {
-        this.value += value * this.scale;
-    }
-    sub(value) {
-        this.value -= value * this.scale;
-    }
-    div(value) {
-        this.value /= value;
-    }
-    mul(value) {
-        this.value *= value;
-    }
-    unscale() {
-        return this.value / this.scale;
-    }
-    number() {
-        return Number(div(this.value, this.scale));
-    }
+    if (b === 0n)
+        throw new RangeError('Division by zero');
+    return (a * scale) / b;
 }
 const KNOWN_GLOBALS = new Set(Object.getOwnPropertyNames(globalThis));
 KNOWN_GLOBALS.add('arguments');
 function collectUnresolved(node, result) {
-    if (!node || typeof node !== 'object') return;
+    if (!node || typeof node !== 'object')
+        return;
     if (Array.isArray(node)) {
-        for (const item of node)collectUnresolved(item, result);
+        for (const item of node)
+            collectUnresolved(item, result);
         return;
     }
     const obj = node;
     if (obj.type === 'Identifier' && obj.ctxt === 1 && typeof obj.value === 'string') {
         result.add(obj.value);
     }
-    for (const key of Object.keys(obj)){
-        if (key === 'span') continue;
+    for (const key of Object.keys(obj)) {
+        if (key === 'span')
+            continue;
         collectUnresolved(obj[key], result);
     }
 }
 export function assertNoClosure(code, name) {
     let ast;
     try {
-        ast = parseSync(`var __fn = ${code}`, {
-            syntax: 'ecmascript',
-            target: 'esnext'
-        });
-    } catch  {
+        ast = parseSync(`var __fn = ${code}`, { syntax: 'ecmascript', target: 'esnext' });
+    }
+    catch {
         return;
     }
     const unresolved = new Set();
     collectUnresolved(ast, unresolved);
-    for (const g of KNOWN_GLOBALS)unresolved.delete(g);
-    if (unresolved.size === 0) return;
-    const vars = [
-        ...unresolved
-    ].join(', ');
-    throw new Error(`Benchmark "${name}" function references outer-scope variables: ${vars}\n\n` + `Benchmark functions are serialized with .toString() and executed in an isolated\n` + `worker thread. Closed-over variables from the original module scope are not\n` + `available in the worker and will cause a ReferenceError at runtime.\n\n` + `To fix this, move the referenced values into:\n` + `  - "setup" function (returned value becomes the first argument of run/pre/post)\n` + `  - "data" option (passed as the second argument of run/pre/post)`);
+    for (const g of KNOWN_GLOBALS)
+        unresolved.delete(g);
+    if (unresolved.size === 0)
+        return;
+    const vars = [...unresolved].join(', ');
+    throw new Error(`Benchmark "${name}" function references outer-scope variables: ${vars}\n\n` +
+        `Benchmark functions are serialized with .toString() and executed in an isolated\n` +
+        `worker thread. Closed-over variables from the original module scope are not\n` +
+        `available in the worker and will cause a ReferenceError at runtime.\n\n` +
+        `To fix this, move the referenced values into:\n` +
+        `  - "setup" function (returned value becomes the first argument of run/pre/post)\n` +
+        `  - "data" option (passed as the second argument of run/pre/post)`);
 }
-export const transpile = async (code)=>{
-    const output = await transform(code, {
-        filename: 'benchmark.ts',
-        jsc: {
-            parser: {
-                syntax: 'typescript',
-                tsx: false,
-                dynamicImport: true
-            },
-            target: 'esnext'
-        },
-        module: {
-            type: 'es6'
-        }
-    });
-    return output.code;
-};
-
-//# sourceMappingURL=utils.js.map

package/build/worker.js

@@ -1,15 +1,18 @@
 import { workerData } from 'node:worker_threads';
 import { SourceTextModule, SyntheticModule } from 'node:vm';
-import { createRequire } from 'node:module';
+import { createRequire, register } from 'node:module';
 import { isAbsolute } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { benchmark } from "./runner.js";
-const { benchmarkUrl, setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB } = workerData;
-const serialize = (code)=>code ? code : 'undefined';
+import { benchmark } from './runner.js';
+import {} from './types.js';
+import { resolveHookUrl } from './utils.js';
+register(resolveHookUrl);
+const { benchmarkUrl, setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB, } = workerData;
+const serialize = (code) => (code ? code : 'undefined');
 const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
 const benchmarkDirUrl = new URL('.', resolvedBenchmarkUrl).href;
 const requireFrom = createRequire(fileURLToPath(new URL('benchmark.js', benchmarkDirUrl)));
-const resolveSpecifier = (specifier)=>{
+const resolveSpecifier = (specifier) => {
     if (specifier.startsWith('file:')) {
         return specifier;
     }
@@ -21,7 +24,8 @@ const resolveSpecifier = (specifier)=>{
     }
     try {
         return requireFrom.resolve(specifier);
-    } catch  {
+    }
+    catch {
         return specifier;
     }
 };
@@ -33,25 +37,24 @@ export const run = ${serialize(runCode)};
 export const post = ${serialize(postCode)};
   `;
 const imports = new Map();
-const createSyntheticModule = (moduleExports, exportNames, identifier)=>{
-    const mod = new SyntheticModule(exportNames, ()=>{
-        for (const name of exportNames){
+const createSyntheticModule = (moduleExports, exportNames, identifier) => {
+    const mod = new SyntheticModule(exportNames, () => {
+        for (const name of exportNames) {
             if (name === 'default') {
                 mod.setExport(name, moduleExports);
                 continue;
             }
             mod.setExport(name, moduleExports[name]);
         }
-    }, {
-        identifier
-    });
+    }, { identifier });
     return mod;
 };
-const isCjsModule = (target)=>target.endsWith('.cjs') || target.endsWith('.cts');
-const toRequireTarget = (target)=>target.startsWith('file:') ? fileURLToPath(target) : target;
-const loadModule = async (target)=>{
+const isCjsModule = (target) => target.endsWith('.cjs') || target.endsWith('.cts');
+const toRequireTarget = (target) => (target.startsWith('file:') ? fileURLToPath(target) : target);
+const loadModule = async (target) => {
     const cached = imports.get(target);
-    if (cached) return cached;
+    if (cached)
+        return cached;
     if (isCjsModule(target)) {
         const required = requireFrom(toRequireTarget(target));
         const exportNames = required && (typeof required === 'object' || typeof required === 'function') ? Object.keys(required) : [];
@@ -68,7 +71,7 @@ const loadModule = async (target)=>{
     imports.set(target, mod);
     return mod;
 };
-const loadDynamicModule = async (target)=>{
+const loadDynamicModule = async (target) => {
     const mod = await loadModule(target);
     if (mod.status !== 'evaluated') {
         await mod.evaluate();
@@ -77,15 +80,15 @@ const loadDynamicModule = async (target)=>{
 };
 const mod = new SourceTextModule(source, {
     identifier: resolvedBenchmarkUrl,
-    initializeImportMeta (meta) {
+    initializeImportMeta(meta) {
         meta.url = resolvedBenchmarkUrl;
     },
-    importModuleDynamically (specifier) {
+    importModuleDynamically(specifier) {
         const resolved = resolveSpecifier(specifier);
         return loadDynamicModule(resolved);
-    }
+    },
 });
-await mod.link(async (specifier)=>loadModule(resolveSpecifier(specifier)));
+await mod.link(async (specifier) => loadModule(resolveSpecifier(specifier)));
 await mod.evaluate();
 const { setup, teardown, pre, run, post } = mod.namespace;
 if (!run) {
@@ -104,7 +107,5 @@ process.exitCode = await benchmark({
     relThreshold,
     gcObserver,
     durationsSAB,
-    controlSAB
+    controlSAB,
 });
-
-//# sourceMappingURL=worker.js.map

package/package.json

@@ -1,28 +1,18 @@
 {
   "name": "overtake",
-  "version": "1.4.0",
+  "version": "2.0.1",
   "description": "NodeJS performance benchmark",
   "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"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "repository": {
     "type": "git",
@@ -41,30 +31,22 @@
   },
   "homepage": "https://github.com/3axap4eHko/overtake#readme",
   "devDependencies": {
-    "@jest/globals": "^30.2.0",
-    "@swc/jest": "^0.2.39",
-    "@types/async": "^3.2.25",
-    "@types/jest": "^30.0.0",
     "@types/node": "^25.3.0",
     "@types/progress": "^2.0.7",
     "husky": "^9.1.7",
-    "inop": "^0.9.0",
-    "jest": "^30.2.0",
     "overtake": "^1.3.1",
     "prettier": "^3.8.1",
     "pretty-quick": "^4.2.2",
-    "typescript": "^5.9.3"
+    "typescript": "5.9.3"
   },
   "dependencies": {
-    "@swc/core": "^1.15.11",
-    "async": "^3.2.6",
-    "commander": "^14.0.3",
-    "glob": "^13.0.6",
+    "@swc/core": "^1.15.18",
     "progress": "^2.0.3"
   },
   "scripts": {
-    "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
+    "build": "rm -rf build && tsc",
     "start": "./bin/overtake.js",
-    "test": "jest --detectOpenHandles --passWithNoTests"
+    "test": "node --experimental-test-module-mocks --import ./src/register-hook.ts --test src/__tests__/*.ts",
+    "test:cov": "node --experimental-test-module-mocks --experimental-test-coverage --import ./src/register-hook.ts --test src/__tests__/*.ts"
   }
 }

package/src/__tests__/assert-no-closure.ts

@@ -0,0 +1,135 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { assertNoClosure } from '../utils.js';
+
+describe('assertNoClosure', () => {
+  describe('allows functions without closures', () => {
+    it('arrow with params only', () => {
+      assert.doesNotThrow(() => assertNoClosure('(x) => x * 2', 'run'));
+    });
+
+    it('arrow with local variables', () => {
+      assert.doesNotThrow(() => assertNoClosure('(ctx, input) => { const y = ctx.value + input; return y; }', 'run'));
+    });
+
+    it('function expression', () => {
+      assert.doesNotThrow(() => assertNoClosure('function(x) { return x + 1; }', 'run'));
+    });
+
+    it('named function expression', () => {
+      assert.doesNotThrow(() => assertNoClosure('function run(x) { return x + 1; }', 'run'));
+    });
+
+    it('async arrow', () => {
+      assert.doesNotThrow(() => assertNoClosure('async (ctx) => { const r = await fetch("url"); return r; }', 'run'));
+    });
+
+    it('destructured params', () => {
+      assert.doesNotThrow(() => assertNoClosure('({a, b: c}, [d, ...e]) => a + c + d + e.length', 'run'));
+    });
+
+    it('nested function declaration', () => {
+      assert.doesNotThrow(() => assertNoClosure('(arr) => { function helper(x) { return x * 2; } return arr.map(helper); }', 'run'));
+    });
+
+    it('for-of loop variable', () => {
+      assert.doesNotThrow(() => assertNoClosure('(arr) => { let sum = 0; for (const x of arr) sum += x; return sum; }', 'run'));
+    });
+
+    it('member access on params', () => {
+      assert.doesNotThrow(() => assertNoClosure('(ctx) => ctx.data.map(x => x.value)', 'run'));
+    });
+
+    it('globals like console, Buffer, Math, Array', () => {
+      assert.doesNotThrow(() => assertNoClosure('(ctx) => { console.log(Math.max(...ctx)); return Buffer.from(Array.of(1)); }', 'run'));
+    });
+
+    it('try-catch with error binding', () => {
+      assert.doesNotThrow(() => assertNoClosure('(ctx) => { try { return ctx(); } catch (e) { return e; } }', 'run'));
+    });
+
+    it('class expression', () => {
+      assert.doesNotThrow(() => assertNoClosure('() => { class Foo { bar() { return 1; } } return new Foo(); }', 'run'));
+    });
+
+    it('label statements', () => {
+      assert.doesNotThrow(() => assertNoClosure('() => { outer: for (let i = 0; i < 10; i++) { break outer; } }', 'run'));
+    });
+  });
+
+  describe('detects closures', () => {
+    it('single closed-over variable', () => {
+      assert.throws(() => assertNoClosure('(x) => x + closedOver', 'run'), /closedOver/);
+    });
+
+    it('multiple closed-over variables', () => {
+      assert.throws(() => assertNoClosure('(ctx) => sharedData.filter(x => x > threshold)', 'run'), /sharedData/);
+    });
+
+    it('closed-over function call', () => {
+      assert.throws(() => assertNoClosure('(ctx) => helper(ctx)', 'run'), /helper/);
+    });
+
+    it('closed-over array', () => {
+      assert.throws(() => assertNoClosure('() => myArray.map(x => x * 2)', 'run'), /myArray/);
+    });
+
+    it('computed member access with outer variable', () => {
+      assert.throws(() => assertNoClosure('(obj) => obj[key]', 'run'), /key/);
+    });
+
+    it('variable used as argument', () => {
+      assert.throws(() => assertNoClosure('() => JSON.stringify(config)', 'run'), /config/);
+    });
+
+    it('variable in template literal', () => {
+      assert.throws(() => assertNoClosure('() => `${prefix}-value`', 'run'), /prefix/);
+    });
+  });
+
+  describe('error message', () => {
+    it('includes the function name', () => {
+      assert.throws(() => assertNoClosure('() => x', 'setup'), /"setup"/);
+      assert.throws(() => assertNoClosure('() => x', 'run'), /"run"/);
+      assert.throws(() => assertNoClosure('() => x', 'teardown'), /"teardown"/);
+    });
+
+    it('lists all closed-over variables', () => {
+      try {
+        assertNoClosure('() => a + b + c', 'run');
+        assert.fail('should have thrown');
+      } catch (e) {
+        assert.match((e as Error).message, /\ba\b/);
+        assert.match((e as Error).message, /\bb\b/);
+        assert.match((e as Error).message, /\bc\b/);
+      }
+    });
+
+    it('explains the problem and suggests fix', () => {
+      try {
+        assertNoClosure('() => x', 'run');
+        assert.fail('should have thrown');
+      } catch (e) {
+        const msg = (e as Error).message;
+        assert.ok(msg.includes('.toString()'));
+        assert.ok(msg.includes('worker'));
+        assert.ok(msg.includes('setup'));
+        assert.ok(msg.includes('data'));
+      }
+    });
+  });
+
+  describe('edge cases', () => {
+    it('silently passes on unparseable code', () => {
+      assert.doesNotThrow(() => assertNoClosure('not valid js {{{', 'run'));
+    });
+
+    it('empty arrow function', () => {
+      assert.doesNotThrow(() => assertNoClosure('() => {}', 'run'));
+    });
+
+    it('undefined return', () => {
+      assert.doesNotThrow(() => assertNoClosure('() => undefined', 'run'));
+    });
+  });
+});

package/src/__tests__/benchmark-execute.ts

@@ -0,0 +1,48 @@
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert/strict';
+
+describe('Benchmark.execute', () => {
+  it('returns an error report when executor task setup fails', async () => {
+    const pushAsync = mock.fn(() => Promise.reject(new Error('Benchmark "run" function references outer-scope variables: port')));
+    const kill = mock.fn();
+
+    mock.module('../executor.js', {
+      namedExports: {
+        createExecutor: () => ({ pushAsync, kill }),
+      },
+    });
+
+    const { Benchmark } = await import('../index.js');
+
+    const bench = Benchmark.create('feed');
+    bench.target('target').measure('run', () => 1);
+
+    const reports = await bench.execute();
+
+    assert.deepStrictEqual(reports, [
+      {
+        target: 'target',
+        measures: [
+          {
+            measure: 'run',
+            feeds: [
+              {
+                feed: 'feed',
+                data: {
+                  count: 0,
+                  heapUsedKB: 0,
+                  dceWarning: false,
+                  error: 'Benchmark "run" function references outer-scope variables: port',
+                },
+              },
+            ],
+          },
+        ],
+      },
+    ]);
+    assert.strictEqual(pushAsync.mock.callCount(), 1);
+    assert.strictEqual(kill.mock.callCount(), 1);
+
+    mock.restoreAll();
+  });
+});