hecks 3.4.2 → 3.6.0

data/lib/hecks/fuzzing/sequence_generator/step_builder.rb

@@ -4,6 +4,8 @@ require_relative "../value_generator"
 require_relative "../../runtime/errors"
 require_relative "../../runtime/value"
 require_relative "../../naming"
+require_relative "argument_drawing"
+require_relative "identity_shaping"
 
 module Hecks
   module Fuzzing
@@ -12,6 +14,9 @@ module Hecks
       # occasionally malform exactly one of them, shape its identity, and
       # dispatch it for real.
       module StepBuilder
+        include ArgumentDrawing
+        include IdentityShaping
+
         private
 
         def build_query_step(runtime, entry)
@@ -39,163 +44,54 @@ module Hecks
         # The caller draw and then the dry-run coin follow the mutation. The order
         # is part of the seed contract; both draw nothing when off.
         def build_command_step(runtime, catalog, entry)
-          args = args_for(entry[:command].attributes, entry[:aggregate], needed: entry[:command].needs.map(&:to_s))
-          add_identity!(args, entry)
-          steer_grant!(args, entry, catalog)
+          args = command_args(entry, catalog)
           mutations = adversarial_mutations!(args, entry, catalog)
           caller, caller_note = caller_draw!(entry, catalog)
           mutations << caller_note if caller_note
           @state_before = state_before(runtime, entry, args)
 
-          step =
-            if dry_run_draw?
-              safe_call { as_caller(caller) { runtime.dry_run?(entry[:verb], **symbolize(args)) } }
-              { "dry_run" => entry[:verb], "args" => args }
-            else
-              outcome = safe_call { as_caller(caller) { runtime.dispatch_flat(entry[:verb], symbolize(args)) } }
-              if outcome
-                record_outcome(catalog, entry, args)
-                harvest_written_rows(runtime, catalog)
-                @event_count += outcome.events.length
-              end
-              { "verb" => entry[:verb], "args" => args }
-            end
+          step = dispatch_step(runtime, catalog, entry, args, caller)
           step.merge!(caller) if caller
           step["adversarial"] = mutations unless mutations.empty?
           step
         end
 
-        # Draws nothing when the fraction is zero, like `adversarial?`.
-        def dry_run_draw? = @dry_run.positive? && @random.rand < @dry_run
-
-        # Runs the block under `Hecks.as_caller`, the binding `Fuzzing::Replay` makes
-        # from the step's keys, or yields bare when there is no caller.
-        def as_caller(caller, &)
-          return yield unless caller
-
-          Hecks.as_caller(role: caller["role"], actor_id: caller["actor_id"], &)
-        end
-
-        # `needed` names the facts the runtime answers when a step leaves them out; a malformation
-        # never drops one, since each engine would fill it from its own clock.
-        def args_for(attributes, aggregate, needed: [])
-          args = attributes.each_with_object({}) do |attribute, built|
-            # Omitting an optional argument is an ordinary payload, not a malformation
-            # (see OPTIONAL_OMITTED_PROBABILITY).
-            next if attribute.optional? && @random.rand < SequenceGenerator::OPTIONAL_OMITTED_PROBABILITY
-
-            if attribute.list?
-              value = list_value_for(attribute, aggregate)
-              # `list_value_for` answers nil for a list of entities (those are
-              # populated by per-element append commands), so the step skips it.
-              next if value.nil?
-
-              built[attribute.name.to_s] = value
-            else
-              built[attribute.name.to_s] = ValueGenerator.value_for(attribute, aggregate, random: @random, known_ids: @known_ids)
-            end
-          end
-
-          malform(args, attributes, aggregate, needed)
-        end
-
-        # An array of 0-3 independently generated elements shaped like the bare
-        # element type. `nil`, not `[]`, when the element type is not a value object.
-        def list_value_for(attribute, aggregate)
-          value_object = Runtime::Value.value_object_for(aggregate, attribute.type.to_s)
-          return nil unless value_object
-
-          Array.new(@random.rand(0..3)) { ValueGenerator.value_for(attribute, aggregate, random: @random, known_ids: @known_ids) }
+        # The arguments of a command step before any adversarial mutation: drawn, then given an
+        # identity, then steered toward a grantable role.
+        def command_args(entry, catalog)
+          args = args_for(entry[:command].attributes, entry[:aggregate], needed: entry[:command].needs.map(&:to_s))
+          add_identity!(args, entry)
+          steer_grant!(args, entry, catalog)
+          args
         end
 
