ruby_reactor 0.8.3 → 0.8.5

data/lib/ruby_reactor/dsl/async_reactor_builder.rb

@@ -18,15 +18,21 @@ module RubyReactor
         @child_reactor_class = child_reactor_class
         @reactor = reactor
         @argument_mappings = {}
-        @retry_config = {}
       end
 
       def argument(child_input_name, source)
         @argument_mappings[child_input_name] = source
       end
 
-      def retries(max_attempts: 3, backoff: :exponential, base_delay: 1)
-        @retry_config = { max_attempts: max_attempts, backoff: backoff, base_delay: base_delay }
+      # A parent never retries a nested reactor as a whole (008 R-14): the
+      # child owns its steps' retries. Kept as a stub to name the replacement.
+      def retries(*)
+        raise RubyReactor::Error::DeprecatedDslError.new(
+          "`retries` on an `async_reactor` has been removed: a parent never retries a nested " \
+          "reactor as a whole. Declare `retries` on :#{@name}'s child reactor's own steps " \
+          "(`retries max_attempts: 3` in the step block or the step class); the child retries them itself.",
+          step: @name
+        )
       end
 
       def build
@@ -44,12 +50,9 @@ module RubyReactor
           # that reads `result(:name)` and decides to fail.
           compensate_block: nil,
           undo_block: nil,
-          conditions: [],
-          guards: [],
           dependencies: dependencies_from_mappings,
           args_validator: nil,
-          output_validator: nil,
-          retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
+          output_validator: nil
         )
       end
 

data/lib/ruby_reactor/dsl/compose_builder.rb

@@ -20,7 +20,6 @@ module RubyReactor
         end
         @reactor = reactor
         @argument_mappings = {}
-        @retry_config = {}
       end
 
       def argument(composed_input_name, source)
@@ -44,12 +43,15 @@ module RubyReactor
         )
       end
 
-      def retries(max_attempts: 3, backoff: :exponential, base_delay: 1)
-        @retry_config = {
-          max_attempts: max_attempts,
-          backoff: backoff,
-          base_delay: base_delay
-        }
+      # A parent never retries a nested reactor as a whole (008 R-14): the
+      # child owns its steps' retries. Kept as a stub to name the replacement.
+      def retries(*)
+        raise RubyReactor::Error::DeprecatedDslError.new(
+          "`retries` on a `compose` has been removed: a parent never retries a nested " \
+          "reactor as a whole. Declare `retries` on :#{@name}'s child reactor's own steps " \
+          "(`retries max_attempts: 3` in the step block or the step class); the child retries them itself.",
+          step: @name
+        )
       end
 
       def build
@@ -66,12 +68,9 @@ module RubyReactor
           run_block: nil,
           compensate_block: nil,
           undo_block: nil,
-          conditions: [],
-          guards: [],
           dependencies: dependencies,
           args_validator: nil,
-          output_validator: nil,
-          retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
+          output_validator: nil
         }
 
         RubyReactor::Dsl::StepConfig.new(step_config)

data/lib/ruby_reactor/dsl/interrupt_builder.rb

@@ -73,9 +73,7 @@ module RubyReactor
           validation_schema: @validation_schema,
           max_attempts: @max_attempts,
           resume_mode: @resume_mode,
-          dependencies: @dependencies,
-          conditions: @conditions,
-          guards: @guards
+          dependencies: @dependencies
         }
 
         RubyReactor::Dsl::InterruptStepConfig.new(step_config)

data/lib/ruby_reactor/dsl/map_builder.rb

@@ -129,8 +129,6 @@ module RubyReactor
           run_block: nil,
           compensate_block: nil,
           undo_block: nil,
-          conditions: [],
-          guards: [],
           dependencies: dependencies.uniq,
           args_validator: nil,
           output_validator: nil

data/lib/ruby_reactor/dsl/reactor.rb

@@ -11,7 +11,6 @@ module RubyReactor
         base.instance_variable_set(:@middlewares, [])
         base.instance_variable_set(:@input_validations, {})
         base.instance_variable_set(:@background_handoff, nil)
-        base.instance_variable_set(:@retry_defaults, { max_attempts: 3, backoff: :exponential, base_delay: 1 })
       end
 
       module ClassMethods
