diff --git a/.rubocop.yml b/.rubocop.yml
index 8f0f17b2..4b337765 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -188,6 +188,10 @@ Metrics/MethodLength:
   CountComments: false
   Max: 12 # TODO: Lower to 10
 
+Style/Next:
+  Description: Prefer `if` guards over `next` inside loops for readability.
+  Enabled: false
+
 Metrics/ModuleLength:
   Description: Avoid modules longer than 100 lines of code.
   Max: 300
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d99693a6..09fa1a3c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,24 @@
 Unreleased
 ==========
 
+## Breaking Changes
+* JSON formatter: group stats changed from `{ "covered_percent": 80.0 }` to full stats shape `{ "covered": 8, "missed": 2, "total": 10, "percent": 80.0, "strength": 0.0 }`. The key `covered_percent` is renamed to `percent`.
+* JSON formatter: `simplecov_json_formatter` gem is now built in. `require "simplecov_json_formatter"` continues to work via a shim.
+* `StringFilter` now matches at path-segment boundaries. `"lib"` matches `/lib/` but no longer matches `/library/`. Use a `Regexp` filter for substring matching.
+* Removed `docile` gem dependency. The `SimpleCov.configure` DSL block is now evaluated via `instance_exec` with instance variable proxying.
+
+## Enhancements
+* JSON formatter: added `total` section with aggregate coverage statistics (covered, missed, total, percent, strength) for line, branch, and method coverage. Line stats additionally include `omitted` (count of blank/comment lines, i.e. lines that cannot be covered)
+* JSON formatter: per-file output now includes `lines_covered_percent`, and when enabled: `branches_covered_percent`, `methods` array, and `methods_covered_percent`
+* JSON formatter: group stats now include full statistics for all enabled coverage types, not just line coverage percent
+* JSON formatter: added `silent:` keyword to `JSONFormatter.new` to suppress console output
+* Merged `simplecov-html` formatter into the main gem. A backward-compatibility shim ensures `require "simplecov-html"` still works.
+* Merged `simplecov_json_formatter` into the main gem. A backward-compatibility shim ensures `require "simplecov_json_formatter"` still works.
+* `CommandGuesser` now appends the framework name to parallel test data (e.g. `"RSpec (1/2)"` instead of `"(1/2)"`)
+
 ## Bugfixes
 * Don't report misleading 100% branch/method coverage for files added via `track_files` that were never loaded. See #902
+* Fix HTML formatter tab bar layout: dark mode toggle no longer wraps onto two lines, and tabs connect seamlessly with the content panel
 
 0.22.1 (2024-09-02)
 ==========
diff --git a/features/step_definitions/json_steps.rb b/features/step_definitions/json_steps.rb
index a66f1461..fd94548e 100644
--- a/features/step_definitions/json_steps.rb
+++ b/features/step_definitions/json_steps.rb
@@ -6,7 +6,12 @@
     coverage_hash = json_report.fetch "coverage"
     directory = Dir.pwd
 
-    expect(coverage_hash.fetch("#{directory}/lib/faked_project.rb")).to eq "lines" => [nil, nil, 1, 1, 1, nil, nil, nil, 5, 3, nil, nil, 1]
-    expect(coverage_hash.fetch("#{directory}/lib/faked_project/some_class.rb")).to eq "lines" => [nil, nil, 1, 1, 1, nil, 1, 2, nil, nil, 1, 1, nil, nil, 1, 1, 1, nil, 0, nil, nil, 0, nil, nil, 1, nil, 1, 0, nil, nil]
+    faked_project = coverage_hash.fetch("#{directory}/lib/faked_project.rb")
+    expect(faked_project["lines"]).to eq [nil, nil, 1, 1, 1, nil, nil, nil, 5, 3, nil, nil, 1]
+    expect(faked_project["lines_covered_percent"]).to be_a(Float)
+
+    some_class = coverage_hash.fetch("#{directory}/lib/faked_project/some_class.rb")
+    expect(some_class["lines"]).to eq [nil, nil, 1, 1, 1, nil, 1, 2, nil, nil, 1, 1, nil, nil, 1, 1, 1, nil, 0, nil, nil, 0, nil, nil, 1, nil, 1, 0, nil, nil]
+    expect(some_class["lines_covered_percent"]).to be_a(Float)
   end
 end
diff --git a/lib/simplecov.rb b/lib/simplecov.rb
index b829678d..0430b120 100644
--- a/lib/simplecov.rb
+++ b/lib/simplecov.rb
@@ -478,6 +478,7 @@ def probably_running_parallel_tests?
 require_relative "simplecov/configuration"
 SimpleCov.extend SimpleCov::Configuration
 require_relative "simplecov/coverage_statistics"
+require_relative "simplecov/coverage_violations"
 require_relative "simplecov/exit_codes"
 require_relative "simplecov/profiles"
 require_relative "simplecov/source_file/line"
diff --git a/lib/simplecov/coverage_statistics.rb b/lib/simplecov/coverage_statistics.rb
index a9666f26..cff423cc 100644
--- a/lib/simplecov/coverage_statistics.rb
+++ b/lib/simplecov/coverage_statistics.rb
@@ -8,32 +8,35 @@ module SimpleCov
   # * total - how many things to cover there are (total relevant loc/branches)
   # * covered - how many of the coverables are hit
   # * missed - how many of the coverables are missed
+  # * omitted - how many lines cannot be covered (blank lines/comments); only meaningful for line coverage
   # * percent - percentage as covered/missed
   # * strength - average hits per/coverable (will not exist for one shot lines format)
   class CoverageStatistics
-    attr_reader :total, :covered, :missed, :strength, :percent
+    attr_reader :total, :covered, :missed, :omitted, :strength, :percent
 
     def self.from(coverage_statistics)
-      sum_covered, sum_missed, sum_total_strength =
-        coverage_statistics.reduce([0, 0, 0.0]) do |(covered, missed, total_strength), file_coverage_statistics|
+      sum_covered, sum_missed, sum_omitted, sum_total_strength =
+        coverage_statistics.reduce([0, 0, 0, 0.0]) do |(covered, missed, omitted, total_strength), file_coverage_statistics|
           [
             covered + file_coverage_statistics.covered,
             missed + file_coverage_statistics.missed,
+            omitted + file_coverage_statistics.omitted,
             # gotta remultiply with loc because files have different strength and loc
             # giving them a different "weight" in total
             total_strength + (file_coverage_statistics.strength * file_coverage_statistics.total)
           ]
         end
 
-      new(covered: sum_covered, missed: sum_missed, total_strength: sum_total_strength)
+      new(covered: sum_covered, missed: sum_missed, omitted: sum_omitted, total_strength: sum_total_strength)
     end
 
     # Requires only covered, missed and strength to be initialized.
     #
     # Other values are computed by this class.
-    def initialize(covered:, missed:, total_strength: 0.0, percent: nil)
+    def initialize(covered:, missed:, omitted: 0, total_strength: 0.0, percent: nil)
       @covered  = covered
       @missed   = missed
+      @omitted  = omitted
       @total    = covered + missed
       @percent  = percent || compute_percent(covered, missed, total)
       @strength = compute_strength(total_strength, total)
