hecks 1.3.0 → 1.4.0

data/lib/hecks/bluebook/expression/resolver.rb

@@ -20,14 +20,12 @@ module Hecks
         SIGN_TESTS = Hecks::Vocabulary.fetch("SignTest")
 
         # Which Comparison operator each sign test is sugar for, against the
-        # literal 0 — declared the same way in Vocabulary::SignTest's
-        # compares_via (language/bluebook/vocabulary.bluebook) ; spec/vocabulary_conformance_spec
-        # holds the two tables equal.
-        SIGN_TEST_OPERATORS = {
-          "positive?" => ">",
-          "negative?" => "<",
-          "zero?"     => "=="
-        }.freeze
+        # literal 0 — Vocabulary::SignTest's own compares_via
+        # (language/bluebook/vocabulary.bluebook), read off the generated
+        # table rather than typed a second time.
+        SIGN_TEST_OPERATORS = Hecks::Vocabulary.rows("SignTest")
+                                               .to_h { |row| [row["name"], row["compares_via"]] }
+                                               .freeze
 
         # The leaf grammar an expression's dotted/arithmetic side parses into.
         # Which node a string produces is a pure function of the string, so
@@ -40,7 +38,7 @@ module Hecks
         StringLiteral  = Struct.new(:value, keyword_init: true)
         BoolLiteral    = Struct.new(:value, keyword_init: true)
         # `["active", "suspended"]` — a literal set, the haystack half of
-        # an `.include?`. Vocabulary::IncludeHaystack has always ADMITTED
+        # an `.include?`. Vocabulary::IncludeHaystack has always admitted
         # Array (and Evaluator#includes? has always had a `when Array`
         # arm), but nothing could produce one: there was no array-literal
         # node, so `["a", "b"].include?(x)` fell through to Lookup and
@@ -66,18 +64,18 @@ module Hecks
         Size           = Struct.new(:receiver, keyword_init: true)
         Lookup         = Struct.new(:path, keyword_init: true)
 
-        # UPDATE 2026-08-27: every "vendored addition, not (yet) upstream
+        # Update 2026-08-27: every "vendored addition, not (yet) upstream
         # hecks" comment on this file's own MatchesRegex/Presence/Split/
         # First/Last/StartsWith/EndsWith below (plus ArrayLiteral above)
-        # described a REAL gap, found the hard way, in the history each
+        # described a real gap, found the hard way, in the history each
         # comment tells — and that history stays exactly as written,
-        # on purpose. What changed is the PRESENT TENSE claim "not (yet)
+        # on purpose. What changed is the present tense claim "not (yet)
         # upstream": a review of this exact migration found these eight
-        # symbols had working Ruby parse/interpret arms but had NEVER
+        # symbols had working Ruby parse/interpret arms but had never
         # gone through Propose -> Render -> Admit
         # (lib/hecks/grammar/expression_operators.json) the way every
         # other operator here has — a closed-vocabulary guard
-        # (spec/operator_conformance_spec.rb) built entirely over TABLES
+        # (spec/operator_conformance_spec.rb) built entirely over tables
         # structurally could not see hand-coded Struct/parse/interpret
         # additions, so eight operators ran in Ruby, admitted nowhere,
         # invisible to the one guard whose whole job was "reads in every
@@ -88,13 +86,13 @@ module Hecks
         #
         # `receiver.match?(/pattern/)` -- vendored addition, not (yet)
         # upstream hecks (migration plan task 8): confirmed the
-        # SINGLE most impactful corpus-wide dispatch-time gap of the
+        # single most impactful corpus-wide dispatch-time gap of the
         # whole migration -- `.match?(regex)` appears in nearly every
         # value_object's format-validation rule across every corpus
         # this migration touched (email/phone/ISO-8601-timestamp/zip
-        # patterns, dozens of files), and had NO parse support at all:
+        # patterns, dozens of files), and had no parse support at all:
         # it fell all the way through to the `Lookup` catch-all below,
-        # which tried to split the ENTIRE ".match?(/\A\d{5}\z/)" text
+        # which tried to split the entire ".match?(/\A\d{5}\z/)" text
         # on "." as if it were a dotted attribute path, and crashed with
         # an opaque "no implicit conversion of Symbol into Integer"
         # somewhere downstream -- confirmed live via a real dispatch,
