hecks 5.0.0 → 6.0.0

data/lib/hecks/runtime/adapter_lookup.rb

@@ -1,4 +1,5 @@
 require_relative "errors"
+require_relative "adapter_namespace"
 
 module Hecks
   module Runtime
@@ -31,16 +32,34 @@ module Hecks
         @stand_in = previous
       end
 
+      # Builds the port's adapter, handing it the context it declares: an `initialize` that takes
+      # `registry:` is given the registry that is asking, and one that takes `aggregate:` is given
+      # the aggregate asking out. An adapter that declares neither is built bare, as before.
+      #
       # @param registry [Runtime::Registry] the booted registry whose adapters are searched
       # @param port_name [String] the port's name as an adapter declares it
       # @param asked [String] what is being asked, worded into a refusal
+      # @param aggregate [Bluebook::Aggregate, nil] the aggregate asking, when one is
       # @return [Object] a new instance of the port's only adapter, or the stand-in for it
       # @raise [Runtime::WiringError] if no adapter, or more than one, implements the port
-      def call(registry, port_name, asked:)
-        adapter_class(registry, port_name, asked: asked)
+      def call(registry, port_name, asked:, aggregate: nil)
+        klass = adapter_class(registry, port_name, asked: asked)
         return @stand_in.call(port_name, asked) if @stand_in
 
-        adapter_class(registry, port_name, asked: asked).new
+        build(klass, registry: registry, aggregate: aggregate)
+      end
+
+      # Builds `klass` with the context keywords its constructor names, and no others.
+      #
+      # @param klass [Class] the adapter class
+      # @param context [Hash{Symbol => Object}] what could be handed over, by keyword
+      # @return [Object] the adapter
+      def build(klass, **context)
+        parameters = klass.instance_method(:initialize).parameters
+        return klass.new(**context) if parameters.any? { |kind, _| kind == :keyrest }
+
+        named = parameters.filter_map { |kind, name| name if %i[key keyreq].include?(kind) }
+        klass.new(**context.slice(*named))
       end
 
       # Finds the class of the one adapter this boot loaded for a port name, without building it,
@@ -55,7 +74,7 @@ module Hecks
         implementations = registry.adapters.values.select { |adapter| adapter.port == port_name }
 
         case implementations.size
-        when 1 then Adapters.const_get(implementations.first.name)
+        when 1 then AdapterNamespace.resolve(implementations.first.name)
         when 0 then raise WiringError, "no adapter implements the #{port_name} port — nothing can answer #{asked}"
         else raise WiringError,
                    "#{implementations.size} adapters implement the #{port_name} port " \
@@ -81,13 +100,17 @@ module Hecks
         check_keywords!(klass, method, query, asked)
       end
 
-      # @raise [Runtime::WiringError] if the constructor requires arguments
+      # The keywords {build} hands an adapter that names them.
+      CONTEXT = %i[registry aggregate].freeze
+
+      # @raise [Runtime::WiringError] if the constructor requires arguments beyond the context
       def check_buildable!(klass, port_name)
-        required = klass.instance_method(:initialize).parameters.filter_map { |kind, name| name if %i[req keyreq].include?(kind) }
+        parameters = klass.instance_method(:initialize).parameters
+        required = parameters.filter_map { |kind, name| name if kind == :req || (kind == :keyreq && !CONTEXT.include?(name)) }
         return if required.empty?
 
         raise WiringError, "#{klass} implements the #{port_name} port but its constructor requires " \
-                           "#{required.join(", ")} — it is built with no arguments"
+                           "#{required.join(", ")} — it is built with #{CONTEXT.join(" and ")} keywords at most"
       end
 
       # @raise [Runtime::WiringError] if the method is missing or only inherited

data/lib/hecks/runtime/adapter_namespace.rb

