ruby_reactor 0.8.4 → 0.8.6

data/lib/ruby_reactor/executor/step_executor.rb

@@ -80,12 +80,18 @@ module RubyReactor
         # it, not this one. (`async_reactor` still resolves here: its resolved
         # values are the child's INPUTS, needed at dispatch.)
         deferred_body = step_config.async_dispatch == :step || handoff_at?(step_config, :before)
-        resolved_arguments = deferred_body ? {} : resolve_arguments(step_config)
+        resolved_arguments, resolution_error = resolve_before_start(step_config, deferred_body)
 
         @middlewares.on(:start_step, step_config.name, resolved_arguments, @context)
         completed = false
         begin
-          result = if step_config.interrupt?
+          # A step whose arguments could not be resolved fails like any step
+          # (`:failed_step`, attribution) but never started: the result
+          # handler undoes the completed steps and does not compensate it.
+          result = if resolution_error
+                     @result_handler.handle_step_result(step_config,
+                                                        pre_body_failure(step_config, resolution_error), {})
+                   elsif step_config.interrupt?
                      handle_interrupt_step(step_config)
                    elsif step_config.async_dispatch == :step
                      dispatch_async_step(step_config)
@@ -113,6 +119,7 @@ module RubyReactor
           unless completed
             event = e.is_a?(Error::ExecutionParked) ? :snooze_step : :failed_step
             @middlewares.on(event, step_config.name, e, @context)
+            track_interrupted_construct(step_config, resolved_arguments, e)
           end
           raise
         end
@@ -120,6 +127,30 @@ module RubyReactor
 
       private
 
+      # An interruption leaves a caller-process run `aborted` for a manual
+      # undo, which replays the undo stack. A compose or map cut short already
+      # holds completed child work that only its own undo reverts, so it joins
+      # the stack. A worker run is redelivered instead, and re-runs the step.
+      def track_interrupted_construct(step_config, arguments, error)
+        return if @context.inline_async_execution || Error::Rescuable === error # rubocop:disable Style/CaseEquality
+        return if error.is_a?(Error::RollbackHandedOff) # a rollback signal, not an interruption
+        return unless step_config.undoes_partial_run?
+
+        @compensation_manager.add_to_undo_stack({ step: step_config,
+                                                  arguments: step_config.rollback_arguments(arguments),
+                                                  result: RubyReactor.Success(nil) })
+      end
+
+      # `[arguments, nil]`, or `[{}, ArgumentResolutionError]` for the caller
+      # to fail the step with once its `:start_step` has fired.
+      def resolve_before_start(step_config, deferred_body)
+        return [{}, nil] if deferred_body
+
+        [step_config.resolve_arguments(@context), nil]
+      rescue Error::ArgumentResolutionError => e
+        [{}, e]
+      end
+
       # The reactor's single hand-off point, `{ mode: :after|:before, step: }`.
       # Nil for a reactor that never declares `background`.
       def background_handoff
@@ -130,23 +161,20 @@ module RubyReactor
       end
 
       # Hand-off is keyed to REACHING the named step, not to where the
-      # declaration sits in the class body. A step whose `where`/guard says it
-      # must not run never triggers it — the hand-off only ever relocates work
-      # that is actually going to happen. Inside the worker the whole thing is
+      # declaration sits in the class body. Inside the worker the whole thing is
       # suppressed (`inline_async_execution`) so it cannot re-trigger.
       def handoff_at?(step_config, mode)
         point = background_handoff
-        return false unless point && point[:mode] == mode && point[:step] == step_config.name
-        return false if @context.inline_async_execution
-
-        step_config.should_run?(@context)
+        point && point[:mode] == mode && point[:step] == step_config.name && !@context.inline_async_execution
       end
 
