overtake 1.0.4 → 1.1.0

package/examples/quick-start.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "1.0.4",
+  "version": "1.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,30 +51,54 @@ commander
           return instance;
         };
         const script = new SourceTextModule(code, {
-          context: createContext({ benchmark }),
+          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,

package/src/runner.ts

@@ -1,21 +1,175 @@
+import { performance, PerformanceObserver } from 'node:perf_hooks';
 import { Options, Control } from './types.js';
+import { GCWatcher } from './gc-watcher.js';
+import { StepFn, MaybePromise } from './types.js';
 
 const COMPLETE_VALUE = 100_00;
 
+const hr = process.hrtime.bigint.bind(process.hrtime);
+
 const runSync = (run: Function) => {
   return (...args: unknown[]) => {
-    const start = process.hrtime.bigint();
+    const start = hr();
     run(...args);
-    return process.hrtime.bigint() - start;
+    return hr() - start;
   };
 };
 
 const runAsync = (run: Function) => {
   return async (...args: unknown[]) => {
-    const start = process.hrtime.bigint();
+    const start = hr();
     await run(...args);
-    return process.hrtime.bigint() - start;
+    return hr() - start;
+  };
+};
+
+const TARGET_SAMPLE_NS = 1_000_000n; // aim for ~1ms per measured sample
+const MAX_BATCH = 1_048_576;
+const PROGRESS_STRIDE = 16;
+const GC_STRIDE = 32;
+const OUTLIER_MULTIPLIER = 4;
+const OUTLIER_IQR_MULTIPLIER = 3;
+const OUTLIER_WINDOW = 64;
+
+type GCEvent = { start: number; end: number };
+
+const collectSample = async <TContext, TInput>(
+  batchSize: number,
+  run: (ctx: TContext, data: TInput) => MaybePromise<bigint>,
+  pre: StepFn<TContext, TInput> | undefined,
+  post: StepFn<TContext, TInput> | undefined,
+  context: TContext,
+  data: TInput,
+) => {
+  let sampleDuration = 0n;
+  for (let b = 0; b < batchSize; b++) {
+    await pre?.(context, data);
+    sampleDuration += await run(context, data);
+    await post?.(context, data);
+  }
+  return sampleDuration / BigInt(batchSize);
+};
+
+const tuneParameters = async <TContext, TInput>({
+  initialBatch,
+  run,
+  pre,
+  post,
+  context,
+  data,
+  minCycles,
+  relThreshold,
+  maxCycles,
+}: {
+  initialBatch: number;
+  run: (ctx: TContext, data: TInput) => MaybePromise<bigint>;
+  pre?: StepFn<TContext, TInput>;
+  post?: StepFn<TContext, TInput>;
+  context: TContext;
+  data: TInput;
+  minCycles: number;
+  relThreshold: number;
+  maxCycles: number;
+}) => {
+  let batchSize = initialBatch;
+  let bestCv = Number.POSITIVE_INFINITY;
+  let bestBatch = batchSize;
+
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const samples: number[] = [];
+    const sampleCount = Math.min(8, maxCycles);
+    for (let s = 0; s < sampleCount; s++) {
+      const duration = await collectSample(batchSize, run, pre, post, context, data);
+      samples.push(Number(duration));
+    }
+    const mean = samples.reduce((acc, v) => acc + v, 0) / samples.length;
+    const variance = samples.reduce((acc, v) => acc + (v - mean) * (v - mean), 0) / Math.max(1, samples.length - 1);
+    const stddev = Math.sqrt(variance);
+    const cv = mean === 0 ? Number.POSITIVE_INFINITY : stddev / mean;
+
+    if (cv < bestCv) {
+      bestCv = cv;
+      bestBatch = batchSize;
+    }
+
+    if (cv <= relThreshold || batchSize >= MAX_BATCH) {
+      break;
+    }
+    batchSize = Math.min(MAX_BATCH, batchSize * 2);
+  }
+
+  const tunedRel = bestCv < relThreshold ? Math.max(bestCv * 1.5, relThreshold * 0.5) : relThreshold;
+  const tunedMin = Math.min(maxCycles, Math.max(minCycles, Math.ceil(minCycles * Math.max(1, bestCv / (relThreshold || 1e-6)))));
+
+  return { batchSize: bestBatch, relThreshold: tunedRel, minCycles: tunedMin };
+};
+
+const createGCTracker = () => {
+  if (process.env.OVERTAKE_GC_OBSERVER !== '1') {
+    return null;
+  }
+  if (typeof PerformanceObserver === 'undefined') {
+    return null;
+  }
+
+  const events: GCEvent[] = [];
+  const observer = new PerformanceObserver((list) => {
+    for (const entry of list.getEntries()) {
+      events.push({ start: entry.startTime, end: entry.startTime + entry.duration });
+    }
+  });
+
+  try {
+    observer.observe({ entryTypes: ['gc'] });
+  } catch {
+    return null;
+  }
+
+  const overlaps = (start: number, end: number) => {
+    let noisy = false;
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event.end < start - 5_000) {
+        events.splice(i, 1);
+        continue;
+      }
+      if (event.start <= end && event.end >= start) {
+        noisy = true;
+      }
+    }
+    return noisy;
   };