diff --git a/lib/simplecov/coverage_violations.rb b/lib/simplecov/coverage_violations.rb
new file mode 100644
index 00000000..77a7b354
--- /dev/null
+++ b/lib/simplecov/coverage_violations.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Computes coverage threshold violations for a given result. Shared by
+  # the exit-code checks and the JSON formatter's `errors` section.
+  #
+  # Each method returns an array of violation hashes. All percents are
+  # rounded via `SimpleCov.round_coverage` so downstream consumers don't
+  # need to round again.
+  module CoverageViolations
+    class << self
+      # @return [Array<Hash>] {:criterion, :expected, :actual}
+      def minimum_overall(result, thresholds)
+        thresholds.filter_map do |criterion, expected|
+          actual = round(result.coverage_statistics.fetch(criterion).percent)
+          {criterion: criterion, expected: expected, actual: actual} if actual < expected
+        end
+      end
+
+      # @return [Array<Hash>] {:criterion, :expected, :actual, :filename, :project_filename}
+      def minimum_by_file(result, thresholds)
+        thresholds.flat_map do |criterion, expected|
+          result.files.filter_map { |file| file_minimum_violation(file, criterion, expected) }
+        end
+      end
+
+      # @return [Array<Hash>] {:group_name, :criterion, :expected, :actual}
+      def minimum_by_group(result, thresholds)
+        thresholds.flat_map do |group_name, minimums|
+          group = lookup_group(result, group_name)
+          group ? group_minimum_violations(group_name, group, minimums) : []
+        end
+      end
+
+      # @return [Array<Hash>] {:criterion, :maximum, :actual} where `actual`
+      #   is the observed drop (in percentage points) vs. the last run.
+      def maximum_drop(result, thresholds, last_run: SimpleCov::LastRun.read)
+        return [] unless last_run
+
+        thresholds.filter_map do |criterion, maximum|
+          actual = compute_drop(criterion, result, last_run)
+          {criterion: criterion, maximum: maximum, actual: actual} if actual && actual > maximum
+        end
+      end
+
+    private
+
+      def file_minimum_violation(file, criterion, expected)
+        actual = round(file.coverage_statistics.fetch(criterion).percent)
+        return unless actual < expected
+
+        {
+          criterion: criterion,
+          expected: expected,
+          actual: actual,
+          filename: file.filename,
+          project_filename: file.project_filename
+        }
+      end
+
+      def group_minimum_violations(group_name, group, minimums)
+        minimums.filter_map do |criterion, expected|
+          actual = round(group.coverage_statistics.fetch(criterion).percent)
+          {group_name: group_name, criterion: criterion, expected: expected, actual: actual} if actual < expected
+        end
+      end
+
+      def lookup_group(result, group_name)
+        group = result.groups[group_name]
+        warn "minimum_coverage_by_group: no group named '#{group_name}' exists. Available groups: #{result.groups.keys.join(', ')}" unless group
+        group
+      end
+
+      def compute_drop(criterion, result, last_run)
+        last_coverage_percent = last_run.dig(:result, criterion)
+        last_coverage_percent ||= last_run.dig(:result, :covered_percent) if criterion == :line
+        return unless last_coverage_percent
+
+        current = round(result.coverage_statistics.fetch(criterion).percent)
+        (last_coverage_percent - current).floor(10)
+      end
+
+      def round(percent)
+        SimpleCov.round_coverage(percent)
+      end
+    end
+  end
+end
diff --git a/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb b/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb
index b77f3d50..7484507c 100644
--- a/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb
+++ b/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb
@@ -3,26 +3,22 @@
 module SimpleCov
   module ExitCodes
     class MaximumCoverageDropCheck
-      MAX_DROP_ACCURACY = 10
-
       def initialize(result, maximum_coverage_drop)
         @result = result
         @maximum_coverage_drop = maximum_coverage_drop
       end
 
       def failing?
-        return false unless maximum_coverage_drop && last_run
-
-        coverage_drop_violations.any?
+        violations.any?
       end
 
       def report
-        coverage_drop_violations.each do |violation|
+        violations.each do |violation|
           $stderr.printf(
             "%<criterion>s coverage has dropped by %<drop_percent>.2f%% since the last time (maximum allowed: %<max_drop>.2f%%).\n",
-            criterion: violation[:criterion].capitalize,
-            drop_percent: SimpleCov.round_coverage(violation[:drop_percent]),
-            max_drop: violation[:max_drop]
+            criterion: violation.fetch(:criterion).capitalize,
+            drop_percent: violation.fetch(:actual),
+            max_drop: violation.fetch(:maximum)
           )
         end
       end
@@ -33,50 +29,8 @@ def exit_code
 
     private
 
-      attr_reader :result, :maximum_coverage_drop
-
-      def last_run
-        return @last_run if defined?(@last_run)
-
-        @last_run = SimpleCov::LastRun.read
-      end
-
-      def coverage_drop_violations
-        @coverage_drop_violations ||=
-          compute_coverage_drop_data.select do |achieved|
-            achieved.fetch(:max_drop) < achieved.fetch(:drop_percent)
-          end
-      end
-
-      def compute_coverage_drop_data
-        maximum_coverage_drop.map do |criterion, percent|
-          {
-            criterion: criterion,
-            max_drop: percent,
-            drop_percent: drop_percent(criterion)
-          }
-        end
-      end
-
-      def drop_percent(criterion)
-        drop = last_coverage(criterion) -
-               SimpleCov.round_coverage(
-                 result.coverage_statistics.fetch(criterion).percent
-               )
-
-        # floats, I tell ya.
-        # irb(main):001:0* 80.01 - 80.0
-        # => 0.010000000000005116
-        drop.floor(MAX_DROP_ACCURACY)
-      end
-
-      def last_coverage(criterion)
-        last_coverage_percent = last_run[:result][criterion]
-
-        # fallback for old file format
-        last_coverage_percent = last_run[:result][:covered_percent] if !last_coverage_percent && criterion == :line
-
-        last_coverage_percent || 0
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.maximum_drop(@result, @maximum_coverage_drop)
       end
     end
   end
diff --git a/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb b/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb
index 80820b9b..e41d74c6 100644
--- a/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb
+++ b/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb
@@ -9,17 +9,17 @@ def initialize(result, minimum_coverage_by_file)
       end
 
       def failing?
-        minimum_violations.any?
+        violations.any?
       end
 
       def report
-        minimum_violations.each do |violation|
+        violations.each do |violation|
           $stderr.printf(
             "%<criterion>s coverage by file (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%) in %<filename>s.\n",
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
+            covered: violation.fetch(:actual),
+            minimum_coverage: violation.fetch(:expected),
             criterion: violation.fetch(:criterion).capitalize,
-            filename: violation.fetch(:filename)
+            filename: violation.fetch(:project_filename)
           )
         end
       end
@@ -30,27 +30,8 @@ def exit_code
 
     private
 
-      attr_reader :result, :minimum_coverage_by_file
-
-      def minimum_violations
-        @minimum_violations ||=
-          compute_minimum_coverage_data.select do |achieved|
-            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-          end
-      end
-
-      def compute_minimum_coverage_data
-        minimum_coverage_by_file.flat_map do |criterion, expected_percent|
-          result.files.map do |file|
-            actual_coverage = file.coverage_statistics.fetch(criterion)
-            {
-              criterion: criterion,
-              minimum_expected: expected_percent,
-              actual: SimpleCov.round_coverage(actual_coverage.percent),
-              filename: file.project_filename
-            }
-          end
-        end
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_by_file(@result, @minimum_coverage_by_file)
       end
     end
   end
diff --git a/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb b/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb
index d424947a..bc6179d6 100644
--- a/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb
+++ b/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb
@@ -9,16 +9,16 @@ def initialize(result, minimum_coverage_by_group)
       end
 
       def failing?
-        minimum_violations.any?
+        violations.any?
       end
 
       def report
-        minimum_violations.each do |violation|
+        violations.each do |violation|
           $stderr.printf(
             "%<criterion>s coverage by group (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%) in %<group_name>s.\n",
             group_name: violation.fetch(:group_name),
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
+            covered: violation.fetch(:actual),
+            minimum_coverage: violation.fetch(:expected),
             criterion: violation.fetch(:criterion).capitalize
           )
         end