@@ -55,16 +54,14 @@ module RubyReactor
                 "inputs inside the worker."
         end
 
-        def retry_defaults(**kwargs)
-          if kwargs.empty?
-            @retry_defaults ||= { max_attempts: 1, backoff: :exponential, base_delay: 1 }
-          else
-            @retry_defaults = {
-              max_attempts: kwargs[:max_attempts] || 1,
-              backoff: kwargs[:backoff] || :exponential,
-              base_delay: kwargs[:base_delay] || 1
-            }
-          end
+        # Reactor-wide retry defaults are gone: the builders snapshotted them at
+        # `step` time, so they silently applied only to steps declared AFTER
+        # the `retry_defaults` line. A step's retry policy now lives on the step.
+        def retry_defaults(*, **)
+          raise RubyReactor::Error::DeprecatedDslError,
+                "`retry_defaults` has been removed from #{name || "this reactor"}: reactor-wide defaults " \
+                "silently applied only to steps declared after them. Declare `retries` on each step class " \
+                "(or step block) that should retry; a step with no `retries` runs once."
         end
 
         # rubocop:disable Metrics/ParameterLists

data/lib/ruby_reactor/dsl/retryable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    # The one `retries` vocabulary. A step class EXTENDS it (class-level DSL);
+    # the step, compose and async_reactor builders INCLUDE it, so every form
+    # shares the same defaults and validation. Modeled on
+    # `Lockable::ClassMethods`: `inherited` copies the declaration down, so a
+    # subclass redeclaring leaves its parent and siblings untouched.
+    module Retryable
+      BACKOFF_STRATEGIES = %i[exponential linear fixed].freeze
+
+      # The declared policy, or nil when nothing was declared.
+      attr_reader :retry_config
+
+      def retries(max_attempts: 3, backoff: :exponential, base_delay: 1)
+        unless max_attempts.is_a?(Integer) && max_attempts >= 1
+          invalid_retries!(:max_attempts, "an Integer >= 1", max_attempts)
+        end
+        invalid_retries!(:backoff, "one of #{BACKOFF_STRATEGIES.inspect}", backoff) unless
+          BACKOFF_STRATEGIES.include?(backoff)
+        invalid_retries!(:base_delay, "a Numeric >= 0", base_delay) unless
+          base_delay.is_a?(Numeric) && base_delay >= 0
+
+        @retry_config = { max_attempts: max_attempts, backoff: backoff, base_delay: base_delay }
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@retry_config, @retry_config) if @retry_config
+      end
+
+      private
+
+      def invalid_retries!(option, expected, value)
+        raise ArgumentError, "#{retry_owner_label}: retries #{option} must be #{expected} (got #{value.inspect})"
+      end
+
+      # A step class's name, or a builder's step name.
+      def retry_owner_label
+        name&.to_s || inspect
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/step_builder.rb

@@ -6,14 +6,15 @@ module RubyReactor
       include RubyReactor::Dsl::TemplateHelpers
       include RubyReactor::Dsl::ValidationHelpers
       include RubyReactor::Dsl::Lockable::ClassMethods
+      include RubyReactor::Dsl::Retryable
 
       COORDINATION_MACROS = {
         lock_config: "with_lock", semaphore_config: "with_semaphore", rate_limit_config: "with_rate_limit",
         period_config: "with_period", ordered_lock_config: "with_ordered_lock"
       }.freeze
 
-      attr_accessor :name, :impl, :arguments, :run_block, :compensate_block, :undo_block, :conditions, :guards,
-                    :dependencies, :args_validator, :output_validator, :retry_config
+      attr_accessor :name, :impl, :arguments, :run_block, :compensate_block, :undo_block,
+                    :dependencies, :args_validator, :output_validator
 
       def initialize(name, impl = nil, reactor = nil)
         @name = name
@@ -23,14 +24,12 @@ module RubyReactor
         @run_block = nil
         @compensate_block = nil
         @undo_block = nil
-        @conditions = []
-        @guards = []
         @dependencies = []
         @arg_validations = []
         @validate_args_input = nil
         @args_validator = nil
         @output_validator = nil
-        @retry_config = {}
+        @retry_config = nil
         @inline_contract = nil
         @rule_sites = []
       end
@@ -77,12 +76,15 @@ module RubyReactor
         @undo_block = block
       end
 
-      def where(&predicate)
-        @conditions << predicate
+      # `where`/`guard` were a second, pre-body skip mechanism with failure
+      # rules of their own (008 R-15). A step decides to skip itself from its
+      # body instead, so both stay only to name the replacement.
+      def where(*)
+        raise_removed_condition!(:where)
       end
 
-      def guard(&guard_fn)
-        @guards << guard_fn
+      def guard(*)
+        raise_removed_condition!(:guard)
       end
 
       def wait_for(*step_names)
@@ -130,20 +132,13 @@ module RubyReactor
         )
       end
 
-      def retries(max_attempts: 3, backoff: :exponential, base_delay: 1)
-        @retry_config = {
-          max_attempts: max_attempts,
-          backoff: backoff,
-          base_delay: base_delay
-        }
-      end
-
       # `async_dispatch` marks a step whose work is dispatched as an independent
       # unit rather than run inline — `:step` for `async_step`, `:reactor` for
       # `async_reactor`. Nil for an ordinary step.
       def build(async_dispatch: nil)
         check_contract_conflicts!
         check_coordination_conflicts!
+        check_retry_conflict!
         warn_deprecated_rules
 
         step_config = {
@@ -154,13 +149,11 @@ module RubyReactor
           run_block: @run_block,
           compensate_block: @compensate_block,
           undo_block: @undo_block,
-          conditions: @conditions,
-          guards: @guards,
           dependencies: @dependencies,
           args_validator: @args_validator || build_args_validator(@arg_validations, @validate_args_input),
           output_validator: @output_validator,
           inline_contract: @inline_contract,
-          retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config,
+          retry_config: @retry_config,
           lock_config: @lock_config,
           semaphore_config: @semaphore_config,
           rate_limit_config: @rate_limit_config,
@@ -173,6 +166,15 @@ module RubyReactor
 
       private
 
+      def raise_removed_condition!(keyword)
+        raise RubyReactor::Error::DeprecatedDslError.new(
+          "`#{keyword}` inside a step block has been removed (`where`/`guard` are gone). To skip " \
+          ":#{@name}, return `Skipped(value)` (or call `skip!(value)`) from its `run` body; the " \
+          "reactor continues with that value, exactly as for a Success.",
+          step: @name
+        )
+      end
+
       # The same primitive declared BOTH inline and on the step class is
       # ambiguous — two keys for one slot of the fixed acquisition order, and
       # `StepConfig`'s readers would silently let the inline one win. Refuse it
@@ -190,6 +192,16 @@ module RubyReactor
         end
       end
 
+      # Same rule as the coordination macros: one retry policy per step.
+      def check_retry_conflict!
+        return unless @retry_config && @impl.respond_to?(:retry_config) && @impl.retry_config
+
+        raise Error::ValidationError,
+              "#{reactor_label} step :#{@name} declares `retries` inline, but #{@impl} declares it too. " \
+              "Keep ONE: drop the inline declaration to use #{@impl}'s, or remove it from #{@impl}. " \
+              "To vary the policy per workflow, subclass #{@impl} and declare `retries` there."
+      end
+
       # A step that owns its input contract takes wiring only from the
       # reactor: rules here would be a second, overlapping rule set.
       def check_contract_conflicts!
@@ -233,11 +245,15 @@ module RubyReactor
       end
 
       def warn_deprecation(site, message)
+        warn_definition(site, "DEPRECATION:", "#{message} Removal no earlier than the next MAJOR.")
+      end
+
+      # A definition-time warning, printed once per declaration site.
+      def warn_definition(site, prefix, message)
         location = "#{site.path}:#{site.lineno}"
         return unless StepBuilder.deprecation_sites.add?(location)
 
-        warn "[RubyReactor] DEPRECATION: #{location} #{reactor_label} #{message} " \
-             "Removal no earlier than the next MAJOR."
+        warn ["[RubyReactor]", prefix, location, reactor_label, message].compact.join(" ")
       end
 
       def owned_contract
@@ -250,8 +266,10 @@ module RubyReactor
     end
 
     class StepConfig
-      attr_reader :name, :impl, :arguments, :run_block, :compensate_block, :undo_block, :conditions, :guards,
-                  :dependencies, :args_validator, :output_validator, :retry_config, :async_dispatch,
+      NO_RETRIES = { max_attempts: 1, backoff: :exponential, base_delay: 1 }.freeze
+
+      attr_reader :name, :impl, :arguments, :run_block, :compensate_block, :undo_block,
+                  :dependencies, :args_validator, :output_validator, :async_dispatch,
                   :inline_contract
 
       def initialize(config)
@@ -262,13 +280,11 @@ module RubyReactor
         @run_block = config[:run_block]
         @compensate_block = config[:compensate_block]
         @undo_block = config[:undo_block]
-        @conditions = config[:conditions] || []
-        @guards = config[:guards] || []
         @dependencies = config[:dependencies] || []
         @args_validator = config[:args_validator]
         @output_validator = config[:output_validator]
         @inline_contract = config[:inline_contract]
-        @retry_config = { max_attempts: 1 }.merge(config[:retry_config] || {})
+        @retry_config = config[:retry_config]
         @lock_config = config[:lock_config]
         @semaphore_config = config[:semaphore_config]
         @rate_limit_config = config[:rate_limit_config]
@@ -287,6 +303,21 @@ module RubyReactor
         @lock_config || (impl.lock_config if impl.respond_to?(:lock_config))
       end
 
+      # A step's EFFECTIVE retry policy, resolved like the coordination
+      # readers: its own (step block) declaration, else the class step's,
+      # else a single attempt. Never nil. The reactor is never consulted.
+      def retry_config
+        @retry_config || (impl.retry_config if impl.respond_to?(:retry_config)) || NO_RETRIES
+      end
+
+      # Where `retry_config` came from: :step_block, :step_class or :none.
+      def retry_source
+        return :step_block if @retry_config
+        return :step_class if impl.respond_to?(:retry_config) && impl.retry_config
+
+        :none
+      end
+
       def semaphore_config
         @semaphore_config || (impl.semaphore_config if impl.respond_to?(:semaphore_config))
       end
@@ -337,13 +368,58 @@ module RubyReactor
         input_contract ? input_contract.enforce!(args) : args
       end
 
+      # The step's `argument` wiring resolved against `context`: each source,
+      # then its `transform`. The one copy every process uses (StepExecutor,
+      # StepWorker). Any raise becomes an `ArgumentResolutionError`, a
+      # never-started failure attributed to this step (008 R-06) — except a
+      # park signal (a worker waiting on an async result), which is not a failure.
+      def resolve_arguments(context)
+        arguments.to_h do |arg_name, arg_config|
+          value = arg_config[:source].resolve(context)
+          value = arg_config[:transform].call(value) if arg_config[:transform]
+          [arg_name, value]
+        end
+      rescue Error::ExecutionParked
+        raise
+      rescue Error::Rescuable => e
+        raise never_started(Error::ArgumentResolutionError, "could not resolve its arguments", e)
+      end
+
+      # Rollback dispatch, the same wherever the step rolls back
+      # (CompensationManager, StepWorker): the inline block, else the class
+      # step, else Skipped — nothing defined, rollback continues. Coordination,
+      # trace and middleware stay with the caller.
+      def call_compensate(error, arguments, context)
+        catch(StepSignals::TAG) do
+          if compensate_block
+            compensate_block.call(error, wrap_inputs(arguments), context)
+          elsif has_impl?
+            impl.compensate(error, arguments, context)
+          else
+            RubyReactor.Skipped()
+          end
+        end
+      end
+
+      def call_undo(result_value, arguments, context)
+        catch(StepSignals::TAG) do
+          if undo_block
+            undo_block.call(result_value, wrap_inputs(arguments), context)
+          elsif has_impl?
+            impl.undo(result_value, arguments, context)
+          else
+            RubyReactor.Skipped()
+          end
+        end
+      end
+
       # The step's work as a reactor runs it. Coordination is NOT taken here:
       # the caller (StepExecutor / StepWorker) takes this config's effective
       # declarations — inline and class alike — in one fixed order around it.
       def call_body(arguments, context)
         catch(StepSignals::TAG) do
           if has_run_block?
-            run_block.call(arguments, context)
+            run_block.call(wrap_inputs(arguments), context)
           elsif impl.respond_to?(:run_without_coordination)
             impl.run_without_coordination(arguments, context)
           else
@@ -360,6 +436,20 @@ module RubyReactor
         !@async_dispatch.nil?
       end
 
+      # Whether a success of this step is recorded for undo. `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 (008 R-10).
+      def rollback_tracked?
+        !async_dispatch?
+      end
+
+      # Whether a run of this step cut short by an interruption is still
+      # tracked for undo: the construct's own definition decides (008 R-16).
+      def undoes_partial_run?
+        rollback_tracked? && has_impl? && impl.respond_to?(:undoes_partial_run?) && impl.undoes_partial_run?
+      end
+
       def has_impl?
         !@impl.nil?
       end
@@ -373,18 +463,26 @@ module RubyReactor
         !@run_block.nil?
       end
 
-      def retryable?
-        (retry_config[:max_attempts] || 0) > 1
+      # What an inline `run`/`undo`/`compensate` block receives as its inputs.
+      def wrap_inputs(arguments)
+        RubyReactor::Step::Inputs.new(arguments, contract: input_contract, owner: "step :#{name}")
       end
 
-      def should_run?(context)
-        @conditions.all? { |condition| condition.call(context) } &&
-          @guards.all? { |guard| guard.call(context) }
+      def retryable?
+        (retry_config[:max_attempts] || 0) > 1
       end
 
       def interrupt?
         false
       end
+
+      private
+
+      def never_started(error_class, what, cause)
+        error = error_class.new("Step '#{name}' #{what}: #{cause.message}", step: name, original_error: cause)
+        error.set_backtrace(cause.backtrace)
+        error
+      end
     end
   end
 end

data/lib/ruby_reactor/error/argument_resolution_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    # A step's `argument` source, `transform` or result path raised. The step's
+    # body never started, so it is never compensated; completed steps are
+    # undone (008 R-06). The same inputs fail the same way, so never retried.
+    class ArgumentResolutionError < Base
+      attr_reader :exception_class
+
+      def initialize(message, step:, original_error:, context: nil)
+        super(message, step: step, context: context, original_error: original_error)
+        @exception_class = original_error.class.name
+      end
+
+      def retryable? = false
+    end
+  end
+end

data/lib/ruby_reactor/error/rescuable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    # `rescue Error::Rescuable` catches every exception reactor code can raise —
+    # standard or not (`NotImplementedError`, `SystemStackError`, a custom
+    # `Exception` subclass) — so it fails its step and rolls back (008 R-16).
+    #
+    # It lets through only interruptions: exceptions raised INTO running code
+    # from outside it. A signal (incl. `Interrupt`, `Sidekiq::Shutdown`), an
+    # exit, running out of memory, and the one an enclosing `Timeout.timeout`
+    # raises — rescuing that would stop the caller's timeout from ever firing.
+    # Running rollback code during any of them is unsafe; the executor marks
+    # the run `aborted` for a manual undo instead.
+    module Rescuable
+      INTERRUPTIONS = [SignalException, SystemExit, NoMemoryError].freeze
+
+      def self.===(exception)
+        exception.is_a?(Exception) && !interruption?(exception)
+      end
+
+      def self.interruption?(exception)
+        INTERRUPTIONS.any? { |klass| exception.is_a?(klass) } ||
+          (defined?(::Timeout::ExitException) && exception.is_a?(::Timeout::ExitException))
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/undeclared_input_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    # A step read an input it can't read (a typo, or a name it never
+    # declared). It fails the same way on every attempt, so it never retries.
+    class UndeclaredInputError < NoMethodError
+      def retryable?
+        false
+      end
+    end
+  end
+end

data/lib/ruby_reactor/executor/compensation_manager.rb

@@ -3,15 +3,17 @@
 module RubyReactor
   class Executor
     class CompensationManager
-      # Raised ONLY by the step's own coordination, before its body: a
-      # coordination error raised from inside a body (a nested direct
+      # Raised ONLY before the step's body: by its own coordination, or while
+      # resolving its arguments (008 R-06).
+      # A coordination error raised from inside a body (a nested direct
       # `Step.run`) arrives as `StepCoordination::NestedCoordinationError`, and
       # a bare `Lock::AcquisitionError` etc. may come from a nested
       # `Reactor.run` — both mean the body ran, so neither is listed here.
       NEVER_STARTED_ERROR_CLASSES = [
         RubyReactor::Executor::StepCoordination::Contended,
         RubyReactor::Executor::StepCoordination::KeyError,
-        RubyReactor::Executor::StepCoordination::DispatchRefused
+        RubyReactor::Executor::StepCoordination::DispatchRefused,
+        RubyReactor::Error::ArgumentResolutionError
       ].freeze
 
       def initialize(context)
@@ -65,15 +67,26 @@ module RubyReactor
         end
       end
 
+      # A unit that compensates itself outside the executor loop (StepWorker's
+      # `async_step`): the same coordination re-take, trace, middleware events
+      # and `rollback_failures` as a step compensated here.
+      def compensate(step_config, error, arguments)
+        compensate_step(step_config, error, arguments)
+      end
+
+      # Newest first. Each entry leaves the stack only once its undo returned,
+      # so an interruption mid-rollback leaves exactly the entries still to
+      # undo — the interrupted one included — for a manual undo (008 R-16).
       def rollback_completed_steps
-        undo_stack.reverse_each do |step_info|
+        until undo_stack.empty?
+          step_info = undo_stack.last
           result = @context.with_step(step_info[:step].name) do
             undo_step(step_info[:step], step_info[:result], step_info[:arguments])
           end
+          undo_stack.pop
           @undo_trace << { type: :undo, step: step_info[:step].name, result: result,
                            arguments: step_info[:arguments] }
         end
-        undo_stack.clear
       end
 
       private
@@ -117,19 +130,18 @@ module RubyReactor
         ).around_rollback(&block)
       end
 
