henitai 0.2.0 → 0.3.0

data/lib/henitai/survivor_rerun_strategy.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Survivor-rerun fast path for {Runner}.
+  #
+  # When +--survivors-from+ is given, this collaborator loads the prior report
+  # and either:
+  #
+  #   * builds stub Mutants directly from +activation-recipes.json+ (the recipe
+  #     fast path, bypassing source parsing and mutant generation), or
+  #   * filters a freshly generated mutant list down to the prior survivors.
+  #
+  # In both cases it records {#survivor_stats} (matched/unmatched counts and the
+  # drift warning) for the Runner to attach to its Result.
+  class SurvivorRerunStrategy
+    attr_reader :survivor_stats
+
+    def initialize(survivors_from:, config:, git_diff_analyzer:)
+      @survivors_from = survivors_from
+      @config = config
+      @git_diff_analyzer = git_diff_analyzer
+      @survivor_stats = nil
+    end
+
+    def active?
+      !@survivors_from.nil?
+    end
+
+    # Attempts to run survivors directly from pre-computed activation recipes,
+    # bypassing source parsing and mutant generation entirely.
+    # Returns the mutant array on success, or nil if recipes are unavailable.
+    def try_recipe_run
+      dirty_worktree_files = dirty_worktree_changed_files
+      loaded = load_survivor_report
+      return nil unless recipe_fast_path_safe?(loaded, dirty_worktree_files)
+
+      run_from_recipes(loaded, dirty_worktree_files)
+    end
+
+    def apply_selection(mutants)
+      dirty_worktree_files = dirty_worktree_changed_files
+      loaded   = load_survivor_report
+      selector = SurvivorSelector.new(survivor_ids: loaded.survivor_ids)
+      selected = selector.select(mutants)
+      finalize_survivor_split(
+        selector,
+        selected,
+        test_filter(
+          loaded,
+          dirty_source_files: dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
+        ).apply(selected)
+      )
+    end
+
+    private
+
+    def load_survivor_report
+      SurvivorLoader.new(@survivors_from, include_paths: Array(@config.includes)).load
+    end
+
+    def run_from_recipes(loaded, dirty_worktree_files)
+      recipes = load_activation_recipes(loaded.survivor_ids)
+      return nil if recipes.nil?
+
+      selector, stubs = recipe_selector_and_stubs(loaded.survivor_ids, recipes)
+      split = test_filter(
+        loaded,
+        dirty_source_files: dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
+      ).apply(stubs)
+      finalize_survivor_split(selector, stubs, split)
+    end
+
+    def recipe_fast_path_safe?(loaded, dirty_worktree_files)
+      !dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
+    end
+
+    # Builds stub Mutants from recipes and a SurvivorSelector primed with the
+    # survivor ID set. The selector is given a synthetic #select call so that
+    # #drift_warning? / #unmatched_ids are available (all IDs will be matched).
+    def recipe_selector_and_stubs(survivor_ids, recipes)
+      stubs    = survivor_ids.map { |id| build_stub_mutant(id, recipes[id]) }
+      selector = SurvivorSelector.new(survivor_ids:)
+      selector.select(stubs)
+      [selector, stubs]
+    end
+
+    # Returns the recipe hash if the file exists and covers every survivor ID;
+    # otherwise returns nil to trigger the normal generation path.
+    def load_activation_recipes(survivor_ids)
+      path    = File.join(File.dirname(@survivors_from), SurvivorActivationCache::FILENAME)
+      recipes = SurvivorActivationCache.load(path)
+      return nil if recipes.nil?
+      return nil unless survivor_ids.all? { |id| recipes.key?(id) }
+
+      recipes
+    end
+
+    def build_stub_mutant(stable_id, recipe)
+      mutant = Mutant.new(
+        subject: stub_subject_from_recipe(recipe),
+        operator: recipe.fetch("operator"),
+        nodes: { original: nil, mutated: nil },
+        description: recipe.fetch("description"),
+        location: recipe_location(recipe["location"]),
+        precomputed_stable_id: stable_id,
+        precomputed_activation_source: recipe.fetch("activationSource")
+      )
+      mutant.covered_by = recipe["coveredBy"]
+      mutant
+    end
+
+    def stub_subject_from_recipe(recipe)
+      Subject.new(
+        namespace: recipe["namespace"],
+        method_name: recipe["methodName"],
+        method_type: (recipe["methodType"] || "instance").to_sym,
+        source_location: { file: recipe["sourceFile"], range: nil }
+      )
+    end
+
+    def recipe_location(loc)
+      return {} unless loc.is_a?(Hash)
+
+      {
+        file: loc["file"],
+        start_line: loc["startLine"],
+        end_line: loc["endLine"],
+        start_col: loc["startCol"],
+        end_col: loc["endCol"]
+      }.compact
+    end
+
+    def finalize_survivor_split(selector, selected, split)
+      split[:stable].each { |m| m.status = :survived }
+      warn_survivor_drift(selector) if selector.drift_warning?
+      @survivor_stats = build_survivor_stats(selector, selected, split)
+      split[:stable] + split[:pending]
+    end
+
+    def test_filter(loaded, dirty_source_files:)
+      SurvivorTestFilter.new(
+        coverage_map: loaded.coverage_map,
+        git_sha: loaded.git_sha,
+        dirty_source_files:,
+        worktree_changed_files: Array(dirty_worktree_changed_files),
+        diff_analyzer: @git_diff_analyzer
+      )
+    end
+
+    def dirty_worktree_changed_files
+      @dirty_worktree_changed_files ||= @git_diff_analyzer.working_tree_changed_files
+    rescue StandardError
+      nil
+    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
+    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)
+    end
+
+    def warn_survivor_drift(selector)
+      warn "henitai: WARNING: #{selector.unmatched_ids.size} prior survivors " \
+           "could not be matched; the source may have drifted - consider a full run"
+    end
+
+    def build_survivor_stats(selector, selected, split)
+      {
+        matched: selected.size,
+        unmatched_count: selector.unmatched_ids.size,
+        unmatched_ids: selector.unmatched_ids,
+        skipped_count: split[:stable].size,
+        drift_warning: selector.drift_warning?
+      }
+    end
+  end
+end