@@ -30,41 +30,8 @@ def exit_code
 
     private
 
-      attr_reader :result, :minimum_coverage_by_group
-
-      def minimum_violations
-        @minimum_violations ||=
-          compute_minimum_coverage_data.select do |achieved|
-            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-          end
-      end
-
-      def compute_minimum_coverage_data
-        minimum_coverage_by_group.flat_map do |group_name, minimum_group_coverage|
-          group = find_group(group_name)
-          next [] unless group
-
-          minimum_group_coverage.map do |criterion, expected_percent|
-            actual_coverage = group.coverage_statistics.fetch(criterion)
-            minimum_coverage_hash(group_name, criterion, expected_percent, SimpleCov.round_coverage(actual_coverage.percent))
-          end
-        end
-      end
-
-      def find_group(group_name)
-        result.groups[group_name] || begin
-          warn "minimum_coverage_by_group: no group named '#{group_name}' exists. Available groups: #{result.groups.keys.join(', ')}"
-          nil
-        end
-      end
-
-      def minimum_coverage_hash(group_name, criterion, minimum_expected, actual)
-        {
-          group_name: group_name,
-          criterion: criterion,
-          minimum_expected: minimum_expected,
-          actual: actual
-        }
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_by_group(@result, @minimum_coverage_by_group)
       end
     end
   end
diff --git a/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb b/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb
index ea3a0ea9..c44b3157 100644
--- a/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb
+++ b/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb
@@ -9,15 +9,15 @@ def initialize(result, minimum_coverage)
       end
 
       def failing?
-        minimum_violations.any?
+        violations.any?
       end
 
       def report
-        minimum_violations.each do |violation|
+        violations.each do |violation|
           $stderr.printf(
             "%<criterion>s coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
+            covered: violation.fetch(:actual),
+            minimum_coverage: violation.fetch(:expected),
             criterion: violation.fetch(:criterion).capitalize
           )
         end
@@ -29,24 +29,8 @@ def exit_code
 
     private
 
-      attr_reader :result, :minimum_coverage
-
-      def minimum_violations
-        @minimum_violations ||= calculate_minimum_violations
-      end
-
-      def calculate_minimum_violations
-        coverage_achieved = minimum_coverage.map do |criterion, percent|
-          {
-            criterion: criterion,
-            minimum_expected: percent,
-            actual: result.coverage_statistics.fetch(criterion).percent
-          }
-        end
-
-        coverage_achieved.select do |achieved|
-          achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-        end
+      def violations
+        @violations ||= SimpleCov::CoverageViolations.minimum_overall(@result, @minimum_coverage)
       end
     end
   end
diff --git a/lib/simplecov/formatter/html_formatter/coverage_helpers.rb b/lib/simplecov/formatter/html_formatter/coverage_helpers.rb
index 9a50c1ea..a2fc0dfe 100644
--- a/lib/simplecov/formatter/html_formatter/coverage_helpers.rb
+++ b/lib/simplecov/formatter/html_formatter/coverage_helpers.rb
@@ -47,21 +47,17 @@ def coverage_type_summary(type, label, summary, enabled:, **opts)
           enabled_type_summary(type, label, summary.fetch(type.to_sym), opts)
         end
 
-        def coverage_summary(stats, show_method_toggle: false)
+        def coverage_summary(source_file, show_method_toggle: false)
+          stats = source_file.coverage_statistics
           _summary = {
-            line: build_stats(stats.fetch(:covered_lines), stats.fetch(:total_lines)),
-            branch: build_stats(stats.fetch(:covered_branches, 0), stats.fetch(:total_branches, 0)),
-            method: build_stats(stats.fetch(:covered_methods, 0), stats.fetch(:total_methods, 0)),
+            line: stats[:line],
+            branch: stats[:branch],
+            method: stats[:method],
             show_method_toggle: show_method_toggle
           }
           template("coverage_summary").result(binding)
         end
 
-        def build_stats(covered, total)
-          pct = total.positive? ? (covered * 100.0 / total) : 100.0
-          {covered: covered, total: total, missed: total - covered, pct: pct}
-        end
-
       private
 
         def totals_cell_attrs(type, css)
@@ -104,12 +100,12 @@ def append_method_attrs(pairs, source_file)
         end
 
         def enabled_type_summary(type, label, stats, opts)