-        # At most one malformation per step, so the check that fired is identifiable.
-        # The rate stays low because refused steps reach no state.
-        def malform(args, attributes, aggregate, needed)
-          return args if args.empty? || @random.rand >= MALFORMED_ARGUMENT_PROBABILITY
-
-          case @random.rand(3)
-          when 0 then corrupt_one(args, attributes, aggregate)
-          when 1 then drop_one(args, aggregate, needed)
-          else        args.merge([InvalidValueGenerator.undeclared_argument(random: @random)].to_h)
+        # Dispatches the step for real, or as a dry run when the coin says so.
+        def dispatch_step(runtime, catalog, entry, args, caller)
+          if dry_run_draw?
+            safe_call { as_caller(caller) { runtime.dry_run?(entry[:verb], **symbolize(args)) } }
+            return { "dry_run" => entry[:verb], "args" => args }
           end
-        end
-
-        # Never drops the identity: an auto-minted id is unreproducible, so the
-        # step's outcome could not be replayed.
-        def drop_one(args, aggregate, needed)
-          identity  = (aggregate.identified_by || :id).to_s
-          droppable = args.keys - [identity, "id"] - needed
-          return args if droppable.empty?
 
-          args.reject { |name, _| name == droppable.sample(random: @random) }
+          outcome = safe_call { as_caller(caller) { runtime.dispatch_flat(entry[:verb], symbolize(args)) } }
+          record_dispatch(runtime, catalog, entry, args, outcome) if outcome
+          { "verb" => entry[:verb], "args" => args }
         end
 
-        def corrupt_one(args, attributes, aggregate)
-          named = attributes.reject(&:list?).select { |attribute| args.key?(attribute.name.to_s) }
-          return args if named.empty?
-
-          attribute = named.sample(random: @random)
-          args.merge(attribute.name.to_s => InvalidValueGenerator.corrupt(attribute, aggregate, random: @random))
+        def record_dispatch(runtime, catalog, entry, args, outcome)
+          record_outcome(catalog, entry, args)
+          harvest_written_rows(runtime, catalog)
+          @event_count += outcome.events.length
         end
 
-        def add_identity!(args, entry)
-          aggregate = entry[:aggregate]
-          parent_key = (aggregate.identified_by || :id).to_s
-
-          if entry[:entity]
-            parent_scalar = pick_known(aggregate.hecks_name)
-            args[parent_key] = identity_shaped(aggregate, aggregate.identified_by, parent_scalar, aggregate)
-            # One identity per hop, drawn from that hop's pool (`entity_pool_key`), as
-            # flat args, which is what `EntityElement#locate_chain` reads.
-            scalars = [parent_scalar]
-            names   = []
-            entry[:chain].each do |piece|
-              names << piece.hecks_name
-              scalar = pick_entity_known(entity_pool_key(aggregate.hecks_name, names, scalars))
-              args[(piece.identified_by || :id).to_s] = identity_shaped(piece, piece.identified_by, scalar, aggregate)
-              scalars << scalar
-            end
-          elsif entry[:command].creates?
-            # A composite identity's parts are already generated as the command's own
-            # attributes; a synthetic `id` would be refused as an undeclared argument.
-            unless composite_identity?(aggregate)
-              args[parent_key] ||= identity_shaped(aggregate, aggregate.identified_by, ValueGenerator.random_id(@random),
-                                                   aggregate)
-            end
-          else
-            scalar = pick_known(aggregate.hecks_name)
-            args[parent_key] = identity_shaped(aggregate, aggregate.identified_by, scalar, aggregate)
-          end
-        end
-
-        # True only for a multi-field identity: `identified_by` is also nil for the
-        # untyped default, whose parts are not in `args`.
-        def composite_identity?(aggregate) = aggregate.identified_by.nil? && aggregate.identity_paths.size > 1
-
-        # Shapes a bare scalar id like the construct's identity field. A
-        # value-object-typed identity given a bare scalar is a TypeMismatch, so it
-        # must be wrapped; the untyped default `:id` stays bare.
-        def identity_shaped(construct, key, scalar, aggregate)
-          return scalar unless key
-
-          attribute = construct.attribute(key)
-          return scalar unless attribute
-
-          value_object = aggregate.value_object(attribute.type.to_s)
-          return scalar unless value_object
-
-          field = value_object.attributes.first
-          return scalar unless field
+        # Draws nothing when the fraction is zero, like `adversarial?`.
+        def dry_run_draw? = @dry_run.positive? && @random.rand < @dry_run
 
