hecks 1.2.0 → 1.4.0

data/lib/hecks/runtime/loader.rb

@@ -19,7 +19,7 @@ module Hecks
       # `Widget::Item.Add(...)` sugar. A caller that only ever dispatches
       # by FQN string (`SmokeTest`, the one caller so far) can pass
       # `false` to skip it: `Facade::Surface.install` puts a bare global
-      # Ruby constant on `Object` per domain AND per aggregate name, with
+      # Ruby constant on `Object` per domain and per aggregate name, with
       # no scoping and no cleanup hook, so a tool booting arbitrary
       # throwaway domains under generic names ("Widget", "Item", "Tag")
       # would otherwise leak those names into the rest of the process —
@@ -55,7 +55,7 @@ module Hecks
         install_facade ? bind_runtime(dispatcher) : dispatcher
       end
 
-      # THE OUTBOX'S BOOT-TIME RECONCILIATION — after the dispatcher
+      # The outbox's boot-time reconciliation — after the dispatcher
       # exists (a row's consumer runs through its interpreters, so this
       # cannot be a plain registry gate the way saga rehydration is) and
       # after saga rehydration (a redriven row may advance a saga, which
@@ -69,7 +69,7 @@ module Hecks
         dispatcher.outbox.redrive!
       end
 
-      # THE EXPLICIT-FILE FORM — `paths` names the exact bluebook/hecksagon/
+      # The explicit-file form — `paths` names the exact bluebook/hecksagon/
       # world files to boot, in place, wherever they actually live. `boot`
       # above only ever takes a directory and globs it; that is the right
       # shape for a real deployment (`examples/banking`, a domain someone
@@ -79,16 +79,16 @@ module Hecks
       # (`Hecks::Behaviors`), but this carries no behaviors-specific
       # logic and is not gated behind requiring that module.
       #
-      # NO COPYING, NO TEMP DIRECTORY. A prior port of this same idea
+      # No copying, no temp directory. A prior port of this same idea
       # (vendored into a downstream consumer, read before writing this)
       # scoped a per-test boot by copying files into `Dir.mktmpdir` — which
       # destroys real relative paths, and worse, makes a `persisted_by`
-      # path resolve against the TEMP copy's root instead of the project's
+      # path resolve against the temp copy's root instead of the project's
       # own (confirmed there: a file adapter kept reading and writing the
       # same deterministic tmp copy across an entire session, because
       # `Hecks.boot`'s own `root` is always `File.dirname` of whatever
       # directory it was handed). `directory` here is `File.dirname` of the
-      # FIRST real path in `paths` — genuinely on disk, not a copy — so
+      # first real path in `paths` — genuinely on disk, not a copy — so
       # every downstream path (`EraCheck`, `persisted_by`, `shared_root`)
       # resolves exactly as an ordinary directory boot's would.
       def self.boot_files(paths, shared: nil, install_facade: true, environment: nil)
@@ -110,7 +110,7 @@ module Hecks
       end
 
       # ADR 0031 — replaces two previously-hardcoded, unconditional calls
-      # with a per-boot `BootGates` instance holding exactly the gates THIS
+      # with a per-boot `BootGates` instance holding exactly the gates this
       # registry's own bound adapters have a capability for. Ordering is
       # preserved: era-checking (when a persistence plugin contributes one)
       # still runs before `verify!`, saga rehydration still runs after
@@ -118,7 +118,7 @@ module Hecks
       # comment).
       #
       # ADR 0033 — this loader no longer names `EraCheck`, or any other
-      # era-specific class, at all. Every LOADED persistence plugin
+      # era-specific class, at all. Every loaded persistence plugin
       # (`Ports::Persistence.each_plugin` — nothing here if nothing was
       # ever `require`d) is asked to contribute its own `:pre_verify`/
       # `:post_verify` gates generically; `:saga_rehydration` is the one
