henitai 0.4.0 → 0.5.1

data/lib/henitai/slot_scheduler.rb

@@ -2,6 +2,11 @@
 
 require_relative "slot_scheduler/process_control"
 require_relative "slot_scheduler/draining"
+require_relative "slot_scheduler/drain_verdict"
+require_relative "slot_scheduler/retry_policy"
+require_relative "slot_scheduler/slot_deadline"
+require_relative "slot_scheduler/slot_table"
+require_relative "slot_scheduler/test_file_selection"
 
 module Henitai
   # Owns the process-slot table for a single parallel mutation run.
@@ -40,18 +45,23 @@ module Henitai
     # @return [Array<ScenarioExecutionResult>] verdicts accumulated so far.
     attr_reader :flaky_retry_count, :results
 
-    def initialize(integration:, config:, progress_reporter:, options:, host:)
+    # +slot_table+ is injectable so a spec can seed mid-run state, or assert
+    # against the table through its own public interface, without reaching a
+    # private reader here.
+    # rubocop:disable Metrics/ParameterLists -- every one of these is a distinct
+    # collaborator supplied by ProcessWorkerRunner; bundling them into a context
+    # object would only move the list.
+    def initialize(integration:, config:, progress_reporter:, options:, host:, slot_table: SlotTable.new)
+      # rubocop:enable Metrics/ParameterLists
       @integration = integration
       @config = config
       @progress_reporter = progress_reporter
       @options = options
       @host = host
+      @slot_table = slot_table
       @pending = []
-      @slots = {}
-      @pid_to_slot = {}
       @results = []
       @flaky_retry_count = 0
-      @next_slot_id = 0
     end
 
     # Queues the mutants to be scheduled into worker slots.
@@ -60,11 +70,11 @@ module Henitai
     end
 
     def done?
-      pending.empty? && slots.empty?
+      pending.empty? && slot_table.empty?
     end
 
     def fill_idle_slots
-      while slots.size < worker_count && !pending.empty?
+      while slot_table.size < worker_count && !pending.empty?
         mutant = pending.shift
         spawn_into_slot(mutant)
       end
@@ -83,8 +93,8 @@ module Henitai
 
     def next_event_timeout
       now = monotonic_time
-      slot_timeouts = slots.each_value.filter_map do |slot|
-        remaining_slot_timeout(slot, now)
+      slot_timeouts = slot_table.each_value.filter_map do |slot|
+        slot_deadline.remaining(slot, now)
       end
 
       slot_timeouts.min
@@ -92,7 +102,7 @@ module Henitai
 
     private
 
-    attr_reader :pending, :slots, :pid_to_slot, :integration, :config,
+    attr_reader :pending, :slot_table, :integration, :config,
                 :progress_reporter, :options, :host
 
     def worker_count = host.worker_count
@@ -101,12 +111,12 @@ module Henitai
     def shutdown? = host.shutdown_requested?
 
     def spawn_into_slot(mutant)
-      test_files = resolve_test_files(mutant)
-      mutant.covered_by = test_files if mutant.respond_to?(:covered_by=)
-      mutant.tests_completed = test_files.size if mutant.respond_to?(:tests_completed=)
-      return record_no_coverage(mutant) if resolved_selection_empty?(test_files)
+      selection = test_file_selection
+      test_files = selection.for(mutant)
+      annotate_selection(mutant, test_files)
+      return record_no_coverage(mutant) if selection.resolved_empty?(test_files)
 
-      worker_index = next_free_worker_index
+      worker_index = slot_table.next_free_worker_index(worker_count)
       with_worker_slot(worker_index) do
         handle = integration.spawn_mutant(mutant: mutant, test_files: test_files)
         register_slot(handle, mutant, worker_index, slot_timeout(mutant, test_files))
@@ -115,11 +125,18 @@ module Henitai
       record_spawn_failure(mutant, e)
     end
 
