branchproof 0.2.0

data/lib/branchproof/runtime.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Branchproof
+  # Process-local execution recorder. It deliberately never coerces or stores
+  # application values: Ruby's conditional expression is used for truthiness.
+  # Captures condition evaluations while preserving application values.
+  module Runtime
+    class << self
+      def boot(evidence:)
+        return nil if defined?(@booted) && @booted && @evidence.equal?(evidence) && Process.pid == @process_id
+
+        @evidence = evidence
+        @run_id = evidence.respond_to?(:run_id) ? evidence.run_id.to_s : SecureRandom.hex(16)
+        @process_id = Process.pid
+        @frames = {}
+        @contexts = {}
+        @diagnostics = []
+        @storage_disabled = false
+        @booted = true
+        nil
+      end
+
+      def enter(decision_id)
+        state[:frames] << { decision_id: String(decision_id), context: state[:context]&.dup,
+                            observations: [], outcome: nil, finished: false,
+                            execution_id: SecureRandom.hex(12) }
+        nil
+      end
+
+      def condition(decision_id, index, value)
+        frame = current_frame(decision_id)
+        if frame
+          truth = value ? true : false
+          frame[:observations] << [Integer(index), truth]
+        end
+        value
+      end
+
+      def finish(decision_id, value)
+        frame = current_frame(decision_id)
+        if frame
+          frame[:outcome] = (value ? true : false)
+          frame[:finished] = true
+        end
+        value
+      end
+
+      def leave(decision_id)
+        frames = state[:frames]
+        frame = frames.pop
+        unless frame && frame[:decision_id] == String(decision_id)
+          latch("runtime_frame_mismatch", "decision frame stack is not balanced")
+          cleanup_state
+          return nil
+        end
+        return nil unless @evidence && !@storage_disabled
+
+        execution = {
+          run_id: @run_id,
+          execution_id: frame[:execution_id],
+          decision_id: frame[:decision_id],
+          test_id: frame[:context]&.fetch(:test_id, nil),
+          phase: frame[:context]&.fetch(:phase, "unattributed") || "unattributed",
+          owner: owner_tuple,
+          observations: frame[:observations].map(&:dup),
+          outcome: frame[:finished] ? frame[:outcome] : nil,
+          status: frame[:finished] ? "completed" : "aborted"
+        }
+        safely_record(execution)
+        cleanup_state
+        nil
+      end
+
+      def context(test_id:, phase:)
+        state[:context] = if test_id.nil? || phase.to_s == "unattributed"
+                            nil
+                          else
+                            { test_id: test_id, phase: phase }
+                          end
+        nil
+      end
+
+      def register_test(test:)
+        return nil unless @evidence.respond_to?(:register_test)
+
+        result = @evidence.register_test(test: test)
+        unless result.is_a?(Hash) && result[:status].to_s == "registered"
+          reported = result.is_a?(Hash) ? result[:status] : result.class
+          latch("recorder_status", "test registration returned #{reported}")
+        end
+        result
+      rescue StandardError => e
+        latch("recorder_failure", "test registration failed: #{e.class}: #{e.message}")
+        nil
+      end
+
+      def snapshot
+        if @evidence.respond_to?(:snapshot)
+          result = @evidence.snapshot
+          return result if @diagnostics.nil? || @diagnostics.empty?
+
+          copy = Marshal.load(Marshal.dump(result))
+          copy[:diagnostics] = Array(copy[:diagnostics]) + @diagnostics
+          copy[:completeness] = (copy[:completeness] || {}).merge(observation: false)
+          return copy
+        end
+        { observations: [], diagnostics: @diagnostics.dup,
+          completeness: { observation: true, attribution: true, analysis: true } }
+      end
+
+      def diagnostics
+        @diagnostics&.map(&:dup) || []
+      end
+
+      private
+
+      def state
+        @frames ||= {}
+        if @process_id && Process.pid != @process_id
+          @process_id = Process.pid
+          @run_id = SecureRandom.hex(16)
+          @frames = {}
+          @diagnostics = [{ code: "forked_process", severity: "error",
+                            message: "runtime process identity changed; evidence storage disabled",
+                            source_id: nil, decision_id: nil, execution_id: nil, test_id: nil, details: {} }]
+          @storage_disabled = true
+        end
+        key = [Process.pid, Thread.current, Fiber.current]
+        @frames[key] ||= { frames: [], context: nil }
+      end
+
+      def cleanup_state
+        key = [Process.pid, Thread.current, Fiber.current]
+        current = @frames[key]
+        @frames.delete(key) if current && current[:frames].empty? && current[:context].nil?
+      end
+
+      def current_frame(decision_id)
+        frame = state[:frames].last
+        return frame if frame && frame[:decision_id] == String(decision_id)
+
+        latch("runtime_frame_mismatch", "no active frame for #{decision_id}") if frame
+        nil
+      end
+
+      def owner_tuple
+        { process_id: Process.pid, thread_id: Thread.current.object_id, fiber_id: Fiber.current.object_id }
+      end
+
+      def safely_record(execution)
+        result = @evidence.record(execution: execution)
+        unless result.is_a?(Hash) && result[:status].to_s == "recorded"
+          reported = result.is_a?(Hash) ? result[:status] : result.class
+          latch("recorder_status", "evidence recorder returned #{reported}")
+        end
+        result
+      rescue StandardError => e
+        latch("recorder_failure", "evidence recorder failed: #{e.class}: #{e.message}")
+      end
+
+      def latch(code, message)
+        @storage_disabled = true
+        @diagnostics ||= []
+        @diagnostics << { code: code, severity: "error", message: message,
+                          source_id: nil, decision_id: nil, execution_id: nil, test_id: nil, details: {} }
+      end
+    end
+  end
+end