@@ -118,13 +116,13 @@ module Hecks
         Presence       = Struct.new(:receiver, :negated, keyword_init: true)
 
         # `.set?`/`.unset?` -- sibling of `.present?`/`.blank?` immediately
-        # above, added for a DELIBERATELY narrower question, spelled out in
+        # above, added for a deliberately narrower question, spelled out in
         # the name so choosing between the two pairs is a choice, not a
         # trap: `.present?` means "not EMPTY" (Rails-standard -- nil/false,
-        # and an EMPTY String/Array/Hash, are blank; nothing else is),
+        # and an empty String/Array/Hash, are blank; nothing else is),
         # which quietly answers "was this ever assigned" and "does the
-        # assigned value happen to be empty" as the SAME question. For an
-        # optional field whose only legitimate unset state IS nil, that
+        # assigned value happen to be empty" as the same question. For an
+        # optional field whose only legitimate unset state is nil, that
         # conflation is a real trap -- confirmed live: a corpus author
         # reaching for `superseded_by.blank?` to guard an optional
         # reference burned real time before landing on "just don't guard
@@ -144,7 +142,7 @@ module Hecks
         # `value.split("::").length == 4 && value.split("::").all? { |s|
         # s.length > 0 }` -- `.split(` matched none of this grammar's
         # known suffixes, so it fell through to the `Lookup` catch-all,
-        # which split the RAW EXPRESSION TEXT on "." (not the runtime
+        # which split the raw expression text on "." (not the runtime
         # value) and crashed with `TypeError: no implicit conversion of
         # Symbol into Integer` the moment `String#[]` was handed a
         # Symbol segment -- meaning every command taking a Phrase was
@@ -213,13 +211,13 @@ module Hecks
         end
 
         # A grammar's own dispatch table — one `return Node.new(...) if
-        # expr =~ /pattern/` per leaf production, in a FIXED precedence
+        # expr =~ /pattern/` per leaf production, in a fixed precedence
         # order (`.length` before the generic suffixes, sign tests before
         # the rest, etc. — see this file's own history comments on why
         # several of these were added in exactly this position). Each
         # branch is already one line; splitting the table into smaller
         # methods would not shrink any single check, only hide the
-        # precedence order this method's own line-by-line sequence IS.
+        # precedence order this method's own line-by-line sequence is.
         # rubocop:disable-next Metrics/AbcSize
         # rubocop:disable-next Metrics/CyclomaticComplexity
         # rubocop:disable-next Metrics/MethodLength
@@ -299,7 +297,7 @@ module Hecks
         # `parse`'s own dispatch table, mirrored: one `when` per leaf node
         # type it can produce, each already delegating to a small named
         # helper (add, apply_sign_test, emptiness_of, ...) — the case
-        # itself IS the closed, declared set this method exists to
+        # itself is the closed, declared set this method exists to
         # exhaust; the `else` backstop's own comment explains why a
         # missing arm is a bug this method is built to make loud, not
         # quiet.
@@ -365,8 +363,8 @@ module Hecks
 
         # `.present?`/`.blank?` -- vendored addition, see the
         # `Presence` struct's own comment above. `nil` and `false` are
-        # blank ; a String/Array/Hash is blank when EMPTY, not merely
-        # falsy -- a VO-wrapped field that IS assigned (`{value: "x"}`,
+        # blank ; a String/Array/Hash is blank when empty, not merely
+        # falsy -- a VO-wrapped field that is assigned (`{value: "x"}`,
         # `Value#to_h`'d first) is present regardless of what its own
         # inner value holds, matching how every VO-typed field in this
         # corpus is actually shaped once set at all.
@@ -389,7 +387,7 @@ module Hecks
         # `receiver.match?(/pattern/)` -- vendored addition, see the
         # `MatchesRegex` struct's own comment above. `receiver_value` is
         # coerced to a plain String first -- inlined here rather than
