@d-es-ign/stryker-js-core 9.6.0

package/src/process/2-mutant-instrumenter-executor.ts

@@ -0,0 +1,122 @@
+import type { execaCommand } from 'execa';
+import {
+  Injector,
+  tokens,
+  commonTokens,
+  PluginContext,
+  PluginKind,
+} from '@stryker-mutator/api/plugin';
+import {
+  createInstrumenter,
+  InstrumentResult,
+} from '@stryker-mutator/instrumenter';
+import { StrykerOptions } from '@stryker-mutator/api/core';
+import { Reporter } from '@stryker-mutator/api/report';
+import { I } from '@stryker-mutator/util';
+
+import { coreTokens, PluginCreator } from '../di/index.js';
+import { Sandbox } from '../sandbox/sandbox.js';
+import {
+  ConcurrencyTokenProvider,
+  createCheckerPool,
+} from '../concurrent/index.js';
+import { createCheckerFactory } from '../checker/index.js';
+import { createPreprocessor } from '../sandbox/index.js';
+import { Timer } from '../utils/timer.js';
+import { TemporaryDirectory } from '../utils/temporary-directory.js';
+import { UnexpectedExitHandler } from '../unexpected-exit-handler.js';
+import { FileSystem, Project } from '../fs/index.js';
+import { IdGenerator } from '../child-proxy/id-generator.js';
+
+import { DryRunContext } from './3-dry-run-executor.js';
+
+export interface MutantInstrumenterContext extends PluginContext {
+  [commonTokens.options]: StrykerOptions;
+  [coreTokens.project]: Project;
+  [coreTokens.reporter]: Required<Reporter>;
+  [coreTokens.timer]: I<Timer>;
+  [coreTokens.temporaryDirectory]: I<TemporaryDirectory>;
+  [coreTokens.execa]: typeof execaCommand;
+  [coreTokens.process]: NodeJS.Process;
+  [coreTokens.unexpectedExitRegistry]: I<UnexpectedExitHandler>;
+  [coreTokens.pluginModulePaths]: readonly string[];
+  [coreTokens.fs]: I<FileSystem>;
+  [coreTokens.pluginCreator]: PluginCreator;
+  [coreTokens.loggingServerAddress]: { port: number };
+}
+
+export class MutantInstrumenterExecutor {
+  public static readonly inject = tokens(
+    commonTokens.injector,
+    coreTokens.project,
+    commonTokens.options,
+    coreTokens.pluginCreator,
+  );
+  constructor(
+    private readonly injector: Injector<MutantInstrumenterContext>,
+    private readonly project: Project,
+    private readonly options: StrykerOptions,
+    private readonly pluginCreator: PluginCreator,
+  ) {}
+
+  public async execute(): Promise<Injector<DryRunContext>> {
+    // Create the checker and instrumenter
+    const instrumenter = this.injector.injectFunction(createInstrumenter);
+
+    // Instrument files in-memory
+    const ignorers = this.options.ignorers.map((name) =>
+      this.pluginCreator.create(PluginKind.Ignore, name),
+    );
+    const instrumentResult = await instrumenter.instrument(
+      await this.readFilesToMutate(),
+      { ignorers, ...this.options.mutator },
+    );
+
+    // Preprocess the project
+    const preprocess = this.injector.injectFunction(createPreprocessor);
+    this.writeInstrumentedFiles(instrumentResult);
+    await preprocess.preprocess(this.project);
+
+    // Initialize the checker pool
+    const concurrencyTokenProviderProvider = this.injector.provideClass(
+      coreTokens.concurrencyTokenProvider,
+      ConcurrencyTokenProvider,
+    );
+    const concurrencyTokenProvider = concurrencyTokenProviderProvider.resolve(
+      coreTokens.concurrencyTokenProvider,
+    );
+
+    const checkerPoolProvider = concurrencyTokenProviderProvider
+      .provideValue(
+        coreTokens.checkerConcurrencyTokens,
+        concurrencyTokenProvider.checkerToken$,
+      )
+      .provideClass(coreTokens.workerIdGenerator, IdGenerator)
+      .provideFactory(coreTokens.checkerFactory, createCheckerFactory)
+      .provideFactory(coreTokens.checkerPool, createCheckerPool);
+    const checkerPool = checkerPoolProvider.resolve(coreTokens.checkerPool);
+    await checkerPool.init();
+
+    // Feed the sandbox
+    const dryRunProvider = checkerPoolProvider
+      .provideClass(coreTokens.sandbox, Sandbox)
+      .provideValue(coreTokens.mutants, instrumentResult.mutants);
+    const sandbox = dryRunProvider.resolve(coreTokens.sandbox);
+    await sandbox.init();
+    return dryRunProvider;
+  }
+
+  private readFilesToMutate() {
+    return Promise.all(
+      [...this.project.filesToMutate.values()].map((file) =>
+        file.toInstrumenterFile(),
+      ),
+    );
+  }
+
+  private writeInstrumentedFiles(instrumentResult: InstrumentResult): void {
+    for (const { name, content } of Object.values(instrumentResult.files)) {
+      this.project.files.get(name)!.setContent(content);
+    }
+  }
+}