@@ -0,0 +1,21 @@
+module Hecks
+  module Runtime
+    # The one place the runtime turns a declared adapter name into the class behind it.
+    #
+    # A hecksagon binds adapters by name (`persisted_by "Postgres"`), and an adapter's class is
+    # the constant of that name under `Hecks::Adapters`, whether the gem or an application
+    # defines it. Every other runtime file asks the registry, which asks here, so the runtime
+    # never names an adapter itself.
+    #
+    # @example
+    #   AdapterNamespace.resolve("Memory")  # => Hecks::Adapters::Memory
+    module AdapterNamespace
+      module_function
+
+      # @param name [String] the adapter's declared name
+      # @return [Class] the adapter class of that name
+      # @raise [NameError] if no adapter class has that name
+      def resolve(name) = Hecks::Adapters.const_get(name)
+    end
+  end
+end

data/lib/hecks/runtime/asking.rb

@@ -0,0 +1,30 @@
+module Hecks
+  module Runtime
+    # The registry whose port operation is asking an adapter, bound on this thread for the
+    # length of the ask, so an adapter that answers by dispatching reaches the same boot
+    # (ADR 0125). An adapter that names `registry:` in its constructor is handed the registry
+    # directly and
+    # should prefer it: this thread-local is the registry whose ask is running, which a launcher's
+    # own
+    # boot can differ from.
+    module Asking
+      module_function
+
+      # @return [Runtime::Registry, nil] the asking registry, or nil outside an ask
+      def registry = Thread.current[:hecks_asking_registry]
+
+      # Binds `registry` as the asking registry for the block, restoring the previous one.
+      #
+      # @param registry [Runtime::Registry] the registry whose port operation asks
+      # @yield the ask
+      # @return [Object] the block's result
+      def with(registry)
+        previous = Thread.current[:hecks_asking_registry]
+        Thread.current[:hecks_asking_registry] = registry
+        yield
+      ensure
+        Thread.current[:hecks_asking_registry] = previous
+      end
+    end
+  end
+end

data/lib/hecks/runtime/caller.rb

@@ -48,10 +48,32 @@ module Hecks
       # @return [Object] the block's result
       def without
         previous = Thread.current[:hecks_caller]
+        previous_origin = Thread.current[:hecks_caller_origin]
+        Thread.current[:hecks_caller_origin] = previous_origin || previous
         Thread.current[:hecks_caller] = nil
         yield
       ensure
         Thread.current[:hecks_caller] = previous
+        Thread.current[:hecks_caller_origin] = previous_origin
+      end
+
+      # The caller a reaction cascade on this thread began under: the one `without` cleared at
+      # its outermost level. A bulk run's rows are dispatched under it (ADR 0125), so a row
+      # carries its requester's authority and not the system's.
+      #
+      # @return [Runtime::Caller::Current, nil] the cascade's first caller, the current one
+      #   outside a cascade, or nil when neither is bound
+      def origin = Thread.current[:hecks_caller_origin] || current
+
+      # Binds `bound` as the ambient caller for the block, or none when it is nil.
+      #
+      # @param bound [Runtime::Caller::Current, nil] a caller `current` or `origin` answered
+      # @yield the code that sees `bound` as the ambient caller
+      # @return [Object] the block's result
+      def restoring(bound, &)
+        return without(&) unless bound
+
+        as(role: bound.role, actor_id: bound.actor_id, as_of: bound.as_of, scope: bound.scope, &)
       end
     end
   end

data/lib/hecks/runtime/capability_graph.rb

@@ -32,7 +32,8 @@ module Hecks
       private
 
       def adapters_for(port_name)
-        @registry.adapters.values.select { |adapter| adapter.port == port_name }.map(&:name)
+        serving = @registry.adapters.values.select { |adapter| adapter.port == port_name }
+        serving.map(&:name)
       end
     end
   end

data/lib/hecks/runtime/collecting.rb