-          css = coverage_css_class(stats.fetch(:pct))
-          missed = stats.fetch(:missed)
+          css = coverage_css_class(stats.percent)
+          missed = stats.missed
           parts = [
             %(<div class="t-#{type}-summary">\n    #{label}: ),
-            %(<span class="#{css}"><b>#{Kernel.format('%.2f', stats.fetch(:pct).floor(2))}%</b></span>),
-            %(<span class="coverage-cell__fraction"> #{stats.fetch(:covered)}/#{stats.fetch(:total)} #{opts.fetch(:suffix, 'covered')}</span>)
+            %(<span class="#{css}"><b>#{Kernel.format('%.2f', stats.percent.floor(2))}%</b></span>),
+            %(<span class="coverage-cell__fraction"> #{stats.covered}/#{stats.total} #{opts.fetch(:suffix, 'covered')}</span>)
           ]
           parts << missed_summary_html(missed, opts.fetch(:missed_class, "red"), opts.fetch(:toggle, false)) if missed.positive?
           parts << "\n  </div>"
diff --git a/lib/simplecov/formatter/html_formatter/views/source_file.erb b/lib/simplecov/formatter/html_formatter/views/source_file.erb
index 48f76c41..94a3f7f5 100644
--- a/lib/simplecov/formatter/html_formatter/views/source_file.erb
+++ b/lib/simplecov/formatter/html_formatter/views/source_file.erb
@@ -1,11 +1,7 @@
 <div class="source_table" id="<%= id source_file %>">
   <div class="header">
     <h2><%= shortened_filename source_file %></h2>
-    <%= coverage_summary({
-      covered_lines: source_file.covered_lines.count, total_lines: source_file.covered_lines.count + source_file.missed_lines.count,
-      covered_branches: branch_coverage? ? source_file.covered_branches.count : 0, total_branches: branch_coverage? ? source_file.total_branches.count : 0,
-      covered_methods: method_coverage? ? source_file.covered_methods.count : 0, total_methods: method_coverage? ? source_file.methods.count : 0
-    }, show_method_toggle: method_coverage? && source_file.missed_methods.any?) %>
+    <%= coverage_summary(source_file, show_method_toggle: method_coverage? && source_file.missed_methods.any?) %>
 <%- if method_coverage? && source_file.missed_methods.any? -%>
     <div class="t-missed-method-list" style="display: none">
       <ul>
diff --git a/lib/simplecov/formatter/json_formatter/result_hash_formatter.rb b/lib/simplecov/formatter/json_formatter/result_hash_formatter.rb
index 3e92c2d9..698fc23a 100644
--- a/lib/simplecov/formatter/json_formatter/result_hash_formatter.rb
+++ b/lib/simplecov/formatter/json_formatter/result_hash_formatter.rb
@@ -11,14 +11,20 @@ def initialize(result)
         end
 
         def format
+          format_total
           format_files
           format_groups
+          format_errors
 
           formatted_result
         end
 
       private
 
+        def format_total
+          formatted_result[:total] = format_coverage_statistics(@result.coverage_statistics)
+        end
+
         def format_files
           @result.files.each do |source_file|
             formatted_result[:coverage][source_file.filename] =
@@ -28,11 +34,51 @@ def format_files
 
         def format_groups
           @result.groups.each do |name, file_list|
-            formatted_result[:groups][name] = {
-              lines: {
-                covered_percent: file_list.covered_percent
-              }
-            }
+            formatted_result[:groups][name] = format_coverage_statistics(file_list.coverage_statistics)
+          end
+        end
+
+        def format_errors
+          format_minimum_coverage_errors
+          format_minimum_coverage_by_file_errors
+          format_minimum_coverage_by_group_errors
+          format_maximum_coverage_drop_errors
+        end
+
+        CRITERION_KEYS = {line: :lines, branch: :branches, method: :methods}.freeze
+        private_constant :CRITERION_KEYS
+
+        def format_minimum_coverage_errors
+          SimpleCov::CoverageViolations.minimum_overall(@result, SimpleCov.minimum_coverage).each do |violation|
+            key = CRITERION_KEYS.fetch(violation.fetch(:criterion))
+            bucket = formatted_result[:errors][:minimum_coverage] ||= {}
+            bucket[key] = {expected: violation.fetch(:expected), actual: violation.fetch(:actual)}
+          end
+        end
+
+        def format_minimum_coverage_by_file_errors
+          SimpleCov::CoverageViolations.minimum_by_file(@result, SimpleCov.minimum_coverage_by_file).each do |violation|
+            key = CRITERION_KEYS.fetch(violation.fetch(:criterion))
+            bucket = formatted_result[:errors][:minimum_coverage_by_file] ||= {}
+            criterion_errors = bucket[key] ||= {}
+            criterion_errors[violation.fetch(:filename)] = {expected: violation.fetch(:expected), actual: violation.fetch(:actual)}
+          end
+        end
+
+        def format_minimum_coverage_by_group_errors
+          SimpleCov::CoverageViolations.minimum_by_group(@result, SimpleCov.minimum_coverage_by_group).each do |violation|
+            key = CRITERION_KEYS.fetch(violation.fetch(:criterion))
+            bucket = formatted_result[:errors][:minimum_coverage_by_group] ||= {}
+            group_errors = bucket[violation.fetch(:group_name)] ||= {}
+            group_errors[key] = {expected: violation.fetch(:expected), actual: violation.fetch(:actual)}
+          end
+        end
+
+        def format_maximum_coverage_drop_errors
+          SimpleCov::CoverageViolations.maximum_drop(@result, SimpleCov.maximum_coverage_drop).each do |violation|
+            key = CRITERION_KEYS.fetch(violation.fetch(:criterion))
+            bucket = formatted_result[:errors][:maximum_coverage_drop] ||= {}
+            bucket[key] = {maximum: violation.fetch(:maximum), actual: violation.fetch(:actual)}
           end
         end
 
@@ -41,8 +87,10 @@ def formatted_result
             meta: {
               simplecov_version: SimpleCov::VERSION
             },
+            total: {},
             coverage: {},
-            groups: {}
+            groups: {},
+            errors: {}
           }
         end
 
@@ -50,6 +98,34 @@ def format_source_file(source_file)
           source_file_formatter = SourceFileFormatter.new(source_file)
           source_file_formatter.format
         end
+
+        def format_coverage_statistics(statistics)
+          result = {lines: format_line_statistic(statistics[:line])}
+          result[:branches] = format_single_statistic(statistics[:branch]) if SimpleCov.branch_coverage? && statistics[:branch]
+          result[:methods] = format_single_statistic(statistics[:method]) if SimpleCov.method_coverage? && statistics[:method]
+          result
+        end
+
+        def format_line_statistic(stat)
+          {
+            covered: stat.covered,
+            missed: stat.missed,
+            omitted: stat.omitted,
+            total: stat.total,
+            percent: stat.percent,
+            strength: stat.strength
+          }
+        end
+
+        def format_single_statistic(stat)
+          {
+            covered: stat.covered,
+            missed: stat.missed,
+            total: stat.total,
+            percent: stat.percent,
+            strength: stat.strength
+          }
+        end
       end
     end
   end
diff --git a/lib/simplecov/formatter/json_formatter/source_file_formatter.rb b/lib/simplecov/formatter/json_formatter/source_file_formatter.rb
index 67303e4b..246eca3e 100644
--- a/lib/simplecov/formatter/json_formatter/source_file_formatter.rb
+++ b/lib/simplecov/formatter/json_formatter/source_file_formatter.rb
@@ -10,24 +10,32 @@ def initialize(source_file)
         end
 
         def format
-          if SimpleCov.branch_coverage?
-            line_coverage.merge(branch_coverage)
-          else
-            line_coverage
-          end
+          result = line_coverage
+          result.merge!(branch_coverage) if SimpleCov.branch_coverage?
+          result.merge!(method_coverage) if SimpleCov.method_coverage?
+          result
         end
 
       private
 
         def line_coverage
           @line_coverage ||= {
-            lines: lines
+            lines: lines,
+            lines_covered_percent: @source_file.covered_percent
           }
         end
 
         def branch_coverage
           {
-            branches: branches
+            branches: branches,
+            branches_covered_percent: @source_file.branches_coverage_percent
+          }
+        end
+
+        def method_coverage
+          {
+            methods: format_methods,
+            methods_covered_percent: @source_file.methods_coverage_percent
           }
         end
 
@@ -43,6 +51,12 @@ def branches
           end
         end
 
+        def format_methods
+          @source_file.methods.collect do |method|
+            parse_method(method)
+          end
+        end
+
         def parse_line(line)
           return line.coverage unless line.skipped?
 
@@ -57,6 +71,15 @@ def parse_branch(branch)
             coverage: parse_line(branch)
           }
         end
+
+        def parse_method(method)
+          {
+            name: method.to_s,
+            start_line: method.start_line,
+            end_line: method.end_line,
+            coverage: parse_line(method)
+          }
+        end
       end
     end
   end
diff --git a/lib/simplecov/source_file.rb b/lib/simplecov/source_file.rb
index cd874c88..8a2818e4 100644
--- a/lib/simplecov/source_file.rb
+++ b/lib/simplecov/source_file.rb
@@ -402,7 +402,8 @@ def line_coverage_statistics
         line: CoverageStatistics.new(
           total_strength: lines_strength,
           covered:  covered_lines.size,
-          missed:   missed_lines.size
+          missed:   missed_lines.size,
+          omitted:  never_lines.size
         )
       }
     end
diff --git a/spec/coverage_statistics_spec.rb b/spec/coverage_statistics_spec.rb
index 234b4a84..3b6b73f3 100644
--- a/spec/coverage_statistics_spec.rb
+++ b/spec/coverage_statistics_spec.rb
@@ -5,17 +5,24 @@
 RSpec.describe SimpleCov::CoverageStatistics do
   describe ".new" do
     it "retains statistics and computes new ones" do
-      statistics = described_class.new(covered: 4, missed: 6, total_strength: 14)
+      statistics = described_class.new(covered: 4, missed: 6, omitted: 2, total_strength: 14)
 
       expect(statistics.covered).to eq 4
       expect(statistics.missed).to eq 6
+      expect(statistics.omitted).to eq 2
 
       expect(statistics.total).to eq 10
       expect(statistics.percent).to eq 40.0
       expect(statistics.strength).to eq 1.4
     end
 
-    it "can omit the total strength defaulting to 0.0" do
+    it "defaults omitted to 0" do
+      statistics = described_class.new(covered: 4, missed: 6)
+
+      expect(statistics.omitted).to eq 0
+    end
+
+    it "can omitted the total strength defaulting to 0.0" do
       statistics = described_class.new(covered: 4, missed: 6)
 
       expect(statistics.strength).to eq 0.0
@@ -44,14 +51,15 @@
     it "produces sensible total results" do
       statistics = described_class.from(
         [
-          described_class.new(covered: 3, missed: 4, total_strength: 54),
-          described_class.new(covered: 0, missed: 13, total_strength: 0),
-          described_class.new(covered: 37, missed: 0, total_strength: 682)
+          described_class.new(covered: 3, missed: 4, omitted: 2, total_strength: 54),
+          described_class.new(covered: 0, missed: 13, omitted: 5, total_strength: 0),
+          described_class.new(covered: 37, missed: 0, omitted: 8, total_strength: 682)
         ]
       )
 
       expect(statistics.covered).to eq 40
       expect(statistics.missed).to eq 17
+      expect(statistics.omitted).to eq 15
       expect(statistics.total).to eq 57
       expect(statistics.percent).to be_within(0.01).of(70.18)
       expect(statistics.strength).to be_within(0.01).of(12.91)
@@ -65,6 +73,7 @@ def empty_statistics
   def expect_all_empty(statistics)
     expect(statistics.covered).to eq 0
     expect(statistics.missed).to eq 0
+    expect(statistics.omitted).to eq 0
 
     expect(statistics.total).to eq 0
     # might be counter-intuitive but think of it as "we covered everything we could"
diff --git a/spec/exit_codes/minimum_coverage_by_file_check_spec.rb b/spec/exit_codes/minimum_coverage_by_file_check_spec.rb
index a2a21142..ffad42c4 100644
--- a/spec/exit_codes/minimum_coverage_by_file_check_spec.rb
+++ b/spec/exit_codes/minimum_coverage_by_file_check_spec.rb
@@ -11,7 +11,7 @@
   let(:coverage_statistics) { {line: SimpleCov::CoverageStatistics.new(covered: 8, missed: 2)} }
   let(:files) do
     [
-      instance_double(SimpleCov::SourceFile, coverage_statistics: coverage_statistics, project_filename: "/lib/foo.rb")
+      instance_double(SimpleCov::SourceFile, coverage_statistics: coverage_statistics, filename: "/abs/lib/foo.rb", project_filename: "/lib/foo.rb")
     ]
   end
 
diff --git a/spec/fixtures/json/sample.json b/spec/fixtures/json/sample.json
index 55a4e7a0..35e6929d 100644
--- a/spec/fixtures/json/sample.json
+++ b/spec/fixtures/json/sample.json
@@ -2,6 +2,16 @@
   "meta": {
     "simplecov_version": "0.22.0"
   },
+  "total": {
+    "lines": {
+      "covered": 9,
+      "missed": 1,
+      "omitted": 10,
+      "total": 10,
+      "percent": 90.0,
+      "strength": 1.0
+    }
+  },
   "coverage": {
     "/STUB_WORKING_DIRECTORY/spec/fixtures/json/sample.rb": {
       "lines": [
@@ -30,8 +40,10 @@
         "ignored",
         "ignored",
         null
-      ]
+      ],
+      "lines_covered_percent": 90.0
     }
   },
-  "groups": {}
+  "groups": {},
+  "errors": {}
 }