data/lib/henitai/survivor_test_filter.rb

@@ -57,7 +57,7 @@ module Henitai
       covering = @coverage_map[mutant.stable_id]
       return false if covering.nil? || covering.empty?
 
-      covering.none? { |test_file| changed.include?(test_file) }
+      !changed.intersect?(covering)
     end
 
     # Returns a Set of changed test file paths, or nil on any git error

data/lib/henitai/test_prioritizer.rb

@@ -2,15 +2,41 @@
 
 module Henitai
   # Orders test files so previously effective tests run first.
+  #
+  # Primary key: kill-history count (a test that killed neighbouring mutants
+  # probably kills this one). Tiebreaker: measured per-test-file runtime,
+  # ascending, so the first kill costs as little wall-clock as possible.
+  # Untimed tests sort after timed ones by original inventory order; with no
+  # timing source at all the ordering is exactly the historical behavior.
   class TestPrioritizer
+    # @param timing_source [#call, nil] returns a Hash of test file path to
+    #   wall-clock seconds; resolved lazily on first sort.
+    def initialize(timing_source: nil)
+      @timing_source = timing_source
+    end
+
     def sort(tests, _mutant, history)
       Array(tests).each_with_index.sort_by do |test, index|
-        [-history_count(history, test), index]
+        [-history_count(history, test), runtime(test), index]
       end.map(&:first)
     end
 
     private
 
+    def runtime(test)
+      durations = timing_durations
+      history_key_candidates(test).each do |key|
+        value = durations[key]
+        return value.to_f unless value.nil?
+      end
+
+      Float::INFINITY
+    end
+
+    def timing_durations
+      @timing_durations ||= @timing_source&.call || {}
+    end
+
     def history_count(history, test)
       return 0 unless history.respond_to?(:fetch)
 
@@ -45,7 +71,7 @@ module Henitai
 
     def relative_history_key(path)
       pathname = Pathname.new(path)
-      return unless pathname.absolute?
+      return path unless pathname.absolute?
 
       pathname.relative_path_from(Pathname.pwd).to_s
     rescue StandardError