package/src/process/3-dry-run-executor.ts

@@ -0,0 +1,262 @@
+import { EOL } from 'os';
+
+import { I, requireResolve } from '@stryker-mutator/util';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens, Injector } from '@stryker-mutator/api/plugin';
+import { StrykerOptions, Mutant } from '@stryker-mutator/api/core';
+import { DryRunCompletedEvent, RunTiming } from '@stryker-mutator/api/report';
+import {
+  DryRunResult,
+  TestRunner,
+  DryRunStatus,
+  CompleteDryRunResult,
+  TestStatus,
+  TestResult,
+  FailedTestResult,
+  ErrorDryRunResult,
+} from '@stryker-mutator/api/test-runner';
+import { lastValueFrom, of } from 'rxjs';
+
+import { coreTokens } from '../di/index.js';
+import { Sandbox } from '../sandbox/sandbox.js';
+import { Timer } from '../utils/timer.js';
+import { createTestRunnerFactory } from '../test-runner/index.js';
+import { MutationTestReportHelper } from '../reporters/mutation-test-report-helper.js';
+import { ConfigError } from '../errors.js';
+import {
+  ConcurrencyTokenProvider,
+  Pool,
+  createTestRunnerPool,
+} from '../concurrent/index.js';
+import { FileMatcher } from '../config/index.js';
+import {
+  IncrementalDiffer,
+  MutantTestPlanner,
+  TestCoverage,
+} from '../mutants/index.js';
+import { CheckerFacade } from '../checker/index.js';
+import { StrictReporter } from '../reporters/index.js';
+import { objectUtils } from '../utils/object-utils.js';
+
+import { IdGenerator } from '../child-proxy/id-generator.js';
+
+import { MutationTestContext } from './4-mutation-test-executor.js';
+import { MutantInstrumenterContext } from './2-mutant-instrumenter-executor.js';
+
+const INITIAL_TEST_RUN_MARKER = 'Initial test run';
+
+export interface DryRunContext extends MutantInstrumenterContext {
+  [coreTokens.sandbox]: I<Sandbox>;
+  [coreTokens.mutants]: readonly Mutant[];
+  [coreTokens.checkerPool]: I<Pool<I<CheckerFacade>>>;
+  [coreTokens.concurrencyTokenProvider]: I<ConcurrencyTokenProvider>;
+}
+
+function isFailedTest(testResult: TestResult): testResult is FailedTestResult {
+  return testResult.status === TestStatus.Failed;
+}
+
+export class DryRunExecutor {
+  public static readonly inject = tokens(
+    commonTokens.injector,
+    commonTokens.logger,
+    commonTokens.options,
+    coreTokens.timer,
+    coreTokens.concurrencyTokenProvider,
+    coreTokens.sandbox,
+    coreTokens.reporter,
+  );
+
+  constructor(
+    private readonly injector: Injector<DryRunContext>,
+    private readonly log: Logger,
+    private readonly options: StrykerOptions,
+    private readonly timer: I<Timer>,
+    private readonly concurrencyTokenProvider: I<ConcurrencyTokenProvider>,
+    private readonly sandbox: I<Sandbox>,
+    private readonly reporter: StrictReporter,
+  ) {}
+
+  public async execute(): Promise<Injector<MutationTestContext>> {
+    const testRunnerInjector = this.injector
+      .provideClass(coreTokens.workerIdGenerator, IdGenerator)
+      .provideFactory(coreTokens.testRunnerFactory, createTestRunnerFactory)
+      .provideValue(
+        coreTokens.testRunnerConcurrencyTokens,
+        this.concurrencyTokenProvider.testRunnerToken$,
+      )
+      .provideFactory(coreTokens.testRunnerPool, createTestRunnerPool);
+    const testRunnerPool = testRunnerInjector.resolve(
+      coreTokens.testRunnerPool,
+    );
+    const { result, timing } = await lastValueFrom(
+      testRunnerPool.schedule(of(0), (testRunner) =>
+        this.executeDryRun(testRunner),
+      ),
+    );
+
+    this.logInitialTestRunSucceeded(result.tests, timing);
+    if (!result.tests.length && !this.options.allowEmpty) {
+      throw new ConfigError(
+        'No tests were executed. Stryker will exit prematurely. Please check your configuration.',
+      );
+    }
+
+    return testRunnerInjector
+      .provideValue(coreTokens.timeOverheadMS, timing.overhead)
+      .provideValue(coreTokens.dryRunResult, result)
+      .provideValue(coreTokens.requireFromCwd, requireResolve)
+      .provideFactory(coreTokens.testCoverage, TestCoverage.from)
+      .provideClass(coreTokens.incrementalDiffer, IncrementalDiffer)
+      .provideClass(coreTokens.mutantTestPlanner, MutantTestPlanner)
+      .provideClass(
+        coreTokens.mutationTestReportHelper,
+        MutationTestReportHelper,
+      )
+      .provideClass(coreTokens.workerIdGenerator, IdGenerator);
+  }
+
+  private validateResultCompleted(
+    runResult: DryRunResult,
+  ): asserts runResult is CompleteDryRunResult {
+    switch (runResult.status) {
+      case DryRunStatus.Complete: {
+        const failedTests = runResult.tests.filter(isFailedTest);
+        if (failedTests.length) {
+          this.logFailedTestsInInitialRun(failedTests);
+          throw new ConfigError(
+            'There were failed tests in the initial test run.',
+          );
+        }
+        return;
+      }
+      case DryRunStatus.Error:
+        this.logErrorsInInitialRun(runResult);
+        break;
+      case DryRunStatus.Timeout:
+        this.logTimeoutInitialRun();
+        break;
+    }
+    throw new Error('Something went wrong in the initial test run');
+  }
+
+  private async executeDryRun(
+    testRunner: TestRunner,
+  ): Promise<DryRunCompletedEvent> {
+    if (this.options.dryRunOnly) {
+      this.log.info(
+        'Note: running the dry-run only. No mutations will be tested.',
+      );
+    }
+
+    const dryRunTimeout = this.options.dryRunTimeoutMinutes * 1000 * 60;
+    const project = this.injector.resolve(coreTokens.project);
+    const dryRunFiles = objectUtils.map(project.filesToMutate, (_, name) =>
+      this.sandbox.sandboxFileFor(name),
+    );
+    const testFiles =
+      project.testFiles.length > 0
+        ? project.testFiles.map((file) => this.sandbox.sandboxFileFor(file))
+        : undefined;
+    this.timer.mark(INITIAL_TEST_RUN_MARKER);
+    this.log.info(
+      `Starting initial test run (${this.options.testRunner} test runner with "${this.options.coverageAnalysis}" coverage analysis). This may take a while.`,
+    );
+    this.log.debug(`Using timeout of ${dryRunTimeout} ms.`);
+    const result = await testRunner.dryRun({
+      timeout: dryRunTimeout,
+      coverageAnalysis: this.options.coverageAnalysis,
+      disableBail: this.options.disableBail,
+      files: dryRunFiles,
+      testFiles,
+    });
+    const grossTimeMS = this.timer.elapsedMs(INITIAL_TEST_RUN_MARKER);
+    const capabilities = await testRunner.capabilities();
+    this.validateResultCompleted(result);
+
+    this.remapSandboxFilesToOriginalFiles(result);
+    const timing = this.calculateTiming(grossTimeMS, result.tests);
+    const dryRunCompleted = { result, timing, capabilities };
+    this.reporter.onDryRunCompleted(dryRunCompleted);
+    return dryRunCompleted;
+  }
+
+  /**
+   * Remaps test files to their respective original names outside the sandbox.
+   * @param dryRunResult the completed result
+   */
+  private remapSandboxFilesToOriginalFiles(dryRunResult: CompleteDryRunResult) {
+    const disableTypeCheckingFileMatcher = new FileMatcher(
+      this.options.disableTypeChecks,
+    );
+    dryRunResult.tests.forEach((test) => {
+      if (test.fileName) {
+        test.fileName = this.sandbox.originalFileFor(test.fileName);
+
+        // HACK line numbers of the tests can be offset by 1 because the disable type checks preprocessor could have added a `// @ts-nocheck` line.
+        // We correct for that here if needed
+        // If we do more complex stuff in sandbox preprocessing in the future, we might want to add a robust remapping logic
+        if (
+          test.startPosition &&
+          disableTypeCheckingFileMatcher.matches(test.fileName)
+        ) {
+          test.startPosition.line--;
+        }
+      }
+    });
+  }
+
+  private logInitialTestRunSucceeded(tests: TestResult[], timing: RunTiming) {
+    if (!tests.length) {
+      this.log.info('No tests were found');
+      return;
+    }
+
+    this.log.info(
+      'Initial test run succeeded. Ran %s tests in %s (net %s ms, overhead %s ms).',
+      tests.length,
+      this.timer.humanReadableElapsed(INITIAL_TEST_RUN_MARKER),
+      timing.net,
+      timing.overhead,
+    );
+  }
+
+  /**
+   * Calculates the timing variables for the test run.
+   * grossTime = NetTime + overheadTime
+   *
+   * The overhead time is used to calculate exact timeout values during mutation testing.
+   * See timeoutMS setting in README for more information on this calculation
+   */
+  private calculateTiming(
+    grossTimeMS: number,
+    tests: readonly TestResult[],
+  ): RunTiming {
+    const netTimeMS = tests.reduce(
+      (total, test) => total + test.timeSpentMs,
+      0,
+    );
+    const overheadTimeMS = grossTimeMS - netTimeMS;
+    return {
+      net: netTimeMS,
+      overhead: overheadTimeMS < 0 ? 0 : overheadTimeMS,
+    };
+  }
+
+  private logFailedTestsInInitialRun(failedTests: FailedTestResult[]): void {
+    let message = 'One or more tests failed in the initial test run:';
+    failedTests.forEach((test) => {
+      message += `${EOL}\t${test.name}`;
+      message += `${EOL}\t\t${test.failureMessage}`;
+    });
+    this.log.error(message);
+  }
+  private logErrorsInInitialRun(runResult: ErrorDryRunResult) {
+    const message = `One or more tests resulted in an error:${EOL}\t${runResult.errorMessage}`;
+    this.log.error(message);
+  }
+
+  private logTimeoutInitialRun() {
+    this.log.error('Initial test run timed out!');
+  }
+}