-      # Post-execution trigger for `after:`. Only a plain continue-Success means
-      # the named step actually completed here — a Failure, Skipped, interrupt,
-      # queued retry or an already-async result each own the flow instead.
+      # Post-execution trigger for `after:`. Only a result the run continues
+      # from hands off: a Success, or a Skipped, which is only an
+      # instrumentation mark and never changes execution. A Halt stops the run,
+      # and a Failure, interrupt, queued retry or already-async result each own
+      # the flow instead.
       def handoff_after?(step_config, result)
-        return false unless result.is_a?(RubyReactor::Success) && !result.is_a?(RubyReactor::Skipped)
+        return false unless result.is_a?(RubyReactor::Success) && !result.is_a?(RubyReactor::Halt)
 
         handoff_at?(step_config, :after)
       end
@@ -175,7 +203,7 @@ module RubyReactor
       end
 
       def execute_step_with_retry(step_config, resolved_arguments = nil)
-        resolved_arguments ||= resolve_arguments(step_config)
+        resolved_arguments ||= step_config.resolve_arguments(@context)
         result = @retry_manager.execute_with_retry(step_config, @reactor_class) do
           safe_execute_step_sync(step_config, resolved_arguments)
         end
@@ -188,7 +216,7 @@ module RubyReactor
       end
 
       def safe_execute_step_sync(step_config, resolved_arguments = nil)
-        resolved_arguments ||= resolve_arguments(step_config)
+        resolved_arguments ||= step_config.resolve_arguments(@context)
         execute_step_sync_without_result_handling(step_config, resolved_arguments)
       rescue Error::InputValidationError => e
         # Validation failures are not retryable and must surface as a structured
@@ -216,10 +244,12 @@ module RubyReactor
       rescue Error::ExecutionParked
         @context.retry_context.decrement_attempt_for_step(step_config.name)
         raise
-      rescue StandardError => e
-        # Identify redacted inputs
-        redact_inputs = @reactor_class.inputs.select { |_, config| config[:redact] }.keys
-
+      # Arguments raised: the body never started. Not retried (the same
+      # inputs fail the same way), never compensated.
+      rescue Error::ArgumentResolutionError => e
+        pre_body_failure(step_config, e)
+      # Any other exception, standard or not, is this step's failure (008 R-16).
+      rescue Error::Rescuable => e
         RubyReactor::Failure(
           e,
           step_name: step_config.name,
@@ -230,6 +260,16 @@ module RubyReactor
         )
       end
 
+      def pre_body_failure(step_config, error)
+        RubyReactor::Failure(error, step_name: step_config.name, reactor_name: @reactor_class.name,
+                                    inputs: @context.inputs, redact_inputs: redact_inputs, step_arguments: {},
+                                    retryable: false, exception_class: error.exception_class)
+      end
+
+      def redact_inputs
+        @reactor_class.inputs.select { |_, config| config[:redact] }.keys
+      end
+
       # Contention (US3). Synchronously there is no queue to park into: the
       # step fails. In a worker the execution parks at this step — by raising
       # `Error::StepContentionPark`, which every executor on the stack lets
@@ -315,14 +355,8 @@ module RubyReactor
 
       def execute_step_sync(step_config, resolved_arguments = nil)
         @context.with_step(step_config.name) do
-          # Check conditions and guards
-          unless step_config.should_run?(@context)
-            @dependency_graph.complete_step(step_config.name)
-            return RubyReactor.Success(nil)
-          end
-
           # Resolve arguments
-          resolved_arguments ||= resolve_arguments(step_config)
+          resolved_arguments ||= step_config.resolve_arguments(@context)
 
           # Validate arguments if validator is defined
           validate_step_arguments(step_config, resolved_arguments)
@@ -338,14 +372,8 @@ module RubyReactor
       # Execute step without handling the result (used during retries)
       def execute_step_sync_without_result_handling(step_config, resolved_arguments = nil)
         @context.with_step(step_config.name) do
-          # Check conditions and guards
-          unless step_config.should_run?(@context)
-            @dependency_graph.complete_step(step_config.name)
-            return RubyReactor.Success(nil)
-          end
-
           # Resolve arguments
