hecks 3.5.0 → 3.7.0

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

@@ -0,0 +1,133 @@
+require "tmpdir"
+require_relative "../../runtime/saga_interpreter"
+
+module Hecks
+  module Fuzzing
+    module SelfConsistency
+      # The saga redelivery check: a rehydrated checkpoint must not advance when its last event
+      # is redelivered. Mixed into `SelfConsistency`, whose `guarded_heki` and saga helpers it uses.
+      module SagaRedelivery
+        # 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)
+
+        # A rehydrated saga checkpoint must not advance when its last event is redelivered.
+        #
+        # The live registry slot is swapped for the cold-read checkpoint and restored in `ensure`;
+        # safe because nothing reads the live registry after this runs. Only state/memory are
+        # compared: a leg whose `from:` and `to:` match legitimately re-runs.
+        def check_saga_idempotency(runtime, history)
+          interpreter = Runtime::SagaInterpreter.new(runtime.registry, door: runtime)
+
+          saga_groups(runtime, history).flat_map do |domain_name, process_manager, anchor, persisted|
+            persisted.filter_map do |correlation, saga|
+              redelivery = last_advancing_event(runtime, interpreter, process_manager, correlation)
+              next unless redelivery
+
+              check_one_saga_redelivery(Redelivery.new(runtime, interpreter, domain_name, process_manager,
+                                                       anchor, correlation, saga, redelivery))
+            end
+          end
+        end
+
+        # The domain event the correlation's current checkpoint last advanced on, or nil if it
+        # never advanced. Skips the synthetic `REFUSED` trigger, which has no event to redeliver.
+        #
+        # Uses `send(:saga_correlation)` on purpose: the private method is the real correlation
+        # logic, and reimplementing it here would only approximate it.
+        def last_advancing_event(runtime, interpreter, process_manager, correlation)
+          entry = last_advance_entry(runtime, process_manager, correlation)
+          return nil unless entry
+
+          runtime.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|
+            row[:process_manager] == process_manager.name && row[:instance] == correlation &&
+              row[:advanced] && row[:on] != Runtime::SagaInterpreter::REFUSED
+          end
+        end
+
+        # One correlation's redelivery check, split out of `check_saga_idempotency`.
+        def check_one_saga_redelivery(redelivery)
+          Dir.mktmpdir("hecks-self-consistency-saga") do |tmp|
+            checkpoint = cold_checkpoint(redelivery, tmp)
+            next unless checkpoint
+
+            probe_redelivery(redelivery, checkpoint)
+          end
+        end
+
+        # Writes the live saga through Heki and reads it back cold: `[state, memory,
+        # 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,
+                                              correlation: redelivery.correlation.to_s, state: saga[:state],
+                                              memory: saga[:memory], completed_compensations: [])
+
+          rehydrated = heki_for(redelivery, tmp).each_saga.find { |_pm, corr, *| corr == redelivery.correlation.to_s }
+          rehydrated&.drop(2)
+        end
+
+        def heki_for(redelivery, tmp)
+          guarded_heki(aggregate: redelivery.anchor, root: tmp, settings: { domain: redelivery.domain_name })
+        end
+
+        # Redelivers the event to the cold-read checkpoint and reports any state/memory change.
+        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]
+
+          preserving_saga(saga_instances, redelivery.correlation, registry.saga_log) do
+            redelivery_finding(redelivery, before, advanced_saga(redelivery, saga_instances, checkpoint))
+          end
+        end
+
+        # Swaps the cold-read checkpoint into the live slot, redelivers the event, and answers
+        # the slot as the redelivery left it.
+        def advanced_saga(redelivery, saga_instances, checkpoint)
+          state, memory, compensations = checkpoint
+          saga_instances[redelivery.correlation] = { state: state, memory: memory,
+                                                     completed_compensations: compensations || [] }
+          redelivery.interpreter.advance(redelivery.event, redelivery.domain_name, only: redelivery.process_manager)
+          saga_instances[redelivery.correlation]
+        end
+
+        # The finding for a redelivery that moved the saga, or nil.
+        def redelivery_finding(redelivery, before, after)
+          after_shape = after && { state: after[:state], memory: deep_stringify_keys(after[:memory]) }
+          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 }
+        end
+
+        # Runs the block, then puts the live saga slot back and slices off any `saga_log` rows the
+        # probe appended: `advance` appends to the log (shared by reference with the primary
+        # trace), and the probe must not leak into it.
+        def preserving_saga(saga_instances, correlation, saga_log)
+          original      = saga_instances[correlation]
+          saga_log_mark = saga_log.size
+          yield
+        ensure
+          saga_log.slice!(saga_log_mark..) if saga_log.size > saga_log_mark
+
+          if original
+            saga_instances[correlation] = original
+          else
+            saga_instances.delete(correlation)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+require "tmpdir"
+require_relative "../../runtime/saga_interpreter"
+
+module Hecks
+  module Fuzzing
+    module SelfConsistency
+      # The saga rehydration check: checkpoints written through Heki and read back cold.
+      # Mixed into `SelfConsistency`, whose `guarded_heki` it uses.
+      module Sagas
+        # A saga checkpoint written through Heki and read back cold must equal the live saga
+        # instances. One finding per (domain, process manager).
+        #
+        # `completed_compensations` is not compared; `history[:saga_instances]` never records it.
+        def check_saga_rehydration(runtime, history)
+          saga_groups(runtime, history).filter_map do |domain_name, process_manager, anchor, persisted|
+            saga_rehydration_finding(anchor, domain_name, process_manager, persisted)
+          end
+        end
+
+        # Every `[domain, process manager, anchor aggregate, persisted conversations]` with at
+        # least one live conversation.
+        def saga_groups(runtime, history)
+          saga_instances = history[:saga_instances] || {}
+          each_domain_process_manager(runtime).filter_map do |domain_name, process_manager|
+            persisted = saga_instances[process_manager.name]
+            next if persisted.nil? || persisted.empty?
+
+            anchor = runtime.registry.bluebook(domain_name).aggregates.first
+            [domain_name, process_manager, anchor, persisted] if anchor
+          end
+        end
+
+        # The finding for one process manager whose cold-read checkpoints differ from live, or nil.
+        def saga_rehydration_finding(anchor, domain_name, process_manager, persisted)
+          Dir.mktmpdir("hecks-self-consistency-saga") do |tmp|
+            write_saga_checkpoints(anchor, tmp, domain_name, process_manager, persisted)
+            live       = normalize_saga_rows(persisted)
+            rehydrated = cold_read_saga_rows(anchor, tmp, domain_name)
+            next if rehydrated == live
+
+            { field: "saga_rehydration", domain: domain_name, process_manager: process_manager.name,
+              live: live, rehydrated: rehydrated }
+          end
+        end
+
+        # Writes every live conversation of `process_manager` through Heki under `tmp`.
+        def write_saga_checkpoints(anchor, tmp, domain_name, process_manager, persisted)
+          writer = guarded_heki(aggregate: anchor, root: tmp, settings: { domain: domain_name })
+          persisted.each do |correlation, saga|
+            writer.save_saga(process_manager: process_manager.name, correlation: correlation.to_s,
+                             state: saga[:state], memory: saga[:memory], completed_compensations: [])
+          end
+        end
+
+        # Every [domain, process manager] pair any loaded bluebook declares.
+        def each_domain_process_manager(runtime)
+          found = []
+          runtime.registry.bluebooks.each do |domain_name, bluebook|
+            bluebook.process_managers.each { |pm| found << [domain_name, pm] }
+          end
+          found
+        end
+
+        # Live saga rows with `memory` deep-stringified, matching what a Heki round trip yields.
+        def normalize_saga_rows(persisted)
+          persisted.each_with_object({}) do |(correlation, saga), rows|
+            rows[correlation.to_s] = { state: saga[:state], memory: deep_stringify_keys(saga[:memory]) }
+          end
+        end
+
+        # A fresh `Heki` reader at the same path: a new instance has no memoized store, so the
+        # read goes through the on-disk snapshot and journal rather than the writer's memory.
+        def cold_read_saga_rows(anchor, tmp, domain_name)
+          reader = guarded_heki(aggregate: anchor, root: tmp, settings: { domain: domain_name })
+          reader.each_saga.with_object({}) do |(_pm, correlation, state, memory, _completed), rows|
+            rows[correlation] = { state: state, memory: deep_stringify_keys(memory) }
+          end
+        end
+
+        # `SagaStore#each_saga` symbolizes only top-level `memory` keys, while the live side is
+        # symbol-keyed throughout. Stringifying both sides tells that accepted difference apart
+        # from real data loss.
+        def deep_stringify_keys(value)
+          case value
+          when Hash  then value.each_with_object({}) { |(k, v), h| h[k.to_s] = deep_stringify_keys(v) }
+          when Array then value.map { |item| deep_stringify_keys(item) }
+          else value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require "json"
+
+module Hecks
+  module Fuzzing
+    module SelfConsistency
+      # The value-object round trip: every value object a sequence built must survive
+      # `to_json` then `Value.build`. Mixed into `SelfConsistency`.
+      module ValueObjects
+        # Every value object the sequence built must survive `to_json` then `Value.build`.
+        #
+        # The owning aggregate is passed to `build` so nested composite fields resolve; with `nil`
+        # they come back as bare Hashes, a false positive. Query rows are skipped because they
+        # name no single owning aggregate.
+        def check_value_object_round_trip(history)
+          value_objects_in(history).filter_map { |value, aggregate| round_trip_finding(value, aggregate) }
+        end
+
+        # Every `[value, owning aggregate]` pair found in the history's instances and events.
+        def value_objects_in(history)
+          bluebooks = history[:bluebooks] || {}
+          seen = {}.compare_by_identity
+          found = []
+
+          history[:instances].each do |key, state|
+            walk_value_objects(state, found, seen, instance_owner(bluebooks, key))
+          end
+
+          history[:events].each do |event|
+            walk_value_objects(event[:payload], found, seen, owning_aggregate(bluebooks, event[:aggregate].to_s))
+          end
+
+          found
+        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)
+
+        # The aggregate a `"Domain::Aggregate"` name refers to, or nil.
+        def owning_aggregate(bluebooks, qualified_name)
+          domain_name, aggregate_name = qualified_name.split("::", 2)
+          bluebooks[domain_name]&.aggregate(aggregate_name)
+        end
+
+        # The finding for one value that does not survive its round trip, or nil.
+        def round_trip_finding(value, aggregate)
+          rebuilt, error = rebuild(value, aggregate)
+          if error
+            return { field: "value_object_round_trip", type: value.type_name, original: value.to_h,
+                     error: "#{error.class}: #{error.message}" }
+          end
+          return if rebuilt == value
+
+          { field: "value_object_round_trip", type: value.type_name, original: value.to_h,
+            rehydrated: rebuilt.to_h }
+        end
+
+        # `[rebuilt value, nil]`, or `[nil, the error]` when the rebuild raises.
+        def rebuild(value, aggregate)
+          [Runtime::Value.build(value.value_object, JSON.parse(value.to_json), aggregate), nil]
+        rescue StandardError => e
+          [nil, e]
+        end
+
+        # Recurses via `#[]` rather than `#to_h`, which would materialize nested values away.
+        # `seen` compares by identity: a live state and an event payload can share one object,
+        # while two equal but distinct value objects are still two round trips to prove.
+        def walk_value_objects(node, found, seen, aggregate)
+          case node
+          when Runtime::Value then walk_value_object(node, found, seen, aggregate)
+          when Hash           then node.each_value { |value| walk_value_objects(value, found, seen, aggregate) }
+          when Array          then node.each { |value| walk_value_objects(value, found, seen, aggregate) }
+          end
+        end
+
+        def walk_value_object(node, found, seen, aggregate)
+          return if seen[node]
+
+          seen[node] = true
+          found << [node, aggregate]
+          node.value_object.attributes.each do |attribute|
+            walk_value_objects(node[attribute.name], found, seen, aggregate)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/fuzzing/self_consistency.rb

