ruby_reactor 0.6.0 → 0.7.1

data/lib/ruby_reactor/async_waiter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  # The shared wait core behind `result(:name)` for an `async_step` or an
+  # `async_reactor` that has not finished yet. Both callers hand it a pub/sub
+  # channel and a callable that returns the terminal value (or nil while the work
+  # is still in flight), so there is exactly one implementation of the wait.
+  #
+  # The contract is "durable record answers, signal only hurries":
+  #
+  #   * the completing side writes its durable outcome FIRST, then publishes;
+  #   * this side checks the durable target, then blocks until either the signal
+  #     arrives or a coarse fallback interval elapses, then re-checks.
+  #
+  # Redis pub/sub is at-most-once and unpersisted, so a dropped signal must never
+  # cost correctness — only fallback latency. Every exit path here goes through
+  # the durable check, and the whole thing is bounded: it raises rather than
+  # hanging (SC-005).
+  class AsyncWaiter
+    # Latency backstop for a lost signal, not a tuning surface — derived from the
+    # timeout rather than configured (Principle V). The clamp guarantees ~10
+    # re-checks inside any bound, so a dropped notification costs at most ~10% of
+    # the wait, and never re-checks hotter than once a second.
+    FALLBACK_BOUNDS = (1.0..5.0)
+
+    attr_reader :channel, :timeout
+
+    # @param channel [String] completion-signal channel to listen on
+    # @param timeout [Numeric, nil] seconds; defaults to `async_wait_timeout`
+    # @yieldreturn [Object, nil] the terminal value, or nil while still pending
+    def initialize(channel:, timeout: nil, &terminal_check)
+      @channel = channel
+      @timeout = timeout || RubyReactor.configuration.async_wait_timeout
+      @terminal_check = terminal_check
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @signalled = false
+    end
+
+    def wait
+      deadline = monotonic + @timeout
+      subscriber = start_subscriber
+
+      loop do
+        value = @terminal_check.call
+        return value unless value.nil?
+
+        remaining = deadline - monotonic
+        raise timeout_error if remaining <= 0
+
+        block_until_signalled_or([fallback_interval, remaining].min)
+      end
+    ensure
+      # ponytail: killing the thread is enough — `subscribe`'s own ensure closes
+      # the dedicated connection on the way out.
+      subscriber&.kill
+    end
+
+    private
+
+    def fallback_interval
+      (@timeout / 10.0).clamp(FALLBACK_BOUNDS)
+    end
+
+    # Subscribing happens before the first durable check so a completion landing
+    # mid-check still wakes us. The subscription is established asynchronously,
+    # so this narrows the race rather than closing it outright — which is fine
+    # precisely because the fallback re-check, not the signal, is what makes the
+    # wait correct.
+    def start_subscriber
+      Thread.new do
+        RubyReactor.configuration.storage_adapter.subscribe(@channel) do |_message|
+          signal!
+          true # stop subscribing — completion is one-shot
+        end
+      rescue StandardError => e
+        # A waiter that loses its notification channel degrades to the fallback
+        # re-check; it must not take the waiting step down with it.
+        RubyReactor.configuration.logger.warn(
+          "RubyReactor: async completion subscription to #{@channel} failed (#{e.class}: #{e.message}); " \
+          "falling back to periodic re-checks"
+        )
+      end
+    end
+
+    def signal!
+      @mutex.synchronize do
+        @signalled = true
+        @condition.broadcast
+      end
+    end
+
+    def block_until_signalled_or(seconds)
+      @mutex.synchronize do
+        @condition.wait(@mutex, seconds) unless @signalled
+        @signalled = false
+      end
+    end
+
+    def timeout_error
+      Error::AsyncWaitTimeoutError.new(
+        "Timed out after #{@timeout}s waiting for async completion on '#{@channel}'. " \
+        "The dispatched work never reached a terminal state within " \
+        "`RubyReactor.configuration.async_wait_timeout` — check that a worker is running and " \
+        "consuming the queue, or raise the timeout if this unit is legitimately slower."
+      )
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/ruby_reactor/configuration.rb

@@ -10,7 +10,8 @@ module RubyReactor
     attr_writer :queue_name, :job_retry_count, :logger, :async_router,
                 :lock_snooze_base_delay, :lock_snooze_jitter, :lock_snooze_max_attempts,
                 :middlewares, :context_ttl, :context_lock_ttl, :checkpoint_min_interval,
