hecks 3.4.2 → 3.6.0

data/lib/hecks/fuzzing/bounded_exhaustive_expressions.rb

@@ -1,5 +1,7 @@
 require_relative "../bluebook/expression/resolver"
 require_relative "../bluebook/expression/evaluator"
+require_relative "bounded_exhaustive_expressions/fragments"
+require_relative "bounded_exhaustive_expressions/productions"
 
 module Hecks
   module Fuzzing
@@ -9,6 +11,9 @@ module Hecks
     # Generation is type-directed: a sub-expression is only built where its parent
     # accepts its type, with a small literal palette and a depth bound to stay tractable.
     module BoundedExhaustiveExpressions
+      extend Fragments
+      extend Productions
+
       module_function
 
       # Integer and Float are one type: the resolver never distinguishes them.
@@ -144,200 +149,6 @@ module Hecks
       # @return [Array<String>] at most `SAMPLE_CAP` expressions
       def bounded(type, depth) = sample(productions(type, depth))
 
-      # Numeric from Addition, Modulo, Size (string or array), and First/Last of a numeric array.
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] numeric expressions one construct deep
-      def numeric_productions(depth)
-        sub = bounded(:numeric, depth - 1)
-        # Modulo's receiver is restricted to `resolver_numeric_leaves`: `Resolver.parse` splits
-        # on `+` before the `.modulo` suffix, so "0 + 0.modulo(1)" parses as `0 + (0.modulo(1))`.
-        pairs(sub).map { |a, b| "#{a} + #{b}" } +
-          cross(resolver_numeric_leaves(depth - 1), sub).map { |a, b| "#{a}.modulo(#{b})" } +
-          bounded(:string, depth - 1).map { |s| "#{s}.size" } +
-          bounded(:array, depth - 1).map { |a| "#{a}.size" } +
-          sample(numeric_array_productions(depth - 1)).flat_map { |a| ["#{a}.first", "#{a}.last"] }
-      end
-
-      # Booleans safe as the receiver of a Resolver-level suffix such as `.to_s` (a boolean-
-      # typed expression, is wanted). Found live, the same way the
-      # nested `.modulo` bug was: `Compare`, `Include`, `Or`, `And` and `Not` are boolean-
-      # typed at `interpret` time, but `Evaluator`-level syntax, not
-      # something `Resolver.parse` can take as a receiver, even parenthesized.
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] boolean expressions parsed by a Resolver suffix rule
-      def resolver_boolean_leaves(depth)
-        leaves(:boolean) +
-          resolver_numeric_leaves(depth).flat_map { |n| ["#{n}.positive?", "#{n}.negative?", "#{n}.zero?"] } +
-          bounded(:string, depth).flat_map do |s|
-            ["#{s}.present?", "#{s}.blank?", "#{s}.match?(/a/)", "#{s}.start_with?(\"a\")", "#{s}.end_with?(\"a\")"]
-          end +
-          (sample(numeric_array_productions(depth)) + sample(string_array_productions(depth)) + bounded(:array, depth)).map do |x|
-            "#{x}.empty?"
-          end +
-          sample(block_predicate_productions(depth))
-      end
-
-      # Numerics safe to embed as the receiver of a Resolver-level suffix such as `.to_s`.
-      #
-      # A bare `Addition` is excluded: `Resolver.parse` splits on `+` before matching the
-      # suffix, so "0 + 0.to_s" parses as `0 + (0.to_s)`, not `(0 + 0).to_s`.
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] numeric expressions that are never a bare top-level `Addition`
-      def resolver_numeric_leaves(depth)
-        return leaves(:numeric) if depth <= 0
-
-        # Self-referential so Modulo's receiver stays restricted; its argument is unrestricted.
-        leaves(:numeric) +
-          cross(resolver_numeric_leaves(depth - 1), bounded(:numeric, depth - 1)).map { |a, b| "#{a}.modulo(#{b})" } +
-          bounded(:string, depth).map { |s| "#{s}.size" } +
-          bounded(:array, depth).map { |a| "#{a}.size" } +
-          sample(numeric_array_productions(depth)).flat_map { |a| ["#{a}.first", "#{a}.last"] }
-      end
-
-      # String from ToS of numeric, boolean, nil or string, and First/Last of a string array.
-      #
-      # `Split` is not listed: it produces an array, never a String.
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] string expressions one construct deep
-      def string_productions(depth)
-        sample(resolver_numeric_leaves(depth - 1)).map { |n| "#{n}.to_s" } +
-          sample(resolver_boolean_leaves(depth - 1)).map { |b| "#{b}.to_s" } +
-          bounded(:nil_type, depth - 1).map { |n| "#{n}.to_s" } +
-          bounded(:string, depth - 1).map { |s| "#{s}.to_s" } +
-          sample(string_array_productions(depth - 1)).flat_map { |a| ["#{a}.first", "#{a}.last"] }
-      end
-
-      # Array from Split and same-type array literals; array is mostly a receiver type, so
-      # few producers are needed.
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] array expressions one construct deep; `[]` at depth 0
-      def array_productions(depth)
-        return [] if depth <= 0
-
-        bounded(:string, depth - 1).map { |s| "#{s}.split(\",\")" } +
-          [numeric_array_literal(depth - 1), string_array_literal(depth - 1)]
-      end
-
-      # Builds a two-element numeric array literal at `depth`.
-      #
-      # @param depth [Integer] maximum recursive steps remaining for its elements
-      # @return [String] the literal's source text
-      def numeric_array_literal(depth) = "[#{bounded(:numeric, depth).first(2).join(', ')}]"
-
-      # Builds a two-element string array literal at `depth`.
-      #
-      # @param depth [Integer] maximum recursive steps remaining for its elements
-      # @return [String] the literal's source text
-      def string_array_literal(depth)  = "[#{bounded(:string, depth).first(2).join(', ')}]"
-
-      # Arrays known by construction to hold numeric elements, so `.first`/`.last` and block
-      # predicates know the element type without a richer AST.
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] `"arr_num"` plus a numeric array literal at `depth`
-      def numeric_array_productions(depth)
-        ["arr_num", numeric_array_literal(depth)]
-        # no Split entry: a Split of a string never yields numeric elements
-      end
-
-      # Arrays known by construction to hold string elements; the twin of
-      # `numeric_array_productions`.
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] `"arr_str"`, a string array literal, and every string `Split`
-      def string_array_productions(depth)
-        ["arr_str", string_array_literal(depth)] + bounded(:string, depth).map { |s| "#{s}.split(\",\")" }
-      end
-
-      # Boolean from every comparison and predicate construct; a `given` body is boolean-
-      # typed at its own top level (`Evaluator.truthy?`), so this is also
-      # the set `all_predicates` draws from.
-      #
-      # One table rather than helper methods: each term's rationale sits beside it.
-      # rubocop:disable-next Metrics/AbcSize
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] boolean expressions one construct deep
-      def boolean_productions(depth)
-        sub = bounded(:boolean, depth - 1)
-        num = bounded(:numeric, depth - 1)
-        str = bounded(:string, depth - 1)
-
-        pairs(num).map { |a, b| "#{a} == #{b}" } +
-          pairs(num).map { |a, b| "#{a} > #{b}" } +
-          pairs(str).map { |a, b| "#{a} == #{b}" } +
-          pairs(str).map { |a, b| "#{a} < #{b}" } +
-          # `resolver_numeric_leaves`, not `num`: a suffix match is a plain trailing strip, so
-          # an `Addition` would mis-split ("0 + 0.positive?" parses as `0 + (0.positive?)`).
-          resolver_numeric_leaves(depth - 1).flat_map { |n| ["#{n}.positive?", "#{n}.negative?", "#{n}.zero?"] } +
-          (str + sample(numeric_array_productions(depth - 1)) + sample(string_array_productions(depth - 1)) + bounded(:array,
-                                                                                                                      depth - 1))
-          .map do |x|
-            "#{x}.empty?"
-          end +
-          str.map { |s| "#{s}.match?(/a/)" } +
-          str.flat_map { |s| ["#{s}.present?", "#{s}.blank?"] } +
-          str.flat_map { |s| ["#{s}.start_with?(\"a\")", "#{s}.end_with?(\"a\")"] } +
-          pairs(sub).flat_map { |a, b| ["#{a} && #{b}", "#{a} || #{b}"] } +
-          sub.map { |b| "!#{b}" } +
-          block_predicate_productions(depth - 1) +
-          include_productions(depth - 1)
-      end
-
-      # `.all?`/`.any?`/`.none?` over each known-element-typed array, with a predicate body
-      # bound to `BLOCK_PARAM`.
-      #
-      # The only construct where Resolver and Evaluator recurse into each other, and the
-      # only one that can nest into another block predicate.
-      #
-      # @param depth [Integer] maximum recursive steps remaining for the predicate body
-      # @return [Array<String>] `.all?`/`.any?`/`.none?` calls over each
-      #   known-element-typed array source, one per predicate body `predicate_bodies`
-      #   produces; `[]` if `depth` is negative
-      def block_predicate_productions(depth)
-        return [] if depth.negative?
-
-        [
-          ["arr_num", :numeric], [numeric_array_literal(depth), :numeric],
-          ["arr_str", :string], [string_array_literal(depth), :string]
-        ].flat_map do |array_text, element_type|
-          predicate_bodies(element_type, depth).flat_map do |body|
-            %w[all? any? none?].map { |mode| "#{array_text}.#{mode} { |#{BLOCK_PARAM}| #{body} }" }
-          end
-        end
-      end
-
-      # The predicate body a block gets: `boolean_productions` with `BLOCK_PARAM` also a leaf.
-      # Sampled because each body is multiplied by three modes and four array sources.
-      #
-      # @param element_type [Symbol] the type `BLOCK_PARAM` is bound to inside the block
-      # @param depth [Integer] maximum recursive steps remaining for the body
-      # @return [Array<String>] a sampled set of boolean expressions
-      def predicate_bodies(element_type, depth)
-        sample(with_element_leaf(element_type) { boolean_productions(depth) })
-      end
-
-      # `haystack.include?(needle)`: a String haystack needs a String needle, an Array
-      # haystack admits any needle type.
-      #
-      # @param depth [Integer] maximum recursive steps remaining
-      # @return [Array<String>] `include?` expressions for string and array haystacks
-      def include_productions(depth)
-        str = bounded(:string, depth)
-        pairs(str).map { |haystack, needle| "#{haystack}.include?(#{needle})" } +
-          sample(numeric_array_productions(depth)).product(bounded(:numeric, depth)).map do |arr, needle|
-            "#{arr}.include?(#{needle})"
-          end +
-          sample(string_array_productions(depth)).product(bounded(:string, depth)).map do |arr, needle|
-            "#{arr}.include?(#{needle})"
-          end
-      end
-
       # Cap on any sampled list. A full cross product explodes to tens of millions of cases,
       # and `Or`/`And`/`Not` do no type-dependent work, so sampled operands cover them.
       SAMPLE_CAP = 14