@@ -144,7 +144,7 @@ module Hecks
       # `TranslationCompute`/`TranslationRekey` data (`bluebook/
       # translation.rb`, core, no era-specific class involved), so this
       # needs nothing plugin-specific to ask "does anything declare a
-      # compute/rekey rule at all." A LOADED persistence plugin (e.g. the
+      # compute/rekey rule at all." A loaded persistence plugin (e.g. the
       # era plugin's own `:era_compute_rules` gate, registered above) runs
       # the real, adapter-aware version of this check and refuses by name
       # ("...is bound to Memory") long before this ever would; this only
@@ -165,7 +165,7 @@ module Hecks
       end
 
       # `RemoteDispatcher` for a domain routed through Lambda,
-      # `Dispatcher` otherwise — the ONE place this decision gets
+      # `Dispatcher` otherwise — the one place this decision gets
       # made, so everything built on top (`Handle`, `AggregateDoor`,
       # `Facade::Surface`) never has to know which class it's holding.
       # `registry.bluebooks.keys.first` is the just-booted domain's own
@@ -173,7 +173,7 @@ module Hecks
       # any `uses_framework` chapter, `bin/project_rust`'s own header
       # draws the identical distinction), not a directory basename.
       #
-      # `dispatched_by("Lambda")` is its OWN, EXPLICIT verb — NOT
+      # `dispatched_by("Lambda")` is its own, explicit verb — not
       # inferred from `deployed_to("AwsLambda")`'s mere presence. Both
       # Banking's and Embryonaut's `.world` files already declare
       # `deployed_to("AwsLambda")` (it only means "a deploy target
@@ -188,13 +188,13 @@ module Hecks
         settings = registry.world(domain)&.for_verb("dispatched_by") || {}
         return Dispatcher.new(registry) unless settings[:adapter] == "Lambda"
 
-        RemoteDispatcher.new(registry, region: settings.fetch(:region, "us-east-1"))
+        RemoteDispatcher.new(registry, region: settings.fetch(:region, "us-east-1"), function: settings[:function])
       end
 
-      # THE DOOR IS INSTALLED HERE, NOT STAMPED. This used to write the
+      # The door is installed here, not stamped. This used to write the
       # dispatcher onto every aggregate's class (`ruby_class.runtime =`) — the
       # class-level global that made two boots in one process share one
-      # name. The facade's modules close over THIS dispatcher instead, so the
+      # name. The facade's modules close over this dispatcher instead, so the
       # binding lives in the surface a boot installs, not on anything shared.
       def self.bind_runtime(dispatcher)
         Facade::Surface.install(dispatcher)

data/lib/hecks/runtime/outbox.rb

@@ -6,25 +6,25 @@ require_relative "../naming"
 
 module Hecks
   module Runtime
-    # THE TRANSACTIONAL OUTBOX — the durable hand-off between "a command
+    # **The transactional outbox** — the durable hand-off between "a command
     # committed" and "everything that was owed because it committed":
     # the policies that react to its events, the process managers that
     # advance on them, and (through a policy whose trigger is an
     # outbound port operation) the external effects those reactions
     # cause. `future-features.md` item 8, built.
     #
-    # THE SHAPE. One row per (event, consumer). A consumer is a named
+    # **The shape**. One row per (event, consumer). A consumer is a named
     # policy or process manager that would react to the event — resolved
-    # at ENQUEUE time from the registry (`Fanout`), so the outbox records
-    # WHO was owed what, not just that an event happened. Rows move
+    # at enqueue time from the registry (`Fanout`), so the outbox records
+    # who was owed what, not just that an event happened. Rows move
     # `pending → claimed → delivered | failed`:
     #
-    #   pending    written in the SAME adapter transaction as the
+    #   pending    written in the same adapter transaction as the
     #              aggregate save (`Interpreting#run_dispatch_order`
     #              wraps `save` + `emit` + enqueue in `repository.
     #              transaction`), so a row exists iff the state change
     #              it reacts to committed — never one without the other.