data/lib/henitai/timeout_calibrator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Derives a per-mutant timeout from measured per-test-file durations.
+  #
+  # The calibrated value is `multiplier × sum(durations of the selected test
+  # files)`, clamped to a floor so a near-instant baseline doesn't flag normal
+  # jitter as a timeout. Returns nil — caller falls back to the static
+  # default — when any selected test lacks timing data, so a partially
+  # measured run is treated as uncalibratable rather than under-estimated.
+  class TimeoutCalibrator
+    FLOOR_SECONDS = 2.0
+
+    # @param timing_source [#call] returns a Hash of test file path to
+    #   wall-clock seconds; resolved lazily on first use.
+    # @param multiplier [Numeric]
+    def initialize(timing_source:, multiplier:)
+      @timing_source = timing_source
+      @multiplier = multiplier
+    end
+
+    # @param test_files [Array<String>]
+    # @return [Float, nil]
+    def timeout_for(test_files)
+      files = Array(test_files)
+      return nil if files.empty? || durations.empty?
+
+      baselines = files.map { |file| durations[normalize(file)] }
+      return nil if baselines.any?(&:nil?)
+
+      [@multiplier * baselines.sum, FLOOR_SECONDS].max
+    end
+
+    private
+
+    def durations
+      @durations ||= (@timing_source.call || {}).transform_keys { |key| normalize(key) }
+    end
+
+    def normalize(path)
+      File.expand_path(path.to_s)
+    end
+  end
+end

data/lib/henitai/unparse_helper.rb

@@ -9,8 +9,11 @@ module Henitai
 
     def safe_unparse(node)
       Unparser.unparse(node)
-    rescue StandardError
-      # Unparser does not support all AST node types, so fall back gracefully.
+    rescue Unparser::UnknownNodeError, Unparser::InvalidNodeError,
+           Unparser::UnsupportedNodeError, EncodingError
+      # Unparser does not support all AST node types, and some mutated string
+      # segments carry incompatible encodings; fall back gracefully for those.
+      # Other failures (e.g. NoMethodError) are bugs and must surface.
       fallback_source(node)
     end
 