@@ -3,12 +3,19 @@ require "tmpdir"
 require "open3"
 require_relative "../adapters/driven/heki"
 require_relative "../runtime/saga_interpreter"
+require_relative "self_consistency/saga_redelivery"
+require_relative "self_consistency/sagas"
+require_relative "self_consistency/value_objects"
 
 module Hecks
   module Fuzzing
     # Checks that one engine agrees with itself: journal rehydration, replay idempotency and
     # value-object round trips, for Ruby and for the compiled Rust binary.
     module SelfConsistency
+      extend SagaRedelivery
+      extend Sagas
+      extend ValueObjects
+
       module_function
 
       # Guarded like a runtime repository: these adapters bypass `RepositoryFactory.build`,
@@ -42,7 +49,7 @@ module Hecks
 
       # Folding the same entries into the same store twice must change nothing.
       def check_idempotency(runtime)
-        each_touched_repository(runtime).filter_map do |domain_name, aggregate, repository, entries|
+        each_touched_repository(runtime).filter_map do |domain_name, aggregate, _repository, entries|
           Dir.mktmpdir("hecks-self-consistency") do |tmp|
             writer = guarded_heki(aggregate: aggregate, root: tmp)
             once   = fold!(writer, tmp, aggregate, entries)
@@ -55,99 +62,6 @@ module Hecks
         end
       end
 