-          { field.name.to_s => coerce_scalar(field.type.to_s, scalar) }
-        end
+        # Runs the block under `Hecks.as_caller`, the binding `Fuzzing::Replay` makes
+        # from the step's keys, or yields bare when there is no caller.
+        def as_caller(caller, &)
+          return yield unless caller
 
-        def coerce_scalar(type_name, scalar)
-          case type_name
-          when "Integer" then scalar.to_i
-          when "Float"   then scalar.to_f
-          else scalar.to_s
-          end
+          Hecks.as_caller(role: caller["role"], actor_id: caller["actor_id"], &)
         end
 
         def symbolize(args) = args.transform_keys(&:to_sym)
@@ -217,15 +113,10 @@ module Hecks
         # The addressed aggregate's lifecycle value before this dispatch, or
         # `exists`/`absent`; `?` when a mutation mangled the identity. Draws nothing from the RNG.
         def state_before(runtime, entry, args)
-          aggregate = entry[:aggregate]
-          symbolic  = symbolize(args)
-          id = Runtime::Identity.of(aggregate, symbolic) || Runtime::Identity.from(aggregate, symbolic, :id)
-          return "absent" unless id
-
-          record = runtime.registry.repository(entry[:verb].split("::").first, aggregate).find(id)
+          record = addressed_record(runtime, entry, args)
           return "absent" unless record
 
-          lifecycle = aggregate.lifecycle
+          lifecycle = entry[:aggregate].lifecycle
           return "exists" unless lifecycle
 
           key = record.state.key?(lifecycle.field) ? lifecycle.field : lifecycle.field.to_s
@@ -233,6 +124,14 @@ module Hecks
         rescue StandardError
           "?"
         end
+
+        # The stored record the step's identity args address, or nil.
+        def addressed_record(runtime, entry, args)
+          aggregate = entry[:aggregate]
+          symbolic  = symbolize(args)
+          id = Runtime::Identity.of(aggregate, symbolic) || Runtime::Identity.from(aggregate, symbolic, :id)
+          id && runtime.registry.repository(entry[:verb].split("::").first, aggregate).find(id)
+        end
       end
     end
   end

data/lib/hecks/fuzzing/sequence_generator.rb

@@ -9,6 +9,7 @@ require_relative "sequence_generator/step_builder"
 require_relative "sequence_generator/outcome_tracker"
 require_relative "sequence_generator/query_binding"
 require_relative "sequence_generator/adversary"
+require_relative "sequence_generator/prefixing"
 
 module Hecks
   module Fuzzing
@@ -22,6 +23,7 @@ module Hecks
       include OutcomeTracker
       include QueryBinding
       include Adversary
+      include Prefixing
 
       # Creating commands are always eligible; weighting them up reaches an actionable
       # state sooner without starving domains that have few aggregates.