-                :sweeper_enabled, :sweeper_interval, :sweeper_limit
+                :sweeper_enabled, :sweeper_interval, :sweeper_limit, :async_wait_timeout,
+                :async_park_timeout
 
     def queue_name
       @queue_name ||= :default
@@ -89,6 +90,34 @@ module RubyReactor
       @context_lock_ttl ||= 60
     end
 
+    # Seconds a step blocks in the notified wait when it reads
+    # `result(:name)` for an `async_step` / `async_reactor` that has not finished
+    # yet. Never unbounded: on expiry the referencing step fails with an
+    # `Error::AsyncWaitTimeoutError`.
+    #
+    # 30s must comfortably exceed dispatch -> worker pickup -> completion for a
+    # small unit under a healthy queue, while staying under the request/job
+    # timeouts of typical hosts (Sidekiq's 25s shutdown grace, Puma's 60s) so a
+    # stuck wait fails loudly on our terms instead of being killed from outside.
+    #
+    # The wait's fallback re-check interval is DERIVED from this, not configured:
+    # `async_wait_timeout / 10` clamped to 1..5s (see AsyncWaiter).
+    def async_wait_timeout
+      @async_wait_timeout ||= 30
+    end
+
+    # Total seconds a WORKER-side `result(:name)` wait may stay parked before
+    # failing with `Error::AsyncWaitTimeoutError`, measured from the unit's
+    # `dispatched_at`. Inside a worker a pending result does not block the
+    # thread for `async_wait_timeout` — after a short in-thread grace the job
+    # parks (re-enqueues itself, locks kept held) and re-checks on redelivery,
+    # so this bound can be generous where the blocking one must stay tight.
+    # `:infinity` removes the bound (the context TTL then remains the only
+    # backstop), mirroring `lock_snooze_max_attempts`.
+    def async_park_timeout
+      @async_park_timeout ||= 3600
+    end
+
     def job_retry_count
       @job_retry_count ||= 3
     end

data/lib/ruby_reactor/context.rb

@@ -2,6 +2,27 @@
 
 module RubyReactor
   class Context
+    # `composed_contexts[step_name]` is the one channel for "children of this
+    # context, referenced for later drill-down" — the dashboard's
+    # `hydrate_composed_contexts` and `RSpec::TestSubject`'s traversal both
+    # switch on the `type:` tag. Four tags, all plain data (no serialization
+    # change between them):
+    #
+    #   :composed          => { name:, type:, context: }  — an inline `compose` child
+    #   :map_ref           => { name:, type:, map_id:, element_reactor_class: }
+    #   :async_step_ref    => { name:, type:, dispatched_at: }
+    #     The reference only. The `async_step`'s actual outcome lives in the Step
+    #     Result Record bucket, keyed by (context_id, step_name), because a
+    #     separate worker writes it concurrently with this still-running context.
+    #   :async_reactor_ref => { name:, type:, execution_id:, reactor_class_name:, dispatched_at: }
+    #     The child is an ordinary addressable reactor, so its outcome is simply
+    #     its own context row — no extra storage primitive.
+    #
+    # Both async refs are written SYNCHRONOUSLY by the dispatching step, before
+    # it returns, so there is no cross-process write race on the reference
+    # itself (unlike the result).
+    COMPOSED_CONTEXT_TYPES = %i[composed map_ref async_step_ref async_reactor_ref].freeze
+
     attr_accessor :inputs, :intermediate_results, :private_data, :current_step, :retry_count, :concurrency_key,
                   :retry_context, :reactor_class, :execution_trace, :inline_async_execution, :undo_stack,
                   :parent_context, :root_context, :composed_contexts, :context_id, :map_operations, :map_metadata,
@@ -82,6 +103,13 @@ module RubyReactor
       @current_step = old_step
     end
 
