hecks 5.0.0 → 7.0.0

data/lib/hecks/fuzzing/replay/mutation_trace.rb

@@ -5,10 +5,22 @@ module Hecks
       # after, so the mutation can be diffed against an independent recomputation.
       module MutationTrace
         # The entity command a trace is about, and where it lives.
-        Target = Struct.new(:domain, :aggregate_name, :command_name, :aggregate, :entity, :command)
+        Target = Struct.new(:domain, :aggregate_name, :command_name, :aggregate, :entity, :command) do
+          # @return [Array<Bluebook::Attribute>] the owning aggregate's attributes
+          def aggregate_attributes = aggregate.attributes
+
+          # @return [String] the entity's declared name
+          def entity_name = entity.hecks_name
+
+          # @return [Array<String>] the entity's identity paths
+          def identity_paths = entity.identity_paths
+        end
 
         # The element a mutation step addresses, found in its parent's `list_of` attribute.
-        Located = Struct.new(:parent_id, :list_attr, :wants, :element)
+        Located = Struct.new(:parent_id, :list_attr, :wants, :element) do
+          # @return [Symbol, String] the name of the `list_of` attribute holding the element
+          def list_attr_name = list_attr.name
+        end
 
         module_function
 
@@ -24,7 +36,7 @@ module Hecks
           return nil unless located
 
           { verb: verb, domain: target.domain, aggregate: target.aggregate_name, command: target.command_name,
-            parent_id: located.parent_id, list_attr: located.list_attr.name, element_wants: located.wants,
+            parent_id: located.parent_id, list_attr: located.list_attr_name, element_wants: located.wants,
             before: Runtime::Value.materialize(located.element), args: args }
         rescue StandardError
           nil
@@ -35,7 +47,7 @@ module Hecks
           domain_name, aggregate_name, command_name = Naming.split_verb(verb)
           return nil unless command_name&.include?(".")
 
-          aggregate = runtime.registry.bluebook(domain_name)&.aggregate(aggregate_name)
+          aggregate = runtime.bluebook(domain_name)&.aggregate(aggregate_name)
           return nil unless aggregate
 
           entity, command = entity_command(aggregate, command_name)
@@ -68,7 +80,7 @@ module Hecks
         # Finds the stored element the step's identity args address, or nil.
         def locate_element(runtime, target, args)
           parent_id = Replay.identity_for(target.aggregate, target.command, args)
-          record = parent_id && runtime.registry.repository(target.domain, target.aggregate).find(parent_id)
+          record = parent_id && runtime.repository(target.domain, target.aggregate).find(parent_id)
           list_attr = record && list_attribute(target)
           wants = list_attr && element_wants(target, args)
           element = wants && find_element(record.state[list_attr.name], wants)
@@ -76,14 +88,15 @@ module Hecks
         end
 
         def list_attribute(target)
-          target.aggregate.attributes.find { |a| a.list? && a.type.to_s == target.entity.hecks_name }
+          target.aggregate_attributes.find { |a| a.list? && a.type.to_s == target.entity_name }
         end
 
         # The `[head, value]` identity pairs the args give for the entity, or nil when an
         # identity argument is missing.
         def element_wants(target, args)
-          target.entity.identity_paths.map do |path|
-            head = path.to_s.split(".").first.to_sym
+          target.identity_paths.map do |path|
+            head_name = path.to_s.split(".").first
+            head = head_name.to_sym
             raw  = args[head]
             return nil if raw.nil?
 
@@ -108,8 +121,8 @@ module Hecks
         end
 
         def parent_record(runtime, trace)
-          aggregate = runtime.registry.bluebook(trace[:domain])&.aggregate(trace[:aggregate])
-          aggregate && runtime.registry.repository(trace[:domain], aggregate).find(trace[:parent_id])
+          aggregate = runtime.bluebook(trace[:domain])&.aggregate(trace[:aggregate])
+          aggregate && runtime.repository(trace[:domain], aggregate).find(trace[:parent_id])
         end
       end
     end

data/lib/hecks/fuzzing/replay/observation.rb

