hecks 2.7.0 → 2.9.0

data/lib/rubocop/cop/hecks/thread_shared_ivar_mutation.rb

@@ -1,65 +1,15 @@
 module RuboCop
   module Cop
     module Hecks
-      # Flags plain `@ivar` mutation inside a class this codebase already
-      # knows is a thread-shared singleton — one `Dispatcher`/`Registry`
-      # instance lives for the life of a boot and is dispatched through
-      # from every thread of a Puma worker pool (or any other multi-
-      # threaded host), so a plain instance variable on either class is
-      # shared, mutable state with no per-thread or mutex-guarded
-      # isolation at all.
-      #
-      # ## The bug this follows up on
-      #
-      # This is the mechanical follow-up to a real bug already fixed here
-      # (see `dispatcher.rb`'s own `#reenter` comment, and
-      # `spec/runtime/dispatcher_spec.rb`): a plain `@reaction_depth` ivar on
-      # `Dispatcher` let two threads' concurrent top-level
-      # dispatches corrupt each other's view of "how deep into a
-      # reaction cascade am I". The fix moved that one ivar to
-      # `Thread.current[:hecks_reaction_depth]`. This cop exists so the
-      # next plain ivar someone adds to either class gets flagged before
-      # it becomes the next instance of the same bug, rather than after.
-      #
-      # ## Scoped narrowly on purpose
-      #
-      # By class name
-      # (`Hecks::Runtime::Dispatcher`/`Hecks::Runtime::Registry`), not by
-      # blanket-flagging every ivar mutation in the codebase. Most classes
-      # in this codebase are not shared across threads (a fresh value
-      # object per call, a builder used once at boot) and ivar mutation
-      # there is completely ordinary Ruby with no hazard behind it at
-      # all — flagging it everywhere would be noise nobody trusts, the
-      # same reasoning `.rubocop.yml`'s own header gives for every other
-      # cop in this repo.
-      #
-      # ## What counts as "plain"
-      #
-      # `@ivar = ...`, `@ivar ||= ...`, `@ivar +=
-      # ...`, `@ivar << ...`, `@ivar[k] = v`. `initialize` is exempt — an
-      # ivar being set up for the first time, before any other thread can
-      # possibly hold a reference to this object, is not the hazard (see
-      # `Registry#initialize`'s own `@saga_mutex = Mutex.new`, which this
-      # cop must not flag). `Thread.current[...]`-backed state and a
-      # `Mutex`-guarded critical section are exactly the two idioms this
-      # codebase has already established for this — see `Dispatcher
-      # #reenter` and `Registry#saga_mutex` respectively — so the message
-      # points at both rather than inventing a third.
+      # Flags plain `@ivar` mutation inside the thread-shared `Dispatcher` and `Registry` classes.
+      # `initialize` is exempt; use `Thread.current[...]` or a `Mutex` elsewhere.
       #
       # @example
       #   # bad
-      #   class Dispatcher
-      #     def reenter(verb)
-      #       @reaction_depth = @reaction_depth.to_i + 1
-      #     end
-      #   end
+      #   @reaction_depth = @reaction_depth.to_i + 1
       #
       #   # good
-      #   class Dispatcher
-      #     def reenter(verb)
-      #       Thread.current[:hecks_reaction_depth] = Thread.current[:hecks_reaction_depth].to_i + 1
-      #     end
-      #   end
+      #   Thread.current[:hecks_reaction_depth] = Thread.current[:hecks_reaction_depth].to_i + 1
       class ThreadSharedIvarMutation < Base
         MSG = "`%<ivar>s` is a plain instance variable mutated outside `initialize` on " \
               "%<klass>s, which is shared across every thread dispatching through it " \
@@ -73,59 +23,33 @@ module RuboCop
 
         RESTRICT_ON_SEND = [:<<, :[]=].freeze
 
-        # Flags a plain `@ivar = ...` assignment inside a thread-shared class.
-        #
-        # @param node [RuboCop::AST::IvasgnNode] the ivar-assignment node being visited
-        # @return [void]
         def on_ivasgn(node)
