hecks 1.0.2 → 1.1.0

data/lib/hecks/bluebook/dsl/command_builder.rb

@@ -2,8 +2,13 @@ require_relative "word_gate"
 module Hecks
   module Bluebook
     module DSL
+      # The `command "Name" do ... end` receiver — collects a command's
+      # `role`/`goal`/`given`/`ensures`/`sets`/`emits`/`delegates_to`/
+      # `corrects` declarations, resolves implicit attributes a bare `sets
+      # :field` or `append:` self-reference imports from the owner
+      # (`#resolve_implicit_attributes!`), and builds the final `Command`.
       class CommandBuilder
-        GRAMMAR_CONTEXT = "Command"
+        GRAMMAR_CONTEXT = "Command".freeze
 
         include AttributeCollector
         include RuleReference
@@ -67,10 +72,12 @@ module Hecks
         # declares a role), so also named in
         # `GenericDispatch::BOOTSTRAP_CALLS_FALLBACK`.
         def role_impl(value)
-          raise Malformed,
-                "#{@name} declares role twice — a command carries ONE " \
-                "responsibility; the second would silently win and the " \
-                "first would still look declared" if @role
+          if @role
+            raise Malformed,
+                  "#{@name} declares role twice — a command carries ONE " \
+                  "responsibility; the second would silently win and the " \
+                  "first would still look declared"
+          end
 
           @role = value
         end
@@ -104,7 +111,7 @@ module Hecks
           # one thing it exists to say. Transfer has said
           # `reference_to Account, as: :source` for as long as banking has existed;
           # this is the same sentence when the target happens to be the owner.
-          return cross_reference(demodulised, as, optional) if as || demodulised.to_s != @owner.to_s
+          return cross_reference(demodulised, as, optional: optional) if as || demodulised.to_s != @owner.to_s
 
           if @references
             raise Malformed,
@@ -118,7 +125,7 @@ module Hecks
 
         private
 
-        def cross_reference(target, as, optional = false)
+        def cross_reference(target, as, optional: false)
           attribute_impl(as || default_reference_name(target), Reference.new(target), optional: optional)
         end
 
@@ -308,8 +315,8 @@ module Hecks
         # dedicated, `status: "deprecated"` Keyword row (syntax.bluebook)
         # rather than living only as `sets`'s own `was:` — see that
         # row's own comment for why.
-        def then_set_impl(target, positional_to = UNSET, **kwargs)
-          return legacy_then_set(target, positional_to, **kwargs) if MetaValidator.shadow_parsing?
+        def then_set_impl(target, positional_to = UNSET, **)
+          return legacy_then_set(target, positional_to, **) if MetaValidator.shadow_parsing?
 
           raise Malformed, "#{@name}'s then_set is gone — sets is the word now"
         end
@@ -478,8 +485,13 @@ module Hecks
                                      source: { as: as&.to_s, reason: reason.to_s, reverses: reverses })
         end
 
+        # THE EFFECTS THAT WRITE A FIELD OF THE RECORD — `delegate` and
+        # `corrects` name a command and an event, never a field.
+        FIELD_EFFECTS = %i[set append remove increment decrement multiply clamp].freeze
+
         def build
           resolve_implicit_attributes!
+          refuse_duplicate_targets!
 
           delegation = @mutations.find { |mutation| mutation.op == :delegate }
           if delegation && (@mutations.size > 1 || @emits.any?)
@@ -515,6 +527,27 @@ module Hecks
 
         private
 