diff --git a/spec/fixtures/json/sample_groups.json b/spec/fixtures/json/sample_groups.json
index 1c47f59c..bf632dcc 100644
--- a/spec/fixtures/json/sample_groups.json
+++ b/spec/fixtures/json/sample_groups.json
@@ -2,6 +2,16 @@
   "meta": {
     "simplecov_version": "0.22.0"
   },
+  "total": {
+    "lines": {
+      "covered": 9,
+      "missed": 1,
+      "omitted": 10,
+      "total": 10,
+      "percent": 90.0,
+      "strength": 1.0
+    }
+  },
   "coverage": {
     "/STUB_WORKING_DIRECTORY/spec/fixtures/json/sample.rb": {
       "lines": [
@@ -30,14 +40,21 @@
         "ignored",
         "ignored",
         null
-      ]
+      ],
+      "lines_covered_percent": 90.0
     }
   },
   "groups": {
     "My Group": {
       "lines": {
-        "covered_percent": 80.0
+        "covered": 8,
+        "missed": 2,
+        "omitted": 0,
+        "total": 10,
+        "percent": 80.0,
+        "strength": 0.0
       }
     }
-  }
+  },
+  "errors": {}
 }
diff --git a/spec/fixtures/json/sample_with_branch.json b/spec/fixtures/json/sample_with_branch.json
index ac451e80..903ebb0d 100644
--- a/spec/fixtures/json/sample_with_branch.json
+++ b/spec/fixtures/json/sample_with_branch.json
@@ -2,6 +2,23 @@
   "meta": {
     "simplecov_version": "0.22.0"
   },
+  "total": {
+    "lines": {
+      "covered": 9,
+      "missed": 1,
+      "omitted": 10,
+      "total": 10,
+      "percent": 90.0,
+      "strength": 1.0
+    },
+    "branches": {
+      "covered": 1,
+      "missed": 1,
+      "total": 2,
+      "percent": 50.0,
+      "strength": 0.0
+    }
+  },
   "coverage": {
     "/STUB_WORKING_DIRECTORY/spec/fixtures/json/sample.rb": {
       "lines": [
@@ -31,6 +48,7 @@
         "ignored",
         null
       ],
+      "lines_covered_percent": 90.0,
       "branches": [
         {
           "type": "then",
@@ -44,8 +62,10 @@
           "end_line": 16,
           "coverage": 1
         }
-      ]
+      ],
+      "branches_covered_percent": 50.0
     }
   },
-  "groups": {}
+  "groups": {},
+  "errors": {}
 }
diff --git a/spec/fixtures/json/sample_with_method.json b/spec/fixtures/json/sample_with_method.json
new file mode 100644
index 00000000..743d4055
--- /dev/null
+++ b/spec/fixtures/json/sample_with_method.json
@@ -0,0 +1,83 @@
+{
+  "meta": {
+    "simplecov_version": "0.22.0"
+  },
+  "total": {
+    "lines": {
+      "covered": 9,
+      "missed": 1,
+      "omitted": 10,
+      "total": 10,
+      "percent": 90.0,
+      "strength": 1.0
+    },
+    "methods": {
+      "covered": 3,
+      "missed": 0,
+      "total": 3,
+      "percent": 100.0,
+      "strength": 0.0
+    }
+  },
+  "coverage": {
+    "/STUB_WORKING_DIRECTORY/spec/fixtures/json/sample.rb": {
+      "lines": [
+        null,
+        1,
+        1,
+        1,
+        1,
+        null,
+        null,
+        1,
+        1,
+        null,
+        null,
+        1,
+        1,
+        0,
+        null,
+        1,
+        null,
+        null,
+        null,
+        "ignored",
+        "ignored",
+        "ignored",
+        "ignored",
+        "ignored",
+        null
+      ],
+      "lines_covered_percent": 90.0,
+      "methods": [
+        {
+          "name": "Foo#initialize",
+          "start_line": 3,
+          "end_line": 6,
+          "coverage": 1
+        },
+        {
+          "name": "Foo#bar",
+          "start_line": 8,
+          "end_line": 10,
+          "coverage": 1
+        },
+        {
+          "name": "Foo#foo",
+          "start_line": 12,
+          "end_line": 18,
+          "coverage": 1
+        },
+        {
+          "name": "Foo#skipped",
+          "start_line": 21,
+          "end_line": 23,
+          "coverage": "ignored"
+        }
+      ],
+      "methods_covered_percent": 100.0
+    }
+  },
+  "groups": {},
+  "errors": {}
+}
diff --git a/spec/json_formatter_spec.rb b/spec/json_formatter_spec.rb
index 533ca2b1..cc31ab7c 100644
--- a/spec/json_formatter_spec.rb
+++ b/spec/json_formatter_spec.rb
@@ -16,10 +16,24 @@
 
   describe "format" do
     context "with line coverage" do