-          # A plain `@x = 1` parses as `(ivasgn :@x (int 1))` — two
-          # children. The commissioner also visits the bare `(ivasgn :@x)`
-          # node nested one level inside an `op_asgn`/`or_asgn` (`@x += 1`,
-          # `@x ||= 1`) as its own `ivasgn` node with only one child — that
-          # one is handled by `on_op_asgn`/`on_or_asgn` below instead, so
-          # it's skipped here to avoid double-reporting the same mutation.
+          # Skips the bare one-child `ivasgn` nested in `op_asgn`/`or_asgn`; those handlers
+          # report it, so this avoids a double offense.
           return unless node.children.size == 2
 
           check(node, node.children.first)
         end
 
-        # Flags a plain `@ivar += ...` (or similar) compound assignment inside a
-        # thread-shared class.
-        #
-        # @param node [RuboCop::AST::OpAsgnNode] the compound-assignment node being visited
-        # @return [void]
         def on_op_asgn(node)
-          # `@x += 1` parses as `(op_asgn (ivasgn :@x) :+ (int 1))` — the
-          # target is an `ivasgn` node carrying just the name (no value
-          # child, unlike a plain `@x = 1`), not an `ivar` node.
+          # The target of `@x += 1` is a value-less `ivasgn` node, not an `ivar`.
           ivar_node = node.children.first
           return unless ivar_node.is_a?(RuboCop::AST::Node) && ivar_node.ivasgn_type?
 
           check(node, ivar_node.children.first)
         end
 
-        # Flags a plain `@ivar ||= ...` assignment inside a thread-shared class.
-        #
-        # @param node [RuboCop::AST::OrAsgnNode] the `||=` assignment node being visited
-        # @return [void]
         def on_or_asgn(node)
           on_op_asgn(node)
         end
 
-        # Flags a plain `@ivar << ...` or `@ivar[k] = v` mutation inside a thread-shared
-        # class.
-        #
-        # @param node [RuboCop::AST::SendNode] the `<<` or `[]=` send node being visited
-        # @return [void]
         def on_send(node)
           return unless RESTRICT_ON_SEND.include?(node.method_name)
 
           receiver = node.receiver
           return unless receiver
 
-          # `@ivar << x` — the receiver is the ivar.
-          # `@ivar[k] = v` — the receiver is a `send(@ivar, :[], k)`, whose
-          # own receiver is the ivar (`node.receiver.receiver`).
+          # `@ivar << x` has the ivar as receiver; `@ivar[k] = v` has it one `send` deeper.
           ivar_node = if receiver.ivar_type?
                         receiver
                       elsif receiver.send_type? && receiver.receiver&.ivar_type?
@@ -149,14 +73,7 @@ module RuboCop
           !!enclosing_class_name(node)&.then { |name| THREAD_SHARED_CLASSES.include?(name) }
         end
 
-        # Walks outward to the nearest enclosing `class` node and returns
-        # its own short name (`Dispatcher`, not the fully-qualified
-        # `Hecks::Runtime::Dispatcher`) — good enough to match this repo's
-        # own one-class-per-file layout without needing full namespace
-        # resolution, and avoids a false negative on `class Dispatcher`
-        # bodies that reopen the class from inside the `Hecks::Runtime`
-        # module (this repo's actual style) as much as one written as
-        # `class Hecks::Runtime::Dispatcher`.
+        # Uses the short class name so both nested and `Hecks::Runtime::Dispatcher` styles match.
         def enclosing_class_name(node)
           klass = node.each_ancestor(:class).first
           return nil unless klass
@@ -165,13 +82,7 @@ module RuboCop
           const_node.const_name.to_s.split("::").last
         end
 
-        # `initialize` is where an ivar is set up for the first time —
-        # before this object has been handed to a caller at all, so no
-        # other thread can hold a reference to mutate concurrently with
-        # it. Also exempts `initialize` methods defined on an object
-        # reopened via `class << self` or nested module — `each_ancestor`
-        # naturally stops at the nearest enclosing `def`, matching Ruby's
-        # own method-scoping.
+        # An ivar set in `initialize` cannot yet be shared with another thread.
         def inside_initialize?(node)
           def_node = node.each_ancestor(:def, :defs).first
           return false unless def_node

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.9.0
 platform: ruby
 authors:
 - Chris Young
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2026-09-27 00:00:00.000000000 Z
+date: 2026-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -30,10 +30,12 @@ description: |
   Nothing is scripted: no handler body, no class you write, no schema
   you migrate.
 email:
-executables: []
+executables:
+- hecks
 extensions: []
 extra_rdoc_files: []
 files:
