ruby_reactor 0.8.3 → 0.8.5

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/rspec/test_subject.rb

@@ -556,7 +556,6 @@ module RubyReactor
           @middlewares = superclass.middlewares.dup
           @return_step = superclass.return_step
           @background_handoff = superclass.background_handoff
-          @retry_defaults = superclass.instance_variable_get(:@retry_defaults)
 
           # 2. Add Name Handling with Unique Registry Entry
           # We must register a unique name so that if this reactor is reloaded (e.g. after async child completion),
@@ -648,7 +647,6 @@ module RubyReactor
           @middlewares = superclass.middlewares.dup
           @return_step = superclass.return_step
           @background_handoff = superclass.background_handoff
-          @retry_defaults = superclass.instance_variable_get(:@retry_defaults)
         end
 
         strip_background_and_async!(child_class)
@@ -736,7 +734,6 @@ module RubyReactor
           @middlewares = superclass.middlewares.dup
           @return_step = superclass.return_step
           @background_handoff = superclass.background_handoff
-          @retry_defaults = superclass.instance_variable_get(:@retry_defaults)
         end
 
         # Recursively apply interceptors to the child reactor
@@ -765,14 +762,15 @@ module RubyReactor
       # callable a mock block can invoke.
       def original_impl_for(step_config_orig, target_step)
         if step_config_orig.has_run_block?
-          step_config_orig.run_block
+          # A mock may hand `original` a plain Hash (`args.to_h.merge(...)`).
+          ->(args, ctx) { step_config_orig.run_block.call(step_config_orig.wrap_inputs(args), ctx) }
         elsif step_config_orig.has_impl?
           impl = step_config_orig.impl
 
           if impl.respond_to?(:run_without_coordination)
             ->(args, ctx) { impl.run_without_coordination(args, ctx) }
           else
-            ->(args, ctx) { impl.run(args, ctx) }
+            ->(args, ctx) { impl.run(args.to_h, ctx) }
           end
         else
           ->(_, _) { raise "No implementation found for #{target_step}" }

data/lib/ruby_reactor/step/async_reactor_step.rb

@@ -15,6 +15,10 @@ module RubyReactor
     # ordered-lock nonce at ENQUEUE time (so ordering matches caller order), and
     # persist before enqueueing (F2).
     class AsyncReactorStep < RubyReactor::Step
+      # Untyped, so no validation: declared only so `inputs.x` can read them.
+      input :async_reactor_class
+      input :argument_mappings, optional: true
+
       class << self
         # Exclusive keys this EXECUTION currently holds, read from the root
         # context's registry. Shared by the `async_reactor` dispatch check
@@ -54,8 +58,8 @@ module RubyReactor
       end
 
       def run
-        child_class = inputs[:async_reactor_class]
-        child_inputs = build_child_inputs(inputs[:argument_mappings] || {})
+        child_class = inputs.async_reactor_class
+        child_inputs = build_child_inputs(inputs.argument_mappings || {})
 
         # A dispatch-time failure fails the DISPATCHING step, i.e. normal saga
         # handling in the parent. That is deliberately outside the

data/lib/ruby_reactor/step/compose_step.rb

@@ -3,6 +3,10 @@
 module RubyReactor
   class Step
     class ComposeStep < RubyReactor::Step
+      # Untyped, so no validation: declared only so `inputs.x` can read them.
+      input :composed_reactor_class
+      input :argument_mappings, optional: true
+
       def run
         step_name = context.current_step
         composed_data = context.composed_contexts[step_name]
@@ -12,7 +16,7 @@ module RubyReactor
         store_child_context(step_name, child_context)
 
         # Execute the composed reactor
-        result = execute_child_reactor(inputs[:composed_reactor_class], child_context, composed_data)
+        result = execute_child_reactor(inputs.composed_reactor_class, child_context, composed_data)
 
         # Update the stored context
         store_child_context(step_name, child_context)
@@ -30,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
 
@@ -42,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)
@@ -59,8 +69,8 @@ module RubyReactor
         child_context = composed_data ? composed_data[:context] : nil
 
         unless child_context