+    # Reported back onto the mutant so the report can show which tests were
+    # considered, whether or not any of them ran. Guarded by respond_to? because
+    # specs pass Struct stand-ins without these members.
+    def annotate_selection(mutant, test_files)
+      mutant.covered_by = test_files if mutant.respond_to?(:covered_by=)
+      mutant.tests_completed = test_files.size if mutant.respond_to?(:tests_completed=)
+    end
+
     def register_slot(handle, mutant, worker_index, timeout)
-      slot_id = next_slot_id!
-      slot = build_slot(slot_id, mutant, handle, worker_index, timeout)
-      slots[slot_id] = slot
-      pid_to_slot[handle.pid] = slot_id
+      slot = build_slot(slot_table.next_slot_id!, mutant, handle, worker_index, timeout)
+      slot_table.add(slot)
+      slot_table.register_pid(handle.pid, slot.slot_id)
       Integration::SchedulerDiagnostics.child_started(handle.pid)
     end
 
@@ -137,20 +154,11 @@ module Henitai
       resolver ? resolver.call(mutant, test_files) : config.timeout
     end
 
-    # Smallest index in 0...worker_count not held by a live slot, so
-    # concurrently-running children always see distinct values and freed
-    # indices are reused. Slot ids themselves grow monotonically and are
-    # unsuitable as a resource token.
-    def next_free_worker_index
-      used = slots.each_value.map(&:worker_index)
-      (0...worker_count).find { |index| !used.include?(index) } || used.size
-    end
-
     def complete_slot(pid, wait_result)
-      slot_id = pid_to_slot.delete(pid)
+      slot_id = slot_table.release_pid(pid)
       return unless slot_id
 
-      slot = slots[slot_id]
+      slot = slot_table.fetch(slot_id)
       return unless slot
 
       Integration::SchedulerDiagnostics.child_ended(pid)
@@ -159,29 +167,46 @@ module Henitai
     end
 
     def dispatch_slot_result(slot, result)
-      if should_retry?(slot, result)
-        retry_slot(slot)
-      else
-        slots.delete(slot.slot_id)
-        slot.mutant.status = result.status
-        results << result
-        progress_reporter&.progress(slot.mutant, scenario_result: result)
-        result.release_output! if result.respond_to?(:release_output!)
-      end
+      return retry_slot(slot) if retry_policy.retry?(slot: slot, result: result, shutdown: shutdown?)
+
+      finalize_slot(slot, result)
+    end
+
+    def finalize_slot(slot, result)
+      slot_table.delete(slot.slot_id)
+      slot.mutant.status = result.status
+      results << result
+      progress_reporter&.progress(slot.mutant, scenario_result: result)
+      result.release_output! if result.respond_to?(:release_output!)
+    end
+
+    # Memoized lazily, not built in #initialize: specs (and the no-op scheduler
+    # the runner builds when nothing is pending) pass `config: nil`, and this
+    # is only reached once a slot has actually finished.
+    def retry_policy
+      @retry_policy ||= RetryPolicy.new(max_retries: config.max_flaky_retries)
+    end
+
+    def drain_verdict
+      @drain_verdict ||= DrainVerdict.new(integration: integration)
+    end
+
+    def slot_deadline
+      @slot_deadline ||= SlotDeadline.new(drain_window: PROCESS_DRAIN_WINDOW)
     end
 
-    def should_retry?(slot, result)
-      !shutdown? && result.survived? && slot.retry_count < config.max_flaky_retries.to_i
+    def test_file_selection
+      @test_file_selection ||= TestFileSelection.new(options: options, integration: integration)
     end
 
     def retry_slot(slot)
-      test_files = resolve_test_files(slot.mutant)
+      test_files = test_file_selection.for(slot.mutant)
       with_worker_slot(slot.worker_index) do
         handle = integration.spawn_mutant(mutant: slot.mutant, test_files: test_files)
         finish_retry(slot, handle)
       end
     rescue StandardError => e