+- exe/hecks
 - lib/hecks.rb
 - lib/hecks/adapters.rb
 - lib/hecks/adapters/driven.rb
@@ -94,17 +96,6 @@ files:
 - lib/hecks/behaviors/ir.rb
 - lib/hecks/behaviors/rspec.rb
 - lib/hecks/behaviors/runner.rb
-- lib/hecks/bench.rb
-- lib/hecks/bench/cli.rb
-- lib/hecks/bench/environment.rb
-- lib/hecks/bench/postgres_probe.rb
-- lib/hecks/bench/report.rb
-- lib/hecks/bench/ruby_runner.rb
-- lib/hecks/bench/run.rb
-- lib/hecks/bench/rust_runner.rb
-- lib/hecks/bench/stats.rb
-- lib/hecks/bench/suite.rb
-- lib/hecks/bench/workload.rb
 - lib/hecks/bluebook.rb
 - lib/hecks/bluebook/aggregate.rb
 - lib/hecks/bluebook/assembly.rb
@@ -199,13 +190,22 @@ files:
 - lib/hecks/bluebook/synthesizer.rb
 - lib/hecks/bluebook/translation.rb
 - lib/hecks/bluebook/value_object.rb
-- lib/hecks/codemod.rb
+- lib/hecks/cache_dir.rb
+- lib/hecks/cli.rb
+- lib/hecks/cli/document.rb
+- lib/hecks/cli/ir.rb
+- lib/hecks/cli/mcp.rb
+- lib/hecks/cli/mcp_door.rb
+- lib/hecks/cli/model_check.rb
+- lib/hecks/cli/project_cli.rb
+- lib/hecks/cli/project_diagrams.rb
+- lib/hecks/cli/run.rb
+- lib/hecks/cli/smoke_test.rb
+- lib/hecks/cli/stores.rb
 - lib/hecks/construct.rb
-- lib/hecks/corpus.rb
 - lib/hecks/deploy/bluebook/deploy.bluebook
 - lib/hecks/deploy/bluebook/deploy.hecksagon
 - lib/hecks/deploy/oidc.json
-- lib/hecks/doc/reference.rb
 - lib/hecks/embryonaut_bluebook.rb
 - lib/hecks/embryonaut_bluebook/lock.rb
 - lib/hecks/embryonaut_bluebook/shape.rb
@@ -246,47 +246,7 @@ files:
 - lib/hecks/framework/bluebook/privacy.bluebook
 - lib/hecks/framework/oidc.json
 - lib/hecks/freezer.rb
-- lib/hecks/fuzzing.rb
-- lib/hecks/fuzzing/bounded_exhaustive_expressions.rb
-- lib/hecks/fuzzing/combination_miner.rb
-- lib/hecks/fuzzing/concurrent_dispatch.rb
-- lib/hecks/fuzzing/coverage_campaign.rb
-- lib/hecks/fuzzing/differential.rb
-- lib/hecks/fuzzing/domain_generator.rb
-- lib/hecks/fuzzing/era_boundary.rb
-- lib/hecks/fuzzing/form_census.rb
-- lib/hecks/fuzzing/generated_domain_check.rb
-- lib/hecks/fuzzing/invalid_value_generator.rb
-- lib/hecks/fuzzing/isolated_boot.rb
-- lib/hecks/fuzzing/nondeterministic.rb
-- lib/hecks/fuzzing/persistence_parity.rb
-- lib/hecks/fuzzing/properties.rb
-- lib/hecks/fuzzing/properties/corrections.rb
-- lib/hecks/fuzzing/properties/dispatch_and_mutations.rb
-- lib/hecks/fuzzing/properties/guards.rb
-- lib/hecks/fuzzing/properties/invariants_and_aggregation.rb
-- lib/hecks/fuzzing/properties/lifecycle_and_replay.rb
-- lib/hecks/fuzzing/properties/outbox.rb
-- lib/hecks/fuzzing/properties/querying.rb
-- lib/hecks/fuzzing/qa_settings.rb
-- lib/hecks/fuzzing/replay.rb
-- lib/hecks/fuzzing/rotation_priority.rb
-- lib/hecks/fuzzing/rust_gap_manifest.rb
-- lib/hecks/fuzzing/self_consistency.rb
-- lib/hecks/fuzzing/sequence_generator.rb
-- lib/hecks/fuzzing/sequence_generator/adversary.rb
-- lib/hecks/fuzzing/sequence_generator/catalog.rb
-- lib/hecks/fuzzing/sequence_generator/outcome_tracker.rb
-- lib/hecks/fuzzing/sequence_generator/picker.rb
-- lib/hecks/fuzzing/sequence_generator/query_binding.rb
-- lib/hecks/fuzzing/sequence_generator/step_builder.rb
-- lib/hecks/fuzzing/shrinker.rb
-- lib/hecks/fuzzing/structural_skips.rb
-- lib/hecks/fuzzing/sweep_depth.rb
-- lib/hecks/fuzzing/target_capabilities.rb
-- lib/hecks/fuzzing/value_generator.rb
 - lib/hecks/grammar.rb