+    # Appends an execution-trace event stamped with whether this process is the
+    # worker (`inline_async_execution`). Traces written before this field
+    # existed stay unlabeled on deserialize.
+    def append_execution_trace(entry)
+      @execution_trace << entry.merge(background: !!@inline_async_execution)
+    end
+
     def to_h
       {
         inputs: @inputs,

data/lib/ruby_reactor/context_serializer.rb

@@ -36,6 +36,11 @@ module RubyReactor
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def serialize_value(value)
         case value
+        when RubyReactor::Halt
+          { "_type" => "Halt", "reason" => value.reason, "period_key" => value.period_key,
+            "step_name" => value.step_name }
+        when RubyReactor::Skipped
+          { "_type" => "Skipped", "value" => serialize_value(value.value), "reason" => value.reason }
         when RubyReactor::Success
           { "_type" => "Success", "value" => serialize_value(value.value) }
         when RubyReactor::Failure
@@ -112,6 +117,14 @@ module RubyReactor
           if value.key?("_type")
             # Special serialized types (Time, BigDecimal, etc.)
             case value["_type"]
+            when "Halt"
+              RubyReactor::Halt.new(
+                reason: value["reason"],
+                period_key: value["period_key"],
+                step_name: value["step_name"]
+              )
+            when "Skipped"
+              RubyReactor::Skipped.new(deserialize_value(value["value"]), reason: value["reason"])
             when "Success"
               RubyReactor::Success(deserialize_value(value["value"]))
             when "Failure"
@@ -185,6 +198,8 @@ module RubyReactor
       # Simplifies data for public API usage (removes wrappers, flattens types)
       def simplify_for_api(value)
         case value
+        when RubyReactor::Map::ResultEnumerator
+          RubyReactor::Map::ResultSummary.build(value)
         when Hash
           simplified = value.each_with_object({}) do |(k, v), hash|
             hash[k.to_s] = simplify_for_api(v)

data/lib/ruby_reactor/dsl/async_macros.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    # The three ways a reactor sends work out of the calling process, kept
+    # together because they are one design decision seen from three distances:
+    #
+    #   background     — the rest of THIS reactor moves to a worker
+    #                    (`all: true` — EVERYTHING, incl. input validation)
+    #   async_step     — ONE step's work becomes its own job
+    #   async_reactor  — a whole nested reactor runs independently
+    #
+    # Mixed into `Dsl::Reactor::ClassMethods`.
+    module AsyncMacros
+      # The single, unambiguous cut point between what runs in
+      # the calling process and what is handed to a worker. Replaces the
+      # per-step `async` flag, where only the first flagged step ever took
+      # effect and the rest were silently ignored, and the whole-reactor
+      # `async true` flag, which named the same idea with a different word.
+      #
+      #   background after:  :second   # :second is the LAST step to run here
+      #   background before: :third    # :third is the FIRST step in the worker
+      #   background all: true         # the ENTIRE reactor runs in the worker,
+      #                                 # including input validation
+      #
+      # `after:`/`before:` name one cut point from opposite sides — identical
+      # in a linear chain, different in a DAG, where each pins the step it
+      # names. `all:` names no step: there is nothing left to pin, everything
+      # moves. Triggering is keyed to REACHING the named step (or, for `all:`,
+      # to the run starting at all), not to where this declaration sits in
+      # the class body.
+      def background(after: nil, before: nil, all: false)
+        point = validate_background_declaration!(after, before, all)
+
+        @background_handoff = point
+      end
+
+      # The normalized `{ mode:, step: }` pair — one reader, never a one-sided
+      # `background_after`, so no consumer can be accidentally implemented for
+      # `after:` only. `step` is `nil` when `mode` is `:all`.
+      def background_handoff
+        @background_handoff
+      end
+
+      # True only for the whole-reactor hand-off (`background all: true`) —
+      # the entire run, including input validation, happens in a worker.
+      def async?
+        background_handoff&.fetch(:mode, nil) == :all
+      end
+
+      def validate_background_declaration!(after, before, all)
+        given = [after, before, all].count { |v| v }
+        if given > 1
+          raise RubyReactor::Error::ValidationError,
+                "`background` takes exactly one of `after:`, `before:`, or `all:`, got more than one " \
+                "(after: #{after.inspect}, before: #{before.inspect}, all: #{all.inspect}). Each names a " \
+                "different hand-off shape: `after: :x` / `before: :x` pin a cut point around step :x; " \
+                "`all: true` sends the whole reactor, including input validation."
+        end
+
+        if given.zero?
+          raise RubyReactor::Error::ValidationError,
+                "`background` requires one of `after: :step_name` (that step is the last to run in the " \
+                "calling process), `before: :step_name` (that step is the first to run in the worker), or " \
+                "`all: true` (the entire reactor, including input validation, runs in the worker)."
+        end
+
+        point = if all
+                  { mode: :all, step: nil }
+                else
+                  { mode: after ? :after : :before, step: (after || before).to_sym }
+                end
+
+        # Re-declaring the SAME point is a no-op — a class body can be
+        # evaluated twice (Rails reloading, a spec reopening a fixture class)
+        # and that must not be an error. A DIFFERENT second point is the real
+        # footgun `background` exists to remove.
+        if background_handoff && background_handoff != point
+          raise RubyReactor::Error::ValidationError,
+                "#{name || "This reactor"} already declares `background " \
+                "#{describe_handoff_point(background_handoff)}` and cannot also declare `background " \
+                "#{describe_handoff_point(point)}`. A reactor has exactly one hand-off point — a second " \
+                "would reintroduce the ambiguity `background` exists to remove."
+        end
+
+        validate_step_handoff_point!(point) unless point[:mode] == :all
+
+        point
+      end
+      private :validate_background_declaration!
+
+      def validate_step_handoff_point!(point)
+        step_name = point[:step]
+        unless steps.key?(step_name)
+          raise RubyReactor::Error::ValidationError,
+                "`background` names unknown step :#{step_name}. Known steps: " \
+                "#{steps.keys.map { |k| ":#{k}" }.join(", ")}. The step must be defined before the " \
+                "`background` declaration."
+        end
+
+        reject_interrupt_handoff_point!(point)
+      end
+      private :validate_step_handoff_point!
+
+      def describe_handoff_point(point)
+        point[:mode] == :all ? "all: true" : "#{point[:mode]}: :#{point[:step]}"
+      end
+      private :describe_handoff_point
+
+      # An interrupt re-enters the reactor from a foreground process, so an
+      # edge-triggered hand-off keyed to it either never fires (`after:` — the
+      # resume path skips the already-resulted step) or enqueues a worker that
+      # instantly pauses and swallows the InterruptResult (`before:`). Both are
+      # the silent-failure class `background` exists to remove.
+      def reject_interrupt_handoff_point!(point)
+        config = steps[point[:step]]
+        return unless config.respond_to?(:interrupt?) && config.interrupt?
+
+        raise RubyReactor::Error::ValidationError,
+              "`background #{point[:mode]}: :#{point[:step]}` names an interrupt step, which cannot be a " \
+              "hand-off point. To resume :#{point[:step]} in a worker, declare " \
+              "`interrupt :#{point[:step]}, resume: :background` instead; to hand off around it, name an " \
+              "ordinary step on the side you need."
+      end
+      private :reject_interrupt_handoff_point!
+      # A step whose work is dispatched to its own independent worker
+      # job while this reactor keeps executing every other ready step. Same
+      # call shape and same block DSL as `step` — `argument`, `run`,
+      # `compensate`, `undo`, `retries`, validators all behave identically;
+      # only WHERE the body runs changes.
+      #
+      # Any step reading `result(:name)` blocks (bounded) until the unit
+      # finishes. A failure with no reader does NOT compensate this reactor —
+      # compensation is opt-in, via a reader that inspects the result and
+      # returns `Failure` itself.
+      def async_step(name, impl = nil, &block)
+        builder = RubyReactor::Dsl::StepBuilder.new(name, impl, self)
+        builder.instance_eval(&block) if block_given?
+
+        steps[name] = builder.build(async_dispatch: :step)
+      end
+
+      # Dispatch a whole nested reactor to run INDEPENDENTLY — linked
+      # to this one by execution id for traceability, but excluded from its
+      # compensation graph. Fire-and-forget unless a later step reads
+      # `result(:name)`, which blocks until the child is terminal and hands
+      # over the child's real Success/Failure to inspect.
+      #
+      # Contrast with `compose`, which runs the child inline, synchronously,
+      # and fully wired into the parent's rollback path.
+      def async_reactor(name, child_reactor_class, &block)
+        builder = RubyReactor::Dsl::AsyncReactorBuilder.new(name, child_reactor_class, self)
+        builder.instance_eval(&block) if block_given?
+
+        steps[name] = builder.build
+      end
+
+      # A reactor's return value must come from a step that ran in the calling
+      # process. An `async_step` / `async_reactor` may still be in flight when
+      # this reactor finishes — that is the whole point of dispatching it — so
+      # returning it would either mean returning nothing or silently turning
+      # the fire-and-forget contract into a blocking wait.
+      def reject_async_return_step!(step_name)
+        config = steps[step_name]
+        return unless config.respond_to?(:async_dispatch?) && config.async_dispatch?
+
+        kind = config.async_dispatch == :reactor ? "async_reactor" : "async_step"
+        raise RubyReactor::Error::ValidationError,
+              "`returns :#{step_name}` is invalid: :#{step_name} is an `#{kind}`, which may still be " \
+              "running when this reactor finishes. Return a same-process step instead — if you need the " \
+              "dispatched outcome, add a step that reads `result(:#{step_name})` and return that."
+      end
+      private :reject_async_return_step!
+    end
+  end
+end

data/lib/ruby_reactor/dsl/async_reactor_builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    # Builds the `async_reactor` dispatch step. Same `argument` mapping shape as
+    # `ComposeBuilder`, but deliberately NOT a subclass of it: `compose`'s
+    # builder warns that a child's `with_ordered_lock` is ignored (true for an
+    # inline child, which bypasses `Reactor#run`) whereas an `async_reactor`
+    # child is dispatched through the full pre-enqueue sequence and DOES get its
+    # ordering nonce.
+    class AsyncReactorBuilder
+      include RubyReactor::Dsl::TemplateHelpers
+
+      attr_accessor :name, :child_reactor_class, :argument_mappings
+
+      def initialize(name, child_reactor_class, reactor = nil)
+        @name = name
+        @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 }
+      end
+
+      def build
+        RubyReactor::Dsl::StepConfig.new(
+          async_dispatch: :reactor,
+          name: @name,
+          impl: RubyReactor::Step::AsyncReactorStep,
+          arguments: {
+            async_reactor_class: { source: RubyReactor::Template::Value.new(@child_reactor_class) },
+            argument_mappings: { source: RubyReactor::Template::Value.new(@argument_mappings) }
+          },
+          run_block: nil,
+          # No compensate/undo: the child is deliberately outside the parent's
+          # compensation graph. Compensation is opt-in, via a later step
+          # 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
+        )
+      end
+
+      private
+
+      def dependencies_from_mappings
+        @argument_mappings.each_value
+                          .select { |source| source.is_a?(RubyReactor::Template::Result) }
+                          .map(&:step_name)
+                          .uniq
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/compose_builder.rb