-      slots.delete(slot.slot_id)
+      slot_table.delete(slot.slot_id)
       record_spawn_failure(slot.mutant, e)
     end
 
@@ -189,7 +214,7 @@ module Henitai
       @flaky_retry_count += 1 if slot.retry_count.zero?
       slot.retry_count += 1
       reset_slot_for_retry(slot, handle)
-      pid_to_slot[handle.pid] = slot.slot_id
+      slot_table.register_pid(handle.pid, slot.slot_id)
       Integration::SchedulerDiagnostics.child_started(handle.pid)
     end
 
@@ -220,43 +245,6 @@ module Henitai
       progress_reporter&.progress(mutant, scenario_result: nil)
     end
 
-    def resolved_selection_empty?(test_files)
-      options.key?(:test_file_resolver) && test_files.empty?
-    end
-
-    def remaining_slot_timeout(slot, now)
-      # Invariant: drain_draining_slots runs (and removes draining slots) before
-      # the event wait, so next_event_timeout never observes a draining slot
-      # whose SIGTERM has not been sent. Guard term_sent_at_monotonic defensively
-      # against a future ordering change: an unsignalled draining slot is due now.
-      return 0.0 if slot.draining && slot.term_sent_at_monotonic.nil?
-
-      deadline =
-        if slot.draining
-          slot.term_sent_at_monotonic + PROCESS_DRAIN_WINDOW
-        else
-          slot.started_at_monotonic + slot.timeout
-        end
-      remaining = deadline - now
-      remaining.positive? ? remaining : 0.0
-    end
-
-    def resolve_test_files(mutant)
-      if @options.key?(:test_file_resolver)
-        @options[:test_file_resolver].call(mutant)
-      elsif @options.key?(:test_files)
-        @options[:test_files]
-      else
-        integration.select_tests(mutant.subject)
-      end
-    end
-
-    def next_slot_id!
-      id = @next_slot_id
-      @next_slot_id += 1
-      id
-    end
-
     def with_worker_slot(worker_index)
       previous = ENV.fetch(WORKER_SLOT_ENV, nil)
       ENV[WORKER_SLOT_ENV] = worker_index.to_s

data/lib/henitai/source_file_selection.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Resolves which source files a run mutates: everything under `includes:`,
+  # minus anything matched by `excludes:`, optionally narrowed to what changed
+  # since a git ref.
+  #
+  # Excludes are absolute, not a tiebreak: an excluded file (a standalone entry
+  # point that cannot be mutation-tested in-process, say) stays excluded even
+  # when it is the only thing that changed. Both stages are filters over the
+  # same list, so they commute — excludes run first only to keep the
+  # per-test-coverage lookups in `filter_changed` off files that are already
+  # out of scope.
+  class SourceFileSelection
+    def initialize(config:, since:, git_diff_analyzer:, per_test_coverage:)
+      @config = config
+      @since = since
+      @git_diff_analyzer = git_diff_analyzer
+      @per_test_coverage = per_test_coverage
+    end
+
+    def call
+      filter_changed(reject_excluded(included_source_files))
+    end
+
+    def included_source_files
+      Array(@config.includes).flat_map do |include_path|
+        Dir.glob(File.join(include_path, "**", "*.rb"))
+      end.uniq
+    end
+
+    # Drops files matched by any `excludes:` glob. Compared as expanded paths so
+    # a relative glob and an absolute candidate still match.
+    def reject_excluded(files)
+      excluded = excluded_source_files
+      return files if excluded.empty?
+
+      files.reject { |path| excluded.include?(normalize_path(path)) }
+    end
+
+    def filter_changed(files)
+      return files unless @since
+
+      changed = changed_paths_since.map { |path| normalize_path(path) }
+      changed += covered_sources_for_changed_tests(changed)
+      files.select { |path| changed.include?(normalize_path(path)) }
+    end
+
+    private
+
+    def excluded_source_files
+      Array(@config.excludes)
+        .flat_map { |pattern| Dir.glob(pattern) }
+        .map { |path| normalize_path(path) }
+    end
+
+    # Committed changes since the ref plus the current working tree (tracked
+    # dirty and untracked files): the working tree is what gets tested, so it is
+    # always part of "changed since REF".
+    def changed_paths_since
+      @git_diff_analyzer.changed_files(from: @since, to: "HEAD") +
+        @git_diff_analyzer.working_tree_changed_files
+    end
+
+    # Changed test files select the source files they cover, so an edited test
+    # re-tests the subjects it can kill. Uses the per-test map from the previous
+    # run — Gate 1 runs before this run's bootstrap finishes.
+    def covered_sources_for_changed_tests(changed_paths)
+      changed_paths
+        .flat_map { |path| @per_test_coverage.source_files_covered_by(path) }
+        .map { |path| normalize_path(path) }
+    end
+
+    def normalize_path(path) = File.expand_path(path)
+  end
+end