data/lib/hecks/fuzzing/combination_miner.rb

@@ -25,30 +25,41 @@ module Hecks
       end
 
       def brief(paths, root:, bug_titles:)
+        covered, skipped = census_paths(paths, root)
+        { "forms" => FormCensus::FORMS.keys, "corpus" => paths.map { |path| relative(path, root) },
+          "unmet_pairs" => (FormCensus.pairs - covered.keys).sort,
+          "single_carrier_pairs" => single_carrier_pairs(covered),
+          "skipped" => skipped, "recent_bugs" => bug_titles, "covered" => covered }
+      end
+
+      def census_paths(paths, root)
         covered = Hash.new { |hash, key| hash[key] = [] }
         skipped = []
         paths.each do |path|
           FormCensus.covered_pairs(FormCensus.census(path)).each { |pair, names| covered[pair].concat(names) }
         rescue StandardError, ScriptError => e
-          skipped << "#{relative(path, root)} (#{e.class}: #{e.message.lines.first&.strip})"
+          skipped << skip_note(relative(path, root), e)
         end
-        { "forms" => FormCensus::FORMS.keys, "corpus" => paths.map { |path| relative(path, root) },
-          "unmet_pairs" => (FormCensus.pairs - covered.keys).sort,
-          "single_carrier_pairs" => covered.select { |_, names| names.uniq.size == 1 }
-                                           .map { |pair, names| "#{pair} (only #{names.first})" }.sort,
-          "skipped" => skipped, "recent_bugs" => bug_titles, "covered" => covered }
+        [covered, skipped]
+      end
+
+      def skip_note(path, error) = "#{path} (#{error.class}: #{error.message.lines.first&.strip})"
+
+      def single_carrier_pairs(covered)
+        covered.select { |_, names| names.uniq.size == 1 }.map { |pair, names| "#{pair} (only #{names.first})" }.sort
       end
 
       def prompt(root, brief, count:, out_dir:)