@@ -0,0 +1,86 @@
+require_relative "../vocabulary"
+
+module Hecks
+  module Runtime
+    # Gathers refusals instead of raising the first, for the length of a block.
+    #
+    # A rule that refuses calls `Collecting.refuse`. With no collector bound it raises, exactly as
+    # a plain `raise` would, so dispatch and `dry_run?` behave as they always have. With one bound
+    # (by `Dispatcher#validate`) it records the refusal and returns, so a rule that loops over many
+    # checks reports every one that fails.
+    #
+    # The collector is bound per thread, like the caller, so concurrent requests never share one.
+    module Collecting
+      KEY = :hecks_collector
+      STAGE_KEY = :hecks_collecting_stage
+
+      # Which stage each dispatch step belongs to, by step name.
+      STAGES = Hecks::Vocabulary.rows("StepStage").to_h { |row| [row["step"].to_sym, row["stage"].to_sym] }.freeze
+
+      module_function
+
+      # Binds a collector for the block.
+      #
+      # @yield the work whose refusals are gathered
+      # @return [Array<Hecks::Refused>] the refusals recorded, in the order they were found
+      def collect
+        previous = Thread.current[KEY]
+        Thread.current[KEY] = collected = []
+        yield
+        collected
+      ensure
+        Thread.current[KEY] = previous
+      end
+
+      # @return [Boolean] whether a collector is bound on this thread
+      def active? = !Thread.current[KEY].nil?
+
+      # @return [Array<Hecks::Refused>, nil] the refusals recorded so far, or nil when none is bound
+      def refusals = Thread.current[KEY]
+
+      # Names the stage of the step running for the block, so a refusal recorded in it is placed
+      # where it was found, whatever its class would otherwise say (a closed set that refuses a
+      # value while an argument is built is an invariant by class and an argument by place).
+      #
+      # @param stage [Symbol] a `DispatchStage`
+      # @yield the step
+      # @return [Object] the block's result
+      def at_stage(stage)
+        previous = Thread.current[STAGE_KEY]
+        Thread.current[STAGE_KEY] = stage
+        yield
+      ensure
+        Thread.current[STAGE_KEY] = previous
+      end
+
+      # Records a refusal when collecting, raises it otherwise.
+      #
+      # @param refusal [Hecks::Refused] what refused
+      # @return [nil] when collecting
+      # @raise [Hecks::Refused] `refusal`, when no collector is bound
+      def refuse(refusal)
+        raise refusal unless active?
+
+        stage = Thread.current[STAGE_KEY]
+        refusals << (stage ? refusal.in_stage(stage) : refusal)
+        nil
+      end
+
+      # Refuses a set of offenders. Plainly that is one refusal naming them all; when collecting it
+      # is one refusal each, so every offender can be shown against its own field.
+      #
+      # @param names [Array<Symbol>] the offenders
+      # @yieldparam group [Array<Symbol>] the offenders one refusal is about
+      # @yieldreturn [Hecks::Refused] the refusal for that group
+      # @return [void]
+      def refuse_each(names)
+        groups = active? ? names.zip : [names]
+        groups.each { |group| refuse(yield(group)) }
+      end
+
+      # @param step [Symbol] a dispatch step name
+      # @return [Symbol] the stage it belongs to
+      def stage_of(step) = STAGES.fetch(step)
+    end
+  end
+end

data/lib/hecks/runtime/command_interpreter/argument_gate.rb

@@ -1,6 +1,7 @@
 require_relative "../../naming"
 require_relative "../errors"
 require_relative "../refusal_wording"
+require_relative "../collecting"
 
 module Hecks
   module Runtime
@@ -21,10 +22,12 @@ module Hecks
           unknown = (args.keys.map(&:to_sym) - known).sort
           return if unknown.empty?
 
