ruby_reactor 0.6.0 → 0.7.1

data/lib/ruby_reactor/dsl/reactor.rb

@@ -10,13 +10,14 @@ module RubyReactor
         base.instance_variable_set(:@return_step, nil)
         base.instance_variable_set(:@middlewares, [])
         base.instance_variable_set(:@input_validations, {})
-        base.instance_variable_set(:@async, false)
+        base.instance_variable_set(:@background_handoff, nil)
         base.instance_variable_set(:@retry_defaults, { max_attempts: 3, backoff: :exponential, base_delay: 1 })
       end
 
       module ClassMethods
         include RubyReactor::Dsl::TemplateHelpers
         include RubyReactor::Dsl::ValidationHelpers
+        include RubyReactor::Dsl::AsyncMacros
 
         require_relative "interrupt_builder"
         require_relative "interrupt_step_config"
@@ -41,12 +42,17 @@ module RubyReactor
           @input_validations ||= {}
         end
 
-        def async(async = true)
-          @async = async
-        end
-
-        def async?
-          @async ||= false
+        # Whole-reactor `async true` is gone: it named the same idea as
+        # `background`'s cut point with a different word, right next to the
+        # new `async_step`/`async_reactor` macros whose names mean something
+        # else entirely. `async?` (the reader) lives in `AsyncMacros`, driven
+        # off `background_handoff`.
+        def async(*)
+          raise RubyReactor::Error::DeprecatedDslError,
+                "`async true` on a reactor has been removed: it named the same idea as `background`'s cut " \
+                "point with a different word, and read confusingly next to the `async_step`/`async_reactor` " \
+                "step macros. Use `background all: true` instead — identical behavior, including validating " \
+                "inputs inside the worker."
         end
 
         def retry_defaults(**kwargs)
@@ -138,8 +144,18 @@ module RubyReactor
           step_config
         end
 
-        def interrupt(name, &block)
-          builder = RubyReactor::Dsl::InterruptBuilder.new(name, self)
+        # `resume: :background` — after `continue` validates and stores the
+        # payload, the remaining work is enqueued to a worker instead of
+        # running inline in the delivering process (webhook, admin UI).
+        def interrupt(name, resume: :inline, &block)
+          unless %i[inline background].include?(resume)
+            raise RubyReactor::Error::ValidationError,
+                  "interrupt :#{name} has invalid `resume: #{resume.inspect}` — " \
+                  "use `:inline` (default, resume runs in the calling process) or " \
+                  "`:background` (resume is enqueued to a worker)."
+          end
+
+          builder = RubyReactor::Dsl::InterruptBuilder.new(name, self, resume: resume)
           builder.instance_eval(&block) if block_given?
 
           step_config = builder.build
@@ -148,7 +164,10 @@ module RubyReactor
         end
 
         def returns(step_name = nil)
-          @return_step = step_name if step_name
+          if step_name
+            reject_async_return_step!(step_name)
+            @return_step = step_name
+          end
           @return_step
         end
 

data/lib/ruby_reactor/dsl/step_builder.rb

@@ -24,7 +24,6 @@ module RubyReactor
         @validate_args_input = nil
         @args_validator = nil
         @output_validator = nil
-        @async = false
         @retry_config = {}
       end
 
@@ -85,8 +84,22 @@ module RubyReactor
           end
       end
 
