ruby_reactor 0.8.3 → 0.8.5

data/lib/ruby_reactor/executor/result_handler.rb

@@ -62,12 +62,20 @@ module RubyReactor
           @compensation_manager.rollback_completed_steps
           build_validation_failure(error)
         when Error::Base
-          # Other errors need rollback
+          # Other errors need rollback. A `CompensationError` names the step
+          # whose compensation failed.
           @compensation_manager.rollback_completed_steps
-          RubyReactor.Failure("Execution error: #{error.message}", exception_class: error.class.name)
+          RubyReactor.Failure("Execution error: #{error.message}", exception_class: error.class.name,
+                                                                   step_name: error.step || @context.current_step,
+                                                                   reactor_name: @context.reactor_class&.name)
         else
-          # Unknown errors - don't rollback as they may not be reactor-related
-          RubyReactor.Failure("Execution failed: #{error.message}", exception_class: error.class.name)
+          # Any other StandardError after completed work (a checkpoint write,
+          # a hook) still leaves a partial saga: roll it back like any failure
+          # (Constitution II, 008 R-07) and name the step that was executing.
+          @compensation_manager.rollback_completed_steps
+          RubyReactor.Failure("Execution failed: #{error.message}", exception_class: error.class.name,
+                                                                    step_name: @context.current_step,
+                                                                    reactor_name: @context.reactor_class&.name)
         end
       end
 
@@ -108,9 +116,9 @@ module RubyReactor
         result
       end
 
-      # A step returned `RubyReactor.Skipped(...)`. The reactor continues:
-      # validate and record the value exactly like a Success, but do NOT push
-      # to the undo stack (nothing happened, so there is nothing to undo).
+      # A step returned `RubyReactor.Skipped(...)`: the run continues exactly as
+      # for a Success (value, hand-off, period mark), but the step is NOT pushed
+      # for undo — it had nothing to do, so there is nothing to revert (008 R-19).
       def handle_skipped(step_config, result, resolved_arguments)
         validate_step_output(step_config, result.value, resolved_arguments)
         @step_results[step_config.name] = result
@@ -130,11 +138,7 @@ module RubyReactor
       def handle_success(step_config, result, resolved_arguments)
         validate_step_output(step_config, result.value, resolved_arguments)
         @step_results[step_config.name] = result
-        # `async_step` / `async_reactor` dispatches are independent units of
-        # work with their own compensation flows — the parent rolling back must
-        # not "undo" a dispatch whose unit runs (and may still succeed)
-        # elsewhere. They never enter the parent's undo stack.
-        unless async_unit?(step_config)
+        if step_config.rollback_tracked?
           @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments,
                                                     result: result })
         end
@@ -142,10 +146,6 @@ module RubyReactor
         @dependency_graph.complete_step(step_config.name)
       end
 
-      def async_unit?(step_config)
-        step_config.respond_to?(:async_dispatch?) && step_config.async_dispatch?
-      end
-
       # A composed child's Failure carries the child's own rollback failures;
       # fold them in BEFORE this level rolls back, so they come first.
       def adopt_rollback_failures(result)
@@ -188,13 +188,14 @@ module RubyReactor
         raise error
       end
 
+      # Wrapped first, so a returned `Step::Inputs` is validated and stored as its Hash.
       def handle_unknown_result(step_config, result, resolved_arguments)
-        validate_step_output(step_config, result, resolved_arguments)
         success_result = RubyReactor.Success(result)
+        validate_step_output(step_config, success_result.value, resolved_arguments)
         @step_results[step_config.name] = success_result
         @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments,
                                                   result: success_result })
-        @context.set_result(step_config.name, result)
+        @context.set_result(step_config.name, success_result.value)
         @dependency_graph.complete_step(step_config.name)
       end
 
@@ -253,6 +254,8 @@ module RubyReactor
       def resolve_exception_class(original_error, error)
         # A step's own contention is reported by its cause (Lock::AcquisitionError, ...).
         original_error = original_error.original if original_error.is_a?(StepCoordination::Contended)
