hecks 4.0.0 → 6.0.0

data/lib/hecks/quality_control/quality_control.ports.hecksagon

@@ -1,5 +1,5 @@
-# The ports QualityControl declares, for every hecksagon that attaches the chapter (`Chapters`
-# loads this file with it). Persistence is the attaching hecksagon's: the Hecks chapter binds
+# The ports QualityControl declares, for every hecksagon that attaches the bluebook (`Bluebooks`
+# loads this file with it). Persistence is the attaching hecksagon's: the Hecks bluebook binds
 # every aggregate through its world's `default_adapter`, and the QA ledger binds its own
 # (qa/bluebook/quality_control.hecksagon).
 Hecks.hecksagon "QualityControl" do
@@ -32,6 +32,7 @@ Hecks.hecksagon "QualityControl" do
     answers_query "Seed"
     answers_query "CheckGeneratedDomains"
     answers_query "MineCombinations"
+    answers_query "Mutate"
     answers_query "JudgeNovelty"
     answers_query "DiscoverExternalDomains"
   end

data/lib/hecks/query_ir/rules.rb

@@ -8,11 +8,11 @@ module Hecks
       # Object identity carries no signal: `MetaValidator.call` rebuilds the graph from flat rows,
       # so a bare `given("x")` reference and its block declaration are distinct objects by then.
       # @param registry [Runtime::Registry] the booted registry to walk
-      # @param chapter_name [String, nil] one chapter to walk, every booted chapter when nil
+      # @param declaration_name [String, nil] one bluebook to walk, every booted bluebook when nil
       # @return [Array<Rule>]
-      def collect_rules(registry, chapter_name = nil)
-        chapters = chapter_name ? [registry.bluebook(chapter_name)] : registry.bluebooks.values
-        chapters.flat_map { |chapter| chapter.aggregates.flat_map { |aggregate| aggregate_rules(aggregate) } }
+      def collect_rules(registry, declaration_name = nil)
+        declarations = declaration_name ? [registry.bluebook(declaration_name)] : registry.bluebooks.values
+        declarations.flat_map { |declaration| declaration.aggregates.flat_map { |aggregate| aggregate_rules(aggregate) } }
       end
 
       # A rule's owner: the path a "(declared)" location names, or a command-level location
@@ -51,10 +51,10 @@ module Hecks
       end
 
       def duplicate_groups(all_rules)
-        all_rules.group_by { |r| [r.kind, r.description, r.canonical] }
-                 .map { |key, rules| [key, rules, declaration_count(rules)] }
-                 .select { |_, _, count| count > 1 }
-                 .map do |(kind, description, canonical), rules, _|
+        counted = all_rules.group_by { |r| [r.kind, r.description, r.canonical] }
+                           .map { |key, rules| [key, rules, declaration_count(rules)] }
+        counted.select { |_, _, count| count > 1 }
+               .map do |(kind, description, canonical), rules, _|
           { kind: kind, description: description, canonical: canonical, locations: rules.map(&:location) }
         end
       end
@@ -102,7 +102,7 @@ module Hecks
       # A rule owned by a nested entity is also covered by a "(declared)" entry anywhere under the
       # same root aggregate, matching the DSL's shared given pool.
       #
-      # Known gap: a bare chapter-wide `given(desc)` reference still shows as its own "(declared)"
+      # Known gap: a bare bluebook-wide `given(desc)` reference still shows as its own "(declared)"
       # owner, because the built IR cannot tell a reference from a declaration. Verify a flagged
       # group by hand before treating it as fresh duplication.
       # @param rules [Array<Rule>] one duplicate-key group's own rules

data/lib/hecks/query_ir/touchpoints.rb

@@ -7,6 +7,9 @@ module Hecks
       # `Assembly::Contracts`; `impact_preview` checks touchpoint 4 only for these.
       RECONSTRUCTION_METHODS = { "Aggregate" => :aggregate, "Entity" => :entity }.freeze
 