-      def async(async = true)
-        @async = async
+      # The per-step hand-off flag is gone. Only the FIRST flagged step
+      # in a reactor ever took effect — every later one was silently ignored —
+      # so this must fail at class-definition time rather than surprise someone
+      # at run time. Kept as a stub purely to say what to use instead.
+      def async(*)
+        raise RubyReactor::Error::DeprecatedDslError.new(
+          "`async` inside a `step` block has been removed: it was ambiguous (only the first " \
+          "flagged step in a reactor ever took effect). Replacements:\n  " \
+          "* `background after: :#{@name}` — hand every REMAINING step to a worker once " \
+          ":#{@name} finishes in the calling process (declared on the reactor, not the step);\n  " \
+          "* `background before: :#{@name}` — hand off starting WITH :#{@name};\n  " \
+          "* `async_step :#{@name}` — dispatch just this step's work to its own job while the " \
+          "reactor keeps running;\n  " \
+          "* `async_reactor :name, ChildReactor` — dispatch a whole nested reactor independently.",
+          step: @name
+        )
       end
 
       def retries(max_attempts: 3, backoff: :exponential, base_delay: 1)
@@ -97,8 +110,12 @@ module RubyReactor
         }
       end
 
-      def build
+      # `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)
         step_config = {
+          async_dispatch: async_dispatch,
           name: @name,
           impl: @impl,
           arguments: @arguments,
@@ -110,7 +127,6 @@ module RubyReactor
           dependencies: @dependencies,
           args_validator: @args_validator || build_args_validator(@arg_validations, @validate_args_input),
           output_validator: @output_validator,
-          async: @async,
           retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
         }
 
@@ -120,9 +136,10 @@ module RubyReactor
 
     class StepConfig
       attr_reader :name, :impl, :arguments, :run_block, :compensate_block, :undo_block, :conditions, :guards,
-                  :dependencies, :args_validator, :output_validator, :async, :retry_config
+                  :dependencies, :args_validator, :output_validator, :retry_config, :async_dispatch
 
       def initialize(config)
+        @async_dispatch = config[:async_dispatch]
         @name = config[:name]
         @impl = config[:impl]
         @arguments = config[:arguments] || {}
@@ -134,10 +151,16 @@ module RubyReactor
         @dependencies = config[:dependencies] || []
         @args_validator = config[:args_validator]
         @output_validator = config[:output_validator]
-        @async = config[:async] || false
         @retry_config = { max_attempts: 1 }.merge(config[:retry_config] || {})
       end
 
+      # True for `async_step` / `async_reactor` — the step's work leaves this
+      # process instead of running inline. `RSpec::TestSubject`'s `async: false`
+      # clears the marker to run the whole reactor in one process.
+      def async_dispatch?
+        !@async_dispatch.nil?
+      end
+
       def has_impl?
         !@impl.nil?
       end
@@ -146,10 +169,6 @@ module RubyReactor
         !@run_block.nil?
       end
 
-      def async?
-        @async
-      end
-
       def retryable?
         (retry_config[:max_attempts] || 0) > 1
       end

data/lib/ruby_reactor/dsl/template_helpers.rb

@@ -3,6 +3,8 @@
 module RubyReactor
   module Dsl
     module TemplateHelpers
+      include RubyReactor::StepSignals
+
       def input(name, path = nil)
         RubyReactor::Template::Input.new(name, path)
       end
@@ -19,7 +21,7 @@ module RubyReactor
         RubyReactor::Template::Element.new(map_name, path)
       end
 
-      # Make Success, Failure, and Skipped available in DSL contexts
+      # Make Success, Failure, Halt, and Skipped available in DSL contexts
       # rubocop:disable Naming/MethodName
       def Success(value = nil)
         # rubocop:enable Naming/MethodName
@@ -33,9 +35,15 @@ module RubyReactor
       end
 
       # rubocop:disable Naming/MethodName
-      def Skipped(reason: nil, **kwargs)
+      def Halt(reason: nil, **kwargs)
+        # rubocop:enable Naming/MethodName
+        RubyReactor.Halt(reason: reason, **kwargs)
+      end
+
+      # rubocop:disable Naming/MethodName
+      def Skipped(...)
         # rubocop:enable Naming/MethodName
-        RubyReactor.Skipped(reason: reason, **kwargs)
+        RubyReactor.Skipped(...)
       end
     end
   end