-- lib/hecks/grammar/evolve.rb
 - lib/hecks/grammar/expression.bluebook
 - lib/hecks/grammar/expression_operators.json
 - lib/hecks/grammar/grammar.hecksagon
@@ -318,6 +278,7 @@ files:
 - lib/hecks/language/world/wiring.bluebook
 - lib/hecks/language/world/world.bluebook
 - lib/hecks/literal.rb
+- lib/hecks/mcp_door_scope.rb
 - lib/hecks/mcp_stdio_guard.rb
 - lib/hecks/naming.rb
 - lib/hecks/ports.rb
@@ -360,6 +321,7 @@ files:
 - lib/hecks/ports/persistence/plugins/era/expected_era.rb
 - lib/hecks/ports/persistence/plugins/era/lineage.rb
 - lib/hecks/ports/persistence/plugins/era/postgres_era.rb
+- lib/hecks/ports/persistence/plugins/era/postgres_era/events.rb
 - lib/hecks/ports/persistence/plugins/era/postgres_era/lineage.rb
 - lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/era_store.rb
 - lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/field_cache.rb
@@ -460,7 +422,6 @@ files:
 - lib/hecks/projector/ir_projector.rb
 - lib/hecks/projector/narrate_projector.rb
 - lib/hecks/projector/target.rb
-- lib/hecks/query_ir.rb
 - lib/hecks/query_specification.rb
 - lib/hecks/query_specification/common/authorization_spec.rb
 - lib/hecks/query_specification/common/comparators.rb
@@ -481,6 +442,16 @@ files:
 - lib/hecks/query_specification/read_model/specification.rb
 - lib/hecks/release/gem_pin.rb
 - lib/hecks/release/gem_pin/published_versions.rb
+- lib/hecks/release/runner.rb
+- lib/hecks/release/runner/ci_publisher.rb
+- lib/hecks/release/runner/commands.rb
+- lib/hecks/release/runner/console.rb
+- lib/hecks/release/runner/gem_publisher.rb
+- lib/hecks/release/runner/git.rb
+- lib/hecks/release/runner/npm_publisher.rb
+- lib/hecks/release/runner/preflight.rb
+- lib/hecks/release/runner/published.rb
+- lib/hecks/release/runner/tagger.rb
 - lib/hecks/rendering.rb
 - lib/hecks/router.rb
 - lib/hecks/router/namespace_installer.rb

data/lib/hecks/bench/cli.rb

