hecks 3.4.2 → 3.6.0

data/lib/hecks/forms/record_renderer.rb

@@ -41,7 +41,7 @@ module Hecks
         current = aggregate.lifecycle && state[aggregate.lifecycle.field]
         <<~HTML
           <h1>#{Escape.html("#{domain}::#{aggregate.hecks_name}")} <span class="mono">#{Escape.html(id)}</span></h1>
-          #{%(<span class="badge role">#{Escape.html(aggregate.lifecycle.field)}: #{Escape.html(current)}</span>) if current}
+          #{lifecycle_badge(aggregate, current)}
           #{state_table(state)}
           <h2>Commands</h2>
           #{command_links(domain, aggregate, id, current)}
@@ -49,6 +49,14 @@ module Hecks
         HTML
       end
 
+      # @return [String, nil] the badge naming the lifecycle field and its state; nil when the
+      #   record has no lifecycle state
+      def self.lifecycle_badge(aggregate, current)
+        return unless current
+
+        %(<span class="badge role">#{Escape.html(aggregate.lifecycle.field)}: #{Escape.html(current)}</span>)
+      end
+
       def self.state_table(state)
         rows = state.map do |key, value|
           "<tr><th>#{Escape.html(Humanize.label(key.to_s))}</th><td>#{Escape.html(render_value(value))}</td></tr>"
@@ -70,15 +78,18 @@ module Hecks
         commands = aggregate.commands.reject(&:creates?).select { |cmd| applies?(aggregate, cmd, current_state) }
         return "<p><em>No commands act on an existing #{Escape.html(aggregate.hecks_name)}.</em></p>" if commands.empty?
 
-        items = commands.map do |cmd|
-          # The id is free-form, so it is percent-encoded as a query value.
-          href = "/#{domain}/#{aggregate.hecks_name}/#{cmd.hecks_name}.html?to=#{Escape.url(id)}"
-          %(<li><a href="#{Escape.attr(href)}"><span>#{Escape.html(cmd.hecks_name)}</span>) \
-            "<span class=\"kind\">#{Escape.html(cmd.goal.to_s)}</span></a></li>"
-        end
+        items = commands.map { |cmd| command_item(domain, aggregate, cmd, id) }
         %(<ul class="verb-list">#{items.join}</ul>)
       end
 
+      # @return [String] the list item linking to the command's form, addressed to record `id`
+      def self.command_item(domain, aggregate, cmd, id)
+        # The id is free-form, so it is percent-encoded as a query value.
+        href = "/#{domain}/#{aggregate.hecks_name}/#{cmd.hecks_name}.html?to=#{Escape.url(id)}"
+        %(<li><a href="#{Escape.attr(href)}"><span>#{Escape.html(cmd.hecks_name)}</span>) \
+          "<span class=\"kind\">#{Escape.html(cmd.goal.to_s)}</span></a></li>"
+      end
+
       def self.applies?(aggregate, command, current_state)
         transitions = aggregate.lifecycle&.transitions_for(command.hecks_name) || []
         return true if transitions.empty?
@@ -89,10 +100,7 @@ module Hecks
       def self.query_links(domain, aggregate)
         return "" if aggregate.queries.empty?
 
-        items = aggregate.queries.map do |query|
-          %(<li><a href="/#{domain}/#{aggregate.hecks_name}/#{query.hecks_name}.html">) \
-            "<span>#{Escape.html(query.hecks_name)}</span><span class=\"kind\">query</span></a></li>"
-        end
+        items = aggregate.queries.map { |query| verb_item(domain, aggregate, query, "query") }
         %(<h2>Queries</h2><ul class="verb-list">#{items.join}</ul>)
       end
 
@@ -100,17 +108,18 @@ module Hecks
         commands = aggregate.commands.reject(&:creates?)
         return "" if commands.empty? && aggregate.queries.empty?
 
-        cmd_items = commands.map do |c|
-          %(<li><a href="/#{domain}/#{aggregate.hecks_name}/#{c.hecks_name}.html">) \
-            "<span>#{Escape.html(c.hecks_name)}</span><span class=\"kind\">command</span></a></li>"
-        end
-        query_items = aggregate.queries.map do |q|
-          %(<li><a href="/#{domain}/#{aggregate.hecks_name}/#{q.hecks_name}.html">) \
-            "<span>#{Escape.html(q.hecks_name)}</span><span class=\"kind\">query</span></a></li>"
-        end
+        cmd_items = commands.map { |c| verb_item(domain, aggregate, c, "command") }
+        query_items = aggregate.queries.map { |q| verb_item(domain, aggregate, q, "query") }
         %(<h2>Every command &amp; query on #{Escape.html(aggregate.hecks_name)}</h2>) \
           "<ul class=\"verb-list\">#{(cmd_items + query_items).join}</ul>"
       end
+
+      # @param kind [String] the word shown beside the verb, `"command"` or `"query"`
+      # @return [String] the list item linking to the verb's own page
+      def self.verb_item(domain, aggregate, verb, kind)
+        %(<li><a href="/#{domain}/#{aggregate.hecks_name}/#{verb.hecks_name}.html">) \
+          "<span>#{Escape.html(verb.hecks_name)}</span><span class=\"kind\">#{kind}</span></a></li>"
+      end
     end
   end
 end

data/lib/hecks/forms/reference_options.rb

@@ -12,7 +12,7 @@ module Hecks
 
       def self.walk(fields, &block)
         fields.each do |field|
-          block.call(field)
+          yield(field)
           walk(field.children, &block) if field.children
         end
       end

data/lib/hecks/forms/text_shape.rb

@@ -0,0 +1,40 @@
+require_relative "../vocabulary"
+
+module Hecks
+  module Forms
+    module FieldShape
+      # Resolves a text attribute into a field, reading its HTML input type off its name and
+      # pattern.
+      module TextShape
+        # Vocabulary::FieldHint rows (language/bluebook/vocabulary.bluebook), matched
+        # case-insensitively. hecks project_field_hints writes the Rust host's copy from the same
+        # rows.
+        HINTS = Hecks::Vocabulary.rows("FieldHint")
+                                 .to_h { |row| [row["name"], Regexp.new(row["pattern"], Regexp::IGNORECASE)] }
+                                 .freeze
+        EMAIL_HINT    = HINTS.fetch("email")
+        URL_HINT      = HINTS.fetch("url")
+        TEL_HINT      = HINTS.fetch("tel")
+        TEXTAREA_HINT = HINTS.fetch("textarea")
+
+        # @param attribute [Bluebook::Attribute] a string-typed attribute
+        # @param common [Hash] the field attributes every kind shares
+        # @return [Forms::Field] a `:text` field, or a `:textarea` for a long-form name
+        def self.field(attribute, common)
+          name = attribute.name.to_s
+          html_type = html_type(name, attribute.pattern.to_s)
+          kind = html_type == "text" && name.match?(TEXTAREA_HINT) ? :textarea : :text
+          Field.new(**common, kind: kind, html_type: html_type)
+        end
+
+        def self.html_type(name, pattern)
+          return "email" if pattern.include?("@") || name.match?(EMAIL_HINT)
+          return "url" if pattern.match?(/https?/i) || name.match?(URL_HINT)
+          return "tel" if name.match?(TEL_HINT)
+
+          "text"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fqn.rb

@@ -41,7 +41,6 @@ module Hecks
     end
 
     # Parses a `Realm::Domain@version::Aggregate.verb` address.
-    # One method on purpose: each step consumes locals the step before it derived.
     #
     # @param text [String] a `Realm::Domain::Aggregate.verb` address, with domain
     #   optionally `@version`-pinned and aggregate optional for a domain-level query
@@ -49,34 +48,53 @@ module Hecks
     # @raise [Fqn::Invalid] if `text` is not shaped like a FQN, its verb is neither
     #   PascalCase nor snake_case, its domain version is malformed, or it names a
     #   domain-level command
-    # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def self.parse(text)
       head, separator, verb = text.to_s.rpartition(".")
-      raise Invalid, "FQN must be Realm::Domain::Aggregate.verb — got #{text.inspect}" if separator.empty?
-
       segments = head.split("::", -1)
-      valid_fqn = [1, 2, 3].include?(segments.length) && segments.none?(&:empty?) && !verb.empty?
-      raise Invalid, "FQN must be Realm::Domain::Aggregate.verb — got #{text.inspect}" unless valid_fqn
-
-      realm, domain_spec, aggregate = case segments.length
-                                      when 3 then segments
-                                      # realm::domain.query is a domain-level read model
-                                      when 2 then query_name?(verb) ? [segments[0], segments[1], nil] : [nil, *segments]
-                                      else [nil, segments.first, nil]
-                                      end
-      domain, version = split_domain(domain_spec)
-      kind = if command_name?(verb)
-               :command
-             elsif query_name?(verb)
-               :query
-             else
-               raise Invalid, "FQN verb must be PascalCase command or snake_case query — got #{text.inspect}"
-             end
+      unless valid_shape?(separator, segments, verb)
+        raise Invalid, "FQN must be Realm::Domain::Aggregate.verb — got #{text.inspect}"
+      end
 
+      new(**address_fields(segments, verb, text))
+    end
+
+    # @return [Hash{Symbol => Object}] the keywords `new` takes for the address
+    # @raise [Fqn::Invalid] if the domain version is malformed, the verb is neither PascalCase nor
+    #   snake_case, or the address names a domain-level command
+    def self.address_fields(segments, verb, text)
+      realm, domain_spec, aggregate = address_parts(segments, verb)
+      domain, version = split_domain(domain_spec)
+      kind = verb_kind(verb, text)
       raise Invalid, "domain-level FQNs are query-only — got #{text.inspect}" if aggregate.nil? && kind == :command
 
-      new(realm: realm, domain: domain, version: version, aggregate: aggregate, verb: verb, kind: kind)
+      { realm: realm, domain: domain, version: version, aggregate: aggregate, verb: verb, kind: kind }
+    end
+
+    # @return [Boolean] whether the verb is separated by a dot from one to three non-empty names
+    def self.valid_shape?(separator, segments, verb)
+      !separator.empty? && [1, 2, 3].include?(segments.length) && segments.none?(&:empty?) && !verb.empty?
+    end
+
+    # @return [Array(String, String, String)] the realm, the domain with its version, and the
+    #   aggregate, each nil when the address leaves it out
+    def self.address_parts(segments, verb)
+      case segments.length
+      when 3 then segments
+      # realm::domain.query is a domain-level read model
+      when 2 then query_name?(verb) ? [segments[0], segments[1], nil] : [nil, *segments]
+      else [nil, segments.first, nil]
+      end
+    end
+
+    # @return [Symbol] `:command` or `:query`, by the verb's spelling
+    # @raise [Fqn::Invalid] if the verb is neither PascalCase nor snake_case
+    def self.verb_kind(verb, text)
+      return :command if command_name?(verb)
+      return :query if query_name?(verb)
+
+      raise Invalid, "FQN verb must be PascalCase command or snake_case query — got #{text.inspect}"
     end
+    private_class_method :address_fields, :valid_shape?, :address_parts, :verb_kind
 
     # Whether `name` is a valid command verb: PascalCase.
     #
@@ -95,21 +113,21 @@ module Hecks
     # @param domain [String] the domain name
     # @param aggregate [String, nil] the aggregate name, or nil for a domain-level query
     # @param verb [String] the command or query verb
-    # @param kind [Symbol, String] `:command` or `:query`
-    # @param version [String, nil] the pinned domain version, or nil for the
-    #   world's configured latest alias
+    # @param options [Hash] `kind:` (required), `:command` or `:query`, and `version:`, the
+    #   pinned domain version, or nil for the world's configured latest alias
+    # @raise [ArgumentError] if `kind:` is missing, or for any other keyword
     # @raise [Fqn::Invalid] if any segment is empty or contains a separator, or if
     #   `verb` does not match the shape required by `kind`
-    def initialize(realm:, domain:, aggregate:, verb:, kind:, version: nil)
-      @realm     = realm && segment(realm, "realm")
+    def initialize(realm:, domain:, aggregate:, verb:, **options)
+      refuse_unknown_options!(options)
+      @realm     = optional_segment(realm, "realm")
       @domain    = segment(domain, "domain")
-      @version   = version && segment(version, "version")
-      @aggregate = aggregate && segment(aggregate, "aggregate")
+      @version   = optional_segment(options[:version], "version")
+      @aggregate = optional_segment(aggregate, "aggregate")
       @verb      = segment(verb, "verb")
-      @kind      = kind.to_sym
+      @kind      = options.fetch(:kind).to_sym
 
-      valid = command? ? self.class.command_name?(@verb) : self.class.query_name?(@verb)
-      raise Invalid, "#{@kind} FQN has an invalid verb #{@verb.inspect}" unless valid
+      refuse_invalid_verb!
     end
 
     # Whether this address names a command.
@@ -144,6 +162,20 @@ module Hecks
     end
     private_class_method :split_domain
 
+    def refuse_unknown_options!(options)
+      raise ArgumentError, "missing keyword: :kind" unless options.key?(:kind)
+
+      unknown = options.keys - %i[kind version]
+      raise ArgumentError, "unknown keyword: #{unknown.first.inspect}" unless unknown.empty?
+    end
+
+    def refuse_invalid_verb!
+      valid = command? ? self.class.command_name?(@verb) : self.class.query_name?(@verb)
+      raise Invalid, "#{@kind} FQN has an invalid verb #{@verb.inspect}" unless valid
+    end
+
+    def optional_segment(value, label) = value && segment(value, label)
+
     def segment(value, label)
       text = value.to_s
       if text.empty? || text.include?("::") || text.include?(".") || text.include?("@")

data/lib/hecks/framework.rb

@@ -36,9 +36,15 @@ module Hecks
     def self.chapter(name)
       path = members.fetch(name.to_s) do
         raise Runtime::WiringError,
-              "no framework member named #{name.inspect} — known: #{members.keys.sort.join(', ')}"
+              "no framework member named #{name.inspect} — known: #{members.keys.sort.join(", ")}"
       end
 
+      scratch_registry(path).bluebook(name.to_s)
+    end
+
+    # @param path [String] a member's bluebook file
+    # @return [Runtime::Registry] a fresh registry holding only that member's chapter
+    def self.scratch_registry(path)
       lib = File.expand_path("..", __dir__)
       registry = Runtime::Registry.new
       Hecks.with_registry(registry) do
@@ -49,8 +55,9 @@ module Hecks
         Kernel.load(File.join(lib, "hecks/adapters/driven/prism.adapter"))
         Kernel.load(path)
       end
-      registry.bluebook(name.to_s)
+      registry
     end
+    private_class_method :scratch_registry
 
     # Loads a member's bluebook unless this registry already holds it.
     #
@@ -64,7 +71,7 @@ module Hecks
     def self.load!(name)
       path = members.fetch(name.to_s) do
         raise Runtime::WiringError,
-              "no framework member named #{name.inspect} — known: #{members.keys.sort.join(', ')}"
+              "no framework member named #{name.inspect} — known: #{members.keys.sort.join(", ")}"
       end
 
       return if Hecks.current_registry.bluebook(name.to_s)

data/lib/hecks/freezer.rb

@@ -32,14 +32,23 @@ module Hecks
     # @return [String, nil] the dotted path (Hash keys, Array indices, or
     #   `"(the value itself)"`) to the first mutable value found, or nil if none
     def unfrozen_within(held, path = [])
-      return (path.empty? ? "(the value itself)" : path.join(".")) unless immune?(held) || held.frozen?
+      return mutable_path(path) unless immune?(held) || held.frozen?
 
+      first_unfrozen_child(held, path)
+    end
+
+    # @return [String, nil] the path to the first mutable value inside a Hash or Array, or nil
+    def first_unfrozen_child(held, path)
       case held
       when Hash  then held.lazy.filter_map { |key, inner| unfrozen_within(inner, path + [key.to_s]) }.first
       when Array then held.each_with_index.lazy.filter_map { |inner, i| unfrozen_within(inner, path + [i.to_s]) }.first
       end
     end
 
+    # @param path [Array<String>] the owner path walked so far
+    # @return [String] the path as dotted text, or `"(the value itself)"` for the root
+    def mutable_path(path) = path.empty? ? "(the value itself)" : path.join(".")
+
     # Explicit rather than trusting `frozen?` on immediates.
     #
     # @param held [Object] any domain value

data/lib/hecks/fuzzing/bounded_exhaustive_expressions/fragments.rb

@@ -0,0 +1,61 @@
+module Hecks
+  module Fuzzing
+    module BoundedExhaustiveExpressions
+      # The small, pure expression builders the production rules assemble: one construct over
+      # an operand list, with no recursion into `bounded` or `productions`.
+      module Fragments
+        # Equality and ordering over sampled numeric and string pairs.
+        #
+        # @param num [Array<String>] numeric operands
+        # @param str [Array<String>] string operands
+        # @return [Array<String>] the comparison expressions
+        def comparisons(num, str)
+          pairs(num).map { |a, b| "#{a} == #{b}" } +
+            pairs(num).map { |a, b| "#{a} > #{b}" } +
+            pairs(str).map { |a, b| "#{a} == #{b}" } +
+            pairs(str).map { |a, b| "#{a} < #{b}" }
+        end
+
+        # `And`, `Or` and `Not` over a boolean operand list.
+        #
+        # @param sub [Array<String>] boolean operands
+        # @return [Array<String>] the connective expressions
+        def connectives(sub)
+          pairs(sub).flat_map { |a, b| ["#{a} && #{b}", "#{a} || #{b}"] } + sub.map { |b| "!#{b}" }
+        end
+
+        # The string predicates, grouped by predicate rather than by operand.
+        #
+        # @param str [Array<String>] string operands
+        # @return [Array<String>] the predicate expressions
+        def string_tests(str)
+          str.map { |s| "#{s}.match?(/a/)" } +
+            str.flat_map { |s| ["#{s}.present?", "#{s}.blank?"] } +
+            str.flat_map { |s| ["#{s}.start_with?(\"a\")", "#{s}.end_with?(\"a\")"] }
+        end
+
+        # The string predicates for one operand.
+        #
+        # @param str [String] a string expression
+        # @return [Array<String>] the predicate expressions
+        def string_suffix_tests(str)
+          ["#{str}.present?", "#{str}.blank?", "#{str}.match?(/a/)", "#{str}.start_with?(\"a\")", "#{str}.end_with?(\"a\")"]
+        end
+
+        # @param numerics [Array<String>] numeric expressions
+        # @return [Array<String>] `.positive?`, `.negative?` and `.zero?` over each
+        def sign_tests(numerics)
+          numerics.flat_map { |n| ["#{n}.positive?", "#{n}.negative?", "#{n}.zero?"] }
+        end
+
+        # @param operands [Array<String>] string or array expressions
+        # @return [Array<String>] `.empty?` over each
+        def empty_tests(operands) = operands.map { |x| "#{x}.empty?" }
+
+        # @param arrays [Array<String>] array expressions
+        # @return [Array<String>] `.first` and `.last` over each
+        def first_and_last(arrays) = arrays.flat_map { |a| ["#{a}.first", "#{a}.last"] }
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/bounded_exhaustive_expressions/productions.rb

@@ -0,0 +1,217 @@
+module Hecks
+  module Fuzzing
+    module BoundedExhaustiveExpressions
+      # The recursive production rules, one per result type; mixed into
+      # `BoundedExhaustiveExpressions`, whose `leaves`, `bounded`, `sample`, `pairs` and `cross`
+      # they build on.
+      #
+      # The order each rule calls `bounded` and `with_element_leaf` in is part of its behavior:
+      # `with_element_leaf` invalidates only its own element type's cache entries, so a list
+      # built while a block parameter is bound is cached for the types it touches.
+      module Productions
+        # Numeric from Addition, Modulo, Size (string or array), and First/Last of a numeric array.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] numeric expressions one construct deep
+        def numeric_productions(depth)
+          sub = bounded(:numeric, depth - 1)
+          # Modulo's receiver is restricted to `resolver_numeric_leaves`: `Resolver.parse` splits
+          # on `+` before the `.modulo` suffix, so "0 + 0.modulo(1)" parses as `0 + (0.modulo(1))`.
+          pairs(sub).map { |a, b| "#{a} + #{b}" } +
+            cross(resolver_numeric_leaves(depth - 1), sub).map { |a, b| "#{a}.modulo(#{b})" } +
+            sized_numerics(depth - 1)
+        end
+
+        # Numeric from Size of a string or an array, and First/Last of a numeric array.
+        #
+        # @param depth [Integer] maximum recursive steps remaining for the receivers
+        # @return [Array<String>] the `.size`, `.first` and `.last` expressions
+        def sized_numerics(depth)
+          bounded(:string, depth).map { |s| "#{s}.size" } +
+            bounded(:array, depth).map { |a| "#{a}.size" } +
+            first_and_last(sample(numeric_array_productions(depth)))
+        end
+
+        # Booleans safe as the receiver of a Resolver-level suffix such as `.to_s` (a boolean-
+        # typed expression, is wanted). Found live, the same way the
+        # nested `.modulo` bug was: `Compare`, `Include`, `Or`, `And` and `Not` are boolean-
+        # typed at `interpret` time, but `Evaluator`-level syntax, not
+        # something `Resolver.parse` can take as a receiver, even parenthesized.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] boolean expressions parsed by a Resolver suffix rule
+        def resolver_boolean_leaves(depth)
+          leaves(:boolean) +
+            sign_tests(resolver_numeric_leaves(depth)) +
+            bounded(:string, depth).flat_map { |s| string_suffix_tests(s) } +
+            empty_tests(array_operands(depth)) +
+            sample(block_predicate_productions(depth))
+        end
+
+        # Numerics safe to embed as the receiver of a Resolver-level suffix such as `.to_s`.
+        #
+        # A bare `Addition` is excluded: `Resolver.parse` splits on `+` before matching the
+        # suffix, so "0 + 0.to_s" parses as `0 + (0.to_s)`, not `(0 + 0).to_s`.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] numeric expressions that are never a bare top-level `Addition`
+        def resolver_numeric_leaves(depth)
+          return leaves(:numeric) if depth <= 0
+
+          # Self-referential so Modulo's receiver stays restricted; its argument is unrestricted.
+          leaves(:numeric) +
+            cross(resolver_numeric_leaves(depth - 1), bounded(:numeric, depth - 1)).map { |a, b| "#{a}.modulo(#{b})" } +
+            sized_numerics(depth)
+        end
+
+        # String from ToS of numeric, boolean, nil or string, and First/Last of a string array.
+        #
+        # `Split` is not listed: it produces an array, never a String.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] string expressions one construct deep
+        def string_productions(depth)
+          inner = depth - 1
+          [sample(resolver_numeric_leaves(inner)), sample(resolver_boolean_leaves(inner)),
+           bounded(:nil_type, inner), bounded(:string, inner)].flat_map { |list| list.map { |x| "#{x}.to_s" } } +
+            first_and_last(sample(string_array_productions(inner)))
+        end
+
+        # Array from Split and same-type array literals; array is mostly a receiver type, so
+        # few producers are needed.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] array expressions one construct deep; `[]` at depth 0
+        def array_productions(depth)
+          return [] if depth <= 0
+
+          bounded(:string, depth - 1).map { |s| "#{s}.split(\",\")" } +
+            [numeric_array_literal(depth - 1), string_array_literal(depth - 1)]
+        end
+
+        # Builds a two-element numeric array literal at `depth`.
+        #
+        # @param depth [Integer] maximum recursive steps remaining for its elements
+        # @return [String] the literal's source text
+        def numeric_array_literal(depth) = "[#{bounded(:numeric, depth).first(2).join(", ")}]"
+
+        # Builds a two-element string array literal at `depth`.
+        #
+        # @param depth [Integer] maximum recursive steps remaining for its elements
+        # @return [String] the literal's source text
+        def string_array_literal(depth) = "[#{bounded(:string, depth).first(2).join(", ")}]"
+
+        # Arrays known by construction to hold numeric elements, so `.first`/`.last` and block
+        # predicates know the element type without a richer AST.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] `"arr_num"` plus a numeric array literal at `depth`
+        def numeric_array_productions(depth)
+          ["arr_num", numeric_array_literal(depth)]
+          # no Split entry: a Split of a string never yields numeric elements
+        end
+
+        # Arrays known by construction to hold string elements; the twin of
+        # `numeric_array_productions`.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] `"arr_str"`, a string array literal, and every string `Split`
+        def string_array_productions(depth)
+          ["arr_str", string_array_literal(depth)] + bounded(:string, depth).map { |s| "#{s}.split(\",\")" }
+        end
+
+        # Boolean from every comparison and predicate construct; a `given` body is boolean-
+        # typed at its own top level (`Evaluator.truthy?`), so this is also
+        # the set `all_predicates` draws from.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] boolean expressions one construct deep
+        def boolean_productions(depth)
+          inner = depth - 1
+          sub = bounded(:boolean, inner)
+          num = bounded(:numeric, inner)
+          str = bounded(:string, inner)
+
+          comparisons(num, str) + operand_tests(str, inner) + string_tests(str) + connectives(sub) +
+            block_predicate_productions(inner) + include_productions(inner)
+        end
+
+        # The sign and emptiness predicates over numeric, string and array operands.
+        #
+        # @param str [Array<String>] string operands
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] the predicate expressions
+        def operand_tests(str, depth)
+          # `resolver_numeric_leaves`, not `num`: a suffix match is a plain trailing strip, so
+          # an `Addition` would mis-split ("0 + 0.positive?" parses as `0 + (0.positive?)`).
+          sign_tests(resolver_numeric_leaves(depth)) + empty_tests(str + array_operands(depth))
+        end
+
+        # Every array source a predicate may be asked `.empty?`: numeric, string, and plain.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] the sampled array expressions
+        def array_operands(depth)
+          sample(numeric_array_productions(depth)) + sample(string_array_productions(depth)) + bounded(:array, depth)
+        end
+
+        # `.all?`/`.any?`/`.none?` over each known-element-typed array, with a predicate body
+        # bound to `BLOCK_PARAM`.
+        #
+        # The only construct where Resolver and Evaluator recurse into each other, and the
+        # only one that can nest into another block predicate.
+        #
+        # @param depth [Integer] maximum recursive steps remaining for the predicate body
+        # @return [Array<String>] `.all?`/`.any?`/`.none?` calls over each
+        #   known-element-typed array source, one per predicate body `predicate_bodies`
+        #   produces; `[]` if `depth` is negative
+        def block_predicate_productions(depth)
+          return [] if depth.negative?
+
+          typed_array_sources(depth).flat_map do |array_text, element_type|
+            predicate_bodies(element_type, depth).flat_map do |body|
+              %w[all? any? none?].map { |mode| "#{array_text}.#{mode} { |#{BLOCK_PARAM}| #{body} }" }
+            end
+          end
+        end
+
+        # The array sources a block predicate ranges over, paired with their element type.
+        #
+        # @param depth [Integer] maximum recursive steps remaining for the literals
+        # @return [Array<Array(String, Symbol)>] source text and element type
+        def typed_array_sources(depth)
+          [
+            ["arr_num", :numeric], [numeric_array_literal(depth), :numeric],
+            ["arr_str", :string], [string_array_literal(depth), :string]
+          ]
+        end
+
+        # The predicate body a block gets: `boolean_productions` with `BLOCK_PARAM` also a leaf.
+        # Sampled because each body is multiplied by three modes and four array sources.
+        #
+        # @param element_type [Symbol] the type `BLOCK_PARAM` is bound to inside the block
+        # @param depth [Integer] maximum recursive steps remaining for the body
+        # @return [Array<String>] a sampled set of boolean expressions
+        def predicate_bodies(element_type, depth)
+          sample(with_element_leaf(element_type) { boolean_productions(depth) })
+        end
+
+        # `haystack.include?(needle)`: a String haystack needs a String needle, an Array
+        # haystack admits any needle type.
+        #
+        # @param depth [Integer] maximum recursive steps remaining
+        # @return [Array<String>] `include?` expressions for string and array haystacks
+        def include_productions(depth)
+          str = bounded(:string, depth)
+          pairs(str).map { |haystack, needle| "#{haystack}.include?(#{needle})" } +
+            sample(numeric_array_productions(depth)).product(bounded(:numeric, depth)).map do |arr, needle|
+              "#{arr}.include?(#{needle})"
+            end +
+            sample(string_array_productions(depth)).product(bounded(:string, depth)).map do |arr, needle|
+              "#{arr}.include?(#{needle})"
+            end
+        end
+      end
+    end
+  end
+end