ruby_reactor 0.8.4 → 0.8.6

data/lib/ruby_reactor/rspec/matchers.rb

@@ -4,8 +4,10 @@ module RubyReactor
   module RSpec
     # rubocop:disable Metrics/ModuleLength
     module Matchers
+      extend ::RSpec::Matchers::DSL
+
       # rubocop:disable Metrics/BlockLength
-      ::RSpec::Matchers.define :be_success do
+      matcher :be_success do
         match do |subject|
           subject.ensure_executed! if subject.respond_to?(:ensure_executed!)
           subject.success?
@@ -63,7 +65,7 @@ module RubyReactor
         end
       end
 
-      ::RSpec::Matchers.define :be_failure do
+      matcher :be_failure do
         match do |subject|
           subject.ensure_executed! if subject.respond_to?(:ensure_executed!)
           subject.failure?
@@ -74,7 +76,7 @@ module RubyReactor
         end
       end
 
-      ::RSpec::Matchers.define :have_run_step do |step_name|
+      matcher :have_run_step do |step_name|
         match do |subject|
           subject.ensure_executed!
           @trace = subject.reactor_instance.context.execution_trace
@@ -127,7 +129,7 @@ module RubyReactor
         end
       end
 
-      ::RSpec::Matchers.define :have_retried_step do |step_name|
+      matcher :have_retried_step do |step_name|
         match do |subject|
           subject.ensure_executed!
           attempts = subject.reactor_instance.context.retry_context.attempts_for_step(step_name)
@@ -151,7 +153,7 @@ module RubyReactor
         end
       end
 
-      ::RSpec::Matchers.define :have_validation_error do |field|
+      matcher :have_validation_error do |field|
         match do |subject|
           subject.ensure_executed!
           return false unless subject.failure?
@@ -173,7 +175,7 @@ module RubyReactor
       end
 
       # Matcher to check if reactor is paused at an interrupt
-      ::RSpec::Matchers.define :be_paused do
+      matcher :be_paused do
         match do |subject|
           subject.ensure_executed!
           subject.paused?
@@ -188,9 +190,26 @@ module RubyReactor
         end
       end
 
+      # A run whose rollback handed off at a fan-out map and has not finished
+      # (009): its element rollback jobs are still pending.
+      matcher :be_rolling_back do
+        match do |subject|
+          subject.ensure_executed!
+          subject.rolling_back?
+        end
+
+        failure_message do |subject|
+          "expected reactor to be rolling back, but status was #{subject.reactor_instance.context.status}"
+        end
+
+        failure_message_when_negated do |_subject|
+          "expected reactor not to be rolling back, but it is"
+        end
+      end
+
       # Matcher to check if reactor is paused at a specific interrupt step
       # Works with both single and multiple concurrent interrupts
-      ::RSpec::Matchers.define :be_paused_at do |*step_names|
+      matcher :be_paused_at do |*step_names|
         match do |subject|
           subject.ensure_executed!
           return false unless subject.paused?
@@ -221,7 +240,7 @@ module RubyReactor
       end
 
       # Matcher to check the exact set of ready interrupt steps
-      ::RSpec::Matchers.define :have_ready_interrupts do |*expected_steps|
+      matcher :have_ready_interrupts do |*expected_steps|
         match do |subject|
           subject.ensure_executed!
           return false unless subject.paused?
@@ -261,6 +280,15 @@ module RubyReactor
         RubyReactor.configuration.storage_adapter
       end
 
+      def self.rate_limit_total(key_base, period, since)
+        return coordination_adapter.rate_limit_count(key_base, period) unless since
+
+        seconds = RubyReactor::Period.period_seconds(period)
+        ((since.to_i / seconds)..(Time.now.to_i / seconds)).sum do |bucket|
+          coordination_adapter.rate_limit_count(key_base, period, now: bucket * seconds)
+        end
+      end
+
       # Distinguishes `RubyReactor::Halt` (a clean halt) from a plain
       # `Success`. Works on any object with a `halted?` predicate.
       #
@@ -268,7 +296,7 @@ module RubyReactor
       #   expect(result).to be_halted
       #   expect(result).to be_halted.because(:period)
       #   expect(result).to be_halted.at_step(:second)
