ruby_reactor 0.8.4 → 0.8.5

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

data/lib/ruby_reactor/map/helpers.rb

@@ -41,7 +41,7 @@ module RubyReactor
           begin
             collected = collect_block.call(results)
             RubyReactor::Success(collected)
-          rescue StandardError => e
+          rescue RubyReactor::Error::Rescuable => e
             RubyReactor::Failure(e)
           end
         else
@@ -83,7 +83,20 @@ module RubyReactor
                                   parent_context)
           failure_response = nil
           begin
-            failure_response = executor.result_handler.handle_execution_error(error)
+            # The map failed in its element jobs, so no executor compensated it.
+            # Fail it exactly as the inline path does: adopt the failing
+            # element's rollback failures, compensate the map (its completed
+            # elements; every index has settled, R-04), undo the completed
+            # steps, and fail with `CompensationError` if the map's rollback
+            # was incomplete.
+            manager = executor.compensation_manager
+            manager.rollback_failures.concat(final_result.rollback_failures)
+            failure_response = begin
+              manager.handle_step_failure(parent_context.reactor_class.steps[step_name_sym], final_result.error, {})
+              executor.result_handler.handle_execution_error(error)
+            rescue RubyReactor::Error::CompensationError => e
+              executor.result_handler.handle_execution_error(e)
+            end
             # Manually update context status since we're not running executor loop
             executor.send(:update_context_status, failure_response)
           ensure
@@ -95,6 +108,12 @@ module RubyReactor
           store_parent(parent_context, storage)
         else
           parent_context.set_result(step_name_sym, final_result.value)
+          # A completed fan-out map is tracked for undo like any step (R-03).
+          # The record stays empty: `MapStep#undo` finds its elements through
+          # the map's element index, so the parent does not grow per element.
+          parent_context.undo_stack << { step: parent_context.reactor_class.steps[step_name_sym], arguments: {},
+                                         result: RubyReactor.Success(nil) }
+          record_elements_started(parent_context, step_name, storage)
 
           # Manually update execution trace to reflect completion
           # This is necessary because resume_execution continues from the NEXT step
@@ -149,6 +168,17 @@ module RubyReactor
         )
       end
 
+      # Every index of a completed map ran: record the count on the map's
+      # reference in the parent, which outlives the element index, so a late
+      # rollback names each element whose context expired.
+      def record_elements_started(parent_context, step_name, storage)
+        ref = Utils::FetchIndifferent.call(parent_context.composed_contexts, step_name)
+        return unless ref
+
+        map_id = Utils::FetchIndifferent.call(ref, :map_id)
+        ref[:started] = storage.retrieve_map_metadata(map_id, parent_context.reactor_class.name)&.fetch("count", 0).to_i
+      end
+
       def store_parent(parent_context, storage)
         storage.store_context(
           parent_context.context_id,

data/lib/ruby_reactor/map/result_enumerator.rb

@@ -22,7 +22,8 @@ module RubyReactor
 
         if @strict_ordering
           count.times do |i|
-            yield self[i]
+            raw = raw_at(i)
+            yield raw && wrap_result(raw) unless skipped?(raw)
           end
         else
           offset = 0
@@ -37,7 +38,7 @@ module RubyReactor
 
             break if results.empty?
 
-            results.each { |result| yield wrap_result(result) }
+            results.each { |result| yield wrap_result(result) unless skipped?(result) }
 
             offset += results.size
             break if results.size < @batch_size
@@ -59,21 +60,15 @@ module RubyReactor
         !empty?
       end
 
+      # nil for an index a fail-fast map skipped (never started).
       def [](index)
         index += count if index.negative?
         return nil if index.negative? || index >= count
 
-        results = @storage.retrieve_map_results_batch(
-          @map_id,
-          @reactor_class_name,
-          offset: index,
-          limit: 1,
-          strict_ordering: @strict_ordering
-        )
+        raw = raw_at(index)
+        return nil if raw.nil? || skipped?(raw)
 
-        return nil if results.empty?
-
-        wrap_result(results.first)
+        wrap_result(raw)
       end
 
       def first
@@ -94,6 +89,17 @@ module RubyReactor
 
       private
 
+      def raw_at(index)
+        @storage.retrieve_map_results_batch(@map_id, @reactor_class_name, offset: index, limit: 1,
+                                                                          strict_ordering: @strict_ordering).first
+      end
+
+      # A `_skipped` slot settles an index a fail-fast map never ran (R-04).
+      # Such a map is never collected as a success, so no consumer sees one.
+      def skipped?(result)
+        result.is_a?(Hash) && result.key?("_skipped")
+      end
+
       def wrap_result(result)
         if result.is_a?(Hash) && result.key?("_error")
           # `backtrace: []` is load-bearing: without it Failure falls back to

data/lib/ruby_reactor/reactor.rb

@@ -153,6 +153,14 @@ module RubyReactor
               "Cannot resume: reactor has been cancelled (Reason: #{@context.cancellation_reason})"
       end
 
+      # Only a reactor paused at an interrupt takes a resume (008 FR-032): one
+      # that is executing or rolling back (`running`), finished, or `aborted`
+      # must not be run forward from its stored state.
+      unless @context.status.to_s == "paused"
+        raise Error::ValidationError,
+              "Cannot resume: the reactor is #{@context.status}, not paused at an interrupt"
+      end
+
       validate_continue_step!(step_name)
 
       if (failure = validate_continue_payload(payload, step_name))
@@ -170,6 +178,11 @@ module RubyReactor
         return @result = enqueue_background_resume
       end
 
+      # Claim the resume before running it, so a `continue` that arrives while
+      # this one executes or rolls back reads `running` and fails (FR-032).
+      @context.status = :running
+      save_context
+
       # Resume execution
       executor = Executor.new(self.class, {}, @context)
       @result = executor.resume_execution
@@ -179,6 +192,12 @@ module RubyReactor
       @execution_trace = executor.execution_trace
 
       @result
+    rescue Lock::AcquisitionError, Semaphore::AcquisitionError => e
+      # Contended at the resume's own gates: nothing ran, so the run is still
+      # paused and the caller may retry, as with `Reactor.run`. A context-lock
+      # contention means a live resume holds the run: leave it alone.
+      reopen_paused unless executor&.past_gates? || e.is_a?(Lock::ContextLockContention)
+      raise
     rescue Error::InputValidationError => e
       # This might catch other validations, but here we specifically want payload validation.
       # The block above handles payload validation explicitly.
@@ -211,6 +230,11 @@ module RubyReactor
       RubyReactor::Configuration.instance
     end
 
+    def reopen_paused
+      @context.status = :paused
+      save_context
+    end
+
     def validate_steps!
       return unless self.class.steps.empty?
 

data/lib/ruby_reactor/rspec/matchers.rb

@@ -261,6 +261,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.
       #
@@ -419,22 +428,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)
+      #   expect("stripe:42").to have_rate_limit_count(1).for(:minute).since(started_at)
       ::RSpec::Matchers.define :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

data/lib/ruby_reactor/step/compose_step.rb

@@ -34,7 +34,10 @@ 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)
+        # 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 +49,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)