-          resolved_arguments ||= resolve_arguments(step_config)
+          resolved_arguments ||= step_config.resolve_arguments(@context)
 
           yield resolved_arguments if block_given?
 
@@ -435,22 +463,6 @@ module RubyReactor
         raise error
       end
 
-      def resolve_arguments(step_config)
-        resolved = {}
-
-        step_config.arguments.each do |arg_name, arg_config|
-          source = arg_config[:source]
-          transform = arg_config[:transform]
-
-          value = source.resolve(@context)
-          value = transform.call(value) if transform
-
-          resolved[arg_name] = value
-        end
-
-        resolved
-      end
-
       def run_step_implementation(step_config, arguments)
         contract = step_config.input_contract
         @context.append_execution_trace(

data/lib/ruby_reactor/executor.rb

@@ -135,6 +135,10 @@ module RubyReactor
       handle_interrupt(@result) if @result.is_a?(RubyReactor::InterruptResult)
       completed = true
       @result
+    rescue Error::RollbackHandedOff => e
+      record_rollback_handoff(e)
+      completed = true
+      @result
     rescue RubyReactor::Lock::AcquisitionError,
            RubyReactor::Semaphore::AcquisitionError,
            RubyReactor::RateLimit::ExceededError,
@@ -152,11 +156,14 @@ module RubyReactor
       park_held_primitives! if @context.inline_async_execution
       @contention_snooze = true
       raise
-    rescue StandardError => e
-      @result = @result_handler.handle_execution_error(e)
+    rescue Error::Rescuable => e
+      @result = handing_off { aborting_on_interruption { @result_handler.handle_execution_error(e) } }
       update_context_status(@result)
       completed = true
       @result
+    rescue Exception # rubocop:disable Lint/RescueException
+      mark_aborted
+      raise
     ensure
       release_locks unless @parked
       leave_ordered_lock_scope
@@ -181,6 +188,9 @@ module RubyReactor
     end
 
     def resume_execution # rubocop:disable Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+      # A composed child re-entered while its own rollback is handed off.
+      return resume_rollback if @context.rolling_back?
+
       middlewares.on(:start_reactor, reactor_class.name, context.inputs, @context)
       completed = false
 
@@ -239,6 +249,7 @@ module RubyReactor
       @context.admit!
       prepare_for_resume
       save_context
+      @past_gates = true
 
       @result = if @context.current_step
                   execute_current_step_and_continue
@@ -252,6 +263,10 @@ module RubyReactor
       handle_interrupt(@result) if @result.is_a?(RubyReactor::InterruptResult)
       completed = true
       @result
+    rescue Error::RollbackHandedOff => e
+      record_rollback_handoff(e)
+      completed = true
+      @result
     rescue RubyReactor::Lock::AcquisitionError,
            RubyReactor::Semaphore::AcquisitionError,
            RubyReactor::RateLimit::ExceededError,
@@ -269,23 +284,145 @@ module RubyReactor
       park_held_primitives!
       @contention_snooze = true
       raise e
-    rescue StandardError => e
-      handle_resume_error(e)
+    rescue Error::Rescuable => e
+      handing_off { aborting_on_interruption { handle_resume_error(e) } }
       update_context_status(@result)
       completed = true
       @result
+    rescue Exception # rubocop:disable Lint/RescueException
+      mark_aborted
+      raise
     ensure
       release_locks unless @parked
+      # Saved while the context lock is still held (009 R-13): released first,
+      # a worker resuming this run could load the pre-save blob, and this save
+      # would then overwrite its progress.
+      save_context unless skip_context_persist?
       @acquired_context_lock&.release
       @acquired_context_lock = nil
       leave_ordered_lock_scope
+
+      emit_lifecycle_completion(completed)
+    end
+
+    # Undoes every completed step (manual undo, a composed child's undo, a
+    # map element's rollback). A rollback that hands off here (009 R-04)
+    # leaves this level's rollback failures on its context, and the next
+    # `undo_all` of the same context picks them up, so none is lost though
+    # the executor is rebuilt on resume (G2).
+    def undo_all(&after_pop)
+      saved = @context.rollback && @context.rollback["failures"]
+      @compensation_manager.restore_rollback_failures(saved) if saved
+      @compensation_manager.rollback_completed_steps(&after_pop)
+      clear_saved_rollback_failures
+    rescue Error::RollbackHandedOff
+      (@context.rollback ||= {})["failures"] =
+        ContextSerializer.serialize_value(@compensation_manager.rollback_failures)
+      raise
+    end
+
+    # Finishes a rollback that handed off at a fan-out map (009 R-04), once
+    # the map's element rollbacks have all reported: the Worker of a
+    # `rolling_back` run, or a composed child re-entered by its root. Under
+    # the run's context lock, as `resume_execution`.
+    def resume_rollback
+      state = @context.rollback || {}
+      # The hand-off came out of a running step (a composed child rolling
+      # back inside `ComposeStep#run`): resume forward, and that step
+      # finishes its child's rollback.
+      if state["trigger"] == "step" || state.empty?
+        @context.rollback = nil
+        @context.status = :running
+        return resume_execution
+      end
+
+      middlewares.on(:start_reactor, reactor_class.name, context.inputs, @context)
+      completed = false
+      enter_ordered_lock_scope
+      acquire_context_lock
+      @result = finish_rollback(state)
+      @context.rollback = nil
+      update_context_status(@result)
+      completed = true
+      @result
+    rescue Error::RollbackHandedOff => e
+      record_rollback_handoff(e)
+      completed = true
+      @result
+    rescue RubyReactor::Lock::AcquisitionError => e
+      @contention_snooze = true
+      raise composed_contention_park(e) || e
+    rescue Error::Rescuable => e
+      handing_off { aborting_on_interruption { handle_resume_error(e) } }
+      update_context_status(@result)
+      completed = true
+      @result
+    rescue Exception # rubocop:disable Lint/RescueException
+      mark_aborted
+      raise
+    ensure
       save_context unless skip_context_persist?
+      @acquired_context_lock&.release
+      @acquired_context_lock = nil
+      leave_ordered_lock_scope
 
       emit_lifecycle_completion(completed)
     end
 
-    def undo_all
-      @compensation_manager.rollback_completed_steps
+    # The rollback's other half (009 R-05): marks the hand-off saved, then
+    # enqueues the owner's Worker if the map rollback already settled and this
+    # side claims the signal. Whichever of this and the last element rollback
+    # job sees both second enqueues the owner, once. Called right after the
+    # `rolling_back` save, while the context lock is still held.
+    def hand_off_rollback!(handed_off)
+      storage = RubyReactor.configuration.storage_adapter
+      map_id = handed_off.map_id
+      map_class = handed_off.reactor_class_name
+      storage.mark_map_rollback_handed_off(map_id, map_class)
+      RubyReactor.configuration.logger.info(
+        "event=ruby_reactor.rollback.handed_off context_id=#{@context.context_id.inspect} map_id=#{map_id.inspect}"
+      )
+      meta = storage.retrieve_map_rollback_metadata(map_id, map_class)
+      return unless meta && storage.count_map_rollback_outcomes(map_id, map_class) >= meta["total"].to_i
+      return unless storage.claim_map_rollback_signal(map_id, map_class)
+
+      RubyReactor.configuration.async_router.perform_async(@context.context_id,
+                                                           RubyReactor.reactor_storage_name(@reactor_class))
+    end
+
+    # True once `resume_execution` is past its reactor-level gates (context
+    # lock, lock, semaphore, period): from there on it may have run steps.
+    def past_gates?
+      @past_gates == true
+    end
+
+    # Reached only by an interruption — a signal, an exit, out of memory, an
+    # enclosing timeout (008 R-08, R-16); every other exception was rescued as
+    # `Error::Rescuable` and rolled back. Running user rollback code now is
+    # unsafe, so none runs: a run in the caller's process is recorded
+    # `aborted`, with the undo entries not yet undone kept, for a manual
+    # `Reactor#undo`; the `ensure` persists it, best effort. A worker run stays
+    # `running` and its job is redelivered.
+    def mark_aborted
+      @context.status = :aborted unless @context.inline_async_execution
+    end
+
+    # A rollback run from a `rescue Error::Rescuable` body is outside the
+    # sibling `rescue Exception`, which never sees what that body raises: an
+    # interruption there must mark the run here.
+    def aborting_on_interruption
+      yield
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      mark_aborted unless Error::Rescuable === e || e.is_a?(Error::RollbackHandedOff) # rubocop:disable Style/CaseEquality
+      raise
+    end
+
+    # A rollback run from a `rescue Error::Rescuable` body (the error's own
+    # rollback) is outside the sibling `rescue Error::RollbackHandedOff`.
+    def handing_off
+      yield
+    rescue Error::RollbackHandedOff => e
+      record_rollback_handoff(e)
     end
 
     def undo_stack
@@ -734,7 +871,8 @@ module RubyReactor
 
       case result
       when RubyReactor::DispatchResult
-        @context.status = :running
+        # A rollback hand-off returns one too, and stays `rolling_back`.
+        @context.status = :running unless @context.rolling_back?
       when RubyReactor::Halt
         @context.status = :halted
       when RubyReactor::Success
@@ -799,6 +937,82 @@ module RubyReactor
       @result
     end
 
+    # Where this level's rollback stands when it hands off (009 DM §1). A
+    # composed child keeps it on its own context, inside the root's blob, and
+    # re-raises; the top-level run saves it as `rolling_back` while it still
+    # holds the context lock (I-6), runs the handshake, and returns a
+    # `DispatchResult`, as a forward hand-off does.
+    def record_rollback_handoff(handed_off)
+      failure = handed_off.failure
+      handed_off.failure = nil # this level's Failure; the level above builds its own
+      @context.rollback = rollback_state(failure)
+      @context.status = :rolling_back
+      raise handed_off if @context.root_context
+
+      save_context
+      hand_off_rollback!(handed_off)
+      @result = RubyReactor::DispatchResult.new(job_id: "map_rollback:#{handed_off.map_id}",
+                                                intermediate_results: @context.intermediate_results,
+                                                execution_id: @context.context_id)
+    end
+
+    # `trigger`: `failure` (a step failure is rolling back), `undo` (set by
+    # `Reactor#undo`), or `step` (a running step's child handed off, and no
+    # rollback started at this level). A later hand-off of the same rollback
+    # keeps what an earlier one recorded.
+    def rollback_state(failure)
+      state = (@context.rollback || {}).dup
+      pending = @compensation_manager.pending
+      state["trigger"] ||= failure || pending ? "failure" : "step"
+      if pending
+        state["step"] = pending[:step].to_s
+        state["compensated"] = pending[:compensated]
+        state["compensation_error"] = pending[:compensation_error]
+      end
+      state["failure"] = ContextSerializer.serialize_value(failure) if failure
+      state["failures"] = ContextSerializer.serialize_value(@compensation_manager.rollback_failures)
+      state
+    end
+
+    # The rest of a handed-off rollback: the failing step's own compensate if
+    # it had not finished (a map or compose adopts its settled state), the
+    # steps still on the undo stack, then the outcome the inline rollback
+    # gives (I-7).
+    def finish_rollback(state)
+      @compensation_manager.restore_rollback_failures(state["failures"])
+      return finish_undo if state["trigger"] == "undo"
+
+      failure = ContextSerializer.deserialize_value(state["failure"])
+      step_config = state["step"] && @reactor_class.steps[state["step"].to_sym]
+      if step_config && !state["compensated"]
+        @compensation_manager.handle_step_failure(step_config, failure.error, {})
+      else
+        @compensation_manager.rollback_completed_steps
+        if state["compensation_error"]
+          raise Error::CompensationError.new(state["compensation_error"], step: step_config&.name, context: @context)
+        end
+      end
+      @context.current_step = failure.step_name&.to_sym
+      @result_handler.handed_off_failure(failure)
+    rescue Error::CompensationError => e
+      @result_handler.handle_execution_error(e)
+    end
+
+    def finish_undo
+      @compensation_manager.rollback_completed_steps
+      @context.cancelled = true
+      @context.cancellation_reason = "Undo triggered"
+      @context.status = "cancelled"
+      nil
+    end
+
+    def clear_saved_rollback_failures
+      return unless @context.rollback
+
+      @context.rollback.delete("failures")
+      @context.rollback = nil if @context.rollback.empty?
+    end
+
     def handle_interrupt(interrupt_result)
       save_context
 

data/lib/ruby_reactor/map/collector.rb

@@ -3,10 +3,14 @@
 module RubyReactor
   module Map
     class Collector
-      extend Helpers
+      # Seconds a collector waits for another collector of the same map. One
+      # that found the map unsettled releases within milliseconds, and may be
+      # the only trigger left for a failure it just deferred (R-04); a holder
+      # busy longer is the one applying the map's result.
+      COLLECT_LOCK_WAIT = 2
 
       def self.perform(arguments)
-        arguments = arguments.transform_keys(&:to_sym)
+        arguments = Helpers.normalize_arguments(arguments)
         map_id = arguments[:map_id]
 
         # Serialize concurrent collector deliveries for the SAME map (eager queue +
@@ -30,7 +34,7 @@ module RubyReactor
         lock = RubyReactor::Lock.new(
           "map_collect:#{map_id}",
           owner: SecureRandom.uuid, ttl: RubyReactor.configuration.context_lock_ttl,
-          wait: 0, auto_extend: true
+          wait: COLLECT_LOCK_WAIT, auto_extend: true
         )
         lock.acquire
         lock
@@ -42,101 +46,39 @@ module RubyReactor
         defined?(Sidekiq::Testing) && Sidekiq::Testing.respond_to?(:inline?) && Sidekiq::Testing.inline?
       end
 
+      # Once every index has a result slot (a value, `_error`, `_halt` or
+      # `_skipped`), signal the map's OWNER run — the top-level context —
+      # once, and write nothing else (009 R-03, I-1). The owner's Worker
+      # resumes, and `MapStep#run` adopts the settled outcome at any
+      # composition depth. An atomic map's failure is applied the same way
+      # only once every index has settled, so its compensate sees every
+      # element that completed, including ones still in flight when it
+      # failed. Until then the last element to settle, or the map sweeper,
+      # re-triggers this collector.
       def self.perform_collection(arguments)
         map_id = arguments[:map_id]
-        parent_context_id = arguments[:parent_context_id]
         parent_reactor_class_name = arguments[:parent_reactor_class_name]
-        step_name = arguments[:step_name]
-        strict_ordering = arguments[:strict_ordering]
-        # timeout = arguments[:timeout]
-
         storage = RubyReactor.configuration.storage_adapter
-        parent_context_data = storage.retrieve_context(parent_context_id, parent_reactor_class_name)
-        parent_context = RubyReactor::Context.deserialize_from_retry(parent_context_data)
-
-        # Idempotency: if the parent already recorded this map step's result, a
-        # prior collector already resumed it. Re-resuming would double-execute the
-        # steps after the map. Skip.
-        return if parent_context.intermediate_results.key?(step_name.to_sym)
 
-        # Check if all tasks are completed
         metadata = storage.retrieve_map_metadata(map_id, parent_reactor_class_name)
-        total_count = metadata ? metadata["count"].to_i : 0
-
-        results_count = storage.count_map_results(map_id, parent_reactor_class_name)
-
-        # Not done yet, requeue or wait?
-        # Actually Collector currently assumes we only call it when we expect completion or check progress
-        # Since map_offset tracks dispatching progress and might exceed count due to batching reservation,
-        # we must strictly check against the total count of elements.
-        # Check for fail_fast failure FIRST
-        if (failed_context_id = storage.retrieve_map_failed_context_id(map_id, parent_reactor_class_name))
-          handle_failure(failed_context_id, metadata, storage, parent_context, step_name)
-          return
-        end
-
-        return if results_count < total_count
-
-        # Retrieve results lazily
-        results = RubyReactor::Map::ResultEnumerator.new(
-          map_id,
-          parent_reactor_class_name,
-          strict_ordering: strict_ordering
-        )
-
-        # Apply collect block (or default collection)
-        step_config = parent_context.reactor_class.steps[step_name.to_sym]
-
-        begin
-          final_result = apply_collect_block(results, step_config)
-
-          if final_result.failure?
-            # Optionally log failure internally or just rely on context status update
-          end
-        rescue StandardError => e
-          final_result = RubyReactor::Failure(e)
-        end
-
-        # Resume parent execution
-        resume_parent_execution(parent_context, step_name, final_result, storage)
-      rescue StandardError => e
-        RubyReactor.configuration.logger.error("Map collector crashed: #{e.message}")
-        RubyReactor.configuration.logger.error(e.backtrace.join("\n")) if e.backtrace
-        raise e
-      end
+        return unless metadata
+        # Judged against the element count, not map_offset (which batching
+        # reservation can push past it).
+        return if storage.count_map_results(map_id, parent_reactor_class_name) < metadata["count"].to_i
+        return unless storage.claim_map_owner_signal(map_id, parent_reactor_class_name)
 
-      def self.apply_collect_block(results, step_config)
-        collect_block = step_config.arguments[:collect_block][:source].value if step_config.arguments[:collect_block]
-        # TODO: Check allow_partial_failure option
-
-        if collect_block
-          begin
-            # Pass Enumerator to collect block
-            collected = collect_block.call(results)
-            RubyReactor::Success(collected)
-          rescue StandardError => e
-            RubyReactor.configuration.logger.error("Map collect block raised: #{e.message}")
-            RubyReactor.configuration.logger.error(e.backtrace.join("\n")) if e.backtrace
-            RubyReactor::Failure(e)
-          end
-        else
-          # Default behavior: Return Success(Enumerator).
-          # Logic for checking failures is deferred to the consumer of the enumerator.
-          RubyReactor::Success(results)
-        end
+        signal_owner(metadata, arguments)
       end
 
-      def self.handle_failure(failed_context_id, metadata, storage, parent_context, step_name)
-        # Resolve the class of the mapped reactor to retrieve its context
-        reactor_class = resolve_reactor_class(metadata["reactor_class_info"])
-        failed_context_data = storage.retrieve_context(failed_context_id, reactor_class.name)
-
-        return unless failed_context_data
-
-        failed_context = RubyReactor::Context.deserialize_from_retry(failed_context_data)
-        reason = failed_context.failure_reason
-        result = reason.is_a?(RubyReactor::Failure) ? reason : RubyReactor::Failure(reason)
-        resume_parent_execution(parent_context, step_name, result, storage)
+      # Metadata written before the upgrade names no owner (S-6): the parent is
+      # the owner of a root-level map.
+      def self.signal_owner(metadata, arguments)
+        owner_id = metadata["owner_context_id"] || metadata["parent_context_id"] || arguments[:parent_context_id]
+        owner_class = metadata["owner_reactor_class_name"] || metadata["parent_reactor_class_name"]
+        RubyReactor.configuration.logger.info(
+          "event=ruby_reactor.map.settled map_id=#{arguments[:map_id].inspect} owner=#{owner_id.inspect}"
+        )
+        RubyReactor.configuration.async_router.perform_async(owner_id, owner_class)
       end
     end
   end