-      ::RSpec::Matchers.define :be_halted do
+      matcher :be_halted do
         match do |subject|
           subject.ensure_executed! if subject.respond_to?(:ensure_executed!)
           actual = subject.respond_to?(:result) ? subject.result : subject
@@ -311,7 +339,7 @@ module RubyReactor
       # Examples:
       #   expect(result).to be_skipped
       #   expect(subject).to be_skipped.at_step(:maybe_sync)
-      ::RSpec::Matchers.define :be_skipped do
+      matcher :be_skipped do
         match do |subject|
           subject.ensure_executed! if subject.respond_to?(:ensure_executed!)
           actual = subject.respond_to?(:result) ? subject.result : subject
@@ -358,7 +386,7 @@ module RubyReactor
       #
       #   expect("order:42").to be_locked
       #   expect("order:42").to be_locked.by("ctx-abc")
-      ::RSpec::Matchers.define :be_locked do
+      matcher :be_locked do
         match do |key|
           info = Matchers.coordination_adapter.lock_info("lock:#{key}")
           next false unless info
@@ -391,7 +419,7 @@ module RubyReactor
       # user-provided semaphore name (without the "semaphore:" prefix).
       #
       #   expect("api_limit").to have_available_tokens(3)
-      ::RSpec::Matchers.define :have_available_tokens do |expected|
+      matcher :have_available_tokens do |expected|
         match do |name|
           Matchers.coordination_adapter.semaphore_state(name)[:available] == expected
         end
@@ -406,7 +434,7 @@ module RubyReactor
       # Asserts the number of currently-checked-out semaphore tokens.
       #
       #   expect("api_limit").to have_held_tokens(2)
-      ::RSpec::Matchers.define :have_held_tokens do |expected|
+      matcher :have_held_tokens do |expected|
         match do |name|
           Matchers.coordination_adapter.semaphore_state(name)[:held] == expected
         end
@@ -419,22 +447,29 @@ module RubyReactor
       end
 
       # Asserts the current rate-limit counter for a (key_base, period) pair.
-      # Use `.for(period_unit)` to specify which window.
+      # Use `.for(period_unit)` to specify which window. Add `.since(time)` to
+      # sum every bucket from `time` to now instead — buckets are fixed
+      # windows, so a run that straddles a boundary splits its count.
       #
       #   expect("stripe:42").to have_rate_limit_count(3).for(:second)
-      ::RSpec::Matchers.define :have_rate_limit_count do |expected|
+      #   expect("stripe:42").to have_rate_limit_count(1).for(:minute).since(started_at)
+      matcher :have_rate_limit_count do |expected|
         match do |key_base|
           raise ArgumentError, "have_rate_limit_count requires .for(period)" unless @period
 
-          Matchers.coordination_adapter.rate_limit_count(key_base, @period) == expected
+          Matchers.rate_limit_total(key_base, @period, @since) == expected
         end
 
         chain :for do |period|
           @period = period
         end
 
+        chain :since do |time|
+          @since = time
+        end
+
         failure_message do |key_base|
-          actual = Matchers.coordination_adapter.rate_limit_count(key_base, @period)
+          actual = Matchers.rate_limit_total(key_base, @period, @since)
           "expected rate-limit '#{key_base}' (#{@period}) count to be #{expected}, got #{actual}"
         end
       end
@@ -442,7 +477,7 @@ module RubyReactor
       # Asserts that a `with_period` bucket has been marked. Use `.for(period)`.
       #
       #   expect("daily_report:7").to be_period_marked.for(:day)
-      ::RSpec::Matchers.define :be_period_marked do
+      matcher :be_period_marked do
         match do |key_base|
           raise ArgumentError, "be_period_marked requires .for(period)" unless @period
 
@@ -466,7 +501,7 @@ module RubyReactor
       # the user-provided ordered_lock key (without the `ordered_lock:` prefix).
       #
       #   expect("orders:42").to have_ordered_lock_next(3)
-      ::RSpec::Matchers.define :have_ordered_lock_next do |expected|
+      matcher :have_ordered_lock_next do |expected|
         match { |key| Matchers.coordination_adapter.ordered_lock_peek(key)[:next] == expected }
 
         failure_message do |key|
@@ -479,7 +514,7 @@ module RubyReactor
       # Asserts the last-advanced cursor for an ordered_lock key.
       #
       #   expect("orders:42").to have_ordered_lock_last_completed(2)