@@ -76,42 +78,24 @@ module Hecks
       # script's `expectations.events` claim. Zero means no interesting state was reached.
       attr_reader :event_count
 
+      # The keywords `.new` takes beyond `seed:` and `steps:`, with their defaults.
+      OPTION_DEFAULTS = { adapter: :memory, adversarial: 0.0, role_draw: 0.0, dry_run: 0.0,
+                          prefix: nil, favor: [] }.freeze
+
       # Takes the same keywords as `.generate`, plus `adapter:` (default `:memory`).
       #
       # @raise [ArgumentError] if `adversarial`, `role_draw`, or `dry_run` is not a
-      #   Numeric between 0.0 and 1.0
-      def initialize(domain_path, seed:, steps:, adapter: :memory, adversarial: 0.0, role_draw: 0.0, dry_run: 0.0,
-                     prefix: nil, favor: [])
-        { adversarial: adversarial, role_draw: role_draw, dry_run: dry_run }.each do |name, fraction|
-          next if fraction.is_a?(Numeric) && fraction.between?(0, 1)
-
-          raise ArgumentError, "#{name}: must be a fraction between 0.0 and 1.0, got #{fraction.inspect}"
-        end
-
-        @domain_path         = domain_path
-        @seed                = seed
-        @step_count          = steps
-        @adapter             = adapter
-        @adversarial         = adversarial.to_f
-        @role_draw           = role_draw.to_f
-        @dry_run             = dry_run.to_f
+      #   Numeric between 0.0 and 1.0, or a keyword is not one `.new` takes
+      def initialize(domain_path, seed:, steps:, **options)
+        settings = OPTION_DEFAULTS.merge(options)
+        validate_options!(settings)
+
+        @domain_path = domain_path
+        @seed        = seed
+        @step_count  = steps
+        configure(settings)
         restart_random(seed)
-        @known_ids           = Hash.new { |h, k| h[k] = [] }
-        @entity_known_ids    = Hash.new { |h, k| h[k] = [] }
-        @appended_identities = Hash.new { |h, k| h[k] = [] }
-        # "Domain::Aggregate" => stored rows a query filters on (query_binding.rb).
-        @written_rows        = Hash.new { |h, k| h[k] = [] }
-        # Role => actor ids granted by this sequence's own `RoleAssignment.Assign` steps.
-        @granted             = Hash.new { |h, k| h[k] = [] }
-        @precedence_caller   = nil
-        @exercised           = Set.new
-        @event_count         = 0
-        @prefix              = prefix
-        @favor               = Array(favor)
-        @own_favor           = @favor
-        @coverage            = []
-        @verbs               = []
-        @attempt             = 0
+        reset_run_state
       end
 
       # Runs the generation against a fresh, isolated boot of the domain.
@@ -125,41 +109,56 @@ module Hecks
           catalog = build_catalog(runtime)
           @verbs  = catalog.values_at(:creating, :instance, :entity_commands, :queries, :entity_queries, :read_models)
                            .flatten.map { |entry| entry[:verb] }.uniq
-
-          steps = []
-          if @prefix
-            realize_prefix(runtime, catalog, @prefix, prefix_limit(@prefix), steps)
-            restart_random(@seed)
-            @favor = @own_favor
-          end
-          @step_count.times { steps << attempt_step(runtime, catalog) }
-          steps.compact
+          generate_steps(runtime, catalog)
         end
       end
 
       private
 