-    #   claimed    the relay is about to run this consumer. Set BEFORE
+    #   claimed    the relay is about to run this consumer. Set before
     #              the reaction (a policy's `reenter`, a saga leg's
     #              dispatch, an adapter call) runs.
     #   delivered  the consumer ran to completion — including the
@@ -33,7 +33,7 @@ module Hecks
     #              tracks delivery, not the domain's answer.
     #   failed     the consumer raised a defect (non-refusal error).
     #
-    # DELIVERY IS INLINE BY DEFAULT — the dispatcher drains the rows it
+    # **Delivery is inline by default** — the dispatcher drains the rows it
     # just wrote, in the same call, in the order C10.2 fixes (per event
     # in `emits` order: that event's policy rows, then its saga rows —
     # the emitting domain's own policies before other domains'). Nothing about the
@@ -44,20 +44,20 @@ module Hecks
     # `Relay#redrive!` — run at boot by `Loader.run_boot_gates!` —
     # finds it.
     #
-    # WHAT REDRIVE DOES, AND DELIBERATELY DOESN'T. A `pending` row is
-    # REDRIVEN: its consumer provably never started (claiming is the
+    # **What redrive does, and deliberately doesn't**. A `pending` row is
+    # redriven: its consumer provably never started (claiming is the
     # first thing delivery does), so running it now is exactly-once by
-    # construction. A `claimed` row is NOT auto-redriven: the consumer
+    # construction. A `claimed` row is not auto-redriven: the consumer
     # started and the crash hid its outcome — the same reasoning
     # `saga_pending_dispatch.rb` gives (a stalled transfer is a better
     # defect than a double-credited one). It is surfaced loudly
     # (`warn`, and a `stalled: true` entry in `Relay#log`) and left for
     # `Relay#redrive!(claimed: true)` — an explicit operator decision,
     # never a boot-time default. `delivery_id` (event uid + consumer) is
-    # UNIQUE per store, so a re-enqueue of the same fact to the same
+    # unique per store, so a re-enqueue of the same fact to the same
     # consumer is a no-op rather than a second row.
     #
-    # WHICH ADAPTERS. Memory (in-process rows — visible to specs,
+    # **Which adapters**. Memory (in-process rows — visible to specs,
     # gone with the process, exactly like everything else Memory holds),
     # Sqlite and Postgres (a `hecks_outbox` table in the aggregate's own
     # database — the only way the enqueue can share the save's
@@ -93,7 +93,7 @@ module Hecks
         event.to_h.merge(correlation: event.correlation)
       end
 
-      # THE EMITTING DOMAIN'S OWN BLUEBOOK FIRST, then the rest in load
+      # The emitting domain's own bluebook first, then the rest in load
       # order (C10.2) — the one policy ordering both `PolicyInterpreter#
       # policies_for` and `Fanout.policies` read.
       def bluebooks_home_first(registry, domain)
@@ -121,7 +121,7 @@ module Hecks
         end
       end
 
-      # WHO IS OWED WHAT — the same selection `PolicyInterpreter#policies_for`
+      # **Who is owed what** — the same selection `PolicyInterpreter#policies_for`
       # and `SagaInterpreter#advance` make at delivery time, made once at
       # enqueue time so the row names its consumer. Policy rows first,
       # then saga rows, event order preserved within each: exactly the
@@ -129,13 +129,13 @@ module Hecks
       module Fanout
         module_function
 
-        # ONE UID PER EVENT for this enqueue — the Event struct is
+        # One UID per event for this enqueue — the Event struct is
         # frozen after `emit!`, so the uid lives on the rows rather than
         # on it (and stays off `Event#to_h`, whose shape the golden and
         # parity specs pin). Policy and saga rows for the same event
         # share it, which is what makes `delivery_id` mean "this fact,
         # this consumer".
