hecks 2.9.0 → 3.0.0

data/lib/hecks/fuzzing/concurrent_dispatch.rb

@@ -0,0 +1,214 @@
+require "fileutils"
+require "tmpdir"
+require "tempfile"
+require "json"
+require_relative "isolated_boot"
+require_relative "../naming"
+require_relative "../quality_control/cli/child"
+
+module Hecks
+  module Fuzzing
+    # Races a generated sequence's own command step across two real OS processes
+    # against a live domain, checking the outcome against a sequential oracle to catch a broken
+    # cross-process lock.
+    module ConcurrentDispatch
+      module_function
+
+      COMMAND_STEP = ->(step) { step["verb"] && !step["query"] && !step["dry_run"] }
+
+      # `database:` is the shared, never-dropped scratch database; `race_schema:`
+      # and `reference_schema:` are this call's own disposable schemas.
+      def check(domain_path, steps, database:, race_schema:, reference_schema:)
+        normalized = steps.map { |step| step.transform_keys(&:to_s) }
+        lockable, probe_errors = lockable_verbs(domain_path, normalized, database: database, schema: reference_schema)
+        race_index = pick_race_index(normalized, lockable)
+        unless race_index
+          # `[]` must mean "nothing to race" (a query/dry-run-only sequence,
+          # a legitimate clean result), never a probe failure for every verb —
+          # see lockable_verbs, which distinguishes the two below.
+          return [] if probe_errors.empty?
+
+          return [{ field:  "concurrency_unraceable",
+                    detail: "no command step could be raced because the cross-process-lock probe failed: " \
+                            "#{probe_errors.uniq.join('; ')}" }]
+        end
+
+        setup_steps = normalized[0...race_index]
+        race_step   = normalized[race_index]
+
+        reference  = reference_outcomes(domain_path, setup_steps, race_step, database: database, schema: reference_schema)
+        concurrent = concurrent_outcomes(domain_path, setup_steps, race_step, database: database, schema: race_schema)
+
+        divergences_for(race_step, reference, concurrent)
+      rescue StandardError => e
+        [{ field: "process", detail: "#{e.class}: #{e.message}" }]
+      end
+
+      # Picks the command step closest to the middle of the sequence (best odds of
+      # conflicting with itself); nil if no step is eligible after lockable_verbs filters.
+      def pick_race_index(steps, lockable_verbs = nil)
+        command_indices = steps.each_index.select { |i| COMMAND_STEP.call(steps[i]) }
+        command_indices = command_indices.select { |i| lockable_verbs.include?(steps[i]["verb"]) } if lockable_verbs
+        return nil if command_indices.empty?
+
+        command_indices[command_indices.size / 2]
+      end
+
+      # Filters to verbs whose aggregate resolves to a `:cross_process_lock`-declaring
+      # adapter — a Memory-backed aggregate (e.g. one only `uses_framework`s) can never
+      # agree with the sequential oracle across two processes, a guaranteed false positive.
+      def lockable_verbs(domain_path, steps, database:, schema:)
+        verbs = steps.select { |step| COMMAND_STEP.call(step) }.map { |step| step["verb"] }.uniq
+        lockable = []
+        probe_errors = []
+        boot_preserving_schema(domain_path, database: database, schema: schema) do |copy|
+          runtime = Hecks.boot(copy, environment: nil)
+          verbs.each do |verb|
+            lockable << verb if verb_cross_process_lockable?(runtime, verb, probe_errors)
+          end
+        end
+        [lockable, probe_errors]
+      end
+
+      # false (with a recorded probe error) for a verb this boot cannot resolve, not a guess.
+      def verb_cross_process_lockable?(runtime, verb, probe_errors = [])
+        domain, aggregate_name, = Naming.split_verb(verb)
+        return false unless domain && aggregate_name
+
+        aggregate = runtime.registry.bluebook(domain)&.aggregate(aggregate_name)
+        return false unless aggregate
+
+        repository = runtime.registry.repository(domain, aggregate)
+        repository.capabilities.include?(:cross_process_lock)
+      rescue StandardError => e
+        # Still `false` — a verb this boot cannot resolve is not raced on a
+        # guess — but never silent: `check` needs to tell "nothing here
+        # declares a cross-process lock" from "asking broke".
+        probe_errors << "#{verb}: #{e.class}: #{e.message}"
+        false
+      end
+
+      def divergences_for(race_step, reference, concurrent)
+        crashes = (reference + concurrent).select { |outcome| outcome.start_with?("crashed:") }.uniq
+        return crashes.map { |c| { field: "concurrency_crash", verb: race_step["verb"], detail: c } } if crashes.any?
+
+        return [] if reference.sort == concurrent.sort
+
+        [{ field: "concurrency_race", verb: race_step["verb"], reference: reference, concurrent: concurrent,
+           detail: "two concurrent cross-process dispatches of #{race_step['verb']} settled as #{concurrent.sort} " \
+                   "where the identical pair, dispatched sequentially with no contention, settled as " \
+                   "#{reference.sort} — the cross-process write lock did not correctly serialize this write" }]
+      end
+
+      # The oracle: one boot, one process, setup then the race step twice in a row.
+      # Nothing else touches this schema, so the outcome is correct by construction.
+      def reference_outcomes(domain_path, setup_steps, race_step, database:, schema:)
+        outcomes = []
+        IsolatedBoot.call(domain_path, adapter: :postgres_era, database: database, schema: schema) do |copy|
+          runtime = Hecks.boot(copy, environment: nil)
+          dispatch_all!(runtime, setup_steps)
+          outcomes << dispatch_one(runtime, race_step)
+          outcomes << dispatch_one(runtime, race_step)
+        end
+        outcomes
+      end
+
+      # Setup replays once, sequentially, before either racer starts, against the
+      # already-wiped schema. Real OS processes, not threads, race it —
+      # Runtime::AggregateLock's in-process registry would serialize threads
+      # regardless of the lock fix. Process.spawn, not Process.fork — forking
+      # duplicates open file descriptors, including this process's own live
+      # Postgres connection, which corrupted it when tried here.
+      def concurrent_outcomes(domain_path, setup_steps, race_step, database:, schema:)
+        IsolatedBoot.call(domain_path, adapter: :postgres_era, database: database, schema: schema) do |copy|
+          dispatch_all!(Hecks.boot(copy, environment: nil), setup_steps)
+        end
+
+        root = File.expand_path("../../..", __dir__)
+        args_json = JSON.generate(race_step["args"] || {})
+        logs = Array.new(2) { Tempfile.new(["qa-concurrency-racer-", ".log"]) }
+        logs.each(&:unlink)
+
+        pids = logs.map do |log|
+          racer = Hecks::QualityControlCli::Child.argv(root, "qa_concurrency_racer", domain_path, database, schema,
+                                                       race_step["verb"], args_json)
+          Process.spawn(*racer, out: log, err: log, chdir: root)
+        end
+
+        pids.each { |pid| Process.wait(pid) }
+        logs.map do |log|
+          log.rewind
+          output = log.read
+          log.close
+          output.strip.empty? ? "crashed:no output from the concurrency racer" : output.lines.last.chomp
+        end
+      end
+
+      # Never raises: a declared domain refusal maps to "refused"; anything else
+      # escaping maps to "crashed:<class>: <message>" instead of killing a racer.
+      def dispatch_one(runtime, step)
+        args = (step["args"] || {}).transform_keys(&:to_sym)
+        runtime.dispatch_flat(step["verb"], args)
+        "succeeded"
+      rescue *Hecks::Runtime::DOMAIN_REFUSALS, Hecks::Bluebook::Expression::EvaluationError
+        "refused"
+      rescue StandardError => e
+        "crashed:#{e.class}: #{e.message}"
+      end
+
+      # Setup tolerates an ordinary refusal but never a crash — an unexpected
+      # exception here leaves the schema in an unknown state, not safe to race against.
+      def dispatch_all!(runtime, steps)
+        steps.each do |step|
+          outcome = dispatch_one(runtime, step)
+          raise "setup step #{step['verb']} #{outcome}" if outcome.start_with?("crashed:")
+        end
+      end
+
+      # Same copy-and-rebind IsolatedBoot.call(..., adapter: :postgres_era) does,
+      # minus the schema wipe — this schema already holds what setup wrote, and
+      # the race must run against that, not a blank one.
+      def boot_preserving_schema(domain_path, database:, schema:)
+        Dir.mktmpdir("hecks-concurrency") do |tmp|
+          copy = File.join(tmp, File.basename(domain_path))
+          IsolatedBoot.copy_dereferencing(domain_path, copy)
+          FileUtils.rm_rf(File.join(copy, "data"))
+          IsolatedBoot.rewrite_bindings!(copy, "PostgresEra")
+          write_postgres_era_world!(copy, database: database, schema: schema)
+          yield copy
+        end
+      end
+
+      # One world file per directory, merging every hecksagon name found there,
+      # replacing any other `.world` file the copy already carries.
+      def write_postgres_era_world!(copy, database:, schema:)
+        worlds_by_dir = Hash.new { |h, k| h[k] = [] }
+        Dir.glob(File.join(copy, "**", "*.hecksagon")).each do |hecksagon_path|
+          names = File.read(hecksagon_path).scan(/Hecks\.hecksagon\s+"([^"]+)"/).flatten
+          worlds_by_dir[File.dirname(hecksagon_path)].concat(names)
+        end
+        worlds_by_dir.each do |dir, names|
+          names = names.uniq
+          next if names.empty?
+
+          world_path = File.join(dir, "hecks_fuzz_postgres_era.world")
+          File.write(world_path, names.map do |name|
+            <<~WORLD
+              Hecks.world "#{name}" do
+                persisted_by("PostgresEra") do
+                  database "#{database}"
+                  schema "#{schema}"
+                  allow_superuser true
+                end
+              end
+            WORLD
+          end.join("\n"))
+        end
+
+        Dir.glob(File.join(copy, "**", "*.world")).each do |path|
+          File.delete(path) unless File.basename(path) == "hecks_fuzz_postgres_era.world"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/coverage_campaign.rb