-      # Re-runs the first `limit` attempts of another seed's generation (its own prefix
-      # first), carrying its known ids and exercised verbs into this seed. The prefix is
-      # on top of this seed's budget: taking it out of the budget left too little to explore.
-      def realize_prefix(runtime, catalog, spec, limit, steps)
-        return 0 unless limit.positive?
-
-        inner = spec["prefix"]
-        used  = inner ? realize_prefix(runtime, catalog, inner, [prefix_limit(inner), limit].min, steps) : 0
-        restart_random(Integer(spec.fetch("seed")))
-        @favor = Array(spec["favor"])
-        (limit - used).times { steps << attempt_step(runtime, catalog) }
-        limit
+      def validate_options!(settings)
+        unknown = settings.keys - OPTION_DEFAULTS.keys
+        raise ArgumentError, "unknown keyword: #{unknown.first.inspect}" if unknown.any?
+
+        settings.slice(:adversarial, :role_draw, :dry_run).each do |name, fraction|
+          next if fraction.is_a?(Numeric) && fraction.between?(0, 1)
+
+          raise ArgumentError, "#{name}: must be a fraction between 0.0 and 1.0, got #{fraction.inspect}"
+        end
       end
 
-      # Both streams restart together so a prefix replay draws the same query bindings.
-      def restart_random(seed)
-        @random         = Random.new(seed)
-        @binding_random = Random.new(seed + QueryBinding::BINDING_SEED_OFFSET)
+      def configure(settings)
+        @adapter     = settings[:adapter]
+        @adversarial = settings[:adversarial].to_f
+        @role_draw   = settings[:role_draw].to_f
+        @dry_run     = settings[:dry_run].to_f
+        @prefix      = settings[:prefix]
+        @favor       = Array(settings[:favor])
+        @own_favor   = @favor
       end
 
-      def prefix_limit(spec) = Integer(spec.fetch("steps")).clamp(0, @step_count)
+      # Everything a run accumulates: the ids it has seen, the rows it has written, what it has
+      # exercised, and the coverage it has reached.
+      def reset_run_state
+        @known_ids           = new_pool
+        @entity_known_ids    = new_pool
+        @appended_identities = new_pool
+        # "Domain::Aggregate" => stored rows a query filters on (query_binding.rb).
+        @written_rows        = new_pool
+        # Role => actor ids granted by this sequence's own `RoleAssignment.Assign` steps.
+        @granted             = new_pool
+        reset_progress
+      end
+
+      def reset_progress
+        @precedence_caller = nil
+        @exercised         = Set.new
+        @event_count       = 0
+        @coverage          = []
+        @verbs             = []
+        @attempt           = 0
+      end
+
+      def new_pool = Hash.new { |h, k| h[k] = [] }
 
       def attempt_step(runtime, catalog)
         index = @attempt
@@ -169,15 +168,18 @@ module Hecks
 
         @exercised << entry[:verb]
         @state_before = "-"
-        step =
-          if entry[:query]    then build_query_step(runtime, entry)
-          elsif entry[:model] then build_read_model_step(runtime, entry)
-          else                     build_command_step(runtime, catalog, entry)
-          end
+        step = build_step(runtime, catalog, entry)
         @coverage << [index, coverage_tuple(entry, step)]
         step
       end
 
+      def build_step(runtime, catalog, entry)
+        if entry[:query]    then build_query_step(runtime, entry)
+        elsif entry[:model] then build_read_model_step(runtime, entry)
+        else                     build_command_step(runtime, catalog, entry)
+        end
+      end
+
       # `verb | kind | state before | mutation | outcome`; see CoverageCampaign.
       def coverage_tuple(entry, step)
         kind     = %w[verb query dry_run].find { |key| step.key?(key) }

data/lib/hecks/fuzzing/shrinker.rb

@@ -33,35 +33,34 @@ module Hecks
         current = steps
         chunk = [current.length / 2, 1].max
         loop do
-          changed = false
-          index = 0
-          while index < current.length
-            return current if meter.exhausted?
-
-            candidate = current[0...index] + (current[(index + chunk)..] || [])
-            if candidate.empty?
-              index += chunk
-              next
-            end
-
-            if meter.try { reproduces.call(candidate) }
-              current = candidate
-              changed = true
-            else
-              index += chunk
-            end
-          end
+          swept = sweep(current, chunk, meter, &reproduces)
+          changed = swept.length < current.length
+          current = swept
+          return current if meter.exhausted? || (chunk == 1 && !changed)
+
+          chunk = [chunk / 2, 1].max
+        end
+      end
 