+        # C4.2 (docs/semantics/bluebook-semantics.md) — a command's effects
+        # are ONE UPDATE SET over the pre-dispatch state, so a field
+        # written twice has no meaning to give: last-wins would make
+        # declaration order significant, which the update set says it is
+        # not. Refused here, where the declaration can still be read whole.
+        def refuse_duplicate_targets!
+          return if MetaValidator.shadow_parsing? # frozen era text is history
+
+          seen = {}
+          @mutations.each do |mutation|
+            next unless FIELD_EFFECTS.include?(mutation.op)
+
+            if (earlier = seen[mutation.target.to_sym])
+              raise Malformed,
+                    "#{@name} writes #{mutation.target} twice (#{earlier.op} and #{mutation.op}) — a command's " \
+                    "effects are one update set over the pre-dispatch state, so each field is written at most once"
+            end
+            seen[mutation.target.to_sym] = mutation
+          end
+        end
+
         # RESOLUTION RULES — see `docs/resolution-rules/README.md` for the
         # precise, language-agnostic algorithm each of `resolve_bare_set!`/
         # `resolve_append_fields!` implements (`implicit-command-attributes.md`
@@ -563,8 +596,8 @@ module Hecks
           # it for an ordering accident this language has never required
           # authors to avoid. rubocop's Style/CombinableLoops can't see
           # that dependency — it only sees two `@mutations.each` calls
-          # back to back — so it's disabled here, not satisfied.
-          # rubocop:disable-next Style/CombinableLoops
+          # back to back — which is exactly why it's disabled repo-wide
+          # (see .rubocop.yml) rather than satisfied.
           @mutations.each { |mutation| refuse_unknown_argument_sources!(mutation) }
         end
 
@@ -674,6 +707,13 @@ module Hecks
         # the naive append; every OTHER field in the same hash did not,
         # caught by this codemod's own reboot-and-diff safety net rather
         # than silently landing wrong.
+        # `anchor` is a snapshot of `present`'s position, taken BEFORE
+        # `attributes.reject!` mutates the array below it — see this
+        # method's own header comment for why: a naive append-at-end
+        # silently scrambled real corpus field order (Keyword#was/
+        # Argument#variadic). Splitting the snapshot from the mutation it
+        # guards is exactly the ordering invariant that must not move.
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def resolve_append_fields!(mutation)
           return unless mutation.source.is_a?(Hash)
 
@@ -755,8 +795,8 @@ module Hecks
         # downstream read it — at dispatch (`MutationApplier#appended`),
         # at IR emission (`Mutation#appended_fields`), and in the
         # meta-validator's own Judge (`Readings#mutation_rows`). #138.
-        def normalize_append_source(op, source)
-          return source unless op == :append
+        def normalize_append_source(oper, source)
+          return source unless oper == :append
           return source if source.is_a?(::Hash)
 
           { value: source }

data/lib/hecks/bluebook/dsl/const_shim.rb

@@ -1,6 +1,12 @@
 module Hecks
   module Bluebook
     module DSL
+      # A global (Object-level, via `Hook` prepended below) `const_missing`
+      # bridge — `.with(resolver) { ... }` installs a resolver for the
+      # dynamic extent of a block, so a bare, not-yet-declared constant
+      # inside a DSL block (a bareword type, `Domain::Aggregate`, ...)
+      # resolves to whatever that DSL context needs (a name, a
+      # `BindingProxy`, a `ScopedConstant`) instead of raising `NameError`.
       module ConstShim
         class << self
           attr_accessor :resolver

data/lib/hecks/bluebook/dsl/domain_port_builder.rb

@@ -2,8 +2,15 @@ require_relative "word_gate"
 module Hecks
   module Bluebook
     module DSL
+      # Parses a `domain_port "Name" do ... end` block into a `DomainPort` —
+      # the inbound (`operation`/`tells`) and outbound (`asks`) operations a
+      # domain exchanges with the outside world. Falls back to building a
+      # plain `Port` (the same object `PortBuilder` builds) when the block is
+      # bare-verb shaped instead, so an existing top-level `.port` file can
+      # migrate to being parsed by this builder — see `legacy_bare_port:`'s
+      # own comment on `#initialize`.
       class DomainPortBuilder