+        # Argument failures report their cause's class (008 R-06).
+        return original_error.exception_class if original_error.is_a?(Error::ArgumentResolutionError)
         return original_error.class.name if original_error
 
         error.respond_to?(:exception_class) ? error.exception_class : nil

data/lib/ruby_reactor/executor/retry_manager.rb

@@ -24,19 +24,18 @@ module RubyReactor
                                                                          step_config.retry_config[:max_attempts])
       end
 
-      def calculate_backoff_delay(step_config, _error, reactor_class)
+      def calculate_backoff_delay(step_config)
         attempt_number = @context.retry_context.attempts_for_step(step_config.name)
-        backoff_strategy = step_config.retry_config[:backoff] || reactor_class.retry_defaults[:backoff]
-        base_delay = step_config.retry_config[:base_delay] || reactor_class.retry_defaults[:base_delay]
+        retry_config = step_config.retry_config
 
-        delay = RetryContext.calculate_backoff_delay(attempt_number, backoff_strategy, base_delay)
+        delay = RetryContext.calculate_backoff_delay(attempt_number, retry_config[:backoff], retry_config[:base_delay])
         @context.retry_context.next_retry_at = Time.now + delay
         delay
       end
 
-      def requeue_job_for_step_retry(step_config, error, reactor_class)
+      def requeue_job_for_step_retry(step_config)
         @context.current_step = step_config.name
-        delay = calculate_backoff_delay(step_config, error, reactor_class)
+        delay = calculate_backoff_delay(step_config)
 
         requeue_job(step_config, delay)
       end
@@ -147,14 +146,14 @@ module RubyReactor
 
         # Always try async retry if configured
         if is_async
-          handle_async_retry(step_config, reactor_class, result)
+          handle_async_retry(step_config)
         else
-          handle_sync_retry(step_config, reactor_class, result)
+          handle_sync_retry(step_config)
         end
       end
 
-      def handle_async_retry(step_config, reactor_class, result)
-        requeue_result = requeue_job_for_step_retry(step_config, result.error, reactor_class)
+      def handle_async_retry(step_config)
+        requeue_result = requeue_job_for_step_retry(step_config)
 
         # If it returned an DispatchResult, we are truly async.
         # Otherwise, it ran inline and we should return the result of that execution.
@@ -169,8 +168,8 @@ module RubyReactor
         end
       end
 
-      def handle_sync_retry(step_config, reactor_class, result)
-        delay = calculate_backoff_delay(step_config, result.error, reactor_class)
+      def handle_sync_retry(step_config)
+        delay = calculate_backoff_delay(step_config)
         sleep(delay)
         nil # continue loop
       end

data/lib/ruby_reactor/executor/step_coordination.rb

@@ -99,7 +99,7 @@ module RubyReactor
         key
       rescue KeyError
         raise