@@ -9,14 +9,18 @@ module Hecks
         def observed_history
           { instances: Replay.snapshot_instances(@runtime), events: events, refusals: @refusals,
             reactions: @runtime.reactions, sagas: @runtime.sagas, saga_instances: saga_instances,
-            queries: @queries, dry_runs: @dry_runs, dry_run_traces: @dry_run_traces,
+            queries: @queries, dry_runs: @dry_runs, dry_run_traces: @dry_run_traces, validations: @validations,
             fan_outs: @fan_outs, guard_checks: @guard_checks, role_checks: @role_checks,
+            refusal_traces: @refusal_traces,
             mutation_traces: @mutation_traces, outbox_traces: @outbox_traces,
             saga_dispatches: @runtime.saga_dispatches, policy_dispatches: @runtime.policy_dispatches,
-            bluebook: @runtime.registry.bluebooks.values.first,
-            bluebooks: @runtime.registry.bluebooks.dup }
+            cross_domain: @runtime.cross_domain_deliveries,
+            bluebook: registry.first_bluebook,
+            bluebooks: registry.bluebooks.dup }
         end
 
+        def registry = @runtime.registry
+
         def events
           @runtime.events.map { |event| { name: event.name, aggregate: event.aggregate, id: event.id, payload: event.payload } }
         end
@@ -26,7 +30,7 @@ module Hecks
         # runtime goes out of scope with the boot and the Memory rebind leaves no
         # real saga store for Properties.sagas_rehydrate_cleanly to read otherwise.
         def saga_instances
-          @runtime.registry.saga_instances.each_with_object({}) do |(pm_name, conversations), out|
+          registry.saga_instances.each_with_object({}) do |(pm_name, conversations), out|
             out[pm_name] = conversations.each_with_object({}) do |(correlation, instance), rows|
               rows[correlation] = { state: instance[:state], memory: Runtime::Value.materialize(instance[:memory]) }
             end
@@ -38,10 +42,10 @@ module Hecks
         # domain declares `for_each`, so the snapshot taken before each dispatch costs
         # nothing until one does.
         def fan_out_targets
-          @runtime.registry.bluebooks.each_with_object({}) do |(domain, bluebook), targets|
+          registry.bluebooks.each_with_object({}) do |(domain, bluebook), targets|
             bluebook.policies.select(&:fans_out?).each do |policy|
               query_domain, aggregate_name, = policy.for_each_route(domain)
-              targets[[query_domain, aggregate_name]] ||= @runtime.registry.bluebook(query_domain)&.aggregate(aggregate_name)
+              targets[[query_domain, aggregate_name]] ||= registry.bluebook(query_domain)&.aggregate(aggregate_name)
             end
           end
         end
@@ -51,7 +55,7 @@ module Hecks
             next unless aggregate
 
             snap[[fdomain, faggregate_name]] =
-              @runtime.registry.repository(fdomain, aggregate).all.to_h { |record| [record.id, record.state.dup] }
+              registry.repository(fdomain, aggregate).all.to_h { |record| [record.id, record.state.dup] }
           end
         end
       end

data/lib/hecks/fuzzing/replay/read_only_steps.rb

@@ -35,12 +35,44 @@ module Hecks
 
           entry = { query: question, args: args, rows: native_rows, instances_at: Replay.snapshot_instances(@runtime) }
           entry[:error] = native_error.message if native_error
+          add_pages(entry, question, args) unless native_error
           add_reference(entry, reference_rows, reference_error) if has_reference
           @queries << entry
 
           @refusals << { verb: question, error: native_error.message, kind: Replay.refusal_kind(native_error) } if native_error
         end
 
+        # A cursor query's walks, taken for `Properties` to hold to the unpaged rows.
+        def add_pages(entry, question, args)
+          entry[:pages] = cursor_walks(question, args) if cursor_query?(question)
+        end
+
+        # Whether `question` names a declared aggregate query that pages by cursor.
+        def cursor_query?(question)
+          domain, aggregate_name, query_name = Naming.split_verb(question)
+          declared = @runtime.bluebooks[domain]&.aggregate(aggregate_name)
+          !declared&.query(query_name.to_s)&.cursor.nil?
+        end
+
+        # Every page of a cursor query, walked at the query's own page size and again one row at
+        # a time (so a boundary falls between any two rows), as `{ page_size:, pages: }` per
+        # walk. A walk starts at the first page whatever `after` the ask itself carried.
+        def cursor_walks(question, args)
+          from_start = args.except(:after)
+          [nil, 1].map { |size| { page_size: size, pages: walk_pages(question, from_start, size) } }
+        end
+
+        def walk_pages(question, args, size)
+          pages = []
+          after = nil
+          loop do
+            page = @runtime.query_page(question, after: after, page_size: size, **args)
+            pages << page.fetch(:rows)
+            break unless (after = page[:after])
+          end
+          pages
+        end
+
         def add_reference(entry, reference_rows, reference_error)
           entry[:reference_rows]  = reference_rows
           entry[:reference_error] = reference_error.message if reference_error