-      ::RSpec::Matchers.define :have_ordered_lock_last_completed do |expected|
+      matcher :have_ordered_lock_last_completed do |expected|
         match do |key|
           Matchers.coordination_adapter.ordered_lock_peek(key)[:last_completed] == expected
         end
@@ -495,7 +530,7 @@ module RubyReactor
       # Order-insensitive — the matcher sorts both sides.
       #
       #   expect("orders:42").to have_ordered_lock_in_flight(2, 3)
-      ::RSpec::Matchers.define :have_ordered_lock_in_flight do |*expected|
+      matcher :have_ordered_lock_in_flight do |*expected|
         match do |key|
           actual = Matchers.coordination_adapter.ordered_lock_peek(key)[:in_flight].sort
           actual == expected.flatten.map(&:to_i).sort
@@ -512,7 +547,7 @@ module RubyReactor
       # in-flight nonces. After a clean drain `peek` returns all zeros.
       #
       #   expect("orders:42").to be_ordered_lock_drained
-      ::RSpec::Matchers.define :be_ordered_lock_drained do
+      matcher :be_ordered_lock_drained do
         match do |key|
           state = Matchers.coordination_adapter.ordered_lock_peek(key)
           state[:next].zero? && state[:last_completed].zero? && state[:in_flight].empty?
@@ -535,7 +570,7 @@ module RubyReactor
       #
       #   expect(result).to have_contended_at(:charge)
       #   expect(result).to have_contended_at(:charge).on("acct:1")
-      ::RSpec::Matchers.define :have_contended_at do |step_name|
+      matcher :have_contended_at do |step_name|
         match do |subject|
           trace = execution_trace_for(subject)
           @entry = trace.find do |t|
@@ -580,7 +615,7 @@ module RubyReactor
       #   expect(result).to have_rollback_failure(:charge)
       #   expect(subject).to have_rollback_failure(:charge).for_key("acct:1").because(:coordination_unavailable)
       #   expect(subject).not_to have_rollback_failure(:charge)
-      ::RSpec::Matchers.define :have_rollback_failure do |step_name|
+      matcher :have_rollback_failure do |step_name|
         match do |subject|
           @entries = rollback_failures_for(subject)
           @entries.any? do |e|

data/lib/ruby_reactor/rspec/sidekiq_helpers.rb

@@ -12,15 +12,18 @@ module RubyReactor
       # until the queues are empty. Recursive — handles jobs that re-enqueue
       # themselves (e.g. ordered_lock snoozes) and worker chains that queue
       # additional jobs.
+      # Whichever test backend is active (Sidekiq fake mode or the ActiveJob
+      # `:test` adapter), via `AsyncTestHelpers`.
       def drain_async_jobs(max_iterations: 100)
-        SidekiqHelpers.drain_async_jobs(max_iterations: max_iterations)
+        AsyncTestHelpers.drain_async_jobs(max_iterations: max_iterations)
       end
 
       # All currently-pending async jobs, wrapped in `PendingJob` so callers
       # can perform individual jobs out-of-order (e.g. to assert
-      # ordered_lock's snooze behavior) without touching Sidekiq internals.
+      # ordered_lock's snooze behavior) without touching backend internals.
+      # `worker_class` names the job's class on either backend.
       def pending_async_jobs
-        SidekiqHelpers.pending_async_jobs
+        AsyncTestHelpers.pending_async_jobs
       end
 
       PendingJob = Struct.new(:worker_class, :raw) do
@@ -39,6 +42,7 @@ module RubyReactor
           RubyReactor::Adapters::Sidekiq::Worker,
           RubyReactor::Adapters::Sidekiq::MapElementWorker,
           RubyReactor::Adapters::Sidekiq::MapCollectorWorker,
+          RubyReactor::Adapters::Sidekiq::MapElementRollbackWorker,
           RubyReactor::Adapters::Sidekiq::StepWorker
         ]
       end

data/lib/ruby_reactor/rspec/test_subject.rb

@@ -351,14 +351,14 @@ module RubyReactor
           RubyReactor::Success.new(val)
         when "halted", "skipped" # "skipped" is the legacy name for a halt
           halted_result(ctx)