-        GRAMMAR_CONTEXT = "DomainPort"
+        GRAMMAR_CONTEXT = "DomainPort".freeze
 
         include WordGate
 
@@ -43,8 +50,8 @@ module Hecks
         # — the routing between the two spellings now lives in the table,
         # not in a Ruby `alias`. Not bootstrap-reachable (checked
         # directly), so no BOOTSTRAP_CALLS_FALLBACK entry needed.
-        def tells_impl(name, to: nil, &block)
-          @operations << PortOperationBuilder.build(name, to: to, owner: @owner, direction: :inbound, &block)
+        def tells_impl(name, to: nil, &)
+          @operations << PortOperationBuilder.build(name, to: to, owner: @owner, direction: :inbound, &)
         end
 
         # WHAT WE ASK OF THE OUTSIDE — the direction this language did not
@@ -57,8 +64,8 @@ module Hecks
         #
         # RENAMED FROM `asks` — item #13's full metaprogrammed dispatch
         # (slice 4c), same reasoning as tells_impl above.
-        def asks_impl(name, to: nil, &block)
-          @operations << PortOperationBuilder.build(name, to: to, owner: @owner, direction: :outbound, &block)
+        def asks_impl(name, to: nil, &)
+          @operations << PortOperationBuilder.build(name, to: to, owner: @owner, direction: :outbound, &)
         end
 
         # THE DRIVEN HALF OF THE SAME WORD. `operation`/`emits` translates an
@@ -101,9 +108,15 @@ module Hecks
         def answers(name) = @answers << name.to_sym
 
         def build
-          raise Malformed, "#{@name} declares both a verb and operations — a port is one or the other, not both" if @verb && !@operations.empty?
+          if @verb && !@operations.empty?
+            raise Malformed,
+                  "#{@name} declares both a verb and operations — a port is one or the other, not both"
+          end
 
-          return MetaValidator.call_port(Port.new(name: @name, verb: @verb, signal: @signal, answers: @answers)) if @verb || (@legacy_bare_port && @operations.empty?)
+          if @verb || (@legacy_bare_port && @operations.empty?)
+            return MetaValidator.call_port(Port.new(name: @name, verb: @verb, signal: @signal,
+                                                    answers: @answers))
+          end
 
           raise Malformed, "#{@name} declares no verb and no operations" if @operations.empty?
 

data/lib/hecks/bluebook/dsl/entity_builder.rb

@@ -2,8 +2,16 @@ require_relative "word_gate"
 module Hecks
   module Bluebook
     module DSL
+      # Parses an `entity "Name" do ... end` block nested inside an aggregate
+      # (or another entity, ADR 0026 — "a piece nested inside a piece") into
+      # an `Entity` — attributes, relationships (`has_many`/`has_one`/
+      # `belongs_to`), its own nested commands/queries/lifecycle, and
+      # preconditions shared across them. Threads the owning aggregate's
+      # value-object and cross-entity `given` pools through unchanged, so a
+      # nested piece resolves identity and shared rules against the same
+      # aggregate-wide state a top-level piece does.
       class EntityBuilder
-        GRAMMAR_CONTEXT = "Entity"
+        GRAMMAR_CONTEXT = "Entity".freeze
 
         include AttributeCollector
         include IdentityDeclaration
@@ -80,7 +88,8 @@ module Hecks
         # rubocop:disable Naming/PredicatePrefix
         def has_many_impl(type, as: nil, **options)
           unless options.empty?
-            raise Malformed, "#{@name}.has_many takes no #{options.keys.first}: — an empty list already means none"
+            raise Malformed,
+                  "#{@name}.has_many takes no #{options.keys.first}: — an empty list already means none"
           end
 
           plural = Naming.demodulise(type)
@@ -139,8 +148,8 @@ module Hecks
           @pending_entities << [name, block]
         end
 