-          composed_inputs = build_composed_inputs(inputs[:argument_mappings] || {})
-          child_context = RubyReactor::Context.new(composed_inputs, inputs[:composed_reactor_class])
+          composed_inputs = build_composed_inputs(inputs.argument_mappings || {})
+          child_context = RubyReactor::Context.new(composed_inputs, inputs.composed_reactor_class)
         end
 
         link_contexts(child_context, context)

data/lib/ruby_reactor/step/input_contract.rb

@@ -25,6 +25,11 @@ module RubyReactor
       def input(name, type = nil, optional: false, default: nil, redact: false, validate: nil, **predicates, &block)
         # rubocop:enable Metrics/ParameterLists
         check_dry_validation_available!
+        if Step::Inputs.public_method_defined?(name)
+          raise Error::ValidationError,
+                "input :#{name} is reserved: step code reads inputs as `inputs.#{name}`, and `#{name}` is already " \
+                "a method there. Rename the input."
+        end
         unless default.nil? || optional
           raise Error::ValidationError,
                 "input :#{name} declares `default:` but is required; a default only applies to an " \

data/lib/ruby_reactor/step/inputs.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Step
+    # What step code (`run`, `undo`, `compensate`) receives as its inputs: a
+    # frozen, read-only view of the argument Hash with one reader per name the
+    # step may read. Any other name raises `Error::UndeclaredInputError` on the
+    # line that reads it, instead of returning nil and failing somewhere else.
+    #
+    #   inputs.order_guid      # the value, or nil for an absent optional input
+    #   inputs.order_id        # raises UndeclaredInputError
+    #   inputs.to_h            # supplied values, readable names only
+    #   Service.call(**inputs) # via `to_hash`
+    #
+    # Readable names are the contract's declarations, or the keys present when
+    # the step has none. Built only where inputs reach step code; everything
+    # else in the gem keeps the Hash.
+    class Inputs
+      def initialize(values, contract: nil, owner: nil)
+        @values = values.to_h
+        @owner = owner
+        declared = contract&.declarations&.keys || []
+        @names = declared.empty? ? @values.keys.map(&:to_sym).uniq : declared
+        @redacted = contract&.redacted_names || []
+        freeze
+      end
+
+      def to_h
+        @names.each_with_object({}) do |name, hash|
+          hash[name] = Utils::FetchIndifferent.call(@values, name) if supplied?(name)
+        end
+      end
+      alias to_hash to_h
+
+      def inspect
+        to_h.to_h { |name, value| [name, @redacted.include?(name) ? InputContract::REDACTED : value] }.inspect
+      end
+
+      private
+
+      def method_missing(name, *args)
+        return Utils::FetchIndifferent.call(@values, name) if args.empty? && @names.include?(name)
+
+        declared = @names.empty? ? "none" : @names.map(&:inspect).join(", ")
+        raise Error::UndeclaredInputError.new("#{@owner} has no input :#{name}. Declared inputs: #{declared}.", name)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @names.include?(name) || super
+      end
+
+      def supplied?(name)
+        @values.key?(name) || @values.key?(name.to_s)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/step/map_step.rb

@@ -3,8 +3,23 @@
 module RubyReactor
   class Step
     class MapStep < RubyReactor::Step
+      # 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
+      input :argument_mappings, optional: true
+      input :strict_ordering, optional: true
+      input :batch_size, optional: true
+      input :collect_block, optional: true
+      input :fail_fast, optional: true
+      input :fan_out, optional: true
+
       def run
-        return RubyReactor::Failure("Map source cannot be nil") if inputs[:source].nil?
+        return RubyReactor::Failure("Map source cannot be nil") if inputs.source.nil?
 
         # Initialize map state in context if not present
         context.map_operations ||= {}
@@ -16,11 +31,37 @@ 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), highest index 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.
+      #
+      # ponytail: serial, in the process that detected the failure, so rollback
+      # time is linear in the number of completed elements. Fan the rollback
+      # out per element if that ever outgrows one job.
       def compensate