data/lib/henitai/subject_selection.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Turns a list of source files into the subjects a run mutates, applying any
+  # CLI subject patterns.
+  #
+  # With no patterns every resolved subject is kept. With patterns, each is
+  # applied independently and the results concatenated, so overlapping patterns
+  # can name the same subject twice — hence the de-duplication on
+  # `[expression, source_file]` rather than on object identity. Expression alone
+  # is not enough: the same expression can legitimately appear in two files.
+  class SubjectSelection
+    def initialize(subject_resolver:, patterns:)
+      @subject_resolver = subject_resolver
+      @patterns = patterns
+    end
+
+    def resolve(source_files)
+      subjects = @subject_resolver.resolve_from_files(source_files)
+      return subjects if pattern_expressions.empty?
+
+      unique(pattern_expressions.flat_map { |expression| @subject_resolver.apply_pattern(subjects, expression) })
+    end
+
+    def unique(subjects)
+      subjects.uniq { |subject| [subject.expression, subject.source_file] }
+    end
+
+    private
+
+    def pattern_expressions = Array(@patterns).map(&:expression)
+  end
+end

data/lib/henitai/survivor_rerun_strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "dirty_source_detector"
+
 module Henitai
   # Survivor-rerun fast path for {Runner}.
   #
@@ -154,27 +156,13 @@ module Henitai
     end
 
     def dirty_source_files?(dirty_worktree_files, git_sha: nil)
-      return true if dirty_worktree_files.nil?
-
-      all_changed = dirty_worktree_files + committed_changed_files(git_sha)
-      include_roots = Array(@config.includes).map { |path| normalize_path(path) }
-      all_changed.any? { |path| in_include_root?(normalize_path(path), include_roots) }
-    rescue StandardError
-      true
+      dirty_source_detector.dirty?(dirty_worktree_files, git_sha: git_sha)
     end
 
-    def committed_changed_files(git_sha)
-      return [] unless git_sha
-
-      @git_diff_analyzer.changed_files(from: git_sha, to: "HEAD")
-    end
-
-    def in_include_root?(path, include_roots)
-      include_roots.any? { |root| path == root || path.start_with?("#{root}/") }
-    end
-
-    def normalize_path(path)
-      File.expand_path(path)
+    def dirty_source_detector
+      @dirty_source_detector ||= DirtySourceDetector.new(
+        includes: @config.includes, git_diff_analyzer: @git_diff_analyzer
+      )
     end
 
     def warn_survivor_drift(selector)

data/lib/henitai/version.rb

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

data/lib/henitai.rb

@@ -58,6 +58,9 @@ module Henitai
   autoload :SurvivorTestFilter,      "henitai/survivor_test_filter"
   autoload :SurvivorActivationCache, "henitai/survivor_activation_cache"
   autoload :SurvivorRerunStrategy, "henitai/survivor_rerun_strategy"
