feat: enable eraseable syntax

package.json

@@ -50,7 +50,7 @@
     "prettier": "^3.4.0",
     "rimraf": "^5.0.10",
     "ts-node": "^10.9.2",
-    "typescript": "^5.6.3",
+    "typescript": "^5.8.2",
     "typescript-eslint": "^8.16.0",
     "vitest": "^3.0.6",
     "vitest-in-process-pool": "^2.0.0"

src/benchmark/runBenchmarkFn.ts

@@ -1,17 +1,19 @@
 import Debug from "debug";
-import {BenchmarkResult, BenchmarkOpts, Convergence, ConvergenceCheckFn} from "../types.js";
+import {BenchmarkResult, BenchmarkOpts, ConvergenceType, ConvergenceCheckFn, Convergence} from "../types.js";
 import {calcSum, filterOutliers, OutlierSensitivity} from "../utils/math.js";
 import {getBenchmarkOptionsWithDefaults} from "./options.js";
 import {createLinearConvergenceCriteria} from "./convergence/linearAverage.js";
 import {createCVConvergenceCriteria} from "./convergence/coefficientOfVariance.js";
 
 const debug = Debug("@chainsafe/benchmark/run");
 
-const convergenceCriteria: Record<Convergence, (startMs: number, opts: Required<BenchmarkOpts>) => ConvergenceCheckFn> =
-  {
-    [Convergence.Linear]: createLinearConvergenceCriteria,
-    [Convergence.CV]: createCVConvergenceCriteria,
-  };
+const convergenceCriteria: Record<
+  ConvergenceType,
+  (startMs: number, opts: Required<BenchmarkOpts>) => ConvergenceCheckFn
+> = {
+  [Convergence.Linear]: createLinearConvergenceCriteria,
+  [Convergence.CV]: createCVConvergenceCriteria,
+};
 
 export type BenchmarkRunOpts = BenchmarkOpts & {
   id: string;

src/cli/options.ts

@@ -1,5 +1,5 @@
 import {Options} from "yargs";
-import {StorageOptions, BenchmarkOpts, FileCollectionOptions, Convergence, AverageCalculation} from "../types.js";
+import {StorageOptions, BenchmarkOpts, FileCollectionOptions, AverageCalculation, Convergence} from "../types.js";
 import {defaultBenchmarkOptions} from "../benchmark/options.js";
 
 export const optionsDefault = {

src/cli/run.ts

@@ -19,7 +19,7 @@ import {isGaRun} from "../github/context.js";
 import {BenchmarkRunner} from "../benchmark/runner.js";
 import {optionsDefault} from "./options.js";
 import {consoleLog} from "../utils/output.js";
-import {HistoryProviderType} from "../history/provider.js";
+import {HistoryProviderStore} from "../history/provider.js";
 import {performanceReportComment} from "../github/comments/performanceReportComment.js";
 import {GithubCommentTag} from "../github/octokit.js";
 import {defaultBenchmarkOptions} from "../benchmark/options.js";
@@ -81,7 +81,7 @@ export async function run(opts_: FileCollectionOptions & StorageOptions & Benchm
         currentCommit.branch ??
         parseBranchFromRef(
           github.context.ref ?? (await shell("git symbolic-ref HEAD")),
-          historyProvider.type === HistoryProviderType.Local
+          historyProvider.type === HistoryProviderStore.Local
         );
       consoleLog(`Persisting new benchmark data for branch '${branch}' commit '${currBench.commitSha}'`);
       // TODO: prune and limit total entries

src/compare/index.ts

@@ -5,14 +5,14 @@ import {isGaRun} from "../github/context.js";
 import {IHistoryProvider} from "../history/provider.js";
 import {validateBenchmark} from "../history/schema.js";
 
-enum CompareWithType {
-  latestCommitInBranch = "latestCommitInBranch",
-  exactCommit = "exactCommit",
-}
+const CompareWith = {
+  latestCommitInBranch: "latestCommitInBranch",
+  exactCommit: "exactCommit",
+} as const;
 
-export type CompareWith =
-  | {type: CompareWithType.latestCommitInBranch; branch: string; before?: string}
-  | {type: CompareWithType.exactCommit; commitSha: string};
+export type CompareWithType =
+  | {type: typeof CompareWith.latestCommitInBranch; branch: string; before?: string}
+  | {type: typeof CompareWith.exactCommit; commitSha: string};
 
 export async function resolveCompare(provider: IHistoryProvider, opts: StorageOptions): Promise<Benchmark | null> {
   const compareWith = await resolveCompareWith(opts);
@@ -25,26 +25,26 @@ export async function resolveCompare(provider: IHistoryProvider, opts: StorageOp
 }
 
 export async function resolvePrevBenchmark(
-  compareWith: CompareWith,
+  compareWith: CompareWithType,
   provider: IHistoryProvider
 ): Promise<Benchmark | null> {
   switch (compareWith.type) {
-    case CompareWithType.exactCommit:
+    case CompareWith.exactCommit:
       return await provider.readHistoryCommit(compareWith.commitSha);
 
-    case CompareWithType.latestCommitInBranch: {
+    case CompareWith.latestCommitInBranch: {
       // Try first latest commit in branch
       return await provider.readLatestInBranch(compareWith.branch);
     }
   }
 }
 
-export function renderCompareWith(compareWith: CompareWith): string {
+export function renderCompareWith(compareWith: CompareWithType): string {
   switch (compareWith.type) {
-    case CompareWithType.exactCommit:
+    case CompareWith.exactCommit:
       return `exactCommit ${compareWith.commitSha}`;
 
-    case CompareWithType.latestCommitInBranch: {
+    case CompareWith.latestCommitInBranch: {
       if (compareWith.before) {
         return `latestCommitInBranch '${compareWith.branch}' before commit ${compareWith.before}`;
       } else {
@@ -54,14 +54,14 @@ export function renderCompareWith(compareWith: CompareWith): string {
   }
 }
 
-export async function resolveCompareWith(opts: StorageOptions): Promise<CompareWith> {
+export async function resolveCompareWith(opts: StorageOptions): Promise<CompareWithType> {
   // compare may be a branch or commit
   if (opts.compareBranch) {
-    return {type: CompareWithType.latestCommitInBranch, branch: opts.compareBranch};
+    return {type: CompareWith.latestCommitInBranch, branch: opts.compareBranch};
   }
 
   if (opts.compareCommit) {
-    return {type: CompareWithType.exactCommit, commitSha: opts.compareCommit};
+    return {type: CompareWith.exactCommit, commitSha: opts.compareCommit};
   }
 
   // In GA CI figure out what to compare against with github actions events
@@ -70,13 +70,13 @@ export async function resolveCompareWith(opts: StorageOptions): Promise<CompareW
       case "pull_request": {
         const eventData = getGithubEventData<GithubActionsEventData["pull_request"]>();
         const baseBranch = eventData.pull_request.base.ref; // base.ref is already parsed
-        return {type: CompareWithType.latestCommitInBranch, branch: baseBranch};
+        return {type: CompareWith.latestCommitInBranch, branch: baseBranch};
       }
 
       case "push": {
         const eventData = getGithubEventData<GithubActionsEventData["push"]>();
         const branch = parseBranchFromRef(github.context.ref);
-        return {type: CompareWithType.latestCommitInBranch, branch: branch, before: eventData.before};
+        return {type: CompareWith.latestCommitInBranch, branch: branch, before: eventData.before};
       }
 
       default:
@@ -86,5 +86,5 @@ export async function resolveCompareWith(opts: StorageOptions): Promise<CompareW
 
   // Otherwise compare against the default branch
   const defaultBranch = await getDefaultBranch(opts);
-  return {type: CompareWithType.latestCommitInBranch, branch: defaultBranch};
+  return {type: CompareWith.latestCommitInBranch, branch: defaultBranch};
 }

src/github/comments/index.ts

@@ -1,14 +1,14 @@
 import * as github from "@actions/github";
 import {getGithubEventData, GithubActionsEventData} from "../../utils/index.js";
-import {commentToCommit, commentToPrUpdatable, GithubCommentTag} from "../octokit.js";
+import {commentToCommit, commentToPrUpdatable, GithubCommentTagType} from "../octokit.js";
 
 export async function postGaComment({
   commentBody,
   tag,
   commentOnPush,
 }: {
   commentBody: string;
-  tag: GithubCommentTag;
+  tag: GithubCommentTagType;
   commentOnPush: boolean;
 }): Promise<void> {
   switch (github.context.eventName) {

src/github/octokit.ts

@@ -1,11 +1,13 @@
+import {EnumLike} from "../types.js";
 import {getContext} from "./context.js";
 
-export enum GithubCommentTag {
-  PerformanceReport = "benchmarkbot/action",
-  ComparisonReport = "benchmarkbot/compare",
-}
+export const GithubCommentTag = {
+  PerformanceReport: "benchmarkbot/action",
+  ComparisonReport: "benchmarkbot/compare",
+} as const;
+export type GithubCommentTagType = EnumLike<typeof GithubCommentTag>;
 
-export async function commentToPrUpdatable(prNumber: number, body: string, tag: GithubCommentTag): Promise<void> {
+export async function commentToPrUpdatable(prNumber: number, body: string, tag: GithubCommentTagType): Promise<void> {
   const {repo, octokit} = getContext();
 
   // Append tag so the comment is findable latter

src/history/gaCache.ts

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import * as cache from "@actions/cache";
 import {Benchmark} from "../types.js";
 import {LocalHistoryProvider} from "./local.js";
-import {HistoryProviderType, IHistoryProvider} from "./provider.js";
+import {HistoryProviderStore, HistoryProviderStoreType, IHistoryProvider} from "./provider.js";
 
 /**
  * Persist results in CSV, one benchmark result per file
@@ -23,14 +23,15 @@ export function getGaCacheHistoryProvider(cacheKey: string): IHistoryProvider {
 }
 
 class GaCacheHistoryProvider extends LocalHistoryProvider implements IHistoryProvider {
-  readonly type = HistoryProviderType.GaCache;
+  readonly type: HistoryProviderStoreType = HistoryProviderStore.GaCache;
   private initializePromise: Promise<unknown> | null = null;
+  private readonly tmpDir: string;
+  private readonly cacheKey: string;
 
-  constructor(
-    private readonly tmpDir: string,
-    private readonly cacheKey: string
-  ) {
+  constructor(tmpDir: string, cacheKey: string) {
     super(tmpDir);
+    this.tmpDir = tmpDir;
+    this.cacheKey = cacheKey;
   }
 
   providerInfo(): string {

src/history/local.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import {HistoryProviderType, IHistoryProvider} from "./provider.js";
+import {HistoryProviderStore, HistoryProviderStoreType, IHistoryProvider} from "./provider.js";
 import {Benchmark, BenchmarkResults} from "../types.js";
 import {fromCsv, toCsv} from "../utils/file.js";
 import {FsError} from "../utils/index.js";
@@ -33,8 +33,12 @@ interface CsvMeta {
  * ```
  */
 export class LocalHistoryProvider implements IHistoryProvider {
-  readonly type: HistoryProviderType = HistoryProviderType.Local;
-  constructor(private readonly dirpath: string) {}
+  readonly type: HistoryProviderStoreType = HistoryProviderStore.Local;
+  private dirpath: string;
+
+  constructor(dirpath: string) {
+    this.dirpath = dirpath;
+  }
 
   providerInfo(): string {
     return `LocalHistoryProvider, dirpath ${this.dirpath}`;

src/history/provider.ts

@@ -1,10 +1,11 @@
-import {Benchmark} from "../types.js";
+import {Benchmark, EnumLike} from "../types.js";
 
-export enum HistoryProviderType {
-  Local = "Local",
-  GaCache = "GaCache",
-  S3 = "S3",
-}
+export const HistoryProviderStore = {
+  Local: "Local",
+  GaCache: "GaCache",
+  S3: "S3",
+} as const;
+export type HistoryProviderStoreType = EnumLike<typeof HistoryProviderStore>;
 
 /**
  * How to organize data?
@@ -29,7 +30,7 @@ export enum HistoryProviderType {
  * In history you can ONLY track a single branch, which should be the main branch.
  */
 export interface IHistoryProvider {
-  readonly type: HistoryProviderType;
+  readonly type: HistoryProviderStoreType;
   providerInfo(): string;
   readLatestInBranch(branch: string): Promise<Benchmark | null>;
   writeLatestInBranch(branch: string, benchmark: Benchmark): Promise<void>;

src/history/s3.ts

@@ -2,7 +2,7 @@ import path from "node:path";
 import S3 from "aws-sdk/clients/s3.js";
 import {Benchmark, BenchmarkResults} from "../types.js";
 import {fromCsv, toCsv, extendError, AwsError} from "../utils/index.js";
-import {HistoryProviderType, IHistoryProvider} from "./provider.js";
+import {HistoryProviderStoreType, HistoryProviderStore, IHistoryProvider} from "./provider.js";
 
 export type S3Config = Pick<S3.Types.ClientConfiguration, "accessKeyId" | "secretAccessKey" | "region" | "endpoint"> & {
   Bucket: string;
@@ -19,10 +19,12 @@ interface CsvMeta {
 }
 
 export class S3HistoryProvider implements IHistoryProvider {
-  readonly type = HistoryProviderType.S3;
+  readonly type: HistoryProviderStoreType = HistoryProviderStore.S3;
   private s3: S3;
+  private config: S3Config;
 
-  constructor(private readonly config: S3Config) {
+  constructor(config: S3Config) {
+    this.config = config;
     this.s3 = new S3(config);
   }
 

src/types.ts

@@ -1,3 +1,5 @@
+export type EnumLike<T> = T[keyof T];
+
 export interface FileCollectionOptions {
   /** File extensions to use */
   extension: string[];
@@ -68,9 +70,9 @@ export type BenchmarkOpts = {
   /**
    * The algorithm to detect the convergence to stop the benchmark function runs.
    * */
-  convergence?: Convergence;
+  convergence?: ConvergenceType;
   /** Use simple average of all runs or clean the outliers before calculating average */
-  averageCalculation?: AverageCalculation;
+  averageCalculation?: AverageCalculationType;
 };
 
 // Create partial only for specific keys
@@ -161,7 +163,7 @@ export type BenchmarkComparisonResult = {
 };
 
 /** Algorithms to detect when to stop the benchmark runs */
-export enum Convergence {
+export const Convergence = {
   /**
    * **Linear**:
    *
@@ -179,7 +181,7 @@ export enum Convergence {
    * high noise or if runs are extremely fast (on the nanosecond scale),
    * you might see premature stopping or extended run times.
    */
-  Linear = "linear",
+  Linear: "linear",
 
   /**
    * **Coefficient of Variation (CV)**:
@@ -202,15 +204,17 @@ export enum Convergence {
    *   convergence may never be triggered. Conversely, extremely uniform runs
    *   can cause an instant (potentially premature) stop.
    */
-  CV = "cv",
-}
+  CV: "cv",
+} as const;
+export type ConvergenceType = EnumLike<typeof Convergence>;
 
 /** How to calculate average for output */
-export enum AverageCalculation {
+export const AverageCalculation = {
   /** Calculate simple average */
-  Simple = "simple",
+  Simple: "simple",
   /** Clean the outliers first then calculate the average */
-  CleanOutliers = "clean-outliers",
-}
+  CleanOutliers: "clean-outliers",
+} as const;
+export type AverageCalculationType = EnumLike<typeof AverageCalculation>;
 
 export type ConvergenceCheckFn = (runIdx: number, totalNs: bigint, runNs: bigint[]) => boolean;

src/utils/math.ts

@@ -1,3 +1,5 @@
+import {EnumLike} from "../types.js";
+
 export const MAX_FRACTION = 8;
 
 export function roundDecimal(n: number): number {
@@ -114,16 +116,17 @@ export function calcQuartile<T extends number | bigint>(arr: T[], sorted: boolea
  * - Mild: Removes typical anomalies (e.g., temporary CPU spikes)
  * - Strict: Only filters extreme deviations (e.g., measurement errors)
  */
-export enum OutlierSensitivity {
+export const OutlierSensitivity = {
   /**
    * A standard multiplier for detecting mild outliers. Captures ~99.3% of normally distributed data.
    */
-  Mild = 1.5,
+  Mild: 1.5,
   /**
    * A stricter multiplier for detecting extreme outliers. Captures ~99.99% of normally distributed data.
    */
-  Strict = 3.0,
-}
+  Strict: 3.0,
+} as const;
+export type OutlierSensitivityType = EnumLike<typeof OutlierSensitivity>;
 
 /**
  * Isolates the core dataset by excluding values far from the central cluster.
@@ -141,7 +144,7 @@ export enum OutlierSensitivity {
 export function filterOutliers<T extends number | bigint>(
   arr: T[],
   sorted: boolean,
-  sensitivity: OutlierSensitivity
+  sensitivity: OutlierSensitivityType
 ): T[] {
   if (arr.length < 4) return arr; // Too few data points