overtake 1.1.0 → 1.1.2

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 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"}
+{"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 : '() => {}');\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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",
@@ -45,17 +45,17 @@
     "@swc/jest": "^0.2.39",
     "@types/async": "^3.2.25",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.10.1",
+    "@types/node": "^25.0.3",
     "husky": "^9.1.7",
-    "inop": "^0.8.0",
+    "inop": "^0.8.10",
     "jest": "^30.2.0",
-    "overtake": "^1.0.5",
-    "prettier": "^3.6.2",
+    "overtake": "^1.1.1",
+    "prettier": "^3.7.4",
     "pretty-quick": "^4.2.2",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@swc/core": "^1.15.2",
+    "@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();
 
@@ -21,8 +22,8 @@ commander
   .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']))
-  .addOption(new Option('--abs-threshold [absThreshold]', 'absolute error threshold in nanoseconds').argParser(parseInt))
-  .addOption(new Option('--rel-threshold [relThreshold]', 'relative error threshold (fraction between 0 and 1)').argParser(parseInt))
+  .addOption(new Option('--abs-threshold [absThreshold]', 'absolute error threshold in nanoseconds').argParser(parseFloat))
+  .addOption(new Option('--rel-threshold [relThreshold]', 'relative error threshold (fraction between 0 and 1)').argParser(parseFloat))
   .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))
@@ -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/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,

package/src/runner.ts

@@ -23,6 +23,10 @@ const runAsync = (run: Function) => {
   };
 };
 
+const isThenable = (value: unknown): value is PromiseLike<unknown> => {
+  return value !== null && (typeof value === 'object' || typeof value === 'function') && typeof (value as PromiseLike<unknown>).then === 'function';
+};
+
 const TARGET_SAMPLE_NS = 1_000_000n; // aim for ~1ms per measured sample
 const MAX_BATCH = 1_048_576;
 const PROGRESS_STRIDE = 16;
