hecks 1.3.0 → 1.4.0

data/lib/hecks/fuzzing/structural_skips.rb

@@ -1,146 +1,39 @@
 module Hecks
   module Fuzzing
-    # WHAT A "NOT GENERATED FOR THIS DOMAIN" REFUSAL IS HIDING, PER VERB.
+    # What each query verb the differential comparison skipped was hiding.
     #
-    # `RustConformanceHelpers#structurally_refused_verbs` drops every named
-    # query/read model the compiled Rust kernel answers "is not generated
-    # for this domain" from BOTH sides of the differential comparison —
-    # correct (the refusal is codegen's own honest "I cannot execute this
-    # construct at all", `rust/project/queries.rb`'s and `read_models.rb`'s
-    # documented boundary), but SILENT: a sweep over a domain whose every
-    # `offset`/`cursor`/`group_by`/`count`/`median` ask was dropped reads
-    # as "agreed across all steps" with nothing on the record saying how
-    # much of the domain was never compared at all. Worse, the drop keys
-    # on Rust's wording alone, so a codegen regression that started
-    # refusing a plain wheres-only query the same way would ALSO vanish
-    # into "agreed" — the exact quiet divergence the practice hunts.
+    # `Differential.manifest_partition` drops a named query or read model
+    # from both sides of the Ruby/Rust comparison only when the binary's own
+    # manifest.json declares it `generated: false`. The drop is correct, but
+    # a sweep that dropped every `offset`/`cursor` ask would still read as
+    # "agreed across all steps". `bin/qa_sweep` therefore logs one Check per
+    # sweep naming every skipped verb and the construct family that caused
+    # it, and marks it Surprised when a family is outside
+    # `QualityControlDials::STRUCTURAL_REFUSAL_BOUNDARY`.
     #
-    # This module attributes each dropped verb to the constructs its OWN
-    # Ruby declaration carries, in the vocabulary `queries.rb`/
-    # `read_models.rb`'s skip reasons already use, so `bin/qa_sweep` can
-    # log one Check per sweep saying exactly which verbs were skipped and
-    # WHY — and mark it Surprised whenever a skipped verb declares nothing
-    # the dial `QualityControlDials::STRUCTURAL_REFUSAL_BOUNDARY` admits as
-    # a reason to skip (a wheres-only query on plain fields, a rooted
-    # read model with nothing but heads, a verb Ruby doesn't even declare).
-    #
-    # COARSER THAN CODEGEN'S OWN PREDICATE, ON PURPOSE. `query_where_skip_
-    # reason` decides per where clause from the field's resolved KIND
-    # (number/string/multi-member value object) — reproducing that here
-    # would be a second copy of codegen's typing rules, drifting on its
-    # own. Instead a literal-valued where is reported as `where_literal`,
-    # a family the dial admits, and only shapes with NO admitted family at
-    # all surprise. That trades some sensitivity for zero false surprises
-    # on today's corpus; the Check's observation still names every skipped
-    # verb with its constructs, so a human reading the sweep sees what was
-    # accepted and can narrow the dial when codegen grows.
+    # The construct comes straight from the manifest entry, written by the
+    # generator branch that made the skip (`Projector::SkipReason`). This
+    # module used to guess it from the Ruby declaration's `to_h` keys, which
+    # was coarser than codegen's own decision and could drift from it.
     module StructuralSkips
       module_function
 
-      # `Query#to_h`/`ReadModel#to_h` keys that, when present and
-      # non-empty, are constructs codegen documents as (conditionally or
-      # wholly) ungenerated — the same names as the dial's own vocabulary.
-      QUERY_OPTION_KEYS      = %i[order_by limit offset cursor consistency freshness authorization inspection
-                                  index_hints scope_to].freeze
-      READ_MODEL_OPTION_KEYS = %i[wheres order_by limit offset cursor consistency freshness authorization inspection
-                                  index_hints group_by count median_field].freeze
-
-      # One entry per skipped verb: `{ verb:, constructs: [...] }`, the
-      # constructs sorted so the printed observation is stable across
-      # seeds and runs.
-      def attribute(bluebooks, verbs)
-        verbs.sort.map { |verb| { verb: verb, constructs: constructs_of(bluebooks, verb) } }
+      # One entry per skipped verb: `{ verb:, constructs: [...] }`, sorted by
+      # verb so the printed observation is stable across seeds and runs. A
+      # verb the manifest doesn't declare answers `unknown`, which no
+      # boundary admits.
+      def attribute(gaps, verbs)
+        verbs.sort.map do |verb|
+          entry = gaps.not_generated(verb)
+          { verb: verb, constructs: entry ? [entry.fetch("construct")] : %w[unknown] }
+        end
       end
 