-        when "running"
+        when "running", "rolling_back"
           # Try to determine if it is truly running or if we just missed the completion
           if @process_jobs && AsyncTestHelpers.active?
             # Force one more check
             process_pending_jobs
             # Reload status
             @reactor_instance = @reactor_class.find(@reactor_instance.context.context_id)
-            return result unless @reactor_instance.context.status.to_s == "running"
+            return result unless %w[running rolling_back].include?(@reactor_instance.context.status.to_s)
           end
 
           # If still running, return a Pending/Running result instead of nil
@@ -405,6 +405,13 @@ module RubyReactor
         @reactor_instance.context.status.to_s == "paused"
       end
 
+      # Whether the run's rollback handed off at a fan-out map and has not
+      # finished (009). Reloads, so it reflects jobs performed since.
+      def rolling_back?
+        ensure_executed!
+        @reactor_instance.context.status.to_s == "rolling_back"
+      end
+
       # Get the current step where the reactor is paused (interrupt step)
       # Note: When multiple interrupts are ready, this returns just one of them.
       # Use `ready_interrupt_steps` to get all ready interrupt steps.
@@ -523,9 +530,12 @@ module RubyReactor
 
       def ensure_executed!
         run unless @executed
+        return unless %w[running rolling_back].include?(@reactor_instance.context.status.to_s)
 
+        # Not finished: jobs the spec performed itself may have moved it on.
+        @reactor_instance = @reactor_class.find(@reactor_instance.context.context_id)
         # Process jobs if status is running and processing is enabled
-        return unless @process_jobs && @reactor_instance.context.status.to_s == "running"
+        return unless @process_jobs && %w[running rolling_back].include?(@reactor_instance.context.status.to_s)
 
         process_pending_jobs
       end

data/lib/ruby_reactor/rspec.rb

@@ -21,15 +21,12 @@ module RubyReactor
     def self.configure(config)
       require_relative "rspec/step_executor_patch"
 
-      # `test_reactor` and the async-job helpers are only auto-included into
+      # Helpers, matchers and async-job helpers are only auto-included into
       # examples tagged `type: :reactor`, so a host app's other specs keep a
       # clean namespace. Specs that want them without the tag can
-      # `include RubyReactor::RSpec::Helpers` explicitly.
-      #
-      # Matchers stay unconditional: `::RSpec::Matchers.define` registers them
-      # globally at load time, so gating this include would not scope anything.
+      # `include RubyReactor::RSpec::Helpers` / `Matchers` explicitly.
       config.include RubyReactor::RSpec::Helpers, REACTOR_METADATA
-      config.include RubyReactor::RSpec::Matchers
+      config.include RubyReactor::RSpec::Matchers, REACTOR_METADATA
       config.include RubyReactor::RSpec::SidekiqHelpers, REACTOR_METADATA
 
       ::RubyReactor::Executor::StepExecutor.prepend(RubyReactor::RSpec::StepExecutorPatch)

data/lib/ruby_reactor/step/compose_step.rb

@@ -34,7 +34,13 @@ module RubyReactor
         return RubyReactor.Success() unless composed_data && composed_data[:context]
 
         child_context = composed_data[:context]
-        executor = RubyReactor::Executor.new(inputs.composed_reactor_class, {}, child_context)
+        # Linked like a running child, so a construct in it finds the run that
+        # owns it: a fan-out map's rollback resumes that run (009 S-3).
+        link_contexts(child_context, context)
+        # The child's own class: it survives serialization, while a Class in a
+        # stored undo record's arguments comes back as its name (a compose
+        # inside a map element is rolled back from its stored row).
+        executor = RubyReactor::Executor.new(child_context.reactor_class, {}, child_context)
         executor.undo_all
         executor.save_context
 
@@ -46,6 +52,9 @@ module RubyReactor
 
       alias undo compensate
 
+      # An interrupted run is undone too: undo replays only the child's completed steps.
+      def self.undoes_partial_run? = true
+
       private
 
       def build_composed_inputs(mappings)

data/lib/ruby_reactor/step/map_step.rb

@@ -3,6 +3,13 @@
 module RubyReactor
   class Step
     class MapStep < RubyReactor::Step