@@ -1,74 +0,0 @@
-require "optparse"
-require_relative "suite"
-require_relative "report"
-
-module Hecks
-  module Bench
-    # The command line behind `bin/bench`: parses flags, runs the `Suite`, prints the report.
-    #
-    # Kept in `lib/` so a spec can drive it with a tiny configuration and read what it
-    # prints, rather than shelling out to a script.
-    module CLI
-      # The defaults `bin/bench` runs with when no flag says otherwise.
-      DEFAULTS = { domains: %w[pizzas banking], targets: Suite::TARGETS, warmup: 200, iterations: 1000,
-                   runs: 3 }.freeze
-
-      module_function
-
-      # Runs the benchmark described by the command line and prints its report.
-      #
-      # @param argv [Array<String>] the command-line arguments
-      # @param out [#puts] where the report goes
-      # @param err [#puts] where progress and usage errors go
-      # @return [Integer] the process exit status: 0 on success, 2 for a usage error
-      def run(argv, out: $stdout, err: $stderr)
-        options = parse(argv)
-        result = Suite.call(options.fetch(:config), log: err)
-        out.puts(options[:format] == "json" ? Report.json(result) : Report.markdown(result))
-        File.write(options[:output], Report.json(result)) if options[:output]
-        0
-      rescue OptionParser::ParseError, ArgumentError => e
-        err.puts "bin/bench: #{e.message}"
-        2
-      end
-
-      # Turns command-line arguments into a configuration and output choices.
-      #
-      # @param argv [Array<String>] the command-line arguments
-      # @return [Hash{Symbol => Object}] `:config` (a `Suite::Config`), `:format` and `:output`
-      # @raise [OptionParser::ParseError] on an unknown or malformed flag
-      def parse(argv)
-        values = DEFAULTS.dup
-        extras = { format: "markdown", output: nil, rust_binary: nil }
-        parser(values, extras).parse(argv.dup)
-        { config: Suite::Config.new(**values, rust_binary: extras[:rust_binary]),
-          format: extras[:format], output: extras[:output] }
-      end
-
-      # Builds the flag parser.
-      #
-      # @param values [Hash{Symbol => Object}] the `Suite::Config` fields, filled in as flags parse
-      # @param extras [Hash{Symbol => Object}] the output choices, filled in as flags parse
-      # @return [OptionParser] the parser
-      def parser(values, extras)
-        OptionParser.new do |opts|
-          opts.banner = "usage: bin/bench [options]"
-          opts.on("--domain NAMES", Array, "pizzas, banking (default: both)") { |v| values[:domains] = v }
-          opts.on("--targets NAMES", Array, "#{Suite::TARGETS.join(', ')} (default: all)") { |v| values[:targets] = v }
-          opts.on("--iterations N", Integer, "timed cycles per run (default #{DEFAULTS[:iterations]})") do |v|
-            values[:iterations] = v
-          end
-          opts.on("--warmup N", Integer, "discarded cycles before timing (default #{DEFAULTS[:warmup]})") do |v|
-            values[:warmup] = v
-          end
-          opts.on("--runs N", Integer, "fresh boots per target, median reported (default #{DEFAULTS[:runs]})") do |v|
-            values[:runs] = v
-          end
-          opts.on("--rust-binary PATH", "use this `rust` binary instead of building one") { |v| extras[:rust_binary] = v }
-          opts.on("--format FORMAT", %w[markdown json], "markdown (default) or json") { |v| extras[:format] = v }
-          opts.on("--output PATH", "also write the full JSON result here") { |v| extras[:output] = v }
-        end
-      end
-    end
-  end
-end

data/lib/hecks/bench/environment.rb