-      # Every skipped verb whose constructs are NOT all inside `boundary`
-      # — including a verb with no constructs at all (nothing explains the
-      # skip) and a verb Ruby never declared (`unknown`).
+      # Every skipped verb whose constructs are not all inside `boundary`.
       def outside_boundary(attributed, boundary)
         admitted = boundary.map(&:to_s)
         attributed.select { |entry| entry[:constructs].empty? || (entry[:constructs] - admitted).any? }
       end
-
-      def constructs_of(bluebooks, verb)
-        if verb.include?("::")
-          query = find_query(bluebooks, verb)
-          return %w[unknown] unless query
-
-          query_constructs(query)
-        else
-          model = find_read_model(bluebooks, verb)
-          return %w[unknown] unless model
-
-          read_model_constructs(model)
-        end
-      end
-
-      # "Domain::Aggregate.Query" or "Domain::Aggregate.Entity.Query" — the
-      # two named-query spellings `Fuzzing::SequenceGenerator`'s catalog
-      # generates (entity queries stay one hop deep there).
-      def find_query(bluebooks, verb)
-        domain, rest = verb.split("::", 2)
-        aggregate_name, *path = rest.to_s.split(".")
-        aggregate = bluebooks[domain]&.aggregate(aggregate_name)
-        return nil unless aggregate && path.any?
-
-        owner = aggregate
-        path[0...-1].each do |entity_name|
-          owner = owner.entities.find { |entity| entity.hecks_name == entity_name }
-          return nil unless owner
-        end
-        owner.query(path.last)
-      end
-
-      # "Domain.report_name" — the bare read-model form `Dispatcher#query`
-      # routes by the absence of "::".
-      def find_read_model(bluebooks, verb)
-        domain, name = verb.split(".", 2)
-        bluebooks[domain]&.read_models&.find { |model| model.query_name.to_s == name.to_s }
-      end
-
-      def query_constructs(query)
-        spec = query.to_h
-        constructs = QUERY_OPTION_KEYS.select { |key| present?(spec[key]) }.map(&:to_s)
-        constructs << "null_semantics" if spec[:null_semantics] && spec[:null_semantics] != { mode: "native" }
-        constructs << "no_wheres" if Array(spec[:wheres]).empty?
-        constructs.concat(where_constructs(Array(spec[:wheres])))
-        constructs.uniq.sort
-      end
-
-      def read_model_constructs(model)
-        spec = model.to_h
-        constructs = READ_MODEL_OPTION_KEYS.select { |key| present?(spec[key]) }.map(&:to_s)
-        constructs << "null_semantics" if spec[:null_semantics] && spec[:null_semantics] != { mode: "native" }
-        constructs << "rootless" if model.reference_target.nil?
-        constructs.concat(where_constructs(Array(spec[:wheres])))
-        constructs.uniq.sort
-      end
-
-      # The where-clause families `query_where_skip_reason` refuses by:
-      # a `/` hop through a reference, a `.` walk into a nested field
-      # (an entity-scoped or value-object path codegen may not resolve),
-      # `none_in_state` (admitted by the vocabulary, deliberately not
-      # generated), and any literal (non-Symbol) value, whose true wire
-      # type codegen may not recover from the IR.
-      def where_constructs(wheres)
-        wheres.flat_map do |where|
-          field = where[:field].to_s
-          value = where[:value].to_s
-          families = []
-          families << "reference_hop_where" if field.include?("/")
-          families << "where_nested_field" if field.include?(".")
-          families << "where_none_in_state" if where[:op].to_s == "none_in_state"
-          families << "where_literal" unless value.start_with?(":")
-          families
-        end
-      end
-
-      def present?(value)
-        return false if value.nil? || value == false
-        return value.any? if value.respond_to?(:empty?)
-
-        true
-      end
     end
   end
 end