data/lib/branchproof/source.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "digest"
+require "pathname"
+require "prism"
+
+module Branchproof
+  # Inventories supported condition and decision occurrences from Ruby files.
+  class Source
+    attr_reader :root, :limits
+
+    def initialize(root:, limits:)
+      raise ArgumentError, "root must be an absolute path" unless root.is_a?(String) && Pathname.new(root).absolute?
+      raise ArgumentError, "limits must be a Limits record" unless limits.is_a?(Hash)
+
+      @root = File.realpath(root)
+      @limits = Limits.normalize(limits)
+    end
+
+    def inventory(paths:)
+      raise ArgumentError, "paths must be an Array" unless paths.is_a?(Array)
+      raise ArgumentError, "paths must contain only Strings" unless paths.all?(String)
+
+      units = paths.flat_map { |path| expand(path) }.uniq.sort.filter_map { |path| read_unit(path) }
+      decisions = units.flat_map { |unit| unit[:decisions] }
+                       .sort_by { |decision| [decision[:source_id], decision[:byte_start]] }
+      diagnostics = units.flat_map { |unit| unit[:diagnostics] }
+      diagnostics += decisions.flat_map do |decision|
+        decision[:support_reasons].map do |reason|
+          Records.diagnostic(code: reason, message: "Unsupported source syntax: #{reason}",
+                             source_id: decision[:source_id], decision_id: decision[:id])
+        end
+      end
+      supported = decisions.count { |decision| decision[:support_status] == "SUPPORTED" }
+      opaque = decisions.sum { |decision| decision[:opaque_ranges].length }
+      limited = diagnostics.count { |diagnostic| diagnostic[:code] == "limit_reached" }
+      scope = Records.build(discovered: decisions.length, supported: supported,
+                            unsupported: decisions.length - supported, opaque: opaque,
+                            unexecuted: 0, completed: 0, aborted: 0, unattributed: 0, limited: limited)
+      Records.build(root: @root, source_units: units.map { |unit| unit.except(:diagnostics) },
+                    decisions: decisions, diagnostics: diagnostics, scope: scope)
+    end
+
+    private
+
+    def expand(path)
+      pattern = File.expand_path(path.to_s, @root)
+      matches = Dir[pattern].select { |candidate| File.file?(candidate) }
+      matches = [pattern] if matches.empty? && File.file?(pattern)
+      matches.filter_map do |candidate|
+        File.realpath(candidate)
+      rescue SystemCallError
+        nil
+      end
+    end
+
+    def read_unit(path)
+      bytes = File.binread(path)
+      parsed = Prism.parse(bytes)
+      encoding = source_encoding(bytes, parsed)
+      source_id = Records.source_id(relative_path: relative(path), digest: Digest::SHA256.hexdigest(bytes),
+                                    encoding: encoding)
+      diagnostics = parsed.errors.map do |error|
+        Records.diagnostic(code: "parse_error", severity: "error", message: error.message, source_id: source_id,
+                           details: { byte_start: error.location.start_offset, byte_length: error.location.length })
+      end
+      if parsed.respond_to?(:data_loc) && parsed.data_loc
+        diagnostics << Records.diagnostic(
+          code: "unsupported_data_section",
+          message: "__END__ data is outside the supported source scope",
+          source_id: source_id
+        )
+      end
+      file_reasons = []
+      file_reasons << "unsupported_data_section" if parsed.respond_to?(:data_loc) && parsed.data_loc
+      file_reasons << "parse_error" unless parsed.errors.empty?
+      decisions = parsed.value ? decisions_for(parsed.value, bytes, source_id, file_reasons, encoding) : []
+      Records.build(source_id: source_id, relative_path: relative(path), absolute_path: File.expand_path(path),
+                    real_path: File.realpath(path), digest: Digest::SHA256.hexdigest(bytes), encoding: encoding,
+                    original_bytes: bytes, decisions: decisions, diagnostics: diagnostics)
+    rescue SystemCallError => e
+      Records.build(source_id: nil, relative_path: relative(path), absolute_path: File.expand_path(path),
+                    real_path: nil, digest: nil, encoding: nil, original_bytes: nil, decisions: [],
+                    diagnostics: [Records.diagnostic(code: "source_unreadable", severity: "error", message: e.message)])
+    end
+
+    def source_encoding(bytes, parsed)
+      source = parsed.source
+      return source.encoding.name if source.respond_to?(:encoding)
+
+      header = bytes.lines.first(2).join
+      match = header.match(/coding\s*[:=]\s*([A-Za-z0-9._-]+)/)
+      return Encoding.find(match[1]).name if match
+
+      Encoding::UTF_8.name
+    rescue ArgumentError
+      Encoding::UTF_8.name
+    end
+
+    def decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8")
+      nodes = []
+      walk(program) { |node| nodes << node if decision_node?(node) }
+      nodes.sort_by { |node| node.location.start_offset }.map.with_index do |node, _|
+        build_decision(node, bytes, source_id, file_reasons, encoding)
+      end
+    end
+
+    def walk(node, &block)
+      yield node
+      node.child_nodes.each { |child| walk(child, &block) if child }
+    end
+
+    def decision_node?(node)
+      node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+    end
+
+    def build_decision(node, bytes, source_id, file_reasons = [], encoding = "UTF-8")
+      predicate = unwrap_predicate(node.predicate)
+      leaves = []
+      tree = tree_for(predicate, bytes, leaves)
+      start_offset = predicate.location.start_offset
+      length = predicate.location.length
+      context = if node.is_a?(Prism::UnlessNode)
+                  "unless"
+                elsif node.if_keyword_loc.nil?
+                  "ternary"
+                else
+                  token = bytes.byteslice(node.if_keyword_loc.start_offset, node.if_keyword_loc.length)
+                  token == "elsif" ? "elsif" : "if"
+                end
+      opaque_ranges = leaves.filter_map { |leaf| leaf.delete(:_opaque_range) }
+      conditions = leaves.each_with_index.map do |leaf, index|
+        expression = text_value(leaf.delete(:_expression), "UTF-8")
+        location = leaf.delete(:_location)
+        literal_truth = leaf.delete(:_literal_truth)
+        Records.build(id: nil, index: index, byte_start: location.start_offset, byte_length: location.length,
+                      expression: expression, literal_truth: literal_truth, coupling: "unknown")
+      end
+      decision_id = Records.decision_id(source_id: source_id, context: context, byte_start: start_offset,
+                                        byte_length: length, tree: tree)
+      conditions = conditions.map do |condition|
+        condition.merge(id: Records.condition_id(decision_id, condition[:index]))
+      end
+      reasons = unsupported_reasons(predicate, bytes) + file_reasons
+      reasons << "unsupported_control_expression" if ambiguous_parentheses?(node.predicate)
+      reasons << "condition_limit_exceeded" if conditions.length > @limits[:conditions_per_decision]
+      discovered_condition_count = conditions.length
+      if discovered_condition_count > @limits[:conditions_per_decision]
+        conditions = conditions.first(@limits[:conditions_per_decision])
+        tree = nil
+      end
+      support = reasons.empty? ? "SUPPORTED" : "UNSUPPORTED"
+      expression = text_value(bytes.byteslice(predicate.location.start_offset, predicate.location.length), encoding)
+      Records.build(id: decision_id, source_id: source_id, context: context, byte_start: start_offset,
+                    byte_length: length, line: predicate.location.start_line, column: predicate.location.start_column,
+                    expression: expression,
+                    tree: tree,
+                    conditions: conditions, discovered_condition_count: discovered_condition_count,
+                    support_status: support, support_reasons: reasons.uniq, opaque_ranges: opaque_ranges)
+    end
+
+    def tree_for(node, bytes, leaves)
+      node = unwrap_predicate(node)
+      case node
+      when Prism::AndNode
+        Records.build(type: :and, left: tree_for(node.left, bytes, leaves), right: tree_for(node.right, bytes, leaves))
+      when Prism::OrNode
+        Records.build(type: :or, left: tree_for(node.left, bytes, leaves), right: tree_for(node.right, bytes, leaves))
+      else
+        location = node.location
+        leaf = {
+          _expression: bytes.byteslice(location.start_offset, location.length), _location: location,
+          _literal_truth: literal_truth(node),
+          _opaque_range: opaque?(node) ? { start: location.start_offset, length: location.length } : nil
+        }
+        leaves << leaf
+        Records.build(type: :atom, index: leaves.length - 1)
+      end
+    end
+
+    def literal_truth(node)
+      return true if node.is_a?(Prism::TrueNode)
+      return false if node.is_a?(Prism::FalseNode) || node.is_a?(Prism::NilNode)
+
+      nil
+    end
+
+    def opaque?(node)
+      node.is_a?(Prism::CallNode) && node.name == :!
+    end
+
+    def unsupported_reasons(predicate, bytes)
+      reasons = []
+      walk(predicate) do |node|
+        if node.is_a?(Prism::MatchLastLineNode) || node.is_a?(Prism::InterpolatedMatchLastLineNode)
+          reasons << "unsupported_implicit_regexp"
+        end
+        reasons << "unsupported_flip_flop" if node.is_a?(Prism::FlipFlopNode)
+        reasons << "unsupported_heredoc" if node.respond_to?(:opening_loc) && node.opening_loc &&
+                                            bytes.byteslice(node.opening_loc.start_offset,
+                                                            node.opening_loc.length).start_with?("<<")
+        if (node.is_a?(Prism::AndNode) || node.is_a?(Prism::OrNode)) && node.respond_to?(:operator_loc)
+          operator = bytes.byteslice(node.operator_loc.start_offset, node.operator_loc.length)
+          reasons << "unsupported_keyword_boolean" if %w[and or].include?(operator)
+        end
+      end
+      reasons
+    end
+
+    def unwrap_predicate(node)
+      while node.is_a?(Prism::ParenthesesNode)
+        statements = node.body
+        body = statements&.body
+        return node unless body&.length == 1
+
+        node = body.first
+      end
+      node
+    end
+
+    def ambiguous_parentheses?(node)
+      return false unless node.is_a?(Prism::ParenthesesNode)
+
+      body = node.body&.body
+      !body || body.length != 1
+    end
+
+    def text_value(value, encoding)
+      value.dup.force_encoding(encoding).encode("UTF-8")
+    rescue EncodingError
+      value.dup.force_encoding(Encoding::BINARY)
+    end
+
+    def relative(path)
+      Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(@root)).to_s
+    end
+  end
+end

