modestbench 0.0.2 → 0.1.0

package/src/cli/commands/run.ts

@@ -10,6 +10,12 @@ import { resolve } from 'node:path';
 import type { BenchmarkRun } from '../../types/index.js';
 import type { CliContext } from '../index.js';
 
+import { ErrorCodes } from '../../constants.js';
+import {
+  InvalidArgumentError,
+  type ModestBenchError,
+  UnknownReporterError,
+} from '../../errors/index.js';
 import { ExitCodes } from '../../types/cli.js';
 
 /**
@@ -89,6 +95,18 @@ export const handleRunCommand = async (
       console.error(`Found ${discoveredFiles.length} benchmark file(s)`);
     }
 
+    // Check if no files found and throw to trigger help display
+    if (discoveredFiles.length === 0) {
+      let msg = `No benchmark files found matching pattern "${config.pattern}"`;
+      if (config.exclude?.length) {
+        msg += ` (excluding: ${config.exclude.join(', ')})`;
+      }
+      // Throw error to trigger yargs fail handler which shows help
+      const error = new Error(msg);
+      error.name = 'FileDiscoveryError';
+      throw error;
+    }
+
     // Step 4: Validation phase
     if (showCliMessages) {
       console.error('Validating benchmark files...');
@@ -143,6 +161,11 @@ export const handleRunCommand = async (
 
     return handleResults(executionResult, options, shouldBeQuiet);
   } catch (error) {
+    // Re-throw FileDiscoveryError so yargs fail handler can show help
+    if ((error as ModestBenchError).code === ErrorCodes.FILE_DISCOVERY_FAILED) {
+      throw error;
+    }
+
     if (!shouldBeQuiet) {
       console.error(
         `Error: ${error instanceof Error ? error.message : String(error)}`,
@@ -253,8 +276,13 @@ const loadConfiguration = async (context: CliContext, options: RunOptions) => {
 
     return config;
   } catch (error) {
-    throw new Error(
+    // Re-throw our custom errors
+    if ((error as ModestBenchError).code === ErrorCodes.CONFIG_LOAD_FAILED) {
+      throw error;
+    }
+    throw new InvalidArgumentError(
       `Configuration error: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
     );
   }
 };
@@ -324,7 +352,7 @@ const setupReporters = async (
         reporter = context.reporterRegistry.get(reporterName);
         if (!reporter) {
           const availableReporters = ['human', 'json', 'csv', 'simple'];
-          throw new Error(
+          throw new UnknownReporterError(
             `Unknown reporter: ${reporterName}. Available: ${availableReporters.join(', ')}`,
           );
         }
@@ -339,8 +367,13 @@ const setupReporters = async (
 
     return reporters;
   } catch (error) {
-    throw new Error(
+    // Re-throw our custom errors
+    if ((error as ModestBenchError).code === ErrorCodes.REPORTER_UNKNOWN) {
+      throw error;
+    }
+    throw new InvalidArgumentError(
       `Reporter setup error: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
     );
   }
 };

package/src/cli/index.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+
 /**
  * ModestBench CLI Entry Point
  *
@@ -16,7 +17,6 @@ import { hideBin } from 'yargs/helpers';
 import type {
   BenchmarkEngine,
   ConfigurationManager,
-  ErrorManager,
   HistoryStorage,
   ProgressManager,
   ReporterRegistry,
@@ -24,6 +24,7 @@ import type {
 
 import { bootstrap } from '../bootstrap.js';
 import { AccurateEngine, TinybenchEngine } from '../core/engines/index.js';
+import { isModestBenchError, UnknownError } from '../errors/index.js';
 import {
   CsvReporter,
   HumanReporter,
@@ -42,7 +43,6 @@ export interface CliContext {
   readonly abortController: AbortController;
   readonly configManager: ConfigurationManager;
   readonly engine: BenchmarkEngine;
-  readonly errorManager: ErrorManager;
   readonly historyStorage: HistoryStorage;
   readonly options: GlobalOptions;
   readonly progressManager: ProgressManager;
@@ -151,13 +151,13 @@ export const main = async (
       .completion()
       .wrap(Math.min(120, cli.terminalWidth()))
       .command(
-        'run [pattern..]',
+        ['$0 [pattern..]', 'run [pattern..]'],
         'Run benchmark files',
         (yargs) => {
           return yargs
             .positional('pattern', {
               array: true,
-              default: [],
+              default: ['./bench/**/*.bench.{js,mjs,cjs,ts}'],
               describe:
                 'File paths, directory paths, or glob patterns for benchmark files',
               type: 'string',