-          if chunk > 1
-            chunk = [chunk / 2, 1].max
-          elsif !changed
-            break
+      # One pass removing `chunk` steps at a time; a removal that still reproduces is kept.
+      #
+      # @return [Array<Hash>] the surviving steps
+      def sweep(current, chunk, meter, &)
+        index = 0
+        while index < current.length && !meter.exhausted?
+          candidate = without_chunk(current, index, chunk)
+          if !candidate.empty? && meter.try { yield(candidate) }
+            current = candidate
+          else
+            index += chunk
           end
         end
         current
       end
 
-      def drop_arguments(steps, meter, &reproduces)
+      def without_chunk(steps, index, chunk) = steps[0...index] + (steps[(index + chunk)..] || [])
+
+      def drop_arguments(steps, meter, &)
         steps.each_index do |position|
           original = args_of(steps[position])
           next unless original.is_a?(Hash)
@@ -69,16 +68,21 @@ module Hecks
           original.each_key do |key|
             return steps if meter.exhausted?
 
-            step      = steps[position]
-            trimmed   = args_of(step).reject { |name, _| name == key }
-            candidate = steps.map(&:dup)
-            candidate[position] = step.merge("args" => trimmed)
-            steps = candidate if meter.try { reproduces.call(candidate) }
+            candidate = without_argument(steps, position, key)
+            steps = candidate if meter.try { yield(candidate) }
           end
         end
         steps
       end
 
+      # A copy of `steps` whose step at `position` lacks the argument `key`.
+      def without_argument(steps, position, key)
+        step = steps[position]
+        candidate = steps.map(&:dup)
+        candidate[position] = step.merge("args" => args_of(step).reject { |name, _| name == key })
+        candidate
+      end
+
       # `key?` first, never `||`, which cannot tell a stored `false` from an absent key.
       def args_of(step)
         step.key?("args") ? step["args"] : step[:args]
@@ -127,7 +131,7 @@ module Hecks
         return [] unless left.is_a?(Hash) && right.is_a?(Hash)
 
         (left.keys | right.keys).reject { |key| left[key] == right[key] }