-      # Every value object the sequence built must survive `to_json` then `Value.build`.
-      #
-      # The owning aggregate is passed to `build` so nested composite fields resolve; with `nil`
-      # they come back as bare Hashes, a false positive. Query rows are skipped because they
-      # name no single owning aggregate.
-      def check_value_object_round_trip(history)
-        bluebooks = history[:bluebooks] || {}
-        seen = {}.compare_by_identity
-        found = []
-
-        history[:instances].each do |key, state|
-          domain_name, aggregate_name = key.to_s.split("#", 2).first.to_s.split("::", 2)
-          aggregate = bluebooks[domain_name]&.aggregate(aggregate_name)
-          walk_value_objects(state, found, seen, aggregate)
-        end
-
-        history[:events].each do |event|
-          domain_name, aggregate_name = event[:aggregate].to_s.split("::", 2)
-          aggregate = bluebooks[domain_name]&.aggregate(aggregate_name)
-          walk_value_objects(event[:payload], found, seen, aggregate)
-        end
-
-        found.filter_map do |value, aggregate|
-          begin
-            rebuilt = Runtime::Value.build(value.value_object, JSON.parse(value.to_json), aggregate)
-          rescue StandardError => e
-            next { field: "value_object_round_trip", type: value.type_name, original: value.to_h,
-                   error: "#{e.class}: #{e.message}" }
-          end
-
-          next if rebuilt == value
-
-          { field: "value_object_round_trip", type: value.type_name, original: value.to_h,
-            rehydrated: rebuilt.to_h }
-        end
-      end
-
-      # A saga checkpoint written through Heki and read back cold must equal the live saga
-      # instances. One finding per (domain, process manager).
-      #
-      # `completed_compensations` is not compared; `history[:saga_instances]` never records it.
-      def check_saga_rehydration(runtime, history)
-        saga_instances = history[:saga_instances] || {}
-        each_domain_process_manager(runtime).filter_map do |domain_name, process_manager|
-          persisted = saga_instances[process_manager.name]
-          next if persisted.nil? || persisted.empty?
-
-          anchor = runtime.registry.bluebook(domain_name).aggregates.first
-          next unless anchor
-
-          Dir.mktmpdir("hecks-self-consistency-saga") do |tmp|
-            writer = guarded_heki(aggregate: anchor, root: tmp, settings: { domain: domain_name })
-            persisted.each do |correlation, saga|
-              writer.save_saga(process_manager: process_manager.name, correlation: correlation.to_s,
-                               state: saga[:state], memory: saga[:memory], completed_compensations: [])
-            end
-
-            live       = normalize_saga_rows(persisted)
-            rehydrated = cold_read_saga_rows(anchor, tmp, domain_name)
-            next if rehydrated == live
-
-            { field: "saga_rehydration", domain: domain_name, process_manager: process_manager.name,
-              live: live, rehydrated: rehydrated }
-          end
-        end
-      end
-
-      # A rehydrated saga checkpoint must not advance when its last event is redelivered.
-      #
-      # The live registry slot is swapped for the cold-read checkpoint and restored in `ensure`;
-      # safe because nothing reads the live registry after this runs. Only state/memory are
-      # compared: a leg whose `from:` and `to:` match legitimately re-runs.
-      def check_saga_idempotency(runtime, history)
-        saga_instances = history[:saga_instances] || {}
-        interpreter    = Runtime::SagaInterpreter.new(runtime.registry, door: runtime)
-
-        each_domain_process_manager(runtime).flat_map do |domain_name, process_manager|
-          persisted = saga_instances[process_manager.name]
-          next [] if persisted.nil? || persisted.empty?
-
-          anchor = runtime.registry.bluebook(domain_name).aggregates.first
-          next [] unless anchor
-
-          persisted.filter_map do |correlation, saga|
-            redelivery = last_advancing_event(runtime, interpreter, process_manager, correlation)
-            next unless redelivery
-
-            check_one_saga_redelivery(runtime, interpreter, domain_name, process_manager, anchor,
-                                      correlation, saga, redelivery)
-          end
-        end
-      end
-
       # Seeds a fresh invocation of the binary with prior "instances" and no steps.
       # `emitted_*` fields are not stripped: no Ruby side exists to disagree with, and stripping
       # only the result would report a false divergence on every record carrying one.