data/lib/henitai/verdict_fingerprint.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "digest"
+require "find"
+require "json"
+
+require_relative "generated_artifacts"
+
+module Henitai
+  # Content fingerprints that decide whether a stored verdict is still
+  # trustworthy: the subject's source (method body) and the covering test
+  # files must both be byte-identical to what was recorded. Survived verdicts
+  # additionally record the full-map covering-set membership plus a run-level
+  # dependency fingerprint (ADR-11). Any read failure yields nil / a mismatch
+  # — conservative, never reuse on doubt.
+  module VerdictFingerprint
+    # Files that influence test behavior but never appear in any covering
+    # set: helpers, support code, fixtures/factories, lockfile and tool
+    # config. One combined hash over all of them gates survivor reuse.
+    DEPENDENCY_GLOBS = %w[
+      spec/spec_helper.rb
+      spec/rails_helper.rb
+      spec/support/**/*
+      spec/fixtures/**/*
+      spec/factories/**/*
+      test/test_helper.rb
+      test/support/**/*
+      test/fixtures/**/*
+      test/factories/**/*
+      Gemfile.lock
+      .henitai.yml
+      .rspec
+    ].freeze
+
+    module_function
+
+    # SHA256 of the subject's source lines. nil when the subject has no
+    # source range or the file cannot be read.
+    def subject_source_hash(mutant)
+      subject = mutant.subject
+      return nil unless subject.respond_to?(:source_file) && subject.respond_to?(:source_range)
+
+      range = subject.source_range
+      return nil unless range
+
+      lines = File.readlines(subject.source_file)
+      Digest::SHA256.hexdigest(lines[(range.begin - 1)..(range.end - 1)].to_a.join)
+    rescue SystemCallError, IOError
+      nil
+    end
+
+    # JSON fingerprint of the covering test files: their sorted paths plus a
+    # combined content hash. nil when no tests are known or any is unreadable.
+    def tests_fingerprint(test_files)
+      paths = Array(test_files).map(&:to_s).sort
+      return nil if paths.empty?
+
+      sha = combined_content_sha(paths)
+      return nil unless sha
+
+      JSON.generate("paths" => paths, "sha" => sha)
+    end
+
+    # True when every recorded test file still exists with identical content.
+    def tests_fingerprint_current?(fingerprint_json)
+      return false if fingerprint_json.nil?
+
+      fingerprint = JSON.parse(fingerprint_json)
+      combined_content_sha(fingerprint.fetch("paths")) == fingerprint.fetch("sha")
+    rescue StandardError
+      false
+    end
+
+    # Existing dependency files resolved against +root+, sorted. Shared by
+    # the fingerprint below and by the coverage freshness watch — a stale
+    # per-test map after a dependency edit would let the test selector omit
+    # a newly covering test. Uses Find with pruning instead of Dir.glob so
+    # generated subtrees (thousands of mutation-log files under fixture
+    # projects) are never walked at all.
+    def dependency_files(root = Dir.pwd)
+      files = DEPENDENCY_GLOBS.flat_map do |pattern|
+        base = File.join(root, pattern)
+        pattern.include?("*") ? pruned_tree_files(File.dirname(base.sub("/**/*", "/x"))) : [base]
+      end
+      files.select { |path| File.file?(path) }.uniq.sort
+    end
+
+    def pruned_tree_files(dir)
+      return [] unless File.directory?(dir)
+
+      collected = [] # : Array[String]
+      Find.find(dir) do |path|
+        Find.prune if File.directory?(path) && GeneratedArtifacts.generated_dir?(path)
+        collected << path if File.file?(path)
+      end
+      collected
+    end
+
+    # Run-level combined SHA over the dependency file set. Missing files are
+    # simply excluded (not an error); a read failure yields nil — no reuse.
+    def dependency_fingerprint(root = Dir.pwd) = combined_content_sha(dependency_files(root))
+
+    # Fingerprint recorded for a Survived verdict: the sorted full-map
+    # intersection set (paths + combined content sha) plus the run-level
+    # dependency sha. nil when any input is unavailable — the verdict is
+    # then never reusable.
+    def survivor_tests_fingerprint(test_files, dependency_sha:)
+      return nil if dependency_sha.nil?
+
+      paths = Array(test_files).map(&:to_s).sort
+      return nil if paths.empty?
+
+      sha = combined_content_sha(paths)
+      return nil unless sha
+
+      JSON.generate("paths" => paths, "sha" => sha, "dependencies" => dependency_sha)
+    end
+
+    # True when the recorded covering set still equals the live one in
+    # membership AND content, and the dependency fingerprint is unchanged.
+    # Any parse/read failure or missing field resolves to stale.
+    def survivor_fingerprint_current?(fingerprint_json, live_paths:, dependency_sha:)
+      return false if fingerprint_json.nil? || dependency_sha.nil?
+
+      survivor_fingerprint_matches?(JSON.parse(fingerprint_json), live_paths, dependency_sha)
+    rescue StandardError
+      false
+    end
+
+    def survivor_fingerprint_matches?(fingerprint, live_paths, dependency_sha)
+      recorded_paths = fingerprint.fetch("paths")
+      return false if recorded_paths.empty?
+
+      recorded_paths == Array(live_paths).map(&:to_s).sort &&
+        fingerprint.fetch("dependencies") == dependency_sha &&
+        combined_content_sha(recorded_paths) == fingerprint.fetch("sha")
+    end
+
+    def combined_content_sha(paths)
+      digest = Digest::SHA256.new
+      paths.each do |path|
+        content = File.read(path)
+        digest.update(path.bytesize.to_s)
+        digest.update(":")
+        digest.update(path)
+        digest.update(content.bytesize.to_s)
+        digest.update(":")
+        digest.update(content)
+      end
+      digest.hexdigest
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/henitai/version.rb

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

data/lib/henitai.rb

@@ -20,9 +20,13 @@ module Henitai
   # Raised when coverage data cannot be bootstrapped or validated.
   class CoverageError < StandardError; end
 