-        # ROW ORDER IS DELIVERY ORDER (C10.2): per event, in `emits`
+        # Row order is delivery order (C10.2): per event, in `emits`
         # order — that event's policy rows, then its saga rows.
         def rows_for(registry, events, domain)
           uids = events.to_h { |event| [event, SecureRandom.uuid] }
@@ -194,13 +194,13 @@ module Hecks
         end
       end
 
-      # THE RELAY — one per `Dispatcher`. Enqueues into a repository's
+      # **The relay** — one per `Dispatcher`. Enqueues into a repository's
       # store, drains rows inline, and redrives what a previous process
       # left behind.
       class Relay
         attr_reader :registry, :log
 
-        # NOT `saga_log`/`reaction_log` — those are ported byte-for-byte
+        # Not `saga_log`/`reaction_log` — those are ported byte-for-byte
         # by the Rust kernel (`spec/rust_conformance_spec.rb`); this is
         # an additive, Ruby-only log, the same rule `saga_dispatch_log`
         # and `policy_dispatch_log` already follow.
@@ -213,7 +213,7 @@ module Hecks
         # through (`Dispatcher#initialize`). Until then this relay can
         # enqueue (that needs only the registry) but not deliver — and
         # nothing can dispatch without a dispatcher, so nothing asks it
-        # to. The registry holds ONE relay for its lifetime; a second
+        # to. The registry holds one relay for its lifetime; a second
         # dispatcher fronting the same registry re-attaches, which is
         # fine because both dispatchers share every log and store.
         def attach(policies:, sagas:)
@@ -224,7 +224,7 @@ module Hecks
 
         def attached? = !@policies.nil?
 
-        # Called INSIDE the save transaction by `Interpreting` for the
+        # Called inside the save transaction by `Interpreting` for the
         # command/entity paths, and outside one by `Dispatcher` for port
         # operations (which save nothing, so there is no transaction to
         # share). Returns the rows as stored (ids assigned), or nil when
@@ -243,7 +243,7 @@ module Hecks
         # outbox here" — react directly, the pre-outbox path.
         def deliver(rows, events, domain, repository)
           if rows.nil?
-            # PER EVENT, in `emits` order — its policies, then its sagas
+            # Per event, in `emits` order — its policies, then its sagas
             # (C10.2, docs/semantics/bluebook-semantics.md); the same
             # order `Fanout.rows_for` lays the outbox rows in.
             events.each do |event|
@@ -287,9 +287,9 @@ module Hecks
           stores.flat_map { |repository| repository.outbox_rows(status: status) }
         end
 
-        # BOOT-TIME RECONCILIATION. Redrives `pending` rows (never
+        # **Boot-time reconciliation**. Redrives `pending` rows (never
         # claimed — safe by construction); surfaces `claimed` rows and
-        # redrives them ONLY when told to (`claimed: true`).
+        # redrives them only when told to (`claimed: true`).
         def redrive!(claimed: false)
           redriven = []
           stores.each do |repository|

data/lib/hecks/runtime/policy_interpreter.rb

@@ -22,13 +22,13 @@ module Hecks
       end
 
       # `deliver` returns `nil` for a policy whose `where` did not hold —
-      # SILENTLY, the same as a policy `policies_for` never selected at all
+      # silently, the same as a policy `policies_for` never selected at all
       # (an `event_qualifier` miss carries no reaction_log entry either) —
-      # so nothing is appended for it. A `for_each` policy answers an ARRAY
+      # so nothing is appended for it. A `for_each` policy answers an array
       # (one record per matched row) rather than one record ; `Array(...)`
       # is wrong here (it would explode a plain record Hash into its own
       # key/value pairs), so the two shapes are told apart explicitly.
-      # `only:` — ONE `[policy, home_domain]` pair, the outbox relay's
+      # `only:` — one `[policy, home_domain]` pair, the outbox relay's
       # way of running exactly the consumer a row names (`Runtime::
       # Outbox::Relay#run_consumer`) instead of every policy that
       # matches the event. Selection is otherwise identical.
@@ -44,13 +44,13 @@ module Hecks
 
       private
 