-        # calling `Evaluator#string_of` (a DIFFERENT module_function
+        # calling `Evaluator#string_of` (a different module_function
         # module; not actually in scope from inside Resolver despite
         # `Modulo`'s own parse rule above calling a same-named
         # `match_call` that has the identical cross-module problem --
@@ -410,7 +408,7 @@ module Hecks
           Regexp.new(pattern, options).match?(text)
         rescue RegexpError => e
           # M9: a malformed pattern between the slashes (an unclosed
-          # character class, say) is a defect in the EXPRESSION TEXT
+          # character class, say) is a defect in the expression text
           # itself, exactly the same category of author mistake an
           # unresolvable attribute name already refuses for — `Regexp.new`
           # raising a raw `RegexpError` crossed this sublanguage's own
@@ -420,7 +418,7 @@ module Hecks
         end
 
         # The elements of a bracketed literal, or nil if this isn't one.
-        # Splits on TOP-LEVEL commas only — quote-aware and depth-aware,
+        # Splits on top-level commas only — quote-aware and depth-aware,
         # the same discipline `split_addition` already applies, so a
         # nested array or a comma inside a string element stays whole.
         def array_elements(expr)
@@ -455,9 +453,9 @@ module Hecks
           elements.reject(&:empty?)
         end
 
-        # BRACES COUNT TOWARD DEPTH, exactly as parens do — a `+` inside a
+        # Braces count toward depth, exactly as parens do — a `+` inside a
         # block predicate's own `{ |x| ... }` body is not this expression's
-        # own addition. `parse` tries addition BEFORE `parse_block_opener`,
+        # own addition. `parse` tries addition before `parse_block_opener`,
         # so a paren-only depth count split
         #   kings.any? { |k| k.square.file == to.file + 1 && ... }
         # at that inner `+`, turning the whole expression into a nonsense
@@ -483,7 +481,7 @@ module Hecks
             # Phase 7 of the equivalence-gap plan): `ArrayLiteral` can
             # appear as a general sub-expression now, not only as
             # `.include?`'s own haystack, so an array element containing
-            # its own top-level `+` (`[0, 0 + 0]`) used to read as THIS
+            # its own top-level `+` (`[0, 0 + 0]`) used to read as this
             # expression's own addition split point -- the whole
             # receiver before `.all?`/`.any?`/etc. torn in half before
             # `parse_block_opener` ever saw it as one atomic leaf.
@@ -629,48 +627,48 @@ module Hecks
           Evaluator.apply(node.operator, number, 0)
         end
 
-        # FOUND LIVE via the type-directed bounded-exhaustive expression
+        # Found live via the type-directed bounded-exhaustive expression
         # generator (Phase 7, equivalence-gap plan — spec/
         # bounded_exhaustive_expression_spec.rb): `.modulo(`'s own
         # argument position accepts any numeric sub-expression, including
-        # ANOTHER `.modulo(...)` call — `0.modulo(num_b.modulo(-1))` is
+        # another `.modulo(...)` call — `0.modulo(num_b.modulo(-1))` is
         # perfectly well-typed — but `expr.rindex(marker)` finds the
-        # RIGHTMOST (innermost) `.modulo(` in the whole string, not the
-        # OUTERMOST one a nested call needs split at. For that expression
-        # it found the INNER `.modulo(` (inside `num_b.modulo(-1)`) and
+        # rightmost (innermost) `.modulo(` in the whole string, not the
+        # outermost one a nested call needs split at. For that expression
+        # it found the inner `.modulo(` (inside `num_b.modulo(-1)`) and
         # split there, producing a receiver of `"0.modulo(num_b"` and a
         # divisor of `"-1)"` — both garbage, both re-parsed as bogus
         # `Lookup` paths, both then refusing with "cannot resolve" — a
-        # SILENT MISPARSE that happened to fail safe into a real
+        # silent misparse that happened to fail safe into a real
         # `EvaluationError` rather than a raw crash, which is exactly why
         # this had gone unnoticed: nothing before this generator existed
         # ever fed `.modulo` a nested `.modulo` call, random fuzzing
         # essentially never manufactures that specific shape by chance,
