overtake 2.0.0 → 2.0.2

package/build/index.js

@@ -0,0 +1,375 @@
+import { cpus } from 'node:os';
+import Progress from 'progress';
+import { createExecutor } from './executor.js';
+import { DEFAULT_CYCLES } from './types.js';
+export const DEFAULT_WORKERS = Math.max(1, Math.ceil(cpus().length / 4));
+const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
+export const DEFAULT_REPORT_TYPES = ['ops'];
+const createExecutorErrorReport = (error) => ({
+    count: 0,
+    heapUsedKB: 0,
+    dceWarning: false,
+    error: error instanceof Error ? error.message : String(error),
+});
+export class MeasureContext {
+    pre;
+    post;
+    title;
+    run;
+    constructor(title, run) {
+        this.title = title;
+        this.run = run;
+    }
+}
+export class Measure {
+    #ctx;
+    constructor(ctx) {
+        this.#ctx = ctx;
+    }
+    pre(fn) {
+        this.#ctx.pre = fn;
+        return this;
+    }
+    post(fn) {
+        this.#ctx.post = fn;
+        return this;
+    }
+}
+export class TargetContext {
+    teardown;
+    measures = [];
+    title;
+    setup;
+    constructor(title, setup) {
+        this.title = title;
+        this.setup = setup;
+    }
+}
+export class Target {
+    #ctx;
+    constructor(ctx) {
+        this.#ctx = ctx;
+    }
+    teardown(fn) {
+        this.#ctx.teardown = fn;
+        return this;
+    }
+    measure(title, run) {
+        const measure = new MeasureContext(title, run);
+        this.#ctx.measures.push(measure);
+        return new Measure(measure);
+    }
+}
+export class FeedContext {
+    title;
+    fn;
+    constructor(title, fn) {
+        this.title = title;
+        this.fn = fn;
+    }
+}
+export class Benchmark {
+    #targets = [];
+    #feeds = [];
+    #executed = false;
+    static create(title, fn) {
+        if (fn) {
+            return new Benchmark(title, fn);
+        }
+        else {
+            return new Benchmark(title);
+        }
+    }
+    constructor(title, fn) {
+        if (fn) {
+            this.feed(title, fn);
+        }
+        else {
+            this.feed(title);
+        }
+    }
+    feed(title, fn) {
+        const self = this;
+        self.#feeds.push(fn ? new FeedContext(title, fn) : new FeedContext(title));
+        return self;
+    }
+    target(title, setup) {
+        const target = new TargetContext(title, setup);
+        this.#targets.push(target);
+        return new Target(target);
+    }
+    async execute(options = {}) {
+        const { workers = DEFAULT_WORKERS, warmupCycles = 20, maxCycles = DEFAULT_CYCLES, minCycles = 50, absThreshold = 1_000, relThreshold = 0.02, gcObserver = true, reportTypes = DEFAULT_REPORT_TYPES, progress = false, progressInterval = 100, } = options;
+        if (this.#executed) {
+            throw new Error("Benchmark is executed and can't be reused");
+        }
+        this.#executed = true;
+        const benchmarkUrl = options[BENCHMARK_URL];
+        const totalBenchmarks = this.#targets.reduce((acc, t) => acc + t.measures.length * this.#feeds.length, 0);
+        const progressMap = new Map();
+        let completedBenchmarks = 0;
+        let bar = null;
+        if (progress && totalBenchmarks > 0) {
+            bar = new Progress('  [:bar] :percent :current/:total :label', {
+                total: totalBenchmarks * 100,
+                width: 30,
+                complete: '=',
+                incomplete: ' ',
+            });
+        }
+        const onProgress = progress
+            ? (info) => {
+                progressMap.set(info.id, info.progress);
+                const totalProgress = (completedBenchmarks + [...progressMap.values()].reduce((a, b) => a + b, 0)) * 100;
+                const label = info.id.length > 30 ? info.id.slice(0, 27) + '...' : info.id;
+                bar?.update(totalProgress / (totalBenchmarks * 100), { label });
+            }
+            : undefined;
+        const executor = createExecutor({
+            workers,
+            warmupCycles,
+            maxCycles,
+            minCycles,
+            absThreshold,
+            relThreshold,
+            gcObserver,
+            reportTypes,
+            onProgress,
+            progressInterval,
+            [BENCHMARK_URL]: benchmarkUrl,
+        });
+        const reports = [];
+        const pendingReports = [];
+        try {
+            const feedData = await Promise.all(this.#feeds.map(async (feed) => ({ title: feed.title, data: await feed.fn?.() })));
+            for (const target of this.#targets) {
+                const targetReport = { target: target.title, measures: [] };
+                for (const measure of target.measures) {
+                    const measureReport = { measure: measure.title, feeds: [] };
+                    for (const feed of feedData) {
+                        const id = `${target.title}/${measure.title}/${feed.title}`;
+                        const feedReport = {
+                            feed: feed.title,
+                            data: createExecutorErrorReport('Benchmark did not produce a report'),
+                        };
+                        measureReport.feeds.push(feedReport);
+                        pendingReports.push((async () => {
+                            try {
+                                feedReport.data = await executor.pushAsync({
+                                    id,
+                                    setup: target.setup,
+                                    teardown: target.teardown,
+                                    pre: measure.pre,
+                                    run: measure.run,
+                                    post: measure.post,
+                                    data: feed.data,
+                                });
+                            }
+                            catch (error) {
+                                feedReport.data = createExecutorErrorReport(error);
+                            }
+                            finally {
+                                progressMap.delete(id);
+                                completedBenchmarks++;
+                            }
+                        })());
+                    }
+                    targetReport.measures.push(measureReport);
+                }
+                reports.push(targetReport);
+            }
+            await Promise.all(pendingReports);
+            if (bar) {
+                bar.update(1, { label: 'done' });
+                bar.terminate();
+            }
+            return reports;
+        }
+        finally {
+            executor.kill();
+        }
+    }
+}
+export const printSimpleReports = (reports) => {
+    for (const report of reports) {
+        for (const { measure, feeds } of report.measures) {
+            console.group('\n', report.target, measure);
+            for (const { feed, data } of feeds) {
+                const { count, heapUsedKB, dceWarning, error: benchError, ...metrics } = data;
+                if (benchError) {
+                    console.log(feed, `\x1b[31m[error: ${benchError}]\x1b[0m`);
+                    continue;
+                }
+                const output = Object.entries(metrics)
+                    .map(([key, report]) => `${key}: ${report.toString()}`)
+                    .join('; ');
+                const extras = [];
+                if (heapUsedKB)
+                    extras.push(`heap: ${heapUsedKB}KB`);
+                if (dceWarning)
+                    extras.push('\x1b[33m[DCE warning]\x1b[0m');
+                const extrasStr = extras.length > 0 ? ` (${extras.join(', ')})` : '';
+                console.log(feed, output + extrasStr);
+            }
+            console.groupEnd();
+        }
+    }
+};
+export const printTableReports = (reports) => {
+    for (const report of reports) {
+        for (const { measure, feeds } of report.measures) {
+            console.log('\n', report.target, measure);
+            const table = {};
+            for (const { feed, data } of feeds) {
+                const { error: benchError } = data;
+                if (benchError) {
+                    table[feed] = { error: benchError };
+                }
+                else {
+                    table[feed] = Object.fromEntries(Object.entries(data).map(([key, report]) => [key, report.toString()]));
+                }
+            }
+            console.table(table);
+        }
+    }
+};
+export const printJSONReports = (reports, padding) => {
+    const output = {};
+    for (const report of reports) {
+        for (const { measure, feeds } of report.measures) {
+            const row = {};
+            for (const { feed, data } of feeds) {
+                const { error: benchError } = data;
+                if (benchError) {
+                    row[feed] = { error: String(benchError) };
+                }
+                else {
+                    row[feed] = Object.fromEntries(Object.entries(data).map(([key, report]) => [key, report.toString()]));
+                }
+            }
+            output[`${report.target} ${measure}`] = row;
+        }
+    }
+    console.log(JSON.stringify(output, null, padding));
+};
+export const printMarkdownReports = (reports) => {
+    for (const report of reports) {
+        for (const { measure, feeds } of report.measures) {
+            console.log(`\n## ${report.target} - ${measure}\n`);
+            if (feeds.length === 0)
+                continue;
+            const firstValid = feeds.find((f) => !f.data.error);
+            if (!firstValid) {
+                for (const { feed, data } of feeds) {
+                    console.log(`| ${feed} | error: ${data.error} |`);
+                }
+                continue;
+            }
+            const keys = Object.keys(firstValid.data).filter((k) => k !== 'count' && k !== 'error');
+            const header = ['Feed', ...keys].join(' | ');
+            const separator = ['---', ...keys.map(() => '---')].join(' | ');
+            console.log(`| ${header} |`);
+            console.log(`| ${separator} |`);
+            for (const { feed, data } of feeds) {
+                if (data.error) {
+                    console.log(`| ${feed} | error: ${data.error} |`);
+                    continue;
+                }
+                const values = keys.map((k) => data[k]?.toString() ?? '-');
+                console.log(`| ${[feed, ...values].join(' | ')} |`);
+            }
+        }
+    }
+};
+export const printHistogramReports = (reports, width = 40) => {
+    for (const report of reports) {
+        for (const { measure, feeds } of report.measures) {
+            console.log(`\n${report.target} - ${measure}\n`);
+            const opsKey = 'ops';
+            const values = feeds.map((f) => {
+                const { error: benchError } = f.data;
+                return {
+                    feed: f.feed,
+                    value: benchError ? 0 : (f.data[opsKey]?.valueOf() ?? 0),
+                    error: benchError,
+                };
+            });
+            const maxValue = Math.max(...values.map((v) => v.value));
+            const maxLabelLen = Math.max(...values.map((v) => v.feed.length));
+            for (const { feed, value, error } of values) {
+                const label = feed.padEnd(maxLabelLen);
+                if (error) {
+                    console.log(`  ${label} | \x1b[31m[error: ${error}]\x1b[0m`);
+                    continue;
+                }
+                const barLen = maxValue > 0 ? Math.round((value / maxValue) * width) : 0;
+                const bar = '\u2588'.repeat(barLen);
+                const formatted = value.toLocaleString('en-US', { maximumFractionDigits: 2 });
+                console.log(`  ${label} | ${bar} ${formatted} ops/s`);
+            }
+        }
+    }
+};
+export const reportsToBaseline = (reports) => {
+    const results = {};
+    for (const report of reports) {
+        for (const { measure, feeds } of report.measures) {
+            for (const { feed, data } of feeds) {
+                if (data.error)
+                    continue;
+                const key = `${report.target}/${measure}/${feed}`;
+                results[key] = {};
+                for (const [metric, value] of Object.entries(data)) {
+                    if (metric !== 'count' && typeof value.valueOf === 'function') {
+                        results[key][metric] = value.valueOf();
+                    }
+                }
+            }
+        }
+    }
+    return {
+        version: 1,
+        timestamp: new Date().toISOString(),
+        results,
+    };
+};
+export const printComparisonReports = (reports, baseline, threshold = 5) => {
+    for (const report of reports) {
+        for (const { measure, feeds } of report.measures) {
+            console.log(`\n${report.target} - ${measure}\n`);
+            for (const { feed, data } of feeds) {
+                const key = `${report.target}/${measure}/${feed}`;
+                const baselineData = baseline.results[key];
+                console.log(`  ${feed}:`);
+                if (data.error) {
+                    console.log(`    \x1b[31m[error: ${data.error}]\x1b[0m`);
+                    continue;
+                }
+                for (const [metric, value] of Object.entries(data)) {
+                    if (metric === 'count')
+                        continue;
+                    const current = value.valueOf();
+                    const baselineValue = baselineData?.[metric];
+                    if (baselineValue !== undefined && baselineValue !== 0) {
+                        const change = ((current - baselineValue) / baselineValue) * 100;
+                        const isOps = metric === 'ops';
+                        const improved = isOps ? change > threshold : change < -threshold;
+                        const regressed = isOps ? change < -threshold : change > threshold;
+                        let indicator = ' ';
+                        if (improved)
+                            indicator = '\x1b[32m+\x1b[0m';
+                        else if (regressed)
+                            indicator = '\x1b[31m!\x1b[0m';
+                        const changeStr = change >= 0 ? `+${change.toFixed(1)}%` : `${change.toFixed(1)}%`;
+                        const coloredChange = regressed ? `\x1b[31m${changeStr}\x1b[0m` : improved ? `\x1b[32m${changeStr}\x1b[0m` : changeStr;
+                        console.log(`    ${indicator} ${metric}: ${value.toString()} (${coloredChange})`);
+                    }
+                    else {
+                        console.log(`    * ${metric}: ${value.toString()} (new)`);
+                    }
+                }
+            }
+        }
+    }
+    console.log(`\nBaseline from: ${baseline.timestamp}`);
+};

package/build/register-hook.d.ts

@@ -0,0 +1 @@
+export {};

package/build/register-hook.js

@@ -0,0 +1,15 @@
+import { register } from 'node:module';
+async function resolve(s, c, n) {
+    try {
+        return await n(s, c);
+    }
+    catch (e) {
+        if (s.endsWith('.js'))
+            try {
+                return await n(s.slice(0, -3) + '.ts', c);
+            }
+            catch { }
+        throw e;
+    }
+}
+register('data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`));

package/build/reporter.d.ts

@@ -1,4 +1,4 @@
-import { type ReportType } from './types.ts';
+import { type ReportType } from './types.js';
 export declare class Report {
     readonly type: ReportType;
     readonly value: bigint;

package/build/reporter.js

@@ -0,0 +1,255 @@
+import { div, max, divs, isqrt } from './utils.js';
+import { DURATION_SCALE } from './types.js';
+const units = [
+    { unit: 'ns', factor: 1 },
+    { unit: 'µs', factor: 1e3 },
+    { unit: 'ms', factor: 1e6 },
+    { unit: 's', factor: 1e9 },
+    { unit: 'm', factor: 60 * 1e9 },
+    { unit: 'h', factor: 3600 * 1e9 },
+];
+function smartFixed(n) {
+    return n.toLocaleString(undefined, {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 2,
+        useGrouping: true,
+    });
+}
+export class Report {
+    type;
+    value;
+    uncertainty;
+    scale;
+    constructor(type, value, uncertainty = 0, scale = 1n) {
+        this.type = type;
+        this.value = value;
+        this.uncertainty = uncertainty;
+        this.scale = scale;
+    }
+    valueOf() {
+        return Number(div(this.value, this.scale));
+    }
+    toString() {
+        const uncertainty = this.uncertainty ? ` ± ${smartFixed(this.uncertainty)}%` : '';
+        const value = this.valueOf();
+        if (this.type === 'ops') {
+            return `${smartFixed(value)} ops/s${uncertainty}`;
+        }
+        if (this.type === 'rme') {
+            return `${smartFixed(value)}%`;
+        }
+        if (this.type === 'variance') {
+            let display = value;
+            let unit = 'ns²';
+            const varianceUnits = [
+                { unit: 'ns²', factor: 1 },
+                { unit: 'µs²', factor: 1e6 },
+                { unit: 'ms²', factor: 1e12 },
+            ];
+            for (const { unit: u, factor } of varianceUnits) {
+                const candidate = value / factor;
+                if (candidate < 1000) {
+                    display = candidate;
+                    unit = u;
+                    break;
+                }
+            }
+            return `${smartFixed(display)} ${unit}`;
+        }
+        let display = value;
+        let unit = 'ns';
+        for (const { unit: u, factor } of units) {
+            const candidate = value / factor;
+            if (candidate < 1000) {
+                display = candidate;
+                unit = u;
+                break;
+            }
+        }
+        return `${smartFixed(display)} ${unit}${uncertainty}`;
+    }
+}
+const SQRT_SCALE = 1000000n;
+const SQRT_SCALE_SQ = SQRT_SCALE * SQRT_SCALE;
+const Z95_NUM = 196n;
+const Z95_DENOM = 100n;
+export const computeStats = (durations) => {
+    let sum = 0n;
+    for (const d of durations)
+        sum += d;
+    const n = BigInt(durations.length);
+    const mean = sum / n;
+    let ssd = 0n;
+    for (const d of durations) {
+        const diff = d - mean;
+        ssd += diff * diff;
+    }
+    return { sum, mean, ssd, n };
+};
+export const createReport = (durations, type, stats) => {
+    const n = durations.length;
+    if (n === 0) {
+        return new Report(type, 0n);
+    }
+    const st = stats ?? computeStats(durations);
+    switch (type) {
+        case 'min': {
+            return new Report(type, durations[0], 0, DURATION_SCALE);
+        }
+        case 'max': {
+            return new Report(type, durations[n - 1], 0, DURATION_SCALE);
+        }
+        case 'median': {
+            const mid = Math.floor(n / 2);
+            const med = n % 2 === 0 ? (durations[mid - 1] + durations[mid]) / 2n : durations[mid];
+            return new Report(type, med, 0, DURATION_SCALE);
+        }
+        case 'mode': {
+            const freq = new Map();
+            let maxCount = 0n;
+            let modeVal = durations[0];
+            for (const d of durations) {
+                const count = (freq.get(d) || 0n) + 1n;
+                freq.set(d, count);
+                if (count > maxCount) {
+                    maxCount = count;
+                    modeVal = d;
+                }
+            }
+            let lower = modeVal;
+            let upper = modeVal;
+            const firstIdx = durations.indexOf(modeVal);
+            const lastIdx = durations.lastIndexOf(modeVal);
+            if (firstIdx > 0)
+                lower = durations[firstIdx - 1];
+            if (lastIdx < n - 1)
+                upper = durations[lastIdx + 1];
+            const gap = max(modeVal - lower, upper - modeVal);
+            const uncertainty = modeVal > 0 ? Number(((gap / 2n) * 100n) / modeVal) : 0;
+            return new Report(type, modeVal, uncertainty, DURATION_SCALE);
+        }
+        case 'ops': {
+            const { mean: avgScaled, ssd, n: nBig } = st;
+            const nsPerSecScaled = 1000000000n * DURATION_SCALE;
+            const raw = Number(nsPerSecScaled) / Number(avgScaled);
+            const extra = raw < 1 ? Math.ceil(-Math.log10(raw)) : 0;
+            const exp = raw > 100 ? 0 : 2 + extra;
+            const scale = 10n ** BigInt(exp);
+            const value = avgScaled > 0n ? (nsPerSecScaled * scale) / avgScaled : 0n;
+            let uncertainty = 0;
+            if (n >= 2 && avgScaled > 0n) {
+                const RME_PRECISION = 1000000n;
+                const semOverMeanSqScaled = (ssd * RME_PRECISION * RME_PRECISION) / (BigInt(n - 1) * nBig * avgScaled * avgScaled);
+                const semOverMeanScaled = isqrt(semOverMeanSqScaled);
+                uncertainty = Number(Z95_NUM * semOverMeanScaled) / Number(RME_PRECISION);
+            }
+            return new Report(type, value, uncertainty, scale);
+        }
+        case 'mean': {
+            const { sum } = st;
+            const value = divs(sum, BigInt(n), 1n);
+            return new Report(type, value, 0, DURATION_SCALE);
+        }
+        case 'variance': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE * DURATION_SCALE);
+            const { ssd } = st;
+            const variance = ssd / BigInt(n - 1);
+            return new Report(type, variance, 0, DURATION_SCALE * DURATION_SCALE);
+        }
+        case 'sd': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd } = st;
+            const scaledVariance = (ssd * SQRT_SCALE_SQ) / BigInt(n - 1);
+            const sdScaled = isqrt(scaledVariance);
+            return new Report(type, sdScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'sem': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            return new Report(type, semScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'moe': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            return new Report(type, moeScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'rme': {
+            if (n < 2)
+                return new Report(type, 0n);
+            const { mean, ssd, n: nBig } = st;
+            if (mean === 0n)
+                return new Report(type, 0n);
+            const RME_PRECISION = 1000000n;
+            const semOverMeanSqScaled = (ssd * RME_PRECISION * RME_PRECISION) / (BigInt(n - 1) * nBig * mean * mean);
+            const semOverMeanScaled = isqrt(semOverMeanSqScaled);
+            const rmeScaled = (Z95_NUM * semOverMeanScaled * 100n) / RME_PRECISION;
+            return new Report(type, rmeScaled, 0, 100n);
+        }
+        case 'mad': {
+            const medianIdx = Math.floor(n / 2);
+            const median = n % 2 === 1 ? durations[medianIdx] : (durations[medianIdx - 1] + durations[medianIdx]) / 2n;
+            const deviations = new BigUint64Array(n);
+            for (let i = 0; i < n; i++) {
+                const diff = durations[i] > median ? durations[i] - median : median - durations[i];
+                deviations[i] = diff;
+            }
+            deviations.sort();
+            const madIdx = Math.floor(n / 2);
+            const mad = n % 2 === 1 ? deviations[madIdx] : (deviations[madIdx - 1] + deviations[madIdx]) / 2n;
+            return new Report(type, mad, 0, DURATION_SCALE);
+        }
+        case 'iqr': {
+            const q1Idx = Math.floor(n * 0.25);
+            const q3Idx = Math.floor(n * 0.75);
+            const q1 = durations[q1Idx];
+            const q3 = durations[q3Idx];
+            const iqr = q3 - q1;
+            return new Report(type, iqr, 0, DURATION_SCALE);
+        }
+        case 'ci_lower': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { mean, ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            const ciLowerScaled = mean * SQRT_SCALE - moeScaled;
+            return new Report(type, ciLowerScaled > 0n ? ciLowerScaled : 0n, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        case 'ci_upper': {
+            if (n < 2)
+                return new Report(type, 0n, 0, DURATION_SCALE);
+            const { mean, ssd, n: nBig } = st;
+            const semSqScaled = (ssd * SQRT_SCALE_SQ) / (BigInt(n - 1) * nBig);
+            const semScaled = isqrt(semSqScaled);
+            const moeScaled = (Z95_NUM * semScaled) / Z95_DENOM;
+            const ciUpperScaled = mean * SQRT_SCALE + moeScaled;
+            return new Report(type, ciUpperScaled, 0, DURATION_SCALE * SQRT_SCALE);
+        }
+        default: {
+            const p = Number(type.slice(1));
+            if (p === 0) {
+                return new Report(type, durations[0], 0, DURATION_SCALE);
+            }
+            if (p === 100) {
+                return new Report(type, durations[n - 1], 0, DURATION_SCALE);
+            }
+            const idx = Math.ceil((p / 100) * n) - 1;
+            const value = durations[Math.min(Math.max(idx, 0), n - 1)];
+            const prev = idx > 0 ? durations[idx - 1] : value;
+            const next = idx < n - 1 ? durations[idx + 1] : value;
+            const gap = max(value - prev, next - value);
+            const uncertainty = value > 0 ? Number(div(divs(gap, 2n, 10000n), value)) / 100 : 0;
+            return new Report(type, value, uncertainty, DURATION_SCALE);
+        }
+    }
+};

package/build/runner.d.ts

@@ -1,2 +1,2 @@
-import { type Options } from './types.ts';
+import { type Options } from './types.js';
 export declare const benchmark: <TContext, TInput>({ setup, teardown, pre, run: runRaw, post, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver, durationsSAB, controlSAB, }: Required<Options<TContext, TInput>>) => Promise<number>;