-          raise UnknownArgument,
-                RefusalWording.render_site("UnknownArgument", "unknown_args",
-                                           command: command.hecks_name, unknown: unknown,
-                                           declared: declared_names(command))
+          Collecting.refuse_each(unknown) do |names|
+            UnknownArgument.new(RefusalWording.render_site("UnknownArgument", "unknown_args",
+                                                           command: command.hecks_name, unknown: names,
+                                                           declared: declared_names(command)),
+                                attribute: names.first)
+          end
         end
 
         # Every name a payload may carry: the declared attributes plus the addressing keys.
@@ -45,10 +48,12 @@ module Hecks
           absent = (required_argument_names(command, aggregate) - args.keys.map(&:to_sym)).sort
           return if absent.empty?
 
-          raise AbsentArgument,
-                RefusalWording.render_site("AbsentArgument", "absent_args",
-                                           command: command.hecks_name, absent: absent,
-                                           declared: declared_names(command))
+          Collecting.refuse_each(absent) do |names|
+            AbsentArgument.new(RefusalWording.render_site("AbsentArgument", "absent_args",
+                                                          command: command.hecks_name, absent: names,
+                                                          declared: declared_names(command)),
+                               attribute: names.first)
+          end
         end
 
         # The declared, non-optional argument names, less a port operation's promoted identity.

data/lib/hecks/runtime/command_interpreter/delegation.rb

@@ -1,3 +1,4 @@
+require_relative "../collecting"
 require_relative "../errors"
 require_relative "../instance"
 require_relative "../entity_element"
@@ -13,12 +14,24 @@ module Hecks
       module Delegation
         # What a `delegates_to` mutation resolved to: the entity, its command, the command's own
         # arguments, the located element, and a view of it for the givens.
-        Target = Struct.new(:entity, :command, :args, :element, :view)
+        Target = Struct.new(:entity, :command, :args, :element, :view) do
+          # @return [Array] the target command's ensures clauses
+          def ensures = command.ensures
+
+          # @return [Array] the target command's mutations, in declaration order
+          def mutations = command.mutations
+
+          # @return [String] the located element's identity
+          def element_id = view.id
+
+          # @return [Symbol, String, nil] the entity's state field, nil without a lifecycle
+          def lifecycle_field = entity.lifecycle_field
+        end
 
         private
 
         def step_delegate_to_entity(ctx)
-          delegation = ctx.command.mutations.find { |mutation| mutation.op == :delegate }
+          delegation = ctx.command_mutations.find { |mutation| mutation.op == :delegate }
           return unless delegation
 
           # Not emitted here — C7.2: a refused command records nothing, and the parent's own
@@ -28,18 +41,35 @@ module Hecks
         end
 
         # Runs the target entity command's givens, transition, mutations and ensures against the
-        # element, answering the command and arguments `step_emit` will emit.
+        # element, answering the command and arguments `step_emit` will emit, or nil when a
+        # validation recorded a refusal in the target's givens or ensures.
         def run_delegation(ctx, delegation)
-          target      = locate_delegate(ctx, delegation)
-          transition  = check_delegate_givens(ctx, target)
-          old_element = target.command.ensures.empty? ? nil : target.element.dup
+          target = locate_delegate(ctx, delegation)
+          return unless delegate_stage_held?(:givens) { enforce_delegate_givens(ctx, target) }
+
+          transition  = @rules.admissible_transition(target.entity, target.command, target.view)
+          old_element = target.ensures.empty? ? nil : target.element.dup
           mutate_delegate(ctx, target, transition)
-          enforce_delegate_ensures(ctx, target, old_element)
+          return unless delegate_stage_held?(:ensures) { enforce_delegate_ensures(ctx, target, old_element) }
+
           [target.command, target.args]
         end
 