@@ -20,7 +20,6 @@ module RubyReactor
         end
         @reactor = reactor
         @argument_mappings = {}
-        @async = false
         @retry_config = {}
       end
 
@@ -28,8 +27,21 @@ module RubyReactor
         @argument_mappings[composed_input_name] = source
       end
 
-      def async(async = true)
-        @async = async
+      # `compose`'s `async` set the very same per-step hand-off flag the
+      # step DSL's did, so it goes with it. The exact migration is
+      # `background before: :<this compose step>` — that reproduces the old
+      # semantics precisely (this step and everything after it move to the
+      # worker) without the author having to identify a predecessor step.
+      def async(*)
+        raise RubyReactor::Error::DeprecatedDslError.new(
+          "`async` inside a `compose` block has been removed (it set the same ambiguous per-step " \
+          "hand-off flag as `step`'s). Use `background before: :#{@name}` on the reactor to move " \
+          ":#{@name} and every step after it to a worker — that reproduces the old behavior exactly. " \
+          "For a nested reactor that should run INDEPENDENTLY of this one, use " \
+          "`async_reactor :#{@name}, #{@composed_reactor_class&.name || "ChildReactor"}` instead; " \
+          "for one step's worth of work, `async_step`.",
+          step: @name
+        )
       end
 
       def retries(max_attempts: 3, backoff: :exponential, base_delay: 1)