-        def lifecycle_impl(field, default:, &block)
-          @lifecycle = LifecycleBuilder.build(field, default: default, &block)
+        def lifecycle_impl(field, default:, &)
+          @lifecycle = LifecycleBuilder.build(field, default: default, &)
         end
 
         # A PRECONDITION SHARED ACROSS THIS PIECE'S OWN COMMANDS, DECLARED
@@ -400,10 +409,22 @@ module Hecks
         # See `AggregateBuilder#seal_lifecycle_guards`'s own comment —
         # the identical check, one level down.
         def seal_lifecycle_guards
-          return if @lifecycle
-
           @commands.each do |command|
+            if @lifecycle && !MetaValidator.shadow_parsing?
+              # C5.3 — the same refusal `AggregateBuilder::Sealing` gives
+              # an aggregate: a `sets` on the lifecycle field (frozen era
+              # text excepted, as there).
+              command.mutations.each do |mutation|
+                next if [:delegate, :corrects].include?(mutation.op)
+                next unless mutation.target.to_sym == @lifecycle.field.to_sym
+
+                raise Malformed,
+                      "#{@name}.#{command.hecks_name} sets #{mutation.target}, #{@name}'s lifecycle field — " \
+                      "a lifecycle field moves only by transition; declare one instead of setting it"
+              end
+            end
             next unless command.from
+            next if @lifecycle
 
             raise Malformed,
                   "#{@name}.#{command.hecks_name} guards from: #{Array(command.from).inspect}, but " \

data/lib/hecks/bluebook/dsl/generic_dispatch.rb

@@ -269,7 +269,8 @@ module Hecks
             # would silently execute as a no-op instead of raising the
             # same "not yet implemented" refusal a genuinely unmigrated
             # word already gets.
-            raise Runtime::WiringError, "no dispatcher handles shape #{shape[:kind].inspect} — add one before shape_for can produce it"
+            raise Runtime::WiringError,
+                  "no dispatcher handles shape #{shape[:kind].inspect} — add one before shape_for can produce it"
           end
         end
 
@@ -277,6 +278,13 @@ module Hecks
         # which of the four safe shapes (context, word) is, or `nil` if
         # it falls outside this slice's own verified scope. No argument
         # values are read here; this only ever looks at the table.
+        #
+        # An early-return classification chain: each `return` depends on
+        # locals (`calls`, `fills`, `arguments`, `arg`) computed by the
+        # checks before it. Splitting per shape would mean re-deriving or
+        # threading those locals across method boundaries for a
+        # classification that is only ever read top-to-bottom once, here.
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def shape_for(context, word, rows)
           keyword = rows[:keywords].find { |k| k[:context] == context && k[:word] == word && k[:status] != "retired" }
           return nil unless keyword
@@ -333,7 +341,9 @@ module Hecks
           raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0)" unless args.empty?
 
           rows = MetaValidator::SyntaxBoot.call[:keywords]
-          siblings = rows.count { |k| k[:context] == keyword[:context] && k[:fills] == keyword[:fills] && k[:status] != "retired" }
+          siblings = rows.count do |k|
+            k[:context] == keyword[:context] && k[:fills] == keyword[:fills] && k[:status] != "retired"
+          end
           value = siblings > 1 ? keyword[:word].to_sym : true
 
           builder.instance_variable_set(:"@#{keyword[:fills]}", value)

data/lib/hecks/bluebook/dsl/hecksagon_builder.rb

@@ -2,8 +2,15 @@ require_relative "word_gate"
 module Hecks
   module Bluebook
     module DSL
+      # Parses a `.hecksagon` file's top-level DSL block into a `Hecksagon`
+      # — a domain's own WIRING: which adapter binds to which verb
+      # (`persisted_by`, `projected_by`, ...), which framework/vendored
+      # bluebooks it attaches, which external events it subscribes to, and
+      # its bare chapter-root port. Kept separate from the bluebook itself
+      # (the domain's own declared MODEL) because wiring is an operational
+      # decision, not a fact the domain states about itself.
       class HecksagonBuilder
