ruby_reactor 0.5.3 → 0.6.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
@@ -52,6 +52,7 @@ The key value is **Reliability**: if any part of your workflow fails, Ruby React
 - [Installation](#installation)
 - [Configuration](#configuration)
 - [Quick Start](#quick-start)
+- [Defining Steps](#defining-steps)
 - [Web Dashboard](#web-dashboard)
   - [Rails Installation](#rails-installation)
 - [Usage](#usage)
@@ -114,18 +115,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),
@@ -161,10 +165,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) ===
 
@@ -180,8 +185,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
@@ -198,6 +204,60 @@ result = HelloReactor.run
 puts result.value  # => "Hello from Ruby Reactor!"
 ```
 
+> **Note:** Examples in this README use inline `step` blocks where a step is trivial. For production workflows, prefer [class-based steps](#defining-steps).
+
+## Defining Steps
+
+RubyReactor supports two ways to define step logic:
+
+| Style | Best for |
+|-------|----------|
+| **Class steps** (preferred) | Real business logic, compensation/undo, shared steps, testability |
+| **Inline blocks** | Quick prototypes, trivial one-liners, documentation examples |
+
+Whichever style you use, a step's `run` returns one of three signals — all exposed as bare helpers in both class steps and inline blocks:
+
+- **`Success(value)`** — step succeeded; `value` flows to dependent steps.
+- **`Failure(error)`** — step failed; the reactor rolls back completed steps (compensate/undo).
+- **`Skipped(reason:)`** — clean halt: stop the reactor, keep partial progress, **no rollback**. See [Skipping a reactor cleanly](documentation/core_concepts.md#skipping-a-reactor-cleanly).
+
+**Class steps** are plain Ruby classes that include `RubyReactor::Step` and implement `run`, and optionally `compensate` and `undo`:
+
+```ruby
+class ReserveInventoryStep
+  include RubyReactor::Step
+
+  def self.run(arguments, context)
+    reservation_id = InventoryService.reserve(arguments[:order][:items])
+    Success(reservation_id: reservation_id)
+  end
+
+  def self.compensate(error, arguments, context)
+    InventoryService.release_partial(arguments[:order][:items])
+    Success()
+  end
+
+  def self.undo(result, arguments, context)
+    InventoryService.release(result[:reservation_id])
+    Success()
+  end
+end
+
+class OrderProcessingReactor < RubyReactor::Reactor
+  step :reserve_inventory, ReserveInventoryStep do
+    argument :order, result(:validate_order)
+  end
+end
+```
+
+**Why prefer class steps?**
+
+- **Testability** — unit-test `run`, `compensate`, and `undo` in isolation without booting the whole reactor
+- **Composability** — share the same step class across multiple reactors and compose larger workflows from small, focused units
+- **Readability** — reactor files stay orchestration-only; business logic lives in named classes instead of growing inline blocks
+
+See [Core Concepts — Step Classes](documentation/core_concepts.md#step-classes-preferred) for the full reference. Usage examples below mix class and inline steps — inline where the logic is trivial.
+
 ## Web Dashboard
 
 RubyReactor ships with a built-in web dashboard to inspect reactor executions, view logs, and retry failed steps. The dashboard is a Rack app (a [Roda](https://roda.jeremyevans.net/) application) bundled inside the gem with its pre-compiled JS/CSS assets — no extra install or asset build step is required.
@@ -237,60 +297,59 @@ You can secure the dashboard using standard Rails authentication methods (e.g.,
 
 ## Usage
 
-RubyReactor allows you to define complex workflows as "reactors" with steps that can depend on each other, handle failures with compensations, and validate inputs.
+RubyReactor allows you to define complex workflows as "reactors" with steps that can depend on each other, handle failures with compensations, and validate inputs. Examples in this section mix class steps with inline blocks; see [Defining Steps](#defining-steps) for guidance.
 
 ### Basic Example: User Registration
 
 ```ruby
 require 'ruby_reactor'
 
+class ValidateEmailStep
+  include RubyReactor::Step
+
+  def self.run(arguments, _context)
+    email = arguments[:email]
+    email&.include?('@') ? Success(email.strip) : Failure("Email must contain @")
+  end
+end
+
+class CreateUserStep
+  include RubyReactor::Step
+
+  def self.run(arguments, _context)
+    Success(
+      id: rand(10000),
+      email: arguments[:email],
+      password_hash: arguments[:password_hash],
+      created_at: Time.now
+    )
+  end
+
+  def self.compensate(_error, arguments, _context)
+    Notify.to(arguments[:email])
+    Success()
+  end
+end
+
 class UserRegistrationReactor < RubyReactor::Reactor
-  # Define inputs with optional validation
   input :email
   input :password
 
-  # Define steps with their dependencies
-  step :validate_email do
+  step :validate_email, ValidateEmailStep do
     argument :email, input(:email)
-
-    run do |args, context|
-      if args[:email] && args[:email].include?('@')
-        Success(args[:email].strip)
-      else
-        Failure("Email must contain @")
-      end
-    end
   end
 
   step :hash_password do
     argument :password, input(:password)
-
-    run do |args, context|
+    run do |args, _context|
       require 'digest'
-      hashed = Digest::SHA256.hexdigest(args[:password])
-      Success(hashed)
+      Success(Digest::SHA256.hexdigest(args[:password]))
     end
   end
 
-  step :create_user do
-    # Arguments can reference results from other steps
+  step :create_user, CreateUserStep do
     argument :email, result(:validate_email)
     argument :password_hash, result(:hash_password)
-
-    run do |args, context|
-      user = {
-        id: rand(10000),
-        email: args[:email],
-        password_hash: args[:password_hash],
-        created_at: Time.now
-      }
-      Success(user)
-    end
-
-    compensate do |error, args, context|
-      Notify.to(args[:email])
-      Success()
-    end
   end
 
   step :notify_user do
@@ -302,12 +361,12 @@ class UserRegistrationReactor < RubyReactor::Reactor
       Success()
     end
 
-    compensate do |error, args, context|
+    compensate do |_error, args, _context|
       Email.send("support@acme.com", "Email verification for #{args[:email]} couldn't be sent")
       Success()
     end
   end
-  # Specify which step's result to return
+
   returns :create_user
 end
 
@@ -326,7 +385,18 @@ 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
 
@@ -401,8 +471,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
@@ -411,7 +481,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
@@ -545,7 +626,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]}" }
@@ -603,7 +684,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:
 
@@ -613,14 +694,14 @@ result.success?  # true (Skipped is a Success subclass)
 result.skipped?  # true on dedup hit, false otherwise
 ```
 
-A step's `run` block can also return `RubyReactor.Skipped(reason: "...")` to halt the reactor cleanly — remaining steps don't execute, **and already-completed steps are NOT compensated**. Use it when the rest of the workflow is unnecessary and partial progress should be kept (`Failure` is for "stop and roll back").
+A step's `run` block can also return `Skipped(reason: "...")` to halt the reactor cleanly — remaining steps don't execute, **and already-completed steps are NOT compensated**. Use it when the rest of the workflow is unnecessary and partial progress should be kept (`Failure` is for "stop and roll back"). `Skipped` is a bare helper just like `Success`/`Failure` (or use the fully-qualified `RubyReactor.Skipped(...)`).
 
 ```ruby
 step :ensure_active do
   argument :user, result(:fetch_user)
-  run do |args|
-    next RubyReactor.Skipped(reason: "user_opted_out") if args[:user].opted_out?
-    RubyReactor.Success(args[:user])
+  run do |args, _ctx|
+    next Skipped(reason: "user_opted_out") if args[:user].opted_out?
+    Success(args[:user])
   end
 end
 ```
@@ -1089,7 +1170,7 @@ end
 
 ### Testing
 
-RubyReactor provides testing utilities for RSpec. See the [Testing with RSpec](documentation/testing.md) guide for comprehensive documentation.
+RubyReactor provides testing utilities for RSpec. See the [Testing with RSpec](documentation/testing.md) guide for comprehensive documentation — including [unit-testing class-based steps](documentation/testing.md#testing-step-classes) directly.
 
 ```ruby
 RSpec.describe PaymentReactor do
@@ -1116,13 +1197,13 @@ end
 For detailed documentation, see the following guides:
 
 ### [Core Concepts](documentation/core_concepts.md)
-Learn about the fundamental building blocks of RubyReactor: Reactors, Steps, Context, and Results. Understand how steps are defined, how data flows between them, and how the context maintains state throughout execution.
+Learn about the fundamental building blocks of RubyReactor: Reactors, Steps, Context, and Results. Covers class-based steps (the preferred approach) and inline blocks, how data flows between steps, and how the context maintains state throughout execution.
 
 ### [DAG (Directed Acyclic Graph)](documentation/DAG.md)
 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 two asynchronous execution models: Full Reactor Async and Step-Level Async. 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.
@@ -1165,9 +1246,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,91 @@
+# 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::AsyncResult.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::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results,
+                                       execution_id: context_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::AsyncResult.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 AsyncResult so RetryManager#handle_async_retry recognises the
+          # element was successfully requeued and yields a RetryQueuedResult.
+          RubyReactor::AsyncResult.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::AsyncResult.new(job_id: job_id)
+        end
+        # rubocop:enable Metrics/ParameterLists
+      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,24 @@
+# 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
+      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