-      rescue StandardError => e
+      rescue RubyReactor::Error::Rescuable => e
         raise KeyError.new(
           "#{step_name}: coordination key proc raised #{e.class}: #{e.message}",
           step: step_name, original_error: e
@@ -188,7 +188,7 @@ module RubyReactor
       # counter and marker must survive the park.
       rescue Contended, Error::ExecutionParked
         raise
-      rescue StandardError
+      rescue Error::Rescuable
         clear_contention_state
         raise
       end
@@ -498,7 +498,7 @@ module RubyReactor
         rescue Error::ExecutionParked
           outcome = :parked
           raise
-        rescue StandardError
+        rescue Error::Rescuable
           outcome = :failed
           raise
         ensure
@@ -513,8 +513,8 @@ module RubyReactor
       #   step again and must keep its place: the stash survives, so the next
       #   attempt re-reads the SAME nonce. The heartbeat is stopped across the
       #   gap; `poison_pill_timeout` bounds it.
-      # - :abandoned — an exit that is not a `StandardError` (`Sidekiq::Shutdown`,
-      #   `NoMemoryError`, ...). Not advanced: `Sidekiq::Shutdown` pushes the
+      # - :abandoned — an interruption (`Sidekiq::Shutdown`, `NoMemoryError`,
+      #   ...; `Error::Rescuable`, 008 R-16). Not advanced: `Sidekiq::Shutdown` pushes the
       #   job back to run again, which must keep this place, and `failed: true`
       #   would poison successors for work that may yet complete. With the
       #   heartbeat stopped, the poison pill releases the position within
@@ -644,7 +644,7 @@ module RubyReactor
         return skipped_for_period if storage_adapter.period_seen?(key)
 
         result = yield
-        if plain_success?(result) && !chain_failed?(result)
+        if continuing_success?(result) && !chain_failed?(result)
           storage_adapter.period_mark(key, RubyReactor::Period.ttl_seconds(config[:every]))
         end
         result
@@ -654,8 +654,11 @@ module RubyReactor
         RubyReactor.Skipped(nil, reason: :period, step_name: step_name)
       end
 
-      def plain_success?(result)
-        result.is_a?(RubyReactor::Success) && !result.is_a?(RubyReactor::Halt) && !result.is_a?(RubyReactor::Skipped)
+      # A body's `Skipped` marks the bucket like a Success: it is only an
+      # instrumentation mark. The library's own skips (period, ordered lock)
+      # are returned by the gates around this one, never through it.
+      def continuing_success?(result)
+        result.is_a?(RubyReactor::Success) && !result.is_a?(RubyReactor::Halt)
       end
 
       def period_key(config)

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,28 @@ 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 unless step_config.undoes_partial_run?
+
+        @compensation_manager.add_to_undo_stack({ step: step_config, 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 +159,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 +201,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 +214,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 +242,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 +258,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 +353,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 +370,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 +461,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

@@ -152,11 +152,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 = 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
@@ -239,6 +242,7 @@ module RubyReactor
       @context.admit!
       prepare_for_resume
       save_context
+      @past_gates = true
 
       @result = if @context.current_step
                   execute_current_step_and_continue
@@ -269,11 +273,14 @@ module RubyReactor
       park_held_primitives!
       @contention_snooze = true
       raise e
-    rescue StandardError => e
-      handle_resume_error(e)
+    rescue Error::Rescuable => e
+      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
       @acquired_context_lock&.release
@@ -288,6 +295,33 @@ module RubyReactor
       @compensation_manager.rollback_completed_steps
     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 # rubocop:disable Style/CaseEquality
+      raise
+    end
+
     def undo_stack
       @compensation_manager.undo_stack
     end

data/lib/ruby_reactor/map/collector.rb

@@ -5,6 +5,12 @@ module RubyReactor
     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)
         map_id = arguments[:map_id]
@@ -30,7 +36,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
@@ -56,8 +62,9 @@ module RubyReactor
 
         # 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)
+        # steps after the map. Skip. A parent already finished (a prior
+        # collector applied this map's failure) must not be rolled back twice.
+        return if parent_context.intermediate_results.key?(step_name.to_sym) || parent_context.finished?
 
         # Check if all tasks are completed
         metadata = storage.retrieve_map_metadata(map_id, parent_reactor_class_name)
@@ -65,18 +72,21 @@ module RubyReactor
 
         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
+        # Completion is judged against the total count of elements, not
+        # map_offset (which batching reservation can push past it).
+        #
+        # A fail-fast failure is applied only once every index has settled
+        # (a result, `_error`, `_halt` or `_skipped` slot), so the map's
+        # compensate sees every element that completed — including ones still
+        # in flight when the failure happened (R-04). Until then the last
+        # element to settle, or the map sweeper, re-triggers this collector.
+        return if results_count < total_count
+
         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,
@@ -114,7 +124,7 @@ module RubyReactor
             # Pass Enumerator to collect block
             collected = collect_block.call(results)
             RubyReactor::Success(collected)
-          rescue StandardError => e
+          rescue RubyReactor::Error::Rescuable => 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)

data/lib/ruby_reactor/map/dispatcher.rb

@@ -65,9 +65,8 @@ module RubyReactor
         reactor_class_name = arguments[:parent_reactor_class_name]
 
         # Fail Fast Check
-        if arguments[:fail_fast]
-          failed_context_id = storage.retrieve_map_failed_context_id(map_id, reactor_class_name)
-          return if failed_context_id
+        if arguments[:fail_fast] && storage.retrieve_map_failed_context_id(map_id, reactor_class_name)
+          return settle_undispatched(arguments, storage)
         end
 
         batch_size = arguments[:batch_size] || source.size # Default to all if no batch_size (async=true only)
@@ -104,6 +103,33 @@ module RubyReactor
         end
       end
 
+      # A fail-fast map stopped dispatching: claim every index not dispatched
+      # yet (one offset bump, so a later dispatcher claims none), settle each
+      # with a `_skipped` slot, count them down, and trigger the collector if
+      # that settled the map. Without this those indices never settle, so the
+      # failure would never be applied (R-04) and the map sweeper would keep
+      # re-dispatching them.
+      def self.settle_undispatched(arguments, storage)
+        map_id = arguments[:map_id]
+        reactor_class_name = arguments[:parent_reactor_class_name]
+        total = storage.retrieve_map_metadata(map_id, reactor_class_name)&.fetch("count", 0).to_i
+        new_offset = storage.increment_map_offset(map_id, total, reactor_class_name)
+        claimed = (new_offset - total)...[new_offset, total].min
+        return if claimed.none?
+
+        claimed.each do |index|
+          storage.store_map_result(map_id, index, { "_skipped" => true }, reactor_class_name,
+                                   strict_ordering: arguments[:strict_ordering])
+        end
+        return unless storage.decrement_map_counter_by(map_id, claimed.size, reactor_class_name) <= 0
+
+        RubyReactor.configuration.async_router.perform_map_collection_async(
+          parent_context_id: arguments[:parent_context_id], map_id: map_id,
+          parent_reactor_class_name: reactor_class_name, step_name: arguments[:step_name].to_s,
+          strict_ordering: arguments[:strict_ordering], timeout: 3600
+        )
+      end
+
       # Re-dispatch a SPECIFIC index whose result slot is missing (Phase 5c, used
       # by the map sweeper). Index-driven rather than offset-driven: resolve the
       # source from the stored parent context and pick source[index]. Idempotent

data/lib/ruby_reactor/map/element_executor.rb

@@ -55,11 +55,13 @@ module RubyReactor
         context.inline_async_execution = true
 
         storage = RubyReactor.configuration.storage_adapter
+        return if check_fail_fast?(arguments, storage)
+
+        # Indexed only once it runs: a skipped element saves no context, and
+        # the map's rollback reports an indexed element without one as expired.
         storage.store_map_element_context_id(arguments[:map_id], context.context_id,
                                              arguments[:parent_reactor_class_name])
 
-        return if check_fail_fast?(arguments, storage)
-
         executor = Executor.new(context.reactor_class, {}, context)
         begin
           arguments[:serialized_context] ? executor.resume_execution : executor.execute
@@ -151,7 +153,11 @@ module RubyReactor
         failed_context_id = storage.retrieve_map_failed_context_id(map_id, parent_reactor_class_name)
         return false unless failed_context_id
 
-        # Skip execution
+        # Skip execution, but settle the index: the collector applies a
+        # fail-fast failure only once every index has a result slot (R-04), and
+        # the map sweeper would otherwise keep re-dispatching this one.
+        storage.store_map_result(map_id, arguments[:index], { "_skipped" => true }, parent_reactor_class_name,
+                                 strict_ordering: arguments[:strict_ordering])
         finalize_execution(arguments, storage)
         true
       end