-        # TODO: Implement compensation for map steps
-        RubyReactor.Success()
+        step_name = context.current_step
+        map_id = "#{context.context_id}:#{step_name}"
+        failures = []
+
+        completed_elements(map_id, failures).each do |index, element_context|
+          tag = { map_step: step_name.to_sym, element_index: index }
+          failures.concat(rollback_element(map_id, index, element_context).map { |entry| entry.merge(tag) })
+        end
+
+        return RubyReactor.Success() if failures.empty?
+
+        RubyReactor.Failure("map :#{step_name} rollback incomplete", rollback_failures: failures)
       end
 
+      alias undo compensate
+
+      # An interrupted run is undone too: undo replays only each element's completed steps.
+      def self.undoes_partial_run? = true
+
       class << self
         def build_mapped_inputs(mappings, context, element)
           built = {}
@@ -69,6 +110,79 @@ 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
+
+      # `[[index, context], ...]` for every completed element, highest index
+      # first. An element whose row is gone (expired past `context_ttl`) is
+      # reported, never skipped silently.
+      def completed_elements(map_id, failures)
+        storage = RubyReactor.configuration.storage_adapter
+        storage_name = RubyReactor.reactor_storage_name(element_class)
+        # A parked or retried fan-out element registers its id again.
+        ids = storage.retrieve_map_element_context_ids(map_id, context.reactor_class.name).uniq
+        rows = ids.map { |id| storage.retrieve_context(id, storage_name) }
+        elements = rows.compact.map do |data|
+          element_context = RubyReactor::Context.deserialize_from_retry(data)
+          [Utils::FetchIndifferent.call(element_context.map_metadata || {}, :index).to_i, element_context]
+        end
+
+        report_unavailable(elements.map(&:first), rows.count(nil), failures)
+        # An `aborted` element (an inline run interrupted in it) kept the undo
+        # entries of the steps it completed.
+        elements.select { |_, element| %w[completed aborted].include?(element.status.to_s) }
+                .sort_by { |index, _| -index }
+      end
+
+      # The parent's map reference (in its own blob, so it lives as long as
+      # the parent) counts the elements that started: set per element inline,
+      # and to the total when a fan-out map completes. With it, every started
+      # index without a row is named, even when the index list itself expired;
+      # without it (a failed fan-out map skipped some indices), one unnamed
+      # entry per indexed row that is gone.
+      def report_unavailable(found_indexes, missing_rows, failures)
+        ref = Utils::FetchIndifferent.call(context.composed_contexts, context.current_step)
+        started = ref && Utils::FetchIndifferent.call(ref, :started)
+        missing = started ? (0...started).to_a - found_indexes : [nil] * missing_rows
+        missing.each { |index| failures << rollback_entry(index, :context_unavailable, "context expired") }
+      end
+
+      def rollback_entry(index, reason, message)
+        step_name = context.current_step.to_sym
+        { step: step_name, kind: :undo, key: nil, reason: reason, map_step: step_name, element_index: index,
+          message: "map element #{index} #{message}" }
+      end
+
+      # The element's own undo stack, replayed as `ComposeStep` replays its
+      # child's, under the element's liveness lock: a held lock after the map
+      # settled is a live duplicate delivery, which is left alone and reported.
+      def rollback_element(map_id, index, element_context)
+        lock = acquire_element_lock(map_id, index)
+        return [rollback_entry(index, :element_in_flight, "was still running at rollback time")] if lock == :held
+
+        executor = RubyReactor::Executor.new(element_class, {}, element_context)
+        executor.undo_all
+        executor.save_context
+        executor.compensation_manager.rollback_failures
+      ensure
+        lock.release if lock.respond_to?(:release)
+      end
+
+      def acquire_element_lock(map_id, index)
+        return nil if RubyReactor::Map::ElementExecutor.inline_testing_mode?
+
+        config = RubyReactor.configuration
+        lock = RubyReactor::Lock.new("map_element:#{map_id}:#{index}",
+                                     owner: SecureRandom.uuid, ttl: config.context_lock_ttl, wait: ELEMENT_LOCK_WAIT)
+        lock.acquire
+        lock
+      rescue RubyReactor::Lock::AcquisitionError
+        :held
+      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
@@ -77,21 +191,21 @@ module RubyReactor
       def fan_out?
         return false if context.map_metadata || context.root_context&.map_metadata
 