+        # Runs one of the target's own rule stages. A refusal it records while validating is placed
+        # in that stage, as the same rule's refusal is in a direct dispatch of the entity command,
+        # and finishes the delegation there, as a refused stage finishes any validating run.
+        #
+        # @param stage [Symbol] the `DispatchStage` the target's rules belong to
+        # @yield the stage's rules
+        # @return [Boolean] whether the stage recorded no refusal
+        def delegate_stage_held?(stage, &)
+          recorded = Collecting.refusals&.size
+          Collecting.at_stage(stage, &)
+          Collecting.refusals&.size == recorded
+        end
+
         def enforce_delegate_ensures(ctx, target, old_element)
-          settled = Instance.new(aggregate: target.entity, id: target.view.id, state: target.element)
+          settled = Instance.new(aggregate: target.entity, id: target.element_id, state: target.element)
           @rules.enforce_ensures(settled, target.command, target.args, old: old_element, domain: ctx.domain, parent: ctx.instance)
         end
 
@@ -51,19 +81,17 @@ module Hecks
           Target.new(entity, target_command, target_args, element, view)
         end
 
-        # @return [Object, nil] the transition the target command is admissible under, if any
-        def check_delegate_givens(ctx, target)
+        def enforce_delegate_givens(ctx, target)
           @rules.enforce_givens(target.view, target.command, target.args,
                                 domain: ctx.domain, declaring: target.entity, parent: ctx.instance)
-          @rules.admissible_transition(target.entity, target.command, target.view)
         end
 
         def mutate_delegate(ctx, target, transition)
           pre = target.element.dup # C4.2 — the update set reads the element as it was
-          target.command.mutations.each do |mutation|
+          target.mutations.each do |mutation|
             EntityElement.apply_to_element(@rules, ctx.aggregate, target.entity, target.element, mutation, target.args, pre)
           end
-          target.element[target.entity.lifecycle.field] = transition.target if transition
+          target.element[target.lifecycle_field] = transition.target if transition
         end
 
         # The entity and command a `delegates_to` mutation names, resolved once so
@@ -72,16 +100,17 @@ module Hecks
           entity_name, _dot, command_name = delegation.target.to_s.rpartition(".")
           entity = delegation_entity(ctx, entity_name, command_name)
           target_command = entity.command(command_name) ||