data/lib/branchproof/version.rb

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

data/lib/branchproof/worker.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LineLength, Metrics/ModuleLength
+
+require "json"
+require "tmpdir"
+require "stringio"
+require "fileutils"
+
+module Branchproof
+  # Runs one isolated Minitest worker and atomically exports its result.
+  module Worker
+    module_function
+
+    def child_process(config_path)
+      payload = JSON.parse(File.binread(config_path))
+      project = symbolize(payload.fetch("project", legacy_project))
+      prepend_load_paths(project)
+      inventory = symbolize(payload.fetch("inventory"))
+      Array(inventory[:source_units]).each do |unit|
+        unit[:original_bytes] = File.binread(unit[:absolute_path]) if unit[:absolute_path]
+      end
+      limits = symbolize(payload.fetch("limits"))
+      require "minitest"
+      require "minitest/test"
+      require_relative "minitest_adapter"
+      evidence = Branchproof::Evidence.new(inventory: inventory, limits: limits, run_id: payload.fetch("run_id"))
+      runtime = Branchproof::Runtime
+      runtime.boot(evidence: evidence)
+      loader = Branchproof::Loader.new(inventory: inventory, instrumenter: Branchproof::Instrumenter.new)
+      status = loader.install
+      return write_failure(payload, "loader", status) unless status[:status].to_sym == :installed
+
+      adapter = Branchproof::MinitestAdapter.new(runtime: runtime)
+      rails_metadata = nil
+      ARGV.replace(payload.fetch("runner_args"))
+      adapter.run(test_files: payload.fetch("test_files"), runner_args: payload.fetch("runner_args"),
+                  before_load: lambda {
+                    rails_metadata = boot_project(project)
+                  }, on_complete: lambda { |baseline|
+                    result = completion_result(baseline: baseline, project: project, rails_metadata: rails_metadata,
+                                               evidence: runtime.snapshot, tests: adapter.tests.values,
+                                               diagnostics: loader.diagnostics)
+                    write_completion(payload, result)
+                  })
+      adapter.validate_runner!
+      Minitest.autorun
+      nil
+    rescue StandardError => e
+      code = if e.message.include?("parallel")
+               "unsupported_runner"
+             elsif defined?(Branchproof::RailsSupport::Error) && e.is_a?(Branchproof::RailsSupport::Error)
+               "rails_boot"
+             else
+               "worker"
+             end
+      write_failure(payload || {}, code, { message: e.message }) if payload
+      2
+    end
+
+    def legacy_project
+      { "kind" => "ruby", "root" => Dir.pwd,
+        "load_paths" => [File.join(Dir.pwd, "lib"), File.join(Dir.pwd, "test")],
+        "environment" => {} }
+    end
+
+    def prepend_load_paths(project)
+      paths = Array(project[:load_paths])
+      paths = legacy_project.fetch("load_paths") if paths.empty?
+      paths.reverse_each { |path| $LOAD_PATH.unshift(File.expand_path(path.to_s, project[:root].to_s)) }
+      nil
+    end
+
+    def boot_project(project)
+      return nil unless project[:kind].to_s == "rails"
+
+      require_relative "rails_support"
+      Branchproof::RailsSupport.boot(project: project)
+    end
+
+    def project_metadata(project, rails_metadata)
+      metadata = { kind: project[:kind].to_s, root: project[:root].to_s,
+                   load_paths: Array(project[:load_paths]).map(&:to_s), serial_policy: { mode: "single_process", workers: 1 } }
+      metadata.merge!(rails_metadata) if rails_metadata
+      metadata
+    end
+
+    # This result boundary intentionally carries the complete worker payload.
+    # rubocop:disable-next Metrics/ParameterLists
+    def completion_result(baseline:, project:, rails_metadata:, evidence:, tests:, diagnostics:)
+      result = baseline.merge(project: project_metadata(project, rails_metadata), evidence: evidence,
+                              tests: tests, diagnostics: diagnostics)
+      return result unless diagnostics.any? { |diagnostic| diagnostic[:severity].to_s == "error" }
+
+      result.merge(status: "ERROR", finalized: false, exit_status: 2,
+                   evidence: incomplete_evidence(evidence, diagnostics))
+    end
+
+    def incomplete_evidence(evidence, diagnostics)
+      copy = Marshal.load(Marshal.dump(evidence))
+      copy[:diagnostics] = Array(copy[:diagnostics]) + diagnostics
+      copy[:completeness] = (copy[:completeness] || {}).merge(observation: false, analysis: false)
+      copy
+    end
+
+    def write_completion(payload, result)
+      path = payload.fetch("result_path")
+      temporary = "#{path}.tmp-#{Process.pid}"
+      File.binwrite(temporary, JSON.generate(normalize(result)))
+      File.rename(temporary, path)
+      File.binwrite(payload.fetch("marker_path"), "complete\n")
+      nil
+    end
+
+    def write_failure(payload, code, details)
+      return unless payload["result_path"]
+
+      write_completion(payload, { status: "ERROR", executed_tests: 0, failed_tests: 0, skipped_tests: 0,
+                                  finalized: false, exit_status: 2, project: project_metadata_for(payload),
+                                  diagnostics: [{ code: code, severity: "error", message: details.to_s }] })
+    end
+
+    def project_metadata_for(payload)
+      project = symbolize(payload.fetch("project", legacy_project))
+      project_metadata(project, nil)
+    end
+
+    def symbolize(value)
+      return value.map { symbolize(_1) } if value.is_a?(Array)
+      return value.transform_keys(&:to_sym).transform_values { symbolize(_1) } if value.is_a?(Hash)
+
+      value
+    end
+
+    def normalize(value)
+      case value
+      when Hash then value.each_with_object({}) { |(key, item), result| result[key.to_s] = normalize(item) }
+      when Array then value.map { normalize(_1) }
+      when Symbol then value.to_s
+      else value
+      end
+    end
+  end
+end
+# rubocop:enable Layout/LineLength, Metrics/ModuleLength