data/lib/ruby_reactor/error/async_result_pending.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    # Raised inside a WORKER when `result(:name)` references an `async_step` /
+    # `async_reactor` that is not yet terminal. Instead of blocking the worker
+    # thread for the whole wait (the sync-caller behavior), the executor parks:
+    # exclusive lock / semaphore stay HELD (recorded on the context), the job
+    # re-enqueues itself via the snooze path, and the wait resumes on
+    # redelivery. Bounded by `Configuration#async_park_timeout`, enforced at
+    # the wait site before this is raised.
+    class AsyncResultPending < Base
+      attr_reader :channel
+
+      def initialize(message, channel: nil)
+        super(message)
+        @channel = channel
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/async_wait_timeout_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    # Raised when a notified wait on an `async_step` / `async_reactor`
+    # result exceeds `Configuration#async_wait_timeout`. Never an unbounded wait.
+    class AsyncWaitTimeoutError < Base
+    end
+  end
+end

data/lib/ruby_reactor/error/deprecated_dsl_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    # Definition-time error for DSL that has been removed. Subclasses
+    # ValidationError so existing `rescue Error::ValidationError` sites keep
+    # catching it.
+    class DeprecatedDslError < ValidationError
+    end
+  end
+end

data/lib/ruby_reactor/executor/async_step_dispatch.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Executor
+    # The dispatching half of `async_step`, mixed into StepExecutor. Split out
+    # because it is a self-contained concern — write the durable record and the
+    # context reference, enqueue, then mark the node graph-complete — and because
+    # it is where the structured logging for every hand-off lives.
+    module AsyncStepDispatch
+      private
+
+      # Send one step's work off as its own job and KEEP GOING.
+      #
+      # The ordering below is load-bearing (F2): the durable record and the
+      # context reference are written BEFORE the enqueue, so a crash in between
+      # can never leave a job with no record — and that same record is what
+      # tells a recovery pass the work is already out there, so it
+      # re-attaches instead of dispatching a duplicate side effect.
+      #
+      # Deliberately NOT gated on `inline_async_execution`: that flag stops the
+      # `background` hand-off from re-triggering inside a worker, but an
+      # `async_step` reached during a worker resume must still get its own job,
+      # or the feature silently degrades to inline execution exactly where the
+      # spec says it must not.
+      def dispatch_async_step(step_config)
+        if already_dispatched?(step_config)
+          @dependency_graph.complete_step(step_config.name)
+          return RubyReactor.Success(nil)
+        end
+
+        record_async_step_dispatch(step_config)
+        enqueue_async_step(step_config)
+
+        # Mark complete for SCHEDULING only — no result is recorded, so
+        # `result(:name)` still routes through the notified wait. This is what
+        # lets unrelated siblings become ready and run while the unit is in
+        # flight, instead of the loop returning early on an DispatchResult.
+        @dependency_graph.complete_step(step_config.name)
+        RubyReactor.Success(nil)
+      end
+
+      def already_dispatched?(step_config)
+        !storage.retrieve_step_result(@context.context_id, step_config.name, async_step_class_name).nil?
+      end
+
+      def record_async_step_dispatch(step_config)
+        root = @context.root_context || @context
+        @context.composed_contexts[step_config.name] = {
+          name: step_config.name,
+          type: :async_step_ref,
+          # Carried on the ref so the dashboard can find the Step Result Record
+          # from the reference alone, without re-deriving which context owns it.
+          context_id: @context.context_id,
+          dispatched_at: Time.now
+        }
+        storage.store_step_result(
+          @context.context_id, step_config.name,
+          {
+            "status" => "dispatched", "dispatched_at" => Time.now.iso8601,
+            # The re-dispatch arguments, verbatim. The record's own key names the
+            # reactor that OWNS the step, which for a composed child is not the
+            # root the worker must load, so recovery cannot re-derive them.
+            "root_context_id" => root.context_id,
+            "reactor_class_name" => RubyReactor.reactor_storage_name(root.reactor_class),
+            "step_context_id" => @context.context_id,
+            "step_name" => step_config.name.to_s
+          },
+          async_step_class_name
+        )
+
+        # The worker loads the parent by id, so the parent must be durable
+        # before the job exists AND must outlive the dispatched unit — including
+        # the fire-and-forget case where this reactor finishes immediately and
+        # nothing ever waits.
+        checkpoint_root!(root, RubyReactor.reactor_storage_name(root.reactor_class))
+      end
+
+      def enqueue_async_step(step_config)
+        root = @context.root_context || @context
+        log_async_event("async_step.dispatched", step_config.name)
+        configuration.async_router.perform_step_async(
+          root_context_id: root.context_id,
+          reactor_class_name: RubyReactor.reactor_storage_name(root.reactor_class),
+          step_context_id: @context.context_id,
+          step_name: step_config.name
+        )
+      end
+
+      # Step Result Records are namespaced by the reactor that OWNS the step,
+      # which for a composed child is the child — the same name the reader's
+      # `Template::Result` will look under.
+      def async_step_class_name
+        RubyReactor.reactor_storage_name(@context.reactor_class || @reactor_class)
+      end
+
+      def storage
+        RubyReactor::Configuration.instance.storage_adapter
+      end
+
+      # One machine-parseable line per hand-off / dispatch, carrying the
+      # three identifiers needed to correlate it with everything else.
+      def log_async_event(event, step_name)
+        configuration.logger.info(
+          "event=\"ruby_reactor.#{event}\" reactor=#{@reactor_class&.name.inspect} " \
+          "step=#{step_name.inspect} execution_id=#{@context.context_id.inspect}"
+        )
+      end
+    end
+  end
+end

data/lib/ruby_reactor/executor/compensation_manager.rb

@@ -55,33 +55,44 @@ module RubyReactor
         @context.middlewares || RubyReactor::MiddlewareRunner.new([])
       end
 
+      # Ensure we have a value to log (if it's a Success/Failure object, get the value or error)
+      def loggable_value(result)
+        if result.respond_to?(:value)
+          result.value
+        elsif result.respond_to?(:error)
+          result.error
+        else
+          result
+        end
+      end
+
+      def skipped_result?(result)
+        result.respond_to?(:skipped?) && result.skipped?
+      end
+
       def compensate_step(step_config, error, arguments)
         middlewares.on(:start_compensation, step_config.name, error, arguments, @context)
         begin
-          compensate_result = 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.Success() # Default compensation
-                              end
-
-          # Ensure we have a value to log
-          logged_result = if compensate_result.respond_to?(:value)
-                            compensate_result.value
-                          elsif compensate_result.respond_to?(:error)
-                            compensate_result.error
-                          else
-                            compensate_result
-                          end
-
-          @context.execution_trace << {
-            type: :compensate,
-            step: step_config.name,
-            timestamp: Time.now,
-            result: logged_result,
-            arguments: arguments
-          }
+          compensate_result = 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
+
+          @context.append_execution_trace(
+            {
+              type: :compensate,
+              step: step_config.name,
+              timestamp: Time.now,
+              result: loggable_value(compensate_result),
+              arguments: arguments,
+              skipped: skipped_result?(compensate_result)
+            }
+          )
           @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
 
           if compensate_result.is_a?(RubyReactor::Failure)
@@ -100,25 +111,26 @@ module RubyReactor
       def undo_step(step_config, result, arguments)
         middlewares.on(:start_undo, step_config.name, result, arguments, @context)
         begin
-          undo_result = 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.Success()
-                        end
-
-          # Ensure we have a value to log (if it's a Success/Failure object, get the value or error)
-          logged_result = if undo_result.respond_to?(:value)
-                            undo_result.value
-                          elsif undo_result.respond_to?(:error)
-                            undo_result.error
-                          else
-                            undo_result
-                          end
-
-          @context.execution_trace << { type: :undo, step: step_config.name, timestamp: Time.now, result: logged_result,
-                                        arguments: arguments }
+          undo_result = 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
+
+          @context.append_execution_trace(
+            {
+              type: :undo,
+              step: step_config.name,
+              timestamp: Time.now,
+              result: loggable_value(undo_result),
+              arguments: arguments,
+              skipped: skipped_result?(undo_result)
+            }
+          )
 
           if undo_result.is_a?(RubyReactor::Failure)
             middlewares.on(:failed_undo, step_config.name, undo_result, @context)
@@ -130,8 +142,9 @@ module RubyReactor
         rescue StandardError => e
           middlewares.on(:failed_undo, step_config.name, e, @context)
           # Log undo failure but don't halt the rollback process
-          @context.execution_trace << { type: :undo_failure, step: step_config.name, timestamp: Time.now,
-                                        error: e.message }
+          @context.append_execution_trace(
+            { type: :undo_failure, step: step_config.name, timestamp: Time.now, error: e.message }
+          )
           RubyReactor.Failure(e)
         end
       end

data/lib/ruby_reactor/executor/ordered_lock_support.rb

@@ -69,7 +69,7 @@ module RubyReactor
       #
       # The strict-mode chain-skip only fires on a *fresh* start (no step
       # has run yet on this context). This lets an in-flight run that paused
-      # (Interrupt / AsyncResult) complete on resume regardless of chain
+      # (Interrupt / DispatchResult) complete on resume regardless of chain
       # failures that landed while it was parked, while still applying
       # strict to a fresh Sidekiq job (which enters via `resume_execution`
       # but has no prior step state).
@@ -117,14 +117,14 @@ module RubyReactor
         @ordered_lock_drained_replay == true
       end
 
-      # Terminal Skipped result when the ordered-lock gate short-circuits this
+      # Terminal Halt result when the ordered-lock gate short-circuits this
       # run (stale batch, strict chain failure, or a drained-batch redelivery of
       # an already-terminal context), or nil to continue. Shared by `execute`
       # and `resume_execution`.
       def ordered_lock_short_circuit
-        return RubyReactor::Skipped.new(reason: :ordered_lock_stale_batch) if ordered_lock_stale_batch?
-        return RubyReactor::Skipped.new(reason: :ordered_lock_drained_replay) if ordered_lock_drained_replay?
-        return RubyReactor::Skipped.new(reason: :ordered_lock_chain_failed) if ordered_lock_chain_skip?
+        return RubyReactor::Halt.new(reason: :ordered_lock_stale_batch) if ordered_lock_stale_batch?
+        return RubyReactor::Halt.new(reason: :ordered_lock_drained_replay) if ordered_lock_drained_replay?
+        return RubyReactor::Halt.new(reason: :ordered_lock_chain_failed) if ordered_lock_chain_skip?
 
         nil
       end
@@ -138,12 +138,12 @@ module RubyReactor
       def short_circuit!(result)
         @result = result
 
-        # A stale-batch or drained-batch-redelivery skip means this run's epoch
+        # A stale-batch or drained-batch-redelivery halt means this run's epoch
         # belongs to a drained generation — typically a slow straggler or a
         # Sidekiq at-least-once redelivery. If the redelivery is of a job that
         # ALREADY reached a terminal status, its stored context is the source of
-        # truth; writing :skipped over a :completed/:failed record would silently
-        # corrupt the outcome. Return the skip to the worker (so it stops)
+        # truth; writing :halted over a :completed/:failed record would silently
+        # corrupt the outcome. Return the halt to the worker (so it stops)
         # without saving. The `@skip_context_persist` flag also suppresses the
         # ensure-block save in execute / resume_execution, which would otherwise
         # clobber the stored terminal record with this run's stale in-memory
@@ -169,14 +169,14 @@ module RubyReactor
       # set when the status was terminal, but re-checking keeps both paths
       # uniform and self-guarding.
       def redelivery_of_terminal?(result)