@@ -59,7 +71,6 @@ module RubyReactor
           dependencies: dependencies,
           args_validator: nil,
           output_validator: nil,
-          async: @async,
           retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
         }
 
@@ -77,6 +88,14 @@ module RubyReactor
         @composed_reactor_class.compose(name, reactor_class, &block)
       end
 
+      # An inline compose child is a real reactor class, so it can declare its
+      # own hand-off point — delegate rather than making inline children the one
+      # place `background` is unavailable.
+      def background(**kwargs)
+        ensure_composed_reactor_class!
+        @composed_reactor_class.background(**kwargs)
+      end
+
       private
 
       # Composed children bypass `Reactor#run`, so `assign_ordered_lock_nonce!`

data/lib/ruby_reactor/dsl/interrupt_builder.rb

@@ -3,12 +3,13 @@
 module RubyReactor
   module Dsl
     class InterruptBuilder < StepBuilder
-      def initialize(name, reactor = nil)
+      def initialize(name, reactor = nil, resume: :inline)
         super(name, nil, reactor)
         @correlation_id_block = nil
         @timeout_config = nil
         @validation_schema = nil
         @max_attempts = 1
+        @resume_mode = resume
       end
 
       def max_attempts(count)
@@ -51,8 +52,8 @@ module RubyReactor
           timeout_config: @timeout_config,
           validation_schema: @validation_schema,
           max_attempts: @max_attempts,
