henitai 0.1.2 → 0.1.4

data/lib/henitai/result.rb

@@ -11,13 +11,15 @@ module Henitai
     include UnparseHelper
 
     SCHEMA_VERSION = "1.0"
+    DEFAULT_THRESHOLDS = { high: 80, low: 60 }.freeze
 
-    attr_reader :mutants, :started_at, :finished_at
+    attr_reader :mutants, :started_at, :finished_at, :thresholds
 
-    def initialize(mutants:, started_at:, finished_at:)
+    def initialize(mutants:, started_at:, finished_at:, thresholds: nil)
       @mutants     = mutants
       @started_at  = started_at
       @finished_at = finished_at
+      @thresholds  = DEFAULT_THRESHOLDS.merge(thresholds || {})
     end
 
     # @return [Integer] number of killed mutants
@@ -88,7 +90,7 @@ module Henitai
     def to_stryker_schema
       {
         schemaVersion: SCHEMA_VERSION,
-        thresholds: { high: 80, low: 60 },
+        thresholds: thresholds,
         files: build_files_section
       }
     end
@@ -119,7 +121,17 @@ module Henitai
         status: stryker_status(mutant.status),
         description: mutant.description,
         duration: duration_for(mutant)
-      }.compact
+      }.compact.merge(coverage_schema(mutant))
+    end
+
+    def coverage_schema(mutant)
+      covered_by = Array(mutant.covered_by).compact
+      return {} if covered_by.empty?
+
+      {
+        coveredBy: covered_by,
+        testsCompleted: mutant.tests_completed || covered_by.size
+      }
     end
 
     def replacement_for(mutant)

data/lib/henitai/runner.rb

@@ -35,18 +35,24 @@ module Henitai
     end
 
     # Entry point — runs the full pipeline and returns a Result.
+    #
+    # Coverage bootstrap (Gate 0) runs in a background thread so that Gate 1
+    # (subject resolution) and Gate 2 (mutant generation) proceed concurrently.
+    # The thread is joined before Gate 3 (static filtering), which is the first
+    # phase that requires coverage data.
+    #
+    # For targeted runs (`subjects:` provided), the bootstrap is further scoped
+    # to the spec files that cover the requested subjects rather than the full
+    # suite, reducing the baseline run time proportionally.
+    #
     # @return [Result]
     def run
       started_at = Time.now
       source_files = self.source_files
-      bootstrap_coverage(source_files)
       subjects = resolve_subjects(source_files)
-      mutants = generate_mutants(subjects)
-      mutants = filter_mutants(mutants)
-      mutants = execute_mutants(mutants)
-      finished_at = Time.now
+      mutants = execute_mutants(mutants_for(subjects, source_files))
 
-      build_result(mutants, started_at, finished_at)
+      build_result(mutants, started_at, Time.now)
     end
 
     private
@@ -69,6 +75,29 @@ module Henitai
       static_filter.apply(mutants, config)
     end
 