data/lib/branchproof.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "branchproof/version"
+require_relative "branchproof/records"
+require_relative "branchproof/limits"
+require_relative "branchproof/source"
+require_relative "branchproof/project"
+
+# Public namespace for source inventory and one-run MC/DC reporting.
+module Branchproof
+  class Error < StandardError; end
+  autoload :CLI, "branchproof/cli"
+  autoload :Instrumenter, "branchproof/instrumenter"
+  autoload :Loader, "branchproof/loader"
+  autoload :Runtime, "branchproof/runtime"
+  autoload :MinitestAdapter, "branchproof/minitest_adapter"
+  autoload :Evidence, "branchproof/evidence"
+  autoload :Analyzer, "branchproof/analyzer"
+  autoload :Minimizer, "branchproof/minimizer"
+  autoload :Report, "branchproof/report"
+  autoload :Worker, "branchproof/worker"
+end
+
+MCDC = Branchproof unless defined?(MCDC)

data/lib/mcdc.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "branchproof"

data/llms.txt

@@ -0,0 +1,33 @@
+# Module Branchproof <a id="module-Branchproof"></a>
+
+|  |  |
+| --- | --- |
+| **Defined in** | lib/branchproof.rb, lib/branchproof/cli.rb, lib/branchproof/limits.rb, lib/branchproof/loader.rb, lib/branchproof/report.rb, lib/branchproof/source.rb, lib/branchproof/worker.rb, lib/branchproof/project.rb, lib/branchproof/records.rb, lib/branchproof/runtime.rb, lib/branchproof/version.rb, lib/branchproof/analyzer.rb, lib/branchproof/evidence.rb, lib/branchproof/minimizer.rb, lib/branchproof/instrumenter.rb, lib/branchproof/rails_support.rb, lib/branchproof/minitest_adapter.rb |
+
+Public namespace for source inventory and one-run MC/DC reporting.
+
+## Constants
+### `VERSION` <a id="constant-VERSION"></a> <a id="VERSION-constant"></a>
+Not documented.
+
+# Documentation
+
+- [Branchproof/Analyzer.md](doc/Branchproof/Analyzer.md)
+- [Branchproof/CLI.md](doc/Branchproof/CLI.md)
+- [Branchproof/Error.md](doc/Branchproof/Error.md)
+- [Branchproof/Evidence.md](doc/Branchproof/Evidence.md)
+- [Branchproof/Instrumenter.md](doc/Branchproof/Instrumenter.md)
+- [Branchproof/Limits.md](doc/Branchproof/Limits.md)
+- [Branchproof/Loader.md](doc/Branchproof/Loader.md)
+- [Branchproof/Minimizer.md](doc/Branchproof/Minimizer.md)
+- [Branchproof/MinitestAdapter.md](doc/Branchproof/MinitestAdapter.md)
+- [Branchproof/Project.md](doc/Branchproof/Project.md)
+- [Branchproof/RailsSupport/Error.md](doc/Branchproof/RailsSupport/Error.md)
+- [Branchproof/RailsSupport.md](doc/Branchproof/RailsSupport.md)
+- [Branchproof/Records.md](doc/Branchproof/Records.md)
+- [Branchproof/Report.md](doc/Branchproof/Report.md)
+- [Branchproof/Runtime.md](doc/Branchproof/Runtime.md)
+- [Branchproof/Source.md](doc/Branchproof/Source.md)
+- [Branchproof/Worker.md](doc/Branchproof/Worker.md)
+- [CHANGELOG.md](doc/CHANGELOG.md)
+- [README.md](doc/README.md)