+      include RubyReactor::Map::StepRollback
+
+      # Seconds a rollback waits for an element's liveness lock. The last
+      # element to settle triggers the collector before its own job releases
+      # that lock, so a short wait covers the gap.
+      ELEMENT_LOCK_WAIT = 2
+
       # Untyped, so no validation: declared only so `inputs.x` can read them.
       input :source
       input :mapped_reactor_class
@@ -10,14 +17,16 @@ module RubyReactor
       input :strict_ordering, optional: true
       input :batch_size, optional: true
       input :collect_block, optional: true
-      input :fail_fast, optional: true
+      input :atomic, optional: true
       input :fan_out, optional: true
 
       def run
-        return RubyReactor::Failure("Map source cannot be nil") if inputs.source.nil?
-
         # Initialize map state in context if not present
         context.map_operations ||= {}
+        # Dispatched already: the owner run resumed (009 R-03) — adopt the
+        # settled outcome, never dispatch again (I-3).
+        return adopt_dispatched_map(context.current_step) if dispatched_map_id(context.current_step)
+        return RubyReactor::Failure("Map source cannot be nil") if inputs.source.nil?
 
         if fan_out?
           run_async(context.current_step)
@@ -26,11 +35,32 @@ module RubyReactor
         end
       end
 
+      # Compensating a failed map and undoing a completed one are the same work,
+      # as for compose: replay the undo stack of every element that COMPLETED
+      # (a failed element already rolled itself back; a halted or skipped one
+      # did nothing to undo), newest-started first. Elements are found through
+      # the index both modes write, so nothing per element lives in the parent
+      # (008 R-02). Runs only once every element has settled (R-04), from the
+      # execution that owns the map, so it is the elements' only writer.
+      #
+      # A map rolls back where it ran (009 R-01): a fan-out map one job per
+      # started element, `batch_size` per throw, handing the run off until
+      # they all report; an inline map in process, 100 elements per read.
       def compensate
-        # TODO: Implement compensation for map steps
-        RubyReactor.Success()
+        step_name = context.current_step
+        map_id = "#{context.context_id}:#{step_name}"
+        dispatched_map_id(step_name) ? distributed_rollback(map_id, step_name) : inline_rollback(map_id, step_name)
       end
 
+      alias undo compensate
+
+      # An interrupted run is undone too: undo replays only each element's completed steps.
+      def self.undoes_partial_run? = true
+
+      # The undo record keeps no arguments: rollback reads the map's
+      # declaration and records, never the resolved source (009 R-14).
+      def self.rollback_arguments(_resolved) = {}
+
       class << self
         def build_mapped_inputs(mappings, context, element)
           built = {}
@@ -79,6 +109,12 @@ module RubyReactor
 
       private
 
+      # Read from the map step's static declaration, not from the undo record,
+      # which a fan-out map leaves empty (R-03).
+      def element_class
+        context.reactor_class.steps[context.current_step].arguments[:mapped_reactor_class][:source].value
+      end
+
       # Fans out anywhere except inside a map element: an element's result and
       # the map's completion counter are tracked by its own ElementExecutor job,
       # so a nested hand-off there would escape that tracking. A reactor worker
@@ -90,16 +126,20 @@ module RubyReactor
         inputs.fan_out
       end
 
+      def atomic?
+        inputs.atomic.nil? || inputs.atomic
+      end
+
       def run_inline
         results = execute_inline_map
         return results if results.is_a?(RubyReactor::Failure) || results.is_a?(RubyReactor::Halt)
 
-        process_results(results, inputs.collect_block, inputs.fail_fast)
+        collect_results(results)
       end
 
       def execute_inline_map
         results = []
-        fail_fast = inputs.fail_fast.nil? || inputs.fail_fast
+        atomic = atomic?
 
         inputs.source.each_with_index do |element, index|
           result = execute_single_element(element, index)
@@ -108,12 +148,10 @@ module RubyReactor
           # rather than being collected as a (nil) value.
           return result if result.is_a?(RubyReactor::Halt)
 
-          if fail_fast && result.failure?
-            return result # Stop immediately on first failure
-          end
+          return result if atomic && result.failure? # Stop immediately on first failure
 
-          # When fail_fast is false, store Result objects; when true, store values
-          results << (fail_fast ? result.value : result)
+          # A non-atomic map collects Result objects; an atomic one, values.
+          results << (atomic ? result.value : result)
         end
 
         results