-        # and the resulting refusal LOOKS like an ordinary, correct one
+        # and the resulting refusal looks like an ordinary, correct one
         # unless you already know every name this generator's own
         # synthetic state declares (real corpus authors would see this as
         # a mysterious "cannot resolve" on text they never wrote).
         #
         # Fixed the same way `split_addition`/`Evaluator.top_level_index`
         # already handle nested `(`/`{` elsewhere in this exact file:
-        # find the FIRST (leftmost, outermost) occurrence of the marker,
-        # then track paren/quote depth from there to find ITS OWN
+        # find the first (leftmost, outermost) occurrence of the marker,
+        # then track paren/quote depth from there to find its own
         # matching close — not just strip the string's own trailing `)`
         # and hope it belongs to this call.
-        # Not just the FIRST occurrence, either — `.modulo` also CHAINS
-        # (`x.modulo(a).modulo(b)`, the receiver of the OUTER call itself
+        # Not just the first occurrence, either — `.modulo` also chains
+        # (`x.modulo(a).modulo(b)`, the receiver of the outer call itself
         # ending in a `.modulo(...)` call), a second real shape the
         # leftmost-occurrence-only version of this fix still mis-parsed:
         # the first `.modulo(`'s own matching close paren lands mid-
         # string (right after `a)`, before the second `.modulo(b)`), so
         # it correctly fails the "reaches the end" check below and must
-        # be tried again at the NEXT occurrence rather than giving up.
-        # Trying occurrences strictly left to right and taking the FIRST
+        # be tried again at the next occurrence rather than giving up.
+        # Trying occurrences strictly left to right and taking the first
         # one whose matching close reaches the string's last character
-        # handles both shapes with the same rule: for NESTING
+        # handles both shapes with the same rule: for nesting
         # (`.modulo(x.modulo(y))`), the leftmost (outer) occurrence's own
         # paren-depth tracking already walks straight through the inner
-        # call to the true final `)`; for CHAINING, the leftmost
+        # call to the true final `)`; for chaining, the leftmost
         # occurrence's close lands short and is rejected, so the next
         # occurrence (the true outermost call) is tried instead.
         def match_call(expr, marker)
@@ -685,7 +683,7 @@ module Hecks
         end
 
         # `matching_brace` (resolver/block_predicates.rb)'s own twin, one
-        # bracket pair over: `start` is the index just past the OPENING
+        # bracket pair over: `start` is the index just past the opening
         # `(` already consumed by the caller (depth starts at 1, not 0,
         # for the same reason).
         def matching_paren(expr, start)
@@ -709,12 +707,12 @@ module Hecks
           nil
         end
 
-        # Both operands are coerced to a real Integer/Float BEFORE the
-        # zero-check, and the check reads the COERCED divisor — not the
+        # Both operands are coerced to a real Integer/Float before the
+        # zero-check, and the check reads the coerced divisor — not the
         # raw `divisor_value` (which might not even respond to `.zero?`,
         # a String for instance) and not a `.to_i`-truncated stand-in for
         # it either. The old order checked a truncated `divisor.to_i`
-        # AFTER already validating the untruncated value wasn't zero, so
+        # after already validating the untruncated value wasn't zero, so
         # a divisor merely small (`0.3`, truncating to `0`) sailed past
         # the guard and then blew up `Integer#%` with a raw
         # `ZeroDivisionError` the moment it reached zero anyway.
@@ -785,7 +783,7 @@ module Hecks
         # from_identifier`/`Value::Coercion#fields_for`'s own single-
         # field auto-unwrap already treats as "this VO IS its scalar"
         # everywhere else in this runtime) came back as the `Value`
-        # wrapper itself, never unwrapped for READING -- so `Value#==`
+        # wrapper itself, never unwrapped for reading -- so `Value#==`
         # (which only ever equals another `Value` instance) silently
         # refused every `guarantees "..." do status == "active" end` /
         # `expects "..." do trash_day.present? end`-shaped bare
@@ -797,12 +795,12 @@ module Hecks
         # predicate. Scoped narrowly to the single-field `{value: X}`
         # shape only.
         #
-        # UPDATE 2026-08-18: originally scoped to unwrap ONLY the bare
+        # Update 2026-08-18: originally scoped to unwrap only the bare
         # (undotted) case, on the belief that a dotted lookup only ever