@@ -64,19 +96,24 @@ module Hecks
         def dry_run(step, hypothetical, args)
           before = state_snapshot
           entry  = { verb: hypothetical }
-          attempt_dry_run(entry, step, hypothetical, args)
+          raised = attempt_dry_run(entry, step, hypothetical, args)
           after = state_snapshot
           @dry_runs << entry
-          @dry_run_traces << entry.merge(before: before, after: after)
+          @dry_run_traces << entry.merge(before: before, after: after, raised: raised,
+                                         validation: validation_of(step, hypothetical, args))
         end
 
         def state_snapshot = { instances: Replay.snapshot_instances(@runtime), events: @runtime.events.size }
 
+        # Runs the dry run into `entry`, and answers the offender of what it raised, if anything.
         def attempt_dry_run(entry, step, hypothetical, args)
           Replay.as_step_caller(step) { @runtime.dry_run?(hypothetical, **args) }
           entry[:ok] = true
+          nil
         rescue *Runtime::DOMAIN_REFUSALS, Bluebook::Expression::EvaluationError => e
-          entry.merge!(ok: false, error: e.message)
+          entry[:ok] = false
+          entry[:error] = e.message
+          offender_of(e)
         end
       end
     end

data/lib/hecks/fuzzing/replay/refusal_trace.rb

@@ -0,0 +1,44 @@
+module Hecks
+  module Fuzzing
+    module Replay
+      # Everything a refused dispatch must leave as it found it: stored records, journal entries,
+      # events, reactions, saga advances and outbox rows. Read before every dispatch and again
+      # after a refusal, so `Properties.refusals_leave_no_trace` can compare the two.
+      module RefusalTrace
+        module_function
+
+        # What a dispatch could change, read off the live runtime.
+        #
+        # @param runtime [Hecks::Runtime] the booted runtime a step dispatches against
+        # @return [Hash] `instances:`, `journal:`, `events:`, `reactions:`, `sagas:` and `outbox:`
+        def snapshot(runtime)
+          { instances: Replay.snapshot_instances(runtime), journal: journal(runtime.registry),
+            events: runtime.events.size, reactions: runtime.reactions.size, sagas: runtime.sagas.size,
+            outbox: outbox_ids(runtime.outbox) }
+        end
+
+        # The delivery ids of every row the outbox holds.
+        #
+        # @param outbox [#rows] the runtime's outbox
+        # @return [Array<String>] each row's `delivery_id`, in row order
+        def outbox_ids(outbox) = outbox.rows.map(&:delivery_id)
+
+        # Each append-only repository's entries, keyed by `"Domain::Aggregate"`; a repository
+        # that keeps no journal is left out.
+        #
+        # @param registry [Runtime::Registry] the booted registry
+        # @return [Hash{String => Array<Array>}] `[operation, id, state]` per entry
+        def journal(registry)
+          registry.bluebooks.each_with_object({}) do |(domain, bluebook), out|
+            bluebook.aggregates.each do |aggregate|
+              repository = registry.repository(domain, aggregate)
+              next unless repository.is_a?(Ports::Persistence::AppendOnly)
+
+              out["#{domain}::#{aggregate.name}"] = repository.entries.map { |e| [e.operation, e.id, e.state] }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/replay/role_check.rb

@@ -19,7 +19,7 @@ module Hecks
           domain, command = command_of(runtime, step["verb"])
           return nil unless command && governed?(runtime, domain, command)
 