+      # The whitespace a line starts with.
+      LEADING_WHITESPACE = /\A\s*/
+
       # Checks the six touchpoints of `.claude/skills/bluebook-construct-creator/SKILL.md` for a
       # construct/field pair. Advisory, not a gate: a `false` can be a legitimate exemption
       # (`Deviations`, `GUARANTEED_BY_CONSTRUCTION`, or the spec-only `META_DOMAIN_KNOWN_GAPS`).
@@ -78,7 +81,7 @@ module Hecks
       def reconstruction_method_source(method_name)
         file, start_line = Hecks::Bluebook::MetaValidator::Reconstruction.instance_method(method_name).source_location
         lines = File.readlines(file)
-        indent = lines[start_line - 1][/\A\s*/]
+        indent = lines[start_line - 1][LEADING_WHITESPACE]
 
         lines[start_line..].take_while { |line| inside_method?(line, indent) }.join
       end
@@ -87,7 +90,7 @@ module Hecks
       # @return [Boolean] whether the line still belongs to the method: blank, indented deeper, or
       #   not the next `def`
       def inside_method?(line, indent)
-        line.strip.empty? || line[/\A\s*/].size > indent.size || !line.lstrip.start_with?("def ")
+        line.strip.empty? || line[LEADING_WHITESPACE].size > indent.size || !line.lstrip.start_with?("def ")
       end
 
       def fuzzer_claims?(name, field)

data/lib/hecks/query_ir.rb

