benchforge 0.1.1 → 0.1.3

package/dist/index.d.mts

@@ -0,0 +1,711 @@
+import { a as MeasuredResults, i as BenchmarkSpec, n as BenchGroup, r as BenchSuite, t as RunnerOptions } from "./BenchRunner-BLfGX2wQ.mjs";
+import { Alignment } from "table";
+import { Argv, InferredOptionTypes } from "yargs";
+import * as node_http0 from "node:http";
+
+//#region src/BenchMatrix.d.ts
+/** Stateless variant - called each iteration with case data */
+type VariantFn<T = unknown> = (caseData: T) => void;
+/** Stateful variant - setup once, run many */
+interface StatefulVariant<T = unknown, S = unknown> {
+  setup: (caseData: T) => S | Promise<S>;
+  run: (state: S) => void;
+}
+/** A variant is either a plain function or a stateful setup+run pair */
+type Variant<T = unknown, S = unknown> = VariantFn<T> | StatefulVariant<T, S>;
+/** Variant with any state type - used in BenchMatrix to allow mixed variants */
+type AnyVariant<T = unknown> = VariantFn<T> | StatefulVariant<T, any>;
+/** Result from casesModule.loadCase() */
+interface LoadedCase<T = unknown> {
+  data: T;
+  metadata?: Record<string, unknown>;
+}
+interface MatrixDefaults {
+  warmup?: number;
+  maxTime?: number;
+  iterations?: number;
+}
+/** Bench matrix configuration */
+interface BenchMatrix<T = unknown> {
+  name: string;
+  variantDir?: string;
+  variants?: Record<string, AnyVariant<T>>;
+  cases?: string[];
+  casesModule?: string;
+  baselineDir?: string;
+  baselineVariant?: string;
+  defaults?: MatrixDefaults;
+}
+/** Collection of matrices */
+interface MatrixSuite {
+  name: string;
+  matrices: BenchMatrix<any>[];
+}
+/** Results for a single variant across all cases */
+interface VariantResult {
+  id: string;
+  cases: CaseResult[];
+}
+/** Results for a single (variant, case) pair */
+interface CaseResult {
+  caseId: string;
+  measured: MeasuredResults;
+  metadata?: Record<string, unknown>;
+  baseline?: MeasuredResults;
+  deltaPercent?: number;
+}
+/** Results from running a matrix */
+interface MatrixResults {
+  name: string;
+  variants: VariantResult[];
+}
+/** @return true if variant is a StatefulVariant (has setup + run) */
+declare function isStatefulVariant<T, S>(v: Variant<T, S>): v is StatefulVariant<T, S>;
+/** Options for runMatrix */
+interface RunMatrixOptions {
+  iterations?: number;
+  maxTime?: number;
+  warmup?: number;
+  useWorker?: boolean;
+  filteredCases?: string[];
+  filteredVariants?: string[];
+  collect?: boolean;
+  cpuCounters?: boolean;
+  traceOpt?: boolean;
+  noSettle?: boolean;
+  pauseFirst?: number;
+  pauseInterval?: number;
+  pauseDuration?: number;
+  gcStats?: boolean;
+  heapSample?: boolean;
+  heapInterval?: number;
+  heapDepth?: number;
+}
+/** Run a BenchMatrix with inline variants or variantDir */
+declare function runMatrix<T>(matrix: BenchMatrix<T>, options?: RunMatrixOptions): Promise<MatrixResults>;
+//#endregion
+//#region src/table-util/TableReport.d.ts
+type AnyColumn<T> = Column<T> | DiffColumn<T>;
+/** Column with optional formatter */
+interface Column<T> extends ColumnFormat<T> {
+  formatter?: (value: unknown) => string | null;
+  diffKey?: undefined;
+}
+/** Comparison column against baseline */
+interface DiffColumn<T> extends ColumnFormat<T> {
+  diffFormatter?: (value: unknown, baseline: unknown) => string | null;
+  formatter?: undefined;
+  /** Key for comparison value against baseline */
+  diffKey: keyof T;
+}
+interface ColumnFormat<T> {
+  key: keyof T;
+  title: string;
+  alignment?: Alignment;
+  width?: number;
+}
+/** Table headers and configuration */
+//#endregion
+//#region src/BenchmarkReport.d.ts
+/** Benchmark results with optional baseline for comparison */
+interface ReportGroup {
+  name: string;
+  reports: BenchmarkReport[];
+  baseline?: BenchmarkReport;
+}
+/** Results from a single benchmark run */
+interface BenchmarkReport {
+  name: string;
+  measuredResults: MeasuredResults;
+  metadata?: UnknownRecord;
+}
+interface ReportColumnGroup<T> {
+  groupTitle?: string;
+  columns: ReportColumn<T>[];
+}
+type ReportColumn<T> = AnyColumn<T> & {
+  /** Add diff column after this column when baseline exists */comparable?: boolean; /** Set true for throughput metrics where higher values are better (e.g., lines/sec) */
+  higherIsBetter?: boolean;
+};
+/** Maps benchmark results to table columns */
+interface ResultsMapper<T extends Record<string, any> = Record<string, any>> {
+  extract(results: MeasuredResults, metadata?: UnknownRecord): T;
+  columns(): ReportColumnGroup<T>[];
+}
+type UnknownRecord = Record<string, unknown>;
+/** @return formatted table report with optional baseline comparisons */
+declare function reportResults<S extends ReadonlyArray<ResultsMapper<any>>>(groups: ReportGroup[], sections: S): string;
+//#endregion
+//#region src/cli/CliArgs.d.ts
+type Configure<T> = (yargs: Argv) => Argv<T>;
+/** CLI args type inferred from cliOptions */
+type DefaultCliArgs = InferredOptionTypes<typeof cliOptions>;
+declare const cliOptions: {
+  readonly time: {
+    readonly type: "number";
+    readonly default: 0.642;
+    readonly requiresArg: true;
+    readonly describe: "test duration in seconds";
+  };
+  readonly cpu: {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "CPU counter measurements (requires root)";
+  };
+  readonly collect: {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "force GC after each iteration";
+  };
+  readonly "gc-stats": {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "collect GC statistics (Node: --trace-gc-nvp, browser: CDP tracing)";
+  };
+  readonly profile: {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "run once for profiling";
+  };
+  readonly filter: {
+    readonly type: "string";
+    readonly requiresArg: true;
+    readonly describe: "filter benchmarks by regex or substring";
+  };
+  readonly all: {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "run all cases (ignore defaultCases)";
+  };
+  readonly worker: {
+    readonly type: "boolean";
+    readonly default: true;
+    readonly describe: "run in worker process for isolation (default: true)";
+  };
+  readonly adaptive: {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "adaptive sampling (experimental)";
+  };
+  readonly "min-time": {
+    readonly type: "number";
+    readonly default: 1;
+    readonly describe: "minimum time before adaptive convergence can stop";
+  };
+  readonly convergence: {
+    readonly type: "number";
+    readonly default: 95;
+    readonly describe: "adaptive confidence threshold (0-100)";
+  };
+  readonly warmup: {
+    readonly type: "number";
+    readonly default: 0;
+    readonly describe: "warmup iterations before measurement";
+  };
+  readonly html: {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "generate HTML report and open in browser";
+  };
+  readonly "export-html": {
+    readonly type: "string";
+    readonly requiresArg: true;
+    readonly describe: "export HTML report to specified file";
+  };
+  readonly json: {
+    readonly type: "string";
+    readonly requiresArg: true;
+    readonly describe: "export benchmark data to JSON file";
+  };
+  readonly perfetto: {
+    readonly type: "string";
+    readonly requiresArg: true;
+    readonly describe: "export Perfetto trace file (view at ui.perfetto.dev)";
+  };
+  readonly "trace-opt": {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "trace V8 optimization tiers (requires --allow-natives-syntax)";
+  };
+  readonly "skip-settle": {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "skip post-warmup settle time (see V8 optimization cold start)";
+  };
+  readonly "pause-first": {
+    readonly type: "number";
+    readonly describe: "iterations before first pause (then pause-interval applies)";
+  };
+  readonly "pause-interval": {
+    readonly type: "number";
+    readonly default: 0;
+    readonly describe: "iterations between pauses for V8 optimization (0 to disable)";
+  };
+  readonly "pause-duration": {
+    readonly type: "number";
+    readonly default: 100;
+    readonly describe: "pause duration in ms for V8 optimization";
+  };
+  readonly batches: {
+    readonly type: "number";
+    readonly default: 1;
+    readonly describe: "divide time into N batches, alternating baseline/current order";
+  };
+  readonly iterations: {
+    readonly type: "number";
+    readonly requiresArg: true;
+    readonly describe: "exact number of iterations (overrides --time)";
+  };
+  readonly "heap-sample": {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "heap sampling allocation attribution (includes garbage)";
+  };
+  readonly "heap-interval": {
+    readonly type: "number";
+    readonly default: 32768;
+    readonly describe: "heap sampling interval in bytes";
+  };
+  readonly "heap-depth": {
+    readonly type: "number";
+    readonly default: 64;
+    readonly describe: "heap sampling stack depth";
+  };
+  readonly "heap-rows": {
+    readonly type: "number";
+    readonly default: 20;
+    readonly describe: "top allocation sites to show";
+  };
+  readonly "heap-stack": {
+    readonly type: "number";
+    readonly default: 3;
+    readonly describe: "call stack depth to display";
+  };
+  readonly "heap-verbose": {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "verbose output with file:// paths and line numbers";
+  };
+  readonly "heap-user-only": {
+    readonly type: "boolean";
+    readonly default: false;
+    readonly describe: "filter to user code only (hide node internals)";
+  };
+  readonly url: {
+    readonly type: "string";
+    readonly requiresArg: true;
+    readonly describe: "page URL for browser profiling (enables browser mode)";
+  };
+  readonly headless: {
+    readonly type: "boolean";
+    readonly default: true;
+    readonly describe: "run browser in headless mode";
+  };
+  readonly timeout: {
+    readonly type: "number";
+    readonly default: 60;
+    readonly describe: "browser page timeout in seconds";
+  };
+  readonly "chrome-args": {
+    readonly type: "string";
+    readonly requiresArg: true;
+    readonly describe: "extra Chromium flags (space-separated)";
+  };
+};
+/** @return yargs with standard benchmark options */
+declare function defaultCliArgs(yargsInstance: Argv): Argv<DefaultCliArgs>;
+/** @return parsed command line arguments */
+declare function parseCliArgs<T = DefaultCliArgs>(args: string[], configure?: Configure<T>): T;
+//#endregion
+//#region src/html/Types.d.ts
+/** Data passed to the HTML report generator */
+interface ReportData {
+  groups: GroupData[];
+  metadata: {
+    timestamp: string;
+    bencherVersion: string;
+    cliArgs?: Record<string, unknown>;
+    gcTrackingEnabled?: boolean;
+    currentVersion?: GitVersion;
+    baselineVersion?: GitVersion;
+  };
+}
+interface GroupData {
+  name: string;
+  baseline?: BenchmarkData;
+  benchmarks: BenchmarkData[];
+}
+interface BenchmarkData {
+  name: string;
+  samples: number[];
+  warmupSamples?: number[];
+  allocationSamples?: number[];
+  heapSamples?: number[];
+  gcEvents?: GcEvent[];
+  optSamples?: number[];
+  pausePoints?: PausePoint[];
+  stats: {
+    min: number;
+    max: number;
+    avg: number;
+    p50: number;
+    p75: number;
+    p99: number;
+    p999: number;
+  };
+  heapSize?: {
+    min: number;
+    max: number;
+    avg: number;
+  };
+  sectionStats?: FormattedStat[];
+  comparisonCI?: DifferenceCI;
+}
+interface FormattedStat {
+  label: string;
+  value: string;
+  groupTitle?: string;
+}
+interface GcEvent {
+  offset: number;
+  duration: number;
+}
+interface PausePoint {
+  sampleIndex: number;
+  durationMs: number;
+}
+interface GitVersion {
+  hash: string;
+  date: string;
+  dirty?: boolean;
+}
+type CIDirection = "faster" | "slower" | "uncertain";
+interface HistogramBin {
+  x: number;
+  count: number;
+}
+interface DifferenceCI {
+  percent: number;
+  ci: [number, number];
+  direction: CIDirection;
+  histogram?: HistogramBin[];
+}
+interface HtmlReportOptions {
+  openBrowser: boolean;
+  outputPath?: string;
+}
+interface HtmlReportResult {
+  reportDir: string;
+  server?: node_http0.Server;
+  closeServer?: () => void;
+}
+//#endregion
+//#region src/html/HtmlReport.d.ts
+/** Generate HTML report from prepared data and optionally open in browser */
+declare function generateHtmlReport(data: ReportData, options: HtmlReportOptions): Promise<HtmlReportResult>;
+//#endregion
+//#region src/html/HtmlTemplate.d.ts
+/** Format ISO date as local time with UTC: "Jan 9, 2026, 3:45 PM (2026-01-09T23:45:00Z)" */
+declare function formatDateWithTimezone(isoDate: string): string;
+//#endregion
+//#region src/GitUtils.d.ts
+/** Get current git version info. For dirty repos, uses most recent modified file date. */
+declare function getCurrentGitVersion(): GitVersion | undefined;
+/** Read baseline version from .baseline-version file */
+declare function getBaselineVersion(baselineDir?: string): GitVersion | undefined;
+/** Format git version for display: "abc1234 (Jan 9, 2026, 3:45 PM)" or "abc1234*" if dirty */
+declare function formatGitVersion(version: GitVersion): string;
+//#endregion
+//#region src/heap-sample/HeapSampleReport.d.ts
+interface CallFrame {
+  fn: string;
+  url: string;
+  line: number;
+  col: number;
+}
+type UserCodeFilter = (site: CallFrame) => boolean;
+interface HeapReportOptions {
+  topN: number;
+  stackDepth?: number;
+  verbose?: boolean;
+  userOnly?: boolean;
+  isUserCode?: UserCodeFilter;
+  totalAll?: number;
+  totalUserCode?: number;
+  sampleCount?: number;
+}
+//#endregion
+//#region src/matrix/MatrixReport.d.ts
+/** Custom column definition for extra computed metrics */
+interface ExtraColumn {
+  key: string;
+  title: string;
+  groupTitle?: string;
+  extract: (caseResult: CaseResult) => unknown;
+  formatter?: (value: unknown) => string;
+}
+/** Options for matrix report generation */
+interface MatrixReportOptions {
+  extraColumns?: ExtraColumn[];
+  sections?: ResultsMapper[];
+  variantTitle?: string;
+}
+/** Format matrix results as one table per case */
+declare function reportMatrixResults(results: MatrixResults, options?: MatrixReportOptions): string;
+/** GC statistics columns - derived from gcStatsSection for consistency */
+declare const gcStatsColumns: ExtraColumn[];
+/** GC pause time column */
+declare const gcPauseColumn: ExtraColumn;
+/** Heap sampling total bytes column */
+declare const heapTotalColumn: ExtraColumn;
+//#endregion
+//#region src/cli/RunBenchCLI.d.ts
+/** Parse CLI with custom configuration */
+declare function parseBenchArgs<T = DefaultCliArgs>(configureArgs?: Configure<T>): T & DefaultCliArgs;
+/** Run suite with CLI arguments */
+declare function runBenchmarks(suite: BenchSuite, args: DefaultCliArgs): Promise<ReportGroup[]>;
+/** Generate table with standard sections */
+declare function defaultReport(groups: ReportGroup[], args: DefaultCliArgs): string;
+/** Run benchmarks, display table, and optionally generate HTML report */
+declare function benchExports(suite: BenchSuite, args: DefaultCliArgs): Promise<void>;
+/** Print heap allocation reports for benchmarks with heap profiles */
+declare function printHeapReports(groups: ReportGroup[], options: HeapReportOptions): void;
+/** Run benchmarks and display table. Suite is optional with --url (browser mode). */
+declare function runDefaultBench(suite?: BenchSuite, configureArgs?: Configure<any>): Promise<void>;
+/** Log V8 optimization tier distribution and deoptimizations */
+declare function reportOptStatus(groups: ReportGroup[]): void;
+/** @return true if any result has the specified field with a defined value */
+declare function hasField(results: ReportGroup[], field: keyof MeasuredResults): boolean;
+interface ExportOptions {
+  results: ReportGroup[];
+  args: DefaultCliArgs;
+  sections?: any[];
+  suiteName?: string;
+  currentVersion?: GitVersion;
+  baselineVersion?: GitVersion;
+}
+/** Export reports (HTML, JSON, Perfetto) based on CLI args */
+declare function exportReports(options: ExportOptions): Promise<void>;
+/** Run matrix suite with CLI arguments.
+*  no options ==> defaultCases/defaultVariants, --filter ==> subset of defaults,
+*  --all --filter ==> subset of all, --all ==> all cases/variants */
+declare function runMatrixSuite(suite: MatrixSuite, args: DefaultCliArgs): Promise<MatrixResults[]>;
+/** Convert CLI args to matrix run options */
+declare function cliToMatrixOptions(args: DefaultCliArgs): RunMatrixOptions;
+/** Generate report for matrix results. Uses same sections as regular benchmarks. */
+declare function defaultMatrixReport(results: MatrixResults[], reportOptions?: MatrixReportOptions, args?: DefaultCliArgs): string;
+/** Run matrix suite with full CLI handling (parse, run, report, export) */
+declare function runDefaultMatrixBench(suite: MatrixSuite, configureArgs?: Configure<any>, reportOptions?: MatrixReportOptions): Promise<void>;
+/** Convert MatrixResults to ReportGroup[] for export compatibility */
+declare function matrixToReportGroups(results: MatrixResults[]): ReportGroup[];
+interface MatrixExportOptions {
+  sections?: any[];
+  currentVersion?: GitVersion;
+  baselineVersion?: GitVersion;
+}
+/** Run matrix benchmarks, display table, and generate exports */
+declare function matrixBenchExports(suite: MatrixSuite, args: DefaultCliArgs, reportOptions?: MatrixReportOptions, exportOptions?: MatrixExportOptions): Promise<void>;
+//#endregion
+//#region src/export/JsonFormat.d.ts
+/** Complete benchmark data structure for JSON export */
+interface BenchmarkJsonData {
+  meta: {
+    timestamp: string;
+    version: string;
+    args: Record<string, any>;
+    environment: {
+      node: string;
+      platform: string;
+      arch?: string;
+    };
+  };
+  suites: BenchmarkSuite[];
+}
+interface BenchmarkSuite {
+  name: string;
+  groups: BenchmarkGroup[];
+}
+interface BenchmarkGroup {
+  name: string;
+  baseline?: BenchmarkResult;
+  benchmarks: BenchmarkResult[];
+}
+interface BenchmarkResult {
+  name: string;
+  status: "completed" | "running" | "failed";
+  /** Raw execution time samples in milliseconds */
+  samples: number[];
+  /** Statistical summaries */
+  time: {
+    min: number;
+    max: number;
+    mean: number;
+    p50: number;
+    p75: number;
+    p99: number;
+    p999: number;
+  };
+  /** Optional performance metrics */
+  heapSize?: {
+    min: number;
+    max: number;
+    mean: number;
+  };
+  gcTime?: {
+    min: number;
+    max: number;
+    mean: number;
+  };
+  cpu?: {
+    instructions?: number;
+    cycles?: number;
+    cacheMisses?: number;
+    branchMisses?: number;
+  };
+  /** Execution metadata */
+  execution: {
+    iterations: number;
+    totalTime: number;
+    warmupRuns?: number;
+  };
+  /** Adaptive mode results */
+  adaptive?: {
+    confidenceInterval: {
+      lower: number;
+      upper: number;
+      margin: number;
+      marginPercent: number;
+      confidence: number;
+    };
+    converged: boolean;
+    stopReason: "threshold_met" | "max_time" | "max_iterations";
+  };
+  /** Error information */
+  error?: {
+    message: string;
+    type: string;
+    stackTrace?: string;
+  };
+}
+//#endregion
+//#region src/export/PerfettoExport.d.ts
+/** Export benchmark results to Perfetto-compatible trace file */
+declare function exportPerfettoTrace(groups: ReportGroup[], outputPath: string, args: DefaultCliArgs): void;
+//#endregion
+//#region src/HtmlDataPrep.d.ts
+interface PrepareHtmlOptions {
+  cliArgs?: Record<string, unknown>;
+  sections?: ResultsMapper[];
+  currentVersion?: GitVersion;
+  baselineVersion?: GitVersion;
+}
+/** Prepare ReportData from benchmark results for HTML rendering */
+declare function prepareHtmlData(groups: ReportGroup[], options: PrepareHtmlOptions): ReportData;
+//#endregion
+//#region src/matrix/CaseLoader.d.ts
+/** Module that exports case definitions */
+interface CasesModule<T = unknown> {
+  cases: string[];
+  defaultCases?: string[];
+  defaultVariants?: string[];
+  loadCase?: (id: string) => LoadedCase<T> | Promise<LoadedCase<T>>;
+}
+/** Load a cases module by URL */
+declare function loadCasesModule<T = unknown>(moduleUrl: string): Promise<CasesModule<T>>;
+/** Load case data from a CasesModule or pass through the caseId */
+declare function loadCaseData<T>(casesModule: CasesModule<T> | undefined, caseId: string): Promise<LoadedCase<T>>;
+//#endregion
+//#region src/matrix/MatrixFilter.d.ts
+/** Filter for matrix case/variant selection */
+interface MatrixFilter {
+  case?: string;
+  variant?: string;
+}
+/** Parse filter string: "case/variant", "case/", "/variant", or "case" */
+declare function parseMatrixFilter(filter: string): MatrixFilter;
+/** Filtered matrix with explicit case and variant lists */
+interface FilteredMatrix<T = unknown> extends BenchMatrix<T> {
+  filteredCases?: string[];
+  filteredVariants?: string[];
+}
+/** Apply filter to a matrix, merging with existing filters via intersection */
+declare function filterMatrix<T>(matrix: FilteredMatrix<T>, filter?: MatrixFilter): Promise<FilteredMatrix<T>>;
+//#endregion
+//#region src/StandardSections.d.ts
+interface TimeStats {
+  mean?: number;
+  p50?: number;
+  p99?: number;
+}
+/** Section: mean, p50, p99 timing */
+declare const timeSection: ResultsMapper<TimeStats>;
+interface GcSectionStats {
+  gc?: number;
+}
+/** Section: GC time as fraction of total benchmark time (Node performance hooks) */
+declare const gcSection: ResultsMapper<GcSectionStats>;
+interface GcStatsInfo {
+  allocPerIter?: number;
+  collected?: number;
+  scavenges?: number;
+  fullGCs?: number;
+  promoPercent?: number;
+  pausePerIter?: number;
+}
+/** Section: detailed GC stats from --trace-gc-nvp (allocation, promotion, pauses) */
+declare const gcStatsSection: ResultsMapper<GcStatsInfo>;
+interface CpuStats {
+  cpuCacheMiss?: number;
+  cpuStall?: number;
+}
+/** Section: CPU L1 cache miss rate and stall rate (requires @mitata/counters) */
+declare const cpuSection: ResultsMapper<CpuStats>;
+interface RunStats {
+  runs?: number;
+}
+/** Section: number of sample iterations */
+declare const runsSection: ResultsMapper<RunStats>;
+/** Section: total sampling duration in seconds (brackets if >= 30s) */
+declare const totalTimeSection: ResultsMapper<{
+  totalTime?: number;
+}>;
+interface AdaptiveStats {
+  median?: number;
+  mean?: number;
+  p99?: number;
+  convergence?: number;
+}
+/** Section: median, mean, p99, and convergence for adaptive mode */
+declare const adaptiveSection: ResultsMapper<AdaptiveStats>;
+/** Build generic sections based on CLI flags */
+declare function buildGenericSections(args: {
+  "gc-stats"?: boolean;
+  "heap-sample"?: boolean;
+}): ResultsMapper[];
+interface OptStats {
+  tiers?: string;
+  deopt?: number;
+}
+/** Section: V8 optimization tier distribution and deopt count */
+declare const optSection: ResultsMapper<OptStats>;
+//#endregion
+//#region src/StatisticalUtils.d.ts
+/** @return mean of values */
+declare function average(values: number[]): number;
+//#endregion
+//#region src/table-util/ConvergenceFormatters.d.ts
+/** @return convergence percentage with color for low values */
+declare function formatConvergence(v: unknown): string;
+//#endregion
+//#region src/table-util/Formatters.d.ts
+/** Format time in milliseconds, showing very small values with units */
+declare function timeMs(ms: unknown): string | null;
+/** Format integer with thousand separators */
+declare function integer(x: unknown): string | null;
+/** Format bytes with appropriate units (B, KB, MB, GB) */
+declare function formatBytes(bytes: unknown): string | null;
+/** @return truncated string with ellipsis if over maxLen */
+declare function truncate(str: string, maxLen?: number): string;
+//#endregion
+export { type AnyVariant, type BenchGroup, type BenchMatrix, type BenchSuite, BenchmarkGroup, BenchmarkJsonData, type BenchmarkReport, BenchmarkResult, type BenchmarkSpec, BenchmarkSuite, type CaseResult, type CasesModule, type Configure, type DefaultCliArgs, type ExportOptions, type ExtraColumn, type FilteredMatrix, type GitVersion, type HtmlReportOptions, type LoadedCase, type MatrixDefaults, type MatrixExportOptions, type MatrixFilter, type MatrixReportOptions, type MatrixResults, type MatrixSuite, type MeasuredResults, type PrepareHtmlOptions, type ReportColumnGroup, type ReportData, type ReportGroup, type ResultsMapper, type RunMatrixOptions, type RunnerOptions, type StatefulVariant, type UnknownRecord, type Variant, type VariantFn, type VariantResult, adaptiveSection, average, benchExports, buildGenericSections, cliToMatrixOptions, cpuSection, defaultCliArgs, defaultMatrixReport, defaultReport, exportPerfettoTrace, exportReports, filterMatrix, formatBytes, formatConvergence, formatDateWithTimezone, formatGitVersion, gcPauseColumn, gcSection, gcStatsColumns, gcStatsSection, generateHtmlReport, getBaselineVersion, getCurrentGitVersion, hasField, heapTotalColumn, integer, isStatefulVariant, loadCaseData, loadCasesModule, matrixBenchExports, matrixToReportGroups, optSection, parseBenchArgs, parseCliArgs, parseMatrixFilter, prepareHtmlData, printHeapReports, reportMatrixResults, reportOptStatus, reportResults, runBenchmarks, runDefaultBench, runDefaultMatrixBench, runMatrix, runMatrixSuite, runsSection, timeMs, timeSection, totalTimeSection, truncate };
+//# sourceMappingURL=index.d.mts.map