-        substitutions = {
-          "count" => count.to_s, "out_dir" => out_dir, "forms" => brief["forms"].join(", "),
-          "corpus" => bulleted(brief["corpus"]), "unmet_pairs" => bulleted(brief["unmet_pairs"]),
-          "single_carrier_pairs" => bulleted(brief["single_carrier_pairs"]),
-          "recent_bugs" => bulleted(brief["recent_bugs"]), "skipped" => bulleted(brief["skipped"])
-        }
+        substitutions = prompt_substitutions(brief, count, out_dir)
         File.read(File.join(root, PROMPT_TEMPLATE)).gsub(/\{\{(\w+)\}\}/) { substitutions.fetch(Regexp.last_match(1)) }
       end
 
+      def prompt_substitutions(brief, count, out_dir)
+        lists = ["corpus", "unmet_pairs", "single_carrier_pairs", "recent_bugs", "skipped"]
+        lists.to_h { |key| [key, bulleted(brief[key])] }
+             .merge("count" => count.to_s, "out_dir" => out_dir, "forms" => brief["forms"].join(", "))
+      end
+
       def repair_prompt(failures, out_dir:)
         listed = failures.map { |candidate, error| "- #{candidate[:bluebook]}\n  boot error: #{error}" }.join("\n")
         <<~PROMPT