@@ -199,105 +113,6 @@ module Hecks
         repository.all.to_h { |record| [record.id.to_s, Runtime::Value.materialize(record.state)] }
       end
 
-      # Every [domain, process manager] pair any loaded bluebook declares.
-      def each_domain_process_manager(runtime)
-        found = []
-        runtime.registry.bluebooks.each do |domain_name, bluebook|
-          bluebook.process_managers.each { |pm| found << [domain_name, pm] }
-        end
-        found
-      end
-
-      # Live saga rows with `memory` deep-stringified, matching what a Heki round trip yields.
-      def normalize_saga_rows(persisted)
-        persisted.each_with_object({}) do |(correlation, saga), rows|
-          rows[correlation.to_s] = { state: saga[:state], memory: deep_stringify_keys(saga[:memory]) }
-        end
-      end
-
-      # A fresh `Heki` reader at the same path: a new instance has no memoized store, so the
-      # read goes through the on-disk snapshot and journal rather than the writer's memory.
-      def cold_read_saga_rows(anchor, tmp, domain_name)
-        reader = guarded_heki(aggregate: anchor, root: tmp, settings: { domain: domain_name })
-        reader.each_saga.with_object({}) do |(_pm, correlation, state, memory, _completed), rows|
-          rows[correlation] = { state: state, memory: deep_stringify_keys(memory) }
-        end
-      end
-
-      # `SagaStore#each_saga` symbolizes only top-level `memory` keys, while the live side is
-      # symbol-keyed throughout. Stringifying both sides tells that accepted difference apart
-      # from real data loss.
-      def deep_stringify_keys(value)
-        case value
-        when Hash  then value.each_with_object({}) { |(k, v), h| h[k.to_s] = deep_stringify_keys(v) }
-        when Array then value.map { |item| deep_stringify_keys(item) }
-        else value
-        end
-      end
-
-      # The domain event the correlation's current checkpoint last advanced on, or nil if it
-      # never advanced. Skips the synthetic `REFUSED` trigger, which has no event to redeliver.
-      #
-      # Uses `send(:saga_correlation)` on purpose: the private method is the real correlation
-      # logic, and reimplementing it here would only approximate it.
-      def last_advancing_event(runtime, interpreter, process_manager, correlation)
-        entry = runtime.registry.saga_log.reverse_each.find do |row|
-          row[:process_manager] == process_manager.name && row[:instance] == correlation &&
-            row[:advanced] && row[:on] != Runtime::SagaInterpreter::REFUSED
-        end
-        return nil unless entry
-
-        runtime.events.reverse_each.find do |event|
-          event.name == entry[:on] && interpreter.send(:saga_correlation, process_manager, event) == correlation
-        end
-      end
-
-      # One correlation's redelivery check, split out of `check_saga_idempotency`.
-      # The `saga_log` mark/restore stays here so it sits beside the `advance` it guards.
-      def check_one_saga_redelivery(runtime, interpreter, domain_name, process_manager, anchor,
-                                    correlation, saga, redelivery)
-        # rubocop:disable-next Metrics/BlockLength
-        Dir.mktmpdir("hecks-self-consistency-saga") do |tmp|
-          writer = guarded_heki(aggregate: anchor, root: tmp, settings: { domain: domain_name })
-          writer.save_saga(process_manager: process_manager.name, correlation: correlation.to_s,
-                           state: saga[:state], memory: saga[:memory], completed_compensations: [])
-
-          rehydrated = guarded_heki(aggregate: anchor, root: tmp, settings: { domain: domain_name })
-                       .each_saga.find { |_pm, corr, *| corr == correlation.to_s }
-          next unless rehydrated
-
-          _pm, _corr, state, memory, compensations = rehydrated
-          before = { state: state, memory: deep_stringify_keys(memory) }
-
-          saga_instances = runtime.registry.saga_instances[process_manager.name]
-          original       = saga_instances[correlation]
-
-          # `advance` appends to `saga_log` (shared by reference with the primary trace);
-          # the tail is sliced back off in `ensure` so the probe does not leak into it.
-          saga_log      = runtime.registry.saga_log
-          saga_log_mark = saga_log.size
-          begin
-            saga_instances[correlation] = { state: state, memory: memory, completed_compensations: compensations || [] }
-            interpreter.advance(redelivery, domain_name, only: process_manager)
-
-            after       = saga_instances[correlation]
-            after_shape = after && { state: after[:state], memory: deep_stringify_keys(after[:memory]) }
-            next if after_shape == before
-
-            { field: "saga_redelivery_idempotency", domain: domain_name, process_manager: process_manager.name,
-              correlation: correlation, on: redelivery.name, before: before, after: after_shape }
-          ensure
-            saga_log.slice!(saga_log_mark..) if saga_log.size > saga_log_mark
-
-            if original
-              saga_instances[correlation] = original
-            else
-              saga_instances.delete(correlation)
-            end
-          end
-        end
-      end
-
       # Folds `entries` into `writer`, then reads back through a fresh `Heki` instance so the
       # result comes from disk rather than the writer's cache. Calling it twice on one writer
       # replays the journal a second time.
@@ -314,26 +129,6 @@ module Hecks
           ]
         end
       end
-
-      # Recurses via `#[]` rather than `#to_h`, which would materialize nested values away.
-      # `seen` compares by identity: a live state and an event payload can share one object,
-      # while two equal but distinct value objects are still two round trips to prove.
-      def walk_value_objects(node, found, seen, aggregate)
-        case node
-        when Runtime::Value
-          return if seen[node]
-
-          seen[node] = true
-          found << [node, aggregate]
-          node.value_object.attributes.each do |attribute|
-            walk_value_objects(node[attribute.name], found, seen, aggregate)
-          end
-        when Hash
-          node.each_value { |value| walk_value_objects(value, found, seen, aggregate) }
-        when Array
-          node.each { |value| walk_value_objects(value, found, seen, aggregate) }
-        end
-      end
     end
   end
 end