@@ -141,7 +179,8 @@ module RubyReactor
           name: context.current_step,
           type: :map_ref,
           map_id: map_id,
-          element_reactor_class: inputs.mapped_reactor_class.name
+          element_reactor_class: inputs.mapped_reactor_class.name,
+          started: index + 1
         }
 
         executor = RubyReactor::Executor.new(inputs.mapped_reactor_class, {}, child_context)
@@ -155,20 +194,6 @@ module RubyReactor
         child_context.inline_async_execution = parent_context.inline_async_execution
       end
 
-      def process_results(results, collect_block, _fail_fast = true)
-        if collect_block
-          begin
-            # Collect block receives Result objects when fail_fast is false, values when true
-            return RubyReactor::Success(collect_block.call(results))
-          rescue StandardError => e
-            return RubyReactor::Failure(e)
-          end
-        end
-
-        # Simplified: both branches returned Success(results)
-        RubyReactor::Success(results)
-      end
-
       def run_async(step_name)
         map_id = "#{context.context_id}:#{step_name}"
         context.map_operations[step_name.to_s] = map_id
@@ -188,10 +213,12 @@ module RubyReactor
           element_reactor_class: inputs.mapped_reactor_class.name
         }
 
+        # The owner's id: the run the caller holds, and the one the map's
+        # completion resumes (a composed child's own id is internal).
         RubyReactor::DispatchResult.new(
           job_id: job_id,
           intermediate_results: context.intermediate_results,
-          execution_id: context.context_id
+          execution_id: owner_context.context_id
         )
       end
 
@@ -200,10 +227,83 @@ module RubyReactor
         storage.initialize_map_operation(
           map_id, inputs.source.size, context.reactor_class.name,
           strict_ordering: inputs.strict_ordering, reactor_class_info: reactor_class_info,
+          owner_context_id: owner_context.context_id,
+          owner_reactor_class_name: RubyReactor.reactor_storage_name(owner_context.reactor_class),
+          batch_size: effective_batch_size, atomic: atomic?,
           **map_recovery_metadata(context.current_step)
         )
       end
 
+      # The top-level run: the one execution that writes the context tree, and
+      # the one the map's completion resumes (009 R-03).
+      def owner_context
+        context.root_context || context
+      end
+
+      # Declared, or `Map::DEFAULT_BATCH_SIZE`: no throw enqueues more (R-10).
+      def effective_batch_size
+        inputs.batch_size || RubyReactor::Map::DEFAULT_BATCH_SIZE
+      end
+
+      def dispatched_map_id(step_name)
+        Utils::FetchIndifferent.call(context.map_operations || {}, step_name)
+      end
+
+      # Re-entry of a dispatched map (S-1). Unsettled (an early or duplicate
+      # resume): hand off again without dispatching. Settled: the failing
+      # element's Failure for an atomic map, else the collected results. The
+      # executor records either like any step result.
+      def adopt_dispatched_map(step_name)
+        map_id = dispatched_map_id(step_name)
+        storage = RubyReactor.configuration.storage_adapter
+        metadata = storage.retrieve_map_metadata(map_id, context.reactor_class.name)
+        return RubyReactor::Failure("map :#{step_name} records expired before it settled") unless metadata
+
+        total = metadata["count"].to_i
+        if storage.count_map_results(map_id, context.reactor_class.name) < total
+          return RubyReactor::DispatchResult.new(job_id: "map:#{map_id}", execution_id: owner_context.context_id,
+                                                 intermediate_results: context.intermediate_results)
+        end
+
+        failed_id = storage.retrieve_map_failed_context_id(map_id, context.reactor_class.name)
+        return adopt_element_failure(step_name, failed_id) if failed_id
+
+        record_elements_started(step_name, total)
+        collect_results(RubyReactor::Map::ResultEnumerator.new(map_id, context.reactor_class.name,
+                                                               strict_ordering: inputs.strict_ordering))
+      end
+
+      # The element's own Failure, carrying its rollback failures: the executor
+      # compensates the map (its completed elements) and rolls the run back.
+      def adopt_element_failure(step_name, failed_id)
+        data = RubyReactor.configuration.storage_adapter.retrieve_context(
+          failed_id, RubyReactor.reactor_storage_name(element_class)
+        )
+        return RubyReactor::Failure("map :#{step_name} element failed; its context expired") unless data
+
+        reason = RubyReactor::Context.deserialize_from_retry(data).failure_reason
+        reason.is_a?(RubyReactor::Failure) ? reason : RubyReactor::Failure(reason)
+      end
+
+      # The collect block gets Result objects for a non-atomic map, values for
+      # an atomic one; a raise is the map's failure.
+      def collect_results(results)
+        return RubyReactor::Success(results) unless inputs.collect_block
+
+        RubyReactor::Success(inputs.collect_block.call(results))
+      rescue RubyReactor::Error::Rescuable => e
+        RubyReactor.configuration.logger.error("Map collect block raised: #{e.message}")
+        RubyReactor::Failure(e)
+      end
+
+      # Every index of a completed map ran: record the count on the map's
+      # reference, which outlives the element index, so a late rollback names
+      # each element whose context expired.
+      def record_elements_started(step_name, total)
+        ref = Utils::FetchIndifferent.call(context.composed_contexts, step_name)
+        ref[:started] = total if ref
+      end
+
       # Recovery metadata for the map sweeper. When this map runs inside a map
       # element (context.map_metadata present), it is a NESTED map: its parent
       # holds the element's `map_element:` lock, not an `async:` lock (N1).