-      it "works" do
+      it "includes line coverage and covered_percent per file" do
         subject.format(result)
         expect(json_output).to eq(json_result("sample"))
       end
+
+      it "preserves raw percentage and strength precision" do
+        unrounded_result = SimpleCov::Result.new({source_fixture("json/sample.rb") => {"lines" => [1, 0, 1]}})
+
+        subject.format(unrounded_result)
+
+        expect(json_output.fetch("total").fetch("lines")).to include(
+          "percent" => 66.66666666666667,
+          "strength" => 0.6666666666666666
+        )
+        expect(json_output.fetch("coverage").fetch(source_fixture("json/sample.rb"))).to include(
+          "lines_covered_percent" => 66.66666666666667
+        )
+      end
     end
 
     context "with branch coverage" do
@@ -51,13 +65,208 @@
         enable_branch_coverage
       end
 
-      it "works" do
+      it "includes branch data and branches_covered_percent per file" do
         subject.format(result)
         expect(json_output).to eq(json_result("sample_with_branch"))
       end
     end
 
+    context "with method coverage" do
+      let(:original_lines) do
+        [nil, 1, 1, 1, 1, nil, nil, 1, 1,
+         nil, nil, 1, 1, 0, nil, 1, nil,
+         nil, nil, nil, 1, 0, nil, nil, nil]
+      end
+
+      let(:original_methods) do
+        {
+          ["Foo", :initialize, 3, 2, 6, 5] => 1,
+          ["Foo", :bar, 8, 2, 10, 5] => 1,
+          ["Foo", :foo, 12, 2, 18, 5] => 1,
+          ["Foo", :skipped, 21, 2, 23, 5] => 0
+        }
+      end
+
+      let(:result) do
+        SimpleCov::Result.new({
+                                source_fixture("json/sample.rb") => {
+                                  "lines" => original_lines,
+                                  "methods" => original_methods
+                                }
+                              })
+      end
+
+      before do
+        enable_method_coverage
+      end
+
+      # total.methods.total is 3, not 4, because Foo#skipped is inside a :nocov: block
+      it "includes methods array and methods_covered_percent per file" do
+        subject.format(result)
+        expect(json_output).to eq(json_result("sample_with_method"))
+      end
+    end
+
+    context "with minimum_coverage below threshold" do
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 95)
+      end
+
+      it "reports the violation in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "minimum_coverage" => {"lines" => {"expected" => 95, "actual" => 90.0}}
+        )
+      end
+    end
+
+    context "with minimum_coverage above threshold" do
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 80)
+      end
+
+      it "returns empty errors" do
+        subject.format(result)
+        expect(json_output.fetch("errors")).to eq({})
+      end
+    end
+
+    context "with minimum_coverage_by_file for lines" do
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage_by_file).and_return(line: 95)
+      end
+
+      it "reports files below the threshold in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "minimum_coverage_by_file" => {
+            "lines" => {source_fixture("json/sample.rb") => {"expected" => 95, "actual" => 90.0}}
+          }
+        )
+      end
+    end
+
+    context "with minimum_coverage_by_file for branches" do
+      let(:result) do
+        SimpleCov::Result.new({
+                                source_fixture("json/sample.rb") => {
+                                  "lines" => [nil, 1, 1, 1, 1, nil, nil, 1, 1, nil, nil,
+                                              1, 1, 0, nil, 1, nil, nil, nil, nil, 1, 0, nil, nil, nil],
+                                  "branches" => {
+                                    [:if, 0, 13, 4, 17, 7] => {
+                                      [:then, 1, 14, 6, 14, 10] => 0,
+                                      [:else, 2, 16, 6, 16, 10] => 1
+                                    }
+                                  }
+                                }
+                              })
+      end
+
+      before do
+        enable_branch_coverage
+        allow(SimpleCov).to receive(:minimum_coverage_by_file).and_return(branch: 75)
+      end
+
+      it "reports files below the threshold in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "minimum_coverage_by_file" => {
+            "branches" => {source_fixture("json/sample.rb") => {"expected" => 75, "actual" => 50.0}}
+          }
+        )
+      end
+    end
+
+    context "with minimum_coverage_by_file when all files pass" do
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage_by_file).and_return(line: 80)
+      end
+
+      it "returns empty errors" do
+        subject.format(result)
+        expect(json_output.fetch("errors")).to eq({})
+      end
+    end
+
+    context "with minimum_coverage_by_group below threshold" do
+      let(:line_stats) { SimpleCov::CoverageStatistics.new(covered: 7, missed: 3) }
+
+      let(:result) do
+        res = SimpleCov::Result.new({
+                                      source_fixture("json/sample.rb") => {"lines" => [
+                                        nil, 1, 1, 1, 1, nil, nil, 1, 1, nil, nil,
+                                        1, 1, 0, nil, 1, nil, nil, nil, nil, 1, 0, nil, nil, nil
+                                      ]}
+                                    })
+
+        allow(res).to receive_messages(
+          groups: {"Models" => double("File List", coverage_statistics: {line: line_stats})}
+        )
+        res
+      end
+
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage_by_group).and_return("Models" => {line: 80})
+      end
+
+      it "reports the group violation in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "minimum_coverage_by_group" => {
+            "Models" => {"lines" => {"expected" => 80, "actual" => 70.0}}
+          }
+        )
+      end
+    end
+
+    context "with maximum_coverage_drop exceeded" do
+      before do
+        allow(SimpleCov).to receive(:maximum_coverage_drop).and_return(line: 2)
+        allow(SimpleCov::LastRun).to receive(:read).and_return({result: {line: 95.0}})
+      end
+
+      it "reports the drop in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "maximum_coverage_drop" => {
+            "lines" => {"maximum" => 2, "actual" => 5.0}
+          }
+        )
+      end
+    end
+
+    context "with maximum_coverage_drop not exceeded" do
+      before do
+        allow(SimpleCov).to receive(:maximum_coverage_drop).and_return(line: 2)
+        allow(SimpleCov::LastRun).to receive(:read).and_return({result: {line: 91.0}})
+      end
+
+      it "returns empty errors" do
+        subject.format(result)
+        expect(json_output.fetch("errors")).to eq({})
+      end
+    end
+
+    context "with maximum_coverage_drop and no last run" do
+      before do
+        allow(SimpleCov).to receive(:maximum_coverage_drop).and_return(line: 2)
+        allow(SimpleCov::LastRun).to receive(:read).and_return(nil)
+      end
+
+      it "returns empty errors" do
+        subject.format(result)
+        expect(json_output.fetch("errors")).to eq({})
+      end
+    end
+
     context "with groups" do