-        GRAMMAR_CONTEXT = "Hecksagon"
+        GRAMMAR_CONTEXT = "Hecksagon".freeze
 
         include WordGate
 

data/lib/hecks/bluebook/dsl/identity_declaration.rb

@@ -39,14 +39,24 @@ module Hecks
         # and Entity Keyword rows name it in `calls:`. Bootstrap-
         # reachable (every self-hosted aggregate/entity declares an
         # identity), so in BOOTSTRAP_CALLS_FALLBACK for both contexts.
+        # Dispatches across the three live forms documented above (value-
+        # object + block, single type target, single/compound field
+        # target), each an early return that sets exactly one pending
+        # ivar. Splitting per form would need each branch's own `return`-
+        # with-nil semantics and the shared `@name`/`identity_pool`
+        # threaded back out as parameters, for no gain beyond what the
+        # three-forms comment above already documents.
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def identified_by_impl(*targets, as: nil, &definition)
           return legacy_identified_by(*targets, as: as, &definition) if MetaValidator.shadow_parsing?
 
           refuse_second_identity!
 
           if definition
-            raise Malformed,
-                  "#{@name}.identified_by cannot combine a value-object type with a block" unless targets.empty?
+            unless targets.empty?
+              raise Malformed,
+                    "#{@name}.identified_by cannot combine a value-object type with a block"
+            end
 
             type_name = identity_value_object_name
             value_object =
@@ -56,7 +66,7 @@ module Hecks
                   owner_value_objects: identity_pool,
                   &definition
                 )
-              rescue NameError => error
+              rescue NameError => e
                 # A REMOVED SPELLING MUST REFUSE LOUDLY, not degrade into a raw
                 # Ruby error — the one contract `EraGuard.shadow_parse` leans
                 # on to know a normal parse genuinely could not read this text
@@ -73,11 +83,9 @@ module Hecks
                 # precisely this text.
                 raise Malformed,
                       "#{@name}.identified_by do ... end could not be read as a value-object " \
-                      "definition: #{error.message}"
+                      "definition: #{e.message}"
               end
-            if value_object.attributes.empty?
-              raise Malformed, "#{@name}.identified_by do declares no identity attributes"
-            end
+            raise Malformed, "#{@name}.identified_by do declares no identity attributes" if value_object.attributes.empty?
 
             install_identity_value_object!(value_object)
             @identity_type_pending = [value_object, as || :identity, attributes.size]
@@ -93,8 +101,10 @@ module Hecks
 
           if targets.one?
             field = targets.first
-            raise Malformed,
-                  "#{@name}.identified_by takes no as: — name the declared field itself" if as
+            if as
+              raise Malformed,
+                    "#{@name}.identified_by takes no as: — name the declared field itself"
+            end
             # Transitional compatibility: the self-hosted language and live
             # corpus still contain this form. Keep it readable until their
             # exemplar-led migration is complete; the final lifecycle cutover
@@ -170,8 +180,10 @@ module Hecks
             if identity_type?(target)
               @identity_type_pending = [target, as, attributes.size]
             else
-              raise Malformed,
-                    "#{@name}.identified_by :#{target} takes no as: — as: only applies to identified_by ValueObject" if as
+              if as
+                raise Malformed,
+                      "#{@name}.identified_by :#{target} takes no as: — as: only applies to identified_by ValueObject"
+              end
 
               @identity_field_pending = target
             end
@@ -180,7 +192,7 @@ module Hecks
 
           raise Malformed, "#{@name}.identified_by names no field" unless path
 
-          paths = Ports::Extraction.canonical(path).to_s.split(" ").reject(&:empty?)
+          paths = Ports::Extraction.canonical(path).to_s.split.reject(&:empty?)
           raise Malformed, "#{@name}.identified_by names no field" if paths.empty?
 
           @identity_paths = paths