-                                .map { |key| "instances:#{key.to_s.split('#').first}" }
+                                .map { |key| "instances:#{key.to_s.split("#").first}" }
       end
 
       # True when the candidate's signature contains the original's.

data/lib/hecks/fuzzing/target_capabilities.rb

@@ -64,10 +64,16 @@ module Hecks
         capabilities << "postgres_era" if postgres_era_bound?(domain_path)
         capabilities << "translations" if Dir.glob(File.join(domain_path, "**", "translations", "*.bluebook")).any?
         capabilities << "governance" if authorization_attached?(domain_path)
-        capabilities << "role_gated" if any_file?(domain_path, "*.bluebook", ROLE_GATED)
-        capabilities << "tenant" if any_file?(domain_path, "*.bluebook", TENANT_SCOPED)
-        capabilities << "sagas" if any_file?(domain_path, "*.bluebook", PROCESS_MANAGER)
-        capabilities.sort
+        capabilities.concat(declared_capabilities(domain_path)).sort
+      end
+
+      # The capabilities a target's own bluebooks declare, by the construct each one spells.
+      #
+      # @param domain_path [String] filesystem path to the target domain's directory
+      # @return [Array<String>] `role_gated`, `tenant` and `sagas`, for those the bluebooks declare
+      def declared_capabilities(domain_path)
+        { "role_gated" => ROLE_GATED, "tenant" => TENANT_SCOPED, "sagas" => PROCESS_MANAGER }
+          .select { |_, pattern| any_file?(domain_path, "*.bluebook", pattern) }.keys
       end
 
       # Answers whether `mode` can run against a target with `capabilities`.

data/lib/hecks/fuzzing/value_generator.rb

@@ -64,21 +64,31 @@ module Hecks
       # @return [Hash, Object] `{field name => value, ...}`, or the lone value when the
       #   value object has one field and the bare-scalar draw hits
       def object_for(value_object, aggregate, random:, known_ids:)
-        fields =
-          if value_object.closed_set? && !value_object.members.empty?
-            return invalid_member(value_object, random: random) if random.rand < INVALID_MEMBER_PROBABILITY
-
-            member = value_object.members.sample(random: random)
-            member.to_h { |field, value| [field.to_s, value] }
-          else
-            value_object.attributes.to_h do |field|
-              [field.name.to_s,
-               value_for(field, aggregate, random: random, known_ids: known_ids, context: value_object.hecks_name)]
-            end
-          end
-
-        # Unwrap only a genuinely single-field value object, never `invalid_member`: a wrong
-        # combination stays a Hash so its wrongness is what gets exercised.
+        if value_object.closed_set? && !value_object.members.empty?
+          return invalid_member(value_object, random: random) if random.rand < INVALID_MEMBER_PROBABILITY
+
+          return bare_or_hash(admitted_member(value_object, random), random)
+        end
+
+        bare_or_hash(attribute_fields(value_object, aggregate, random: random, known_ids: known_ids), random)
+      end
+
+      # One admitted row of a closed set, keyed by field name.
+      def admitted_member(value_object, random)
+        value_object.members.sample(random: random).to_h { |field, value| [field.to_s, value] }
+      end
+
+      # A value per declared attribute, keyed by attribute name.
+      def attribute_fields(value_object, aggregate, random:, known_ids:)
+        value_object.attributes.to_h do |field|
+          [field.name.to_s,
+           value_for(field, aggregate, random: random, known_ids: known_ids, context: value_object.hecks_name)]
+        end
+      end
+
+      # Unwrap only a genuinely single-field value object, never `invalid_member`: a wrong
+      # combination stays a Hash so its wrongness is what gets exercised.
+      def bare_or_hash(fields, random)
         return fields.values.first if fields.size == 1 && random.rand < BARE_SCALAR_PROBABILITY
 
         fields
@@ -110,7 +120,7 @@ module Hecks
       #   draw hits
       def reference_value(attribute, random:, known_ids:)
         pool = known_ids[attribute.type.target_name.to_s] || []
-        return "missing-#{random.bytes(4).unpack1('H*')}" if pool.empty? || random.rand < INVALID_REFERENCE_PROBABILITY
+        return "missing-#{random.bytes(4).unpack1("H*")}" if pool.empty? || random.rand < INVALID_REFERENCE_PROBABILITY
 
         pool.sample(random: random)
       end
@@ -209,7 +219,7 @@ module Hecks
       # @param random [Random] the RNG driving every draw this call makes
       # @return [String] a `"gen-"`-prefixed id with 8 random hex characters
       def random_id(random)
-        "gen-#{random.bytes(4).unpack1('H*')}"
+        "gen-#{random.bytes(4).unpack1("H*")}"
       end
     end
   end

data/lib/hecks/gate/stages.yml

@@ -72,6 +72,16 @@ pre_push:
       run: [bundle, exec, exe/hecks, style_run.check_comments, "paths=lib,spec,examples", only=long_block, --wait]
       blocked: a comment block ran past the cap; shorten it.
 
+# The checks a push of only unguarded lanes (`main`) runs in place of pre_push. The slow suite is
+# skipped there; the style checks are not, since an offense that lands on `main` is a red CI run.
+unguarded_push:
+  env:
+    HECKS_ENVIRONMENT: memory
+  checks:
+    - *check_rubocop
+    - *check_comment_style
+    - *check_comment_blocks
+
 # The checks `.githooks/post-commit` runs after each commit. A red one is reported and never
 # blocks the commit; pre_push runs it again as the backstop.
 post_commit: