ruby_reactor 0.5.4 → 0.7.0

data/README.md

@@ -5,7 +5,7 @@
 
 # RubyReactor
 
-A dynamic, dependency-resolving saga orchestrator for Ruby. Ruby Reactor implements the Saga pattern with compensation-based error handling and DAG-based execution planning. It leverages **Sidekiq** for asynchronous execution and **Redis** for state persistence.
+A dynamic, dependency-resolving saga orchestrator for Ruby. Ruby Reactor implements the Saga pattern with compensation-based error handling and DAG-based execution planning. It leverages **Sidekiq or ActiveJob** for asynchronous execution and **Redis** for state persistence.
 
 ![Payment workflow reactor](documentation/images/payment_workflow.png)
 
@@ -18,7 +18,7 @@ The key value is **Reliability**: if any part of your workflow fails, Ruby React
 ## Features
 
 - **DAG-based Execution**: Steps are executed based on their dependencies, allowing for parallel execution of independent steps.
-- **Async Execution**: Steps can be executed asynchronously in the background using Sidekiq.
+- **Async Execution**: Steps can be executed asynchronously in the background using Sidekiq or ActiveJob (so any ActiveJob-compatible queue — Resque, Solid Queue, GoodJob, etc. — works too).
 - **Map & Parallel Execution**: Iterate over collections in parallel with the `map` step, distributing work across multiple workers.
 - **Retries**: Configurable retry logic for failed steps, with exponential backoff.
 - **Compensation**: Automatic rollback of completed steps when a failure occurs.
@@ -35,7 +35,7 @@ The key value is **Reliability**: if any part of your workflow fails, Ruby React
 | Interrupts (pause/resume)| Yes          | No              | No          | Manual              |
 | Locks / sem / rate / per | Yes          | No              | No          | Manual              |
 | Built-in web dashboard   | Yes          | No              | No          | No                  |
-| Async with Sidekiq       | Yes          | No              | Limited     | Yes                 |
+| Async (Sidekiq/AJ)       | Yes          | No              | Limited     | Yes                 |
 | Durable crash recovery   | Yes          | No              | No          | Manual              |
 
 ## Real-World Use Cases
