simplecov 1.0.3 → 1.1.0

data/lib/simplecov.rb

@@ -158,10 +158,8 @@ module SimpleCov
                                               ::Process.respond_to?(:_fork)
       # simplecov:enable
 
-      # Trigger adapter selection now so the (possibly lazy) parallel_tests
-      # gem load happens at start_tracking time rather than mid-suite.
-      # `current` is memoized; subsequent calls are cheap.
-      SimpleCov::ParallelAdapters.current
+      # Select the parallel adapter and generate identities before any forks.
+      SimpleCov::RunIdentity.prepare
 
       @result = nil
       self.pid = Process.pid
@@ -230,6 +228,7 @@ end
 require "forwardable"
 require_relative "simplecov/color"
 require_relative "simplecov/deprecation"
+require_relative "simplecov/group_names"
 require_relative "simplecov/configuration"
 SimpleCov.extend SimpleCov::Configuration
 require_relative "simplecov/coverage_statistics"
@@ -245,22 +244,29 @@ require_relative "simplecov/result"
 require_relative "simplecov/filter"
 require_relative "simplecov/formatter"
 require_relative "simplecov/last_run"
+require_relative "simplecov/report_stamp"
 require_relative "simplecov/lines_classifier"
 require_relative "simplecov/result_merger"
+require_relative "simplecov/parallel_result_merger"
 require_relative "simplecov/parallel_adapters"
+require_relative "simplecov/run_identity"
+SimpleCov.extend SimpleCov::RunIdentity::Accessors
 require_relative "simplecov/command_guesser"
 require_relative "simplecov/version"
 require_relative "simplecov/result_adapter"
 require_relative "simplecov/combine"
+require_relative "simplecov/combine/identity_interner"
 require_relative "simplecov/combine/branches_combiner"
 require_relative "simplecov/combine/methods_combiner"
-require_relative "simplecov/combine/files_combiner"
 require_relative "simplecov/combine/lines_combiner"
+require_relative "simplecov/combine/coverage_accumulator"
 require_relative "simplecov/combine/results_combiner"
 require_relative "simplecov/useless_results_remover"
 require_relative "simplecov/simulate_coverage"
+require_relative "simplecov/unloaded_file_injector"
 require_relative "simplecov/result_processing"
 require_relative "simplecov/exit_handling"
+require_relative "simplecov/report_deferral"
 require_relative "simplecov/parallel_coordination"
 
 # Load default config

data/schemas/coverage-v1.0.schema.json

@@ -254,7 +254,7 @@
         },
         "total": {"type": "integer", "minimum": 0, "description": "Executable lines: `covered + missed`. Does not include `omitted`."},
         "percent": {"type": "number"},
-        "strength": {"type": "number", "description": "Average number of executions across covered lines (hits per covered line)."}
+        "strength": {"type": "number", "description": "Average executions per coverable line: the sum of hit counts divided by `covered + missed`."}
       }
     },
     "coverage_statistic": {
@@ -266,7 +266,7 @@
         "missed": {"type": "integer", "minimum": 0},
         "total": {"type": "integer", "minimum": 0, "description": "Total branches or methods: `covered + missed`."},
         "percent": {"type": "number"},
-        "strength": {"type": "number", "description": "Average number of executions across covered branches or methods (hits per covered item)."}
+        "strength": {"type": "number", "description": "Average executions per coverable branch or method: the sum of hit counts divided by `covered + missed`."}
       }
     },
     "line_coverage": {

data/schemas/coverage.schema.json

@@ -254,7 +254,7 @@
         },
         "total": {"type": "integer", "minimum": 0, "description": "Executable lines: `covered + missed`. Does not include `omitted`."},
         "percent": {"type": "number"},
