overtake 1.1.1 → 1.1.3

package/build/worker.cjs

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 const _nodeworker_threads = require("node:worker_threads");
 const _nodevm = require("node:vm");
 const _nodemodule = require("node:module");
+const _nodepath = require("node:path");
 const _nodeurl = require("node:url");
 const _runnercjs = require("./runner.cjs");
 function _getRequireWildcardCache(nodeInterop) {
@@ -48,17 +49,22 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const { baseUrl, setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB } = _nodeworker_threads.workerData;
-const serialize = (code)=>code ? code : '() => {}';
-const isCjs = typeof require !== 'undefined';
-const resolveSpecifier = (specifier, parent)=>{
-    if (!isCjs) {
-        try {
-            return require.resolve(specifier, parent);
-        } catch  {}
+const { benchmarkUrl, setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB } = _nodeworker_threads.workerData;
+const serialize = (code)=>code ? code : 'undefined';
+const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : (0, _nodeurl.pathToFileURL)(process.cwd()).href;
+const benchmarkDirUrl = new URL('.', resolvedBenchmarkUrl).href;
+const requireFrom = (0, _nodemodule.createRequire)((0, _nodeurl.fileURLToPath)(new URL('benchmark.js', benchmarkDirUrl)));
+const resolveSpecifier = (specifier)=>{
+    if (specifier.startsWith('file:')) {
+        return specifier;
     }
-    const resolveFrom = (0, _nodemodule.createRequire)((0, _nodeurl.fileURLToPath)(parent));
-    return resolveFrom.resolve(specifier);
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        return new URL(specifier, benchmarkDirUrl).href;
+    }
+    if ((0, _nodepath.isAbsolute)(specifier)) {
+        return (0, _nodeurl.pathToFileURL)(specifier).href;
+    }
+    return requireFrom.resolve(specifier);
 };
 const source = `
 export const setup = ${serialize(setupCode)};
@@ -72,41 +78,67 @@ const context = (0, _nodevm.createContext)({
     Buffer
 });
 const imports = new Map();
+const createSyntheticModule = (moduleExports, exportNames, identifier)=>{
+    const mod = new _nodevm.SyntheticModule(exportNames, ()=>{
+        for (const name of exportNames){
+            if (name === 'default') {
+                mod.setExport(name, moduleExports);
+                continue;
+            }
+            mod.setExport(name, moduleExports[name]);
+        }
+    }, {
+        identifier,
+        context
+    });
+    return mod;
+};
+const isCjsModule = (target)=>target.endsWith('.cjs') || target.endsWith('.cts');
+const toRequireTarget = (target)=>target.startsWith('file:') ? (0, _nodeurl.fileURLToPath)(target) : target;
+const loadModule = async (target)=>{
+    const cached = imports.get(target);
+    if (cached) return cached;
+    if (isCjsModule(target)) {
+        const required = requireFrom(toRequireTarget(target));
+        const exportNames = required && (typeof required === 'object' || typeof required === 'function') ? Object.keys(required) : [];
+        if (!exportNames.includes('default')) {
+            exportNames.push('default');
+        }
+        const mod = createSyntheticModule(required, exportNames, target);
+        imports.set(target, mod);
+        return mod;
+    }
+    const importedModule = await Promise.resolve(target).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
+    const exportNames = Object.keys(importedModule);
+    const mod = createSyntheticModule(importedModule, exportNames, target);
+    imports.set(target, mod);
+    return mod;
+};
+const loadDynamicModule = async (target)=>{
+    const mod = await loadModule(target);
+    if (mod.status !== 'evaluated') {
+        await mod.evaluate();
+    }
+    return mod;
+};
 const mod = new _nodevm.SourceTextModule(source, {
-    identifier: baseUrl,
+    identifier: resolvedBenchmarkUrl,
     context,
     initializeImportMeta (meta) {
-        meta.url = baseUrl;
+        meta.url = resolvedBenchmarkUrl;
     },
-    importModuleDynamically (specifier, referencingModule) {
-        const base = referencingModule.identifier ?? baseUrl;
-        const resolved = resolveSpecifier(specifier, base);
-        return Promise.resolve(resolved).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
+    importModuleDynamically (specifier) {
+        const resolved = resolveSpecifier(specifier);
+        return loadDynamicModule(resolved);
     }
 });
-await mod.link(async (specifier, referencingModule)=>{
-    const base = referencingModule.identifier ?? baseUrl;
-    const target = resolveSpecifier(specifier, base);
-    const cached = imports.get(target);
-    if (cached) return cached;
-    const importedModule = await Promise.resolve(target).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
-    const exportNames = Object.keys(importedModule);
-    const imported = new _nodevm.SyntheticModule(exportNames, ()=>{
-        exportNames.forEach((key)=>imported.setExport(key, importedModule[key]));
-    }, {
-        identifier: target,
-        context: referencingModule.context
-    });
-    imports.set(target, imported);
-    return imported;
-});
+await mod.link(async (specifier)=>loadModule(resolveSpecifier(specifier)));
 await mod.evaluate();
 const { setup, teardown, pre, run, post } = mod.namespace;
 if (!run) {
     throw new Error('Benchmark run function is required');
 }
 process.exitCode = await (0, _runnercjs.benchmark)({
-    baseUrl,
     setup,
     teardown,
     pre,

package/build/worker.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["import { workerData } from 'node:worker_threads';\nimport { SourceTextModule, SyntheticModule, createContext } from 'node:vm';\nimport { createRequire } from 'node:module';\nimport { fileURLToPath } from 'node:url';\nimport { benchmark } from './runner.js';\nimport { WorkerOptions } from './types.js';\n\nconst {\n  baseUrl,\n  setupCode,\n  teardownCode,\n  preCode,\n  runCode,\n  postCode,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n  gcObserver = true,\n\n  durationsSAB,\n  controlSAB,\n}: WorkerOptions = workerData;\n\nconst serialize = (code?: string) => (code ? code : '() => {}');\n\nconst isCjs = typeof require !== 'undefined';\n\nconst resolveSpecifier = (specifier: string, parent: string) => {\n  if (!isCjs) {\n    try {\n      return import.meta.resolve(specifier, parent);\n    } catch {\n      // fall through to CommonJS resolution\n    }\n  }\n  const resolveFrom = createRequire(fileURLToPath(parent));\n  return resolveFrom.resolve(specifier);\n};\n\nconst source = `\nexport const setup = ${serialize(setupCode)};\nexport const teardown = ${serialize(teardownCode)};\nexport const pre = ${serialize(preCode)};\nexport const run = ${serialize(runCode)};\nexport const post = ${serialize(postCode)};\n  `;\n\nconst context = createContext({ console, Buffer });\nconst imports = new Map<string, SyntheticModule>();\nconst mod = new SourceTextModule(source, {\n  identifier: baseUrl,\n  context,\n  initializeImportMeta(meta) {\n    meta.url = baseUrl;\n  },\n  importModuleDynamically(specifier, referencingModule) {\n    const base = referencingModule.identifier ?? baseUrl;\n    const resolved = resolveSpecifier(specifier, base);\n    return import(resolved);\n  },\n});\n\nawait mod.link(async (specifier, referencingModule) => {\n  const base = referencingModule.identifier ?? baseUrl;\n  const target = resolveSpecifier(specifier, base);\n  const cached = imports.get(target);\n  if (cached) return cached;\n\n  const importedModule = await import(target);\n  const exportNames = Object.keys(importedModule);\n  const imported = new SyntheticModule(\n    exportNames,\n    () => {\n      exportNames.forEach((key) => imported.setExport(key, importedModule[key]));\n    },\n    { identifier: target, context: referencingModule.context },\n  );\n  imports.set(target, imported);\n  return imported;\n});\n\nawait mod.evaluate();\nconst { setup, teardown, pre, run, post } = mod.namespace as any;\n\nif (!run) {\n  throw new Error('Benchmark run function is required');\n}\n\nprocess.exitCode = await benchmark({\n  baseUrl,\n  setup,\n  teardown,\n  pre,\n  run,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n  gcObserver,\n\n  durationsSAB,\n  controlSAB,\n});\n"],"names":["baseUrl","setupCode","teardownCode","preCode","runCode","postCode","data","warmupCycles","minCycles","absThreshold","relThreshold","gcObserver","durationsSAB","controlSAB","workerData","serialize","code","isCjs","require","resolveSpecifier","specifier","parent","resolve","resolveFrom","createRequire","fileURLToPath","source","context","createContext","console","Buffer","imports","Map","mod","SourceTextModule","identifier","initializeImportMeta","meta","url","importModuleDynamically","referencingModule","base","resolved","link","target","cached","get","importedModule","exportNames","Object","keys","imported","SyntheticModule","forEach","key","setExport","set","evaluate","setup","teardown","pre","run","post","namespace","Error","process","exitCode","benchmark"],"mappings":";;;;oCAA2B;wBACsC;4BACnC;yBACA;2BACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG1B,MAAM,EACJA,OAAO,EACPC,SAAS,EACTC,YAAY,EACZC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRC,IAAI,EAEJC,YAAY,EACZC,SAAS,EACTC,YAAY,EACZC,YAAY,EACZC,aAAa,IAAI,EAEjBC,YAAY,EACZC,UAAU,EACX,GAAkBC,8BAAU;AAE7B,MAAMC,YAAY,CAACC,OAAmBA,OAAOA,OAAO;AAEpD,MAAMC,QAAQ,OAAOC,YAAY;AAEjC,MAAMC,mBAAmB,CAACC,WAAmBC;IAC3C,IAAI,CAACJ,OAAO;QACV,IAAI;YACF,OAAO,QAAYK,OAAO,CAACF,WAAWC;QACxC,EAAE,OAAM,CAER;IACF;IACA,MAAME,cAAcC,IAAAA,yBAAa,EAACC,IAAAA,sBAAa,EAACJ;IAChD,OAAOE,YAAYD,OAAO,CAACF;AAC7B;AAEA,MAAMM,SAAS,CAAC;qBACK,EAAEX,UAAUd,WAAW;wBACpB,EAAEc,UAAUb,cAAc;mBAC/B,EAAEa,UAAUZ,SAAS;mBACrB,EAAEY,UAAUX,SAAS;oBACpB,EAAEW,UAAUV,UAAU;EACxC,CAAC;AAEH,MAAMsB,UAAUC,IAAAA,qBAAa,EAAC;IAAEC;IAASC;AAAO;AAChD,MAAMC,UAAU,IAAIC;AACpB,MAAMC,MAAM,IAAIC,wBAAgB,CAACR,QAAQ;IACvCS,YAAYnC;IACZ2B;IACAS,sBAAqBC,IAAI;QACvBA,KAAKC,GAAG,GAAGtC;IACb;IACAuC,yBAAwBnB,SAAS,EAAEoB,iBAAiB;QAClD,MAAMC,OAAOD,kBAAkBL,UAAU,IAAInC;QAC7C,MAAM0C,WAAWvB,iBAAiBC,WAAWqB;QAC7C,OAAO,gBAAOC,4DAAP;IACT;AACF;AAEA,MAAMT,IAAIU,IAAI,CAAC,OAAOvB,WAAWoB;IAC/B,MAAMC,OAAOD,kBAAkBL,UAAU,IAAInC;IAC7C,MAAM4C,SAASzB,iBAAiBC,WAAWqB;IAC3C,MAAMI,SAASd,QAAQe,GAAG,CAACF;IAC3B,IAAIC,QAAQ,OAAOA;IAEnB,MAAME,iBAAiB,MAAM,gBAAOH,0DAAP;IAC7B,MAAMI,cAAcC,OAAOC,IAAI,CAACH;IAChC,MAAMI,WAAW,IAAIC,uBAAe,CAClCJ,aACA;QACEA,YAAYK,OAAO,CAAC,CAACC,MAAQH,SAASI,SAAS,CAACD,KAAKP,cAAc,CAACO,IAAI;IAC1E,GACA;QAAEnB,YAAYS;QAAQjB,SAASa,kBAAkBb,OAAO;IAAC;IAE3DI,QAAQyB,GAAG,CAACZ,QAAQO;IACpB,OAAOA;AACT;AAEA,MAAMlB,IAAIwB,QAAQ;AAClB,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,GAAG,EAAEC,GAAG,EAAEC,IAAI,EAAE,GAAG7B,IAAI8B,SAAS;AAEzD,IAAI,CAACF,KAAK;IACR,MAAM,IAAIG,MAAM;AAClB;AAEAC,QAAQC,QAAQ,GAAG,MAAMC,IAAAA,oBAAS,EAAC;IACjCnE;IACA0D;IACAC;IACAC;IACAC;IACAC;IACAxD;IAEAC;IACAC;IACAC;IACAC;IACAC;IAEAC;IACAC;AACF"}
+{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["import { workerData } from 'node:worker_threads';\nimport { SourceTextModule, SyntheticModule, createContext } from 'node:vm';\nimport { createRequire } from 'node:module';\nimport { isAbsolute } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport { benchmark } from './runner.js';\nimport { WorkerOptions } from './types.js';\n\nconst {\n  benchmarkUrl,\n  setupCode,\n  teardownCode,\n  preCode,\n  runCode,\n  postCode,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n  gcObserver = true,\n\n  durationsSAB,\n  controlSAB,\n}: WorkerOptions = workerData;\n\nconst serialize = (code?: string) => (code ? code : 'undefined');\n\nconst resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;\nconst benchmarkDirUrl = new URL('.', resolvedBenchmarkUrl).href;\nconst requireFrom = createRequire(fileURLToPath(new URL('benchmark.js', benchmarkDirUrl)));\n\nconst resolveSpecifier = (specifier: string) => {\n  if (specifier.startsWith('file:')) {\n    return specifier;\n  }\n  if (specifier.startsWith('./') || specifier.startsWith('../')) {\n    return new URL(specifier, benchmarkDirUrl).href;\n  }\n  if (isAbsolute(specifier)) {\n    return pathToFileURL(specifier).href;\n  }\n  return requireFrom.resolve(specifier);\n};\n\nconst source = `\nexport const setup = ${serialize(setupCode)};\nexport const teardown = ${serialize(teardownCode)};\nexport const pre = ${serialize(preCode)};\nexport const run = ${serialize(runCode)};\nexport const post = ${serialize(postCode)};\n  `;\n\nconst context = createContext({ console, Buffer });\nconst imports = new Map<string, SyntheticModule>();\n\nconst createSyntheticModule = (moduleExports: unknown, exportNames: string[], identifier: string) => {\n  const mod = new SyntheticModule(\n    exportNames,\n    () => {\n      for (const name of exportNames) {\n        if (name === 'default') {\n          mod.setExport(name, moduleExports);\n          continue;\n        }\n        mod.setExport(name, (moduleExports as Record<string, unknown>)[name]);\n      }\n    },\n    { identifier, context },\n  );\n  return mod;\n};\n\nconst isCjsModule = (target: string) => target.endsWith('.cjs') || target.endsWith('.cts');\n\nconst toRequireTarget = (target: string) => (target.startsWith('file:') ? fileURLToPath(target) : target);\n\nconst loadModule = async (target: string) => {\n  const cached = imports.get(target);\n  if (cached) return cached;\n\n  if (isCjsModule(target)) {\n    const required = requireFrom(toRequireTarget(target));\n    const exportNames = required && (typeof required === 'object' || typeof required === 'function') ? Object.keys(required) : [];\n    if (!exportNames.includes('default')) {\n      exportNames.push('default');\n    }\n    const mod = createSyntheticModule(required, exportNames, target);\n    imports.set(target, mod);\n    return mod;\n  }\n\n  const importedModule = await import(target);\n  const exportNames = Object.keys(importedModule);\n  const mod = createSyntheticModule(importedModule, exportNames, target);\n  imports.set(target, mod);\n  return mod;\n};\n\nconst loadDynamicModule = async (target: string) => {\n  const mod = await loadModule(target);\n  if (mod.status !== 'evaluated') {\n    await mod.evaluate();\n  }\n  return mod;\n};\nconst mod = new SourceTextModule(source, {\n  identifier: resolvedBenchmarkUrl,\n  context,\n  initializeImportMeta(meta) {\n    meta.url = resolvedBenchmarkUrl;\n  },\n  importModuleDynamically(specifier) {\n    const resolved = resolveSpecifier(specifier);\n    return loadDynamicModule(resolved);\n  },\n});\n\nawait mod.link(async (specifier) => loadModule(resolveSpecifier(specifier)));\n\nawait mod.evaluate();\nconst { setup, teardown, pre, run, post } = mod.namespace as any;\n\nif (!run) {\n  throw new Error('Benchmark run function is required');\n}\n\nprocess.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  gcObserver,\n\n  durationsSAB,\n  controlSAB,\n});\n"],"names":["benchmarkUrl","setupCode","teardownCode","preCode","runCode","postCode","data","warmupCycles","minCycles","absThreshold","relThreshold","gcObserver","durationsSAB","controlSAB","workerData","serialize","code","resolvedBenchmarkUrl","pathToFileURL","process","cwd","href","benchmarkDirUrl","URL","requireFrom","createRequire","fileURLToPath","resolveSpecifier","specifier","startsWith","isAbsolute","resolve","source","context","createContext","console","Buffer","imports","Map","createSyntheticModule","moduleExports","exportNames","identifier","mod","SyntheticModule","name","setExport","isCjsModule","target","endsWith","toRequireTarget","loadModule","cached","get","required","Object","keys","includes","push","set","importedModule","loadDynamicModule","status","evaluate","SourceTextModule","initializeImportMeta","meta","url","importModuleDynamically","resolved","link","setup","teardown","pre","run","post","namespace","Error","exitCode","benchmark"],"mappings":"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"}

package/build/worker.js

@@ -1,19 +1,25 @@
 import { workerData } from 'node:worker_threads';
 import { SourceTextModule, SyntheticModule, createContext } from 'node:vm';
 import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
+import { isAbsolute } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { benchmark } from "./runner.js";
-const { baseUrl, setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB } = workerData;
-const serialize = (code)=>code ? code : '() => {}';
-const isCjs = typeof require !== 'undefined';
-const resolveSpecifier = (specifier, parent)=>{
-    if (!isCjs) {
-        try {
-            return import.meta.resolve(specifier, parent);
-        } catch  {}
+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)=>{
+    if (specifier.startsWith('file:')) {
+        return specifier;
     }
-    const resolveFrom = createRequire(fileURLToPath(parent));
-    return resolveFrom.resolve(specifier);
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        return new URL(specifier, benchmarkDirUrl).href;
+    }
+    if (isAbsolute(specifier)) {
+        return pathToFileURL(specifier).href;
+    }
+    return requireFrom.resolve(specifier);
 };
 const source = `
 export const setup = ${serialize(setupCode)};
@@ -27,41 +33,67 @@ const context = createContext({
     Buffer
 });
 const imports = new Map();
+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,
+        context
+    });
+    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 cached = imports.get(target);
+    if (cached) return cached;
+    if (isCjsModule(target)) {
+        const required = requireFrom(toRequireTarget(target));
+        const exportNames = required && (typeof required === 'object' || typeof required === 'function') ? Object.keys(required) : [];
+        if (!exportNames.includes('default')) {
+            exportNames.push('default');
+        }
+        const mod = createSyntheticModule(required, exportNames, target);
+        imports.set(target, mod);
+        return mod;
+    }
+    const importedModule = await import(target);
+    const exportNames = Object.keys(importedModule);
+    const mod = createSyntheticModule(importedModule, exportNames, target);
+    imports.set(target, mod);
+    return mod;
+};
+const loadDynamicModule = async (target)=>{
+    const mod = await loadModule(target);
+    if (mod.status !== 'evaluated') {
+        await mod.evaluate();
+    }
+    return mod;
+};
 const mod = new SourceTextModule(source, {
-    identifier: baseUrl,
+    identifier: resolvedBenchmarkUrl,
     context,
     initializeImportMeta (meta) {
-        meta.url = baseUrl;
+        meta.url = resolvedBenchmarkUrl;
     },
-    importModuleDynamically (specifier, referencingModule) {
-        const base = referencingModule.identifier ?? baseUrl;
-        const resolved = resolveSpecifier(specifier, base);
-        return import(resolved);
+    importModuleDynamically (specifier) {
+        const resolved = resolveSpecifier(specifier);
+        return loadDynamicModule(resolved);
     }
 });
-await mod.link(async (specifier, referencingModule)=>{
-    const base = referencingModule.identifier ?? baseUrl;
-    const target = resolveSpecifier(specifier, base);
-    const cached = imports.get(target);
-    if (cached) return cached;
-    const importedModule = await import(target);
-    const exportNames = Object.keys(importedModule);
-    const imported = new SyntheticModule(exportNames, ()=>{
-        exportNames.forEach((key)=>imported.setExport(key, importedModule[key]));
-    }, {
-        identifier: target,
-        context: referencingModule.context
-    });
-    imports.set(target, imported);
-    return imported;
-});
+await mod.link(async (specifier)=>loadModule(resolveSpecifier(specifier)));
 await mod.evaluate();
 const { setup, teardown, pre, run, post } = mod.namespace;
 if (!run) {
     throw new Error('Benchmark run function is required');
 }
 process.exitCode = await benchmark({
-    baseUrl,
     setup,
     teardown,
     pre,

package/build/worker.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["import { workerData } from 'node:worker_threads';\nimport { SourceTextModule, SyntheticModule, createContext } from 'node:vm';\nimport { createRequire } from 'node:module';\nimport { fileURLToPath } from 'node:url';\nimport { benchmark } from './runner.js';\nimport { WorkerOptions } from './types.js';\n\nconst {\n  baseUrl,\n  setupCode,\n  teardownCode,\n  preCode,\n  runCode,\n  postCode,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n  gcObserver = true,\n\n  durationsSAB,\n  controlSAB,\n}: WorkerOptions = workerData;\n\nconst serialize = (code?: string) => (code ? code : '() => {}');\n\nconst isCjs = typeof require !== 'undefined';\n\nconst resolveSpecifier = (specifier: string, parent: string) => {\n  if (!isCjs) {\n    try {\n      return import.meta.resolve(specifier, parent);\n    } catch {\n      // fall through to CommonJS resolution\n    }\n  }\n  const resolveFrom = createRequire(fileURLToPath(parent));\n  return resolveFrom.resolve(specifier);\n};\n\nconst source = `\nexport const setup = ${serialize(setupCode)};\nexport const teardown = ${serialize(teardownCode)};\nexport const pre = ${serialize(preCode)};\nexport const run = ${serialize(runCode)};\nexport const post = ${serialize(postCode)};\n  `;\n\nconst context = createContext({ console, Buffer });\nconst imports = new Map<string, SyntheticModule>();\nconst mod = new SourceTextModule(source, {\n  identifier: baseUrl,\n  context,\n  initializeImportMeta(meta) {\n    meta.url = baseUrl;\n  },\n  importModuleDynamically(specifier, referencingModule) {\n    const base = referencingModule.identifier ?? baseUrl;\n    const resolved = resolveSpecifier(specifier, base);\n    return import(resolved);\n  },\n});\n\nawait mod.link(async (specifier, referencingModule) => {\n  const base = referencingModule.identifier ?? baseUrl;\n  const target = resolveSpecifier(specifier, base);\n  const cached = imports.get(target);\n  if (cached) return cached;\n\n  const importedModule = await import(target);\n  const exportNames = Object.keys(importedModule);\n  const imported = new SyntheticModule(\n    exportNames,\n    () => {\n      exportNames.forEach((key) => imported.setExport(key, importedModule[key]));\n    },\n    { identifier: target, context: referencingModule.context },\n  );\n  imports.set(target, imported);\n  return imported;\n});\n\nawait mod.evaluate();\nconst { setup, teardown, pre, run, post } = mod.namespace as any;\n\nif (!run) {\n  throw new Error('Benchmark run function is required');\n}\n\nprocess.exitCode = await benchmark({\n  baseUrl,\n  setup,\n  teardown,\n  pre,\n  run,\n  post,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n  gcObserver,\n\n  durationsSAB,\n  controlSAB,\n});\n"],"names":["workerData","SourceTextModule","SyntheticModule","createContext","createRequire","fileURLToPath","benchmark","baseUrl","setupCode","teardownCode","preCode","runCode","postCode","data","warmupCycles","minCycles","absThreshold","relThreshold","gcObserver","durationsSAB","controlSAB","serialize","code","isCjs","require","resolveSpecifier","specifier","parent","resolve","resolveFrom","source","context","console","Buffer","imports","Map","mod","identifier","initializeImportMeta","meta","url","importModuleDynamically","referencingModule","base","resolved","link","target","cached","get","importedModule","exportNames","Object","keys","imported","forEach","key","setExport","set","evaluate","setup","teardown","pre","run","post","namespace","Error","process","exitCode"],"mappings":"AAAA,SAASA,UAAU,QAAQ,sBAAsB;AACjD,SAASC,gBAAgB,EAAEC,eAAe,EAAEC,aAAa,QAAQ,UAAU;AAC3E,SAASC,aAAa,QAAQ,cAAc;AAC5C,SAASC,aAAa,QAAQ,WAAW;AACzC,SAASC,SAAS,QAAQ,cAAc;AAGxC,MAAM,EACJC,OAAO,EACPC,SAAS,EACTC,YAAY,EACZC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRC,IAAI,EAEJC,YAAY,EACZC,SAAS,EACTC,YAAY,EACZC,YAAY,EACZC,aAAa,IAAI,EAEjBC,YAAY,EACZC,UAAU,EACX,GAAkBpB;AAEnB,MAAMqB,YAAY,CAACC,OAAmBA,OAAOA,OAAO;AAEpD,MAAMC,QAAQ,OAAOC,YAAY;AAEjC,MAAMC,mBAAmB,CAACC,WAAmBC;IAC3C,IAAI,CAACJ,OAAO;QACV,IAAI;YACF,OAAO,YAAYK,OAAO,CAACF,WAAWC;QACxC,EAAE,OAAM,CAER;IACF;IACA,MAAME,cAAczB,cAAcC,cAAcsB;IAChD,OAAOE,YAAYD,OAAO,CAACF;AAC7B;AAEA,MAAMI,SAAS,CAAC;qBACK,EAAET,UAAUb,WAAW;wBACpB,EAAEa,UAAUZ,cAAc;mBAC/B,EAAEY,UAAUX,SAAS;mBACrB,EAAEW,UAAUV,SAAS;oBACpB,EAAEU,UAAUT,UAAU;EACxC,CAAC;AAEH,MAAMmB,UAAU5B,cAAc;IAAE6B;IAASC;AAAO;AAChD,MAAMC,UAAU,IAAIC;AACpB,MAAMC,MAAM,IAAInC,iBAAiB6B,QAAQ;IACvCO,YAAY9B;IACZwB;IACAO,sBAAqBC,IAAI;QACvBA,KAAKC,GAAG,GAAGjC;IACb;IACAkC,yBAAwBf,SAAS,EAAEgB,iBAAiB;QAClD,MAAMC,OAAOD,kBAAkBL,UAAU,IAAI9B;QAC7C,MAAMqC,WAAWnB,iBAAiBC,WAAWiB;QAC7C,OAAO,MAAM,CAACC;IAChB;AACF;AAEA,MAAMR,IAAIS,IAAI,CAAC,OAAOnB,WAAWgB;IAC/B,MAAMC,OAAOD,kBAAkBL,UAAU,IAAI9B;IAC7C,MAAMuC,SAASrB,iBAAiBC,WAAWiB;IAC3C,MAAMI,SAASb,QAAQc,GAAG,CAACF;IAC3B,IAAIC,QAAQ,OAAOA;IAEnB,MAAME,iBAAiB,MAAM,MAAM,CAACH;IACpC,MAAMI,cAAcC,OAAOC,IAAI,CAACH;IAChC,MAAMI,WAAW,IAAInD,gBACnBgD,aACA;QACEA,YAAYI,OAAO,CAAC,CAACC,MAAQF,SAASG,SAAS,CAACD,KAAKN,cAAc,CAACM,IAAI;IAC1E,GACA;QAAElB,YAAYS;QAAQf,SAASW,kBAAkBX,OAAO;IAAC;IAE3DG,QAAQuB,GAAG,CAACX,QAAQO;IACpB,OAAOA;AACT;AAEA,MAAMjB,IAAIsB,QAAQ;AAClB,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,GAAG,EAAEC,GAAG,EAAEC,IAAI,EAAE,GAAG3B,IAAI4B,SAAS;AAEzD,IAAI,CAACF,KAAK;IACR,MAAM,IAAIG,MAAM;AAClB;AAEAC,QAAQC,QAAQ,GAAG,MAAM7D,UAAU;IACjCC;IACAoD;IACAC;IACAC;IACAC;IACAC;IACAlD;IAEAC;IACAC;IACAC;IACAC;IACAC;IAEAC;IACAC;AACF"}
+{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["import { workerData } from 'node:worker_threads';\nimport { SourceTextModule, SyntheticModule, createContext } from 'node:vm';\nimport { createRequire } from 'node:module';\nimport { isAbsolute } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport { benchmark } from './runner.js';\nimport { WorkerOptions } from './types.js';\n\nconst {\n  benchmarkUrl,\n  setupCode,\n  teardownCode,\n  preCode,\n  runCode,\n  postCode,\n  data,\n\n  warmupCycles,\n  minCycles,\n  absThreshold,\n  relThreshold,\n  gcObserver = true,\n\n  durationsSAB,\n  controlSAB,\n}: WorkerOptions = workerData;\n\nconst serialize = (code?: string) => (code ? code : 'undefined');\n\nconst resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;\nconst benchmarkDirUrl = new URL('.', resolvedBenchmarkUrl).href;\nconst requireFrom = createRequire(fileURLToPath(new URL('benchmark.js', benchmarkDirUrl)));\n\nconst resolveSpecifier = (specifier: string) => {\n  if (specifier.startsWith('file:')) {\n    return specifier;\n  }\n  if (specifier.startsWith('./') || specifier.startsWith('../')) {\n    return new URL(specifier, benchmarkDirUrl).href;\n  }\n  if (isAbsolute(specifier)) {\n    return pathToFileURL(specifier).href;\n  }\n  return requireFrom.resolve(specifier);\n};\n\nconst source = `\nexport const setup = ${serialize(setupCode)};\nexport const teardown = ${serialize(teardownCode)};\nexport const pre = ${serialize(preCode)};\nexport const run = ${serialize(runCode)};\nexport const post = ${serialize(postCode)};\n  `;\n\nconst context = createContext({ console, Buffer });\nconst imports = new Map<string, SyntheticModule>();\n\nconst createSyntheticModule = (moduleExports: unknown, exportNames: string[], identifier: string) => {\n  const mod = new SyntheticModule(\n    exportNames,\n    () => {\n      for (const name of exportNames) {\n        if (name === 'default') {\n          mod.setExport(name, moduleExports);\n          continue;\n        }\n        mod.setExport(name, (moduleExports as Record<string, unknown>)[name]);\n      }\n    },\n    { identifier, context },\n  );\n  return mod;\n};\n\nconst isCjsModule = (target: string) => target.endsWith('.cjs') || target.endsWith('.cts');\n\nconst toRequireTarget = (target: string) => (target.startsWith('file:') ? fileURLToPath(target) : target);\n\nconst loadModule = async (target: string) => {\n  const cached = imports.get(target);\n  if (cached) return cached;\n\n  if (isCjsModule(target)) {\n    const required = requireFrom(toRequireTarget(target));\n    const exportNames = required && (typeof required === 'object' || typeof required === 'function') ? Object.keys(required) : [];\n    if (!exportNames.includes('default')) {\n      exportNames.push('default');\n    }\n    const mod = createSyntheticModule(required, exportNames, target);\n    imports.set(target, mod);\n    return mod;\n  }\n\n  const importedModule = await import(target);\n  const exportNames = Object.keys(importedModule);\n  const mod = createSyntheticModule(importedModule, exportNames, target);\n  imports.set(target, mod);\n  return mod;\n};\n\nconst loadDynamicModule = async (target: string) => {\n  const mod = await loadModule(target);\n  if (mod.status !== 'evaluated') {\n    await mod.evaluate();\n  }\n  return mod;\n};\nconst mod = new SourceTextModule(source, {\n  identifier: resolvedBenchmarkUrl,\n  context,\n  initializeImportMeta(meta) {\n    meta.url = resolvedBenchmarkUrl;\n  },\n  importModuleDynamically(specifier) {\n    const resolved = resolveSpecifier(specifier);\n    return loadDynamicModule(resolved);\n  },\n});\n\nawait mod.link(async (specifier) => loadModule(resolveSpecifier(specifier)));\n\nawait mod.evaluate();\nconst { setup, teardown, pre, run, post } = mod.namespace as any;\n\nif (!run) {\n  throw new Error('Benchmark run function is required');\n}\n\nprocess.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  gcObserver,\n\n  durationsSAB,\n  controlSAB,\n});\n"],"names":["workerData","SourceTextModule","SyntheticModule","createContext","createRequire","isAbsolute","fileURLToPath","pathToFileURL","benchmark","benchmarkUrl","setupCode","teardownCode","preCode","runCode","postCode","data","warmupCycles","minCycles","absThreshold","relThreshold","gcObserver","durationsSAB","controlSAB","serialize","code","resolvedBenchmarkUrl","process","cwd","href","benchmarkDirUrl","URL","requireFrom","resolveSpecifier","specifier","startsWith","resolve","source","context","console","Buffer","imports","Map","createSyntheticModule","moduleExports","exportNames","identifier","mod","name","setExport","isCjsModule","target","endsWith","toRequireTarget","loadModule","cached","get","required","Object","keys","includes","push","set","importedModule","loadDynamicModule","status","evaluate","initializeImportMeta","meta","url","importModuleDynamically","resolved","link","setup","teardown","pre","run","post","namespace","Error","exitCode"],"mappings":"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"}

package/examples/accuracy.ts

@@ -6,10 +6,11 @@ const baseline = benchmark('accuracy tuning feed', () => {
   for (let i = 0; i < uints.length; i++) {
     uints[i] = (i * 31) ^ 0x9e3779b1;
   }
+  const tiny = Buffer.alloc(4_096, 3);
   const src = Buffer.alloc(bytes, 7);
   const dst = Buffer.allocUnsafe(bytes);
 
-  return { uints, src, dst };
+  return { uints, tiny, src, dst };
 });
 
 baseline
@@ -17,10 +18,10 @@ baseline
     return { scratch: 0 };
   })
   .measure('sum uint32 array', (ctx, { uints }) => {
-    let acc = ctx.scratch;
+    let acc = ctx.scratch | 0;
     for (let round = 0; round < 8; round++) {
       for (let i = 0; i < uints.length; i++) {
-        acc += uints[i];
+        acc = (acc + uints[i]) | 0;
       }
     }
     ctx.scratch = acc;
@@ -45,10 +46,34 @@ baseline
     dst.fill(0);
   });
 