+  # Raised when another process is using the configured reports directory.
+  class ConcurrentRunError < StandardError; end
+
   autoload :Configuration, "henitai/configuration"
   autoload :CoverageBootstrapper, "henitai/coverage_bootstrapper"
   autoload :CoverageReportReader, "henitai/coverage_report_reader"
+  autoload :PerTestCoverage, "henitai/per_test_coverage"
   autoload :PerTestCoverageSelector, "henitai/per_test_coverage_selector"
   autoload :Subject, "henitai/subject"
   autoload :Mutant, "henitai/mutant"
@@ -31,19 +35,29 @@ module Henitai
   autoload :Operators, "henitai/operators"
   autoload :SourceParser, "henitai/source_parser"
   autoload :SubjectResolver, "henitai/subject_resolver"
+  autoload :GeneratedArtifacts, "henitai/generated_artifacts"
   autoload :GitDiffAnalyzer, "henitai/git_diff_analyzer"
   autoload :GitDiffError, "henitai/git_diff_analyzer"
   autoload :MutantGenerator, "henitai/mutant_generator"
   autoload :MutantHistoryStore, "henitai/mutant_history_store"
+  autoload :MutationSkipDirectives, "henitai/mutation_skip_directives"
   autoload :AridNodeFilter, "henitai/arid_node_filter"
   autoload :AvailableCpuCount, "henitai/available_cpu_count"
   autoload :EquivalenceDetector, "henitai/equivalence_detector"
   autoload :StaticFilter, "henitai/static_filter"
+  autoload :IncrementalFilter, "henitai/incremental_filter"
+  autoload :VerdictFingerprint, "henitai/verdict_fingerprint"
   autoload :StillbornFilter, "henitai/stillborn_filter"
+  autoload :CanonicalReportMerger, "henitai/canonical_report_merger"
+  autoload :CanonicalReportWriter, "henitai/canonical_report_writer"
+  autoload :CheckpointReporter, "henitai/checkpoint_reporter"
+  autoload :CompositeProgressReporter, "henitai/composite_progress_reporter"
+  autoload :ReportsDirectoryLock, "henitai/reports_directory_lock"
   autoload :SurvivorLoader,          "henitai/survivor_loader"
   autoload :SurvivorSelector,        "henitai/survivor_selector"
   autoload :SurvivorTestFilter,      "henitai/survivor_test_filter"
   autoload :SurvivorActivationCache, "henitai/survivor_activation_cache"
+  autoload :SurvivorRerunStrategy, "henitai/survivor_rerun_strategy"
   autoload :ScenarioExecutionResult, "henitai/scenario_execution_result"
   autoload :CoverageFormatter, "henitai/coverage_formatter"
   autoload :MinitestCoverageReporter, "henitai/minitest_coverage_reporter"
@@ -51,9 +65,10 @@ module Henitai
   autoload :SyntaxValidator, "henitai/syntax_validator"
   autoload :SamplingStrategy, "henitai/sampling_strategy"
   autoload :TestPrioritizer, "henitai/test_prioritizer"
+  autoload :TimeoutCalibrator, "henitai/timeout_calibrator"
   autoload :ExecutionEngine, "henitai/execution_engine"
-  autoload :ParallelExecutionRunner, "henitai/parallel_execution_runner"
   autoload :ProcessWorkerRunner, "henitai/process_worker_runner"
+  autoload :SlotScheduler, "henitai/slot_scheduler"
   autoload :ProcessWakeup, "henitai/process_wakeup"
   autoload :Runner, "henitai/runner"
   autoload :Reporter, "henitai/reporter"

data/sig/configuration_validator.rbs

@@ -1,29 +1,53 @@
 module Henitai
   module ConfigurationValidator
+    VALID_TOP_LEVEL_KEYS: Array[Symbol]
+    VALID_MUTATION_KEYS: Array[Symbol]
+    VALID_SAMPLING_KEYS: Array[Symbol]
+    VALID_COVERAGE_CRITERIA_KEYS: Array[Symbol]
+    VALID_THRESHOLDS_KEYS: Array[Symbol]
+    VALID_DASHBOARD_KEYS: Array[Symbol]
+    VALID_INTEGRATION_KEYS: Array[Symbol]
+    VALID_OPERATORS: Array[Symbol]
+    VALIDATION_STEPS: Array[Symbol]
+
     def self.validate!: (Hash[Symbol, untyped]) -> void
