overtake 1.0.5 → 1.1.0

package/build/worker.cjs

@@ -2,21 +2,102 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "exitCode", {
-    enumerable: true,
-    get: function() {
-        return exitCode;
-    }
-});
 const _nodeworker_threads = require("node:worker_threads");
+const _nodevm = require("node:vm");
+const _nodemodule = require("node:module");
+const _nodeurl = require("node:url");
 const _runnercjs = require("./runner.cjs");
-const { setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, durationsSAB, controlSAB } = _nodeworker_threads.workerData;
-const setup = setupCode && Function(`return ${setupCode};`)();
-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 (0, _runnercjs.benchmark)({
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    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 source = `
+export const setup = ${serialize(setupCode)};
+export const teardown = ${serialize(teardownCode)};
+export const pre = ${serialize(preCode)};
+export const run = ${serialize(runCode)};
+export const post = ${serialize(postCode)};
+  `;
+const context = (0, _nodevm.createContext)({
+    console,
+    Buffer
+});
+const imports = new Map();
+const mod = new _nodevm.SourceTextModule(source, {
+    identifier: baseUrl,
+    context,
+    initializeImportMeta (meta) {
+        meta.url = baseUrl;
+    },
+    importModuleDynamically (specifier, referencingModule) {
+        const base = referencingModule.identifier ?? baseUrl;
+        const resolveFrom = (0, _nodemodule.createRequire)((0, _nodeurl.fileURLToPath)(base));
+        return Promise.resolve(resolveFrom.resolve(specifier)).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
+    }
+});
+await mod.link(async (specifier, referencingModule)=>{
+    const base = referencingModule.identifier ?? baseUrl;
+    const resolveFrom = (0, _nodemodule.createRequire)((0, _nodeurl.fileURLToPath)(base));
+    const target = resolveFrom.resolve(specifier);
+    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.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,
@@ -27,9 +108,9 @@ const exitCode = await (0, _runnercjs.benchmark)({
     minCycles,
     absThreshold,
     relThreshold,
+    gcObserver,
     durationsSAB,
     controlSAB
 });
-process.exit(exitCode);
 
 //# sourceMappingURL=worker.cjs.map

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\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"}
+{"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 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 resolveFrom = createRequire(fileURLToPath(base));\n    return import(resolveFrom.resolve(specifier));\n  },\n});\n\nawait mod.link(async (specifier, referencingModule) => {\n  const base = referencingModule.identifier ?? baseUrl;\n  const resolveFrom = createRequire(fileURLToPath(base));\n  const target = resolveFrom.resolve(specifier);\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","source","context","createContext","console","Buffer","imports","Map","mod","SourceTextModule","identifier","initializeImportMeta","meta","url","importModuleDynamically","specifier","referencingModule","base","resolveFrom","createRequire","fileURLToPath","resolve","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,SAAS,CAAC;qBACK,EAAEF,UAAUd,WAAW;wBACpB,EAAEc,UAAUb,cAAc;mBAC/B,EAAEa,UAAUZ,SAAS;mBACrB,EAAEY,UAAUX,SAAS;oBACpB,EAAEW,UAAUV,UAAU;EACxC,CAAC;AAEH,MAAMa,UAAUC,IAAAA,qBAAa,EAAC;IAAEC;IAASC;AAAO;AAChD,MAAMC,UAAU,IAAIC;AACpB,MAAMC,MAAM,IAAIC,wBAAgB,CAACR,QAAQ;IACvCS,YAAY1B;IACZkB;IACAS,sBAAqBC,IAAI;QACvBA,KAAKC,GAAG,GAAG7B;IACb;IACA8B,yBAAwBC,SAAS,EAAEC,iBAAiB;QAClD,MAAMC,OAAOD,kBAAkBN,UAAU,IAAI1B;QAC7C,MAAMkC,cAAcC,IAAAA,yBAAa,EAACC,IAAAA,sBAAa,EAACH;QAChD,OAAO,gBAAOC,YAAYG,OAAO,CAACN,8DAA3B;IACT;AACF;AAEA,MAAMP,IAAIc,IAAI,CAAC,OAAOP,WAAWC;IAC/B,MAAMC,OAAOD,kBAAkBN,UAAU,IAAI1B;IAC7C,MAAMkC,cAAcC,IAAAA,yBAAa,EAACC,IAAAA,sBAAa,EAACH;IAChD,MAAMM,SAASL,YAAYG,OAAO,CAACN;IACnC,MAAMS,SAASlB,QAAQmB,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;QAAEvB,YAAYa;QAAQrB,SAASc,kBAAkBd,OAAO;IAAC;IAE3DI,QAAQ6B,GAAG,CAACZ,QAAQO;IACpB,OAAOA;AACT;AAEA,MAAMtB,IAAI4B,QAAQ;AAClB,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,GAAG,EAAEC,GAAG,EAAEC,IAAI,EAAE,GAAGjC,IAAIkC,SAAS;AAEzD,IAAI,CAACF,KAAK;IACR,MAAM,IAAIG,MAAM;AAClB;AAEAC,QAAQC,QAAQ,GAAG,MAAMC,IAAAA,oBAAS,EAAC;IACjC9D;IACAqD;IACAC;IACAC;IACAC;IACAC;IACAnD;IAEAC;IACAC;IACAC;IACAC;IACAC;IAEAC;IACAC;AACF"}

package/build/worker.d.ts

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

package/build/worker.js

@@ -1,12 +1,58 @@
 import { workerData } from 'node:worker_threads';
+import { SourceTextModule, SyntheticModule, createContext } from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 import { benchmark } from "./runner.js";
-const { setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, durationsSAB, controlSAB } = workerData;
-const setup = setupCode && Function(`return ${setupCode};`)();
-const teardown = teardownCode && Function(`return ${teardownCode};`)();
-const pre = preCode && Function(`return ${preCode};`)();
-const run = runCode && Function(`return ${runCode};`)();
-const post = postCode && Function(`return ${postCode};`)();
-export const exitCode = await benchmark({
+const { baseUrl, setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB } = workerData;
+const serialize = (code)=>code ? code : '() => {}';
+const source = `
+export const setup = ${serialize(setupCode)};
+export const teardown = ${serialize(teardownCode)};
+export const pre = ${serialize(preCode)};
+export const run = ${serialize(runCode)};
+export const post = ${serialize(postCode)};
+  `;
+const context = createContext({
+    console,
+    Buffer
+});
+const imports = new Map();
+const mod = new SourceTextModule(source, {
+    identifier: baseUrl,
+    context,
+    initializeImportMeta (meta) {
+        meta.url = baseUrl;
+    },
+    importModuleDynamically (specifier, referencingModule) {
+        const base = referencingModule.identifier ?? baseUrl;
+        const resolveFrom = createRequire(fileURLToPath(base));
+        return import(resolveFrom.resolve(specifier));
+    }
+});
+await mod.link(async (specifier, referencingModule)=>{
+    const base = referencingModule.identifier ?? baseUrl;
+    const resolveFrom = createRequire(fileURLToPath(base));
+    const target = resolveFrom.resolve(specifier);
+    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.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,
@@ -17,9 +63,9 @@ export const exitCode = await benchmark({
     minCycles,
     absThreshold,
     relThreshold,
+    gcObserver,
     durationsSAB,
     controlSAB
 });
-process.exit(exitCode);
 
 //# sourceMappingURL=worker.js.map

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\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"}
+{"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 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 resolveFrom = createRequire(fileURLToPath(base));\n    return import(resolveFrom.resolve(specifier));\n  },\n});\n\nawait mod.link(async (specifier, referencingModule) => {\n  const base = referencingModule.identifier ?? baseUrl;\n  const resolveFrom = createRequire(fileURLToPath(base));\n  const target = resolveFrom.resolve(specifier);\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","source","context","console","Buffer","imports","Map","mod","identifier","initializeImportMeta","meta","url","importModuleDynamically","specifier","referencingModule","base","resolveFrom","resolve","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,SAAS,CAAC;qBACK,EAAEF,UAAUb,WAAW;wBACpB,EAAEa,UAAUZ,cAAc;mBAC/B,EAAEY,UAAUX,SAAS;mBACrB,EAAEW,UAAUV,SAAS;oBACpB,EAAEU,UAAUT,UAAU;EACxC,CAAC;AAEH,MAAMY,UAAUrB,cAAc;IAAEsB;IAASC;AAAO;AAChD,MAAMC,UAAU,IAAIC;AACpB,MAAMC,MAAM,IAAI5B,iBAAiBsB,QAAQ;IACvCO,YAAYvB;IACZiB;IACAO,sBAAqBC,IAAI;QACvBA,KAAKC,GAAG,GAAG1B;IACb;IACA2B,yBAAwBC,SAAS,EAAEC,iBAAiB;QAClD,MAAMC,OAAOD,kBAAkBN,UAAU,IAAIvB;QAC7C,MAAM+B,cAAclC,cAAcC,cAAcgC;QAChD,OAAO,MAAM,CAACC,YAAYC,OAAO,CAACJ;IACpC;AACF;AAEA,MAAMN,IAAIW,IAAI,CAAC,OAAOL,WAAWC;IAC/B,MAAMC,OAAOD,kBAAkBN,UAAU,IAAIvB;IAC7C,MAAM+B,cAAclC,cAAcC,cAAcgC;IAChD,MAAMI,SAASH,YAAYC,OAAO,CAACJ;IACnC,MAAMO,SAASf,QAAQgB,GAAG,CAACF;IAC3B,IAAIC,QAAQ,OAAOA;IAEnB,MAAME,iBAAiB,MAAM,MAAM,CAACH;IACpC,MAAMI,cAAcC,OAAOC,IAAI,CAACH;IAChC,MAAMI,WAAW,IAAI9C,gBACnB2C,aACA;QACEA,YAAYI,OAAO,CAAC,CAACC,MAAQF,SAASG,SAAS,CAACD,KAAKN,cAAc,CAACM,IAAI;IAC1E,GACA;QAAEpB,YAAYW;QAAQjB,SAASY,kBAAkBZ,OAAO;IAAC;IAE3DG,QAAQyB,GAAG,CAACX,QAAQO;IACpB,OAAOA;AACT;AAEA,MAAMnB,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,MAAMxD,UAAU;IACjCC;IACA+C;IACAC;IACAC;IACAC;IACAC;IACA7C;IAEAC;IACAC;IACAC;IACAC;IACAC;IAEAC;IACAC;AACF"}

package/examples/accuracy.ts

@@ -0,0 +1,54 @@
+import 'overtake';
+
+const baseline = benchmark('accuracy tuning feed', () => {
+  const bytes = 131_072;
+  const uints = new Uint32Array(bytes / 4);
+  for (let i = 0; i < uints.length; i++) {
+    uints[i] = (i * 31) ^ 0x9e3779b1;
+  }
+  const src = Buffer.alloc(bytes, 7);
+  const dst = Buffer.allocUnsafe(bytes);
+
+  return { uints, src, dst };
+});
+
+baseline
+  .target('deterministic math', () => {
+    return { scratch: 0 };
+  })
+  .measure('sum uint32 array', (ctx, { uints }) => {
+    let acc = ctx.scratch;
+    for (let round = 0; round < 8; round++) {
+      for (let i = 0; i < uints.length; i++) {
+        acc += uints[i];
+      }
+    }
+    ctx.scratch = acc;
+  });
+
+baseline.target('buffer reuse copy').measure('copy preallocated buffer', (_, { src, dst }) => {
+  for (let round = 0; round < 8; round++) {
+    dst.set(src);
+  }
+});
+
+baseline
+  .target('buffer reuse xor')
+  .measure('xor in place', (_, { src, dst }) => {
+    for (let round = 0; round < 4; round++) {
+      for (let i = 0; i < src.length; i++) {
+        dst[i] ^= src[i];
+      }
+    }
+  })
+  .pre((_, { dst }) => {
+    dst.fill(0);
+  });
+
+baseline.target('steady loop baseline').measure('counter increment', () => {
+  let x = 0;
+  for (let i = 0; i < 200_000; i++) {
+    x += (i & 1023) >>> 0;
+  }
+  return x;
+});

package/examples/custom-reports.ts

@@ -1,7 +1,6 @@
 // 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));

package/examples/imports.ts

@@ -1,5 +1,6 @@
 // Demonstrates correct import patterns for worker context
 // Run: npx overtake examples/imports.ts
+import 'overtake';
 
 const importExamples = benchmark('test data', () => Buffer.from('hello world'));
 
@@ -13,14 +14,9 @@ importExamples
     createHash('sha256').update(buffer).digest('hex');
   });
 
-// IMPORTANT: Local files need absolute paths
-// Relative imports resolve from node_modules/overtake/build/, not your project
+// Relative imports resolve relative to benchmark file
 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);
+  const { DEFAULT_CYCLES, Control } = await import('../build/types.js');
 
   return {
     DEFAULT_CYCLES,

package/examples/quick-start.ts

@@ -1,5 +1,7 @@
 // Minimal example - comparing array sum algorithms
 // Run: npx overtake examples/quick-start.ts
+// Import overtake to support global types
+import 'overtake';
 
 const sumBenchmark = benchmark('1M numbers', () => Array.from({ length: 1_000_000 }, (_, index) => index));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",
@@ -41,23 +41,24 @@
   },
   "homepage": "https://github.com/3axap4eHko/overtake#readme",
   "devDependencies": {
-    "@jest/globals": "^30.0.5",
+    "@jest/globals": "^30.2.0",
     "@swc/jest": "^0.2.39",
     "@types/async": "^3.2.25",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.10.1",
     "husky": "^9.1.7",
-    "inop": "^0.7.9",
-    "jest": "^30.0.5",
+    "inop": "^0.8.0",
+    "jest": "^30.2.0",
+    "overtake": "^1.0.5",
     "prettier": "^3.6.2",
     "pretty-quick": "^4.2.2",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@swc/core": "^1.13.5",
+    "@swc/core": "^1.15.2",
     "async": "^3.2.6",
-    "commander": "^14.0.0",
-    "glob": "^11.0.3"
+    "commander": "^14.0.2",
+    "glob": "^13.0.0"
   },
   "scripts": {
     "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",

package/src/cli.ts

@@ -1,10 +1,11 @@
 import { createRequire, Module } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { SyntheticModule, createContext, SourceTextModule } from 'node:vm';
 import { stat, readFile } from 'node:fs/promises';
-import { transform } from '@swc/core';
 import { Command, Option } from 'commander';
 import { glob } from 'glob';
 import { Benchmark, printTableReports, printJSONReports, printSimpleReports, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS } from './index.js';
+import { transpile } from './utils.js';
 import { REPORT_TYPES } from './types.js';
 
 const require = createRequire(import.meta.url);
@@ -12,29 +13,11 @@ const { name, description, version } = require('../package.json');
 
 const commander = new Command();
 
-const transpile = async (code: string): Promise<string> => {
-  const output = await transform(code, {
-    filename: 'benchmark.ts',
-    jsc: {
-      parser: {
-        syntax: 'typescript',
-        tsx: false,
-        dynamicImport: true,
-      },
-      target: 'esnext',
-    },
-    module: {
-      type: 'es6',
-    },
-  });
-  return output.code;
-};
-
 commander
   .name(name)
   .description(description)
   .version(version)
-  .argument('<path>', 'glob pattern to find benchmarks')
+  .argument('<paths...>', 'glob pattern to find benchmarks')
   .addOption(new Option('-r, --report-types [reportTypes...]', 'statistic types to include in the report').choices(REPORT_TYPES).default(DEFAULT_REPORT_TYPES))
   .addOption(new Option('-w, --workers [workers]', 'number of concurent workers').default(DEFAULT_WORKERS).argParser(parseInt))
   .addOption(new Option('-f, --format [format]', 'output format').default('simple').choices(['simple', 'json', 'pjson', 'table']))
@@ -43,12 +26,21 @@ commander
   .addOption(new Option('--warmup-cycles [warmupCycles]', 'number of warmup cycles before measuring').argParser(parseInt))
   .addOption(new Option('--max-cycles [maxCycles]', 'maximum measurement cycles per feed').argParser(parseInt))
   .addOption(new Option('--min-cycles [minCycles]', 'minimum measurement cycles per feed').argParser(parseInt))
-  .action(async (path, executeOptions) => {
-    const files = await glob(path, { absolute: true, cwd: process.cwd() }).catch(() => []);
+  .addOption(new Option('--no-gc-observer', 'disable GC overlap detection'))
+  .action(async (patterns: string[], executeOptions) => {
+    const files = new Set<string>();
+    await Promise.all(
+      patterns.map(async (pattern) => {
+        const matches = await glob(pattern, { absolute: true, cwd: process.cwd() }).catch(() => []);
+        matches.forEach((file) => files.add(file));
+      }),
+    );
+
     for (const file of files) {
       const stats = await stat(file).catch(() => false as const);
       if (stats && stats.isFile()) {
         const content = await readFile(file, 'utf8');
+        const identifier = pathToFileURL(file).href;
         const code = await transpile(content);
         let instance: Benchmark<unknown> | undefined;
         const benchmark = (...args: Parameters<(typeof Benchmark)['create']>) => {
@@ -59,33 +51,54 @@ commander
           return instance;
         };
         const script = new SourceTextModule(code, {
+          identifier,
           context: createContext({
             benchmark,
             Buffer,
+            console,
           }),
+          initializeImportMeta(meta) {
+            meta.url = identifier;
+          },
+          async importModuleDynamically(specifier, referencingModule) {
+            if (Module.isBuiltin(specifier)) {
+              return import(specifier);
+            }
+            const baseIdentifier = referencingModule.identifier ?? identifier;
+            const resolveFrom = createRequire(fileURLToPath(baseIdentifier));
+            const resolved = resolveFrom.resolve(specifier);
+            return import(resolved);
+          },
         });
-        const imports = new Map();
+        const imports = new Map<string, SyntheticModule>();
         await script.link(async (specifier: string, referencingModule) => {
-          if (imports.has(specifier)) {
-            return imports.get(specifier);
+          const baseIdentifier = referencingModule.identifier ?? identifier;
+          const resolveFrom = createRequire(fileURLToPath(baseIdentifier));
+          const target = Module.isBuiltin(specifier) ? specifier : resolveFrom.resolve(specifier);
+          const cached = imports.get(target);
+          if (cached) {
+            return cached;
           }
-          const mod = await import(Module.isBuiltin(specifier) ? specifier : require.resolve(specifier));
+          const mod = await import(target);
           const exportNames = Object.keys(mod);
           const imported = new SyntheticModule(
             exportNames,
             () => {
               exportNames.forEach((key) => imported.setExport(key, mod[key]));
             },
-            { identifier: specifier, context: referencingModule.context },
+            { identifier: target, context: referencingModule.context },
           );
 
-          imports.set(specifier, imported);
+          imports.set(target, imported);
           return imported;
         });
         await script.evaluate();
 
         if (instance) {
-          const reports = await instance.execute(executeOptions);
+          const reports = await instance.execute({
+            ...executeOptions,
+            baseUrl: identifier,
+          });
           switch (executeOptions.format) {
             case 'json':
               {

package/src/executor.ts

@@ -1,27 +1,31 @@
 import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
 import { queue } from 'async';
-import { RunOptions, ReportOptions, WorkerOptions, BenchmarkOptions, Control, ReportType, ReportTypeList, CONTROL_SLOTS } from './types.js';
+import { pathToFileURL } from 'node:url';
 import { createReport, Report } from './reporter.js';
 import { cmp } from './utils.js';
+import { RunOptions, ReportOptions, WorkerOptions, BenchmarkOptions, Control, ReportType, ReportTypeList, CONTROL_SLOTS } from './types.js';
 
 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 ({ setup, teardown, pre, run, post, data }) => {
+  const executor = queue<RunOptions<TContext, TInput>>(async ({ baseUrl: runBaseUrl = baseUrl, setup, teardown, pre, run, post, data }) => {
     const setupCode = setup?.toString();
     const teardownCode = teardown?.toString();
     const preCode = pre?.toString();
@@ -33,6 +37,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>({
 
     const workerFile = new URL('./worker.js', import.meta.url);
     const workerData: WorkerOptions = {
+      baseUrl: runBaseUrl,
       setupCode,
       teardownCode,
       preCode,
@@ -44,6 +49,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>({
       minCycles,
       absThreshold,
       relThreshold,
+      gcObserver,
 
       controlSAB,
       durationsSAB,

package/src/gc-watcher.ts

@@ -0,0 +1,23 @@
+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 };
+  }
+
+  seen(marker: GCMarker): boolean {
+    const collected = marker.ref.deref() === undefined;
+    if (!collected) {
+      this.#registry.unregister(marker.token);
+    }
+    return collected;
+  }
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 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';
 
@@ -141,20 +142,29 @@ export class Benchmark<TInput> {
     minCycles = 50,
     absThreshold = 1_000,
     relThreshold = 0.02,
+    gcObserver = true,
     reportTypes = DEFAULT_REPORT_TYPES as unknown as R,
+    baseUrl,
   }: ExecutorOptions<R>): Promise<TargetReport<R>[]> {
     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 executor = createExecutor<unknown, TInput, R>({
+      baseUrl: resolvedBaseUrl,
       workers,
       warmupCycles,
       maxCycles,
       minCycles,
       absThreshold,
       relThreshold,
+      gcObserver,
       reportTypes,
     });
 
@@ -167,6 +177,7 @@ export class Benchmark<TInput> {
           const data = await feed.fn?.();
           executor
             .push<ExecutorReport<R>>({
+              baseUrl: resolvedBaseUrl,
               setup: target.setup,
               teardown: target.teardown,
               pre: measure.pre,