data/lib/hecks/fuzzing/sweep_depth.rb

@@ -1,13 +1,13 @@
 module Hecks
   module Fuzzing
-    # HOW HARD ONE SWEEP FUZZES, AS A FUNCTION OF `Target.clean_streak`
+    # How hard one sweep fuzzes, as a function of `Target.clean_streak`
     # (qa/bluebook/quality_control.bluebook — that attribute's own comment
     # says what the streak means). The sibling of `RotationPriority`: the
     # ledger holds the number, `QualityControlDials::WIDENING_TIERS` holds
     # the policy, and this module is where the two meet — a pure function
     # of both, nothing else read.
     #
-    # WHY THIS IS NOT IN `bin/qa_sweep` ANY MORE. It was — `WIDENING_TIERS`
+    # Why this is not in `bin/qa_sweep` any more. It was — `WIDENING_TIERS`
     # and `widen_for_streak` lived at the top of that script, which meant
     # policy data lived in a script (unlike every other dial, which lives
     # in the bluebook a human edits and reviews) and duplicated itself as
@@ -15,7 +15,7 @@ module Hecks
     # and `bin/qa_sweep` calls it the way it already calls
     # `RotationPriority.pick`.
     #
-    # PURE, DELIBERATELY — the same discipline `RotationPriority` keeps:
+    # **Pure, deliberately** — the same discipline `RotationPriority` keeps:
     # same streak in, same `[seeds, steps]` out, every time, which is what
     # lets a human predict what a given sweep is about to do before it
     # runs one. `tiers:` defaults to the dial but is a plain argument, so
@@ -26,7 +26,7 @@ module Hecks
     module SweepDepth
       module_function
 
-      # THE FALLBACK TABLE, for a boot with no `QualityControlDials` at all
+      # The fallback table, for a boot with no `QualityControlDials` at all
       # — the same shape and the same three rows the dial ships with, so a
       # dial-less ledger fuzzes exactly as a dialled one does by default.
       # Never read when the dial exists; `bin/qa_sweep` passes the dial in.

data/lib/hecks/fuzzing/target_capabilities.rb

@@ -1,30 +1,30 @@
 module Hecks
   module Fuzzing
-    # WHAT A SWEEP TARGET CAN ACTUALLY BE CHECKED FOR, read off the
+    # What a sweep target can actually be checked for, read off the
     # filesystem — never off a stored list.
     #
-    # `bin/qa_sweep` used to decide its ONE comparison mode inline: "is
+    # `bin/qa_sweep` used to decide its one comparison mode inline: "is
     # there a Cargo feature named after this directory? then
     # `:differential`, else `:ruby_only`", and a separate hand-typed abort
     # for `--persistence-parity` ("does any .hecksagon bind PostgresEra?").
     # Every further mode the practice adds (era boundary, concurrency, a
     # WASM front) would have grown one more inline `if`, each one a
     # policy decision hiding in a script. This module is those decisions
-    # as DATA: `MODE_REQUIREMENTS` says which capabilities each mode
+    # as data: `MODE_REQUIREMENTS` says which capabilities each mode
     # needs, `infer` says which capabilities a target's own directory
     # actually has, and `resolve` is the one rule that joins them —
     # `modes_to_run = enabled ∩ eligible`.
     #
-    # INFERENCE DECIDES; A STORED LIST ONLY RECORDS. `Target.capabilities`
+    # Inference decides; a stored list only records. `Target.capabilities`
     # (qa/bluebook/quality_control.bluebook, once PR-1's era lands) is
     # written by the runner from exactly this inference at release time
-    # so `Target.EligibleFor(mode)` can AUDIT the rotation from the
+    # so `Target.EligibleFor(mode)` can audit the rotation from the
     # ledger alone — but the runner re-infers every sweep, because a
     # stored list that lags yesterday's Cargo feature is precisely the
     # "quiet divergence" (the chapter's own opening comment) this whole
     # practice exists to hunt. Nothing here ever reads the ledger.
     #