data/lib/hecks/bluebook/dsl/lifecycle_builder.rb

@@ -2,8 +2,13 @@ require_relative "word_gate"
 module Hecks
   module Bluebook
     module DSL
+      # Parses a `lifecycle :field, default: ... do transition ... end`
+      # block into a `Lifecycle` — the field an aggregate or entity's own
+      # state machine lives on, its starting value, and the `command =>
+      # target_state` transition table (with an optional `from:` guard)
+      # each `transition_impl` call adds a row to.
       class LifecycleBuilder
-        GRAMMAR_CONTEXT = "Lifecycle"
+        GRAMMAR_CONTEXT = "Lifecycle".freeze
 
         include WordGate
 
@@ -30,6 +35,7 @@ module Hecks
         end
 
         def build
+          refuse_ambiguity!
           Lifecycle.new(field: @field, default: @default, transitions: @transitions)
         end
 
@@ -38,6 +44,39 @@ module Hecks
           builder.instance_eval(&block) if block
           builder.build
         end
+
+        private
+
+        # C5.3 (docs/semantics/bluebook-semantics.md) — two transitions for
+        # one command whose `from:` sets overlap (or where either has no
+        # `from:` at all) were silently first-wins; refused where the state
+        # machine can be read whole. Two transitions for one command from
+        # DISJOINT states are the legitimate shape (`match_transition`
+        # picks by the current state) and stay. A `from:` naming a state
+        # nothing declares is NOT refused here: it is a reachability
+        # finding `bin/model_check` already reports (unreachable state,
+        # dead transition), and a bluebook may declare it on purpose.
+        def refuse_ambiguity!
+          return if MetaValidator.shadow_parsing? # frozen era text is history
+
+          @transitions.each_with_index do |(command, transition), index|
+            earlier = @transitions[0...index].find do |other_command, other|
+              other_command == command && overlap?(other, transition)
+            end
+            next unless earlier
+
+            raise Malformed,
+                  "lifecycle :#{@field} declares two transitions for #{command.inspect} from the same state " \
+                  "(=> #{earlier.last.target.inspect} and => #{transition.target.inspect}) — which one fires " \
+                  "would be declaration order; give them disjoint from: states"
+          end
+        end
+
+        def overlap?(one, other)
+          return true if one.from.nil? || other.from.nil?
+
+          Array(one.from).map(&:to_s).intersect?(Array(other.from).map(&:to_s))
+        end
       end
     end
   end

data/lib/hecks/bluebook/dsl/policy_builder.rb

@@ -2,8 +2,14 @@ require_relative "word_gate"
 module Hecks
   module Bluebook
     module DSL
+      # Parses a `policy "Name" do ... end` block into a `Policy` — a
+      # reaction wired at chapter scope: `on` the event it watches, an
+      # optional `where` guard evaluated against the event's own payload, an
+      # optional `for_each` fan-out query, and the `trigger` command it
+      # dispatches (`with:` projecting the event's payload onto the
+      # command's own arguments when the two shapes differ).
       class PolicyBuilder
-        GRAMMAR_CONTEXT = "Policy"
+        GRAMMAR_CONTEXT = "Policy".freeze
 
         include WordGate
 
@@ -100,6 +106,9 @@ module Hecks
                   "could not be read, so no other runtime could ever evaluate it"
           end
 
+          # C3.6 — the same PatternSubset check every rule site gets.
+          Expression::AstJson.refuse_unshared_patterns!(Expression::AstJson.emit_predicate(canonical),
+                                                        owner: @name, word: "where")
           @where = canonical
         end
 

data/lib/hecks/bluebook/dsl/port_builder.rb

@@ -2,8 +2,13 @@ require_relative "word_gate"
 module Hecks
   module Bluebook
     module DSL