+      # Under `with_step`, as `rollback_completed_steps` runs each undo: a
+      # construct (compose, map) reads `context.current_step` to find its own
+      # state during either rollback moment.
       def compensate_step(step_config, error, arguments)
+        @context.with_step(step_config.name) { compensate_step_body(step_config, error, arguments) }
+      end
+
+      def compensate_step_body(step_config, error, arguments)
         middlewares.on(:start_compensation, step_config.name, error, arguments, @context)
         begin
           compensate_result = coordinated_rollback(step_config, arguments) do
-            catch(StepSignals::TAG) do
-              if step_config.compensate_block
-                step_config.compensate_block.call(error, arguments, @context)
-              elsif step_config.has_impl?
-                step_config.impl.compensate(error, arguments, @context)
-              else
-                RubyReactor.Skipped() # Default: nothing defined, rollback continues
-              end
-            end
+            step_config.call_compensate(error, arguments, @context)
           end
 
           @context.append_execution_trace(
@@ -152,7 +164,7 @@ module RubyReactor
           end
 
           compensate_result
-        rescue StandardError => e
+        rescue Error::Rescuable => e
           record_rollback_failure(step_config.name, :compensate, e)
           middlewares.on(:failed_compensation, step_config.name, e, @context)
           # A raise is a compensation failure like a returned Failure: the
@@ -162,19 +174,11 @@ module RubyReactor
         end
       end
 
-      def undo_step(step_config, result, arguments) # rubocop:disable Metrics/MethodLength
+      def undo_step(step_config, result, arguments)
         middlewares.on(:start_undo, step_config.name, result, arguments, @context)
         begin
           undo_result = coordinated_rollback(step_config, arguments) do
-            catch(StepSignals::TAG) do
-              if step_config.undo_block
-                step_config.undo_block.call(result.value, arguments, @context)
-              elsif step_config.has_impl?
-                step_config.impl.undo(result.value, arguments, @context)
-              else
-                RubyReactor.Skipped() # Default: nothing defined, rollback continues
-              end
-            end
+            step_config.call_undo(result.value, arguments, @context)
           end
 
           @context.append_execution_trace(
@@ -196,7 +200,7 @@ module RubyReactor
           end
 
           undo_result
-        rescue StandardError => e
+        rescue Error::Rescuable => e
           record_rollback_failure(step_config.name, :undo, e)
           middlewares.on(:failed_undo, step_config.name, e, @context)
           # Log undo failure but don't halt the rollback process