+  autoload :DirtySourceDetector, "henitai/dirty_source_detector"
+  autoload :SourceFileSelection, "henitai/source_file_selection"
+  autoload :SubjectSelection, "henitai/subject_selection"
   autoload :ScenarioExecutionResult, "henitai/scenario_execution_result"
   autoload :CoverageFormatter, "henitai/coverage_formatter"
   autoload :MinitestCoverageReporter, "henitai/minitest_coverage_reporter"
@@ -65,12 +68,17 @@ module Henitai
   autoload :SyntaxValidator, "henitai/syntax_validator"
   autoload :SamplingStrategy, "henitai/sampling_strategy"
   autoload :TestPrioritizer, "henitai/test_prioritizer"
+  autoload :ExcludedTestFilter, "henitai/excluded_test_filter"
   autoload :TimeoutCalibrator, "henitai/timeout_calibrator"
   autoload :ExecutionEngine, "henitai/execution_engine"
   autoload :ProcessWorkerRunner, "henitai/process_worker_runner"
   autoload :SlotScheduler, "henitai/slot_scheduler"
   autoload :ProcessWakeup, "henitai/process_wakeup"
+  autoload :ProcessLiveness, "henitai/process_liveness"
+  autoload :InheritedFdRegistry, "henitai/inherited_fd_registry"
+  autoload :OrphanWatchdog, "henitai/orphan_watchdog"
   autoload :Runner, "henitai/runner"
+  autoload :RunnerDependencies, "henitai/runner_dependencies"
   autoload :Reporter, "henitai/reporter"
   autoload :Integration, "henitai/integration"
   autoload :Result, "henitai/result"

data/sig/henitai.rbs

@@ -76,36 +76,56 @@ module Henitai
   module Operators
   end
 
-  module Integration::ChildDebugSupport
+  class Integration::LoadedFeatures
+    def include?: (String) -> bool
+    def map: (Array[String]) -> Array[[String, bool]]
+
     private
 