-          { verb: step["verb"], role: command.role.to_s, actor_id: step["actor_id"].to_s,
+          { verb: step["verb"], role: command.role.to_s, roles: command.role_set, actor_id: step["actor_id"].to_s,
             grants: grants_for(runtime.registry, step["actor_id"]) }
         rescue StandardError
           nil
@@ -28,7 +28,7 @@ module Hecks
         # The `[domain, command]` an aggregate-level verb names; the command is nil when none does.
         def command_of(runtime, verb)
           domain, aggregate_name, command_name = Naming.split_verb(verb)
-          [domain, runtime.registry.bluebook(domain)&.aggregate(aggregate_name)&.command(command_name)]
+          [domain, runtime.bluebook(domain)&.aggregate(aggregate_name)&.command(command_name)]
         end
 
         # Whether the command declares a role and its domain has an authorization provider.

data/lib/hecks/fuzzing/replay/session.rb

@@ -1,5 +1,7 @@
 require_relative "observation"
 require_relative "read_only_steps"
+require_relative "validation_reports"
+require_relative "refusal_trace"
 
 module Hecks
   module Fuzzing
@@ -11,6 +13,7 @@ module Hecks
       # which `take_marks` and `dispatch` run them is part of what they mean.
       class Session
         include ReadOnlySteps
+        include ValidationReports
         include Observation
 
         # What is read before a dispatch so its own effects can be sliced out afterwards.
@@ -18,16 +21,15 @@ module Hecks
         # `outbox_ids` is a set of delivery_ids, not a size, because `runtime.outbox.rows`
         # concatenates several stores' own arrays, so a plain "grew from N to M" tail slice
         # could miss or misattribute rows once more than one repository has an outbox.
-        Marks = Struct.new(:reaction, :saga, :outbox_ids, :fan_out_snapshot, :guard_check, :mutation_trace, :role_check)
+        Marks = Struct.new(:reaction, :saga, :outbox_ids, :fan_out_snapshot, :guard_check, :mutation_trace, :role_check,
+                           :refusal_trace)
 
         # @param runtime [Hecks::Runtime] a freshly booted runtime
         def initialize(runtime)
           @runtime         = runtime
           @refusals        = []
-          @queries         = []
-          @dry_runs        = []
-          @dry_run_traces  = []
           @fan_outs        = []
+          start_read_only_records
           start_checks
           @mutation_traces = []
           @outbox_traces   = []
@@ -43,9 +45,9 @@ module Hecks
           self
         end
 
-        # The history of everything played so far, with the booted chapter beside it so
+        # The history of everything played so far, with the booted bluebook beside it so
         # properties.rb's lifecycle/saga checks have the declared IR. `bluebook:` (singular) is
-        # the first-loaded chapter; `bluebooks:` (plural) is the full domain-name-keyed map, for
+        # the first-loaded bluebook; `bluebooks:` (plural) is the full domain-name-keyed map, for
         # a property that must resolve a verb back to its declaring bluebook.
         #
         # `runtime` is still live here, so SelfConsistency runs against the same registry a
@@ -61,23 +63,30 @@ module Hecks
 
         private
 
+        # What the steps that change nothing record: asked queries, dry runs and their traces, and
+        # validations.
+        def start_read_only_records
+          @queries        = []
+          @dry_runs       = []
+          @dry_run_traces = []
+          @validations    = []
+        end
+
         # The two checks recorded before a dispatch and compared with its outcome afterwards.
         def start_checks
-          @guard_checks = []
-          @role_checks  = []
+          @guard_checks   = []
+          @role_checks    = []
+          @refusal_traces = []
         end
 
         def play_step(step)
           step = step.transform_keys(&:to_s)
           args = (step["args"] || {}).transform_keys(&:to_sym)
+          return ask(step["query"], args) if step["query"]
+          return dry_run(step, step["dry_run"], args) if step.key?("dry_run")
+          return validate_step(step, step["validate"], args) if step.key?("validate")
 
-          if (question = step["query"])
-            ask(question, args)
-          elsif (hypothetical = step["dry_run"])
-            dry_run(step, hypothetical, args)
-          else
-            dispatch(step, args)
-          end
+          dispatch(step, args)
         end
 
         def dispatch(step, args)
@@ -91,6 +100,15 @@ module Hecks
           record_effects(step, result, marks)
         rescue *Runtime::DOMAIN_REFUSALS, Bluebook::Expression::EvaluationError => e
           record_refusal(step, e, marks&.guard_check, marks&.role_check)
+          record_refusal_trace(step, e, marks&.refusal_trace)
+        end
+
+        # A refused dispatch's before and after, for `Properties.refusals_leave_no_trace`.
+        def record_refusal_trace(step, error, before)
+          return unless before
+
+          @refusal_traces << { verb: step["verb"], kind: Replay.refusal_kind(error), before: before,
+                               after: RefusalTrace.snapshot(@runtime) }
         end
 
         # Taken before dispatch, so this step's own reactions, sagas and outbox rows can be
@@ -102,9 +120,10 @@ module Hecks
         # anything a cross-aggregate given dereferences, and the entity element a mutation
         # step's args address is snapshotted so it can be diffed against its post-dispatch state.
         def take_marks(step, args)
-          Marks.new(@runtime.reactions.size, @runtime.sagas.size, @runtime.outbox.rows.map(&:delivery_id),
+          Marks.new(@runtime.reactions.size, @runtime.sagas.size, RefusalTrace.outbox_ids(@runtime.outbox),
                     fan_out_snapshot, GuardCheck.build(@runtime, step["verb"], args),
-                    MutationTrace.build(@runtime, step["verb"], args), RoleCheck.build(@runtime, step))
+                    MutationTrace.build(@runtime, step["verb"], args), RoleCheck.build(@runtime, step),
+                    RefusalTrace.snapshot(@runtime))
         end
 
         def record_effects(step, result, marks)
@@ -134,7 +153,8 @@ module Hecks
         end
 
         def outbox_rows_since(marks)
-          @runtime.outbox.rows.reject { |row| marks.outbox_ids.include?(row.delivery_id) }
+          outbox = @runtime.outbox
+          outbox.rows.reject { |row| marks.outbox_ids.include?(row.delivery_id) }
         end
 
         # After — only on success; a refused step mutated nothing, so there is no "after" to

data/lib/hecks/fuzzing/replay/validation_reports.rb

@@ -0,0 +1,61 @@
+module Hecks
+  module Fuzzing
+    module Replay
+      # How a session reports what `validate` says of a command: the verdict kept beside a dry run's
+      # trace, a `validate` step's refusals in the wire shape, and a refusal's offender. Mixed into
+      # `Session` with `ReadOnlySteps`, whose dry runs use them.
+      module ValidationReports
+        private
+
+        # What `validate` says of the same hypothetical, kept beside the trace: whether it would be
+        # accepted, the stage, text and offender of its first refusal, and every refusal as
+        # `[kind, stage, attribute, path, rule, class]`. It is asked through `validate_facts`, which
+        # reads `to` and `with` as facts the way `dry_run?` does; `validate` would route them, and
+        # so answer a different command.
+        def validation_of(step, hypothetical, args)
+          result = Replay.as_step_caller(step) { @runtime.validate_facts(hypothetical, **args) }
+          first = result.refusals.first
+          { ok: result.ok?, first_stage: first&.stage, first_message: first&.message, first_offender: offender_of(first),
+            reasons: result.refusals.map { |refusal| reason_of(refusal) } }
+        rescue Runtime::WiringError
+          nil
+        end
+
+        # A `validate` step: every refusal the command would meet, recorded as data and never as a
+        # refusal of the script. Compared against `kernel/cli.rs`'s own `validate` answer.
+        def validate_step(step, hypothetical, args)
+          result = Replay.as_step_caller(step) { @runtime.validate(hypothetical, args) }
+          @validations << { verb: hypothetical, ok: result.ok?,
+                            refusals: result.refusals.map { |refusal| validation_entry(refusal) } }
+        end
+
+        # One refusal in the wire shape: class, kind, stage, attribute, path, rule and message.
+        def validation_entry(refusal)
+          detail = refusal.to_h
+          { kind: detail[:kind], stage: detail[:stage], refusal: class_name_of(refusal),
+            attribute: detail[:attribute], path: detail[:path], rule: detail[:rule], message: detail[:message] }
+        end
+
+        # One refusal as the comparison reads it: `[kind, stage, attribute, path, rule, class]`.
+        def reason_of(refusal)
+          entry = validation_entry(refusal)
+          parts = entry.values_at(:kind, :stage, :attribute, :path, :rule)
+          [*parts.map { |part| part&.to_s }, entry[:refusal]]
+        end
+
+        def class_name_of(refusal)
+          name = refusal.class.name
+          name.split("::").last
+        end
+
+        # A refusal's class and the attribute it is about: what `validate` keeps of a refusal that
+        # names several offenders when it splits it into one refusal each.
+        def offender_of(refusal)
+          return unless refusal
+
+          [refusal.class.name, refusal.respond_to?(:attribute) ? refusal.attribute : nil]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/replay.rb

@@ -69,9 +69,9 @@ module Hecks
       # rows" reads the state as that query actually saw it, not a shared final one.
       def snapshot_instances(runtime)
         instances = {}
-        runtime.registry.bluebooks.each do |domain_name, bluebook|
+        runtime.bluebooks.each do |domain_name, bluebook|
           bluebook.aggregates.each do |aggregate|
-            runtime.registry.repository(domain_name, aggregate).all.each do |record|
+            runtime.repository(domain_name, aggregate).all.each do |record|
               instances["#{domain_name}::#{aggregate.name}##{record.id}"] = record.state
             end
           end

data/lib/hecks/fuzzing/rust_gap_manifest.rb

@@ -9,7 +9,7 @@ module Hecks
     # The differential fuzzer drops a query or read-model verb only when a manifest says
     # `generated: false`; any other refusal stays in the comparison and fails it.
     #
-    # A binary's manifests are its own `src/generated/<feature>/` plus every shared chapter
+    # A binary's manifests are its own `src/generated/<feature>/` plus every shared bluebook
     # (a generated directory with no `merged.rs`). A missing manifest tolerates nothing.
     class RustGapManifest
       # Commands change state, so dropping their refusal would make the comparison dishonest.
@@ -80,8 +80,8 @@ module Hecks
       def manifest_paths
         generated = File.join(rust_dir, "src/generated")
         own = File.join(generated, feature, "manifest.json")
-        chapters = Dir.glob(File.join(generated, "*/manifest.json")).reject { |path| own_or_merged?(File.dirname(path)) }
-        ([own] + chapters.sort).select { |path| File.exist?(path) }
+        declarations = Dir.glob(File.join(generated, "*/manifest.json")).reject { |path| own_or_merged?(File.dirname(path)) }
+        ([own] + declarations.sort).select { |path| File.exist?(path) }
       end
 
       def own_or_merged?(dir) = File.basename(dir) == feature || File.exist?(File.join(dir, "merged.rs"))

data/lib/hecks/fuzzing/self_consistency/saga_redelivery.rb

@@ -10,7 +10,16 @@ module Hecks
         # One redelivery probe: the runtime and interpreter it runs on, the saga it re-advances,
         # and the event it redelivers.
         Redelivery = Struct.new(:runtime, :interpreter, :domain_name, :process_manager, :anchor,
-                                :correlation, :saga, :event)
+                                :correlation, :saga, :event) do
+          # @return [Runtime::Registry] the registry of the runtime the probe runs on
+          def registry = runtime.registry
+
+          # @return [String] the name of the process manager the probe re-advances
+          def process_manager_name = process_manager.name
+
+          # @return [String] the name of the event the probe redelivers
+          def event_name = event.name
+        end
 
         # A rehydrated saga checkpoint must not advance when its last event is redelivered.
         #