@@ -59,7 +59,9 @@ The key value is **Reliability**: if any part of your workflow fails, Ruby React
   - [Basic Example: User Registration](#basic-example-user-registration)
   - [Async Execution](#async-execution)
     - [Full Reactor Async](#full-reactor-async)
-    - [Step-Level Async](#step-level-async)
+    - [Background Hand-off](#background-hand-off)
+    - [`async_step`](#async_step-one-step-dispatched-on-its-own)
+    - [`async_reactor`](#async_reactor-a-whole-nested-reactor-running-independently)
   - [Durability & Recovery](#durability--recovery)
   - [Interrupts (Pause & Resume)](#interrupts-pause--resume)
   - [Locks, Semaphores & Ordered Locks](#locks-semaphores--ordered-locks)
@@ -115,18 +117,21 @@ RubyReactor.configure do |config|
   ## Extra options passed to Redis.new. Default: {}.
   # config.storage.redis_options = { timeout: 1 }
 
-  ## === Sidekiq ===
+  ## === Background job backend (Sidekiq by default, or ActiveJob) ===
 
-  ## Sidekiq queue used by RubyReactor's async worker. Default: :default.
-  # config.sidekiq_queue = :default
+  ## Queue used by RubyReactor's async worker. Default: :default.
+  # config.queue_name = :default
 
-  ## Sidekiq retry count for infrastructure failures only (deserialization,
-  ## Redis, network). Step retries are managed separately. Default: 3.
-  # config.sidekiq_retry_count = 3
+  ## Retry count for infrastructure failures only (deserialization, Redis,
+  ## network). Step retries are managed separately. Default: 3.
+  # config.job_retry_count = 3
+
+  ## `sidekiq_queue` / `sidekiq_retry_count` still work as deprecated aliases
+  ## for `queue_name` / `job_retry_count` above.
 
   ## === Contention snooze (locks / semaphores / rate limits / ordered locks) ===
 
-  ## When a Sidekiq worker cannot acquire a primitive it re-enqueues itself with
+  ## When a worker cannot acquire a primitive it re-enqueues itself with
   ## `lock_snooze_base_delay + rand(0..lock_snooze_jitter)` seconds (rate-limit
   ## uses a precise `retry_after_seconds` hint from the error; ordered-lock waits
   ## re-poll at the base delay so a successor catches its blocker finishing fast),
@@ -136,6 +141,19 @@ RubyReactor.configure do |config|
   # config.lock_snooze_jitter = 5
   # config.lock_snooze_max_attempts = 20
 
+  ## === Waiting on async results (`result(:name)` on async_step / async_reactor) ===
+
+  ## How long a SYNCHRONOUS caller blocks on a still-pending async result before
+  ## failing with Error::AsyncWaitTimeoutError. Kept tight: a blocking wait pins
+  ## a thread and must stay under typical host timeouts. Default: 30.
+  # config.async_wait_timeout = 30
+
+  ## Total parked time allowed when the reader runs INSIDE a worker: the job
+  ## re-enqueues itself instead of blocking (locks stay held across the gap),
+  ## so this bound can be generous. Measured from the unit's dispatch.
+  ## :infinity removes the bound. Default: 3600.
+  # config.async_park_timeout = 3600
+
   ## === Durability & crash recovery (see "Durability & Recovery" below) ===
 
   ## Retention TTL (seconds) for stored reactor/map state. Must exceed your
@@ -162,10 +180,11 @@ RubyReactor.configure do |config|
   ## Logger. Default: Logger.new($stdout).
   # config.logger = Logger.new($stdout)
 
-  ## Async router. Default: RubyReactor::SidekiqAdapter. Swap for a custom adapter
-  ## if you don't use Sidekiq — it only needs to respond to
+  ## Async router. Default: RubyReactor::Adapters::Sidekiq::Router. Swap in the
+  ## built-in ActiveJob adapter (see "Async Execution" below), or point at any
+  ## custom adapter — it only needs to respond to
   ## `perform_async(context_id, reactor_class_name, **)`.
-  # config.async_router = MyCustomAdapter
+  # config.async_router = RubyReactor::Adapters::ActiveJob::Router
 
   ## === Examples (no default — set these to use the feature) ===
 
@@ -181,8 +200,9 @@ You can also leave out the `configure` block entirely — defaults work for loca
 
 > **Crash recovery needs a kick.** The `sweeper_*` settings above only configure
 > the recovery sweeper — they do not start it. Call `RubyReactor.start_sweeper!`
-> once at boot (ideally from a Sidekiq `on(:startup)` hook) or no crashed reactor
-> will ever resume. See [Durability & Recovery](#durability--recovery).
+> once at boot (ideally from a worker-process startup hook — a Sidekiq
+> `on(:startup)` hook, or a Rails initializer for ActiveJob) or no crashed
+> reactor will ever resume. See [Durability & Recovery](#durability--recovery).
 
 
 ## Quick Start
@@ -380,26 +400,40 @@ end
 
 ### Async Execution
 
-Execute reactors in the background using Sidekiq.
+Execute reactors in the background using Sidekiq or ActiveJob. The backend is
+chosen via `config.async_router` (defaults to the Sidekiq adapter); to run on
+ActiveJob instead:
+
+```ruby
+RubyReactor.configure do |config|
+  config.async_router = RubyReactor::Adapters::ActiveJob::Router
+end
+```
+
+That's the only switch — everything below (full-reactor async, step-level
+async, durability, retries, snoozing) works identically on either backend.
 
 #### Full Reactor Async
 
 ```ruby
 class AsyncReactor < RubyReactor::Reactor
-  async true # Entire reactor runs in background
+  background all: true # Entire reactor runs in background
 
   step :long_running_task do
     run { perform_heavy_work }
   end
 end
 
-# Returns immediately with AsyncResult
+# Returns immediately with DispatchResult
 result = AsyncReactor.run(params)
 ```
 
-#### Step-Level Async
+#### Background Hand-off
 
-You can also mark individual steps as async. Execution will proceed synchronously until the first async step is encountered, at which point the reactor execution is offloaded to a background job.
+A reactor can name **one** point where execution stops running in the caller's
+process and is handed to a worker. Everything before it runs in the caller;
+everything after it runs in a single background job. The cut point is nameable
+from either side.
 
 ```ruby
 class CreateUserReactor < RubyReactor::Reactor
@@ -414,15 +448,16 @@ class CreateUserReactor < RubyReactor::Reactor
     run { |args| User.create(args[:params]) }
   end
 
-  # From here on will run async
+  # :create_user is the LAST step to run in the calling process.
+  # Equivalently here: `background before: :open_account`.
+  background after: :create_user
+
   step :open_account do
-    async true
     argument :user, result(:create_user)
     run { |args| Bank.open_account(args[:user]) }
   end
 
   step :report_new_user do
-    async true
     argument :user, result(:create_user)
     wait_for :open_account
     run { |args| Analytics.track(args[:user]) }
@@ -431,16 +466,112 @@ end
 
 # Usage
 def create(params)
-   # Returns an AsyncResult immediately when 'open_account' is reached
-   result = CreateUserReactor.run(params)
-   
-   # Access synchronous results immediately
-   user = result.intermediate_results[:create_user]
-   
-   # do something with user
+  # Returns an DispatchResult immediately once :create_user completes
+  result = CreateUserReactor.run(params)
+
+  # Access synchronous results immediately
+  user = result.intermediate_results[:create_user]
+
+  # do something with user
 end
 ```
 
+`after: :x` guarantees `:x` runs in the calling process and is the last to do so.
+`before: :x` guarantees `:x` runs in the worker and is the first to do so. They
+coincide in a linear chain; **in a DAG they pin different steps**, so pick
+whichever step you actually need pinned. Compensation is unchanged — `background`
+changes where code runs, not the saga contract.
+
+> **Breaking change:** the per-step `async true` flag has been **removed**. It was
+> ambiguous — only the *first* flagged step in a reactor ever took effect and the
+> rest were silently ignored — and it now raises at class-definition time. The
+> exact replacement for a flagged step `:x` is `background before: :x`. The same
+> applies to `async` inside a `compose` block.
+>
+> **Breaking change:** whole-reactor `async true` has also been **removed** — it
+> named the same idea as `background`'s cut point with a different word, right next
+> to `async_step`/`async_reactor`, whose names mean something else. It now raises
+> at class-definition time. The exact replacement is `background all: true`.
+
+#### `async_step`: one step, dispatched on its own
+
+Where `background` relocates the *rest* of a reactor, `async_step` dispatches one
+step's work to its own job while the reactor keeps running every other ready step.
+
+```ruby
+class SignupReactor < RubyReactor::Reactor
+  input :email
+
+  async_step :send_email do
+    argument :to, input(:email)
+    run { |args| Mailer.welcome(args[:to]).deliver_now; Success(:sent) }
+  end
+
+  # Does NOT wait — it has no dependency on :send_email.
+  step :record_signup do
+    argument :email, input(:email)
+    run { |args| Success(Signup.create!(email: args[:email])) }
+  end
+
+  # DOES wait, because it reads the result.
+  step :confirm_delivery do
+    argument :delivery, result(:send_email)
+    run { |args| Success("confirmed") }
+  end
+end
+```
+
+Reading `result(:send_email)` is what makes a step wait — never unbounded, and
+never thread-hungry: a **synchronous caller** blocks, bounded by
+`config.async_wait_timeout` (default 30s); a reader **inside a worker** parks
+instead — after a short grace the job re-enqueues itself, freeing the thread and
+keeping any held lock/semaphore checked out, bounded by
+`config.async_park_timeout` (default 1h) so legitimately slow units get their
+time. On success the reader gets the raw value; on failure it gets the
+`Failure` **object**, so it can inspect it and decide.
+
+**Compensation is opt-in.** If a dispatched step fails and nothing reads its
+result, the reactor is not compensated — it was dispatched precisely so the
+reactor would not depend on it. A reader that returns `Failure` triggers
+compensation normally. The independence cuts both ways: async dispatches never
+enter the parent's undo stack, so a parent rolling back for its own reasons
+never "undoes" a unit that runs (and may still succeed) elsewhere.
+
+#### `async_reactor`: a whole nested reactor, running independently
+
+```ruby
+class SignupReactor < RubyReactor::Reactor
+  input :user_id
+
+  # Fire-and-forget: nothing reads it, so its failure never affects this reactor.
+  async_reactor :backfill_profile, ProfileBackfillReactor do
+    argument :user_id, input(:user_id)
+  end
+
+  async_reactor :provision_account, AccountProvisioningReactor do
+    argument :user_id, input(:user_id)
+  end
+
+  step :verify do
+    argument :account, result(:provision_account)   # waits for the child
+    run do |args|
+      args[:account].success? ? Success(args[:account].value) : Failure(args[:account].error)
+    end
+  end
+end
+```
+
+The child is an ordinary, independently addressable execution, linked to the
+parent by execution id (drillable in the dashboard) but excluded from its
+compensation graph. Reach for `compose` instead when the child belongs to this
+unit of work — its result is available immediately and its failure rolls the
+parent back.
+
+Lock ownership is never shared across the async boundary: a child declaring a key
+the parent holds fails at dispatch with an explanatory error rather than
+deadlocking. See [Async Reactors](documentation/async_reactors.md) for the full
+rules.
+
 ### Durability & Recovery
 
 Async reactors are durable: state lives in Redis, not in the job payload. Before
@@ -455,8 +586,8 @@ reactor only resumes when the recovery sweeper notices the lapsed liveness lock
 and re-enqueues it. The sweeper is a self-rescheduling chain — **kick it once per
 process boot:**
 
-The recommended spot is a Sidekiq server startup hook, so only the worker
-process runs recovery (not your web/console/client processes):
+The recommended spot is a worker-process startup hook, so only the worker
+process runs recovery (not your web/console/client processes). On Sidekiq:
 
 ```ruby
 # config/initializers/sidekiq.rb
@@ -465,7 +596,18 @@ Sidekiq.configure_server do |config|
 end
 ```
 
-Anywhere that runs once at boot works too — e.g. a Rails initializer:
+ActiveJob has no equivalent server-only hook — call it from wherever your
+queue adapter's worker process boots (e.g. `bin/jobs` for Solid Queue, or a
+dedicated initializer guarded by an env var so it doesn't also run in web
+processes):
+
+```ruby
+# config/initializers/ruby_reactor.rb
+RubyReactor.start_sweeper! if ENV["RUBY_REACTOR_WORKER"]
+```
+
+Anywhere that runs once at boot works too (idempotent, so it's safe even if
+every process calls it) — e.g. an unconditional Rails initializer:
 
 ```ruby
 # config/initializers/ruby_reactor.rb
@@ -599,7 +741,7 @@ class ChargeReactor < RubyReactor::Reactor
 
   # Respect upstream Stripe rate limits: 3/sec and 100/min.
   # Async workers snooze for exactly retry_after seconds instead of
-  # consuming Sidekiq retry budget.
+  # consuming the backend's retry budget.
   with_rate_limit(
     limits: { second: 3, minute: 100 }
   ) { |inputs| "stripe:#{inputs[:account_id]}" }
@@ -657,7 +799,7 @@ Referencing an unregistered name raises `RubyReactor::RateLimitRegistry::Unknown
 On contention:
 
 - **Inline** (`Reactor.run`) raises `RubyReactor::Lock::AcquisitionError` / `RubyReactor::Semaphore::AcquisitionError` / `RubyReactor::RateLimit::ExceededError` / `RubyReactor::OrderedLock::WaitError`.
-- **Async** (Sidekiq) snoozes the job via `perform_in(delay, ...)`. For rate limits the delay uses the error's `retry_after_seconds` hint (precise wakeup — the bucket roll time is known exactly); for locks, semaphores, and ordered-lock waits it's `lock_snooze_base_delay + jitter` (a short re-poll, since a held lock or a live blocker nonce typically clears in milliseconds). Snoozes do not count against the Sidekiq retry budget. After `lock_snooze_max_attempts` snoozes the context is marked failed (ordered-lock waits bypass the cap — see the ordered-lock docs).
+- **Async** (Sidekiq or ActiveJob) snoozes the job via `perform_in(delay, ...)`. For rate limits the delay uses the error's `retry_after_seconds` hint (precise wakeup — the bucket roll time is known exactly); for locks, semaphores, and ordered-lock waits it's `lock_snooze_base_delay + jitter` (a short re-poll, since a held lock or a live blocker nonce typically clears in milliseconds). Snoozes do not count against the backend's retry budget. After `lock_snooze_max_attempts` snoozes the context is marked failed (ordered-lock waits bypass the cap — see the ordered-lock docs).
 
 On dedup hits (period gate already marked), the reactor returns a `RubyReactor::Skipped` result instead — no steps run, no exception:
 
@@ -1176,7 +1318,7 @@ Learn about the fundamental building blocks of RubyReactor: Reactors, Steps, Con
 Deep dive into how RubyReactor manages dependencies. This guide explains how the Directed Acyclic Graph is constructed to ensure steps execute in the correct topological order, enabling automatic parallelization of independent steps.
 
 ### [Async Reactors](documentation/async_reactors.md)
-Explore the two asynchronous execution models: Full Reactor Async and Step-Level Async. Learn how RubyReactor leverages Sidekiq for background processing, non-blocking execution, and scalable worker management.
+Explore the ways to move work off the calling process: Full Reactor Async, the `background` hand-off, `async_step`, and `async_reactor`. Learn how RubyReactor leverages Sidekiq or ActiveJob for background processing, non-blocking execution, and scalable worker management.
 
 ### [Composition](documentation/composition.md)
 Discover how to build complex, modular workflows by composing reactors within other reactors. This guide covers inline composition, class-based composition, and how to manage dependencies between composed workflows.
@@ -1219,9 +1361,9 @@ Hook into the execution lifecycle with observer middlewares. Covers the full set
 - [ ] Multiple storage adapters
   - [X] Redis
   - [ ] ActiveRecord
-- [ ] Multiple Async adapters
+- [X] Multiple Async adapters
   - [X] Sidekiq
-  - [ ] ActiveJob
+  - [X] ActiveJob
 - [X] OpenTelemetry support
 - [X] locks
 

data/lib/ruby_reactor/adapters/active_job/compat.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Adapters
+    module ActiveJob
+      # `Sidekiq::Worker` gives every job class `.perform_async` / `.perform_in`
+      # for free; ActiveJob only has `.perform_later`. Extending this onto an
+      # ActiveJob class normalizes its enqueue API to the same two class
+      # methods, so `RubyReactor::Worker` and `RubyReactor::SweeperJob` can keep
+      # calling `self.class.perform_in(...)` unchanged regardless of backend.
+      # Both methods return the job id (a String), matching what Sidekiq's
+      # native `perform_async`/`perform_in` return.
+      module Compat
+        def perform_async(*args)
+          perform_later(*args).job_id
+        end
+
+        def perform_in(delay, *args)
+          set(wait: delay).perform_later(*args).job_id
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/adapters/active_job/map_collector_worker.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module RubyReactor
+  module Adapters
+    module ActiveJob
+      class MapCollectorWorker < ::ActiveJob::Base
+        extend Compat
+
+        queue_as { RubyReactor.configuration.queue_name }
+
+        def perform(arguments)
+          RubyReactor::Map::Collector.perform(arguments)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/adapters/active_job/map_element_worker.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module RubyReactor
+  module Adapters
+    module ActiveJob
+      class MapElementWorker < ::ActiveJob::Base
+        extend Compat
+
+        queue_as { RubyReactor.configuration.queue_name }
+
+        def perform(arguments)
+          RubyReactor::Map::ElementExecutor.perform(arguments)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/adapters/active_job/router.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Adapters
+    module ActiveJob
+      class Router
+        # Identity-only payload: the worker rehydrates the live context from storage
+        # by (context_id, reactor_class_name). The caller already holds context_id, so
+        # there is no blob to deserialize here.
+        def self.perform_async(context_id, reactor_class_name = nil, intermediate_results: {})
+          job_id = RubyReactor::Adapters::ActiveJob::Worker.perform_async(context_id, reactor_class_name)
+          RubyReactor::DispatchResult.new(job_id: job_id, intermediate_results: intermediate_results,
+                                       execution_id: context_id)
+        end
+
+        def self.perform_in(delay, context_id, reactor_class_name = nil, intermediate_results: {})
+          job_id = RubyReactor::Adapters::ActiveJob::Worker.perform_in(delay, context_id, reactor_class_name)
+          RubyReactor::DispatchResult.new(job_id: job_id, intermediate_results: intermediate_results,
+                                       execution_id: context_id)
+        end
+
+        # One `async_step`'s work, dispatched as its own independent unit. The
+        # payload is identity-only for the same reason every other dispatch here
+        # is: the worker rehydrates the parent context from storage.
+        def self.perform_step_async(root_context_id:, reactor_class_name:, step_context_id:, step_name:)
+          job_id = RubyReactor::Adapters::ActiveJob::StepWorker.perform_async(
+            {
+              "root_context_id" => root_context_id,
+              "reactor_class_name" => reactor_class_name,
+              "step_context_id" => step_context_id,
+              "step_name" => step_name.to_s
+            }
+          )
+          RubyReactor::DispatchResult.new(job_id: job_id)
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def self.perform_map_element_async(map_id:, element_id:, index:, serialized_inputs:, reactor_class_info:,
+                                           strict_ordering:, parent_context_id:, parent_reactor_class_name:,
+                                           step_name:, batch_size: nil, serialized_context: nil, fail_fast: nil)
+          job_id = RubyReactor::Adapters::ActiveJob::MapElementWorker.perform_async(
+            {
+              "map_id" => map_id,
+              "element_id" => element_id,
+              "index" => index,
+              "serialized_inputs" => serialized_inputs,
+              "reactor_class_info" => reactor_class_info,
+              "strict_ordering" => strict_ordering,
+              "parent_context_id" => parent_context_id,
+              "parent_reactor_class_name" => parent_reactor_class_name,
+              "step_name" => step_name,
+              "batch_size" => batch_size,
+              "serialized_context" => serialized_context,
+              "fail_fast" => fail_fast
+            }
+          )
+          RubyReactor::DispatchResult.new(job_id: job_id)
+        end
+
+        def self.perform_map_element_in(delay, map_id:, element_id:, index:, serialized_inputs:,
+                                        reactor_class_info:, strict_ordering:, parent_context_id:,
+                                        parent_reactor_class_name:, step_name:, batch_size: nil,
+                                        serialized_context: nil, fail_fast: nil)
+          job_id = RubyReactor::Adapters::ActiveJob::MapElementWorker.perform_in(
+            delay,
+            {
+              "map_id" => map_id,
+              "element_id" => element_id,
+              "index" => index,
+              "serialized_inputs" => serialized_inputs,
+              "reactor_class_info" => reactor_class_info,
+              "strict_ordering" => strict_ordering,
+              "parent_context_id" => parent_context_id,
+              "parent_reactor_class_name" => parent_reactor_class_name,
+              "step_name" => step_name,
+              "batch_size" => batch_size,
+              "serialized_context" => serialized_context,
+              "fail_fast" => fail_fast
+            }
+          )
+          # Return an DispatchResult so RetryManager#handle_async_retry recognises the
+          # element was successfully requeued and yields a RetryQueuedResult.
+          RubyReactor::DispatchResult.new(job_id: job_id)
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        # rubocop:disable Metrics/ParameterLists
+        def self.perform_map_collection_async(parent_context_id:, map_id:, parent_reactor_class_name:, step_name:,
+                                              strict_ordering:, timeout:)
+          job_id = RubyReactor::Adapters::ActiveJob::MapCollectorWorker.perform_async(
+            {
+              "parent_context_id" => parent_context_id,
+              "map_id" => map_id,
+              "parent_reactor_class_name" => parent_reactor_class_name,
+              "step_name" => step_name,
+              "strict_ordering" => strict_ordering,
+              "timeout" => timeout
+            }
+          )
+          RubyReactor::DispatchResult.new(job_id: job_id)
+        end
+        # rubocop:enable Metrics/ParameterLists
+      end
+    end
+  end
+end

data/lib/ruby_reactor/adapters/active_job/step_worker.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module RubyReactor
+  module Adapters
+    module ActiveJob
+      # ActiveJob counterpart to Sidekiq::StepWorker — binding only.
+      class StepWorker < ::ActiveJob::Base
+        extend Compat
+
+        queue_as { RubyReactor.configuration.queue_name }
+
+        def perform(arguments)
+          RubyReactor::StepWorker.perform(arguments)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/adapters/active_job/sweeper_worker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module RubyReactor
+  module Adapters
+    module ActiveJob
+      class SweeperWorker < ::ActiveJob::Base
+        extend Compat
+        include RubyReactor::SweeperJob
+
+        queue_as { RubyReactor.configuration.queue_name }
+      end
+    end
+  end
+end

data/lib/ruby_reactor/adapters/active_job/worker.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module RubyReactor
+  module Adapters
+    module ActiveJob
+      # ActiveJob worker for executing RubyReactor reactors asynchronously.
+      # All resume/snooze/escalate logic lives in `RubyReactor::Worker` — this
+      # class only wires it to ActiveJob.
+      #
+      # Infra-failure retries only: reactor-specific contention/config errors
+      # are already rescued inside `RubyReactor::Worker#perform` (snoozed or
+      # escalated to `failed`) before they'd ever reach this `retry_on`.
+      class Worker < ::ActiveJob::Base
+        extend Compat
+        include RubyReactor::Worker
+
+        queue_as { RubyReactor.configuration.queue_name }
+        retry_on StandardError, attempts: RubyReactor.configuration.job_retry_count do |job, error|
+          # Attempts exhausted and the job is done for — mark the context
+          # failed and signal any reader waiting on it (mirrors the Sidekiq
+          # adapter's retries-exhausted hook).
+          RubyReactor::Worker.record_retries_exhausted(job.arguments, error)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/adapters/sidekiq/map_collector_worker.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Adapters
+    module Sidekiq
+      class MapCollectorWorker
+        include ::Sidekiq::Worker
+
+        def perform(arguments)
+          RubyReactor::Map::Collector.perform(arguments)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/adapters/sidekiq/map_element_worker.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Adapters
+    module Sidekiq
+      class MapElementWorker
+        include ::Sidekiq::Worker
+
+        def perform(arguments)
+          RubyReactor::Map::ElementExecutor.perform(arguments)
+        end
+      end
+    end
+  end
+end