-    # EVERY REGEX IS ONE THE HARNESS ALREADY OWNED, moved here rather than
+    # Every regex is one the harness already owned, moved here rather than
     # re-derived, and each one's provenance is named beside it so a
     # future edit to the original site is a visible drift, not a silent
     # one: the Cargo feature line (`RustConformanceHelpers#build_rust_for`),
@@ -45,10 +45,13 @@ module Hecks
       # domain-level default (`persisted_by "PostgresEra"`).
       POSTGRES_ERA_BINDING = /persisted_by\s*\(?\s*"PostgresEra"/
 
-      # `HecksagonBuilder#uses_framework` — the one line that attaches
-      # Governance's own `RoleAssignment` lookup to a domain's `role` checks
-      # (`CommandRules::Authorization#governance_attached?`).
-      GOVERNANCE_ATTACHED = /uses_framework\s*\(?\s*"Governance"/
+      # `HecksagonBuilder#uses_framework "X"` — captures which member a
+      # hecksagon attaches, whatever its name. Whether that member answers
+      # a role check is then read off its own declaration (`provides
+      # "authorization"`, via `Framework.providers_of`), the same rule
+      # `Registry#authorization_provider_for` applies at runtime — never a
+      # match on the literal "Governance".
+      FRAMEWORK_ATTACHED = /uses_framework\s*\(?\s*"([^"]+)"/
 
       # A command-level `role "..."` — the only construct
       # `refuse_role_mismatch` ever has anything to check a caller against.
@@ -61,21 +64,21 @@ module Hecks
 
       PROCESS_MANAGER = /^\s*process_manager\s+"/
 
-      # WHICH CAPABILITIES EACH MODE NEEDS BEFORE IT CAN SAY ANYTHING TRUE
-      # ABOUT A TARGET. An empty list means "any target at all" — every
+      # Which capabilities each mode needs before it can say anything true
+      # about a target. An empty list means "any target at all" — every
       # domain boots under Memory, so Ruby-only properties and the
       # self-consistency pass are always answerable. `ruby_only` is listed
-      # requirement-free on purpose and then EXCLUDED by `resolve` whenever
+      # requirement-free on purpose and then excluded by `resolve` whenever
       # `differential` resolved too: they are the same seat, and a compiled
       # Rust binary is strictly the better occupant (item 1 of the
-      # detection plan folded the Ruby-only property battery INTO the
+      # detection plan folded the Ruby-only property battery into the
       # differential seat, so nothing is lost by the exclusion).
       #
       # The four `false`-by-default modes in `QualityControlDials::MODES`
       # (`adapter_parity_postgres`, `era_boundary`, `concurrency`,
       # `wasm_front`) are named here with their requirements even though
       # nothing runs them yet — so `resolved modes:` can already say, per
-      # target, which of them WOULD be eligible the day a human flips the
+      # target, which of them would be eligible the day a human flips the
       # dial, and so flipping it is a one-line data change rather than a
       # code change plus a data change.
       MODE_REQUIREMENTS = {
@@ -92,7 +95,24 @@ module Hecks
         wasm_front:                 %w[rust]
       }.freeze
 
-      # MODES THAT NAME A SEPARATE, EXPENSIVE PASS OF THEIR OWN rather than
+      # Which of those modes `bin/qa_sweep` can actually run today.
+      # `MODE_REQUIREMENTS` above says what a mode needs; this says what
+      # exists to do it, and the two are not the same. Conflating them is
+      # how `qa/settings.yml` came to enable `wasm_front` and
+      # `adapter_parity_postgres` with nothing behind either — no seat, no
+      # check folded into the seed loop, no `MODE_EXPECTATIONS` entry — while
+      # `resolved modes:` still printed them per target, so the sweep
+      # advertised coverage it never performed. A mode named in
+      # `MODE_REQUIREMENTS` but absent here is one this practice wants and has
+      # not built: `bin/qa_sweep` refuses to start when a dial or `--modes`
+      # enables it, rather than resolving it into a line nobody can act on.
+      # `spec/qa_sweep_runnable_modes_spec.rb` keeps this list honest from
+      # both sides by grepping the runner itself.
+      RUNNABLE_MODES = %i[differential ruby_only self_consistency properties_in_differential
+                          structural_skip_report adapter_parity_sqlite persistence_parity
+                          era_boundary concurrency].freeze
+
+      # Modes that name a separate, expensive pass of their own rather than
       # an extra check folded into the ordinary per-seed loop —
       # `bin/qa_sweep` runs these only when asked by name (`--modes
       # persistence_parity`, or its older alias `--persistence-parity`) or
@@ -110,7 +130,7 @@ module Hecks
         capabilities << "rust" if rust_feature?(domain_path, rust_dir)
         capabilities << "postgres_era" if any_file?(domain_path, "*.hecksagon", POSTGRES_ERA_BINDING)
         capabilities << "translations" if Dir.glob(File.join(domain_path, "**", "translations", "*.bluebook")).any?
-        capabilities << "governance" if any_file?(domain_path, "*.hecksagon", GOVERNANCE_ATTACHED)
+        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)
@@ -122,7 +142,7 @@ module Hecks
         (required - capabilities).empty?
       end
 