@@ -1,100 +0,0 @@
-require "etc"
-require "open3"
-
-module Hecks
-  module Bench
-    # A description of the machine and toolchain a benchmark ran on.
-    #
-    # A number without its hardware is not reproducible, so every report carries
-    # this. Each probe is best effort: a missing tool becomes `"unknown"` rather
-    # than an error, since the benchmark itself is still valid without it.
-    module Environment
-      module_function
-
-      # Collects the machine and toolchain facts a report should carry.
-      #
-      # @return [Hash{Symbol => Object}] `:cpu`, `:cores`, `:memory_gib`, `:os`, `:ruby`,
-      #   `:yjit`, `:rustc`, `:cargo`, `:hecks`, `:commit` and `:load_average`
-      def describe
-        {
-          cpu: cpu, cores: Etc.nprocessors, memory_gib: memory_gib, os: os,
-          ruby: RUBY_DESCRIPTION, yjit: yjit?,
-          rustc: capture("rustc", "-V"), cargo: capture("cargo", "-V"),
-          hecks: Hecks::VERSION, commit: commit, load_average: load_average
-        }
-      end
-
-      # Reads the one-minute load average, the quickest sign that something else was
-      # busy while a benchmark ran. `Suite.call` reads it before and after and reports both.
-      #
-      # @return [Float, nil] the one-minute load average, or nil when it cannot be read
-      def load_average
-        text = RUBY_PLATFORM.include?("darwin") ? capture("sysctl", "-n", "vm.loadavg").delete("{}") : File.read("/proc/loadavg")
-        text.split.first.to_f.round(2)
-      rescue SystemCallError
-        nil
-      end
-
-      # Names the processor.
-      #
-      # @return [String] the CPU model, or `"unknown"`
-      def cpu
-        return capture("sysctl", "-n", "machdep.cpu.brand_string") if RUBY_PLATFORM.include?("darwin")
-
-        model = File.foreach("/proc/cpuinfo").find { |line| line.start_with?("model name") }
-        model ? model.split(":", 2).last.strip : "unknown"
-      rescue SystemCallError
-        "unknown"
-      end
-
-      # Reads installed memory.
-      #
-      # @return [Float, String] physical memory in GiB, or `"unknown"`
-      def memory_gib
-        bytes =
-          if RUBY_PLATFORM.include?("darwin")
-            capture("sysctl", "-n", "hw.memsize").to_i
-          else
-            File.read("/proc/meminfo")[/MemTotal:\s+(\d+)/, 1].to_i * 1024
-          end
-        bytes.zero? ? "unknown" : (bytes / (1024.0**3)).round(1)
-      rescue SystemCallError
-        "unknown"
-      end
-
-      # Names the operating system.
-      #
-      # @return [String] the OS name and version, or `"unknown"`
-      def os
-        return "macOS #{capture('sw_vers', '-productVersion')} (#{capture('uname', '-m')})" if RUBY_PLATFORM.include?("darwin")
-
-        capture("uname", "-sr")
-      end
-
-      # Says whether Ruby's `YJIT` compiler was running.
-      #
-      # @return [Boolean] true when `YJIT` is enabled in this process
-      def yjit?
-        defined?(RubyVM::YJIT) ? RubyVM::YJIT.enabled? : false
-      end
-
-      # Names the Hecks source revision under test.
-      #
-      # @return [String] the short commit hash, or `"unknown"` outside a git checkout
-      def commit
-        capture("git", "-C", File.expand_path("../../..", __dir__), "rev-parse", "--short", "HEAD")
-      end
-
-      # Runs a command and returns its first line of output.
-      #
-      # @param command [Array<String>] the program and its arguments
-      # @return [String] the trimmed first line of stdout, or `"unknown"` if it cannot run
-      def capture(*command)
-        out, status = Open3.capture2(*command, err: File::NULL)
-        status.success? && !out.strip.empty? ? out.lines.first.strip : "unknown"
-      rescue SystemCallError
-        "unknown"
-      end
-    end
-  end
-end

data/lib/hecks/bench/postgres_probe.rb

@@ -1,41 +0,0 @@
-module Hecks
-  module Bench
-    # Decides whether the Postgres targets can run at all.
-    #
-    # Postgres is optional. A machine with no server, or without the `pg` gem, gets a
-    # skipped target and a sentence saying why, never a stack trace. Connection
-    # settings come from libpq's own environment (`PGHOST`, `PGPORT`, `PGUSER`,
-    # `PGPASSWORD`), the same way the fuzzer's Postgres adapters read them.
-    module PostgresProbe
-      module_function
-
-      # Tries to reach the server's maintenance database.
-      #
-      # @return [String, nil] nil when a server answered, otherwise one sentence saying why
-      #   the Postgres targets cannot run
-      def unavailable_reason
-        require "pg"
-        PG.connect(dbname: "postgres", connect_timeout: 2).close
-        nil
-      rescue LoadError
-        "the `pg` gem is not installed"
-      rescue PG::Error => e
-        "no Postgres server is reachable (#{e.message.lines.first.to_s.strip}); start one, or point " \
-        "PGHOST, PGPORT and PGUSER at one"
-      end
-
-      # Reads the server's version for the report's environment block.
-      #
-      # @return [String] the `server_version` setting, or `"unknown"` if it cannot be read
-      def server_version
-        require "pg"
-        connection = PG.connect(dbname: "postgres", connect_timeout: 2)
-        connection.exec("SHOW server_version").getvalue(0, 0)
-      rescue LoadError, PG::Error
-        "unknown"
-      ensure
-        connection&.close
-      end
-    end
-  end
-end

data/lib/hecks/bench/report.rb