-      # SCANS EVERY LOADED BLUEBOOK, not just the emitting command's own —
-      # a policy commonly lives in the CONSUMER's bluebook, reacting
+      # Scans every loaded bluebook, not just the emitting command's own —
+      # a policy commonly lives in the consumer's bluebook, reacting
       # passively to an event a different domain's aggregate emits (the
       # corpus-standard shape : `world/conception/bluebook/domain_cell.bluebook`'s
       # ConceiveOnAbsorption reacts `on "DomainAbsorbed"`, an event
       # `body/organs/bluebook/gut.bluebook`'s Gut.Absorb emits — two
-      # different bluebooks, joined only by the event's NAME). Restricting
+      # different bluebooks, joined only by the event's name). Restricting
       # the scan to the emitting domain's own bluebook (the previous
       # shape) silently drops every cross-domain reaction : the policy is
       # never even a candidate, no refusal, no log entry, nothing —
@@ -58,12 +58,12 @@ module Hecks
       # which encode this exact cross-bluebook cascade as their contract.
       #
       # Returns [policy, home_domain] pairs rather than bare policies —
-      # `deliver`/`deliver_for_each` fall back to the REACTING policy's
-      # OWN domain (not the emitting one) when a trigger or for_each route
+      # `deliver`/`deliver_for_each` fall back to the reacting policy's
+      # own domain (not the emitting one) when a trigger or for_each route
       # is bare, and that fallback has to travel with each match now that
       # a single event can surface policies from several different homes.
       #
-      # THE EMITTING DOMAIN'S OWN POLICIES FIRST, in declaration order,
+      # The emitting domain's own policies first, in declaration order,
       # then other bluebooks' in load order (C10.2) — the same order the
       # outbox lays its rows in (`Outbox::Fanout.policies`) and the Rust
       # kernel runs (`react_policies`: its own table, then cross-domain).
@@ -79,7 +79,7 @@ module Hecks
         end
       end
 
-      # THE GUARD, evaluated against the triggering event's own payload —
+      # The guard, evaluated against the triggering event's own payload —
       # a policy has no aggregate instance of its own to read state from,
       # so `state` is empty and every bare name a `where` resolves comes
       # from `attrs` (Expression::Resolver#fetch checks `attrs` before
@@ -88,7 +88,7 @@ module Hecks
       # policy simply has none of). Called from inside `deliver`'s own
       # rescue-guarded body (both callers, below) — never guarded here —
       # so an EvaluationError (an unresolvable field, a bad comparison) is
-      # caught the SAME way any other reaction defect is, not swallowed as
+      # caught the same way any other reaction defect is, not swallowed as
       # though the policy had merely declined to fire.
       def where_holds?(policy, event)
         return true if policy.where.to_s.empty?
@@ -97,7 +97,7 @@ module Hecks
       end
 
       def deliver(policy, event, domain)
-        # `record` ASSIGNED BEFORE ANY BRANCH THAT CAN RAISE, same reason
+        # `record` assigned before any branch that can raise, same reason
         # `deliver_for_each`'s own header gives : both rescue clauses below
         # call `.merge` on it, and a defect raised before it existed would
         # be caught here only to raise a second, different NoMethodError
@@ -121,7 +121,7 @@ module Hecks
         # fatal to the command that emitted the event.
         record.merge(delivered: false, reason: e.message)
       rescue StandardError => e
-        # A DEFECT, not a refusal — a NoMethodError in an interpreter, a
+        # A defect, not a refusal — a NoMethodError in an interpreter, a
         # NameError from a missing constant, a TypeError from a bad
         # assumption : exactly the class of thing DOMAIN_REFUSALS
         # (errors.rb, see the comment above that constant) deliberately
@@ -129,19 +129,19 @@ module Hecks
         # folding a crash into the same `delivered: false` shape as an
         # ordinary refusal makes a broken runtime read as normal operation
         # in the log. This clause does not reopen that hole: it is a