data/lib/hecks/fuzzing/concurrent_dispatch/racing.rb

@@ -0,0 +1,64 @@
+require "json"
+require "tempfile"
+require_relative "../isolated_boot"
+require_relative "../../quality_control/cli/child"
+
+module Hecks
+  module Fuzzing
+    module ConcurrentDispatch
+      # The oracle run and the two-process race that `ConcurrentDispatch.check` compares.
+      module Racing
+        # 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
+
+          logs = Array.new(2) { Tempfile.new(["qa-concurrency-racer-", ".log"]) }
+          logs.each(&:unlink)
+
+          pids = spawn_racers(logs, domain_path, race_step, database, schema)
+          pids.each { |pid| Process.wait(pid) }
+          logs.map { |log| racer_outcome(log) }
+        end
+
+        # Starts one racer process per log, each writing its outcome line to its own log.
+        def spawn_racers(logs, domain_path, race_step, database, schema)
+          root = File.expand_path("../../../..", __dir__)
+          args_json = JSON.generate(race_step["args"] || {})
+          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
+        end
+
+        # The last line a racer wrote, or a crash outcome when it wrote nothing.
+        def racer_outcome(log)
+          log.rewind
+          output = log.read
+          log.close
+          output.strip.empty? ? "crashed:no output from the concurrency racer" : output.lines.last.chomp
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/concurrent_dispatch/world_copy.rb