package/src/process/4-mutation-test-executor.ts

@@ -0,0 +1,272 @@
+import {
+  from,
+  partition,
+  merge,
+  Observable,
+  lastValueFrom,
+  EMPTY,
+  concat,
+  bufferTime,
+  mergeMap,
+} from 'rxjs';
+import { toArray, map, shareReplay, tap } from 'rxjs/operators';
+import { tokens, commonTokens } from '@stryker-mutator/api/plugin';
+import {
+  MutantResult,
+  Mutant,
+  StrykerOptions,
+  PlanKind,
+  MutantTestPlan,
+  MutantRunPlan,
+} from '@stryker-mutator/api/core';
+import {
+  TestRunner,
+  CompleteDryRunResult,
+} from '@stryker-mutator/api/test-runner';
+import { Logger } from '@stryker-mutator/api/logging';
+import { I } from '@stryker-mutator/util';
+import { CheckStatus } from '@stryker-mutator/api/check';
+
+import { coreTokens } from '../di/index.js';
+import { StrictReporter } from '../reporters/strict-reporter.js';
+import { MutationTestReportHelper } from '../reporters/mutation-test-report-helper.js';
+import { Timer } from '../utils/timer.js';
+import { ConcurrencyTokenProvider, Pool } from '../concurrent/index.js';
+import { isEarlyResult, MutantTestPlanner } from '../mutants/index.js';
+import { CheckerFacade } from '../checker/index.js';
+
+import { DryRunContext } from './3-dry-run-executor.js';
+
+export interface MutationTestContext extends DryRunContext {
+  [coreTokens.testRunnerPool]: I<Pool<TestRunner>>;
+  [coreTokens.timeOverheadMS]: number;
+  [coreTokens.mutationTestReportHelper]: MutationTestReportHelper;
+  [coreTokens.mutantTestPlanner]: MutantTestPlanner;
+  [coreTokens.dryRunResult]: I<CompleteDryRunResult>;
+}
+
+const CHECK_BUFFER_MS = 10_000;
+
+/**
+ * Sorting the tests just before running them can yield a significant performance boost,
+ * because it can reduce the number of times a test runner process needs to be recreated.
+ * However, we need to buffer the results in order to be able to sort them.
+ *
+ * This value is very low, since it would halt the test execution otherwise.
+ * @see https://github.com/stryker-mutator/stryker-js/issues/3462
+ */
+const BUFFER_FOR_SORTING_MS = 0;
+
+export class MutationTestExecutor {
+  public static inject = tokens(
+    coreTokens.reporter,
+    coreTokens.testRunnerPool,
+    coreTokens.checkerPool,
+    coreTokens.mutants,
+    coreTokens.mutantTestPlanner,
+    coreTokens.mutationTestReportHelper,
+    commonTokens.logger,
+    commonTokens.options,
+    coreTokens.timer,
+    coreTokens.concurrencyTokenProvider,
+    coreTokens.dryRunResult,
+  );
+
+  constructor(
+    private readonly reporter: StrictReporter,
+    private readonly testRunnerPool: I<Pool<TestRunner>>,
+    private readonly checkerPool: I<Pool<I<CheckerFacade>>>,
+    private readonly mutants: readonly Mutant[],
+    private readonly planner: MutantTestPlanner,
+    private readonly mutationTestReportHelper: I<MutationTestReportHelper>,
+    private readonly log: Logger,
+    private readonly options: StrykerOptions,
+    private readonly timer: I<Timer>,
+    private readonly concurrencyTokenProvider: I<ConcurrencyTokenProvider>,
+    private readonly dryRunResult: CompleteDryRunResult,
+  ) {}
+
+  public async execute(): Promise<MutantResult[]> {
+    if (this.options.dryRunOnly) {
+      this.log.info(
+        'The dry-run has been completed successfully. No mutations have been executed.',
+      );
+      return [];
+    }
+
+    if (this.dryRunResult.tests.length === 0 && this.options.allowEmpty) {
+      this.logDone();
+      return [];
+    }
+
+    const mutantTestPlans = await this.planner.makePlan(this.mutants);
+    const { earlyResult$, runMutant$ } = this.executeEarlyResult(
+      from(mutantTestPlans),
+    );
+    const { passedMutant$, checkResult$ } = this.executeCheck(runMutant$);
+    const { coveredMutant$, noCoverageResult$ } =
+      this.executeNoCoverage(passedMutant$);
+    const testRunnerResult$ = this.executeRunInTestRunner(coveredMutant$);
+    const results = await lastValueFrom(
+      merge(
+        testRunnerResult$,
+        checkResult$,
+        noCoverageResult$,
+        earlyResult$,
+      ).pipe(toArray()),
+    );
+    await this.mutationTestReportHelper.reportAll(results);
+    await this.reporter.wrapUp();
+    this.logDone();
+    return results;
+  }
+
+  private executeEarlyResult(input$: Observable<MutantTestPlan>) {
+    const [earlyResultMutants$, runMutant$] = partition(
+      input$.pipe(shareReplay()),
+      isEarlyResult,
+    );
+    const earlyResult$ = earlyResultMutants$.pipe(
+      map(({ mutant }) =>
+        this.mutationTestReportHelper.reportMutantStatus(mutant, mutant.status),
+      ),
+    );
+    return { earlyResult$, runMutant$ };
+  }
+
+  private executeNoCoverage(input$: Observable<MutantRunPlan>) {
+    const [noCoverageMatchedMutant$, coveredMutant$] = partition(
+      input$.pipe(shareReplay()),
+      ({ runOptions }) => runOptions.testFilter?.length === 0,
+    );
+    const noCoverageResult$ = noCoverageMatchedMutant$.pipe(
+      map(({ mutant }) =>
+        this.mutationTestReportHelper.reportMutantStatus(mutant, 'NoCoverage'),
+      ),
+    );
+    return { noCoverageResult$, coveredMutant$ };
+  }
+
+  private executeRunInTestRunner(
+    input$: Observable<MutantRunPlan>,
+  ): Observable<MutantResult> {
+    const sortedPlan$ = input$.pipe(
+      bufferTime(BUFFER_FOR_SORTING_MS),
+      mergeMap((plans) => plans.sort(reloadEnvironmentLast)),
+    );
+    return this.testRunnerPool.schedule(
+      sortedPlan$,
+      async (testRunner, { mutant, runOptions }) => {
+        const result = await testRunner.mutantRun(runOptions);
+        return this.mutationTestReportHelper.reportMutantRunResult(
+          mutant,
+          result,
+        );
+      },
+    );
+  }
+
+  private logDone() {
+    this.log.info('Done in %s.', this.timer.humanReadableElapsed());
+  }
+
+  /**
+   * Checks mutants against all configured checkers (if any) and returns steams for failed checks and passed checks respectively
+   * @param input$ The mutant run plans to check
+   */
+  public executeCheck(input$: Observable<MutantRunPlan>): {
+    checkResult$: Observable<MutantResult>;
+    passedMutant$: Observable<MutantRunPlan>;
+  } {
+    let checkResult$: Observable<MutantResult> = EMPTY;
+    let passedMutant$ = input$;
+    for (const checkerName of this.options.checkers) {
+      // Use this checker
+      const [checkFailedResult$, checkPassedResult$] = partition(
+        this.executeSingleChecker(checkerName, passedMutant$).pipe(
+          shareReplay(),
+        ),
+        isEarlyResult,
+      );
+
+      // Prepare for the next one
+      passedMutant$ = checkPassedResult$;
+      checkResult$ = concat(
+        checkResult$,
+        checkFailedResult$.pipe(map(({ mutant }) => mutant)),
+      );
+    }
+    return {
+      checkResult$,
+      passedMutant$: passedMutant$.pipe(
+        tap({
+          complete: () => {
+            this.checkerPool
+              .dispose()
+              .then(() => {
+                this.concurrencyTokenProvider.freeCheckers();
+              })
+              .catch((error) => {
+                this.log.error(
+                  'An error occurred while disposing checkers: %s',
+                  error,
+                );
+              });
+          },
+        }),
+      ),
+    };
+  }
+
+  /**
+   * Executes the check task for one checker
+   * @param checkerName The name of the checker to execute
+   * @param input$ The mutants tasks to check
+   * @returns An observable stream with early results (check failed) and passed results
+   */
+  private executeSingleChecker(
+    checkerName: string,
+    input$: Observable<MutantRunPlan>,
+  ): Observable<MutantTestPlan> {
+    const group$ = this.checkerPool
+      .schedule(input$.pipe(bufferTime(CHECK_BUFFER_MS)), (checker, mutants) =>
+        checker.group(checkerName, mutants),
+      )
+      .pipe(mergeMap((mutantGroups) => mutantGroups));
+    const checkTask$ = this.checkerPool
+      .schedule(group$, (checker, group) => checker.check(checkerName, group))
+      .pipe(
+        mergeMap((mutantGroupResults) => mutantGroupResults),
+        map(([mutantRunPlan, checkResult]) =>
+          checkResult.status === CheckStatus.Passed
+            ? mutantRunPlan
+            : {
+                plan: PlanKind.EarlyResult as const,
+                mutant: this.mutationTestReportHelper.reportCheckFailed(
+                  mutantRunPlan.mutant,
+                  checkResult,
+                ),
+              },
+        ),
+      );
+    return checkTask$;
+  }
+}
+
+/**
+ * Sorting function that sorts mutant run plans that reload environments last.
+ * This can yield a significant performance boost, because it reduces the times a test runner process needs to restart.
+ * @see https://github.com/stryker-mutator/stryker-js/issues/3462
+ */
+function reloadEnvironmentLast(a: MutantRunPlan, b: MutantRunPlan): number {
+  if (a.plan === PlanKind.Run && b.plan === PlanKind.Run) {
+    if (a.runOptions.reloadEnvironment && !b.runOptions.reloadEnvironment) {
+      return 1;
+    }
+    if (!a.runOptions.reloadEnvironment && b.runOptions.reloadEnvironment) {
+      return -1;
+    }
+    return 0;
+  }
+  return 0;
+}

package/src/process/index.ts

@@ -0,0 +1,4 @@
+export * from './1-prepare-executor.js';
+export * from './2-mutant-instrumenter-executor.js';
+export * from './3-dry-run-executor.js';
+export * from './4-mutation-test-executor.js';