+
+  const dispose = () => observer.disconnect();
+
+  return { overlaps, dispose };
+};
+
+const pushWindow = (arr: number[], value: number, cap: number) => {
+  if (arr.length === cap) {
+    arr.shift();
+  }
+  arr.push(value);
+};
+
+const medianAndIqr = (arr: number[]) => {
+  if (arr.length === 0) return { median: 0, iqr: 0 };
+  const sorted = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  const median = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  const q1Idx = Math.floor(sorted.length * 0.25);
+  const q3Idx = Math.floor(sorted.length * 0.75);
+  const q1 = sorted[q1Idx];
+  const q3 = sorted[q3Idx];
+  return { median, iqr: q3 - q1 };
+};
+
+const windowCv = (arr: number[]) => {
+  if (arr.length < 2) return Number.POSITIVE_INFINITY;
+  const mean = arr.reduce((a, v) => a + v, 0) / arr.length;
+  const variance = arr.reduce((a, v) => a + (v - mean) * (v - mean), 0) / (arr.length - 1);
+  const stddev = Math.sqrt(variance);
+  return mean === 0 ? Number.POSITIVE_INFINITY : stddev / mean;
 };
 
 export const benchmark = async <TContext, TInput>({
@@ -30,6 +184,7 @@ export const benchmark = async <TContext, TInput>({
   minCycles,
   absThreshold,
   relThreshold,
+  gcObserver = false,
 
   durationsSAB,
   controlSAB,
@@ -43,40 +198,133 @@ export const benchmark = async <TContext, TInput>({
 
   const context = (await setup?.()) as TContext;
   const maxCycles = durations.length;
+  const gcWatcher = new GCWatcher();
+  const gcTracker = gcObserver ? createGCTracker() : null;
 
   try {
+    // classify sync/async and capture initial duration
     await pre?.(context, data!);
-    const result = runRaw(context, data!);
+    const probeStart = hr();
+    const probeResult = runRaw(context, data!);
+    const isAsync = probeResult instanceof Promise;
+    if (isAsync) {
+      await probeResult;
+    }
+    const durationProbe = hr() - probeStart;
     await post?.(context, data!);
-    const run = result instanceof Promise ? runAsync(runRaw) : runSync(runRaw);
-    const start = Date.now();
-    while (Date.now() - start < 1_000) {
-      Math.sqrt(Math.random());
+
+    const run = isAsync ? runAsync(runRaw) : runSync(runRaw);
+
+    // choose batch size to amortize timer overhead
+    const durationPerRun = durationProbe === 0n ? 1n : durationProbe;
+    const suggestedBatch = Number(TARGET_SAMPLE_NS / durationPerRun);
+    const initialBatchSize = Math.min(MAX_BATCH, Math.max(1, suggestedBatch));
+
+    // auto-tune based on warmup samples
+    const tuned = await tuneParameters({
+      initialBatch: initialBatchSize,
+      run,
+      pre,
+      post,
+      context,
+      data: data as TInput,
+      minCycles,
+      relThreshold,
+      maxCycles,
+    });
+    let batchSize = tuned.batchSize;
+    minCycles = tuned.minCycles;
+    relThreshold = tuned.relThreshold;
+
+    // warmup: run until requested cycles, adapt if unstable
+    const warmupStart = Date.now();
+    let warmupRemaining = warmupCycles;
+    const warmupWindow: number[] = [];
+    const warmupCap = Math.max(warmupCycles, Math.min(maxCycles, warmupCycles * 4 || 1000));
+
+    while (Date.now() - warmupStart < 1_000 && warmupRemaining > 0) {
+      const start = hr();
+      await pre?.(context, data!);
+      await run(context, data);
+      await post?.(context, data!);
+      pushWindow(warmupWindow, Number(hr() - start), warmupCap);
+      warmupRemaining--;
     }
-    for (let i = 0; i < warmupCycles; i++) {
+    let warmupDone = 0;
+    while (warmupDone < warmupRemaining) {
+      const start = hr();
       await pre?.(context, data!);
       await run(context, data);
       await post?.(context, data!);
+      pushWindow(warmupWindow, Number(hr() - start), warmupCap);
+      warmupDone++;
+      if (global.gc && warmupDone % GC_STRIDE === 0) {
+        global.gc();
+      }
+    }
+    while (warmupWindow.length >= 8 && warmupWindow.length < warmupCap) {
+      const cv = windowCv(warmupWindow);
+      if (cv <= relThreshold * 2) {
+        break;
+      }
+      const start = hr();
+      await pre?.(context, data!);
+      await run(context, data);
+      await post?.(context, data!);
+      pushWindow(warmupWindow, Number(hr() - start), warmupCap);
     }
 
     let i = 0;
     let mean = 0n;
     let m2 = 0n;
+    const outlierWindow: number[] = [];
 
     while (true) {
       if (i >= maxCycles) break;
 
-      await pre?.(context, data!);
-      const duration = await run(context, data);
-      await post?.(context, data!);
+      const gcMarker = gcWatcher.start();
+      const sampleStart = performance.now();
+      let sampleDuration = 0n;
+      for (let b = 0; b < batchSize; b++) {
+        await pre?.(context, data!);
+        sampleDuration += await run(context, data);
+        await post?.(context, data!);
+        if (global.gc && (i + b) % GC_STRIDE === 0) {
+          global.gc();
+        }
+      }
+
+      // normalize by batch size
+      sampleDuration /= BigInt(batchSize);
 
-      durations[i++] = duration;
-      const delta = duration - mean;
+      const sampleEnd = performance.now();
+      const gcNoise = gcWatcher.seen(gcMarker) || (gcTracker?.overlaps(sampleStart, sampleEnd) ?? false);
+      if (gcNoise) {
+        continue;
+      }
+
+      const durationNumber = Number(sampleDuration);
+      pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
+      const { median, iqr } = medianAndIqr(outlierWindow);
+      const maxAllowed = median + OUTLIER_IQR_MULTIPLIER * iqr || Number.POSITIVE_INFINITY;
+      if (outlierWindow.length >= 8 && durationNumber > maxAllowed) {
+        continue;
+      }
+
+      const meanNumber = Number(mean);
+      if (i >= 8 && meanNumber > 0 && durationNumber > OUTLIER_MULTIPLIER * meanNumber) {
+        continue;
+      }
+
+      durations[i++] = sampleDuration;
+      const delta = sampleDuration - mean;
       mean += delta / BigInt(i);
-      m2 += delta * (duration - mean);
+      m2 += delta * (sampleDuration - mean);
 
       const progress = Math.max(i / maxCycles) * COMPLETE_VALUE;
-      control[Control.PROGRESS] = progress;
+      if (i % PROGRESS_STRIDE === 0) {
+        control[Control.PROGRESS] = progress;
+      }
 
       if (i >= minCycles) {
         const variance = Number(m2) / (i - 1);
@@ -99,6 +347,7 @@ export const benchmark = async <TContext, TInput>({
     console.error(e && typeof e === 'object' && 'stack' in e ? e.stack : e);
     control[Control.COMPLETE] = 1;
   } finally {
+    gcTracker?.dispose?.();
     try {
       await teardown?.(context);
     } catch (e) {

package/src/types.ts

@@ -33,9 +33,12 @@ export interface BenchmarkOptions {
   minCycles?: number;
   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>;
@@ -45,6 +48,7 @@ export interface RunOptions<TContext, TInput> {
 }
 
 export interface WorkerOptions extends Required<BenchmarkOptions> {
+  baseUrl: string;
   setupCode?: string;
   teardownCode?: string;
   preCode?: string;