@@ -0,0 +1,143 @@
+module Hecks
+  module Fuzzing
+    # Remembers which (verb, kind, state, mutation, outcome) tuples a sweep has reached.
+    # Later seeds splice corpus prefixes and favor rarely hit verbs.
+    #
+    # Reproducible: the only randomness is `Random.new(seed)`, and each `Plan` is printable.
+    class CoverageCampaign
+      # One seed's generation instructions, printable and reproducible.
+      Plan = Struct.new(:prefix, :favor, keyword_init: true) do
+        # The keyword arguments `SequenceGenerator.generate` and `.trace` accept.
+        def generator_options = { prefix: prefix, favor: favor }
+
+        def spliced? = !prefix.nil?
+      end
+
+      attr_reader :corpus
+
+      # @param splice_probability [Float] chance, per seed with a non-empty corpus, of splicing
+      # @param favor_count [Integer] rare verbs to favor per plan; zero or less disables favoring
+      # @param corpus_limit [Integer] entries kept; the oldest is dropped past this
+      # @param max_prefix_depth [Integer] nested-prefix depth beyond which entries are not admitted
+      def initialize(splice_probability:, favor_count:, corpus_limit: 64, max_prefix_depth: 6)
+        @splice_probability = splice_probability.to_f
+        @favor_count        = favor_count.to_i
+        @corpus_limit       = corpus_limit
+        @max_prefix_depth   = max_prefix_depth
+        @corpus             = []
+        @seen               = Set.new
+        @verb_hits          = Hash.new(0)
+        @declared_verbs     = Set.new
+        @seeds              = 0
+        @spliced            = 0
+        @seeds_with_new     = 0
+      end
+
+      # Builds this seed's plan: a possible corpus splice, plus the verbs to favor.
+      #
+      # @param seed [Integer] drives the splice coin flip, the corpus entry and the prefix length
+      # @return [Fuzzing::CoverageCampaign::Plan]
+      def plan(seed)
+        random = Random.new(seed)
+        prefix = nil
+        if !@corpus.empty? && random.rand < @splice_probability
+          entry  = @corpus[random.rand(@corpus.size)]
+          prefix = entry[:spec].merge("steps" => random.rand(1..entry[:attempts]))
+        end
+        Plan.new(prefix: prefix, favor: rare_verbs)
+      end
+
+      # Folds one seed's trace into the running coverage; admits a corpus entry if it reached
+      # a new tuple.
+      #
+      # @param seed [Integer] the seed the trace was generated from
+      # @param plan [Fuzzing::CoverageCampaign::Plan] the plan that seed ran with
+      # @param trace [Fuzzing::SequenceGenerator::Trace] from `SequenceGenerator.trace`
+      # @return [void]
+      def record(seed, plan, trace)
+        @seeds   += 1
+        @spliced += 1 if plan.spliced?
+        @declared_verbs.merge(trace.verbs)
+
+        new_at = trace.coverage.filter_map do |index, tuple|
+          @verb_hits[tuple.split(" | ").first] += 1
+          index if @seen.add?(tuple)
+        end
+        return if new_at.empty?
+
+        @seeds_with_new += 1
+        admit(seed, plan, new_at.max + 1)
+      end
+
+      # The number of distinct coverage tuples reached so far.
+      def tuples_seen = @seen.size
+
+      # One line of running totals: tuples seen, seeds run, seeds with new coverage, splices.
+      def summary
+        "coverage: #{@seen.size} distinct (verb, kind, state, mutation, outcome) tuple(s) over #{@seeds} seed(s); " \
+          "#{@seeds_with_new} seed(s) reached something new; #{@spliced} spliced from a corpus of #{@corpus.size}"
+      end
+
+      # Serializes the accumulated corpus and coverage knowledge, JSON-safe, so a later process can
+      # pick this campaign up where it left off. This campaign's own dials — splice probability,
+      # favor count, corpus and prefix-depth bounds — are configuration a caller supplies fresh each
+      # time, not state, so they are not part of this.
+      #
+      # @return [Hash] with string keys "corpus", "seen", "verb_hits", "declared_verbs"
+      def to_h
+        { "corpus"         => @corpus.map { |entry| { "spec" => entry[:spec], "attempts" => entry[:attempts] } },
+          "seen"           => @seen.to_a,
+          "verb_hits"      => @verb_hits.dup,
+          "declared_verbs" => @declared_verbs.to_a }
+      end
+
+      # Replaces this campaign's accumulated corpus and coverage knowledge with what a prior
+      # campaign's `#to_h` serialized, leaving this campaign's own dials untouched.
+      #
+      # @param state [Hash] as `#to_h` produced it; string or symbol keys both accepted
+      # @return [void]
+      def restore!(state)
+        state = state.transform_keys(&:to_s)
+        @corpus = Array(state["corpus"]).map { |entry| { spec: entry["spec"], attempts: entry["attempts"] } }
+        @seen = Set.new(Array(state["seen"]))
+        @verb_hits = Hash.new(0).merge(state["verb_hits"] || {})
+        @declared_verbs = Set.new(Array(state["declared_verbs"]))
+      end
+
+      # Builds a campaign that already knows what a prior campaign's `#to_h` reached, configured
+      # with this process's own dials rather than whatever the saved state's own process ran with.
+      #
+      # @param state [Hash] as `#to_h` produced it; string or symbol keys both accepted, since a
+      #   round trip through JSON turns every key into a string
+      # @param splice_probability [Float] see `#initialize`
+      # @param favor_count [Integer] see `#initialize`
+      # @param corpus_limit [Integer] see `#initialize`
+      # @param max_prefix_depth [Integer] see `#initialize`
+      # @return [Fuzzing::CoverageCampaign]
+      def self.load(state, splice_probability:, favor_count:, corpus_limit: 64, max_prefix_depth: 6)
+        new(splice_probability: splice_probability, favor_count: favor_count,
+            corpus_limit: corpus_limit, max_prefix_depth: max_prefix_depth).tap { |campaign| campaign.restore!(state) }
+      end
+
+      private
+
+      def admit(seed, plan, attempts)
+        return if depth(plan.prefix) + 1 > @max_prefix_depth
+
+        spec = { "seed" => seed, "favor" => plan.favor }
+        spec["prefix"] = plan.prefix if plan.prefix
+        @corpus << { spec: spec, attempts: attempts }
+        @corpus.shift while @corpus.size > @corpus_limit
+      end
+
+      def depth(prefix) = prefix.nil? ? 0 : 1 + depth(prefix["prefix"])
+
+      # Ties break by name so a plan is a pure function of what was recorded.
+      def rare_verbs
+        return [] unless @favor_count.positive?
+
+        (@declared_verbs | @verb_hits.keys).min_by(@favor_count) { |verb| [@verb_hits[verb], verb] }
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/differential.rb