-        # SECOND, narrower rescue, tried only once the first one above has
+        # second, narrower rescue, tried only once the first one above has
         # already declined to match, so a legitimate refusal still takes
         # the branch above and a defect always takes this one.
         #
-        # Catching it HERE is safe for a fact this method's caller cannot
+        # Catching it here is safe for a fact this method's caller cannot
         # see from where it sits: by the time `react` runs, the command
-        # that EMITTED `event` has already succeeded and PERSISTED —
+        # that emitted `event` has already succeeded and persisted —
         # `Dispatcher#dispatch` calls `@policies.react` only after its own
         # `announced` events are already in hand. Letting this exception
         # keep propagating would not undo that command (nothing here is
         # transactional across aggregates) — it would only blow up the
-        # ORIGINAL caller's `dispatch` call for a failure that happened in
-        # a DIFFERENT command, one the caller never asked to run and has no
+        # original caller's `dispatch` call for a failure that happened in
+        # a different command, one the caller never asked to run and has no
         # way to compensate for. So the defect is recorded, distinguishably
         # (`defect: true`, plus the error's own class — nothing here is
         # allowed to read like an ordinary refusal), warned to STDERR so it
@@ -152,19 +152,19 @@ module Hecks
         record.merge(delivered: false, reason: e.message, defect: true, error_class: e.class.name)
       end
 
-      # THE FAN-OUT — `policy.for_each` names a query ; this runs it
+      # **The fan-out** — `policy.for_each` names a query ; this runs it
       # against the triggering event's own payload (the same source
       # `deliver`'s own ordinary path forwards to `trigger` wholesale) and
       # fires `trigger` once per row, merging each row's own id into the
-      # forwarded payload under whichever key THE TARGET COMMAND ITSELF
+      # forwarded payload under whichever key the target command itself
       # expects to be addressed by (`Behaviour::Command#addressing_key_for`
       # — never a guessed, one-size mint: `Account.Freeze`, addressed by
-      # `account` because it is declared ON Account and self-references
+      # `account` because it is declared on Account and self-references
       # it, refused every dispatch for as long as this hardcoded
       # `<aggregate>_id` instead — a real bug, found wiring `for_each`
       # into a real domain for the first time, not a hypothetical). A
       # refusal is recorded per row and the fan-out continues ; a crash
-      # resolving the QUERY ITSELF, or the TARGET COMMAND'S OWN inability
+      # resolving the query itself, or the target command's own inability
       # to address this aggregate at all (`addressing_key_for` answering
       # `nil` — a domain-authoring mistake, not a data problem), is a
       # single top-level defect for the policy, the same shape `deliver`'s
@@ -174,9 +174,9 @@ module Hecks
 
         query_domain, aggregate_name, query_name = policy.for_each_route(domain)
         aggregate = resolve_query_aggregate(query_domain, aggregate_name, policy.for_each)
-        # THE QUERY READS THE EVENT, never the projection — `with:` says
-        # what the TRIGGER is given, and the fan-out's query is asking a
-        # different question (WHICH rows) in the event's own vocabulary.
+        # The query reads the event, never the projection — `with:` says
+        # what the trigger is given, and the fan-out's query is asking a
+        # different question (which rows) in the event's own vocabulary.
         query_args    = for_each_query_args(aggregate.query(query_name), event)
         rows          = QueryInterpreter.new(@registry).call(query_domain, aggregate, query_name, query_args)
         reference_key = addressing_key_for(target, aggregate_name)
@@ -192,20 +192,20 @@ module Hecks
         record.merge(delivered: false, reason: e.message, defect: true, error_class: e.class.name)
       end
 
-      # THE EVENT'S OWN IDENTITY IS A FACT TOO, not only its payload. A
-      # for_each query commonly filters by the EMITTING record's own
+      # The event's own identity is a fact too, not only its payload. A
+      # for_each query commonly filters by the emitting record's own
       # identity (`OpenForCustomer`'s own `reference:`, scoping by the
       # very customer who was just suspended) — which used to arrive for