-    def debug_child_puts: (String) -> void
-    def debug_child?: () -> bool
-    def debug_child_rspec_trace: (
+    def candidates_for: (String) -> Array[String]
+    def normalize: (String) -> String
+  end
+
+  class Integration::ChildDebugLog
+    PREFIX: String
+
+    def initialize: (?io: IO?, ?loaded_features: Integration::LoadedFeatures) -> void
+    def enabled?: () -> bool
+    def write: (String) -> void
+    def rspec_trace: (
       test_files: Array[String],
       rspec_options: Array[String],
       rspec_argv: Array[String]
     ) -> void
-    def debug_child_rspec_exit: (untyped) -> void
-    def debug_child_example_count: (String) -> void
-    def debug_child_activation_start: (String) -> void
-    def debug_child_activation_end: (untyped, test_files: Array[String]) -> void
-    def debug_child_mutant_meta: (Mutant) -> void
-    def debug_child_activation_check: () -> void
-    def loaded_feature_map: (Array[String]) -> Array[[String, bool]]
-    def loaded_feature?: (String) -> bool
+    def rspec_exit: (untyped) -> void
+    def example_count: (String) -> void
+    def activation_start: (String) -> void
+    def activation_end: (untyped, test_files: Array[String]) -> void
+    def mutant_meta: (untyped) -> void
+    def activation_check: () -> void
+    def timeout_signal_sent: (Integer) -> void
+    def thread_dump: (String) -> void
     def rspec_world_example_count: () -> Integer?
-    def pause: (Float) -> void
+
+    private
+
+    def dump_thread: (Thread, Integer) -> void
+    def value_of: (untyped, Symbol) -> untyped
+    def location_of: (untyped) -> String?
+    def subject_expression_of: (untyped) -> String?
+    def io: () -> IO
   end
 
   module Integration::ChildRuntimeControl
+    def child_debug_log: () -> Integration::ChildDebugLog
+
     private
 
     def suppress_simplecov!: () -> void
     def suppress_coverage!: () -> void
     def debug_child_timeout_dump: (Integer) -> void
     def install_debug_timeout_trap: () -> void
-    def debug_child_thread_dump: (String) -> void
+    def pause: (Float) -> void
   end
 
   module Integration::RspecChildRunner
@@ -371,7 +391,6 @@ module Henitai
     def self.for: (String) -> untyped
 
     class Base
-      include ChildDebugSupport
       include ChildRuntimeControl
 
       def select_tests: (Subject) -> Array[String]
@@ -383,6 +402,7 @@ module Henitai
       def wait_with_timeout: (Integer, Float) -> untyped
       def reap_child: (Integer) -> void
       def cleanup_process_group: (Integer) -> void
+      def child_debug_log: () -> ChildDebugLog
 
       private
 
@@ -392,18 +412,6 @@ module Henitai
       def cleanup_child_process: (Integer) -> void
       def suppress_simplecov!: () -> void
       def suppress_coverage!: () -> void
-      def debug_child?: () -> bool
-      def debug_child_puts: (String) -> void
-      def debug_child_rspec_trace: (test_files: Array[String], rspec_options: Array[String], rspec_argv: Array[String]) -> void
-      def debug_child_rspec_exit: (untyped status) -> void
-      def debug_child_activation_start: (String mutant_id) -> void
-      def debug_child_activation_end: (untyped activation_result, test_files: Array[String]) -> void
-      def debug_child_mutant_meta: (Mutant) -> void
-      def debug_child_activation_check: () -> void
-      def debug_child_example_count: (String) -> void
-      def loaded_feature_map: (Array[String]) -> Array[[String, bool]]
-      def loaded_feature?: (String) -> bool
-      def rspec_world_example_count: () -> Integer?
       def with_non_interactive_stdin: () { () -> untyped } -> untyped
       def subprocess_env: () -> Hash[String, String]
       def scenario_log_support: () -> ScenarioLogSupport
@@ -973,6 +981,8 @@ module Henitai
 
     SCHEMA_VERSION: String
     DEFAULT_THRESHOLDS: Hash[Symbol, Integer]
+    DEFAULT_COVERAGE_CRITERIA: Hash[Symbol, bool]
+    CRITERION_STATUSES: Hash[Symbol, Symbol]
 
     attr_reader mutants: Array[Mutant]
     attr_reader started_at: Time
@@ -982,8 +992,9 @@ module Henitai
     attr_reader session_id: String
     attr_reader git_sha: String?
     attr_reader since: String?
+    attr_reader coverage_criteria: Hash[Symbol, bool]
 
-    def initialize: (mutants: Array[Mutant], started_at: Time, finished_at: Time, ?thresholds: Hash[Symbol, Integer]?, ?partial_rerun: bool, ?survivor_stats: Hash[Symbol, untyped]?, ?session_id: String, ?git_sha: String?, ?source_provider: ^(String) -> String, ?authoritative: bool, ?since: String?) -> void
+    def initialize: (mutants: Array[Mutant], started_at: Time, finished_at: Time, ?thresholds: Hash[Symbol, Integer]?, ?partial_rerun: bool, ?survivor_stats: Hash[Symbol, untyped]?, ?session_id: String, ?git_sha: String?, ?source_provider: ^(String) -> String, ?authoritative: bool, ?since: String?, ?coverage_criteria: Hash[Symbol, bool]?) -> void
     def partial_rerun?: () -> bool
     def authoritative?: () -> bool
     def killed: () -> Integer
@@ -1000,6 +1011,7 @@ module Henitai
     private
 
     def detected_in: (Array[Mutant]) -> Integer
+    def detected_statuses: () -> Array[Symbol]
     def mutation_score_for: (Array[Mutant]) -> Float?
     def mutation_score_indicator_for: (Array[Mutant]) -> Float?
     def base_schema: () -> Hash[Symbol, untyped]
@@ -1063,12 +1075,59 @@ module Henitai
     def self.write: (String, Hash[String, Hash[String, untyped]]) -> void
   end
 
+  class RunnerDependencies
+    def initialize: (config: untyped) -> void
+    def subject_resolver: () -> untyped
+    def git_diff_analyzer: () -> untyped
+    def mutant_generator: () -> untyped
+    def static_filter: () -> untyped
+    def execution_engine: () -> untyped
+    def coverage_bootstrapper: () -> CoverageBootstrapper
+    def integration: () -> untyped
+    def operators: () -> Array[Operator]
+    def per_test_coverage: () -> PerTestCoverage
+    def history_store: () -> untyped
+    def progress_reporter: (full_run: bool) -> untyped
+    def source_provider: () -> ^(String) -> String
+  end
+
+  class SourceFileSelection
+    def initialize: (
+      config: untyped,
+      since: String?,
+      git_diff_analyzer: untyped,
+      per_test_coverage: untyped
+    ) -> void
+    def call: () -> Array[String]
+    def included_source_files: () -> Array[String]
+    def reject_excluded: (Array[String]) -> Array[String]
+    def filter_changed: (Array[String]) -> Array[String]
+
+    private
+
+    def excluded_source_files: () -> Array[String]
+    def changed_paths_since: () -> Array[String]
+    def covered_sources_for_changed_tests: (Array[String]) -> Array[String]
+    def normalize_path: (String) -> String
+  end
+
+  class SubjectSelection
+    def initialize: (subject_resolver: untyped, patterns: Array[untyped]?) -> void
+    def resolve: (Array[String]) -> Array[Subject]
+    def unique: (Array[Subject]) -> Array[Subject]
+
+    private
+
+    def pattern_expressions: () -> Array[String]
+  end
+
   class Runner
     attr_reader config: Configuration
     attr_reader result: untyped
 
-    def initialize: (?config: Configuration, ?subjects: Array[Subject], ?since: String, ?survivors_from: String?, ?mode: Hash[Symbol, bool]) -> void
+    def initialize: (?config: Configuration, ?subjects: Array[Subject], ?since: String, ?survivors_from: String?, ?mode: Hash[Symbol, bool], ?deps: RunnerDependencies?) -> void
     def run: () -> Result
+    def deps: () -> RunnerDependencies
     def resolve_subjects: (?Array[String]) -> untyped
     def generate_mutants: (untyped) -> untyped
     def filter_mutants: (untyped) -> untyped
@@ -1087,15 +1146,8 @@ module Henitai
     def per_test_coverage: () -> PerTestCoverage
     def history_store_path: () -> String
     def source_files: () -> Array[String]
-    def included_source_files: () -> Array[String]
-    def reject_excluded: (Array[String]) -> Array[String]
-    def excluded_source_files: () -> Array[String]
-    def filter_changed: (Array[String]) -> Array[String]
-    def changed_paths_since: () -> Array[String]
-    def covered_sources_for_changed_tests: (Array[String]) -> Array[String]
-    def pattern_subjects: () -> Array[Subject]
-    def unique_subjects: (Array[Subject]) -> Array[Subject]
-    def normalize_path: (String) -> String
+    def source_file_selection: () -> SourceFileSelection
+    def subject_selection: () -> SubjectSelection
 
     private
 
@@ -1111,6 +1163,8 @@ module Henitai
     def mutants_for: (Array[Subject], Array[String]) -> Array[Mutant]
     def with_reports_dir: () { () -> untyped } -> untyped
     def result_thresholds: () -> Hash[Symbol, Integer]?
+    def result_coverage_criteria: () -> Hash[Symbol, bool]?
+    def optional_config: (Symbol) -> untyped
     def survivor_rerun?: () -> bool
     def full_run?: () -> bool
     def survivor_strategy: () -> SurvivorRerunStrategy