@@ -0,0 +1,156 @@
+require "json"
+require "open3"
+require_relative "replay"
+require_relative "properties"
+require_relative "self_consistency"
+require_relative "rust_gap_manifest"
+require_relative "nondeterministic"
+
+module Hecks
+  module Fuzzing
+    # The Ruby-vs-Rust comparison of one generated sequence, shared by the QualityControl sweep
+    # (`hecks quality_control ask run`) and `hecks quality_control check_generated_domains --rust`.
+    #
+    # `differ` is duck-typed (the `RustConformanceHelpers` comparison helpers plus a
+    # `structural_skips` set) so lib never requires spec/.
+    module Differential
+      module_function
+
+      # Drops both sides' rows for verbs `gaps` declares not generated; every other
+      # divergence, however worded, stays in. A tolerated verb Rust nonetheless answered
+      # is reported as stale, so a wrong manifest cannot silently hold.
+      #
+      # @param gaps [Hecks::Fuzzing::RustGapManifest] the compiled binary's manifest
+      # @param ruby_refusals [Array<Hash>] Ruby's own refusal rows for this history
+      # @param rust_refusals [Array<Hash>] the Rust binary's own refusal rows
+      # @param ruby_queries [Array<Hash>] Ruby's own query rows for this history
+      # @param rust_queries [Array<Hash>] the Rust binary's own query rows
+      # @return [Hash] the four row lists with tolerated verbs removed, `skipped:` (a
+      #   `Set<String>` of tolerated verbs reached) and `stale:` (`Array<Hash>` divergences)
+      def manifest_partition(gaps, ruby_refusals:, rust_refusals:, ruby_queries:, rust_queries:)
+        verb_of  = ->(row) { row.key?("verb") ? row["verb"] : row["query"] }
+        declared = ->(row) { gaps.not_generated?(verb_of.call(row)) }
+        stale = rust_queries.select(&declared).map do |row|
+          { field: "manifest", verb: row["query"],
+            detail: "#{row['query']} is declared generated: false in manifest.json " \
+                    "(#{gaps.not_generated(row['query']).values_at('gap_class', 'construct').join('/')}), " \
+                    "but the Rust binary answered it — regenerate with hecks project_rust" }
+        end
+        reached = (ruby_refusals + rust_refusals + ruby_queries).select(&declared)
+        { ruby_refusals: ruby_refusals.reject(&declared), rust_refusals: rust_refusals.reject(&declared),
+          ruby_queries: ruby_queries.reject(&declared), rust_queries: rust_queries.reject(&declared),
+          skipped: reached.to_set(&verb_of), stale: stale }
+      end
+
+      # Runs the standard property battery on a replayed history.
+      #
+      # @param history [Hash] as returned by `Replay.call`
+      # @return [Array<Hash>] one `{field:, detail:}` entry per failed property
+      def property_divergences(history)
+        Properties.check(history).reject { |_, result| result == true }
+                  .map { |name, message| { field: name.to_s, detail: message } }
+      end
+
+      # Flattens `history[:self_consistency]`'s per-check divergence lists.
+      #
+      # @param history [Hash] as returned by `Replay.call`, optionally with `:self_consistency`
+      # @return [Array<Hash>] empty if `history` carries no `:self_consistency`
+      def self_consistency_divergences(history)
+        return [] unless history[:self_consistency]
+
+        history[:self_consistency].values.flatten(1)
+      end
+
+      # rubocop:disable-next Metrics/AbcSize
+      # rubocop:disable-next Metrics/CyclomaticComplexity
+      # rubocop:disable-next Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/MethodLength
+      # @param differ [Object] duck-typed `RustConformanceHelpers` interface
+      # @param domain_path [String] the domain directory to replay
+      # @param steps [Array<Hash>] the step sequence replayed on both engines
+      # @param binary [String] the compiled Rust conformance binary
+      # @param modes [Array<Symbol>] `:differential` (always run), `:self_consistency`,
+      #   `:properties_in_differential`, `:adapter_parity_sqlite`
+      # @param adapter_parity_sqlite [Proc, nil] the caller's comparison; `nil` skips the mode
+      # @return [Hash{Symbol => Array<Hash>}] one divergence list per active mode
+      def diff(differ, domain_path, steps, binary, modes:, adapter_parity_sqlite: nil)
+        self_consistency = modes.include?(:self_consistency)
+        ruby_result    = Replay.call(domain_path, steps, self_consistency: self_consistency)
+        ruby_instances = JSON.parse(JSON.generate(ruby_result[:instances]))
+        ruby_events    = JSON.parse(JSON.generate(ruby_result[:events]))
+        ruby_refusals  = ruby_result[:refusals].map do |r|
+          { "verb" => r[:verb].to_s, "kind" => r[:kind].to_s.split("::").last, "error" => r[:error] }
+        end
+        ruby_queries  = JSON.parse(JSON.generate(ruby_result[:queries].map { |row| Nondeterministic.strip(row, :query_row) }))
+        ruby_sagas    = JSON.parse(JSON.generate(ruby_result[:sagas]))
+        ruby_dry_runs = ruby_result[:dry_runs].map { |d| { "verb" => d[:verb].to_s, "ok" => d[:ok] } }
+
+        outcomes = {}
+        outcomes[:properties_in_differential] = property_divergences(ruby_result) if modes.include?(:properties_in_differential)
+        if modes.include?(:adapter_parity_sqlite) && adapter_parity_sqlite
+          outcomes[:adapter_parity_sqlite] = adapter_parity_sqlite.call
+        end
+
+        stdout, status = Open3.capture2(binary, stdin_data: JSON.generate({ "steps" => steps }))
+        unless status.success?
+          return outcomes.merge(differential: [{ field:  "process",
+                                                 detail: "rust binary exited #{status.exitstatus}: #{stdout}" }])
+        end
+
+        rust_output = JSON.parse(stdout)
+        rust_live_instances = JSON.parse(JSON.generate(rust_output["instances"])) if self_consistency
+        differ.strip_emitted_flags!(rust_output["instances"])
+        differ.strip_emitted_flags!(rust_output["queries"])
+        differ.strip_occurred_at!(rust_output["events"])
+
+        divergences = []
+        divergences << { field: "instances", ruby: ruby_instances, rust: rust_output["instances"] } \
+          unless rust_output["instances"] == ruby_instances
+        divergences << { field: "events", ruby: ruby_events, rust: rust_output["events"] } \
+          unless rust_output["events"] == ruby_events
+
+        kept = manifest_partition(RustGapManifest.for_binary(binary),
+                                  ruby_refusals: ruby_refusals, rust_refusals: rust_output["refusals"],
+                                  ruby_queries: ruby_queries, rust_queries: rust_output["queries"])
+        differ.structural_skips.merge(kept[:skipped])
+        divergences.concat(kept[:stale])
+
+        by_kind = ->(r) { r.slice("verb", "kind") }
+        rust_refusals      = kept[:rust_refusals].map(&by_kind)
+        kept_ruby_refusals = kept[:ruby_refusals].map(&by_kind)
+        divergences << { field: "refusals", ruby: kept_ruby_refusals, rust: rust_refusals } \
+          unless rust_refusals == kept_ruby_refusals
+
+        wordless          = ->(row) { differ.reduce_to_wire_precision(row.except("error", "reference_error")) }
+        rust_queries      = kept[:rust_queries].map(&wordless)
+        kept_ruby_queries = kept[:ruby_queries].map(&wordless)
+        divergences << { field: "queries", ruby: kept_ruby_queries, rust: rust_queries } \
+          unless rust_queries == kept_ruby_queries
+
+        divergences << { field: "sagas", ruby: ruby_sagas, rust: rust_output["sagas"] } \
+          unless rust_output["sagas"] == ruby_sagas
+
+        cross_domain = differ.cross_domain_policy_names(rust_output)
+        kept_ruby_reactions = JSON.parse(JSON.generate(ruby_result[:reactions]))
+                                  .reject { |r| cross_domain.include?(r["policy"]) }
+        rust_reactions = rust_output.fetch("reactions")
+        divergences << { field: "reactions", ruby: kept_ruby_reactions, rust: rust_reactions } \
+          unless rust_reactions == kept_ruby_reactions
+
+        rust_dry_runs = Array(rust_output["dry_runs"]).map { |d| d.slice("verb", "ok") }
+        divergences << { field: "dry_runs", ruby: ruby_dry_runs, rust: rust_dry_runs } \
+          unless rust_dry_runs == ruby_dry_runs
+        outcomes[:differential] = divergences
+
+        if self_consistency
+          outcomes[:self_consistency] =
+            self_consistency_divergences(ruby_result) +
+            SelfConsistency.check_rust_rehydration(binary, differ, rust_live_instances) +
+            SelfConsistency.check_rust_idempotency(binary, differ, rust_live_instances)
+        end
+
+        outcomes
+      end
+    end
+  end
+end