overtake 2.0.0 → 2.0.1

package/bin/overtake.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env -S node --experimental-vm-modules --no-warnings --expose-gc
-import '../src/cli.ts';
+import '../build/cli.js';

package/build/cli.js

@@ -0,0 +1,135 @@
+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, version, description } = require('../package.json');
+const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
+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);
+    }
+    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');
+            }
+            instance = Benchmark.create(...args);
+            return instance;
+        };
+        await import(identifier);
+        if (instance) {
+            const reports = await instance.execute({
+                ...executeOptions,
+                [BENCHMARK_URL]: identifier,
+            });
+            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);
+                }
+            }
+        }
+    }
+}

package/build/executor.d.ts

@@ -1,5 +1,5 @@
-import { Report } from './reporter.ts';
-import { type ExecutorRunOptions, type ReportOptions, type BenchmarkOptions, type ReportTypeList, type ProgressCallback } from './types.ts';
+import { Report } from './reporter.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;

package/build/executor.js

@@ -0,0 +1,126 @@
+import { Worker } from 'node:worker_threads';
+import { once } from 'node:events';
+import { pathToFileURL } from 'node:url';
+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) => {
+    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 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');
+        assertNoClosure(runCode, 'run');
+        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);
+        const workerData = {
+            benchmarkUrl: resolvedBenchmarkUrl,
+            setupCode,
+            teardownCode,
+            preCode,
+            runCode,
+            postCode,
+            data,
+            warmupCycles,
+            minCycles,
+            absThreshold,
+            relThreshold,
+            gcObserver,
+            controlSAB,
+            durationsSAB,
+        };
+        const worker = new Worker(workerFile, {
+            workerData,
+        });
+        const control = new Int32Array(controlSAB);
+        let progressIntervalId;
+        if (onProgress && id) {
+            progressIntervalId = setInterval(() => {
+                const progress = control[Control.PROGRESS] / COMPLETE_VALUE;
+                onProgress({ id, progress });
+            }, progressInterval);
+        }
+        const WORKER_TIMEOUT_MS = 300_000;
+        const exitPromise = once(worker, 'exit');
+        const timeoutId = setTimeout(() => worker.terminate(), WORKER_TIMEOUT_MS);
+        let workerError;
+        try {
+            const [exitCode] = await exitPromise;
+            clearTimeout(timeoutId);
+            if (progressIntervalId)
+                clearInterval(progressIntervalId);
+            if (exitCode !== 0) {
+                workerError = `worker exited with code ${exitCode}`;
+            }
+        }
+        catch (err) {
+            clearTimeout(timeoutId);
+            if (progressIntervalId)
+                clearInterval(progressIntervalId);
+            workerError = err instanceof Error ? err.message : String(err);
+        }
+        const count = control[Control.INDEX];
+        const heapUsedKB = control[Control.HEAP_USED];
+        const durations = new BigUint64Array(durationsSAB).slice(0, count).sort(cmp);
+        const DCE_THRESHOLD_OPS = 5_000_000_000;
+        let dceWarning = false;
+        if (count > 0) {
+            let sum = 0n;
+            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 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);
+    };
+    return { pushAsync, kill() { } };
+};

package/build/gc-watcher.js

@@ -0,0 +1,16 @@
+export class GCWatcher {
+    #registry = new FinalizationRegistry(() => { });
+    start() {
+        const target = {};
+        const ref = new WeakRef(target);
+        this.#registry.register(target, null, ref);
+        return { ref };
+    }
+    seen(marker) {
+        const collected = marker.ref.deref() === undefined;
+        if (!collected) {
+            this.#registry.unregister(marker.ref);
+        }
+        return collected;
+    }
+}

package/build/index.d.ts

@@ -1,5 +1,5 @@
-import { type ExecutorOptions, type ExecutorReport } from './executor.ts';
-import { type MaybePromise, type StepFn, type SetupFn, type TeardownFn, type FeedFn, type ReportType, type ReportTypeList } from './types.ts';
+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;
 }

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 {};