@@ -491,8 +491,15 @@ export const main = async (
           if (process.env.DEBUG) {
             console.error(err.stack);
           }
+          // Show help for file discovery errors (similar to usage errors)
+          if (err.name === 'FileDiscoveryError') {
+            console.error();
+            yargsInstance.showHelp();
+            process.exit(ExitCodes.DISCOVERY_ERROR);
+          }
           process.exit(ExitCodes.RUNTIME_ERROR);
         } else {
+          // Show help for usage errors (unknown arguments, etc.)
           console.error(msg);
           console.error();
           yargsInstance.showHelp();
@@ -564,7 +571,6 @@ const createCliContext = async (
       abortController,
       configManager: engine.configManager,
       engine,
-      errorManager: engine.errorManager,
       historyStorage: engine.historyStorage,
       options,
       progressManager: engine.progressManager,
@@ -589,9 +595,7 @@ const setupSignalHandlers = (abortController: AbortController): void => {
     if (abortRequested) {
       // Second signal, force exit
       console.log(`\nReceived ${signal} again, forcing exit...`);
-      process.exit(
-        128 + (signal === 'SIGINT' ? 2 : signal === 'SIGQUIT' ? 3 : 15),
-      );
+      process.exit(computeExitCode(signal));
     }
 
     console.log(`\nReceived ${signal}, aborting benchmarks...`);
@@ -601,9 +605,7 @@ const setupSignalHandlers = (abortController: AbortController): void => {
     // Give a short grace period for cleanup, then exit
     setTimeout(() => {
       console.log('\nBenchmark aborted.');
-      process.exit(
-        128 + (signal === 'SIGINT' ? 2 : signal === 'SIGQUIT' ? 3 : 15),
-      );
+      process.exit(computeExitCode(signal));
     }, 100);
   };
 
@@ -611,13 +613,27 @@ const setupSignalHandlers = (abortController: AbortController): void => {
   process.on('SIGQUIT', () => handleSignal('SIGQUIT'));
   process.on('SIGTERM', () => handleSignal('SIGTERM'));
 
-  process.on('uncaughtException', (error) => {
-    console.error('Uncaught exception:', error);
+  process.once('uncaughtException', (error) => {
+    // Wrap non-ModestBench errors with UnknownError
+    const wrappedError: Error = isModestBenchError(error)
+      ? error
+      : new UnknownError(
+          error instanceof Error ? error.message : String(error),
+          { cause: error },
+        );
+    console.error(wrappedError.toString());
     process.exit(ExitCodes.RUNTIME_ERROR);
   });
 
-  process.on('unhandledRejection', (reason, promise) => {
-    console.error('Unhandled rejection at:', promise, 'reason:', reason);
+  process.once('unhandledRejection', (reason) => {
+    // Wrap non-ModestBench errors with UnknownError
+    const wrappedError: Error = isModestBenchError(reason)
+      ? (reason as Error)
+      : new UnknownError(
+          reason instanceof Error ? reason.message : String(reason),
+          { cause: reason },
+        );
+    console.error(wrappedError.toString());
     process.exit(ExitCodes.RUNTIME_ERROR);
   });
 };
@@ -640,3 +656,13 @@ try {
     cli();
   }
 }
+
+/**
+ * Compute the exit code based on the signal
+ *
+ * @param signal - The signal that caused the exit
+ * @returns The exit code
+ */
+const computeExitCode = (signal: string): number => {
+  return 128 + (signal === 'SIGINT' ? 2 : signal === 'SIGQUIT' ? 3 : 15);
+};

package/src/config/manager.ts

@@ -9,6 +9,7 @@
 import { cosmiconfig } from 'cosmiconfig';
 import { resolve } from 'node:path';
 
+import type { ModestBenchError } from '../errors/base.js';
 import type {
   ConfigurationManager,
   ModestBenchConfig,
@@ -17,6 +18,8 @@ import type {
   ValidationWarning,
 } from '../types/index.js';
 
+import { ErrorCodes } from '../constants.js';
+import { ConfigLoadError, ConfigValidationError } from '../errors/index.js';
 import { safeParseConfig } from './schema.js';
 
 /**
@@ -62,7 +65,7 @@ const DEFAULT_CONFIG: ModestBenchConfig = {
   time: 1000, // 1 second minimum for tinybench to gather samples
   timeout: 30000, // 30 seconds
   verbose: false, // No verbose output by default
-  warmup: 0, // No warmup by default for test speed
+  warmup: 30, // Light warmup by default - enough for basic JIT optimization
 };
 
 /**
@@ -175,15 +178,22 @@ export class ModestBenchConfigurationManager implements ConfigurationManager {
       // 3. Validate final configuration
       const validation = this.validate(finalConfig);
       if (!validation.valid) {
-        throw new Error(
+        throw new ConfigValidationError(
           `Configuration validation failed: ${validation.errors.map((e) => e.message).join(', ')}`,
         );
       }
 
       return finalConfig;
     } catch (error) {
-      throw new Error(
+      // Re-throw our custom errors
+      if (
+        (error as ModestBenchError).code === ErrorCodes.CONFIG_VALIDATION_FAILED
+      ) {
+        throw error;
+      }
+      throw new ConfigLoadError(
         `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error },
       );
     }
   }

package/src/constants.ts

@@ -19,3 +19,63 @@ export const BENCHMARK_FILE_PATTERN = `.bench.{${Array.from(
 )
   .map((ext) => ext.slice(1))
   .join(',')}}`;
+
+/**
+ * Error codes for all ModestBench errors
+ *
+ * Use these constants to check error types instead of instanceof checks.
+ */
+export const ErrorCodes = {
+  //#region cli-errors
+  CLI_INVALID_ARGUMENT: 'ERR_MB_CLI_INVALID_ARGUMENT',
+  CLI_INVALID_DATE_FORMAT: 'ERR_MB_CLI_INVALID_DATE_FORMAT',
+  //#endregion
+
+  //#region config-errors
+  CONFIG_LOAD_FAILED: 'ERR_MB_CONFIG_LOAD_FAILED',
+  CONFIG_NOT_FOUND: 'ERR_MB_CONFIG_NOT_FOUND',
+  CONFIG_UNSUPPORTED_FORMAT: 'ERR_MB_CONFIG_UNSUPPORTED_FORMAT',
+  CONFIG_VALIDATION_FAILED: 'ERR_MB_CONFIG_VALIDATION_FAILED',
+  //#endregion
+
+  //#region execution-errors
+  EXECUTION_BENCHMARK_FAILED: 'ERR_MB_EXECUTION_BENCHMARK_FAILED',
+  EXECUTION_SETUP_FAILED: 'ERR_MB_EXECUTION_SETUP_FAILED',
+  EXECUTION_TASK_FAILED: 'ERR_MB_EXECUTION_TASK_FAILED',
+  EXECUTION_TEARDOWN_FAILED: 'ERR_MB_EXECUTION_TEARDOWN_FAILED',
+  EXECUTION_TIMEOUT: 'ERR_MB_EXECUTION_TIMEOUT',
+  EXECUTION_TOO_FAST: 'ERR_MB_EXECUTION_TOO_FAST',
+  //#endregion
+
+  //#region file-errors
+  FILE_DISCOVERY_FAILED: 'ERR_MB_FILE_DISCOVERY_FAILED',
+  FILE_LOAD_FAILED: 'ERR_MB_FILE_LOAD_FAILED',
+  FILE_NOT_FOUND: 'ERR_MB_FILE_NOT_FOUND',
+  FILE_PERMISSION_DENIED: 'ERR_MB_FILE_PERMISSION_DENIED',
+  FILE_UNSUPPORTED_EXTENSION: 'ERR_MB_FILE_UNSUPPORTED_EXTENSION',
+  //#endregion
+
+  //#region reporter-errors
+  REPORTER_ALREADY_REGISTERED: 'ERR_MB_REPORTER_ALREADY_REGISTERED',
+  REPORTER_OUTPUT_FAILED: 'ERR_MB_REPORTER_OUTPUT_FAILED',
+  REPORTER_UNKNOWN: 'ERR_MB_REPORTER_UNKNOWN',
+  //#endregion
+
+  //#region storage-errors
+  STORAGE_CORRUPTION: 'ERR_MB_STORAGE_CORRUPTION',
+  STORAGE_EXPORT_UNSUPPORTED: 'ERR_MB_STORAGE_EXPORT_UNSUPPORTED',
+  STORAGE_FAILED: 'ERR_MB_STORAGE_FAILED',
+  STORAGE_INDEX_CORRUPTION: 'ERR_MB_STORAGE_INDEX_CORRUPTION',
+  STORAGE_INSUFFICIENT_SPACE: 'ERR_MB_STORAGE_INSUFFICIENT_SPACE',
+  //#endregion
+
+  //#region misc-errors
+  UNKNOWN: 'ERR_MB_UNKNOWN',
+  //#endregion
+
+  //#region validation-errors
+  VALIDATION_SCHEMA_FAILED: 'ERR_MB_VALIDATION_SCHEMA_FAILED',
+  VALIDATION_STRUCTURE_INVALID: 'ERR_MB_VALIDATION_STRUCTURE_INVALID',
+  VALIDATION_TYPE_FAILED: 'ERR_MB_VALIDATION_TYPE_FAILED',
+  //#endregion
+} as const;

package/src/core/engine.ts

@@ -15,8 +15,6 @@ import type {
   CiInfo,
   ConfigurationManager,
   EnvironmentInfo,
-  ErrorManager,
-  ExecutionPhase,
   FileLoader,
   FileResult,
   GitInfo,
@@ -33,12 +31,19 @@ import type {
   ValidationWarning,
 } from '../types/index.js';
 
+import {
+  BenchmarkExecutionError,
+  FileDiscoveryError,
+  SchemaValidationError,
+  SetupError,
+  StructureValidationError,
+} from '../errors/index.js';
+
 /**
  * Dependencies required by the BenchmarkEngine
  */
 interface EngineDependencies {
   readonly configManager: ConfigurationManager;
-  readonly errorManager: ErrorManager;
   readonly fileLoader: FileLoader;
   readonly historyStorage: HistoryStorage;
   readonly progressManager: ProgressManager;
@@ -55,8 +60,6 @@ interface EngineDependencies {
 export abstract class ModestBenchEngine implements BenchmarkEngine {
   public readonly configManager: ConfigurationManager;
 
-  public readonly errorManager: ErrorManager;
-
   public readonly fileLoader: FileLoader;
 
   public readonly historyStorage: HistoryStorage;
@@ -71,7 +74,6 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
     this.reporterRegistry = dependencies.reporterRegistry;
     this.historyStorage = dependencies.historyStorage;
     this.progressManager = dependencies.progressManager;
-    this.errorManager = dependencies.errorManager;
   }
 
   /**
@@ -86,13 +88,10 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
     } catch (error) {
       const discoveryError =
         error instanceof Error ? error : new Error(String(error));
-      this.errorManager.handleError(discoveryError, {
-        metadata: { exclude, pattern },
-        phase: 'discovery',
-        timestamp: new Date(),
-      });
-
-      throw new Error(`File discovery failed: ${discoveryError.message}`);
+      throw new FileDiscoveryError(
+        `File discovery failed: ${discoveryError.message}`,
+        { cause: discoveryError },
+      );
     }
   }
 
@@ -105,11 +104,9 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
     signal?: AbortSignal,
   ): Promise<BenchmarkRun> {
     const startTime = new Date();
-    let currentPhase: ExecutionPhase = 'discovery';
 
     try {
       // 1. Merge configuration with defaults
-      currentPhase = 'discovery';
       const mergedConfig = await this.configManager.load(
         undefined, // No specific config path for now
         config as Record<string, unknown>,
@@ -121,32 +118,22 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
         (await this.discover(mergedConfig.pattern, mergedConfig.exclude));
 
       if (files.length === 0) {
-        const error = new Error(
-          'No benchmark files found matching the pattern',
-        );
-        this.errorManager.handleError(error, {
-          phase: currentPhase,
-          timestamp: new Date(),
-        });
-        throw error;
+        let msg = `No benchmark files found matching the pattern "${mergedConfig.pattern}`;
+        if (mergedConfig.exclude?.length) {
+          msg += ` and excluding "${mergedConfig.exclude.join(', ')}"`;
+        }
+        throw new FileDiscoveryError(msg);
       }
 
       // 3. Validate files
-      currentPhase = 'validation';
       const validationResult = await this.validate(files);
       if (!validationResult.valid) {
-        const error = new Error(
+        throw new SchemaValidationError(
           `Validation failed: ${validationResult.errors.map((e) => e.message).join(', ')}`,
         );
-        this.errorManager.handleError(error, {
-          phase: currentPhase,
-          timestamp: new Date(),
-        });
-        throw error;
       }
 
       // 4. Initialize progress tracking
-      currentPhase = 'setup';
       const runId = this.generateRunId();
 
       // Pre-calculate total tasks for progress tracking
@@ -234,7 +221,6 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
       await this.callReporters(reporters, 'onStart', initialRun);
 
       // 6. Execute benchmark files
-      currentPhase = 'execution';
       const fileResults: FileResult[] = [];
 
       for (const filePath of files) {
@@ -261,11 +247,6 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
         } catch (error) {
           const fileError =
             error instanceof Error ? error : new Error(String(error));
-          this.errorManager.handleError(fileError, {
-            file: filePath,
-            phase: currentPhase,
-            timestamp: new Date(),
-          });
 
           // Call reporter onError
           await this.callReporters(reporters, 'onError', fileError);
@@ -348,15 +329,23 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
       // 9. Return completed run
       return finalRun;
     } catch (error) {
+      // Re-throw our custom errors
+      if (
+        error instanceof FileDiscoveryError ||
+        error instanceof SchemaValidationError ||
+        error instanceof BenchmarkExecutionError
+      ) {
+        throw error;
+      }
+
       const executionError =
         error instanceof Error ? error : new Error(String(error));
-      const handledError = this.errorManager.handleError(executionError, {
-        phase: currentPhase,
-        timestamp: new Date(),
-      });
 
       // Re-throw the original error with more context
-      throw new Error(`Benchmark execution failed: ${handledError.message}`);
+      throw new BenchmarkExecutionError(
+        `Benchmark execution failed: ${executionError.message}`,
+        { cause: executionError },
+      );
     }
   }
 
@@ -421,11 +410,6 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
         } catch (error) {
           const validationError =
             error instanceof Error ? error : new Error(String(error));
-          this.errorManager.handleError(validationError, {
-            file,
-            phase: 'validation',
-            timestamp: new Date(),
-          });
 
           errors.push({
             code: 'FILE_VALIDATION_ERROR',
@@ -514,7 +498,7 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
       const benchmarkDef = benchmarkFile.exports as BenchmarkDefinition;
 
       if (!benchmarkDef || typeof benchmarkDef !== 'object') {
-        throw new Error(
+        throw new StructureValidationError(
           'Benchmark file must export a default object with suites',
         );
       }
@@ -632,7 +616,9 @@ export abstract class ModestBenchEngine implements BenchmarkEngine {
             error instanceof Error
               ? error
               : new Error(`Setup failed: ${String(error)}`);
-          throw new Error(`Suite setup failed: ${setupError.message}`);
+          throw new SetupError(`Suite setup failed: ${setupError.message}`, {
+            cause: setupError,
+          });
         }
       }
 

package/src/core/engines/accurate-engine.ts

@@ -26,6 +26,7 @@ import type {
   TaskResult,
 } from '../../types/index.js';
 
+import { StructureValidationError } from '../../errors/index.js';
 import { ModestBenchEngine } from '../engine.js';
 import { calculateStatistics, removeOutliersIQR } from '../stats-utils.js';
 
@@ -59,7 +60,9 @@ export class AccurateEngine extends ModestBenchEngine {
   ): Promise<TaskResult> {
     try {
       if (!taskData.fn || typeof taskData.fn !== 'function') {
-        throw new Error('Benchmark task must have a "fn" function property');
+        throw new StructureValidationError(
+          'Benchmark task must have a "fn" function property',
+        );
       }
 
       // Check for V8 native syntax support

package/src/core/engines/tinybench-engine.ts

@@ -14,6 +14,11 @@ import type {
   TaskResult,
 } from '../../types/index.js';
 
+import {
+  BenchmarkExecutionError,
+  OperationTooFastError,
+  StructureValidationError,
+} from '../../errors/index.js';
 import { ModestBenchEngine } from '../engine.js';
 import { calculateStatistics, removeOutliersIQR } from '../stats-utils.js';
 
@@ -33,7 +38,9 @@ export class TinybenchEngine extends ModestBenchEngine {
   ): Promise<TaskResult> {
     try {
       if (!taskData.fn || typeof taskData.fn !== 'function') {
-        throw new Error('Benchmark task must have a "fn" function property');
+        throw new StructureValidationError(
+          'Benchmark task must have a "fn" function property',
+        );
       }
 
       // Determine effective time and iterations based on limitBy mode
@@ -137,13 +144,13 @@ export class TinybenchEngine extends ModestBenchEngine {
             await minimalBench.run();
           } catch {
             // If still failing, the operation is too fast even for tinybench
-            throw new Error(
+            throw new OperationTooFastError(
               `Benchmark operation is too fast to measure reliably (execution time < 1ns)`,
             );
           }
           const minimalResults = minimalBench.results[0];
           if (!minimalResults || minimalResults.error) {
-            throw new Error(
+            throw new OperationTooFastError(
               `Benchmark too fast to measure reliably: ${minimalResults?.error?.message || 'unknown error'}`,
             );
           }
@@ -180,7 +187,7 @@ export class TinybenchEngine extends ModestBenchEngine {
       // Get results
       const results = bench.results[0];
       if (!results) {
-        throw new Error('No benchmark results returned');
+        throw new BenchmarkExecutionError('No benchmark results returned');
       }
 
       // Check if the task was aborted
@@ -251,7 +258,7 @@ export class TinybenchEngine extends ModestBenchEngine {
 
           if (!minimalResults || minimalResults.error) {
             // If retry also fails, just accept it failed
-            throw new Error(
+            throw new OperationTooFastError(
               `Benchmark operation is too fast to measure reliably`,
             );
           }

package/src/core/loader.ts

@@ -22,6 +22,11 @@ import {
   BENCHMARK_FILE_EXTENSIONS,
   BENCHMARK_FILE_PATTERN,
 } from '../constants.js';
+import {
+  FileDiscoveryError,
+  FileLoadError,
+  StructureValidationError,
+} from '../errors/index.js';
 import { benchmarkFileSchema } from './benchmark-schema.js';
 
 /**
@@ -106,8 +111,9 @@ export class BenchmarkFileLoader implements FileLoader {
 
       return supportedFiles.sort();
     } catch (error) {
-      throw new Error(
+      throw new FileDiscoveryError(
         `File discovery failed: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error },
       );
     }
   }
@@ -120,7 +126,7 @@ export class BenchmarkFileLoader implements FileLoader {
       // Basic file checks (existence, extension)
       const basicValidation = await this.validate(filePath);
       if (!basicValidation.valid) {
-        throw new Error(
+        throw new FileLoadError(
           `Invalid benchmark file: ${basicValidation.errors.map((e) => e.message).join(', ')}`,
         );
       }
@@ -160,7 +166,7 @@ export class BenchmarkFileLoader implements FileLoader {
       // Validate the loaded exports structure with Zod
       const structureValidation = this.validateExports(filePath, exports);
       if (!structureValidation.valid || !structureValidation.data) {
-        throw new Error(
+        throw new StructureValidationError(
           `Invalid benchmark structure: ${structureValidation.errors.map((e) => e.message).join(', ')}`,
         );
       }
@@ -185,8 +191,16 @@ export class BenchmarkFileLoader implements FileLoader {
         },
       };
     } catch (error) {
-      throw new Error(
+      // Re-throw our custom errors
+      if (
+        error instanceof FileLoadError ||
+        error instanceof StructureValidationError
+      ) {
+        throw error;
+      }
+      throw new FileLoadError(
         `Failed to load file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error },
       );
     }
   }
@@ -199,8 +213,16 @@ export class BenchmarkFileLoader implements FileLoader {
       const loadPromises = filePaths.map((filePath) => this.load(filePath));
       return await Promise.all(loadPromises);
     } catch (error) {
-      throw new Error(
+      // Re-throw our custom errors (from individual load calls)
+      if (
+        error instanceof FileLoadError ||
+        error instanceof StructureValidationError
+      ) {
+        throw error;
+      }
+      throw new FileLoadError(
         `Failed to load files: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error },
       );
     }
   }