+      # Parses a top-level `.port` file's `Hecks.port "Name" do verb "x";
+      # signal :effect end` body into a `Port` — the adapter-facing shape (one
+      # verb, one signal, an optional method contract in `answers`) a domain
+      # calls OUT through, as opposed to `DomainPortBuilder`'s own inbound/
+      # outbound operations.
       class PortBuilder
-        GRAMMAR_CONTEXT = "Port"
+        GRAMMAR_CONTEXT = "Port".freeze
 
         include WordGate
 

data/lib/hecks/bluebook/dsl/port_operation_builder.rb

@@ -2,8 +2,14 @@ require_relative "word_gate"
 module Hecks
   module Bluebook
     module DSL
+      # Parses one `operation`/`tells`/`asks` block inside a `domain_port`
+      # into a `PortOperation` — its own attributes (the external fact's
+      # payload) plus either the events it `emits` (inbound) or the
+      # `answers`/`refuses` pair naming its two possible outcomes (outbound).
+      # `to:` records which aggregate the operation routes to as dispatch
+      # metadata, never as an attribute — see `to:`'s own comment below.
       class PortOperationBuilder
-        GRAMMAR_CONTEXT = "PortOperation"
+        GRAMMAR_CONTEXT = "PortOperation".freeze
 
         include AttributeCollector
         include WordGate
@@ -93,9 +99,11 @@ module Hecks
           # AN INBOUND OPERATION STILL HAS TO SAY SOMETHING. Only inbound: an
           # `asks` says it with `answers`/`refuses` instead, and
           # `refuse_wrong_words!` above has already insisted on both.
-          raise Malformed,
-                "#{@name} declares no emits — an operation with nothing to say " \
-                "afterward is a call into nothing" if !outbound && @emits.empty?
+          if !outbound && @emits.empty?
+            raise Malformed,
+                  "#{@name} declares no emits — an operation with nothing to say " \
+                  "afterward is a call into nothing"
+          end
 
           operation
         end
@@ -119,18 +127,31 @@ module Hecks
         # runtime cannot keep.
         def refuse_wrong_words!(outbound)
           if outbound
-            raise Malformed, "#{@name} is an asks and declares emits — name its two endings with " \
-                             "answers and refuses instead" unless @emits.empty?
-            raise Malformed, "#{@name} declares no answers — an ask with no word for what came " \
-                             "back cannot be reacted to" unless @answers
-            raise Malformed, "#{@name} declares no refuses — an ask that cannot fail is a call " \
-                             "into a system you do not control, pretending otherwise" unless @refuses
+            unless @emits.empty?
+              raise Malformed, "#{@name} is an asks and declares emits — name its two endings with " \
+                               "answers and refuses instead"
+            end
+            unless @answers
+              raise Malformed, "#{@name} declares no answers — an ask with no word for what came " \
+                               "back cannot be reacted to"
+            end
+            unless @refuses
+              raise Malformed, "#{@name} declares no refuses — an ask that cannot fail is a call " \
+                               "into a system you do not control, pretending otherwise"
+            end
           else
-            raise Malformed, "#{@name} is a tells and declares #{@answers ? 'answers' : 'refuses'} — " \
-                             "an inbound fact has no channel back to whoever sent it" if @answers || @refuses
+            if @answers || @refuses
+              raise Malformed, "#{@name} is a tells and declares #{@answers ? 'answers' : 'refuses'} — " \
+                               "an inbound fact has no channel back to whoever sent it"
+            end
           end
         end
 
+        # `private` above (scoping the instance methods between it and here)
+        # doesn't reach a singleton method — correctly so: `.build` is this
+        # builder's real public entry point (DomainPortBuilder calls it),
+        # never meant to be private.
+        # rubocop:disable-next Lint/IneffectiveAccessModifier
         def self.build(name, to: nil, owner: nil, direction: :inbound, &block)
           builder = new(name, to: to, owner: owner, direction: direction)
           builder.instance_eval(&block) if block