@@ -0,0 +1,66 @@
+require "fileutils"
+require "tmpdir"
+require_relative "../isolated_boot"
+
+module Hecks
+  module Fuzzing
+    module ConcurrentDispatch
+      # Copies a target domain, rebinds it to a shared `PostgresEra` schema and boots it there.
+      module WorldCopy
+        FUZZ_WORLD_FILE = "hecks_fuzz_postgres_era.world".freeze
+
+        # 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:)
+          hecksagon_names_by_dir(copy).each do |dir, names|
+            names = names.uniq
+            next if names.empty?
+
+            worlds = names.map { |name| postgres_era_world(name, database, schema) }
+            File.write(File.join(dir, FUZZ_WORLD_FILE), worlds.join("\n"))
+          end
+
+          Dir.glob(File.join(copy, "**", "*.world")).each do |path|
+            File.delete(path) unless File.basename(path) == FUZZ_WORLD_FILE
+          end
+        end
+
+        # The `Hecks.hecksagon` names each directory under `copy` declares.
+        def hecksagon_names_by_dir(copy)
+          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
+        end
+
+        def postgres_era_world(name, database, schema)
+          <<~WORLD
+            Hecks.world "#{name}" do
+              persisted_by("PostgresEra") do
+                database "#{database}"
+                schema "#{schema}"
+                allow_superuser true
+              end
+            end
+          WORLD
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/concurrent_dispatch.rb

@@ -5,6 +5,8 @@ require "json"
 require_relative "isolated_boot"
 require_relative "../naming"
 require_relative "../quality_control/cli/child"
+require_relative "concurrent_dispatch/racing"
+require_relative "concurrent_dispatch/world_copy"
 
 module Hecks
   module Fuzzing
@@ -12,6 +14,9 @@ module Hecks
     # against a live domain, checking the outcome against a sequential oracle to catch a broken
     # cross-process lock.
     module ConcurrentDispatch
+      extend Racing
+      extend WorldCopy
+
       module_function
 
       COMMAND_STEP = ->(step) { step["verb"] && !step["query"] && !step["dry_run"] }
@@ -22,26 +27,34 @@ module Hecks
         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
+        return unraceable(probe_errors) unless race_index
+
+        schemas = { race: race_schema, reference: reference_schema }
+        race(domain_path, normalized, race_index, database: database, schemas: schemas)
+      rescue StandardError => e
+        [{ field: "process", detail: "#{e.class}: #{e.message}" }]
+      end
+
+      # `[]` 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.
+      def unraceable(probe_errors)
+        return [] if probe_errors.empty?
+
+        [{ 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]
+      # Runs the oracle and the race over the setup that precedes `race_index`.
+      def race(domain_path, steps, race_index, database:, schemas:)
+        setup_steps = steps[0...race_index]
+        race_step   = steps[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)
+        reference  = reference_outcomes(domain_path, setup_steps, race_step, database: database, schema: schemas[:reference])
+        concurrent = concurrent_outcomes(domain_path, setup_steps, race_step, database: database, schema: schemas[:race])
 
         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
@@ -95,55 +108,11 @@ module Hecks
         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} " \
+           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)
@@ -161,52 +130,7 @@ module Hecks
       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"
+          raise "setup step #{step["verb"]} #{outcome}" if outcome.start_with?("crashed:")
         end
       end
     end

data/lib/hecks/fuzzing/coverage_campaign.rb

@@ -28,9 +28,7 @@ module Hecks
         @seen               = Set.new
         @verb_hits          = Hash.new(0)
         @declared_verbs     = Set.new
-        @seeds              = 0
-        @spliced            = 0
-        @seeds_with_new     = 0
+        @seeds = @spliced = @seeds_with_new = 0
       end
 
       # Builds this seed's plan: a possible corpus splice, plus the verbs to favor.
@@ -40,10 +38,7 @@ module Hecks
       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
+        prefix = splice_prefix(random) if !@corpus.empty? && random.rand < @splice_probability
         Plan.new(prefix: prefix, favor: rare_verbs)
       end
 
@@ -121,6 +116,11 @@ module Hecks
 
       private
 
+      def splice_prefix(random)
+        entry = @corpus[random.rand(@corpus.size)]
+        entry[:spec].merge("steps" => random.rand(1..entry[:attempts]))
+      end
+
       def admit(seed, plan, attempts)
         return if depth(plan.prefix) + 1 > @max_prefix_depth