-      # free because LEGACY dispatch left the self-addressing key riding
+      # free because legacy dispatch left the self-addressing key riding
       # along in `event.payload` unfiltered. Routing separated from
       # payload (`to:`/`with:`, what the facade's own bang-methods always
       # use) correctly stopped carrying it there, which left this query
-      # silently seeing NEITHER the field it needs NOR any error saying
+      # silently seeing neither the field it needs nor any error saying
       # why — an empty result read as "nothing to freeze" instead of "the
       # customer" the whole reaction exists to catch.
       #
-      # Merged in ONLY when the query declares an argument by that exact
-      # name AND the emitting aggregate's own identity is genuinely what
+      # Merged in only when the query declares an argument by that exact
+      # name and the emitting aggregate's own identity is genuinely what
       # that name means (`construct.identity_heads`) — the same guard
       # `SagaInterpreter::Correlation#self_identified?` uses for the
       # identical shape one call away, so an unrelated aggregate sharing
@@ -229,22 +229,22 @@ module Hecks
         args
       end
 
-      # WHAT THE TRIGGER IS GIVEN. Undeclared, the event's whole payload
+      # **What the trigger is given**. Undeclared, the event's whole payload
       # forwards verbatim — the behaviour every policy had before `with:`
       # existed, and still the right default for a trigger shaped like
       # its event.
       #
       # Declared, it is the same reading a saga's own `dispatch ...,
       # with:` gets (`SagaInterpreter#dispatch_args`): a Symbol names a
-      # field on the SOURCE below, anything else is a literal the policy
+      # field on the source below, anything else is a literal the policy
       # supplies itself. A saga additionally resolves against its own
       # memory and correlation key; a policy has neither — it holds
       # nothing between events — so the source is the event, plus:
       #
-      # `extra` is a FAN-OUT'S ROW KEY, merged into the source BEFORE the
+      # `extra` is a fan-out's row key, merged into the source before the
       # projection rather than after it. That is what lets a `for_each`
       # policy name the row it is acting on — `with: { account: :account }`
-      # — and therefore what lets one send the row and NOTHING ELSE. A
+      # — and therefore what lets one send the row and nothing else. A
       # trigger needing only which record to act on is the ordinary case
       # for a fan-out, and before this it could not be written: the whole
       # event rode along, and the target had to declare every field of it
@@ -261,26 +261,26 @@ module Hecks
           label:     "#{policy.name}'s trigger"
         )
 
-        # THE RAW INPUTS `args` WAS RESOLVED FROM — same additive,
+        # **The raw inputs `args` was resolved from** — same additive,
         # Ruby-only shape SagaInterpreter#deliver_saga_dispatch's own
         # saga_dispatch_log gets, for Properties.dispatch_binding_
         # fidelity's own independent re-derivation of Policy#with_spec's
         # 2-branch resolution (Symbol → payload lookup, anything else →
         # literal — a policy holds no correlation and no memory, so
         # `payload` — the merged event-payload-plus-fan-out-row source —
-        # is the WHOLE source, unlike a saga's own 4-branch one).
+        # is the whole source, unlike a saga's own 4-branch one).
         @registry.policy_dispatch_log << { policy: policy.name, on: event.name, payload: payload,
                                             with_spec: policy.with_spec, args: args }
         args
       end
 
-      # THE EMITTING RECORD'S OWN IDENTITY IS A FACT A PROJECTION MAY READ
+      # The emitting record's own identity is a fact a projection may read
       # — the same reasoning `for_each_query_args` gives one method up,
-      # extended from the fan-out's QUERY to the trigger's own `with:`.
+      # extended from the fan-out's query to the trigger's own `with:`.
       # Routing separated from payload (`to:`/`with:`) stopped carrying
       # the emitting aggregate's identity in the payload, which is right
       # for the event (a KnightCaptured is a fact about a knight, not a