@@ -18,7 +18,7 @@ module Hecks
 
     # Mirrors the conformance spec's MODEL_CONSTRUCTS; kept here because a spec is not a library.
     CONSTRUCTS = {
-      "Bluebook"       => Hecks::Bluebook::Chapter,
+      "Bluebook"       => Hecks::Bluebook::Declaration,
       "Aggregate"      => Hecks::Bluebook::Aggregate,
       "Command"        => Hecks::Bluebook::Command,
       "Entity"         => Hecks::Bluebook::Entity,
@@ -43,8 +43,8 @@ module Hecks
     # @return [Array<Symbol>] the attribute names the self-hosted meta-domain
     #   grammar declares for `name`
     def meta_declared(name)
-      Hecks::Bluebook::MetaValidator.grammar_registry
-                                    .bluebook("Bluebook").aggregate(name).attributes.map(&:name)
+      grammar = Hecks::Bluebook::MetaValidator.grammar_registry.bluebook("Bluebook")
+      grammar.aggregate(name).attributes.map(&:name)
     end
 
     # The structural diff between what a Ruby IR class emits (`ir_spec.keys`) and what the

data/lib/hecks/query_specification/common/comparison.rb

@@ -177,7 +177,7 @@ module Hecks
           return true unless record
 
           # The state lives on the target's lifecycle field, else on `:state`.
-          field = target_ir.lifecycle&.field || :state
+          field = target_ir.lifecycle_field || :state
           comparable(record.state[field]) != state
         end
 

data/lib/hecks/query_specification/common/dsl.rb

@@ -54,11 +54,10 @@ module Hecks
         # @return [OffsetSpec] the offset just recorded
         def offset_impl(value) = @offset = OffsetSpec.new(value: value)
 
-        # Records a cursor declaration. The word parses and round-trips, but both builders
-        # refuse it at `build` (`seal_cursor`) because no interpreter applies it.
+        # Records a cursor declaration: the query pages by this field and identity. `QueryBuilder`
+        # checks it at `build`; a read model still refuses it.
         #
-        # @param value [Symbol, Object] the query argument carrying the cursor, such as
-        #   `:after`, or a literal
+        # @param value [Symbol] the order field the position is read from (`:id` with no order_by)
         # @return [CursorSpec] the cursor just recorded
         def cursor(value) = @cursor = CursorSpec.new(value: value)
 

data/lib/hecks/query_specification/hop_path.rb

@@ -9,7 +9,10 @@ module Hecks
     module HopPath
       module_function
 
-      Hop = Struct.new(:attribute, :target_name, :target, keyword_init: true)
+      Hop = Struct.new(:attribute, :target_name, :target, keyword_init: true) do
+        # @return [Array<Bluebook::Attribute>] the attributes of the aggregate the hop lands on
+        def target_attributes = target.attributes
+      end
 
       # `refusal` is nil when clean, `:unresolvable` when a hop's target is not found,
       # `:too_deep` when the chain exceeds MAX_HOPS.
@@ -52,7 +55,7 @@ module Hecks
       #   starts from
       # @return [Array(Hop, String), nil] the hop and the rest of the path after the first
       #   `/`; the hop's `target` is `nil` when the referenced aggregate is not in the
-      #   declaring chapter. `nil` when the path has no `/` or its head names no reference
+      #   declaring bluebook. `nil` when the path has no `/` or its head names no reference
       # @raise [Bluebook::DSL::Malformed] if the reference has no `declared_in` aggregate
       #   to resolve its target through
       def next_hop(field, attributes)
@@ -62,7 +65,7 @@ module Hecks
         attribute = attributes.find { |candidate| candidate.reference? && hop_name(candidate) == head }
         return nil unless attribute
 
-        hop = Hop.new(attribute: attribute, target_name: attribute.type.target_name, target: attribute.type.resolve)
+        hop = Hop.new(attribute: attribute, target_name: attribute.target_name, target: attribute.target_aggregate)
         [hop, rest]
       end
 
@@ -95,7 +98,7 @@ module Hecks
         hops << hop
         return Plan.new(hops: hops, tail: nil, refusal: :unresolvable) unless hop.target
 
-        walk(rest, hop.target.attributes, hops)
+        walk(rest, hop.target_attributes, hops)
       end
     end
   end

data/lib/hecks/rails_app/bluebook/rails_app.bluebook

@@ -0,0 +1,60 @@
+# The RailsApp bluebook: what a Rails app says of its own pages, beside the domain it drives.
+#
+# Every page is derived from the domain: a list and a form for each creating command, a record
+# page that offers the commands the signed-in person may run. A project declares only what the
+# domain cannot say, as `member` rows of a `value_object "App"` or `"Listing"` in its own bluebook;
+# the aggregates below name every field a row may carry. A project with no rows has pages that
+# work, titled after its Rails application, with a list for each aggregate in the order declared.
+#
+# `hecks-rails` reads the rows when the app boots. Nothing here names a database, a template or a
+# route: the pages are the same code for every domain, and these rows are the only place a project
+# changes them. No command declares a role: the bluebook boots standing alone.
+Hecks.bluebook "RailsApp" do
+  vision "Name a Rails app and shape its lists; every page else is derived from the domain."
+
+  aggregate "App" do
+    description "The shape of the one App row: the name the pages carry and the aggregate the app opens on."
+
+    identified_by :title
+
+    attribute :title, Title
+    attribute :home,  Home, optional: true
+
+    # Shown in the header and the browser tab; the Rails application's own name when no row names one.
+    value_object "Title" do
+      attribute :value, String, matches: :present
+    end
+
+    # The aggregate the root path lists, by its name in the domain; the first aggregate declared when
+    # no row names one.
+    value_object "Home" do
+      attribute :value, String, matches: :present
+    end
+  end
+
+  aggregate "Listing" do
+    description "The shape of one Listing row: how the list of an aggregate is headed and which of its attributes it shows."
+
+    identified_by :aggregate
+
+    attribute :aggregate, AggregateName
+    attribute :label,     Label,   optional: true
+    attribute :columns,   Columns, optional: true
+
+    # The aggregate the row shapes, by its name in the domain.
+    value_object "AggregateName" do
+      attribute :value, String, matches: :present
+    end
+
+    # The heading and navigation entry for the aggregate; its plural name in words when absent.
+    value_object "Label" do
+      attribute :value, String, matches: :present
+    end
+
+    # The attributes shown as columns, comma separated and in order; identity, lifecycle state and
+    # the first scalar attributes when absent.
+    value_object "Columns" do
+      attribute :value, String, matches: :present
+    end
+  end
+end

data/lib/hecks/rails_app/bluebook/rails_app.hecksagon

@@ -0,0 +1,4 @@
+# The RailsApp domain, bound so it boots standing alone.
+Hecks.hecksagon "RailsApp" do
+  persisted_by "Memory"
+end

data/lib/hecks/refused.rb

@@ -0,0 +1,104 @@
+require_relative "vocabulary"
+
+module Hecks
+  # The domain saying no: the parent of every class `Runtime::DOMAIN_REFUSALS` names, so a
+  # driving adapter can `rescue Hecks::Refused` instead of splatting the list. A runtime fault
+  # (`Runtime::StaleWrite`, `Runtime::WiringError`) is not one.
+  #
+  # What sort of no it is (`kind`) and which point of dispatch it came from (`stage`) are rows of
+  # the language's `RefusalClass` vocabulary table, so Ruby, Rust and every client read one table.
+  class Refused < StandardError
+    # The `RefusalClass` rows by refusal name.
+    CLASSES = Hecks::Vocabulary.rows("RefusalClass").to_h { |row| [row["name"], row] }.freeze
+
+    # What a refusal that is not a named domain refusal (the base class, an adapter's narrowing of
+    # one it does not name) is classed as.
+    DEFAULT_CLASS = { "kind" => "refused", "stage" => "state" }.freeze
+
+    # The last constant name of a class's path, such as `NotFound` of `Hecks::Runtime::NotFound`.
+    LAST_NAME = /\w+\z/
+
+    # @return [Symbol, nil] the attribute the refusal is about, when it is about one; the
+    #   first in sorted order when it names several
+    attr_reader :attribute
+
+    # @return [String, nil] the text of the rule that refused (a `given`, `ensures` or invariant)
+    attr_reader :rule
+
+    # @param message [String, nil] the refusal text
+    # @param attribute [Symbol, String, nil] the attribute the refusal is about, if any
+    # @param rule [String, nil] the description of the rule that refused, if a rule did
+    # @param stage [Symbol, String, nil] a narrower stage than the refusal's class implies
+    # @param path [String, nil] a JSON Pointer to the offending value; `/attribute` when omitted
+    def initialize(message = nil, attribute: nil, rule: nil, stage: nil, path: nil)
+      super(message)
+      @attribute = attribute&.to_sym
+      @rule      = rule
+      @stage     = stage&.to_sym
+      @path      = path
+    end
+
+    # What sort of no this is, for an adapter that answers a missing record or a caller who lacks
+    # a role differently from a rule that did not hold.
+    #
+    # @return [Symbol] one of the `RefusalKind` vocabulary rows; `:refused` for a broken rule
+    def kind = classification["kind"].to_sym
+
+    # The point of dispatch the refusal came from.
+    #
+    # @return [Symbol] one of the `DispatchStage` vocabulary rows
+    def stage = @stage || classification["stage"].to_sym
+
+    # The same refusal, placed in a stage: where it was found rather than where its class usually
+    # comes from. A stage the raise site already named is kept.
+    #
+    # @param stage [Symbol, String] a `DispatchStage`
+    # @return [Hecks::Refused] this refusal if it names a stage, else a copy that does
+    def in_stage(stage)
+      return self if @stage
+
+      dup.tap { |copy| copy.stage = stage.to_sym }
+    end
+
+    # The same refusal, placed inside an attribute of the command: a field refused within a value
+    # object is about the value object's attribute, at the path that leads to the field.
+    #
+    # @param name [Symbol, String] the command attribute the refusal came from
+    # @return [Hecks::Refused] this refusal if it is already about `name`, else a re-rooted copy
+    def within(name)
+      return self if @attribute == name.to_sym
+
+      inner = path
+      dup.tap do |copy|
+        copy.attribute = name.to_sym
+        copy.path = "/#{name}#{inner}"
+      end
+    end
+
+    # @return [String, nil] a JSON Pointer to the offending value, such as `/balance/cents`
+    def path = @path || (@attribute && "/#{@attribute}")
+
+    # The refusal as plain data, the shape every client receives.
+    #
+    # @return [Hash{Symbol => Object}] kind, stage, attribute, path, rule and message
+    def to_h
+      { kind: kind, stage: stage, attribute: attribute, path: path, rule: rule, message: message }
+    end
+
+    protected
+
+    attr_writer :attribute, :path, :stage
+
+    private
+
+    def classification
+      self.class.ancestors.each do |ancestor|
+        row = CLASSES[short_name(ancestor)]
+        return row if row
+      end
+      DEFAULT_CLASS
+    end
+
+    def short_name(klass) = klass.to_s[LAST_NAME]
+  end
+end

data/lib/hecks/release/approval.rb

@@ -12,6 +12,9 @@ module Hecks
     # decision is read from git history alone, so it can be made again on any later run. It reads
     # only the Vocabulary table, so `release.yml` can run it with the runner's own Ruby.
     module Approval
+      # The key of a trailer line and the space after its colon: "Release-Approved-By: ".
+      TRAILER_KEY = /\A[^:]*:\s*/
+
       module_function
 
       # @return [String] the trailer key, read from the `Lane` row that feeds a tag
@@ -27,10 +30,14 @@ module Hecks
       # @param message [String] a commit message
       # @return [String, nil] who approved, from the first trailer line with a name, or nil
       def approver(message)
-        line = message.to_s.lines.map(&:strip).find { |text| text.match?(/\A#{Regexp.escape(trailer)}:\s*\S/) }
-        line&.sub(/\A[^:]*:\s*/, "")
+        line = stripped_lines(message).find { |text| text.match?(/\A#{Regexp.escape(trailer)}:\s*\S/) }
+        line&.sub(TRAILER_KEY, "")
       end
 
+      # @param message [String, nil] a commit message
+      # @return [Array<String>] its lines, each stripped
+      def stripped_lines(message) = message.to_s.lines.map(&:strip)
+
       # @param message [String] the message of the commit that set the version
       # @param tag_exists [Boolean] whether the release's tag already stands on origin: a release
       #   that was begun was approved when it began, so finishing it asks again for nothing

data/lib/hecks/release/gem_pin.rb

@@ -8,6 +8,10 @@ module Hecks
       GEM_LINE = /^\s*gem\s+["']hecks["'](?<rest>.*)$/
       SOURCE_OPTION = /\b(?:path|git|github|gitlab|bitbucket|branch|ref|tag):/
       LOCKED = /^    hecks \((?<version>[^)]+)\)/
+      # A quoted argument on a gem line, captured without its quotes.
+      QUOTED = /["']([^"']+)["']/
+      # A version constraint such as "~> 3.1" or "4.0.0", as opposed to an option value.
+      VERSION_CONSTRAINT = /\A\s*(?:[~><=!]+\s*)?\d/
 
       # What `resolve` found.
       #
@@ -43,8 +47,8 @@ module Hecks
       private
 
       def gemfiles(root)
-        Dir.glob("**/Gemfile", base: root).reject { |rel| rel.include?("node_modules/") }.sort
-           .map { |rel| File.join(root, rel) }
+        found = Dir.glob("**/Gemfile", base: root).reject { |rel| rel.include?("node_modules/") }
+        found.sort.map { |rel| File.join(root, rel) }
       end
 
       def pin_for(gemfile, root)
@@ -77,7 +81,7 @@ module Hecks
       end
 
       def newest_allowed(rest, rel)
-        constraints = rest.scan(/["']([^"']+)["']/).flatten.grep(/\A\s*(?:[~><=!]+\s*)?\d/)
+        constraints = rest.scan(QUOTED).flatten.grep(VERSION_CONSTRAINT)
         version = @published.newest_satisfying(Gem::Requirement.new(*constraints))
         raise Error, "no published hecks release satisfies the constraint in #{rel}" unless version
 

data/lib/hecks/release/lane.rb

@@ -2,7 +2,7 @@ require "hecks/vocabulary"
 
 module Hecks
   module Release
-    # The lane a release is cut from, read from the `Lane` rows of the Vocabulary chapter.
+    # The lane a release is cut from, read from the `Lane` rows of the Vocabulary bluebook.
     #
     # A release ships what the gates passed, so it is cut from the guarded lane that feeds a tag
     # (`stable`, which feeds `edge`), never from the lane that takes pushes with no gate.

data/lib/hecks/release/runner/clean_tree.rb

@@ -16,6 +16,9 @@ module Hecks
         # Ignored build output, which the gem leaves out.
         BUILD_OUTPUT = %r{(\A|/)target/?\z}
 
+        # The status code and the space that open a porcelain status line.
+        STATUS_CODE = /\A\S+\s+/
+
         # @param git [#read] runs a git command in the checkout and answers its output
         def initialize(git:)
           @git = git
@@ -24,7 +27,7 @@ module Hecks
         # @return [Array<String>] each modified, untracked or ignored path under the packaged paths
         def stray
           lines = @git.read("status", "--porcelain", "--ignored", "--", *SHIPPED).lines.map(&:strip)
-          lines.reject(&:empty?).map { |line| line.sub(/\A\S+\s+/, "") }.grep_v(BUILD_OUTPUT)
+          lines.reject(&:empty?).map { |line| line.sub(STATUS_CODE, "") }.grep_v(BUILD_OUTPUT)
         end
 
         # @return [void]

data/lib/hecks/release/runner/console.rb

@@ -50,7 +50,8 @@ module Hecks
 
           @out.print("#{question} [y/N] ")
           @out.flush
-          %w[y yes].include?(@input.gets.to_s.strip.downcase)
+          answer = @input.gets.to_s.strip
+          %w[y yes].include?(answer.downcase)
         end
       end
     end

data/lib/hecks/router/aggregate_reader.rb

@@ -10,12 +10,11 @@ module Hecks
         #   query/command-only entry
         #   whose owner isn't a real aggregate root
         def self.for(entry)
-          domain = entry.fqn.domain
-          aggregate = entry.dispatcher.registry.bluebook(domain)&.aggregate(entry.fqn.aggregate)
-          new(entry.dispatcher, domain, aggregate) if aggregate
+          aggregate = entry.aggregate
+          new(entry.dispatcher, entry.domain, aggregate) if aggregate
         end
 
-        def repository = dispatcher.registry.repository(domain, aggregate)
+        def repository = dispatcher.repository(domain, aggregate)
 
         def events
           fqn = "#{domain}::#{aggregate.hecks_name}"

data/lib/hecks/router/namespace_installer.rb

@@ -24,11 +24,18 @@ module Hecks
 
       attr_reader :router
 
-      def current_entries = router.available.reject { |entry| entry.fqn.version }
+      def current_entries = router.available.reject { |entry| pinned?(entry.fqn) }
+
+      def aggregate_entries = current_entries.reject { |entry| domain_level?(entry.fqn) }
+
+      def pinned?(fqn) = !fqn.version.nil?
+
+      def domain_level?(fqn) = fqn.aggregate.nil?
 
       def install_namespace_entry(entry)
-        target = namespace_for(entry.fqn.realm, entry.fqn.domain, entry.fqn.aggregate)
-        define_options(target, entry.fqn)
+        fqn = entry.fqn
+        target = namespace_at(fqn)
+        define_options(target, fqn)
         define_verb(target, entry)
       end
 
@@ -42,24 +49,24 @@ module Hecks
 
       def define_verb(target, entry)
         active_router = router
-        address = entry.fqn.to_s
+        fqn = entry.fqn
+        address = fqn.to_s
         route = entry.command? ? :dispatch : :query
-        target.define_singleton_method(entry.fqn.verb) { |**args| active_router.public_send(route, address, **args) }
+        target.define_singleton_method(fqn.verb) { |**args| active_router.public_send(route, address, **args) }
       end
 
       # `.find`/`.all`/`.count`/`.events`/`.repository`, matching `Hecks.boot`'s
       # module; grouped by (realm, domain, aggregate) since the five don't vary by verb.
       def install_aggregate_modules!
-        current_entries.reject { |entry| entry.fqn.aggregate.nil? }
-                       .group_by { |entry| [entry.fqn.realm, entry.fqn.domain, entry.fqn.aggregate] }
-                       .each_value { |entries| install_aggregate_module(entries.first) }
+        aggregate_entries.group_by { |entry| aggregate_key(entry.fqn) }
+                         .each_value { |entries| install_aggregate_module(entries.first) }
       end
 
       def install_aggregate_module(entry)
         reader = AggregateReader.for(entry)
         return unless reader
 
-        define_module_methods(namespace_for(entry.fqn.realm, entry.fqn.domain, entry.fqn.aggregate), reader)
+        define_module_methods(namespace_at(entry.fqn), reader)
       end
 
       def define_module_methods(target, reader)
@@ -71,16 +78,19 @@ module Hecks
       end
 
       def install_shortcuts!
-        current_entries.reject { |entry| entry.fqn.aggregate.nil? }
-                       .group_by { |entry| [entry.fqn.aggregate, entry.fqn.verb] }
-                       .each { |(aggregate, verb), candidates| install_shortcut(aggregate, verb, candidates) }
+        aggregate_entries.group_by { |entry| shortcut_key(entry.fqn) }
+                         .each { |(aggregate, verb), candidates| install_shortcut(aggregate, verb, candidates) }
       end
 
+      def aggregate_key(fqn) = [fqn.realm, fqn.domain, fqn.aggregate]
+
+      def shortcut_key(fqn) = [fqn.aggregate, fqn.verb]
+
       def install_shortcut(aggregate, verb, candidates)
-        # Bounded chapters wrap in their own module (`Domain::Aggregate`) so two
+        # Bounded bluebooks wrap in their own module (`Domain::Aggregate`) so two
         # BCs can both declare `Person` without colliding on `Object::Person`.
-        # Folder-spread files of the same chapter aren't BCs, so they still get it.
-        return if bounded_chapter?(candidates)
+        # Folder-spread files of the same bluebook aren't BCs, so they still get it.
+        return if bounded_bluebook?(candidates)
 
         installer = self
         shortcut_target(aggregate).define_singleton_method(verb) do |**args|
@@ -88,10 +98,12 @@ module Hecks
         end
       end
 
-      def bounded_chapter?(candidates)
-        candidates.any? { |entry| entry.dispatcher.registry.bounded?(entry.fqn.domain) }
+      def bounded_bluebook?(candidates)
+        candidates.any? { |entry| entry.dispatcher.bounded?(domain_of(entry.fqn)) }
       end
 
+      def domain_of(fqn) = fqn.domain
+
       def dispatch_short(candidates, **args)
         raise AmbiguousShortRoute, ambiguity_message(candidates) if candidates.length > 1
 
@@ -114,6 +126,8 @@ module Hecks
         constant || Object.const_set(aggregate, Module.new)
       end
 
+      def namespace_at(fqn) = namespace_for(fqn.realm, fqn.domain, fqn.aggregate)
+
       def namespace_for(realm, domain, aggregate)
         [realm, domain, aggregate].compact.reduce(Object) do |parent, name|
           constant = parent.const_get(name, false) if parent.const_defined?(name, false)

data/lib/hecks/router.rb

@@ -86,7 +86,7 @@ module Hecks
       entry = resolve(address)
       raise WrongVerbKind, "#{address.inspect} names a query; use #query" unless entry.command?
 
-      entry.dispatcher.dispatch_flat(local_verb(entry), args)
+      entry.dispatcher.dispatch_flat(entry.local_verb, args)
     end
 
     # Queries a resolved aggregate, entity, or read model.
@@ -105,15 +105,7 @@ module Hecks
       entry = resolve(address)
       raise WrongVerbKind, "#{address.inspect} names a command; use #dispatch" unless entry.query?
 
-      entry.dispatcher.query(local_verb(entry), **args)
-    end
-
-    private
-
-    def local_verb(entry)
-      return "#{entry.fqn.domain}.#{entry.declared_verb}" unless entry.fqn.aggregate
-
-      "#{entry.fqn.domain}::#{entry.fqn.aggregate}.#{entry.declared_verb}"
+      entry.dispatcher.query(entry.local_verb, **args)
     end
   end
 end