@@ -198,7 +202,7 @@ export const benchmark = async <TContext, TInput>({
 
   const context = (await setup?.()) as TContext;
   const maxCycles = durations.length;
-  const gcWatcher = new GCWatcher();
+  const gcWatcher = gcObserver ? new GCWatcher() : null;
   const gcTracker = gcObserver ? createGCTracker() : null;
 
   try {
@@ -206,7 +210,7 @@ export const benchmark = async <TContext, TInput>({
     await pre?.(context, data!);
     const probeStart = hr();
     const probeResult = runRaw(context, data!);
-    const isAsync = probeResult instanceof Promise;
+    const isAsync = isThenable(probeResult);
     if (isAsync) {
       await probeResult;
     }
@@ -282,7 +286,7 @@ export const benchmark = async <TContext, TInput>({
     while (true) {
       if (i >= maxCycles) break;
 
-      const gcMarker = gcWatcher.start();
+      const gcMarker = gcWatcher?.start();
       const sampleStart = performance.now();
       let sampleDuration = 0n;
       for (let b = 0; b < batchSize; b++) {
@@ -298,7 +302,7 @@ export const benchmark = async <TContext, TInput>({
       sampleDuration /= BigInt(batchSize);
 
       const sampleEnd = performance.now();
-      const gcNoise = gcWatcher.seen(gcMarker) || (gcTracker?.overlaps(sampleStart, sampleEnd) ?? false);
+      const gcNoise = (gcMarker ? gcWatcher!.seen(gcMarker) : false) || (gcTracker?.overlaps(sampleStart, sampleEnd) ?? false);
       if (gcNoise) {
         continue;
       }

package/src/types.ts

@@ -34,11 +34,9 @@ export interface BenchmarkOptions {
   absThreshold?: number; // ns
   relThreshold?: number; // %
   gcObserver?: boolean;
-  baseUrl?: string;
 }
 
 export interface RunOptions<TContext, TInput> {
-  baseUrl?: string;
   setup?: SetupFn<TContext>;
   teardown?: TeardownFn<TContext>;
   pre?: StepFn<TContext, TInput>;
@@ -48,7 +46,7 @@ export interface RunOptions<TContext, TInput> {
 }
 
 export interface WorkerOptions extends Required<BenchmarkOptions> {
-  baseUrl: string;
+  benchmarkUrl?: string;
   setupCode?: string;
   teardownCode?: string;
   preCode?: string;

package/src/worker.ts

@@ -1,12 +1,13 @@
 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';
 import { WorkerOptions } from './types.js';
 
 const {
-  baseUrl,
+  benchmarkUrl,
   setupCode,
   teardownCode,
   preCode,
@@ -26,6 +27,23 @@ const {
 
 const serialize = (code?: string) => (code ? code : '() => {}');
 
+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: string) => {
+  if (specifier.startsWith('file:')) {
+    return 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)};
 export const teardown = ${serialize(teardownCode)};
@@ -36,39 +54,71 @@ export const post = ${serialize(postCode)};
 
 const context = createContext({ console, Buffer });
 const imports = new Map<string, SyntheticModule>();
-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 createSyntheticModule = (moduleExports: unknown, exportNames: string[], identifier: string) => {
+  const mod = new SyntheticModule(
+    exportNames,
+    () => {
+      for (const name of exportNames) {
+        if (name === 'default') {
+          mod.setExport(name, moduleExports);
+          continue;
+        }
+        mod.setExport(name, (moduleExports as Record<string, unknown>)[name]);
+      }
+    },
+    { identifier, context },
+  );
+  return mod;
+};
+
+const isCjsModule = (target: string) => target.endsWith('.cjs') || target.endsWith('.cts');
+
+const toRequireTarget = (target: string) => (target.startsWith('file:') ? fileURLToPath(target) : target);
+
+const loadModule = async (target: string) => {
   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 imported = new SyntheticModule(
-    exportNames,
-    () => {
-      exportNames.forEach((key) => imported.setExport(key, importedModule[key]));
-    },
-    { identifier: target, context: referencingModule.context },
-  );
-  imports.set(target, imported);
-  return imported;
+  const mod = createSyntheticModule(importedModule, exportNames, target);
+  imports.set(target, mod);
+  return mod;
+};
+
+const loadDynamicModule = async (target: string) => {
+  const mod = await loadModule(target);
+  if (mod.status !== 'evaluated') {
+    await mod.evaluate();
+  }
+  return mod;
+};
+const mod = new SourceTextModule(source, {
+  identifier: resolvedBenchmarkUrl,
+  context,
+  initializeImportMeta(meta) {
+    meta.url = resolvedBenchmarkUrl;
+  },
+  importModuleDynamically(specifier) {
+    const resolved = resolveSpecifier(specifier);
+    return loadDynamicModule(resolved);
+  },
 });
 
+await mod.link(async (specifier) => loadModule(resolveSpecifier(specifier)));
+
 await mod.evaluate();
 const { setup, teardown, pre, run, post } = mod.namespace as any;
 
@@ -77,7 +127,6 @@ if (!run) {
 }
 
 process.exitCode = await benchmark({
-  baseUrl,
   setup,
   teardown,
   pre,

package/build/queue.cjs

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createQueue", {
-    enumerable: true,
-    get: function() {
-        return createQueue;
-    }
-});
-const createQueue = (worker, concurency = 1)=>{
-    const queue = new Set();
-    const processing = new Map();
-    const iterator = queue[Symbol.iterator]();
-    let next;
-    let counter = 0;
-    queueMicrotask(async ()=>{
-        while(true){
-            if (concurency > 0 && processing.size === concurency) {
-                await Promise.race(processing.values());
-            }
-            if (queue.size === 0) {
-                const { promise, resolve } = Promise.withResolvers();
-                next = resolve;
-                await promise;
-            }
-            const result = iterator.next();
-            if (result.done) {
-                break;
-            }
-            const id = counter++;
-            const task = Promise.resolve(worker(result.value)).catch(()=>{}).finally(()=>{
-                processing.delete(id);
-            });
-            processing.set(id, task);
-        }
-    });
-    return {
-        push: async (input)=>{
-            queue.add(input);
-            if (queue.size === 0) {
-                next?.();
-            }
-        }
-    };
-};
-
-//# sourceMappingURL=queue.cjs.map

package/build/queue.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/queue.ts"],"sourcesContent":["export const createQueue = <T>(worker: (task: T) => Promise<void>, concurency: number = 1) => {\n  const queue = new Set<T>();\n  const processing = new Map<number, Promise<void>>();\n  const iterator = queue[Symbol.iterator]();\n\n  let next: () => void;\n  let counter = 0;\n\n  queueMicrotask(async () => {\n    while (true) {\n      if (concurency > 0 && processing.size === concurency) {\n        await Promise.race(processing.values());\n      }\n      if (queue.size === 0) {\n        const { promise, resolve } = Promise.withResolvers<void>();\n        next = resolve;\n        await promise;\n      }\n      const result = iterator.next();\n      if (result.done) {\n        break;\n      }\n      const id = counter++;\n      const task = Promise.resolve(worker(result.value))\n        .catch(() => {})\n        .finally(() => {\n          processing.delete(id);\n        });\n      processing.set(id, task);\n    }\n  });\n\n  return {\n    push: async (input: T) => {\n      queue.add(input);\n\n      if (queue.size === 0) {\n        next?.();\n      }\n    },\n  };\n};\n"],"names":["createQueue","worker","concurency","queue","Set","processing","Map","iterator","Symbol","next","counter","queueMicrotask","size","Promise","race","values","promise","resolve","withResolvers","result","done","id","task","value","catch","finally","delete","set","push","input","add"],"mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,cAAc,CAAIC,QAAoCC,aAAqB,CAAC;IACvF,MAAMC,QAAQ,IAAIC;IAClB,MAAMC,aAAa,IAAIC;IACvB,MAAMC,WAAWJ,KAAK,CAACK,OAAOD,QAAQ,CAAC;IAEvC,IAAIE;IACJ,IAAIC,UAAU;IAEdC,eAAe;QACb,MAAO,KAAM;YACX,IAAIT,aAAa,KAAKG,WAAWO,IAAI,KAAKV,YAAY;gBACpD,MAAMW,QAAQC,IAAI,CAACT,WAAWU,MAAM;YACtC;YACA,IAAIZ,MAAMS,IAAI,KAAK,GAAG;gBACpB,MAAM,EAAEI,OAAO,EAAEC,OAAO,EAAE,GAAGJ,QAAQK,aAAa;gBAClDT,OAAOQ;gBACP,MAAMD;YACR;YACA,MAAMG,SAASZ,SAASE,IAAI;YAC5B,IAAIU,OAAOC,IAAI,EAAE;gBACf;YACF;YACA,MAAMC,KAAKX;YACX,MAAMY,OAAOT,QAAQI,OAAO,CAAChB,OAAOkB,OAAOI,KAAK,GAC7CC,KAAK,CAAC,KAAO,GACbC,OAAO,CAAC;gBACPpB,WAAWqB,MAAM,CAACL;YACpB;YACFhB,WAAWsB,GAAG,CAACN,IAAIC;QACrB;IACF;IAEA,OAAO;QACLM,MAAM,OAAOC;YACX1B,MAAM2B,GAAG,CAACD;YAEV,IAAI1B,MAAMS,IAAI,KAAK,GAAG;gBACpBH;YACF;QACF;IACF;AACF"}

package/build/queue.d.ts

@@ -1,3 +0,0 @@
-export declare const createQueue: <T>(worker: (task: T) => Promise<void>, concurency?: number) => {
-    push: (input: T) => Promise<void>;
-};

package/build/queue.js

@@ -1,38 +0,0 @@
-export const createQueue = (worker, concurency = 1)=>{
-    const queue = new Set();
-    const processing = new Map();
-    const iterator = queue[Symbol.iterator]();
-    let next;
-    let counter = 0;
-    queueMicrotask(async ()=>{
-        while(true){
-            if (concurency > 0 && processing.size === concurency) {
-                await Promise.race(processing.values());
-            }
-            if (queue.size === 0) {
-                const { promise, resolve } = Promise.withResolvers();
-                next = resolve;
-                await promise;
-            }
-            const result = iterator.next();
-            if (result.done) {
-                break;
-            }
-            const id = counter++;
-            const task = Promise.resolve(worker(result.value)).catch(()=>{}).finally(()=>{
-                processing.delete(id);
-            });
-            processing.set(id, task);
-        }
-    });
-    return {
-        push: async (input)=>{
-            queue.add(input);
-            if (queue.size === 0) {
-                next?.();
-            }
-        }
-    };
-};
-
-//# sourceMappingURL=queue.js.map

package/build/queue.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/queue.ts"],"sourcesContent":["export const createQueue = <T>(worker: (task: T) => Promise<void>, concurency: number = 1) => {\n  const queue = new Set<T>();\n  const processing = new Map<number, Promise<void>>();\n  const iterator = queue[Symbol.iterator]();\n\n  let next: () => void;\n  let counter = 0;\n\n  queueMicrotask(async () => {\n    while (true) {\n      if (concurency > 0 && processing.size === concurency) {\n        await Promise.race(processing.values());\n      }\n      if (queue.size === 0) {\n        const { promise, resolve } = Promise.withResolvers<void>();\n        next = resolve;\n        await promise;\n      }\n      const result = iterator.next();\n      if (result.done) {\n        break;\n      }\n      const id = counter++;\n      const task = Promise.resolve(worker(result.value))\n        .catch(() => {})\n        .finally(() => {\n          processing.delete(id);\n        });\n      processing.set(id, task);\n    }\n  });\n\n  return {\n    push: async (input: T) => {\n      queue.add(input);\n\n      if (queue.size === 0) {\n        next?.();\n      }\n    },\n  };\n};\n"],"names":["createQueue","worker","concurency","queue","Set","processing","Map","iterator","Symbol","next","counter","queueMicrotask","size","Promise","race","values","promise","resolve","withResolvers","result","done","id","task","value","catch","finally","delete","set","push","input","add"],"mappings":"AAAA,OAAO,MAAMA,cAAc,CAAIC,QAAoCC,aAAqB,CAAC;IACvF,MAAMC,QAAQ,IAAIC;IAClB,MAAMC,aAAa,IAAIC;IACvB,MAAMC,WAAWJ,KAAK,CAACK,OAAOD,QAAQ,CAAC;IAEvC,IAAIE;IACJ,IAAIC,UAAU;IAEdC,eAAe;QACb,MAAO,KAAM;YACX,IAAIT,aAAa,KAAKG,WAAWO,IAAI,KAAKV,YAAY;gBACpD,MAAMW,QAAQC,IAAI,CAACT,WAAWU,MAAM;YACtC;YACA,IAAIZ,MAAMS,IAAI,KAAK,GAAG;gBACpB,MAAM,EAAEI,OAAO,EAAEC,OAAO,EAAE,GAAGJ,QAAQK,aAAa;gBAClDT,OAAOQ;gBACP,MAAMD;YACR;YACA,MAAMG,SAASZ,SAASE,IAAI;YAC5B,IAAIU,OAAOC,IAAI,EAAE;gBACf;YACF;YACA,MAAMC,KAAKX;YACX,MAAMY,OAAOT,QAAQI,OAAO,CAAChB,OAAOkB,OAAOI,KAAK,GAC7CC,KAAK,CAAC,KAAO,GACbC,OAAO,CAAC;gBACPpB,WAAWqB,MAAM,CAACL;YACpB;YACFhB,WAAWsB,GAAG,CAACN,IAAIC;QACrB;IACF;IAEA,OAAO;QACLM,MAAM,OAAOC;YACX1B,MAAM2B,GAAG,CAACD;YAEV,IAAI1B,MAAMS,IAAI,KAAK,GAAG;gBACpBH;YACF;QACF;IACF;AACF,EAAE"}

package/src/queue.ts

@@ -1,42 +0,0 @@
-export const createQueue = <T>(worker: (task: T) => Promise<void>, concurency: number = 1) => {
-  const queue = new Set<T>();
-  const processing = new Map<number, Promise<void>>();
-  const iterator = queue[Symbol.iterator]();
-
-  let next: () => void;
-  let counter = 0;
-
-  queueMicrotask(async () => {
-    while (true) {
-      if (concurency > 0 && processing.size === concurency) {
-        await Promise.race(processing.values());
-      }
-      if (queue.size === 0) {
-        const { promise, resolve } = Promise.withResolvers<void>();
-        next = resolve;
-        await promise;
-      }
-      const result = iterator.next();
-      if (result.done) {
-        break;
-      }
-      const id = counter++;
-      const task = Promise.resolve(worker(result.value))
-        .catch(() => {})
-        .finally(() => {
-          processing.delete(id);
-        });
-      processing.set(id, task);
-    }
-  });
-
-  return {
-    push: async (input: T) => {
-      queue.add(input);
-
-      if (queue.size === 0) {
-        next?.();
-      }
-    },
-  };
-};