-      # re-statement of which game) but left a CROSS-aggregate reaction
+      # re-statement of which game) but left a cross-aggregate reaction
       # with no way to say which record to address: chess's Graveyard is
       # one-per-game, fed by policy from every piece's own Captured
       # event, and its burials had no way to name the game — the
@@ -288,10 +288,10 @@ module Hecks
       # graveyard's identity and refused every one ("no Graveyard with
       # label.value \"bb\""). Same-aggregate targets were already covered
       # (`ReactionInvocation.source_receiver_for` lifts Event.id), so
-      # this is the OTHER aggregate's half of that.
+      # this is the other aggregate's half of that.
       #
       # Offered under the emitting aggregate's own identity heads, only
-      # to an EXPLICIT projection (a legacy wholesale forward keeps its
+      # to an explicit projection (a legacy wholesale forward keeps its
       # exact old payload), and never over a value the payload itself
       # carries. `event.id` is the scalar the identity resolves to, so a
       # projection naming it as the target's own identity head routes it
@@ -309,9 +309,9 @@ module Hecks
         construct.identity_heads.to_h { |head| [head.to_sym, event.id] }
       end
 
-      # RESOLVES `target` ("Domain::Aggregate.Command", the same shape
-      # `deliver`'s own caller already built) back to its OWN declared
-      # command, then asks IT how it expects to be addressed by a row of
+      # Resolves `target` ("Domain::Aggregate.Command", the same shape
+      # `deliver`'s own caller already built) back to its own declared
+      # command, then asks it how it expects to be addressed by a row of
       # `aggregate_name` — see `Behaviour::Command#addressing_key_for`'s
       # own comment for the two shapes that answers. Raises (caught by
       # `deliver_for_each`'s own outer `rescue StandardError`, the same
@@ -342,8 +342,8 @@ module Hecks
                                   reason:    "reaction depth #{@door.max_reaction_depth} reached")
         end
 
-        # ALREADY MERGED, by `trigger_args` — the row key belongs in the
-        # source a `with:` projection reads FROM, not bolted onto its
+        # Already merged, by `trigger_args` — the row key belongs in the
+        # source a `with:` projection reads from, not bolted onto its
         # result, or a projection could never name the row it acts on.
         @door.reenter(target, **reaction_invocation(target, args, policy, event))
         row_record.merge(delivered: true)
@@ -361,20 +361,20 @@ module Hecks
         )
       end
 
-      # `for_each`'s own QUERY route moved onto the Policy itself
+      # `for_each`'s own query route moved onto the Policy itself
       # (Behaviour::Policy#for_each_route) — one reading the interpreter
       # and the fuzzer's fan-out property both call, rather than the
-      # same split spelled twice. The reference-KEY the dispatch itself
-      # uses is `addressing_key_for`, above — a property of the TARGET
-      # COMMAND, not of the policy, so it lives on `Behaviour::Command`
+      # same split spelled twice. The reference-key the dispatch itself
+      # uses is `addressing_key_for`, above — a property of the target
+      # command, not of the policy, so it lives on `Behaviour::Command`
       # instead.
 
       def resolve_query_aggregate(domain, aggregate_name, verb)
         bluebook = @registry.bluebook(domain) ||
-                   raise(UnknownVerb, RefusalWording.render("UnknownVerb", "no_domain", domain: domain.inspect, verb: verb))
+                   raise(UnknownVerb, RefusalWording.render_site("UnknownVerb", "no_domain", domain: domain, verb: verb))
         bluebook.aggregate(aggregate_name) ||
-          raise(UnknownVerb, RefusalWording.render("UnknownVerb", "no_aggregate",
-                                                   domain: domain, aggregate: aggregate_name.inspect))
+          raise(UnknownVerb, RefusalWording.render_site("UnknownVerb", "no_aggregate",
+                                                        domain: domain, aggregate: aggregate_name))
       end
     end
   end