-baseline.target('steady loop baseline').measure('counter increment', () => {
+baseline.target('steady loop baseline').measure('counter increment', (_, { uints }) => {
   let x = 0;
   for (let i = 0; i < 200_000; i++) {
-    x += (i & 1023) >>> 0;
+    x = (x + uints[i & (uints.length - 1)]) | 0;
+  }
+  return x;
+});
+
+const gcImpact = baseline.target('gc impact', () => {
+  const pool: Buffer[] = Array.from({ length: 512 }, () => Buffer.alloc(4_096));
+  return { pool };
+});
+
+gcImpact.measure('alloc churn', (_, { tiny }) => {
+  let x = 0;
+  for (let i = 0; i < 512; i++) {
+    const buf = Buffer.from(tiny);
+    x ^= buf[0];
+  }
+  return x;
+});
+
+gcImpact.measure('pool reuse', (ctx, { tiny }) => {
+  let x = 0;
+  const { pool } = ctx;
+  for (let i = 0; i < pool.length; i++) {
+    pool[i].set(tiny);
+    x ^= pool[i][0];
   }
   return x;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",
@@ -47,15 +47,15 @@
     "@types/jest": "^30.0.0",
     "@types/node": "^25.0.3",
     "husky": "^9.1.7",
-    "inop": "^0.8.3",
+    "inop": "^0.8.10",
     "jest": "^30.2.0",
-    "overtake": "^1.1.0",
+    "overtake": "^1.1.1",
     "prettier": "^3.7.4",
     "pretty-quick": "^4.2.2",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@swc/core": "^1.15.7",
+    "@swc/core": "^1.15.8",
     "async": "^3.2.6",
     "commander": "^14.0.2",
     "glob": "^13.0.0"

package/src/cli.ts

@@ -10,6 +10,7 @@ import { REPORT_TYPES } from './types.js';
 
 const require = createRequire(import.meta.url);
 const { name, description, version } = require('../package.json');
+const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
 
 const commander = new Command();
 
@@ -97,8 +98,8 @@ commander
         if (instance) {
           const reports = await instance.execute({
             ...executeOptions,
-            baseUrl: identifier,
-          });
+            [BENCHMARK_URL]: identifier,
+          } as typeof executeOptions);
           switch (executeOptions.format) {
             case 'json':
               {

package/src/executor.ts

@@ -9,23 +9,18 @@ import { RunOptions, ReportOptions, WorkerOptions, BenchmarkOptions, Control, Re
 export type ExecutorReport<R extends ReportTypeList> = Record<R[number], Report> & { count: number };
 
 export interface ExecutorOptions<R extends ReportTypeList> extends BenchmarkOptions, ReportOptions<R> {
-  baseUrl?: string;
   workers?: number;
   maxCycles?: number;
 }
 
-export const createExecutor = <TContext, TInput, R extends ReportTypeList>({
-  baseUrl = pathToFileURL(process.cwd()).href,
-  workers,
-  warmupCycles,
-  maxCycles,
-  minCycles,
-  absThreshold,
-  relThreshold,
-  gcObserver = true,
-  reportTypes,
-}: Required<ExecutorOptions<R>>) => {
-  const executor = queue<RunOptions<TContext, TInput>>(async ({ baseUrl: runBaseUrl = baseUrl, setup, teardown, pre, run, post, data }) => {
+const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
+
+export const createExecutor = <TContext, TInput, R extends ReportTypeList>(options: Required<ExecutorOptions<R>>) => {
+  const { workers, warmupCycles, maxCycles, minCycles, absThreshold, relThreshold, gcObserver = true, reportTypes } = options;
+  const benchmarkUrl = (options as Record<symbol, unknown>)[BENCHMARK_URL];
+  const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
+
+  const executor = queue<RunOptions<TContext, TInput>>(async ({ setup, teardown, pre, run, post, data }) => {
     const setupCode = setup?.toString();
     const teardownCode = teardown?.toString();
     const preCode = pre?.toString();
@@ -37,7 +32,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>({
 
     const workerFile = new URL('./worker.js', import.meta.url);
     const workerData: WorkerOptions = {
-      baseUrl: runBaseUrl,
+      benchmarkUrl: resolvedBenchmarkUrl,
       setupCode,
       teardownCode,
       preCode,

package/src/gc-watcher.ts

@@ -1,22 +1,21 @@
 export interface GCMarker {
   ref: WeakRef<object>;
-  token: object;
 }
 
 export class GCWatcher {
   #registry = new FinalizationRegistry(() => {});
 
   start(): GCMarker {
-    const token = {};
-    const ref = new WeakRef(token);
-    this.#registry.register(token, null, token);
-    return { ref, token };
+    const target = {};
+    const ref = new WeakRef(target);
+    this.#registry.register(target, null, ref);
+    return { ref };
   }
 
   seen(marker: GCMarker): boolean {
     const collected = marker.ref.deref() === undefined;
     if (!collected) {
-      this.#registry.unregister(marker.token);
+      this.#registry.unregister(marker.ref);
     }
     return collected;
   }

package/src/index.ts

@@ -1,5 +1,4 @@
 import { cpus } from 'node:os';
-import { pathToFileURL } from 'node:url';
 import { createExecutor, ExecutorOptions, ExecutorReport } from './executor.js';
 import { MaybePromise, StepFn, SetupFn, TeardownFn, FeedFn, ReportType, ReportTypeList, DEFAULT_CYCLES } from './types.js';
 
@@ -10,6 +9,7 @@ declare global {
 export const DEFAULT_WORKERS = cpus().length;
 
 export const AsyncFunction = (async () => {}).constructor;
+const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
 
 export interface TargetReport<R extends ReportTypeList> {
   target: string;
@@ -135,29 +135,24 @@ export class Benchmark<TInput> {
     return new Target<TContext, TInput>(target);
   }
 
-  async execute<R extends readonly ReportType[] = typeof DEFAULT_REPORT_TYPES>({
-    workers = DEFAULT_WORKERS,
-    warmupCycles = 20,
-    maxCycles = DEFAULT_CYCLES,
-    minCycles = 50,
-    absThreshold = 1_000,
-    relThreshold = 0.02,
-    gcObserver = true,
-    reportTypes = DEFAULT_REPORT_TYPES as unknown as R,
-    baseUrl,
-  }: ExecutorOptions<R>): Promise<TargetReport<R>[]> {
+  async execute<R extends readonly ReportType[] = typeof DEFAULT_REPORT_TYPES>(options: ExecutorOptions<R>): Promise<TargetReport<R>[]> {
+    const {
+      workers = DEFAULT_WORKERS,
+      warmupCycles = 20,
+      maxCycles = DEFAULT_CYCLES,
+      minCycles = 50,
+      absThreshold = 1_000,
+      relThreshold = 0.02,
+      gcObserver = true,
+      reportTypes = DEFAULT_REPORT_TYPES as unknown as R,
+    } = options;
     if (this.#executed) {
       throw new Error("Benchmark is executed and can't be reused");
     }
     this.#executed = true;
-
-    const resolvedBaseUrl = baseUrl ?? pathToFileURL(process.cwd()).href;
-    if (!baseUrl) {
-      console.warn("Overtake: baseUrl not provided; defaulting to process.cwd(). Pass the benchmark's import.meta.url so relative imports resolve correctly.");
-    }
+    const benchmarkUrl = (options as unknown as Record<symbol, unknown>)[BENCHMARK_URL];
 
     const executor = createExecutor<unknown, TInput, R>({
-      baseUrl: resolvedBaseUrl,
       workers,
       warmupCycles,
       maxCycles,
@@ -166,7 +161,8 @@ export class Benchmark<TInput> {
       relThreshold,
       gcObserver,
       reportTypes,
-    });
+      [BENCHMARK_URL]: benchmarkUrl,
+    } as Required<ExecutorOptions<R>>);
 
     const reports: TargetReport<R>[] = [];
     for (const target of this.#targets) {
@@ -177,7 +173,6 @@ export class Benchmark<TInput> {
           const data = await feed.fn?.();
           executor
             .push<ExecutorReport<R>>({
-              baseUrl: resolvedBaseUrl,
               setup: target.setup,
               teardown: target.teardown,
               pre: measure.pre,