+    def mutants_for(subjects, source_files)
+      bootstrap_thread = bootstrap_mutants(source_files, subjects)
+      mutants = generate_mutants(subjects)
+      bootstrap_thread.value
+
+      filtered_mutants = filter_mutants(mutants)
+      return filtered_mutants unless targeted_run?
+
+      refresh_coverage_for_targeted_run(filtered_mutants, source_files)
+    end
+
+    def refresh_coverage_for_targeted_run(mutants, source_files)
+      return mutants unless retry_full_bootstrap?(mutants)
+
+      bootstrap_coverage(source_files)
+      filter_mutants(mutants)
+    end
+
+    def bootstrap_mutants(source_files, subjects)
+      scoped_tests = scoped_bootstrap_test_files(subjects)
+      Thread.new { bootstrap_coverage(source_files, scoped_tests) }
+    end
+
     def execute_mutants(mutants)
       execution_engine.run(
         mutants,
@@ -94,13 +123,33 @@ module Henitai
       @result = Result.new(
         mutants:,
         started_at:,
-        finished_at:
+        finished_at:,
+        thresholds: result_thresholds
       )
       persist_history(@result, finished_at)
       report(@result)
       @result
     end
 
+    # Returns the spec files to use for the coverage bootstrap.
+    #
+    # For full runs (no subject pattern given), returns nil so the bootstrapper
+    # falls back to the integration's full test-file list.
+    #
+    # For targeted runs, returns the union of test files selected for each
+    # resolved subject. Falls back to nil (all tests) if the selection is empty,
+    # so the bootstrapper always has a non-empty file list.
+    def scoped_bootstrap_test_files(subjects)
+      return nil if pattern_subjects.empty?
+
+      files = subjects.flat_map { |subject| integration.select_tests(subject) }.uniq
+      files.empty? ? nil : files
+    end
+
+    def bootstrap_coverage(source_files, test_files = nil)
+      coverage_bootstrapper.ensure!(source_files:, config:, integration:, test_files:)
+    end
+
     def subject_resolver
       @subject_resolver ||= SubjectResolver.new
     end
@@ -125,10 +174,6 @@ module Henitai
       @coverage_bootstrapper ||= CoverageBootstrapper.new
     end
 
-    def bootstrap_coverage(source_files)
-      coverage_bootstrapper.ensure!(source_files:, config:, integration:)
-    end
-
     def integration
       @integration ||= Integration.for(config.integration).new
     end
@@ -172,6 +217,19 @@ module Henitai
       Array(@subjects)
     end
 
+    def targeted_run?
+      !pattern_subjects.empty?
+    end
+
+    def retry_full_bootstrap?(mutants)
+      executable_mutants = Array(mutants).reject do |mutant|
+        %i[ignored compile_error equivalent].include?(mutant.status)
+      end
+      return false if executable_mutants.empty?
+
+      executable_mutants.all? { |mutant| mutant.status == :no_coverage }
+    end
+
     def unique_subjects(subjects)
       subjects.uniq { |subject| [subject.expression, subject.source_file] }
     end
@@ -179,5 +237,11 @@ module Henitai
     def normalize_path(path)
       File.expand_path(path)
     end
+
+    def result_thresholds
+      return nil unless config.respond_to?(:thresholds)
+
+      config.thresholds
+    end
   end
 end

data/lib/henitai/scenario_execution_result.rb

@@ -5,6 +5,16 @@ module Henitai
   class ScenarioExecutionResult
     attr_reader :status, :stdout, :stderr, :exit_status, :log_path
 
+    def self.build(wait_result:, stdout:, stderr:, log_path:)
+      new(
+        status: status_for(wait_result),
+        stdout: stdout,
+        stderr: stderr,
+        log_path: log_path,
+        exit_status: exit_status_for(wait_result)
+      )
+    end
+
     def initialize(status:, stdout:, stderr:, log_path:, exit_status: nil)
       @status = status
       @stdout = stdout.to_s
@@ -51,11 +61,11 @@ module Henitai
       log_text.lines.last(lines).join
     end
 
-    def should_show_logs?(all_logs: false)
+    def should_show_logs?(all_logs: nil)
       all_logs || timeout?
     end
 
-    def failure_tail(all_logs: false, lines: 12)
+    def failure_tail(all_logs: nil, lines: 12)
       return combined_output if all_logs
       return "" unless should_show_logs?(all_logs:)
 
@@ -64,6 +74,25 @@ module Henitai
 
     private
 
+    class << self
+      private
+
+      def status_for(wait_result)
+        return :timeout if wait_result == :timeout
+        return :compile_error if exit_status_for(wait_result) == 2
+        return :survived if wait_result.respond_to?(:success?) && wait_result.success?
+
+        :killed
+      end
+
+      def exit_status_for(wait_result)
+        return nil if wait_result == :timeout
+        return nil unless wait_result.respond_to?(:exitstatus)
+
+        wait_result.exitstatus
+      end
+    end
+
     def stream_section(name, content)
       "#{name}:\n#{content}"
     end

data/lib/henitai/source_parser.rb

@@ -12,12 +12,23 @@ module Henitai
   class SourceParser
     DEFAULT_PATH = "(string)"
 
+    @cache = {}
+
     def self.parse(source, path: DEFAULT_PATH)
       new.parse(source, path:)
     end
 
+    # Returns the parsed AST for +path+, re-using a cached result when the
+    # file's mtime has not changed. This avoids parsing the same file twice
+    # across pipeline phases (e.g. SubjectResolver then MutantGenerator).
     def self.parse_file(path)
-      new.parse_file(path)
+      key = [path, File.mtime(path)]
+      @cache[key] ||= new.parse_file(path)
+    end
+
+    # Clears the parse cache. Intended for test isolation.
+    def self.clear_cache!
+      @cache.clear
     end
 
     def parse(source, path: DEFAULT_PATH)

data/lib/henitai/static_filter.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require "json"
+require_relative "coverage_report_reader"
 
 module Henitai
   # Applies static, pre-execution filtering to generated mutants.
   class StaticFilter
-    DEFAULT_COVERAGE_REPORT_PATH = "coverage/.resultset.json"
-    DEFAULT_PER_TEST_COVERAGE_REPORT_PATH = "coverage/henitai_per_test.json"
+    DEFAULT_COVERAGE_REPORT_PATH = CoverageReportReader::DEFAULT_COVERAGE_REPORT_PATH
+    DEFAULT_PER_TEST_COVERAGE_REPORT_PATH = CoverageReportReader::DEFAULT_PER_TEST_COVERAGE_REPORT_PATH
+
+    def initialize(coverage_report_reader: CoverageReportReader.new)
+      @coverage_report_reader = coverage_report_reader
+    end
 
     # This method is the gate-level filter orchestrator.
     def apply(mutants, config)
@@ -41,31 +45,17 @@ module Henitai
     end
 
     def coverage_lines_by_file(path = DEFAULT_COVERAGE_REPORT_PATH)
-      return {} unless File.exist?(path)
-
-      coverage = Hash.new { |hash, key| hash[key] = [] }
-      JSON.parse(File.read(path)).each_value do |result|
-        result.fetch("coverage", {}).each do |file, file_coverage|
-          coverage[normalize_path(file)].concat(covered_lines(file_coverage))
-        end
-      end
-
-      coverage.transform_values(&:uniq).transform_values(&:sort)
+      coverage_report_reader.coverage_lines_by_file(path)
     end
 
     def test_lines_by_file(path = DEFAULT_PER_TEST_COVERAGE_REPORT_PATH)
-      return {} unless File.exist?(path)
-
-      parsed = JSON.parse(File.read(path))
-      return {} unless parsed.is_a?(Hash)
-
-      parsed.transform_values do |coverage|
-        normalize_test_coverage(coverage)
-      end
+      coverage_report_reader.test_lines_by_file(path)
     end
 
     private
 
+    attr_reader :coverage_report_reader
+
     def ignored?(mutant, config)
       source = source_for(mutant)
       return false unless source
@@ -151,23 +141,6 @@ module Henitai
       (m.captures.first.to_i..m.captures.last.to_i)
     end
 
-    def covered_lines(file_coverage)
-      Array(file_coverage["lines"]).each_with_index.filter_map do |count, index|
-        index + 1 if count.to_i.positive?
-      end
-    end
-
-    def normalize_test_coverage(coverage)
-      case coverage
-      when Hash
-        coverage.transform_values do |lines|
-          Array(lines).grep(Integer).uniq.sort
-        end
-      else
-        Array(coverage).grep(Integer).uniq.sort
-      end
-    end
-
     def coverage_lines_from_test_lines(test_lines)
       coverage = Hash.new { |hash, key| hash[key] = [] }
 
@@ -183,10 +156,16 @@ module Henitai
     end
 
     def normalize_path(path)
+      @normalize_path_cache ||= {}
+      return @normalize_path_cache[path] if @normalize_path_cache.key?(path)
+
       expanded = File.expand_path(path)
-      File.realpath(expanded)
-    rescue Errno::ENOENT, Errno::ENOTDIR
-      expanded
+      resolved = begin
+        File.realpath(expanded)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        expanded
+      end
+      @normalize_path_cache[path] = resolved
     end
 
     def equivalence_detector

data/lib/henitai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Henitai
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/lib/henitai.rb

@@ -22,6 +22,8 @@ module Henitai
 
   autoload :Configuration, "henitai/configuration"
   autoload :CoverageBootstrapper, "henitai/coverage_bootstrapper"
+  autoload :CoverageReportReader, "henitai/coverage_report_reader"
+  autoload :PerTestCoverageSelector, "henitai/per_test_coverage_selector"
   autoload :Subject, "henitai/subject"
   autoload :Mutant, "henitai/mutant"
   autoload :Operator, "henitai/operator"
@@ -33,6 +35,7 @@ module Henitai
   autoload :MutantGenerator, "henitai/mutant_generator"
   autoload :MutantHistoryStore, "henitai/mutant_history_store"
   autoload :AridNodeFilter, "henitai/arid_node_filter"
+  autoload :AvailableCpuCount, "henitai/available_cpu_count"
   autoload :EquivalenceDetector, "henitai/equivalence_detector"
   autoload :StaticFilter, "henitai/static_filter"
   autoload :StillbornFilter, "henitai/stillborn_filter"

data/sig/henitai.rbs

@@ -112,6 +112,7 @@ module Henitai
     attr_reader exit_status: Integer?
     attr_reader log_path: String
 
+    def self.build: (wait_result: untyped, stdout: String?, stderr: String?, log_path: String) -> ScenarioExecutionResult
     def initialize: (status: Symbol, stdout: String?, stderr: String?, log_path: String, ?exit_status: Integer?) -> void
     def survived?: () -> bool
     def killed?: () -> bool
@@ -121,6 +122,11 @@ module Henitai
     def tail: (?Integer) -> String
     def should_show_logs?: (?all_logs: bool) -> bool
     def failure_tail: (?all_logs: bool, ?lines: Integer) -> String
+
+    private
+
+    def self.status_for: (untyped) -> Symbol
+    def self.exit_status_for: (untyped) -> Integer?
   end
 
   class Subject
@@ -154,6 +160,8 @@ module Henitai
     attr_accessor status: Symbol
     attr_accessor killing_test: String?
     attr_accessor duration: Float?
+    attr_accessor covered_by: Array[String]?
+    attr_accessor tests_completed: Integer?
 
     def initialize: (subject: Subject, operator: String, nodes: Hash[Symbol, untyped], description: String, location: Hash[Symbol, untyped]) -> void
     def killed?: () -> bool
@@ -223,15 +231,30 @@ module Henitai
       def test_files: () -> Array[String]
       def run_mutant: (mutant: Mutant, test_files: Array[String], timeout: Float) -> ScenarioExecutionResult
       def run_suite: (Array[String], ?timeout: Float) -> ScenarioExecutionResult
+      def per_test_coverage_supported?: () -> bool
+      def wait_with_timeout: (Integer, Float) -> untyped
+      def reap_child: (Integer) -> void
+      def cleanup_process_group: (Integer) -> void
 
       private
 
       def pause: (Float) -> void
+      def handle_timeout: (Integer) -> Symbol
+      def cleanup_child_process: (Integer) -> void
+      def rspec_options: () -> Array[String]
+      def subprocess_env: () -> Hash[String, String]
+      def scenario_log_support: () -> ScenarioLogSupport
+      def with_subprocess_env: () { () -> untyped } -> untyped
+      def restore_subprocess_env: (Hash[String, String?]) -> void
+      def spawn_suite_process: (Array[String], Hash[Symbol, String]) -> Integer
     end
 
     class ScenarioLogSupport
       def capture_child_output: (Hash[Symbol, String]) { () -> untyped } -> untyped
       def with_coverage_dir: (String) { () -> untyped } -> untyped
+      def read_log_file: (String) -> String
+      def write_combined_log: (String, String, String) -> void
+      def combined_log: (String, String) -> String
 
       private
 
@@ -248,6 +271,11 @@ module Henitai
       def stderr_stream: () -> IO
     end
 
+    class RspecProcessRunner
+      def run_mutant: (Rspec, mutant: Mutant, test_files: Array[String], timeout: Float) -> ScenarioExecutionResult
+      def run_suite: (Rspec, Array[String], timeout: Float) -> ScenarioExecutionResult
+    end
+
     class Rspec < Base
       REQUIRE_DIRECTIVE_PATTERN: Regexp
       DEFAULT_SUITE_TIMEOUT: Float
@@ -256,13 +284,12 @@ module Henitai
       def test_files: () -> Array[String]
       def run_mutant: (mutant: Mutant, test_files: Array[String], timeout: Float) -> ScenarioExecutionResult
       def run_suite: (Array[String], ?timeout: Float) -> ScenarioExecutionResult
+      def per_test_coverage_supported?: () -> bool
 
       private
 
       def run_in_child: (mutant: Mutant, test_files: Array[String], log_paths: Hash[Symbol, String]) -> Integer
       def suite_command: (Array[String]) -> Array[String]
-      def wait_with_timeout: (Integer, Float) -> untyped
-      def handle_timeout: (Integer) -> Symbol
       def build_result: (untyped, Hash[Symbol, String]) -> ScenarioExecutionResult
       def scenario_status: (untyped) -> Symbol
       def exit_status_for: (untyped) -> Integer?
@@ -271,8 +298,7 @@ module Henitai
       def combined_log: (String, String) -> String
       def scenario_log_paths: (String) -> Hash[Symbol, String]
       def run_tests: (Array[String]) -> Integer
-      def scenario_log_support: () -> ScenarioLogSupport
-      def rspec_options: () -> Array[String]
+      def with_subprocess_env: () { () -> untyped } -> untyped
       def spec_files: () -> Array[String]
       def fallback_spec_files: (Subject) -> Array[String]
       def selection_patterns: (Subject) -> Array[String]
@@ -283,7 +309,6 @@ module Henitai
       def relative_candidates: (String, String) -> Array[String]
       def require_candidates: (String, String) -> Array[String]
       def expand_candidates: (String, String) -> Array[String]
-      def reap_child: (Integer) -> void
     end
 
     class Minitest < Rspec
@@ -293,11 +318,11 @@ module Henitai
       private
 
       def run_in_child: (mutant: Mutant, test_files: Array[String], log_paths: Hash[Symbol, String]) -> Integer
-      def suite_command: (Array[String]) -> Array[String]
       def run_tests: (Array[String]) -> Integer
       def preload_environment: () -> void
       def setup_load_path: () -> void
       def subprocess_env: () -> Hash[String, String]
+      def cleanup_suite_process: (Integer?, untyped) -> void
       def spec_files: () -> Array[String]
     end
   end
@@ -347,13 +372,29 @@ module Henitai
     def fallback_source: (untyped) -> String
   end
 
+  class CoverageReportReader
+    def coverage_lines_by_file: (?String) -> Hash[String, Array[Integer]]
+    def test_lines_by_file: (?String) -> Hash[String, Hash[String, Array[Integer]]]
+  end
+
+  class ParallelExecutionRunner
+    def initialize: (worker_count: Integer) -> void
+    def run: (Array[Mutant], untyped, untyped, untyped, ?Hash[Symbol, untyped]) -> void
+  end
+
   class StaticFilter
+    def initialize: (?coverage_report_reader: CoverageReportReader) -> void
     def apply: (Array[Mutant], untyped) -> Array[Mutant]
     def coverage_lines_for: (untyped) -> Hash[String, Array[Integer]]
     def coverage_lines_by_file: (?String) -> Hash[String, Array[Integer]]
     def test_lines_by_file: (?String) -> Hash[String, Hash[String, Array[Integer]]]
   end
 
+  class PerTestCoverageSelector
+    def initialize: (?coverage_report_reader: CoverageReportReader) -> void
+    def filter: (Array[String], Mutant, reports_dir: String) -> Array[String]
+  end
+
   class ExecutionEngine
     def run: (Array[Mutant], untyped, untyped, ?progress_reporter: untyped) -> Array[Mutant]
 
@@ -363,6 +404,8 @@ module Henitai
     def worker_count: (untyped) -> Integer
     def run_linear: (Array[Mutant], untyped, untyped, untyped?, untyped) -> void
     def run_parallel: (Array[Mutant], untyped, untyped, untyped?, untyped) -> void
+    def pipe_stdin?: () -> bool
+    def start_stdin_watcher: () { () -> void } -> Thread
     def process_mutant: (Mutant, untyped, untyped, untyped?, ?untyped) -> void
     def prioritized_tests_for: (Mutant, untyped, untyped) -> Array[String]
     def test_prioritizer: () -> TestPrioritizer
@@ -437,6 +480,7 @@ module Henitai
       def survived_mutant_header: (Mutant) -> String
       def original_line: (Mutant) -> String
       def mutated_line: (Mutant) -> String
+      def display_unparse: (untyped) -> String
       def score_line: (Result) -> String
       def format_row: (String, untyped) -> String
       def count_status: (Result, Symbol) -> Integer
@@ -507,12 +551,14 @@ module Henitai
     include UnparseHelper
 
     SCHEMA_VERSION: String
+    DEFAULT_THRESHOLDS: Hash[Symbol, Integer]
 
     attr_reader mutants: Array[Mutant]
     attr_reader started_at: Time
     attr_reader finished_at: Time
+    attr_reader thresholds: Hash[Symbol, Integer]
 
-    def initialize: (mutants: Array[Mutant], started_at: Time, finished_at: Time) -> void
+    def initialize: (mutants: Array[Mutant], started_at: Time, finished_at: Time, ?thresholds: Hash[Symbol, Integer]?) -> void
     def killed: () -> Integer
     def survived: () -> Integer
     def equivalent: () -> Integer
@@ -527,6 +573,7 @@ module Henitai
 
     def build_files_section: () -> Hash[Symbol, untyped]
     def mutant_to_schema: (Mutant) -> Hash[Symbol, untyped]
+    def coverage_schema: (Mutant) -> Hash[Symbol, untyped]
     def replacement_for: (Mutant) -> String
     def location_for: (Mutant) -> Hash[Symbol, untyped]
     def line_column: (Mutant, Symbol) -> Hash[Symbol, Integer]
@@ -566,19 +613,28 @@ module Henitai
 
     def build_result: (Array[Mutant], Time, Time) -> Result
     def persist_history: (Result, Time) -> void
-    def bootstrap_coverage: (Array[String]) -> void
+    def refresh_coverage_for_targeted_run: (Array[Mutant], Array[String]) -> Array[Mutant]
+    def bootstrap_coverage: (Array[String], ?Array[String]?) -> void
+    def bootstrap_mutants: (Array[String], Array[Subject]) -> Thread
+    def mutants_for: (Array[Subject], Array[String]) -> Array[Mutant]
+    def scoped_bootstrap_test_files: (Array[Subject]) -> Array[String]?
+    def targeted_run?: () -> bool
+    def retry_full_bootstrap?: (Array[Mutant]) -> bool
     def with_reports_dir: () { () -> untyped } -> untyped
+    def result_thresholds: () -> Hash[Symbol, Integer]?
   end
 
   class CoverageBootstrapper
     def initialize: (?static_filter: StaticFilter) -> void
-    def ensure!: (source_files: Array[String], config: Configuration, integration: Integration::Base) -> void
+    def ensure!: (source_files: Array[String], config: Configuration, integration: Integration::Base, ?test_files: Array[String]?) -> void
 
     private
 
     def static_filter: () -> StaticFilter
     def coverage_available?: (Array[String], Configuration) -> bool
-    def bootstrap_coverage: (Integration::Base, Configuration) -> void
+    def coverage_fresh?: (Array[String], Configuration, Integration::Base, Array[String]?) -> bool
+    def coverage_report_path: (Configuration) -> String
+    def bootstrap_coverage: (Integration::Base, Configuration, ?Array[String]?) -> void
     def source_file_paths: (Array[String]) -> Array[String]
   end
 

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: henitai
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Martin Otten
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -88,15 +89,19 @@ files:
 - exe/henitai
 - lib/henitai.rb
 - lib/henitai/arid_node_filter.rb
+- lib/henitai/available_cpu_count.rb
 - lib/henitai/cli.rb
 - lib/henitai/configuration.rb
 - lib/henitai/configuration_validator.rb
 - lib/henitai/coverage_bootstrapper.rb
 - lib/henitai/coverage_formatter.rb
+- lib/henitai/coverage_report_reader.rb
+- lib/henitai/eager_load.rb
 - lib/henitai/equivalence_detector.rb
 - lib/henitai/execution_engine.rb
 - lib/henitai/git_diff_analyzer.rb
 - lib/henitai/integration.rb
+- lib/henitai/integration/rspec_process_runner.rb
 - lib/henitai/minitest_simplecov.rb
 - lib/henitai/mutant.rb
 - lib/henitai/mutant/activator.rb
@@ -113,13 +118,19 @@ files:
 - lib/henitai/operators/equality_operator.rb
 - lib/henitai/operators/hash_literal.rb
 - lib/henitai/operators/logical_operator.rb
+- lib/henitai/operators/method_chain_unwrap.rb
 - lib/henitai/operators/method_expression.rb
 - lib/henitai/operators/pattern_match.rb
 - lib/henitai/operators/range_literal.rb
+- lib/henitai/operators/regex_mutator.rb
 - lib/henitai/operators/return_value.rb
 - lib/henitai/operators/safe_navigation.rb
 - lib/henitai/operators/string_literal.rb
+- lib/henitai/operators/unary_operator.rb
+- lib/henitai/operators/update_operator.rb
+- lib/henitai/parallel_execution_runner.rb
 - lib/henitai/parser_current.rb
+- lib/henitai/per_test_coverage_selector.rb
 - lib/henitai/reporter.rb
 - lib/henitai/result.rb
 - lib/henitai/rspec_coverage_formatter.rb
@@ -147,8 +158,9 @@ metadata:
   changelog_uri: https://github.com/martinotten/henitai/blob/main/CHANGELOG.md
   documentation_uri: https://github.com/martinotten/henitai/blob/main/README.md
   homepage_uri: https://github.com/martinotten/henitai
-  source_code_uri: https://github.com/martinotten/henitai/tree/v0.1.2
+  source_code_uri: https://github.com/martinotten/henitai/tree/v0.1.4
   rubygems_mfa_required: 'true'
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -163,7 +175,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.3.5
+signing_key: 
 specification_version: 4
 summary: Mutation testing for Ruby
 test_files: []