@fuzdev/fuz_util 0.42.0 → 0.44.0

package/dist/benchmark.js

@@ -0,0 +1,400 @@
+/**
+ * Benchmarking library.
+ *
+ * @example
+ * ```ts
+ * import {Benchmark} from './benchmark.js';
+ *
+ * const bench = new Benchmark({
+ *   duration_ms: 5000,
+ *   warmup_iterations: 5,
+ * });
+ *
+ * bench
+ *   .add('slugify', () => slugify(title))
+ *   .add('slugify_slower', () => slugify_slower(title));
+ *
+ * const results = await bench.run();
+ * console.log(bench.table());
+ * ```
+ */
+import { is_promise, wait } from './async.js';
+import { BenchmarkStats } from './benchmark_stats.js';
+import { timer_default, time_unit_detect_best, time_format } from './time.js';
+import { benchmark_format_table, benchmark_format_table_grouped, benchmark_format_markdown, benchmark_format_json, benchmark_format_number, } from './benchmark_format.js';
+// Default configuration values
+const DEFAULT_DURATION_MS = 1000;
+const DEFAULT_WARMUP_ITERATIONS = 10;
+const DEFAULT_COOLDOWN_MS = 100;
+const DEFAULT_MIN_ITERATIONS = 10;
+const DEFAULT_MAX_ITERATIONS = 100_000;
+/**
+ * Validate and normalize benchmark configuration.
+ * Throws if configuration is invalid.
+ */
+const validate_config = (config) => {
+    if (config.duration_ms !== undefined && config.duration_ms <= 0) {
+        throw new Error(`duration_ms must be positive, got ${config.duration_ms}`);
+    }
+    if (config.warmup_iterations !== undefined && config.warmup_iterations < 0) {
+        throw new Error(`warmup_iterations must be non-negative, got ${config.warmup_iterations}`);
+    }
+    if (config.cooldown_ms !== undefined && config.cooldown_ms < 0) {
+        throw new Error(`cooldown_ms must be non-negative, got ${config.cooldown_ms}`);
+    }
+    if (config.min_iterations !== undefined && config.min_iterations < 1) {
+        throw new Error(`min_iterations must be at least 1, got ${config.min_iterations}`);
+    }
+    if (config.max_iterations !== undefined && config.max_iterations < 1) {
+        throw new Error(`max_iterations must be at least 1, got ${config.max_iterations}`);
+    }
+    if (config.min_iterations !== undefined &&
+        config.max_iterations !== undefined &&
+        config.min_iterations > config.max_iterations) {
+        throw new Error(`min_iterations (${config.min_iterations}) cannot exceed max_iterations (${config.max_iterations})`);
+    }
+};
+/**
+ * Warmup function by running it multiple times.
+ * Detects whether the function is async based on return value.
+ *
+ * @param fn - Function to warmup (sync or async)
+ * @param iterations - Number of warmup iterations
+ * @param async_hint - If provided, use this instead of detecting
+ * @returns Whether the function is async
+ *
+ * @example
+ * ```ts
+ * const is_async = await benchmark_warmup(() => expensive_operation(), 10);
+ * ```
+ */
+export const benchmark_warmup = async (fn, iterations, async_hint) => {
+    // If we have an explicit hint, use it
+    if (async_hint !== undefined) {
+        // Still run warmup iterations for JIT
+        for (let i = 0; i < iterations; i++) {
+            const result = fn();
+            if (async_hint && is_promise(result)) {
+                await result; // eslint-disable-line no-await-in-loop
+            }
+        }
+        return async_hint;
+    }
+    // Detect on first iteration
+    let detected_async = false;
+    for (let i = 0; i < iterations; i++) {
+        const result = fn();
+        if (i === 0) {
+            detected_async = is_promise(result);
+        }
+        if (detected_async && is_promise(result)) {
+            await result; // eslint-disable-line no-await-in-loop
+        }
+    }
+    return detected_async;
+};
+/**
+ * Benchmark class for measuring and comparing function performance.
+ */
+export class Benchmark {
+    #config;
+    #tasks = [];
+    #results = [];
+    constructor(config = {}) {
+        validate_config(config);
+        this.#config = {
+            duration_ms: config.duration_ms ?? DEFAULT_DURATION_MS,
+            warmup_iterations: config.warmup_iterations ?? DEFAULT_WARMUP_ITERATIONS,
+            cooldown_ms: config.cooldown_ms ?? DEFAULT_COOLDOWN_MS,
+            min_iterations: config.min_iterations ?? DEFAULT_MIN_ITERATIONS,
+            max_iterations: config.max_iterations ?? DEFAULT_MAX_ITERATIONS,
+            timer: config.timer ?? timer_default,
+            on_iteration: config.on_iteration,
+            on_task_complete: config.on_task_complete,
+        };
+    }
+    add(name_or_task, fn) {
+        const task_name = typeof name_or_task === 'string' ? name_or_task : name_or_task.name;
+        // Validate unique task names
+        if (this.#tasks.some((t) => t.name === task_name)) {
+            throw new Error(`Task "${task_name}" already exists`);
+        }
+        if (typeof name_or_task === 'string') {
+            if (!fn)
+                throw new Error('Function required when name is string');
+            this.#tasks.push({ name: name_or_task, fn });
+        }
+        else {
+            this.#tasks.push(name_or_task);
+        }
+        return this;
+    }
+    /**
+     * Remove a benchmark task by name.
+     * @param name - Name of the task to remove
+     * @returns This Benchmark instance for chaining
+     * @throws Error if task with given name doesn't exist
+     *
+     * @example
+     * ```ts
+     * bench.add('task1', () => fn1());
+     * bench.add('task2', () => fn2());
+     * bench.remove('task1');
+     * // Only task2 remains
+     * ```
+     */
+    remove(name) {
+        const index = this.#tasks.findIndex((t) => t.name === name);
+        if (index === -1) {
+            throw new Error(`Task "${name}" not found`);
+        }
+        this.#tasks.splice(index, 1);
+        return this;
+    }
+    /**
+     * Mark a task to be skipped during benchmark runs.
+     * @param name - Name of the task to skip
+     * @returns This Benchmark instance for chaining
+     * @throws Error if task with given name doesn't exist
+     *
+     * @example
+     * ```ts
+     * bench.add('task1', () => fn1());
+     * bench.add('task2', () => fn2());
+     * bench.skip('task1');
+     * // Only task2 will run
+     * ```
+     */
+    skip(name) {
+        const task = this.#tasks.find((t) => t.name === name);
+        if (!task) {
+            throw new Error(`Task "${name}" not found`);
+        }
+        task.skip = true;
+        return this;
+    }
+    /**
+     * Mark a task to run exclusively (along with other `only` tasks).
+     * @param name - Name of the task to run exclusively
+     * @returns This Benchmark instance for chaining
+     * @throws Error if task with given name doesn't exist
+     *
+     * @example
+     * ```ts
+     * bench.add('task1', () => fn1());
+     * bench.add('task2', () => fn2());
+     * bench.add('task3', () => fn3());
+     * bench.only('task2');
+     * // Only task2 will run
+     * ```
+     */
+    only(name) {
+        const task = this.#tasks.find((t) => t.name === name);
+        if (!task) {
+            throw new Error(`Task "${name}" not found`);
+        }
+        task.only = true;
+        return this;
+    }
+    /**
+     * Run all benchmark tasks.
+     * @returns Array of benchmark results
+     */
+    async run() {
+        this.#results = [];
+        // Determine which tasks to run
+        const has_only = this.#tasks.some((t) => t.only);
+        const tasks_to_run = this.#tasks.filter((t) => {
+            if (t.skip)
+                return false;
+            if (has_only)
+                return t.only;
+            return true;
+        });
+        for (let i = 0; i < tasks_to_run.length; i++) {
+            const task = tasks_to_run[i];
+            const result = await this.#run_task(task); // eslint-disable-line no-await-in-loop
+            this.#results.push(result);
+            // Call on_task_complete callback
+            this.#config.on_task_complete?.(result, i, tasks_to_run.length);
+            // Cooldown between tasks (skip after last task)
+            if (this.#config.cooldown_ms > 0 && i < tasks_to_run.length - 1) {
+                await wait(this.#config.cooldown_ms); // eslint-disable-line no-await-in-loop
+            }
+        }
+        return this.#results;
+    }
+    /**
+     * Run a single benchmark task.
+     * Throws if the task fails during setup, warmup, or measurement.
+     */
+    async #run_task(task) {
+        const suite_start_ns = this.#config.timer.now();
+        // Pre-allocate array to avoid GC pressure during measurement
+        const max_iterations = this.#config.max_iterations;
+        const timings_ns = new Array(max_iterations);
+        let timing_count = 0;
+        try {
+            // Setup
+            if (task.setup) {
+                await task.setup();
+            }
+            // Warmup and detect async
+            const is_async = await benchmark_warmup(task.fn, this.#config.warmup_iterations, task.async);
+            task.is_async = is_async;
+            // Measurement phase
+            const target_time_ns = this.#config.duration_ms * 1_000_000; // Convert ms to ns
+            const min_iterations = this.#config.min_iterations;
+            let aborted = false;
+            const abort = () => {
+                aborted = true;
+            };
+            const measurement_start_ns = this.#config.timer.now();
+            // Use separate code paths for sync vs async for better performance
+            if (is_async) {
+                // Async code path - await each iteration
+                // eslint-disable-next-line no-unmodified-loop-condition
+                while (timing_count < max_iterations && !aborted) {
+                    const iter_start_ns = this.#config.timer.now();
+                    await task.fn(); // eslint-disable-line no-await-in-loop
+                    const iter_end_ns = this.#config.timer.now();
+                    timings_ns[timing_count++] = iter_end_ns - iter_start_ns;
+                    this.#config.on_iteration?.(task.name, timing_count, abort);
+                    const total_elapsed_ns = iter_end_ns - measurement_start_ns;
+                    if (timing_count >= min_iterations && total_elapsed_ns >= target_time_ns) {
+                        break;
+                    }
+                }
+            }
+            else {
+                // Sync code path - no promise checking overhead
+                // eslint-disable-next-line no-unmodified-loop-condition
+                while (timing_count < max_iterations && !aborted) {
+                    const iter_start_ns = this.#config.timer.now();
+                    task.fn();
+                    const iter_end_ns = this.#config.timer.now();
+                    timings_ns[timing_count++] = iter_end_ns - iter_start_ns;
+                    this.#config.on_iteration?.(task.name, timing_count, abort);
+                    const total_elapsed_ns = iter_end_ns - measurement_start_ns;
+                    if (timing_count >= min_iterations && total_elapsed_ns >= target_time_ns) {
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            // Always run teardown
+            if (task.teardown) {
+                await task.teardown();
+            }
+        }
+        // Trim array to actual size
+        timings_ns.length = timing_count;
+        const suite_end_ns = this.#config.timer.now();
+        const total_time_ms = (suite_end_ns - suite_start_ns) / 1_000_000; // Convert back to ms for display
+        // Analyze results
+        const stats = new BenchmarkStats(timings_ns);
+        return {
+            name: task.name,
+            stats,
+            iterations: timing_count,
+            total_time_ms,
+            timings_ns,
+        };
+    }
+    /**
+     * Format results as an ASCII table with percentiles, min/max, and relative performance.
+     * @param options - Formatting options
+     * @returns Formatted table string
+     *
+     * @example
+     * ```ts
+     * // Standard table
+     * console.log(bench.table());
+     *
+     * // Grouped by category
+     * console.log(bench.table({
+     *   groups: [
+     *     { name: 'FAST PATHS', filter: (r) => r.name.includes('fast') },
+     *     { name: 'SLOW PATHS', filter: (r) => r.name.includes('slow') },
+     *   ]
+     * }));
+     * ```
+     */
+    table(options) {
+        return options?.groups
+            ? benchmark_format_table_grouped(this.#results, options.groups)
+            : benchmark_format_table(this.#results);
+    }
+    /**
+     * Format results as a Markdown table.
+     * @returns Formatted markdown string
+     */
+    markdown() {
+        return benchmark_format_markdown(this.#results);
+    }
+    /**
+     * Format results as JSON.
+     * @param options - Formatting options (pretty, include_timings)
+     * @returns JSON string
+     */
+    json(options) {
+        return benchmark_format_json(this.#results, options);
+    }
+    /**
+     * Get the benchmark results.
+     * Returns a shallow copy to prevent external mutation.
+     * @returns Array of benchmark results
+     */
+    results() {
+        return [...this.#results];
+    }
+    /**
+     * Reset the benchmark results.
+     * Keeps tasks intact so benchmarks can be rerun.
+     * @returns This Benchmark instance for chaining
+     */
+    reset() {
+        this.#results = [];
+        return this;
+    }
+    /**
+     * Clear everything (results and tasks).
+     * Use this to start fresh with a new set of benchmarks.
+     * @returns This Benchmark instance for chaining
+     */
+    clear() {
+        this.#results = [];
+        this.#tasks.length = 0;
+        return this;
+    }
+    /**
+     * Get a quick text summary of the fastest task.
+     * @returns Human-readable summary string
+     *
+     * @example
+     * ```ts
+     * console.log(bench.summary());
+     * // "Fastest: slugify_v2 (1,285,515.00 ops/sec, 786.52ns per op)"
+     * // "Slowest: slugify (252,955.00 ops/sec, 3.95μs per op)"
+     * // "Speed difference: 5.08x"
+     * ```
+     */
+    summary() {
+        if (this.#results.length === 0)
+            return 'No results';
+        const fastest = this.#results.reduce((a, b) => a.stats.ops_per_second > b.stats.ops_per_second ? a : b);
+        const slowest = this.#results.reduce((a, b) => a.stats.ops_per_second < b.stats.ops_per_second ? a : b);
+        const ratio = fastest.stats.ops_per_second / slowest.stats.ops_per_second;
+        // Detect best unit for consistent display
+        const mean_times = this.#results.map((r) => r.stats.mean_ns);
+        const unit = time_unit_detect_best(mean_times);
+        const lines = [];
+        lines.push(`Fastest: ${fastest.name} (${benchmark_format_number(fastest.stats.ops_per_second)} ops/sec, ${time_format(fastest.stats.mean_ns, unit)} per op)`);
+        if (this.#results.length > 1) {
+            lines.push(`Slowest: ${slowest.name} (${benchmark_format_number(slowest.stats.ops_per_second)} ops/sec, ${time_format(slowest.stats.mean_ns, unit)} per op)`);
+            lines.push(`Speed difference: ${ratio.toFixed(2)}x`);
+        }
+        return lines.join('\n');
+    }
+}

package/dist/benchmark_baseline.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Benchmark baseline storage and comparison utilities.
+ * Save benchmark results to disk and compare against baselines for regression detection.
+ */
+import { z } from 'zod';
+import type { BenchmarkResult } from './benchmark_types.js';
+import { type BenchmarkComparison } from './benchmark_stats.js';
+/**
+ * Schema for a single benchmark entry in the baseline.
+ */
+export declare const BenchmarkBaselineEntry: z.ZodObject<{
+    name: z.ZodString;
+    mean_ns: z.ZodNumber;
+    median_ns: z.ZodNumber;
+    std_dev_ns: z.ZodNumber;
+    min_ns: z.ZodNumber;
+    max_ns: z.ZodNumber;
+    p75_ns: z.ZodNumber;
+    p90_ns: z.ZodNumber;
+    p95_ns: z.ZodNumber;
+    p99_ns: z.ZodNumber;
+    ops_per_second: z.ZodNumber;
+    sample_size: z.ZodNumber;
+}, z.core.$strip>;
+export type BenchmarkBaselineEntry = z.infer<typeof BenchmarkBaselineEntry>;
+/**
+ * Schema for the complete baseline file.
+ */
+export declare const BenchmarkBaseline: z.ZodObject<{
+    version: z.ZodNumber;
+    timestamp: z.ZodString;
+    git_commit: z.ZodNullable<z.ZodString>;
+    git_branch: z.ZodNullable<z.ZodString>;
+    node_version: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        mean_ns: z.ZodNumber;
+        median_ns: z.ZodNumber;
+        std_dev_ns: z.ZodNumber;
+        min_ns: z.ZodNumber;
+        max_ns: z.ZodNumber;
+        p75_ns: z.ZodNumber;
+        p90_ns: z.ZodNumber;
+        p95_ns: z.ZodNumber;
+        p99_ns: z.ZodNumber;
+        ops_per_second: z.ZodNumber;
+        sample_size: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BenchmarkBaseline = z.infer<typeof BenchmarkBaseline>;
+/**
+ * Options for saving a baseline.
+ */
+export interface BenchmarkBaselineSaveOptions {
+    /** Directory to store baselines (default: '.gro/benchmarks') */
+    path?: string;
+    /** Git commit hash (auto-detected if not provided) */
+    git_commit?: string | null;
+    /** Git branch name (auto-detected if not provided) */
+    git_branch?: string | null;
+}
+/**
+ * Options for loading a baseline.
+ */
+export interface BenchmarkBaselineLoadOptions {
+    /** Directory to load baseline from (default: '.gro/benchmarks') */
+    path?: string;
+}
+/**
+ * Options for comparing against a baseline.
+ */
+export interface BenchmarkBaselineCompareOptions extends BenchmarkBaselineLoadOptions {
+    /**
+     * Minimum speedup ratio to consider a regression.
+     * For example, 1.05 means only flag regressions that are 5% or more slower.
+     * Default: 1.0 (any statistically significant slowdown is a regression)
+     */
+    regression_threshold?: number;
+    /**
+     * Number of days after which to warn about stale baseline.
+     * Default: undefined (no staleness warning)
+     */
+    staleness_warning_days?: number;
+}
+/**
+ * Result of comparing current results against a baseline.
+ */
+export interface BenchmarkBaselineComparisonResult {
+    /** Whether a baseline was found */
+    baseline_found: boolean;
+    /** Timestamp of the baseline */
+    baseline_timestamp: string | null;
+    /** Git commit of the baseline */
+    baseline_commit: string | null;
+    /** Age of the baseline in days */
+    baseline_age_days: number | null;
+    /** Whether the baseline is considered stale based on staleness_warning_days option */
+    baseline_stale: boolean;
+    /** Individual task comparisons */
+    comparisons: Array<BenchmarkBaselineTaskComparison>;
+    /** Tasks that regressed (slower with statistical significance), sorted by effect size (largest first) */
+    regressions: Array<BenchmarkBaselineTaskComparison>;
+    /** Tasks that improved (faster with statistical significance), sorted by effect size (largest first) */
+    improvements: Array<BenchmarkBaselineTaskComparison>;
+    /** Tasks with no significant change */
+    unchanged: Array<BenchmarkBaselineTaskComparison>;
+    /** Tasks in current run but not in baseline */
+    new_tasks: Array<string>;
+    /** Tasks in baseline but not in current run */
+    removed_tasks: Array<string>;
+}
+/**
+ * Comparison result for a single task.
+ */
+export interface BenchmarkBaselineTaskComparison {
+    name: string;
+    baseline: BenchmarkBaselineEntry;
+    current: BenchmarkBaselineEntry;
+    comparison: BenchmarkComparison;
+}
+/**
+ * Save benchmark results as the current baseline.
+ *
+ * @param results - Benchmark results to save
+ * @param options - Save options
+ *
+ * @example
+ * ```ts
+ * const bench = new Benchmark();
+ * bench.add('test', () => fn());
+ * await bench.run();
+ * await benchmark_baseline_save(bench.results());
+ * ```
+ */
+export declare const benchmark_baseline_save: (results: Array<BenchmarkResult>, options?: BenchmarkBaselineSaveOptions) => Promise<void>;
+/**
+ * Load the current baseline from disk.
+ *
+ * @param options - Load options
+ * @returns The baseline, or null if not found or invalid
+ *
+ * @example
+ * ```ts
+ * const baseline = await benchmark_baseline_load();
+ * if (baseline) {
+ *   console.log(`Baseline from ${baseline.timestamp}`);
+ * }
+ * ```
+ */
+export declare const benchmark_baseline_load: (options?: BenchmarkBaselineLoadOptions) => Promise<BenchmarkBaseline | null>;
+/**
+ * Compare benchmark results against the stored baseline.
+ *
+ * @param results - Current benchmark results
+ * @param options - Comparison options including regression threshold and staleness warning
+ * @returns Comparison result with regressions, improvements, and unchanged tasks
+ *
+ * @example
+ * ```ts
+ * const bench = new Benchmark();
+ * bench.add('test', () => fn());
+ * await bench.run();
+ *
+ * const comparison = await benchmark_baseline_compare(bench.results(), {
+ *   regression_threshold: 1.05, // Only flag regressions 5% or more slower
+ *   staleness_warning_days: 7,  // Warn if baseline is older than 7 days
+ * });
+ * if (comparison.regressions.length > 0) {
+ *   console.log('Performance regressions detected!');
+ *   for (const r of comparison.regressions) {
+ *     console.log(`  ${r.name}: ${r.comparison.speedup_ratio.toFixed(2)}x slower`);
+ *   }
+ *   process.exit(1);
+ * }
+ * ```
+ */
+export declare const benchmark_baseline_compare: (results: Array<BenchmarkResult>, options?: BenchmarkBaselineCompareOptions) => Promise<BenchmarkBaselineComparisonResult>;
+/**
+ * Format a baseline comparison result as a human-readable string.
+ *
+ * @param result - Comparison result from benchmark_baseline_compare
+ * @returns Formatted string summary
+ */
+export declare const benchmark_baseline_format: (result: BenchmarkBaselineComparisonResult) => string;
+/**
+ * Format a baseline comparison result as JSON for programmatic consumption.
+ *
+ * @param result - Comparison result from benchmark_baseline_compare
+ * @param options - Formatting options
+ * @returns JSON string
+ */
+export declare const benchmark_baseline_format_json: (result: BenchmarkBaselineComparisonResult, options?: {
+    pretty?: boolean;
+}) => string;
+//# sourceMappingURL=benchmark_baseline.d.ts.map

package/dist/benchmark_baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark_baseline.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/benchmark_baseline.ts"],"names":[],"mappings":"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"}