+          resume_mode: @resume_mode,
           dependencies: @dependencies,
-          async: false, # Interrupts are effectively boundaries, not async jobs themselves (until resumed)
           conditions: @conditions,
           guards: @guards
         }

data/lib/ruby_reactor/dsl/interrupt_step_config.rb

@@ -3,7 +3,8 @@
 module RubyReactor
   module Dsl
     class InterruptStepConfig < StepConfig
-      attr_reader :correlation_id_block, :timeout_config, :validation_schema, :strategy, :max_attempts
+      attr_reader :correlation_id_block, :timeout_config, :validation_schema, :strategy, :max_attempts,
+                  :resume_mode
 
       def initialize(config)
         super
@@ -11,11 +12,16 @@ module RubyReactor
         @timeout_config = config[:timeout_config]
         @validation_schema = config[:validation_schema]
         @max_attempts = config[:max_attempts] || 1
+        @resume_mode = config[:resume_mode] || :inline
       end
 
       def interrupt?
         true
       end
+
+      def background_resume?
+        @resume_mode == :background
+      end
     end
   end
 end

data/lib/ruby_reactor/dsl/lockable.rb

@@ -53,7 +53,7 @@ module RubyReactor
 
         # Configure a calendar-aligned dedup window for this reactor. The
         # reactor will run at most once per bucket per key; subsequent calls
-        # in the same bucket return `RubyReactor::Skipped` without executing
+        # in the same bucket return `RubyReactor::Halt` without executing
         # any steps.
         #
         # Note: `with_period` is *dedup*, not *concurrency*. Two concurrent
@@ -93,13 +93,13 @@ module RubyReactor
         #   assign. Only fully-drained sequences GC themselves.
         # @param strict [Boolean] When true (default), if any nonce in the
         #   sequence terminates with a `Failure`, all subsequent nonces are
-        #   short-circuited with `Skipped(reason: :ordered_lock_chain_failed)`
+        #   short-circuited with `Halt(reason: :ordered_lock_chain_failed)`
         #   instead of executing. This models "stop the line on the first
         #   problem" pipelines (e.g. ledger transactions). When false, the
         #   sequence keeps executing every nonce in order regardless of prior
         #   failures. The poison state is per-key and clears on full drain. The
         #   check only applies to a fresh `execute`; an already-started run
-        #   that paused (InterruptResult/AsyncResult) completes on resume even
+        #   that paused (InterruptResult/DispatchResult) completes on resume even
         #   if the chain failed in the meantime.
         # @yield [inputs] Block that returns the ordered-lock key string.
         def with_ordered_lock(poison_pill_timeout: OrderedLock::DEFAULT_POISON_PILL_TIMEOUT,

data/lib/ruby_reactor/dsl/map_builder.rb

@@ -107,8 +107,7 @@ module RubyReactor
           guards: [],
           dependencies: dependencies.uniq,
           args_validator: nil,
-          output_validator: nil,
-          async: false # MapStep handles async internally via run_async
+          output_validator: nil
         }
       end