@@ -40,14 +49,15 @@ module Hecks
           entry = last_advance_entry(runtime, process_manager, correlation)
           return nil unless entry
 
-          runtime.events.reverse_each.find do |event|
+          events = runtime.events
+          events.reverse_each.find do |event|
             event.name == entry[:on] && interpreter.send(:saga_correlation, process_manager, event) == correlation
           end
         end
 
         # The newest saga-log row in which the correlation advanced on a real event.
         def last_advance_entry(runtime, process_manager, correlation)
-          runtime.registry.saga_log.reverse_each.find do |row|
+          runtime.sagas.reverse_each.find do |row|
             row[:process_manager] == process_manager.name && row[:instance] == correlation &&
               row[:advanced] && row[:on] != Runtime::SagaInterpreter::REFUSED
           end
@@ -67,7 +77,7 @@ module Hecks
         # compensations]`, or nil when the cold read does not find it.
         def cold_checkpoint(redelivery, tmp)
           saga = redelivery.saga
-          heki_for(redelivery, tmp).save_saga(process_manager: redelivery.process_manager.name,
+          heki_for(redelivery, tmp).save_saga(process_manager: redelivery.process_manager_name,
                                               correlation: redelivery.correlation.to_s, state: saga[:state],
                                               memory: saga[:memory], completed_compensations: [])
 
@@ -83,8 +93,8 @@ module Hecks
         def probe_redelivery(redelivery, checkpoint)
           state, memory, = checkpoint
           before = { state: state, memory: deep_stringify_keys(memory) }
-          registry = redelivery.runtime.registry
-          saga_instances = registry.saga_instances[redelivery.process_manager.name]
+          registry = redelivery.registry
+          saga_instances = registry.saga_instances[redelivery.process_manager_name]
 
           preserving_saga(saga_instances, redelivery.correlation, registry.saga_log) do
             redelivery_finding(redelivery, before, advanced_saga(redelivery, saga_instances, checkpoint))
@@ -107,8 +117,8 @@ module Hecks
           return if after_shape == before
 
           { field: "saga_redelivery_idempotency", domain: redelivery.domain_name,
-            process_manager: redelivery.process_manager.name, correlation: redelivery.correlation,
-            on: redelivery.event.name, before: before, after: after_shape }
+            process_manager: redelivery.process_manager_name, correlation: redelivery.correlation,
+            on: redelivery.event_name, before: before, after: after_shape }
         end
 
         # Runs the block, then puts the live saga slot back and slices off any `saga_log` rows the