-        inputs[:fan_out]
+        inputs.fan_out
       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])
+        process_results(results, inputs.collect_block, inputs.fail_fast)
       end
 
       def execute_inline_map
         results = []
-        fail_fast = inputs[:fail_fast].nil? || inputs[:fail_fast]
+        fail_fast = inputs.fail_fast.nil? || inputs.fail_fast
 
-        inputs[:source].each_with_index do |element, index|
+        inputs.source.each_with_index do |element, index|
           result = execute_single_element(element, index)
 
           # An element-level Halt propagates as a run halt: stop immediately
@@ -110,8 +224,8 @@ module RubyReactor
       end
 
       def execute_single_element(element, index)
-        mapped_inputs = self.class.build_mapped_inputs(inputs[:argument_mappings] || {}, context, element)
-        child_context = RubyReactor::Context.new(mapped_inputs, inputs[:mapped_reactor_class])
+        mapped_inputs = self.class.build_mapped_inputs(inputs.argument_mappings || {}, context, element)
+        child_context = RubyReactor::Context.new(mapped_inputs, inputs.mapped_reactor_class)
 
         link_contexts(child_context, context)
 
@@ -131,10 +245,11 @@ 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)
+        executor = RubyReactor::Executor.new(inputs.mapped_reactor_class, {}, child_context)
         executor.execute
         executor.result
       end
@@ -150,7 +265,7 @@ module RubyReactor
           begin
             # Collect block receives Result objects when fail_fast is false, values when true
             return RubyReactor::Success(collect_block.call(results))
-          rescue StandardError => e
+          rescue RubyReactor::Error::Rescuable => e
             return RubyReactor::Failure(e)
           end
         end
@@ -162,9 +277,9 @@ module RubyReactor
       def run_async(step_name)
         map_id = "#{context.context_id}:#{step_name}"
         context.map_operations[step_name.to_s] = map_id
-        prepare_async_execution(map_id, inputs[:source].size)
+        prepare_async_execution(map_id, inputs.source.size)
 
-        reactor_class_info = build_reactor_class_info(inputs[:mapped_reactor_class], step_name)
+        reactor_class_info = build_reactor_class_info(inputs.mapped_reactor_class, step_name)
 
         initialize_map_metadata(map_id, reactor_class_info)
 
@@ -175,7 +290,7 @@ module RubyReactor
           name: step_name.to_s,
           type: :map_ref,
           map_id: map_id,
-          element_reactor_class: inputs[:mapped_reactor_class].name
+          element_reactor_class: inputs.mapped_reactor_class.name
         }
 
         RubyReactor::DispatchResult.new(
@@ -188,9 +303,9 @@ module RubyReactor
       def initialize_map_metadata(map_id, reactor_class_info)
         storage = RubyReactor.configuration.storage_adapter
         storage.initialize_map_operation(
-          map_id, inputs[:source].size, context.reactor_class.name,
-          strict_ordering: inputs[:strict_ordering], reactor_class_info: reactor_class_info,
-          **map_recovery_metadata(inputs[:step_name] || context.current_step)
+          map_id, inputs.source.size, context.reactor_class.name,
+          strict_ordering: inputs.strict_ordering, reactor_class_info: reactor_class_info,
+          **map_recovery_metadata(context.current_step)
         )
       end
 
@@ -215,21 +330,21 @@ module RubyReactor
         # 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
+        batch_size = inputs.batch_size || inputs.source.size
 
         RubyReactor::Map::Dispatcher.perform(
           map_id: map_id,
           parent_context_id: context.context_id,
           parent_reactor_class_name: context.reactor_class.name,
-          source: inputs[:source],
+          source: inputs.source,
           batch_size: batch_size,
           step_name: step_name,
-          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]
+          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
         )
-        queue_collector(map_id, step_name, inputs[:strict_ordering])
+        queue_collector(map_id, step_name, inputs.strict_ordering)
         "map:#{map_id}"
       end