-                           raise(WiringError, "#{ctx.command.hecks_name} delegates_to " \
+                           raise(WiringError, "#{ctx.command_hecks_name} delegates_to " \
                                               "#{entity_name}.#{command_name}, which " \
                                               "#{entity_name} declares no such command")
           [entity, target_command, command_name]
         end
 
         def delegation_entity(ctx, entity_name, command_name)
-          ctx.aggregate.entities.find { |e| e.hecks_name == entity_name } ||
-            raise(WiringError, "#{ctx.command.hecks_name} delegates_to #{entity_name}." \
-                               "#{command_name}, but #{ctx.aggregate.hecks_name} has no " \
+          aggregate = ctx.aggregate
+          aggregate.entities.find { |e| e.hecks_name == entity_name } ||
+            raise(WiringError, "#{ctx.command_hecks_name} delegates_to #{entity_name}." \
+                               "#{command_name}, but #{aggregate.hecks_name} has no " \
                                "entity named #{entity_name.inspect}")
         end
 

data/lib/hecks/runtime/command_interpreter/hydration.rb

@@ -13,12 +13,12 @@ module Hecks
       module Hydration
         private
 
-        # Picks the hydration the command's dependency plan allows.
+        # Picks the hydration the command's dependency plan allows. A command that declares a
+        # `reference_to` acts on a record that must already exist, however complete its payload,
+        # as the Rust kernel's `Hydrate::Act` does; only a creating command may build one.
         def hydrate_for(ctx)
-          if ctx.plan.complete_state? && ctx.plan.state_independent?
-            hydrate_complete_state(ctx)
-          elsif ctx.plan.complete_state?
-            hydrate_prior_or_initial(ctx)
+          if ctx.command.creates? && ctx.plan.complete_state?
+            ctx.plan.state_independent? ? hydrate_complete_state(ctx) : hydrate_prior_or_initial(ctx)
           elsif legacy_implicit_creation?(ctx)
             hydrate_legacy_creation(ctx)
           else
@@ -28,7 +28,7 @@ module Hecks
 
         # The record an acting command names, by route or by the identity its arguments carry.
         def hydrate_existing(ctx)
-          id = ctx.route ? ctx.route.aggregate : acting_identity(ctx)
+          id = ctx.route ? ctx.routed_identity : acting_identity(ctx)
           (ctx.repository.find(id) || raise_record_missing(ctx.aggregate, id)).dup
         end
 
@@ -40,7 +40,7 @@ module Hecks
             identity_from(aggregate, ctx.args, :id) ||
             identity_from(aggregate, ctx.args, reference_key(ctx.command)) ||
             raise(NotFound, RefusalWording.render_site("NotFound", "acting_no_identity",
-                                                       command: ctx.command.hecks_name, aggregate: aggregate.hecks_name,
+                                                       command: ctx.command_hecks_name, aggregate: aggregate.hecks_name,
                                                        identity: identity_reading(aggregate)))
         end
 
@@ -63,37 +63,33 @@ module Hecks
 
         def hydrate_complete_state(ctx)
           id = creation_identity(ctx)
-          # `creates?` on an occupied identity refuses (`AlreadyExists`), except
-          # under ATOMIC_PUT: that adapter enforces the same refusal itself,
-          # atomically, via `insert_only:` in `step_save` — reading here too
-          # would race the write for nothing.
-          if ctx.command.creates? && ctx.strategy != DependencyPlanning::ATOMIC_PUT && ctx.repository.find(id)
+          # An occupied identity refuses (`AlreadyExists`), except under ATOMIC_PUT: that adapter
+          # enforces the same refusal itself, atomically, via `insert_only:` in `step_save` —
+          # reading here too would race the write for nothing.
+          if ctx.strategy != DependencyPlanning::ATOMIC_PUT && ctx.repository.find(id)
             raise_already_exists(ctx.command, ctx.aggregate, id)
           end
 
           fresh_instance(ctx, id)
         end
 
-        # A complete command may still depend on prior state (lifecycle guards
-        # are the common case) — read once, so an existing record is checked
-        # against its real state rather than assumed defaults.
+        # A complete creating command that still reads prior state (lifecycle guards are the
+        # common case) — read once, so an occupied identity refuses before anything is built.
         def hydrate_prior_or_initial(ctx)
           id    = creation_identity(ctx)
           found = ctx.repository.find(id)
           # Same refusal as `hydrate_complete_state`, for a complete-but-state-
-          # dependent command (one with a `given` on its own prior state).
-          # Gated on `creates?`: a non-creating command's complete payload just
-          # means "act on whatever this identity already holds".
-          raise_already_exists(ctx.command, ctx.aggregate, id) if found && ctx.command.creates?
+          # dependent creating command (one with a `given` on its own prior state).
+          raise_already_exists(ctx.command, ctx.aggregate, id) if found
 
-          found ? found.dup : fresh_instance(ctx, id)
+          fresh_instance(ctx, id)
         end
 
         # The identity a complete command's facts derive, checked against its route.
         def creation_identity(ctx)
           derived = identity_of(ctx.aggregate, ctx.args)
           refuse_route_mismatch(ctx.command, ctx.route, derived) if ctx.route && derived
-          ctx.route&.aggregate || derived || raise_creating_no_identity(ctx.command, ctx.aggregate)
+          ctx.routed_identity || derived || raise_creating_no_identity(ctx.command, ctx.aggregate)
         end
 
         def refuse_route_mismatch(command, route, derived)

data/lib/hecks/runtime/command_interpreter/list_mutations.rb

@@ -62,7 +62,8 @@ module Hecks
 
           coerce_entity_fields(aggregate, entity, fields)
           assign_entity_identity(aggregate, entity, current, fields)
-          fields[entity.lifecycle.field] ||= entity.lifecycle.default if entity.lifecycle
+          lifecycle = entity.lifecycle
+          fields[lifecycle.field] ||= lifecycle.default if lifecycle
           # Fill declared defaults for attributes the append mapping did not touch, shared with
           # EntityElement so both entity-creation paths agree on what "the default" means.
           EntityElement.fill_declared_defaults(aggregate, entity, fields)

data/lib/hecks/runtime/command_interpreter/persisting.rb

@@ -16,7 +16,7 @@ module Hecks
         # both are validation, not persistence, and a real dispatch would
         # refuse on either before ever writing.
         def step_save(ctx)
-          step(:save) { @rules.resolve_state_references(ctx.domain, ctx.aggregate, ctx.instance.state) }
+          step(:save) { @rules.resolve_state_references(ctx.domain, ctx.aggregate, ctx.state) }
 
           if ctx.dry_run
             step(:save) { check_dry_run_creates_duplicate(ctx) }
@@ -36,9 +36,9 @@ module Hecks
         # deliberately defers this exact check to here.
         def check_dry_run_creates_duplicate(ctx)
           return unless ctx.strategy == DependencyPlanning::ATOMIC_PUT && ctx.command.creates?
-          return unless ctx.repository.find(ctx.instance.id)
+          return unless ctx.repository.find(ctx.instance_id)
 
-          raise_already_exists(ctx.command, ctx.aggregate, ctx.instance.id)
+          raise_already_exists(ctx.command, ctx.aggregate, ctx.instance_id)
         end
 
         def persist_instance(ctx)
@@ -52,14 +52,14 @@ module Hecks
             # `expected_version:` is nil for a brand-new record or a
             # non-CAS repository, either of which falls through to a
             # plain, unconditional save inside `AppendOnly#save`.
-            ctx.repository.save(ctx.instance, expected_version: ctx.instance.version)
+            ctx.repository.save(ctx.instance, expected_version: ctx.instance_version)
           end
         end
 
         def raise_for_persistence_outcome!(ctx)
-          case ctx.persistence_outcome.status
+          case ctx.outcome_status
           when :conflicted
-            raise_already_exists(ctx.command, ctx.aggregate, ctx.instance.id)
+            raise_already_exists(ctx.command, ctx.aggregate, ctx.instance_id)
           when :stale
             # Not a declared vocabulary refusal, just a plain, informative
             # message — caught by `#call`'s retry loop, re-raised only once
@@ -69,8 +69,8 @@ module Hecks
         end
 
         def lost_race_wording(ctx)
-          "#{ctx.command.hecks_name} on #{ctx.aggregate.hecks_name} " \
-            "(#{identity_reading(ctx.aggregate)}: #{Rendering.describe(ctx.instance.id)}) lost a race — " \
+          "#{ctx.command_hecks_name} on #{ctx.aggregate_hecks_name} " \
+            "(#{identity_reading(ctx.aggregate)}: #{Rendering.describe(ctx.instance_id)}) lost a race — " \
             "another write committed against this record after it was read"
         end
 
@@ -81,13 +81,14 @@ module Hecks
         # real reason. Uses the same `RebuildSweep.remote_value` a sweep
         # computes, and runs only at save time, never as a live read mid-dispatch.
         def seed_projected_fields(ctx)
-          return if ctx.aggregate.projected_fields.empty?
+          aggregate = ctx.aggregate
+          return if aggregate.projected_fields.empty?
 
-          ctx.aggregate.projected_fields.each do |field|
-            value = RebuildSweep.remote_value(@registry, ctx.domain, ctx.aggregate, ctx.instance.state, field)
+          aggregate.projected_fields.each do |field|
+            value = RebuildSweep.remote_value(@registry, ctx.domain, aggregate, ctx.state, field)
             next if value.nil?
 
-            ctx.instance.state[field.name] = value
+            ctx.state[field.name] = value
           end
         end
       end