data/lib/hecks/fuzzing/self_consistency/sagas.rb

@@ -25,7 +25,7 @@ module Hecks
             persisted = saga_instances[process_manager.name]
             next if persisted.nil? || persisted.empty?
 
-            anchor = runtime.registry.bluebook(domain_name).aggregates.first
+            anchor = runtime.bluebook(domain_name).aggregates.first
             [domain_name, process_manager, anchor, persisted] if anchor
           end
         end
@@ -55,7 +55,7 @@ module Hecks
         # Every [domain, process manager] pair any loaded bluebook declares.
         def each_domain_process_manager(runtime)
           found = []
-          runtime.registry.bluebooks.each do |domain_name, bluebook|
+          runtime.bluebooks.each do |domain_name, bluebook|
             bluebook.process_managers.each { |pm| found << [domain_name, pm] }
           end
           found

data/lib/hecks/fuzzing/self_consistency/value_objects.rb

@@ -33,7 +33,13 @@ module Hecks
         end
 
         # The aggregate a stored-record key `Domain::Aggregate#id` belongs to, or nil.
-        def instance_owner(bluebooks, key) = owning_aggregate(bluebooks, key.to_s.split("#", 2).first.to_s)
+        def instance_owner(bluebooks, key) = owning_aggregate(bluebooks, record_aggregate(key))
+
+        # The `"Domain::Aggregate"` part of a stored-record key `Domain::Aggregate#id`.
+        def record_aggregate(key)
+          qualified_name, = key.to_s.split("#", 2)
+          qualified_name.to_s
+        end
 
         # The aggregate a `"Domain::Aggregate"` name refers to, or nil.
         def owning_aggregate(bluebooks, qualified_name)
@@ -77,7 +83,8 @@ module Hecks
 
           seen[node] = true
           found << [node, aggregate]
-          node.value_object.attributes.each do |attribute|
+          value_object = node.value_object
+          value_object.attributes.each do |attribute|
             walk_value_objects(node[attribute.name], found, seen, aggregate)
           end
         end

data/lib/hecks/fuzzing/self_consistency.rb

@@ -99,17 +99,13 @@ module Hecks
 
       # Every [domain, aggregate, repository, entries] tuple with at least one journal entry.
       def each_touched_repository(runtime)
-        found = []
-        runtime.registry.bluebooks.each do |domain_name, bluebook|
-          bluebook.aggregates.each do |aggregate|
-            repository = runtime.registry.repository(domain_name, aggregate)
+        runtime.bluebooks.flat_map do |domain_name, bluebook|
+          bluebook.aggregates.filter_map do |aggregate|
+            repository = runtime.repository(domain_name, aggregate)
             entries    = repository.entries
-            next if entries.empty?
-
-            found << [domain_name, aggregate, repository, entries]
+            [domain_name, aggregate, repository, entries] unless entries.empty?
           end
         end
-        found
       end
 
       # Stored records keyed by stringified id, materialized for comparison with a cold read.