-        # reaches into a VO's OWN field (`field.value`, `field.sub_
+        # reaches into a VO's own field (`field.value`, `field.sub_
         # field`) and so should keep walking `#[]` untouched. That
         # belief held for the single-hop case but not for the general
-        # one: a dotted lookup that NAVIGATES THROUGH an entity/list
+        # one: a dotted lookup that navigates through an entity/list
         # element to a nested field (`leg.voyage`, where `voyage` is
         # itself a single-field VO) landed on the very same unwrapped-
         # `Value` shape the bare case fixed, and hit the identical
@@ -810,26 +808,26 @@ module Hecks
         # literal or another unwrapped VO returned false for everything,
         # no error. The terminal value of a dotted walk deserves the
         # same "this VO IS its scalar" treatment as a bare lookup's
-        # result; only the INTERMEDIATE hops need raw `#[]` addressing
+        # result; only the intermediate hops need raw `#[]` addressing
         # to keep navigating. `unwrap_scalar` is idempotent on an
         # already-raw scalar (a String/Integer doesn't respond to
         # `#to_h`), so this is safe for the existing `field.value`-
         # shaped dotted lookups too -- they already returned a raw
         # scalar and are unaffected.
-        # UPDATE (single-element value objects strictly answer `.value`):
-        # the unwrap used to gate on the sole key being literally NAMED
+        # Update (single-element value objects strictly answer `.value`):
+        # the unwrap used to gate on the sole key being literally named
         # `:value` — correct for the shorthand/closed-set shapes that
         # motivated it, but a lie of omission for `Money{amount}` and
         # every other single-field value object whose author picked a
-        # domain name for the field: the SAME "this VO IS its scalar"
+        # domain name for the field: the same "this VO IS its scalar"
         # reading ([[feedback_name_the_scalar_field]], `Behaviour::
         # ValueObject#sole_attribute`) applies regardless of what the
         # sole field happens to be called, and the name gate made a bare
         # `balance > 0` work for a `Balance{value}` while silently
-        # comparing a whole VO for a `Balance{amount}`. Now the COUNT is
+        # comparing a whole VO for a `Balance{amount}`. Now the count is
         # the gate, never the name. A declared `Runtime::Value` reads
         # its own `sole_attribute` (the declaration's answer, not the
-        # stored hash's); any OTHER to_h-able (a Struct, a bespoke
+        # stored hash's); any other to_h-able (a Struct, a bespoke
         # wrapper with no declaration to consult) keeps the original
         # `{value: X}`-only unwrap, so nothing that never was a value
         # object gains a surprise unwrapping. `rust/src/kernel/json.rs`'s

data/lib/hecks/bluebook/hexagon.rb

@@ -48,7 +48,7 @@ module Hecks
 
     # The built form of a `.world` file, produced by `DSL::WorldBuilder` —
     # a domain's own `realm`/`latest` version markers and its adapter bind
-    # SETTINGS (as opposed to `Hecksagon`'s own bind LIST, above).
+    # settings (as opposed to `Hecksagon`'s own bind list, above).
     # `Behaviour::World` supplies the settings lookups (`for_verb`/
     # `for_binding`); this class holds only the declared data.
     class World

data/lib/hecks/bluebook/lifecycle.rb

@@ -3,7 +3,7 @@ require_relative "behaviour/lifecycle"
 module Hecks
   module Bluebook
     # One declared `transition` row — the state a command moves an
-    # aggregate or entity TO, and, when guarded, the state(s) it must
+    # aggregate or entity to, and, when guarded, the state(s) it must
     # currently be in (`from:`) for the transition to apply. An unguarded
     # transition (`from: nil`) applies from any current state.
     class StateTransition

data/lib/hecks/bluebook/meta_validator/adapter_judge.rb

@@ -34,7 +34,7 @@ module Hecks
         end
 
         def send_to(verb, label, **payload)
-          offer(label) { @runtime.dispatch(verb, **args(payload)) }
+          offer(label) { @runtime.dispatch_flat(verb, args(payload)) }
         end
 
         def judge!