+      let(:line_stats) { SimpleCov::CoverageStatistics.new(covered: 8, missed: 2) }
+
       let(:result) do
         res = SimpleCov::Result.new({
                                       source_fixture("json/sample.rb") => {"lines" => [
@@ -68,7 +277,9 @@
 
         # right now SimpleCov works mostly on global state, hence setting the groups that way
         # would be global state --> Mocking is better here
-        allow(res).to receive_messages(groups: {"My Group" => double("File List", covered_percent: 80.0)})
+        allow(res).to receive_messages(
+          groups: {"My Group" => double("File List", coverage_statistics: {line: line_stats})}
+        )
         res
       end
 
@@ -83,6 +294,10 @@ def enable_branch_coverage
     allow(SimpleCov).to receive(:branch_coverage?).and_return(true)
   end
 
+  def enable_method_coverage
+    allow(SimpleCov).to receive(:method_coverage?).and_return(true)
+  end
+
   def json_output
     JSON.parse(File.read("tmp/coverage/coverage.json"))
   end
diff --git a/test/html_formatter/test_view_helpers.rb b/test/html_formatter/test_view_helpers.rb
index 89c929ef..48e83072 100644
--- a/test/html_formatter/test_view_helpers.rb
+++ b/test/html_formatter/test_view_helpers.rb
@@ -136,46 +136,6 @@ def test_fmt_preserves_string_input
     assert_equal "12,345", formatter.send(:fmt, "12345")
   end
 
-  cover "SimpleCov::Formatter::HTMLFormatter::ViewHelpers#build_stats" if respond_to?(:cover)
-
-  def test_build_stats_basic
-    stats = formatter.send(:build_stats, 80, 100)
-
-    assert_equal 80, stats[:covered]
-    assert_equal 100, stats[:total]
-    assert_equal 20, stats[:missed]
-    assert_in_delta 80.0, stats[:pct], 0.01
-  end
-
-  def test_build_stats_zero_total
-    stats = formatter.send(:build_stats, 0, 0)
-
-    assert_equal 0, stats[:covered]
-    assert_equal 0, stats[:total]
-    assert_equal 0, stats[:missed]
-    assert_in_delta 100.0, stats[:pct], 0.01
-  end
-
-  def test_build_stats_full_coverage
-    stats = formatter.send(:build_stats, 50, 50)
-
-    assert_equal 0, stats[:missed]
-    assert_in_delta 100.0, stats[:pct], 0.01
-  end
-
-  def test_build_stats_no_coverage
-    stats = formatter.send(:build_stats, 0, 100)
-
-    assert_equal 100, stats[:missed]
-    assert_in_delta 0.0, stats[:pct], 0.01
-  end
-
-  def test_build_stats_returns_hash_with_four_keys
-    stats = formatter.send(:build_stats, 3, 7)
-
-    assert_equal %i[covered missed pct total], stats.keys.sort
-  end
-
   cover "SimpleCov::Formatter::HTMLFormatter::ViewHelpers#line_status?" if respond_to?(:cover)
 
   def test_line_status_missed_branch
@@ -256,7 +216,7 @@ def test_coverage_summary_shows_branch_disabled_when_no_branch_coverage
 
   def test_coverage_summary_defaults_branch_and_method_to_zero
     f = new_formatter_with(branch: true, method: true)
-    result = f.send(:coverage_summary, {covered_lines: 80, total_lines: 100})
+    result = f.send(:coverage_summary, stub_source_file_with_stats(covered_lines: 80, total_lines: 100))
 
     assert_includes result, "Line coverage:"
     assert_includes result, "Branch coverage:"
@@ -324,86 +284,36 @@ def test_coverage_summary_passes_stats_to_template
     assert_includes result, "50"
   end
 
-  def test_coverage_summary_uses_build_stats_for_line
+  def test_coverage_summary_renders_line_counts
     f = new_formatter_with(branch: false, method: false)
-    result = f.send(:coverage_summary, {covered_lines: 75, total_lines: 100})
+    result = f.send(:coverage_summary, stub_source_file_with_stats(covered_lines: 75, total_lines: 100))
 
     assert_includes result, "75.00%"
     assert_includes result, "75"
     assert_includes result, "100"
   end
 
-  def test_coverage_summary_uses_build_stats_for_branches
+  def test_coverage_summary_renders_branch_counts
     f = new_formatter_with(branch: true)
-    result = f.send(:coverage_summary, {
-                      covered_lines: 80, total_lines: 100,
-                      covered_branches: 6, total_branches: 8
-                    })
+    result = f.send(:coverage_summary, stub_source_file_with_stats(covered_lines: 80, total_lines: 100, covered_branches: 6, total_branches: 8))
 
     assert_includes result, "75.00%"
     assert_includes result, "6"
     assert_includes result, "8"
   end
 
-  def test_coverage_summary_uses_build_stats_for_methods
+  def test_coverage_summary_renders_method_counts
     f = new_formatter_with(method: true)
-    result = f.send(:coverage_summary, {
-                      covered_lines: 80, total_lines: 100,
-                      covered_methods: 3, total_methods: 4
-                    })
+    result = f.send(:coverage_summary, stub_source_file_with_stats(covered_lines: 80, total_lines: 100, covered_methods: 3, total_methods: 4))
 
     assert_includes result, "75.00%"
     assert_includes result, "3"
     assert_includes result, "4"
   end
 
-  def test_coverage_summary_fetch_defaults_branch_covered_to_zero
-    f = new_formatter_with(branch: true, method: false)
-    result = f.send(:coverage_summary, {
-                      covered_lines: 80, total_lines: 100,
-                      total_branches: 10
-                    })
-
-    assert_includes result, "0/10 covered"
-  end
-
-  def test_coverage_summary_fetch_defaults_branch_total_to_zero
-    f = new_formatter_with(branch: true, method: false)
-    result = f.send(:coverage_summary, {
-                      covered_lines: 80, total_lines: 100,
-                      covered_branches: 0
-                    })
-
-    assert_includes result, "0/0 covered"
-  end
-
-  def test_coverage_summary_fetch_defaults_method_covered_to_zero
-    f = new_formatter_with(branch: false, method: true)
-    result = f.send(:coverage_summary, {
-                      covered_lines: 80, total_lines: 100,
-                      total_methods: 10
-                    })
-
-    assert_includes result, "0/10 covered"
-  end
-
-  def test_coverage_summary_fetch_defaults_method_total_to_zero
-    f = new_formatter_with(branch: false, method: true)
-    result = f.send(:coverage_summary, {
-                      covered_lines: 80, total_lines: 100,
-                      covered_methods: 0
-                    })
-
-    assert_includes result, "0/0 covered"
-  end
-
   def test_coverage_summary_branch_missed_shown_when_nonzero
     f = new_formatter_with(branch: true)
-    result = f.send(:coverage_summary, {
-                      covered_lines: 80, total_lines: 100,
-                      covered_branches: 5, total_branches: 10,
-                      covered_methods: 0, total_methods: 0
-                    })
+    result = f.send(:coverage_summary, stub_source_file_with_stats(covered_lines: 80, total_lines: 100, covered_branches: 5, total_branches: 10))
 
     assert_includes result, "missed-branch-text"
     assert_includes result, "5"
@@ -411,11 +321,7 @@ def test_coverage_summary_branch_missed_shown_when_nonzero
 
   def test_coverage_summary_method_missed_shown_when_nonzero_no_toggle
     f = new_formatter_with(method: true)
-    result = f.send(:coverage_summary, {
-                      covered_lines: 80, total_lines: 100,
-                      covered_branches: 0, total_branches: 0,
-                      covered_methods: 3, total_methods: 10
-                    }, show_method_toggle: false)
+    result = f.send(:coverage_summary, stub_source_file_with_stats(covered_lines: 80, total_lines: 100, covered_methods: 3, total_methods: 10), show_method_toggle: false)
 
     assert_includes result, "missed-method-text-color"
     assert_includes result, "7"
@@ -920,7 +826,7 @@ def test_coverage_header_cells_th_label_span
 
   def test_coverage_type_summary_enabled_returns_div_with_type_class
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, 'class="t-line-summary"'
@@ -936,7 +842,7 @@ def test_coverage_type_summary_disabled_delegates_to_disabled_summary
 
   def test_coverage_type_summary_contains_formatted_percent
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 85.999, covered: 85, total: 100, missed: 15}}
+    summary = line_summary(pct: 85.999, covered: 85, total: 100, missed: 15)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, "85.99%"
@@ -944,7 +850,7 @@ def test_coverage_type_summary_contains_formatted_percent
 
   def test_coverage_type_summary_percent_is_floored
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 85.999, covered: 85, total: 100, missed: 15}}
+    summary = line_summary(pct: 85.999, covered: 85, total: 100, missed: 15)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, "85.99%"
@@ -953,7 +859,7 @@ def test_coverage_type_summary_percent_is_floored
 
   def test_coverage_type_summary_contains_css_class_from_pct
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 95.0, covered: 95, total: 100, missed: 5}}
+    summary = line_summary(pct: 95.0, covered: 95, total: 100, missed: 5)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, '"green"'
@@ -961,7 +867,7 @@ def test_coverage_type_summary_contains_css_class_from_pct
 
   def test_coverage_type_summary_css_class_red_for_low
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 50.0, covered: 50, total: 100, missed: 50}}
+    summary = line_summary(pct: 50.0, covered: 50, total: 100, missed: 50)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, '"red"'
@@ -969,7 +875,7 @@ def test_coverage_type_summary_css_class_red_for_low
 
   def test_coverage_type_summary_contains_covered_and_total
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, "80/100"
@@ -977,7 +883,7 @@ def test_coverage_type_summary_contains_covered_and_total
 
   def test_coverage_type_summary_default_suffix_is_covered
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, "covered"
@@ -985,7 +891,7 @@ def test_coverage_type_summary_default_suffix_is_covered
 
   def test_coverage_type_summary_custom_suffix
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true, suffix: "relevant lines covered")
 
     assert_includes result, "relevant lines covered"