+    def self.warn: (String) -> void
 
-    private
+    module Rules
+      def self?.validate_top_level_keys: (Hash[Symbol, untyped]) -> void
+      def self?.validate_integration: (Hash[Symbol, untyped]) -> void
+      def self?.validate_includes: (Hash[Symbol, untyped]) -> void
+      def self?.validate_excludes: (Hash[Symbol, untyped]) -> void
+      def self?.validate_jobs: (Hash[Symbol, untyped]) -> void
+      def self?.validate_reporters: (Hash[Symbol, untyped]) -> void
+      def self?.validate_reports_dir: (Hash[Symbol, untyped]) -> void
+      def self?.validate_all_logs: (Hash[Symbol, untyped]) -> void
+      def self?.validate_dashboard: (Hash[Symbol, untyped]) -> void
+      def self?.validate_mutation: (Hash[Symbol, untyped]) -> void
+      def self?.validate_mutation_limits: (Hash[Symbol, untyped]) -> void
+      def self?.validate_mutation_filters: (Hash[Symbol, untyped]) -> void
+      def self?.validate_coverage_criteria: (Hash[Symbol, untyped]) -> void
+      def self?.validate_thresholds: (Hash[Symbol, untyped]) -> void
+      def self?.validate_sampling: (untyped) -> void
+      def self?.warn_unknown_keys: (Hash[Symbol, untyped], Array[Symbol], ?String?) -> void
+      def self?.key_path: (String?, Symbol) -> String
+      def self?.ensure_hash!: (untyped, String) -> void
+      def self?.configuration_error: (String) -> void
+    end
 
-    def self.validate_top_level_keys: (Hash[Symbol, untyped]) -> void
-    def self.validate_integration: (Hash[Symbol, untyped]) -> void
-    def self.validate_includes: (Hash[Symbol, untyped]) -> void
-    def self.validate_jobs: (Hash[Symbol, untyped]) -> void
-    def self.validate_reporters: (Hash[Symbol, untyped]) -> void
-    def self.validate_all_logs: (Hash[Symbol, untyped]) -> void
-    def self.validate_dashboard: (Hash[Symbol, untyped]) -> void
-    def self.validate_mutation: (Hash[Symbol, untyped]) -> void
-    def self.validate_coverage_criteria: (Hash[Symbol, untyped]) -> void
-    def self.validate_thresholds: (Hash[Symbol, untyped]) -> void
-    def self.validate_operator: (untyped) -> void
-    def self.validate_timeout: (untyped) -> void
-    def self.validate_threshold: (untyped, String) -> void
-    def self.validate_boolean: (untyped, String) -> void
-    def self.validate_optional_string: (untyped, String) -> void
-    def self.validate_string_array: (untyped, String) -> void
-    def self.warn_unknown_keys: (Hash[Symbol, untyped], Array[Symbol], ?String) -> void
-    def self.key_path: (?String, Symbol) -> String
-    def self.ensure_hash!: (untyped, String) -> void
-    def self.describe_array_type: (untyped) -> String
-    def self.configuration_error: (String) -> void
+    module Scalars
+      def self?.validate_operator: (untyped) -> void
+      def self?.validate_timeout: (untyped) -> void
+      def self?.validate_threshold: (untyped, String) -> void
+      def self?.validate_boolean: (untyped, String) -> void
+      def self?.validate_optional_string: (untyped, String) -> void
+      def self?.validate_string_array: (untyped, String) -> void
+      def self?.validate_ignore_patterns: (untyped) -> void
+      def self?.validate_max_flaky_retries: (untyped) -> void
+      def self?.validate_sampling_ratio: (untyped) -> void
+      def self?.validate_sampling_strategy: (untyped) -> void
+      def self?.validate_sampling_completeness: (Hash[Symbol, untyped]) -> void
+      def self?.describe_array_type: (untyped) -> String
+    end
   end
 end