@@ -1,116 +0,0 @@
-require "json"
-
-module Hecks
-  module Bench
-    # Renders a `Suite.call` result as Markdown or JSON.
-    #
-    # The Markdown is what `docs/benchmarks.md` pastes in. It states the machine, the
-    # counts and the skipped targets next to the table, so a copied table is never a
-    # bare number.
-    module Report
-      module_function
-
-      # Renders the whole report as Markdown.
-      #
-      # @param result [Hash] the value `Suite.call` returned
-      # @return [String] the environment, the configuration, the table and any skipped targets
-      def markdown(result)
-        [environment_block(result[:environment]), configuration_block(result[:config]),
-         table(result[:results]), floor_block(result[:results]), skipped_block(result[:skipped])]
-          .compact.join("\n\n") << "\n"
-      end
-
-      # Renders the whole report as JSON.
-      #
-      # @param result [Hash] the value `Suite.call` returned
-      # @return [String] pretty-printed JSON of `result`
-      def json(result)
-        JSON.pretty_generate(result)
-      end
-
-      # Renders the results table.
-      #
-      # @param results [Array<Hash>] the `:results` of `Suite.call`
-      # @return [String] a Markdown table with one row per domain and target
-      def table(results)
-        header = ["| domain | target | commands/s | range across runs | p50 (us) | p99 (us) | drift |",
-                  "|---|---|---:|---:|---:|---:|---:|"]
-        (header + results.map { |entry| row(entry) }).join("\n")
-      end
-
-      # Renders one table row.
-      #
-      # @param entry [Hash] one aggregated result
-      # @return [String] the row as Markdown
-      def row(entry)
-        median = entry[:median]
-        low, high = entry[:throughput_range]
-        cells = [entry[:domain], entry[:target], number(median[:throughput_per_s], 0),
-                 "#{number(low, 0)} to #{number(high, 0)}", number(median[:p50_us], 1),
-                 number(median[:p99_us], 1), number(median[:drift], 2)]
-        "| #{cells.join(' | ')} |"
-      end
-
-      # Formats a number with thousands separators.
-      #
-      # @param value [Numeric, nil] the number
-      # @param places [Integer] digits after the decimal point
-      # @return [String] the formatted number, or `"n/a"` for nil
-      def number(value, places)
-        return "n/a" if value.nil?
-
-        whole, fraction = format("%.#{places}f", value).split(".")
-        [whole.gsub(/(\d)(?=(\d{3})+\z)/, '\1,'), fraction].compact.join(".")
-      end
-
-      # Renders the machine and toolchain.
-      #
-      # @param environment [Hash] the `:environment` of `Suite.call`
-      # @return [String] a Markdown bullet list
-      def environment_block(environment)
-        load = environment[:load_average]
-        lines = [
-          "- CPU: #{environment[:cpu]} (#{environment[:cores]} cores), #{environment[:memory_gib]} GiB",
-          "- OS: #{environment[:os]}",
-          "- Ruby: #{environment[:ruby]} (YJIT #{environment[:yjit] ? 'on' : 'off'})",
-          "- Rust: #{environment[:rustc]}; #{environment[:cargo]}",
-          "- Hecks: #{environment[:hecks]} at #{environment[:commit]}",
-          "- Load average (1 min) before and after: #{load[:before]} and #{load[:after]}"
-        ]
-        lines << "- Postgres: #{environment[:postgres]}" if environment[:postgres]
-        lines.join("\n")
-      end
-
-      # Renders how hard the run pushed.
-      #
-      # @param config [Hash] the `:config` of `Suite.call`
-      # @return [String] one sentence with the warmup, iteration and run counts
-      def configuration_block(config)
-        "Warmup #{config[:warmup]} cycles, then #{config[:iterations]} timed cycles per run, " \
-          "median of #{config[:runs]} run(s), domains: #{config[:domains].join(', ')}."
-      end
-
-      # Renders the Rust round-trip floor, if a Rust target ran.
-      #
-      # @param results [Array<Hash>] the `:results` of `Suite.call`
-      # @return [String, nil] a sentence naming each domain's floor, or nil without a Rust result
-      def floor_block(results)
-        floors = results.select { |entry| entry[:target] == "rust" }
-                        .map { |entry| "#{entry[:domain]} #{number(entry[:median][:roundtrip_floor_p50_us], 1)} us" }
-        return nil if floors.empty?
-
-        "Rust pipe round-trip floor (p50, a step refused at once): #{floors.join(', ')}."
-      end
-
-      # Renders the targets that did not run.
-      #
-      # @param skipped [Array<Hash>] the `:skipped` of `Suite.call`
-      # @return [String, nil] one line per skipped target, or nil when none were skipped
-      def skipped_block(skipped)
-        return nil if skipped.empty?
-
-        (["Skipped:"] + skipped.map { |entry| "- #{entry[:target]}: #{entry[:reason]}" }).join("\n")
-      end
-    end
-  end
-end