@@ -993,7 +899,7 @@ def test_coverage_type_summary_custom_suffix
 
   def test_coverage_type_summary_suffix_key_is_used
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 100.0, covered: 10, total: 10, missed: 0}}
+    summary = line_summary(pct: 100.0, covered: 10, total: 10, missed: 0)
     result_default = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
     result_custom = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true, suffix: "unique_suffix_text")
 
@@ -1004,7 +910,7 @@ def test_coverage_type_summary_suffix_key_is_used
 
   def test_coverage_type_summary_ends_with_closing_div
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 100.0, covered: 100, total: 100, missed: 0}}
+    summary = line_summary(pct: 100.0, covered: 100, total: 100, missed: 0)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert result.end_with?("</div>"), "Expected closing </div>, got: ...#{result[-30..]}"
@@ -1012,7 +918,7 @@ def test_coverage_type_summary_ends_with_closing_div
 
   def test_coverage_type_summary_contains_label
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 100.0, covered: 100, total: 100, missed: 0}}
+    summary = line_summary(pct: 100.0, covered: 100, total: 100, missed: 0)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, "Line coverage:"
@@ -1020,7 +926,7 @@ def test_coverage_type_summary_contains_label
 
   def test_coverage_type_summary_with_missed_includes_missed_count
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, "<b>20</b> missed"
@@ -1028,7 +934,7 @@ def test_coverage_type_summary_with_missed_includes_missed_count
 
   def test_coverage_type_summary_no_missed_when_zero
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 100.0, covered: 100, total: 100, missed: 0}}
+    summary = line_summary(pct: 100.0, covered: 100, total: 100, missed: 0)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     refute_includes result, "missed"
@@ -1036,7 +942,7 @@ def test_coverage_type_summary_no_missed_when_zero
 
   def test_coverage_type_summary_missed_uses_default_red_class
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, 'class="red"'
@@ -1044,7 +950,7 @@ def test_coverage_type_summary_missed_uses_default_red_class
 
   def test_coverage_type_summary_missed_uses_custom_missed_class
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true, missed_class: "missed-branch-text")
 
     assert_includes result, 'class="missed-branch-text"'
@@ -1053,7 +959,7 @@ def test_coverage_type_summary_missed_uses_custom_missed_class
 
   def test_coverage_type_summary_toggle_false_uses_span
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true, toggle: false)
 
     assert_includes result, "<span"
@@ -1062,7 +968,7 @@ def test_coverage_type_summary_toggle_false_uses_span
 
   def test_coverage_type_summary_toggle_true_uses_anchor
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true, toggle: true)
 
     assert_includes result, "t-missed-method-toggle"
@@ -1078,7 +984,7 @@ def test_coverage_type_summary_type_in_disabled_output
 
   def test_coverage_type_summary_missed_includes_comma_separator
     f = new_formatter_with(branch: false, method: false)
-    summary = {line: {pct: 80.0, covered: 80, total: 100, missed: 20}}
+    summary = line_summary(pct: 80.0, covered: 80, total: 100, missed: 20)
     result = f.send(:coverage_type_summary, "line", "Line coverage", summary, enabled: true)
 
     assert_includes result, %(<span class="coverage-cell__fraction">,</span>)
@@ -1086,7 +992,7 @@ def test_coverage_type_summary_missed_includes_comma_separator
 
   def test_coverage_type_summary_type_appears_in_enabled_div_class
     f = new_formatter_with(branch: false, method: false)
-    summary = {branch: {pct: 75.0, covered: 15, total: 20, missed: 5}}
+    summary = {branch: SimpleCov::CoverageStatistics.new(covered: 15, missed: 5, percent: 75.0)}
     result = f.send(:coverage_type_summary, "branch", "Branch coverage", summary, enabled: true)
 
     assert_includes result, "t-branch-summary"
@@ -1229,31 +1135,34 @@ def new_formatter_with(branch: nil, method: nil)
 
   def render_summary(covered_lines:, total_lines:)
     f = SimpleCov::Formatter::HTMLFormatter.new
-    f.send(:coverage_summary, zero_stats(covered_lines: covered_lines, total_lines: total_lines))
+    f.send(:coverage_summary, stub_source_file_with_stats(covered_lines: covered_lines, total_lines: total_lines))
   end
 
   def full_stats
-    {
-      covered_lines: 80, total_lines: 100,
-      covered_branches: 10, total_branches: 20,
-      covered_methods: 5, total_methods: 10
-    }
+    stub_source_file_with_stats(covered_lines: 80, total_lines: 100, covered_branches: 10, total_branches: 20, covered_methods: 5, total_methods: 10)
   end
 
   def zero_stats(covered_lines: 0, total_lines: 0)
-    {
-      covered_lines: covered_lines, total_lines: total_lines,
-      covered_branches: 0, total_branches: 0,
-      covered_methods: 0, total_methods: 0
-    }
+    stub_source_file_with_stats(covered_lines: covered_lines, total_lines: total_lines)
   end
 
   def method_stats
-    {
-      covered_lines: 80, total_lines: 100,
-      covered_branches: 0, total_branches: 0,
-      covered_methods: 5, total_methods: 10
+    stub_source_file_with_stats(covered_lines: 80, total_lines: 100, covered_methods: 5, total_methods: 10)
+  end
+
+  def stub_source_file_with_stats(covered_lines: 0, total_lines: 0, covered_branches: 0, total_branches: 0, covered_methods: 0, total_methods: 0) # rubocop:disable Metrics/ParameterLists
+    stats = {
+      line: SimpleCov::CoverageStatistics.new(covered: covered_lines, missed: total_lines - covered_lines),
+      branch: SimpleCov::CoverageStatistics.new(covered: covered_branches, missed: total_branches - covered_branches),
+      method: SimpleCov::CoverageStatistics.new(covered: covered_methods, missed: total_methods - covered_methods)
     }
+    obj = Object.new
+    obj.define_singleton_method(:coverage_statistics) { stats }
+    obj
+  end
+
+  def line_summary(pct:, covered:, missed:, **)
+    {line: SimpleCov::CoverageStatistics.new(covered: covered, missed: missed, percent: pct)}
   end
 
   def make_method_stub(start_line, end_line)