overtake 1.4.0 → 2.0.1

package/README.md

@@ -98,8 +98,7 @@ benchmark('data', getData)
 
 ### Importing Local Files
 
-- **CLI mode (`npx overtake`)**: `baseUrl` is set to the benchmark file, so `await import('./helper.js')` works.
-- **Programmatic mode (`suite.execute`)**: pass `baseUrl: import.meta.url` (the benchmark’s file URL) so relative imports resolve correctly. If you omit it, Overtake falls back to `process.cwd()` and relative imports may fail.
+- **CLI mode (`npx overtake`)**: relative imports resolve from the benchmark file automatically.
 
 ```typescript
 // CLI usage – relative path is fine
@@ -109,16 +108,6 @@ benchmark('local', () => 1)
     return { helper };
   })
   .measure('use helper', ({ helper }) => helper());
-
-// Programmatic usage – provide baseUrl
-const suite = new Benchmark('local');
-suite
-  .target('helper', async () => {
-    const { helper } = await import('./helpers.js');
-    return { helper };
-  })
-  .measure('use helper', ({ helper }) => helper());
-await suite.execute({ baseUrl: import.meta.url });
 ```
 
 ## Usage
@@ -285,7 +274,7 @@ npx overtake <pattern> [options]
 | Option               | Short | Description                                           | Default   |
 | -------------------- | ----- | ----------------------------------------------------- | --------- |
 | `--format`           | `-f`  | Output format (see [Output Formats](#output-formats)) | `simple`  |
-| `--report-types`     | `-r`  | Stats to show (see [Metrics](#available-metrics))     | `['ops']` |
+| `--report-types`     | `-r`  | Stats to show, repeat for multiple (`-r ops -r p99`)  | `['ops']` |
 | `--workers`          | `-w`  | Concurrent workers                                    | CPU count |
 | `--min-cycles`       |       | Minimum measurement iterations                        | 50        |
 | `--max-cycles`       |       | Maximum measurement iterations                        | 1000      |
@@ -304,7 +293,7 @@ npx overtake <pattern> [options]
 npx overtake "**/*.bench.ts" -f table
 
 # Show detailed statistics
-npx overtake bench.ts -r ops mean p95 p99
+npx overtake bench.ts -r ops -r mean -r p95 -r p99
 
 # Output JSON for CI
 npx overtake bench.ts -f json > results.json
@@ -400,7 +389,7 @@ Specify with `--report-types` or `reportTypes` option.
 **Example:**
 
 ```bash
-npx overtake bench.ts -r ops mean sd rme p50 p95 p99
+npx overtake bench.ts -r ops -r mean -r sd -r rme -r p50 -r p95 -r p99
 ```
 
 ## Baseline Comparison

package/build/cli.js

@@ -1,134 +1,135 @@
-import { createRequire, Module } from 'node:module';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { SyntheticModule, createContext, SourceTextModule } from 'node:vm';
-import { stat, readFile, writeFile } from 'node:fs/promises';
-import { Command, Option } from 'commander';
-import { glob } from 'glob';
-import { Benchmark, printTableReports, printJSONReports, printSimpleReports, printMarkdownReports, printHistogramReports, printComparisonReports, reportsToBaseline, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS } from "./index.js";
-import { transpile } from "./utils.js";
-import { REPORT_TYPES } from "./types.js";
+import { createRequire, register } from 'node:module';
+import { parseArgs } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import { stat, readFile, writeFile, glob } from 'node:fs/promises';
+import { Benchmark, printTableReports, printJSONReports, printSimpleReports, printMarkdownReports, printHistogramReports, printComparisonReports, reportsToBaseline, DEFAULT_REPORT_TYPES, DEFAULT_WORKERS, } from './index.js';
+import { REPORT_TYPES } from './types.js';
+import { resolveHookUrl } from './utils.js';
+register(resolveHookUrl);
 const require = createRequire(import.meta.url);
-const { name, description, version } = require('../package.json');
+const { name, version, description } = require('../package.json');
 const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
-const commander = new Command();
-commander.name(name).description(description).version(version).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',
-    'markdown',
-    'histogram'
-])).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)).addOption(new Option('--no-gc-observer', 'disable GC overlap detection')).addOption(new Option('--progress', 'show progress bar during benchmark execution')).addOption(new Option('--save-baseline <file>', 'save benchmark results to baseline file')).addOption(new Option('--compare-baseline <file>', 'compare results against baseline file')).action(async (patterns, executeOptions)=>{
-    let baseline = null;
-    if (executeOptions.compareBaseline) {
-        try {
-            const content = await readFile(executeOptions.compareBaseline, 'utf8');
-            baseline = JSON.parse(content);
-        } catch  {
-            console.error(`Warning: Could not load baseline file: ${executeOptions.compareBaseline}`);
-        }
+const FORMATS = ['simple', 'json', 'pjson', 'table', 'markdown', 'histogram'];
+const { values: opts, positionals: patterns } = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    options: {
+        'report-types': { type: 'string', short: 'r', multiple: true },
+        workers: { type: 'string', short: 'w' },
+        format: { type: 'string', short: 'f' },
+        'abs-threshold': { type: 'string' },
+        'rel-threshold': { type: 'string' },
+        'warmup-cycles': { type: 'string' },
+        'max-cycles': { type: 'string' },
+        'min-cycles': { type: 'string' },
+        'no-gc-observer': { type: 'boolean' },
+        progress: { type: 'boolean' },
+        'save-baseline': { type: 'string' },
+        'compare-baseline': { type: 'string' },
+        help: { type: 'boolean', short: 'h' },
+        version: { type: 'boolean', short: 'v' },
+    },
+});
+if (opts.version) {
+    console.log(version);
+    process.exit(0);
+}
+if (opts.help || patterns.length === 0) {
+    console.log(`${name} v${version} - ${description}
+
+Usage: overtake [options] <paths...>
+
+Options:
+  -r, --report-types <type>       statistic type, repeat for multiple (-r ops -r p99)
+  -w, --workers <n>               number of concurrent workers (default: ${DEFAULT_WORKERS})
+  -f, --format <format>           output format: ${FORMATS.join(', ')} (default: simple)
+  --abs-threshold <ns>            absolute error threshold in nanoseconds
+  --rel-threshold <frac>          relative error threshold (0-1)
+  --warmup-cycles <n>             warmup cycles before measuring
+  --max-cycles <n>                maximum measurement cycles per feed
+  --min-cycles <n>                minimum measurement cycles per feed
+  --no-gc-observer                disable GC overlap detection
+  --progress                      show progress bar
+  --save-baseline <file>          save results to baseline file
+  --compare-baseline <file>       compare results against baseline file
+  -v, --version                   show version
+  -h, --help                      show this help`);
+    process.exit(0);
+}
+const reportTypes = opts['report-types']?.length
+    ? opts['report-types'].filter((t) => REPORT_TYPES.includes(t))
+    : DEFAULT_REPORT_TYPES;
+const format = opts.format && FORMATS.includes(opts.format) ? opts.format : 'simple';
+const executeOptions = {
+    reportTypes,
+    workers: opts.workers ? parseInt(opts.workers) : DEFAULT_WORKERS,
+    absThreshold: opts['abs-threshold'] ? parseFloat(opts['abs-threshold']) : undefined,
+    relThreshold: opts['rel-threshold'] ? parseFloat(opts['rel-threshold']) : undefined,
+    warmupCycles: opts['warmup-cycles'] ? parseInt(opts['warmup-cycles']) : undefined,
+    maxCycles: opts['max-cycles'] ? parseInt(opts['max-cycles']) : undefined,
+    minCycles: opts['min-cycles'] ? parseInt(opts['min-cycles']) : undefined,
+    gcObserver: !opts['no-gc-observer'],
+    progress: opts.progress ?? false,
+    format,
+};
+let baseline = null;
+if (opts['compare-baseline']) {
+    try {
+        const content = await readFile(opts['compare-baseline'], 'utf8');
+        baseline = JSON.parse(content);
     }
-    const files = new Set();
-    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);
-        if (stats && stats.isFile()) {
-            const content = await readFile(file, 'utf8');
-            const identifier = pathToFileURL(file).href;
-            const code = await transpile(content);
-            let instance;
-            const benchmark = (...args)=>{
-                if (instance) {
-                    throw new Error('Only one benchmark per file is supported');
-                }
-                instance = Benchmark.create(...args);
-                return instance;
-            };
-            const globals = Object.create(null);
-            for (const k of Object.getOwnPropertyNames(globalThis)){
-                globals[k] = globalThis[k];
+    catch {
+        console.error(`Warning: Could not load baseline file: ${opts['compare-baseline']}`);
+    }
+}
+const files = new Set((await Promise.all(patterns.map((pattern) => Array.fromAsync(glob(pattern, { cwd: process.cwd() })).catch(() => [])))).flat());
+for (const file of files) {
+    const stats = await stat(file).catch(() => false);
+    if (stats && stats.isFile()) {
+        const identifier = pathToFileURL(file).href;
+        let instance;
+        globalThis.benchmark = (...args) => {
+            if (instance) {
+                throw new Error('Only one benchmark per file is supported');
             }
-            globals.benchmark = benchmark;
-            const script = new SourceTextModule(code, {
-                identifier,
-                context: createContext(globals),
-                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);
-                }
+            instance = Benchmark.create(...args);
+            return instance;
+        };
+        await import(identifier);
+        if (instance) {
+            const reports = await instance.execute({
+                ...executeOptions,
+                [BENCHMARK_URL]: identifier,
             });
-            const imports = new Map();
-            await script.link(async (specifier, referencingModule)=>{
-                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(target);
-                const exportNames = Object.keys(mod);
-                const imported = new SyntheticModule(exportNames, ()=>{
-                    exportNames.forEach((key)=>imported.setExport(key, mod[key]));
-                }, {
-                    identifier: target,
-                    context: referencingModule.context
-                });
-                imports.set(target, imported);
-                return imported;
-            });
-            await script.evaluate();
-            if (instance) {
-                const reports = await instance.execute({
-                    ...executeOptions,
-                    [BENCHMARK_URL]: identifier
-                });
-                if (executeOptions.saveBaseline) {
-                    const baselineData = reportsToBaseline(reports);
-                    await writeFile(executeOptions.saveBaseline, JSON.stringify(baselineData, null, 2));
-                    console.log(`Baseline saved to: ${executeOptions.saveBaseline}`);
-                }
-                if (baseline) {
-                    printComparisonReports(reports, baseline);
-                } else {
-                    switch(executeOptions.format){
-                        case 'json':
-                            printJSONReports(reports);
-                            break;
-                        case 'pjson':
-                            printJSONReports(reports, 2);
-                            break;
-                        case 'table':
-                            printTableReports(reports);
-                            break;
-                        case 'markdown':
-                            printMarkdownReports(reports);
-                            break;
-                        case 'histogram':
-                            printHistogramReports(reports);
-                            break;
-                        default:
-                            printSimpleReports(reports);
-                    }
+            if (opts['save-baseline']) {
+                const baselineData = reportsToBaseline(reports);
+                await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
+                console.log(`Baseline saved to: ${opts['save-baseline']}`);
+            }
+            if (baseline) {
+                printComparisonReports(reports, baseline);
+            }
+            else {
+                switch (format) {
+                    case 'json':
+                        printJSONReports(reports);
+                        break;
+                    case 'pjson':
+                        printJSONReports(reports, 2);
+                        break;
+                    case 'table':
+                        printTableReports(reports);
+                        break;
+                    case 'markdown':
+                        printMarkdownReports(reports);
+                        break;
+                    case 'histogram':
+                        printHistogramReports(reports);
+                        break;
+                    default:
+                        printSimpleReports(reports);
                 }
             }
         }
     }
-});
-commander.parse(process.argv);
-
-//# sourceMappingURL=cli.js.map
+}

package/build/executor.d.ts

@@ -1,5 +1,5 @@
 import { Report } from './reporter.js';
-import { ExecutorRunOptions, ReportOptions, BenchmarkOptions, ReportTypeList, ProgressCallback } from './types.js';
+import { type ExecutorRunOptions, type ReportOptions, type BenchmarkOptions, type ReportTypeList, type ProgressCallback } from './types.js';
 export type ExecutorReport<R extends ReportTypeList> = Record<R[number], Report> & {
     count: number;
     heapUsedKB: number;
@@ -12,4 +12,8 @@ export interface ExecutorOptions<R extends ReportTypeList> extends BenchmarkOpti
     onProgress?: ProgressCallback;
     progressInterval?: number;
 }
-export declare const createExecutor: <TContext, TInput, R extends ReportTypeList>(options: Required<ExecutorOptions<R>>) => import("async").QueueObject<ExecutorRunOptions<TContext, TInput>>;
+export interface Executor<TContext, TInput> {
+    pushAsync<T>(task: ExecutorRunOptions<TContext, TInput>): Promise<T>;
+    kill(): void;
+}
+export declare const createExecutor: <TContext, TInput, R extends ReportTypeList>(options: Required<ExecutorOptions<R>>) => Executor<TContext, TInput>;

package/build/executor.js

@@ -1,26 +1,52 @@
 import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
-import { queue } from 'async';
 import { pathToFileURL } from 'node:url';
-import { createReport } from "./reporter.js";
-import { cmp, assertNoClosure } from "./utils.js";
-import { Control, CONTROL_SLOTS, COMPLETE_VALUE } from "./types.js";
+import { createReport, computeStats, Report } from './reporter.js';
+import { cmp, assertNoClosure } from './utils.js';
+import { Control, CONTROL_SLOTS, COMPLETE_VALUE, } from './types.js';
 const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
-export const createExecutor = (options)=>{
+export const createExecutor = (options) => {
     const { workers, warmupCycles, maxCycles, minCycles, absThreshold, relThreshold, gcObserver = true, reportTypes, onProgress, progressInterval = 100 } = options;
     const benchmarkUrl = options[BENCHMARK_URL];
     const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
-    const executor = queue(async ({ id, setup, teardown, pre, run, post, data })=>{
+    const pending = [];
+    let running = 0;
+    const schedule = async (task) => {
+        running++;
+        try {
+            return await runTask(task);
+        }
+        finally {
+            running--;
+            if (pending.length > 0) {
+                const next = pending.shift();
+                schedule(next.task).then(next.resolve, next.reject);
+            }
+        }
+    };
+    const pushAsync = (task) => {
+        if (running < workers) {
+            return schedule(task);
+        }
+        return new Promise((resolve, reject) => {
+            pending.push({ task, resolve: resolve, reject });
+        });
+    };
+    const runTask = async ({ id, setup, teardown, pre, run, post, data }) => {
         const setupCode = setup?.toString();
         const teardownCode = teardown?.toString();
         const preCode = pre?.toString();
         const runCode = run.toString();
         const postCode = post?.toString();
-        if (setupCode) assertNoClosure(setupCode, 'setup');
-        if (teardownCode) assertNoClosure(teardownCode, 'teardown');
-        if (preCode) assertNoClosure(preCode, 'pre');
+        if (setupCode)
+            assertNoClosure(setupCode, 'setup');
+        if (teardownCode)
+            assertNoClosure(teardownCode, 'teardown');
+        if (preCode)
+            assertNoClosure(preCode, 'pre');
         assertNoClosure(runCode, 'run');
-        if (postCode) assertNoClosure(postCode, 'post');
+        if (postCode)
+            assertNoClosure(postCode, 'post');
         const controlSAB = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * CONTROL_SLOTS);
         const durationsSAB = new SharedArrayBuffer(BigUint64Array.BYTES_PER_ELEMENT * maxCycles);
         const workerFile = new URL('./worker.js', import.meta.url);
@@ -38,36 +64,36 @@ export const createExecutor = (options)=>{
             relThreshold,
             gcObserver,
             controlSAB,
-            durationsSAB
+            durationsSAB,
         };
         const worker = new Worker(workerFile, {
-            workerData
+            workerData,
         });
         const control = new Int32Array(controlSAB);
         let progressIntervalId;
         if (onProgress && id) {
-            progressIntervalId = setInterval(()=>{
+            progressIntervalId = setInterval(() => {
                 const progress = control[Control.PROGRESS] / COMPLETE_VALUE;
-                onProgress({
-                    id,
-                    progress
-                });
+                onProgress({ id, progress });
             }, progressInterval);
         }
         const WORKER_TIMEOUT_MS = 300_000;
         const exitPromise = once(worker, 'exit');
-        const timeoutId = setTimeout(()=>worker.terminate(), WORKER_TIMEOUT_MS);
+        const timeoutId = setTimeout(() => worker.terminate(), WORKER_TIMEOUT_MS);
         let workerError;
         try {
             const [exitCode] = await exitPromise;
             clearTimeout(timeoutId);
-            if (progressIntervalId) clearInterval(progressIntervalId);
+            if (progressIntervalId)
+                clearInterval(progressIntervalId);
             if (exitCode !== 0) {
                 workerError = `worker exited with code ${exitCode}`;
             }
-        } catch (err) {
+        }
+        catch (err) {
             clearTimeout(timeoutId);
-            if (progressIntervalId) clearInterval(progressIntervalId);
+            if (progressIntervalId)
+                clearInterval(progressIntervalId);
             workerError = err instanceof Error ? err.message : String(err);
         }
         const count = control[Control.INDEX];
@@ -77,37 +103,24 @@ export const createExecutor = (options)=>{
         let dceWarning = false;
         if (count > 0) {
             let sum = 0n;
-            for (const d of durations)sum += d;
+            for (const d of durations)
+                sum += d;
             const avgNs = Number(sum / BigInt(count)) / 1000;
             const opsPerSec = avgNs > 0 ? 1_000_000_000 / avgNs : Infinity;
             if (opsPerSec > DCE_THRESHOLD_OPS) {
                 dceWarning = true;
             }
         }
-        const report = reportTypes.map((type)=>[
-                type,
-                createReport(durations, type)
-            ]).concat([
-            [
-                'count',
-                count
-            ],
-            [
-                'heapUsedKB',
-                heapUsedKB
-            ],
-            [
-                'dceWarning',
-                dceWarning
-            ],
-            [
-                'error',
-                workerError
-            ]
+        const stats = count > 0 ? computeStats(durations) : undefined;
+        const report = reportTypes
+            .map((type) => [type, createReport(durations, type, stats)])
+            .concat([
+            ['count', count],
+            ['heapUsedKB', heapUsedKB],
+            ['dceWarning', dceWarning],
+            ['error', workerError],
         ]);
         return Object.fromEntries(report);
-    }, workers);
-    return executor;
+    };
+    return { pushAsync, kill() { } };
 };
-
-//# sourceMappingURL=executor.js.map

package/build/gc-watcher.js

@@ -1,12 +1,10 @@
 export class GCWatcher {
-    #registry = new FinalizationRegistry(()=>{});
+    #registry = new FinalizationRegistry(() => { });
     start() {
         const target = {};
         const ref = new WeakRef(target);
         this.#registry.register(target, null, ref);
-        return {
-            ref
-        };
+        return { ref };
     }
     seen(marker) {
         const collected = marker.ref.deref() === undefined;
@@ -16,5 +14,3 @@ export class GCWatcher {
         return collected;
     }
 }
-
-//# sourceMappingURL=gc-watcher.js.map

package/build/index.d.ts

@@ -1,10 +1,9 @@
-import { ExecutorOptions, ExecutorReport } from './executor.js';
-import { MaybePromise, StepFn, SetupFn, TeardownFn, FeedFn, ReportType, ReportTypeList } from './types.js';
+import { type ExecutorOptions, type ExecutorReport } from './executor.js';
+import { type MaybePromise, type StepFn, type SetupFn, type TeardownFn, type FeedFn, type ReportType, type ReportTypeList } from './types.js';
 declare global {
     const benchmark: typeof Benchmark.create;
 }
 export declare const DEFAULT_WORKERS: number;
-export declare const AsyncFunction: Function;
 export interface TargetReport<R extends ReportTypeList> {
     target: string;
     measures: MeasureReport<R>[];
@@ -20,10 +19,10 @@ export interface FeedReport<R extends ReportTypeList> {
 export declare const DEFAULT_REPORT_TYPES: readonly ["ops"];
 export type DefaultReportTypes = (typeof DEFAULT_REPORT_TYPES)[number];
 export declare class MeasureContext<TContext, TInput> {
-    title: string;
-    run: StepFn<TContext, TInput>;
     pre?: StepFn<TContext, TInput>;
     post?: StepFn<TContext, TInput>;
+    title: string;
+    run: StepFn<TContext, TInput>;
     constructor(title: string, run: StepFn<TContext, TInput>);
 }
 export declare class Measure<TContext, TInput> {
@@ -33,11 +32,11 @@ export declare class Measure<TContext, TInput> {
     post(fn: StepFn<TContext, TInput>): Measure<TContext, TInput>;
 }
 export declare class TargetContext<TContext, TInput> {
-    readonly title: string;
-    readonly setup?: SetupFn<MaybePromise<TContext>> | undefined;
     teardown?: TeardownFn<TContext>;
     measures: MeasureContext<TContext, TInput>[];
-    constructor(title: string, setup?: SetupFn<MaybePromise<TContext>> | undefined);
+    readonly title: string;
+    readonly setup?: SetupFn<MaybePromise<TContext>>;
+    constructor(title: string, setup?: SetupFn<MaybePromise<TContext>>);
 }
 export declare class Target<TContext, TInput> {
     #private;
@@ -47,8 +46,8 @@ export declare class Target<TContext, TInput> {
 }
 export declare class FeedContext<TInput> {
     readonly title: string;
-    readonly fn?: FeedFn<TInput> | undefined;
-    constructor(title: string, fn?: FeedFn<TInput> | undefined);
+    readonly fn?: FeedFn<TInput>;
+    constructor(title: string, fn?: FeedFn<TInput>);
 }
 export declare class Benchmark<TInput> {
     #private;
@@ -60,7 +59,7 @@ export declare class Benchmark<TInput> {
     feed<I>(title: string, fn: FeedFn<I>): Benchmark<TInput | I>;
     target<TContext>(title: string): Target<void, TInput>;
     target<TContext>(title: string, setup: SetupFn<Awaited<TContext>>): Target<TContext, TInput>;
-    execute<R extends readonly ReportType[] = typeof DEFAULT_REPORT_TYPES>(options: ExecutorOptions<R> & {
+    execute<R extends readonly ReportType[] = typeof DEFAULT_REPORT_TYPES>(options?: Partial<ExecutorOptions<R>> & {
         progress?: boolean;
     }): Promise<TargetReport<R>[]>;
 }