-      # THE ONE RULE. `enabled` is whatever the dial (or `--modes`) turned
+      # The one rule. `enabled` is whatever the dial (or `--modes`) turned
       # on, in the dial's own declaration order — that order is preserved
       # so the printed line reads the same way the dial does. Then the
       # single exclusion named on `MODE_REQUIREMENTS`.
@@ -141,6 +161,17 @@ module Hecks
         features.match?(/^#{Regexp.escape(feature)}\s*=\s*\[\]/)
       end
 
+      # The capability label stays "governance" — it is the value
+      # `bin/qa_sweep` writes into the QualityControl ledger's
+      # `Target.capabilities`, and renaming it is a ledger change, not
+      # part of dropping the name check.
+      def authorization_attached?(domain_path)
+        attached = Dir.glob(File.join(domain_path, "**", "*.hecksagon"))
+                      .flat_map { |path| File.read(path).scan(FRAMEWORK_ATTACHED).flatten }.uniq
+        providers = Framework.providers_of(Bluebook::Capabilities::AUTHORIZATION)
+        attached.intersect?(providers)
+      end
+
       def any_file?(domain_path, glob, pattern)
         Dir.glob(File.join(domain_path, "**", glob)).any? { |path| File.read(path).match?(pattern) }
       end

data/lib/hecks/fuzzing/value_generator.rb

@@ -4,7 +4,7 @@ module Hecks
   module Fuzzing
     # One attribute, one value — in the exact JSON shape the hand-written
     # corpus already uses (a value-object-typed attribute is a nested hash keyed
-    # by its own field names ; a reference is the BARE ID of the head it points
+    # by its own field names ; a reference is the bare ID of the head it points
     # at, because that is what a reference is). Everything
     # returned is a plain, JSON-safe Ruby value : String keys throughout, never
     # symbols, so a generated step can be dumped straight to JSON.
@@ -15,7 +15,7 @@ module Hecks
     # codebase," and a fixed corpus of a few dozen examples rarely happens to
     # exercise the boundary that actually breaks. But mostly not : an attribute
     # named `email`/`currency` almost always needs a specific shape just to get
-    # PAST its own invariant (`address.include?("@")`, `currency.size == 3`) —
+    # past its own invariant (`address.include?("@")`, `currency.size == 3`) —
     # banking's very first fuzz run never got past Customer.Register, because
     # no plain random word ever contains "@". Reaching deep state matters more
     # than edge-casing every single field every single time, so the "normal"
@@ -31,7 +31,7 @@ module Hecks
       # (lib/hecks/runtime/value/coercion.rb) has accepted a bare
       # `"large"` in place of `{"value" => "large"}` for any single-field
       # value object since 86727afd — but until this generator actually
-      # PRODUCES that shape, nothing exercises it: neither the adapter-
+      # produces that shape, nothing exercises it: neither the adapter-
       # agreement gate nor the Rust/WASM `from_json` codegen (rust/project/
       # json_codec.rb) can ever be caught drifting on a shape they're
       # never handed.
@@ -44,22 +44,22 @@ module Hecks
       # PRD 05 (numeric-boundary-coverage) — Bignum (`2**100`, past i64's
       # own ceiling, which Ruby's own `Integer` has no such ceiling for —
       # `rust/src/kernel/json.rs`'s own `integral_i64` doc comment names
-      # exactly this: a Rust kernel value CANNOT represent it, so this
+      # exactly this: a Rust kernel value cannot represent it, so this
       # exercises a real cross-runtime capability gap, not a Ruby-only
       # edge) and its negative twin. Both round-trip through Ruby's own
       # arithmetic/JSON cleanly (confirmed directly: `(2**100).clamp(...)`
       # and `JSON.generate(2**100)` both just work — Integer has no
-      # ceiling here), so nothing in THIS runtime needed a fix for these;
+      # ceiling here), so nothing in this runtime needed a fix for these;
       # they're included so a real generated sequence occasionally
       # produces the value at all, since nothing had, repo-wide, before.
       INTEGER_EDGE_CASES = [0, -1, 2_147_483_647, -2_147_483_648, 2**100, -(2**100)].freeze
       # BUG#35 (QualityControl QA ledger, `lease-clock-json-precision`) —
       # a Bignum edge case (`2**100`, above) landing on an Integer-typed
-      # CLOCK or COUNT reading fires the already-catalogued `Json::Num`/
+      # clock or count reading fires the already-catalogued `Json::Num`/
       # f64 precision-loss class (`rust/src/kernel/json.rs`'s
       # `parse_number` parses every number through `s.parse::<f64>()`
       # before any target-type conversion runs, and `Json::Num` is a
-      # plain `f64` end to end — see that file's own header) on a NEW
+      # plain `f64` end to end — see that file's own header) on a new
       # site every time a new clock/count-shaped field is authored,
       # without adding any new coverage: both engines already refuse
       # (`TypeMismatch`, out of `i64` range either way) for this shape,
@@ -83,7 +83,7 @@ module Hecks
       # as a clock or a count is capped to a narrower, still-real
       # edge-case pool below (still exercises the ordinary i32
       # boundaries, just never a value past f64's own 2**53 exact-
-      # integer ceiling) — every OTHER Integer-typed field (a money
+      # integer ceiling) — every other Integer-typed field (a money
       # amount, an identity sequence, anything not clock/count-shaped)
       # still draws from the full `INTEGER_EDGE_CASES` pool above,
       # unchanged.
@@ -105,7 +105,7 @@ module Hecks
       # (raw `ArgumentError`, not a domain refusal) or `JSON.generate`
       # (`JSON::GeneratorError`, also not a domain refusal) — both fixed
       # at the source now, so these are safe to generate. -0.0 is
-      # deliberately included too even though it was ALREADY safe
+      # deliberately included too even though it was already safe
       # (finite, round-trips through JSON as `-0.0` cleanly) — a signed
       # zero is exactly the kind of boundary a hand-written corpus never
       # happens to type, and the fuzzer existing to cover it is the
@@ -157,10 +157,10 @@ module Hecks
             end
           end
 
-        # `fields.size == 1` — the SAME test `Behaviour::ValueObject#
+        # `fields.size == 1` — the same test `Behaviour::ValueObject#
         # sole_attribute` names: a genuinely single-field value object,
         # not merely "this particular closed-set member happened to pick
-        # one field." Unwrapping ONLY here, not in `invalid_member`
+        # one field." Unwrapping only here, not in `invalid_member`
         # above — a deliberately-wrong combination stays a Hash so its
         # own wrongness is what gets exercised, not a second, unrelated
         # shape question.
@@ -178,10 +178,10 @@ module Hecks
         end
       end
 
-      # THE ID ITSELF. This minted `{"value" => id}` back when a reference was
+      # The ID itself. This minted `{"value" => id}` back when a reference was
       # stored wrapped ; the payload gate refuses that shape now, so a fuzzer
       # still emitting it would have every generated reference refused and
-      # the SILENT guard would report the fuzzer broken rather than
+      # the silent guard would report the fuzzer broken rather than
       # the runtime.
       def reference_value(attribute, random:, known_ids:)
         pool = known_ids[attribute.type.target_name.to_s] || []
@@ -236,7 +236,7 @@ module Hecks
         random.rand(0.01..1000.0).round(2)
       end
 
-      # The bare scalar a generated IDENTITY value stands for, for recording into
+      # The bare scalar a generated identity value stands for, for recording into
       # `known_ids`. An identity is declared as a value object, so this opens one ;
       # a reference pointing at this record is already that scalar and needs no
       # opening at all. The two used to be the same reading and are not any more.

data/lib/hecks/fuzzing.rb

@@ -8,11 +8,16 @@ end
 require_relative "fuzzing/value_generator"
 require_relative "fuzzing/invalid_value_generator"
 require_relative "fuzzing/sequence_generator"
+require_relative "fuzzing/nondeterministic"
 require_relative "fuzzing/replay"
+require_relative "fuzzing/shrinker"
 require_relative "fuzzing/properties"
+require_relative "fuzzing/qa_settings"
 require_relative "fuzzing/rotation_priority"
 require_relative "fuzzing/sweep_depth"
 require_relative "fuzzing/persistence_parity"
 require_relative "fuzzing/form_census"
 require_relative "fuzzing/target_capabilities"
+require_relative "fuzzing/rust_gap_manifest"
 require_relative "fuzzing/structural_skips"
+require_relative "fuzzing/coverage_campaign"

data/lib/hecks/grammar/evolve.rb

@@ -1,7 +1,7 @@
 module Hecks
   module Grammar
     # The file surgery under bin/evolve: reading and rewriting the
-    # aggregate-local KeywordSeed/ArgumentSeed rows as TEXT, so a
+    # aggregate-local KeywordSeed/ArgumentSeed rows as text, so a
     # proposed word enters the table exactly as a hand would write it
     # and an admitted one loses its ceremony (an absent status reads as
     # admitted — the grown-column convention).
@@ -18,7 +18,7 @@ module Hecks
       module_function
 
       # bin/evolve's own `--name value` flag reader. Only consumes the
-      # NEXT argv element as the value when that element doesn't itself
+      # next argv element as the value when that element doesn't itself
       # look like a flag — otherwise `--foo --bar` would swallow `--bar`
       # as `--foo`'s value (and `--bar` would then never be seen at
       # all), and a value-less `--foo` at the end of argv would bypass
@@ -97,7 +97,7 @@ module Hecks
         row = %(#{indent}member word: "#{word}", context: "#{context}", body: "#{body}", ) +
               %(inner: "#{inner}", opens: "#{opens}", fills: "#{fills}", status: "proposed"\n)
 
-        # At the END of the one_of — grouping by context is a courtesy of
+        # At the end of the one_of — grouping by context is a courtesy of
         # the hand; a proposed row sits at the bottom until admission,
         # when whoever admits it may move it home.
         closing = block.rindex(/^\s*end\s*$/)
@@ -119,7 +119,7 @@ module Hecks
           next line unless member_row?(line, word, context)
 
           stripped = line.sub(/,\s*status: "[^"]*"/, "")
-          # Admitted is the default and stays UNSPELLED — only a word
+          # Admitted is the default and stays unspelled — only a word
           # entering or leaving the language carries its status.
           to == "admitted" ? stripped : stripped.sub(/\n\z/, %(, status: "#{to}"\n))
         end.join
@@ -219,10 +219,10 @@ module Hecks
         block
       end
 
-      # From `value_object "KeywordSeed"` to ITS OWN closing `end` — `member`
+      # From `value_object "KeywordSeed"` to its own closing `end` — `member`
       # rows sit bare now (S3, ADR 0025 — the `one_of do ... end` wrapper
       # is gone), so the first bare `end` line after the opener already
-      # IS the value object's own, the same fact the original one_of-
+      # is the value object's own, the same fact the original one_of-
       # nested version of this method leaned on (nothing else nested
       # inside it either, before or after).
       def keyword_blocks(source) = seed_blocks(source, "KeywordSeed")
@@ -230,7 +230,7 @@ module Hecks
 
       # ── the Argument rows — a word's own arguments, at last with tooling
       # of their own rather than the rename-only cascade above. A word may
-      # carry SEVERAL argument rows (one per position, one per named
+      # carry several argument rows (one per position, one per named
       # kwarg), so identity here is the full (keyword, context, at, named)
       # tuple, not the two-field key a Keyword row answers to.
 
@@ -250,7 +250,7 @@ module Hecks
         end
       end
 
-      # `pairs_shape` — for a `pairs` argument that fills ONE field with a
+      # `pairs_shape` — for a `pairs` argument that fills one field with a
       # whole key/value list rather than naming a field per pair (the
       # shape `Handler.dispatch`'s own `with:` already carries). Without
       # it, `spec/syntax_conformance_spec.rb` reads a pairs argument
@@ -315,7 +315,7 @@ module Hecks
 
       def argument_identity(row) = [row[:keyword], row[:context], row[:at], row[:named]]
 
-      # The rename cascade, ROW-AWARE — only the rows that actually belong
+      # The rename cascade, row-aware — only the rows that actually belong
       # to the renamed word, spelling updated in place, rather than a
       # blind `gsub` on every `keyword: "word",` substring in the file
       # (which a coincidentally-matching row elsewhere could have
@@ -337,7 +337,7 @@ module Hecks
         end
       end
 
-      # From `value_object "ArgumentSeed"` to ITS OWN closing `end` — see
+      # From `value_object "ArgumentSeed"` to its own closing `end` — see
       # `keyword_block`'s own comment for why the first bare `end` after
       # the opener is already the right one, now that `member` rows sit
       # bare (S3, ADR 0025).

data/lib/hecks/grammar.rb

@@ -7,12 +7,12 @@ require_relative "../hecks"
 
 module Hecks
   # The sublanguage grammar domains (grammar/*.bluebook) and the one boot
-  # path for reading them as DATA — the expression chapter replayed
+  # path for reading them as data — the expression chapter replayed
   # through its own admission ledger, so anything derived from it (the
   # operator projections, the conformance specs) reads the set that
   # actually survived the Admit gates, never a hand-copied list.
   #
-  # Booted on CALL, never at require: the Prism adapter normalises every
+  # Booted on call, never at require: the Prism adapter normalises every
   # predicate through CanonicalForm while a bluebook loads, so the
   # expression machinery cannot boot the chapter that configures it —
   # this module exists precisely so generators and specs boot it in a
@@ -42,7 +42,7 @@ module Hecks
       JSON.parse(File.read(LEDGER)).fetch("steps").each do |step|
         args = symbolize(step.fetch("args"))
         begin
-          dispatcher.dispatch(step.fetch("verb"), **args)
+          dispatcher.dispatch_flat(step.fetch("verb"), args)
         rescue *Runtime::DOMAIN_REFUSALS => e
           raise Runtime::WiringError,
                 "the admission ledger refused at #{step['verb']} #{step['args']} — #{e.message}"
@@ -77,15 +77,15 @@ module Hecks
       registry.repository("Expression", aggregate).all
     end
 
-    # THE OPERATORS THE LANGUAGE STANDS ON. Every guard and invariant in
+    # The operators the language stands on. Every guard and invariant in
     # the language's own chapters — the meta-domain (Bluebook, World) and
     # the grammar chapters beside this file — evaluates through the very
     # operator table the ledger admits. An operator one of those
-    # predicates uses is SELF-BEARING: retire it and the language can no
+    # predicates uses is self-bearing: retire it and the language can no
     # longer read its own rules — found the hard way, as a projection
     # missing `!=` that could not boot the chapter to fix itself. This
     # derives the set, with a usage site per operator, so the generator
-    # and the conformance spec can refuse the retirement BY NAME instead
+    # and the conformance spec can refuse the retirement by name instead
     # of wedging.
     def self_bearing_operators
       sites = Hash.new { |h, k| h[k] = [] }
@@ -146,7 +146,7 @@ module Hecks
       walk_operators(node, evaluator).uniq
     end
 
-    # A recursive descent over a CLOSED, declared set of AST node types
+    # A recursive descent over a closed, declared set of AST node types
     # (Evaluator's boolean/compare/include nodes, Resolver's arithmetic
     # nodes, and the generic Struct fallback) — each branch does the
     # same one thing (name the node's own operator, recurse into its