@@ -219,13 +319,13 @@ module RubyReactor
       end
 
       def dispatch_async_map(map_id, _reactor_class_info, step_name)
-        # Every async map runs through the per-element Dispatcher path. When no
-        # batch_size is given we default to the full source size (one fan-out
-        # batch), so there is a single execution path: each element runs in its
-        # own worker, with the map counter/collector tracking completion. This
-        # lets elements with async steps or async retries hand off correctly
-        # instead of being forced to run synchronously in a single worker.
-        batch_size = inputs.batch_size || inputs.source.size
+        # Every async map runs through the per-element Dispatcher path: each
+        # element runs in its own worker, with the map counter/collector
+        # tracking completion. This lets elements with async steps or async
+        # retries hand off correctly instead of being forced to run
+        # synchronously in a single worker. Without a declared batch_size, at
+        # most `Map::DEFAULT_BATCH_SIZE` are enqueued per throw (009 R-10).
+        batch_size = effective_batch_size
 
         RubyReactor::Map::Dispatcher.perform(
           map_id: map_id,
@@ -237,18 +337,26 @@ module RubyReactor
           argument_mappings: inputs.argument_mappings,
           strict_ordering: inputs.strict_ordering,
           mapped_reactor_class: inputs.mapped_reactor_class,
-          fail_fast: inputs.fail_fast.nil? || inputs.fail_fast
+          atomic: atomic?
         )
         queue_collector(map_id, step_name, inputs.strict_ordering)
         "map:#{map_id}"
       end
 
+      # Stores the context the Dispatcher reads the source from, and — for a
+      # map inside a composed child — the owner's tree, which the map's
+      # completion resumes (009 R-03): a fast resume must find it consistent,
+      # as `handle_background_handoff` ensures for a `background` hand-off.
       def prepare_async_execution(map_id, count)
         storage = RubyReactor.configuration.storage_adapter
         middlewares = context.middlewares || Executor.middlewares_for(context.reactor_class)
         middlewares.on(:before_async_enqueue, context)
         serialized_context = ContextSerializer.serialize(context)
         storage.store_context(context.context_id, serialized_context, context.reactor_class.name)
+        unless owner_context.equal?(context)
+          storage.store_context(owner_context.context_id, ContextSerializer.serialize(owner_context),
+                                RubyReactor.reactor_storage_name(owner_context.reactor_class))
+        end
         storage.set_map_counter(map_id, count, context.reactor_class.name)
       end
 

data/lib/ruby_reactor/step.rb

@@ -113,6 +113,13 @@ module RubyReactor
         catch(StepSignals::TAG) { new(with_defaults(arguments), context, reason: reason).compensate }
       end
 
+      # Whether `undo` also reverts a run cut short by an interruption. A
+      # plain step's body stopped mid-way, so no: only a construct whose undo
+      # replays the child work it completed (compose, map) says yes (008 R-16).
+      def undoes_partial_run?
+        false
+      end
+
       def input(...)
         own_input_contract.input(...)
         @input_contract = nil