-        return false unless result.is_a?(RubyReactor::Skipped)
+        return false unless result.is_a?(RubyReactor::Halt)
         return false unless %i[ordered_lock_stale_batch ordered_lock_drained_replay].include?(result.reason)
 
         stored_status_terminal?
       end
 
       def stored_status_terminal?
-        %w[completed failed skipped].include?(stored_context_status)
+        %w[completed failed halted skipped].include?(stored_context_status)
       end
 
       def stored_context_status
@@ -296,7 +296,7 @@ module RubyReactor
 
       def terminal_for_ordered_lock?(result)
         case result
-        when RubyReactor::AsyncResult, RubyReactor::InterruptResult, RetryQueuedResult
+        when RubyReactor::DispatchResult, RubyReactor::InterruptResult, RetryQueuedResult
           false
         when RubyReactor::Success, RubyReactor::Failure
           true

data/lib/ruby_reactor/executor/result_handler.rb

@@ -14,9 +14,13 @@ module RubyReactor
 
       def handle_step_result(step_config, result, resolved_arguments)
         case result
+        when RubyReactor::Halt
+          # Important: must come before Skipped and Success — both are Halt's
+          # siblings under Success, and Halt takes precedence over either.
+          handle_halt(step_config, result)
         when RubyReactor::Skipped
-          # Important: must come before the Success branch — Skipped < Success.
-          handle_skipped(step_config, result)
+          # Must come before the Success branch — Skipped < Success.
+          handle_skipped(step_config, result, resolved_arguments)
         when RubyReactor::Success
           handle_success(step_config, result, resolved_arguments)
         when RubyReactor::MaxRetriesExhaustedFailure
@@ -78,30 +82,62 @@ module RubyReactor
         )
       end
 
-      # A step returned `RubyReactor.Skipped(...)`. Halt cleanly: record the
+      # A step returned `RubyReactor.Halt(...)`. Halt cleanly: record the
       # event in the trace, do NOT push to the undo stack (so existing
       # completed steps stay as-is — no compensation), and stamp the step
       # name on the result so the caller can see who halted.
-      def handle_skipped(step_config, result)
+      def handle_halt(step_config, result)
         @step_results[step_config.name] = result
         result.instance_variable_set(:@step_name, step_config.name) if result.step_name.nil?
-        @context.execution_trace << {
-          type: :skipped,
-          step: step_config.name,
-          timestamp: Time.now,
-          reason: result.reason
-        }
+        @context.append_execution_trace(
+          {
+            type: :halt,
+            step: step_config.name,
+            timestamp: Time.now,
+            reason: result.reason
+          }
+        )
+        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).
+      def handle_skipped(step_config, result, resolved_arguments)
+        validate_step_output(step_config, result.value, resolved_arguments)
+        @step_results[step_config.name] = result
+        @context.set_result(step_config.name, result.value)
+        @dependency_graph.complete_step(step_config.name)
+        @context.append_execution_trace(
+          {
+            type: :skipped,
+            step: step_config.name,
+            timestamp: Time.now,
+            reason: result.reason
+          }
+        )
         result
       end
 
       def handle_success(step_config, result, resolved_arguments)
         validate_step_output(step_config, result.value, resolved_arguments)
         @step_results[step_config.name] = result
-        @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments, result: 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)
+          @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments,
+                                                    result: result })
+        end
         @context.set_result(step_config.name, result.value)
         @dependency_graph.complete_step(step_config.name)
       end
 
+      def async_unit?(step_config)
+        step_config.respond_to?(:async_dispatch?) && step_config.async_dispatch?
+      end
+
       def handle_retries_exhausted(step_config, result, resolved_arguments)
         @compensation_manager.handle_step_failure(step_config, result.original_error, resolved_arguments)
         orig_err = result.original_error.is_a?(Exception) ? result.original_error : nil