-        "strength": {"type": "number", "description": "Average number of executions across covered lines (hits per covered line)."}
+        "strength": {"type": "number", "description": "Average executions per coverable line: the sum of hit counts divided by `covered + missed`."}
       }
     },
     "coverage_statistic": {
@@ -266,7 +266,7 @@
         "missed": {"type": "integer", "minimum": 0},
         "total": {"type": "integer", "minimum": 0, "description": "Total branches or methods: `covered + missed`."},
         "percent": {"type": "number"},
-        "strength": {"type": "number", "description": "Average number of executions across covered branches or methods (hits per covered item)."}
+        "strength": {"type": "number", "description": "Average executions per coverable branch or method: the sum of hit counts divided by `covered + missed`."}
       }
     },
     "line_coverage": {

data/sig/simplecov.rbs

@@ -2,6 +2,7 @@
 module SimpleCov
   # A coverage criterion that can be enabled, measured, and reported.
   type criterion = :line | :branch | :method
+  type line_coverage_alternatives = Hash[criterion | :oneshot_line, :line | :oneshot_line]
 
   # Anything accepted by `skip` / `group` (and the deprecated
   # `add_filter` / `add_group`): a path-segment substring, a Regexp, a
@@ -17,6 +18,14 @@ module SimpleCov
   class ConfigurationError < StandardError
   end
 
+  module GroupNames
+    UNGROUPED: String
+
+    def self?.normalize: (untyped group_name) -> String
+
+    def self?.validate!: (Array[String] group_names) -> Array[String]
+  end
+
   # Maps SimpleCov's criterion names to the keys `Coverage.start` expects.
   CRITERION_TO_RUBY_COVERAGE: Hash[Symbol, Symbol]
 
@@ -27,12 +36,18 @@ module SimpleCov
   self.@autoloading_dot_simplecov: bool?
   self.@dot_simplecov_start_warned: bool?
   self.@at_exit_hook_installed: bool?
+  self.@run_id: String?
+  self.@worker_id: String?
 
   attr_accessor self.pid: Integer?
 
   # When this process started tracking coverage.
   attr_accessor self.process_start_time: Time?
 
+  def self.run_id: () -> String
+
+  def self.worker_id: () -> String
+
   # Should something external (e.g. the Minitest plugin) own the
   # at_exit behavior instead of SimpleCov's own hook?
   attr_accessor self.external_at_exit: bool?
@@ -107,8 +122,10 @@ module SimpleCov
 
   # Collate a series of resultset files into a single merged report. By
   # default ignores `merge_timeout` so every listed resultset merges;
-  # pass `ignore_timeout: false` to honor it.
-  def self.collate: (Array[String] result_filenames, ?(String | Symbol)? profile, ?ignore_timeout: bool) ?{ () [self: singleton(SimpleCov)] -> void } -> void
+  # pass `ignore_timeout: false` to honor it. `processes:` above 1 fans the
+  # merge out across that many forked workers, for an identical report;
+  # anything below 1 is taken as 1.
+  def self.collate: (Array[String] result_filenames, ?(String | Symbol)? profile, ?processes: Integer, ?ignore_timeout: bool) ?{ () [self: singleton(SimpleCov)] -> void } -> void
 
   # The result for the current coverage run, merged across test suites
   # when merging is active. nil when no coverage was tracked.
@@ -143,15 +160,27 @@ module SimpleCov
 
   def self.grouped_file_set: (Hash[String, FileList] grouped) -> Set[SourceFile]
 
-  def self.add_not_loaded_files: (Hash[String, untyped] result) -> [Hash[String, untyped], Set[String]]
-
   def self.unloaded_file_discovery_globs: () -> Array[String]
 
-  def self.discover_unloaded_paths: (Array[String] globs) -> Array[String]
+  # Every path this process was told to track, whether or not it loaded them.
+  # Recorded on the result (and from there into the resultset) so that a merge
+  # in another process can inject the ones nobody loaded without needing this
+  # process's `cover` / `track_files` configuration.
+  def self.tracked_file_paths: () -> Array[String]
+
+  # Add simulated coverage for each of `candidate_paths` the result doesn't
+  # already carry, and return it with the set of paths added.
+  #
+  # @api private — the seam `SimpleCov::ResultMerger` injects through.
+  def self.inject_unloaded_files: (Hash[String, untyped] result, Array[String] candidate_paths, ?synthesize: bool?, ?lines: bool?) -> [Hash[String, untyped], Set[String]]
 
-  def self.inject_unloaded_files: (Hash[String, untyped] result, Array[String] candidate_paths) -> [Hash[String, untyped], Set[String]]
+  # Build this process's slice of the coverage result. `standalone` is true
+  # when no merge step follows, which makes this the final result: it is the
+  # one that reports dropped source files, and the one that injects unloaded
+  # files. When a merge does follow, both jobs belong to the merged result.
+  def self.collect_own_coverage: (standalone: bool) -> void
 
-  def self.process_coverage_result: (report: bool) -> void
+  def self.process_coverage_result: (report: bool, ?inject_unloaded: bool) -> void
 end
 
 # ----- configuration -----
@@ -190,12 +219,15 @@ module SimpleCov
     # The hash of available profiles.
     def profiles: () -> Profiles
 
-    # Configure SimpleCov in a block, evaluated with `self` bound to
-    # the configuration target (usually the SimpleCov module itself):
+    # Configure SimpleCov in a block. A zero-argument block runs with the
+    # configuration target as `self`; a parameterized block keeps its lexical
+    # `self` and receives the target explicitly:
     #
     #     SimpleCov.configure { skip "test" }
+    #     SimpleCov.configure { |config| config.skip caller_filter }
     #
-    def configure: () { () [self: self] -> void } -> void
+    def configure: () { () [self: self] -> untyped } -> self
+                 | () { (self config) -> untyped } -> self
 
     # Gets or sets the behavior that processes coverage results at
     # process exit. The default stores/merges the current result and
@@ -215,14 +247,6 @@ module SimpleCov
     # capitalized, with underscores replaced by spaces.
     def project_name: (?String? new_name) -> String
 
-    private
-
-    # Copy instance variables from block_context into self, saving any
-    # of ours that would be clobbered.
-    def swap_ivars_from: (untyped block_context) -> Hash[Symbol, untyped]
-
-    # Copy instance variables back to block_context and restore ours.
-    def restore_ivars: (untyped block_context, Hash[Symbol, untyped] saved) -> void
   end
 end
 
@@ -230,7 +254,8 @@ end
 
 # Selection and validation of the coverage criteria Ruby's `Coverage`
 # library should track: `:line` (default), `:branch`, `:method`, and
-# `:oneshot_line`, plus the standalone `:eval` toggle.
+# `:oneshot_line`. The standalone `:eval` toggle lives in
+# `configuration/eval_coverage.rb`.
 module SimpleCov
   module Configuration
     # Members are line, branch, method, and oneshot_line (%i[] literals
@@ -241,18 +266,21 @@ module SimpleCov
 
     ONESHOT_LINE_COVERAGE_CRITERION: :oneshot_line
 
+    LINE_COVERAGE_ALTERNATIVES: line_coverage_alternatives
+
     @primary_coverage: (criterion | :oneshot_line)?
     @coverage_criteria: Set[criterion | :oneshot_line]?
     @coverage_for_eval_enabled: bool?
 
     # Enable one or more coverage criteria. `:eval` is accepted as a
-    # shorthand for the standalone eval-coverage toggle;
-    # `:oneshot_line` replaces `:line`.
+    # shorthand for the standalone eval-coverage toggle. `:line` and
+    # `:oneshot_line` replace each other; the last enabled mode wins.
     def enable_coverage: (*(criterion | :oneshot_line | :eval) criteria) -> void
 
     # Remove `criterion` from the set of enabled coverage criteria.
+    # `:eval` turns the standalone eval-coverage toggle back off.
     # Disabling every criterion raises at `start_tracking`, not here.
-    def disable_coverage: ((criterion | :oneshot_line) criterion) -> void
+    def disable_coverage: ((criterion | :oneshot_line | :eval) criterion) -> void
 
     # Gets the report's leading criterion, or sets it. The setter
     # validates at runtime that the criterion is enabled; the parameter
@@ -272,6 +300,12 @@ module SimpleCov
 
     def validate_coverage_criteria!: () -> void
 
+    # Whether this run produces line data at all. The oneshot variant counts:
+    # `ResultAdapter` turns its executed-line list back into a line array. A
+    # branch-only or method-only run produces none, and `Coverage.result`
+    # entries for the files it loaded carry no `"lines"` key.
+    def line_coverage?: () -> bool
+
     def branch_coverage?: () -> bool
 
     def branch_coverage_supported?: () -> bool
@@ -280,21 +314,14 @@ module SimpleCov
 
     def method_coverage_supported?: () -> bool
 
-    def coverage_for_eval_supported?: () -> bool
-
     # Whether the running Ruby's Coverage library supports the given
     # criterion, named in Coverage's own plural vocabulary
     # (`:lines`, `:branches`, `:methods`, `:oneshot_lines`, `:eval`).
     def coverage_criterion_supported?: (Symbol criterion) -> bool
 
-    def coverage_for_eval_enabled?: () -> bool
-
-    # DEPRECATED: use `enable_coverage :eval` instead.
-    def enable_coverage_for_eval: () -> void
-
     private
 
-    def enable_eval_coverage: () -> void
+    def add_coverage_criterion: ((criterion | :oneshot_line) criterion) -> void
 
     def default_primary_coverage: () -> (criterion | :oneshot_line)
 
@@ -306,6 +333,28 @@ module SimpleCov
   end
 end
 
+# ----- configuration/eval_coverage -----
+
+# The standalone eval-coverage toggle (`enable_coverage :eval`),
+# instrumenting `eval`'d code on Rubies that support it. A boolean
+# toggle, never a member of the enabled-criteria set.
+module SimpleCov
+  module Configuration
+    def coverage_for_eval_supported?: () -> bool
+
+    def coverage_for_eval_enabled?: () -> bool
+
+    # DEPRECATED: use `enable_coverage :eval` instead.
+    def enable_coverage_for_eval: () -> void
+
+    private
+
+    def enable_eval_coverage: () -> void
+
+    def disable_eval_coverage: () -> void
+  end
+end
+
 # ----- configuration/coverage -----
 
 # The criterion-first `coverage` configuration method: naming a
@@ -331,9 +380,9 @@ module SimpleCov
     # Configure (and, unless `enabled: false`, enable) a coverage
     # criterion. `primary: true` makes it the report's leading
     # criterion; `oneshot: true` (only for `:line`) selects
-    # oneshot-lines mode; `:eval` is enable-only. Threshold keywords
-    # mirror the block verbs for one-liner use. Returns the criterion
-    # symbol the thresholds were stored under.
+    # oneshot-lines mode. Threshold keywords mirror the block verbs
+    # for one-liner use. Returns the criterion symbol the thresholds
+    # were stored under.
     # The threshold keywords (minimum:, maximum:, exact:, maximum_drop:,
     # minimum_per_file:) arrive via **thresholds in the implementation, so
     # they are typed as a Numeric kwarg splat. The block runs under
@@ -346,9 +395,7 @@ module SimpleCov
 
     def enable_coverage_criterion: ((criterion | :eval) criterion, enabled: bool, oneshot: bool) -> (criterion | :oneshot_line | :eval)
 
-    def enable_oneshot_line: ((criterion | :eval) criterion) -> :oneshot_line
-
-    def enable_eval_coverage_criterion: () -> :eval
+    def resolve_criterion_variant: ((criterion | :eval) criterion, bool oneshot) -> (criterion | :oneshot_line | :eval)
 
     # Threshold-store writers used by CoverageCriterion via `send`.
     # They accept any criterion Symbol; `raise_on_invalid_coverage`
@@ -604,7 +651,7 @@ module SimpleCov
     # into a single coverage report. Defaults to true.
     def merging: (?bool? use) -> bool
 
-    # Get or set whether this process owns final merge processing:
+    # Get or set whether SimpleCov's selected final process owns merge processing:
     # waiting for sibling workers, merging, formatting, enforcing
     # thresholds, and writing `.last_run.json`. Defaults to true except
     # for recognized multi-worker parallel runs writing to a custom
@@ -618,7 +665,7 @@ module SimpleCov
 
     # DEPRECATED: use `merging` instead (same value, same behavior).
     # Returns nil when merging had already been disabled.
-    def use_merging: (?bool? use) -> bool?
+    def use_merging: (?bool? use) -> bool
 
     # The maximum age (in seconds) of a resultset to still be included
     # in merged results. Defaults to 600.
@@ -644,9 +691,11 @@ module SimpleCov
     def inferred_finalize_merge_warning: () -> String
 
     # Host contract: defined on SimpleCov itself (result_processing.rb).
-    # This module is only ever extended onto SimpleCov, where the
-    # method is available to `merge_finalization_owner?`.
+    # This module is only ever extended onto SimpleCov, where both methods
+    # are available to `merge_finalization_owner?`.
     def collating_result?: () -> boolish
+
+    def final_result_process?: () -> boolish
   end
 end
 
@@ -710,6 +759,9 @@ module SimpleCov
 
     private
 
+    # Shared normalize-and-validate step behind every threshold setter.
+    def normalized_threshold: ((Numeric | coverage_thresholds) coverage, String setting) -> coverage_thresholds
+
     def partition_per_file_thresholds: (Hash[Symbol | String | Regexp, Numeric | coverage_thresholds] coverage) -> [coverage_thresholds, Hash[String | Regexp, coverage_thresholds]]
 
     def validate_per_file_key: ((Symbol | String | Regexp) key) -> void
@@ -733,6 +785,11 @@ module SimpleCov
     extend Forwardable
 
     attr_reader original_result: Hash[String, untyped]
+
+    # Every path the producing process was told to track, loaded or not.
+    attr_reader tracked_files: Array[String]
+    attr_reader run_id: String?
+    attr_reader worker_id: String?
     attr_reader files: FileList
     alias source_files files
     # The writers accept the strict types; the ivars stay nilable because
@@ -756,7 +813,7 @@ module SimpleCov
       def initialize: (?filters: Array[Filter[untyped]], ?cover_filters: Array[Filter[untyped]], ?groups: Hash[String, Filter[untyped]]) -> void
     end
 
-    def initialize: (Hash[String, untyped] original_result, ?command_name: String?, ?created_at: Time?, ?not_loaded_files: Set[String], ?report: bool, ?filter_config: FilterConfig) -> void
+    def initialize: (Hash[String, untyped] original_result, ?command_name: String?, ?created_at: Time?, ?not_loaded_files: Set[String], ?tracked_files: _ToA[String], ?run_id: String?, ?worker_id: String?, ?report: bool, ?filter_config: FilterConfig) -> void
 
     def filenames: () -> Array[String]
     # Accepts an absolute or project-relative path (resolved against SimpleCov.root).
@@ -768,13 +825,13 @@ module SimpleCov
     def format!: () -> untyped
     def created_at: () -> Time
     def command_name: () -> String
-    def to_hash: () -> Hash[String, { "coverage" => Hash[String, untyped], "timestamp" => Integer }]
+    def to_hash: () -> Hash[String, Hash[String, untyped]]
     def self.from_hash: (Hash[String, untyped] hash) -> Array[Result]
 
     # Delegated to #files (see FileList).
     def covered_percent: (?criterion) -> Float?
     def covered_percentages: () -> Array[Float?]
-    def least_covered_file: () -> String
+    def least_covered_file: () -> String?
     def covered_strength: (?criterion) -> Float?
     def covered_lines: () -> Integer?
     def missed_lines: () -> Integer?
@@ -791,6 +848,7 @@ module SimpleCov
 
     private
 
+    def initialize_coordination_metadata: (_ToA[String] tracked_files, String? run_id, String? worker_id) -> void
     def warn_about_missing_source_files: (Array[String] missing, Integer input_size) -> void
     def coverage: () -> Hash[String, untyped]
     def apply_filters!: (Array[Filter[untyped]] filters) -> void
@@ -833,11 +891,10 @@ module SimpleCov
 
     def covered_lines: () -> Integer?
     def missed_lines: () -> Integer?
-    # 0.0 when the list is empty, an Integer sum otherwise.
-    def never_lines: () -> (Integer | Float)
-    def skipped_lines: () -> (Integer | Float)
+    def never_lines: () -> Integer
+    def skipped_lines: () -> Integer
     def covered_percentages: () -> Array[Float?]
-    def least_covered_file: () -> String
+    def least_covered_file: () -> String?
     def lines_of_code: () -> Integer?
     def covered_percent: (?criterion) -> Float?
     def covered_strength: (?criterion) -> Float?
@@ -1064,6 +1121,8 @@ module SimpleCov
       def branch_statistics: () -> Hash[criterion, CoverageStatistics]
 
       def method_statistics: () -> Hash[criterion, CoverageStatistics]
+
+      def coverage_statistics: (Array[Line | Branch | Method] covered, Array[Line | Branch | Method] missed, ?omitted: Integer, ?percent: Float?) -> CoverageStatistics
     end
   end
 end
@@ -1141,10 +1200,13 @@ module SimpleCov
   module LastRun
     def self.last_run_path: () -> String
 
-    # nil when the file does not exist or is blank. Keys are symbolized.
+    # nil when the file does not exist, is blank, or does not hold a
+    # JSON object. Keys are symbolized.
     def self.read: () -> Hash[Symbol, untyped]?
 
     def self.write: (Hash[Symbol, untyped] json) -> void
+
+    def self.invalid_last_run: () -> nil
   end
 end
 
@@ -1161,7 +1223,11 @@ module SimpleCov
     # The base implementation raises NotImplementedError.
     def matches?: (SourceFile source_file) -> boolish
 
-    def self.build_filter: (filter_arg filter_argument) -> Filter[untyped]
+    # Whether the verdict depends only on the path, so it can be decided
+    # before the file has any coverage.
+    def path_only?: () -> bool
+
+    def self.build_filter: (filter_arg filter_argument, ?string_filter: singleton(Filter)) -> Filter[untyped]
 
     def self.class_for_argument: (filter_arg filter_argument) -> singleton(Filter)
 
@@ -1177,6 +1243,10 @@ module SimpleCov
   class StringFilter < Filter[String]
     def matches?: (SourceFile source_file) -> bool
 
+    # Whether the verdict depends only on the path, so it can be decided
+    # before the file has any coverage.
+    def path_only?: () -> bool
+
     private
 
     @segment_pattern: Regexp?
@@ -1189,17 +1259,29 @@ module SimpleCov
   # Matches when the project path matches the configured Regexp.
   class RegexFilter < Filter[Regexp]
     def matches?: (SourceFile source_file) -> bool
+
+    # Whether the verdict depends only on the path, so it can be decided
+    # before the file has any coverage.
+    def path_only?: () -> bool
   end
 
   # Matches when the configured block returns truthy for the source file.
   class BlockFilter < Filter[^(SourceFile) -> boolish]
     def matches?: (SourceFile source_file) -> boolish
+
+    # Whether the verdict depends only on the path, so it can be decided
+    # before the file has any coverage.
+    def path_only?: () -> bool
   end
 
   # Matches when the project path matches the configured shell glob
   # (e.g. "lib/**/*.rb").
   class GlobFilter < Filter[String]
     def matches?: (SourceFile source_file) -> bool
+
+    # Whether the verdict depends only on the path, so it can be decided
+    # before the file has any coverage.
+    def path_only?: () -> bool
   end
 
   # Matches when any of the component filters built from the array's
@@ -1209,6 +1291,10 @@ module SimpleCov
     def initialize: (Array[filter_arg] filter_argument) -> void
 
     def matches?: (SourceFile source_file) -> boolish
+
+    # Whether the verdict depends only on the path, so it can be decided
+    # before the file has any coverage.
+    def path_only?: () -> bool
   end
 end
 
@@ -1229,6 +1315,9 @@ module SimpleCov
     # Normalizes a configured formatter — class or ready-built
     # instance — into an instance. See #1240.
     def self.instance_for: (untyped formatter) -> untyped
+
+    # Instantiates a formatter class when necessary and dispatches the result.
+    def self.format: (untyped formatter, SimpleCov::Result result) -> untyped
   end
 end
 
@@ -1264,6 +1353,10 @@ module SimpleCov
       # `coverage.json`); nil leaves the bare directory in the status line.
       def entry_point_filename: () -> String?
 
+      # Prints `output_message` to stderr unless silent; the one home of
+      # the "status lines go to stderr, not through warn" decision (#1225).
+      def emit_status: (SimpleCov::Result result) -> void
+
       def output_message: (SimpleCov::Result result) -> String
 
       # nil for branch/method criteria with nothing to measure, so the
@@ -1284,7 +1377,7 @@ module SimpleCov
 
       private
 
-      def format_group: (String name, SimpleCov::FileList files) -> String
+      def format_group: (String name, SimpleCov::FileList files, SimpleCov::criterion criterion) -> String
     end
   end
 end
@@ -1320,11 +1413,16 @@ end
 
 module SimpleCov
   module Formatter
-    # Writes the HTML report: coverage_data.js plus pre-compiled static
-    # assets, and coverage.json as a side artifact (shared serialization
+    # Writes the HTML report as a single self-contained index.html (the
+    # compiled template with the coverage JSON substituted at the data
+    # marker), and coverage.json as a side artifact (shared serialization
     # via JSONFormatter.build_hash).
     class HTMLFormatter < Base
-      DATA_FILENAME: "coverage_data.js"
+      DATA_MARKER: "<!-- SIMPLECOV_COVERAGE_DATA -->"
+
+      # The sibling files a 1.0.0 through 1.0.3 report wrote next to
+      # index.html, removed by format when an earlier version left them.
+      LEGACY_REPORT_FILES: Array[String]
 
       def format: (SimpleCov::Result result) -> void
 
@@ -1336,17 +1434,55 @@ module SimpleCov
 
       def entry_point_filename: () -> String
 
-      def copy_static_assets: (?String dest_dir) -> void
+      def source_less_hash: (Hash[Symbol, untyped] hash) -> Hash[Symbol, untyped]
+
+      # Write coverage.json and index.html, then clear any legacy
+      # sibling files an earlier version left in the output directory.
+      def write_report_files: (Hash[untyped, untyped] json_hash, Hash[untyped, untyped] viewer_hash, SimpleCov::Result result) -> void
 
-      # Write via temp file + File.rename so parallel writers can't race
-      # and read-only existing assets are replaced without EACCES.
-      def atomic_write: (String dest, String content) -> void
+      # Substitute the coverage JSON into the compiled template.
+      def render_report: (String json) -> String
 
       def public_dir: () -> String
     end
   end
 end
 
+# ----- formatter/coverage_json_writer -----
+
+module SimpleCov
+  module Formatter
+    # Shared writer for the coverage.json artifact (JSONFormatter's
+    # report and HTMLFormatter's side file): one pretty-printed binary
+    # write plus the issue-#1171 concurrent-overwrite warning.
+    module CoverageJSONWriter
+      FILENAME: "coverage.json"
+
+      META_SCAN_BYTES: Integer
+
+      def self?.write: (untyped output_path, Hash[Symbol, untyped] hash, SimpleCov::Result result) -> String
+
+      # Warns when an existing coverage.json is newer than this process's
+      # start time (a concurrent sibling writer). See issue #1171.
+      def self?.warn_if_concurrent_overwrite: (String path, SimpleCov::Result result) -> void
+
+      # timestamp stays untyped (not Time) so the comparison sites don't
+      # require the stdlib `time` extension sigs; the value is produced by
+      # Time.iso8601 at runtime.
+      def self?.existing_meta: (String path) -> ({ timestamp: untyped, command_name: untyped })?
+
+      def self?.parse_meta: (String path) -> Hash[Symbol, untyped]?
+
+      # Bounded head read that parses just the flat meta object of files
+      # this module wrote; nil on any miss so parse_meta falls back to a
+      # full parse.
+      def self?.parse_meta_head: (String path) -> Hash[Symbol, untyped]?
+
+      def self?.parse_meta_full: (String path) -> Hash[Symbol, untyped]?
+    end
+  end
+end
+
 # ----- formatter/json_formatter -----
 
 module SimpleCov
@@ -1368,15 +1504,6 @@ module SimpleCov
       def message_prefix: () -> String
 
       def entry_point_filename: () -> String
-
-      # Warns when an existing coverage.json is newer than this process's
-      # start time (a concurrent sibling writer). See issue #1171.
-      def warn_if_concurrent_overwrite: (String path, SimpleCov::Result result) -> void
-
-      # timestamp stays untyped (not Time) so the comparison sites don't
-      # require the stdlib `time` extension sigs; the value is produced by
-      # Time.iso8601 at runtime.
-      def existing_meta: (String path) -> ({ timestamp: untyped, command_name: untyped })?
     end
   end
 end
@@ -1556,6 +1683,13 @@ module SimpleCov
 
       # How many parallel workers participate in this run. Defaults to 1.
       def self.expected_worker_count: () -> Integer
+
+      # The user's explicit `SimpleCov.parallel_tests false` opt-out.
+      def self.forced_off?: () -> bool
+
+      # Shared PARALLEL_TEST_GROUPS parsing; 1 for unset, empty,
+      # non-numeric, or non-positive values.
+      def self.parallel_test_groups_count: () -> Integer
     end
   end
 end