cdc-sidekiq 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a814eddfc8362aa6e2ad54cf09a8034398327d23626aca65887a5fcee4d8b8cf
-  data.tar.gz: 175152c36354bf40d5831e0812c8d59eae68e5865c265e8c18e0a07ceb14d42e
+  metadata.gz: 70f11806851d7d2e2476a302db30f6ef923c1b503d7571b09618d7606e6e1958
+  data.tar.gz: 36d27831e42392428b70d35ae8c4bd9847ae3212db5051dc47b6745fec3e641c
 SHA512:
-  metadata.gz: ee9285ba79a7c605dd9d43bc251e3352bdb811ec919df7377b1379660dc638b8f35519a11581830ce1a295fe15147fe17ad2f3bae9ce1d6221d134bc0fc93088
-  data.tar.gz: b3739c02f483d35c4c447417743855ef462d5c07c2c0254e9aec50bb88846257ffa58c5ec3b46be50c24c866d02bfb6c0350d92029e2eaeee07455b627bf0b05
+  metadata.gz: 4b988f64c6395cd2ea1104cdb2e7b5cc0160dac42de5f3fe1b6125adfedf381144206df6be2bf1bdc3a70dee2a40db85f4f7f2fa4125def3b123e6ec7854f111
+  data.tar.gz: 2f1c8cc7ed74c14edae32ce0b96f1cc64d0d6739af7908c5d4d4957a402122d8348b5ba00f09fcb51b5bd81886d6ce76fbe3857d232fb88ea51ecfa0d264f4b6

data/CHANGELOG.md

@@ -1,8 +1,15 @@
 ## [Unreleased]
 
+## [0.1.1] - 2026-06-12
+
 - Improved unit test coverage for runtime selection, configuration copying, class-level job declarations, failure policies, and batch payload behavior.
+- Added RBS signatures and validation coverage for the public cdc-sidekiq API.
+- Fixed RBS validation issues around stdlib `Etc`, `default_runtime`, and dynamic processor-job class helpers.
+- Documented all configuration defaults, including `raise_on_failure` and `batch_payloads`.
 - Expanded benchmark documentation with the 500,000-item Ruby 4.0.5 snapshot, interpretation, and runtime tuning guidance.
+- Clarified benchmark prerequisites, runtime knobs, and snapshot variance notes.
 - Documented runtime-selection guidance and the shared-state correctness boundary between cdc-sidekiq and consumer processors/sinks.
+- Filled missing YARD tag descriptions for void-returning APIs.
 - Updated gem metadata documentation URI and description.
 
 

data/README.md

@@ -1,5 +1,10 @@
 # cdc-sidekiq
 
+[![Gem Version](https://badge.fury.io/rb/cdc-sidekiq.svg)](https://badge.fury.io/rb/cdc-sidekiq)
+[![CI](https://github.com/kanutocd/cdc-sidekiq/workflows/CI/badge.svg)](https://github.com/kanutocd/cdc-sidekiq/actions)
+[![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.4-ruby.svg)](https://www.ruby-lang.org/en/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 `cdc-sidekiq` integrates Sidekiq with CDC execution primitives.
 
 Sidekiq remains the durable job system. It owns scheduling, retries, queues, Redis persistence, and operational behavior.
@@ -11,6 +16,9 @@ Sidekiq Job
       |
       v
 CDC::Sidekiq::ProcessorJob
+      |
+      +--> :direct
+      |       sequential processor calls
       |
       +--> cdc-parallel
       |       Ractor fan-out / fan-in
@@ -59,7 +67,7 @@ CDC primitives execute the work.
 
 The open-source edition focuses on execution primitives.
 
-Current and planned OSS capabilities:
+Current OSS capabilities:
 
 - `:direct` runtime
 - `:concurrent` runtime
@@ -85,7 +93,7 @@ cdc-sidekiq
 cdc-orchestrator-pro
     Hybrid runtime
     Nested runtime / worker-local resource pools
-    orchestration, backpressure, telemetry, tuning
+    Orchestration, backpressure, telemetry, tuning
 ```
 
 This keeps the OSS gem small and useful while leaving operational orchestration to the commercial layer.
@@ -136,9 +144,9 @@ Runtime support depends on the selected CDC execution substrate:
 
 | Runtime | Ruby | Required gems |
 | --- | --- | --- |
-| `:direct` | 3.4+ | `cdc-core` |
-| `:concurrent` | 3.4+ | `cdc-core`, `cdc-concurrent` |
-| `:parallel` | 4.0+ | `cdc-core`, `cdc-parallel` |
+| `:direct` | 3.4+ | `sidekiq`, `cdc-core` |
+| `:concurrent` | 3.4+ | `sidekiq`, `cdc-core`, `cdc-concurrent` |
+| `:parallel` | 4.0+ | `sidekiq`, `cdc-core`, `cdc-parallel` |
 
 `cdc-parallel` remains optional because it requires Ruby 4+. Ruby 3.4 users can still use `:direct` and `:concurrent`.
 
@@ -151,10 +159,12 @@ gem "cdc-sidekiq"
 Runtime gems are installed by the application according to the execution model it uses:
 
 ```ruby
-gem "cdc-parallel"   # for Ractor-backed execution
 gem "cdc-concurrent" # for Async-backed execution
+gem "cdc-parallel"   # for Ractor-backed execution
 ```
 
+Applications that only use `:direct` do not need either optional runtime gem.
+
 ## Configuration
 
 ```ruby
@@ -165,10 +175,24 @@ Sidekiq.configure_server do |_config|
     cdc.concurrency = 100
     cdc.timeout = nil
     cdc.preserve_order = true
+    cdc.raise_on_failure = true
+    cdc.batch_payloads = true
   end
 end
 ```
 
+Configuration defaults:
+
+| Option | Default | Meaning |
+| --- | --- | --- |
+| `default_runtime` | `:concurrent` | Runtime used when a job does not declare `cdc_runtime`. |
+| `parallel_size` | `Etc.nprocessors - 1`, minimum `1` | Ractor worker count for `:parallel` jobs. |
+| `concurrency` | `100` | Async task limit for `:concurrent` jobs. |
+| `timeout` | `nil` | Optional per-item timeout passed to CDC processor pools. |
+| `preserve_order` | `true` | Preserve input order for `:concurrent` result arrays. |
+| `raise_on_failure` | `true` | Raise failed `ProcessorResult` objects so Sidekiq can retry. |
+| `batch_payloads` | `true` | Process array payloads with `process_many` instead of treating the array as one item. |
+
 Sidekiq concurrency and CDC runtime concurrency are intentionally separate.
 
 ```text
@@ -275,7 +299,6 @@ class BestEffortJob
 end
 ```
 
-
 ## Benchmarking
 
 `cdc-sidekiq` includes `bin/cdc-sidekiq-load`, a benchmark aligned with Sidekiq's `bin/sidekiq-load` style.
@@ -292,7 +315,7 @@ COUNT=500000 RUNTIME=parallel CDC_PARALLEL_SIZE=7 \
   bundle exec bin/cdc-sidekiq-load
 ```
 
-See [`benchmark/README.md`](benchmark/README.md) for interpretation notes and all benchmark knobs.
+See [`benchmark/README.md`](https://github.com/kanutocd/cdc-sidekiq/tree/main/benchmark) for interpretation notes and all benchmark knobs.
 
 ## Current scope
 

data/benchmark/README.md

@@ -22,6 +22,8 @@ process_many(items)
 
 This benchmark does **not** replace Sidekiq's Redis-backed load benchmark. It measures the inner execution primitive that a CDC-aware Sidekiq job can use after Sidekiq has already started the job.
 
+Run the benchmark from the gem checkout with `bundle exec`. It does not require Redis or a running Sidekiq process, but the selected optional runtime gem must be installed when using `RUNTIME=concurrent` or `RUNTIME=parallel`.
+
 ## Examples
 
 ```bash
@@ -47,10 +49,10 @@ COUNT=500000 RUNTIME=parallel CDC_PARALLEL_SIZE=7 \
 | `BATCH_SIZE` | Number of items per `process_many` call | `COUNT` |
 | `RUNTIME` | `direct`, `concurrent`, or `parallel` | `concurrent` |
 | `CDC_CONCURRENCY` | Async task limit for `cdc-concurrent` | `100` |
-| `CDC_PARALLEL_SIZE` | Ractor worker count for `cdc-parallel` | `Etc.nprocessors - 1` |
-| `CDC_TIMEOUT` | Per-item timeout in seconds | unset |
-| `PRESERVE_ORDER` | Preserve result order for concurrent runtime | `true` |
-| `WARMUP` | Warmup items before timing | `min(COUNT / 50, 10000)` |
+| `CDC_PARALLEL_SIZE` | Ractor worker count for `cdc-parallel` | `Etc.nprocessors - 1`, minimum `1` |
+| `CDC_TIMEOUT` | Per-item timeout in seconds | `nil` |
+| `PRESERVE_ORDER` | Preserve result order for the `:concurrent` runtime | `true` |
+| `WARMUP` | Warmup items before timing | `min(COUNT / 50, 10_000)` |
 | `JSON` | Print machine-readable JSON when set to `1` | unset |
 
 ## Snapshot: 500,000 No-op Items
@@ -70,10 +72,12 @@ Results:
 | Runtime | Knobs | Elapsed | Throughput | GC count |
 | --- | --- | ---: | ---: | ---: |
 | `direct` | default direct execution | `0.085821 sec` | `5,826,083 items/sec` | `0` |
-| `parallel` | `CDC_PARALLEL_SIZE=7` | `6.613177 sec` | `75,607 items/sec` | `58` |
-| `parallel` | `CDC_PARALLEL_SIZE=7` | `5.830767 sec` | `85,752 items/sec` | `44` |
+| `parallel` | `CDC_PARALLEL_SIZE=7`, run 1 | `6.613177 sec` | `75,607 items/sec` | `58` |
+| `parallel` | `CDC_PARALLEL_SIZE=7`, run 2 | `5.830767 sec` | `85,752 items/sec` | `44` |
 | `concurrent` | `CDC_CONCURRENCY=100` | `12.667181 sec` | `39,472 items/sec` | `45` |
 
+The duplicate `parallel` rows are separate sample runs with the same settings. Keep that variance in mind when comparing small differences between runtimes.
+
 ## Interpretation
 
 This snapshot is intentionally a no-op workload. It is useful for measuring runtime overhead, not real downstream work.
@@ -123,6 +127,8 @@ CDC_CONCURRENCY=25
 
 then increase gradually. A concurrency value of `100` can be reasonable for I/O-bound workloads, but it is pure overhead for no-op work.
 
+When comparing results, keep `COUNT`, `BATCH_SIZE`, Ruby version, CPU count, and runtime gem versions fixed. Changing any of those can shift the result more than a runtime tuning change.
+
 ## Benchmark Rule of Thumb
 
 ```text

data/lib/cdc/sidekiq/configuration.rb

@@ -32,7 +32,7 @@ module CDC
       # @return [Boolean] whether array payloads should be processed with #process_many by default.
       attr_accessor :batch_payloads
 
-      # @return [void]
+      # @return [void] returns nothing.
       def initialize
         @default_runtime = :concurrent
         @parallel_size = [Etc.nprocessors - 1, 1].max

data/lib/cdc/sidekiq/errors.rb

@@ -17,7 +17,7 @@ module CDC
       attr_reader :failures
 
       # @param failures [Array<Object>] failed processor results that should be exposed to Sidekiq retry handling.
-      # @return [void]
+      # @return [void] returns nothing.
       def initialize(failures)
         @failures = failures.freeze
         super("CDC processor failed for #{failures.length} item(s)")

data/lib/cdc/sidekiq/processor_job.rb

@@ -30,7 +30,7 @@ module CDC
       # Add CDC processor-job class methods to the including job class.
       #
       # @param base [Class] Sidekiq job class including this module.
-      # @return [void]
+      # @return [void] returns nothing.
       def self.included(base)
         base.extend(ClassMethods)
       end
@@ -53,8 +53,10 @@ module CDC
       private
 
       def process_payload(payload)
-        runtime = self.class.__cdc_sidekiq_runtime
-        if payload.is_a?(Array) && self.class.__cdc_sidekiq_batch_payloads
+        job_class = self.class
+        # @type var job_class: untyped
+        runtime = job_class.__cdc_sidekiq_runtime
+        if payload.is_a?(Array) && job_class.__cdc_sidekiq_batch_payloads
           runtime.process_many(payload)
         else
           runtime.process(payload)
@@ -62,9 +64,14 @@ module CDC
       end
 
       def handle_processor_failures(results)
-        return unless self.class.__cdc_sidekiq_raise_on_failure
+        job_class = self.class
+        # @type var job_class: untyped
+        return unless job_class.__cdc_sidekiq_raise_on_failure
 
-        failures = Array(results).select { |result| result.respond_to?(:failure?) && result.failure? }
+        failures = Array(results).select do |result|
+          # @type var result: untyped
+          result.respond_to?(:failure?) && result.failure?
+        end
         raise ProcessorFailureError, failures unless failures.empty?
       end
 
@@ -179,7 +186,7 @@ module CDC
 
         def __cdc_sidekiq_processor
           processor = @cdc_processor
-          raise MissingProcessorError, "#{name} must declare cdc_processor" unless processor
+          raise MissingProcessorError, "#{__send__(:name)} must declare cdc_processor" unless processor
 
           processor.is_a?(Class) ? processor.new : processor
         end

data/lib/cdc/sidekiq/runtime.rb

@@ -14,7 +14,7 @@ module CDC
       # @param concurrency [Integer] number of Async tasks used by cdc-concurrent.
       # @param timeout [Float, nil] optional timeout passed to the selected runtime.
       # @param preserve_order [Boolean] whether cdc-concurrent should preserve input order.
-      # @return [void]
+      # @return [void] returns nothing.
       def initialize(processor:, runtime:, parallel_size:, concurrency:, timeout:, preserve_order:)
         @processor = processor
         @runtime = runtime.to_sym
@@ -69,7 +69,7 @@ module CDC
       # Minimal runtime used for tests and simple sequential execution.
       class DirectPool
         # @param processor [Object] CDC processor object that responds to #process.
-        # @return [void]
+        # @return [void] returns nothing.
         def initialize(processor)
           @processor = processor
         end

data/lib/cdc/sidekiq/version.rb

@@ -3,6 +3,6 @@
 module CDC
   module Sidekiq
     # Current cdc-sidekiq gem version.
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/sig/cdc/sidekiq/configuration.rbs

@@ -0,0 +1,54 @@
+module CDC
+  module Sidekiq
+    # Runtime defaults shared by CDC-aware Sidekiq jobs.
+    #
+    # The configuration intentionally describes only the CDC execution layer.
+    # Sidekiq still owns queue selection, scheduling, retries, durability, and
+    # job concurrency. cdc-sidekiq owns runtime selection for work performed
+    # inside a Sidekiq job.
+    class Configuration
+      @default_runtime: Symbol
+
+      @parallel_size: Integer
+
+      @concurrency: Integer
+
+      @timeout: Float?
+
+      @preserve_order: bool
+
+      @raise_on_failure: bool
+
+      @batch_payloads: bool
+
+      # @return [Symbol] default runtime used when a job does not declare one.
+      attr_accessor default_runtime: Symbol
+
+      # @return [Integer] default number of Ractor workers for cdc-parallel jobs.
+      attr_accessor parallel_size: Integer
+
+      # @return [Integer] default number of Async tasks for cdc-concurrent jobs.
+      attr_accessor concurrency: Integer
+
+      # @return [Float, nil] default per-item timeout passed to CDC processor pools.
+      attr_accessor timeout: Float?
+
+      # @return [Boolean] default result-ordering policy for cdc-concurrent jobs.
+      attr_accessor preserve_order: bool
+
+      # @return [Boolean] default failure policy for processor jobs.
+      attr_accessor raise_on_failure: bool
+
+      # @return [Boolean] whether array payloads should be processed with #process_many by default.
+      attr_accessor batch_payloads: bool
+
+      # @return [void]
+      def initialize: () -> void
+
+      # Build an immutable copy so job-level overrides cannot mutate globals.
+      #
+      # @return [Configuration] independent copy of this configuration.
+      def dup: () -> Configuration
+    end
+  end
+end

data/sig/cdc/sidekiq/errors.rbs

@@ -0,0 +1,27 @@
+module CDC
+  module Sidekiq
+    # Base error for all cdc-sidekiq failures.
+    class Error < StandardError
+    end
+
+    # Raised when a job declares an unsupported CDC runtime.
+    class UnsupportedRuntimeError < Error
+    end
+
+    # Raised when a Sidekiq processor job does not declare a processor.
+    class MissingProcessorError < Error
+    end
+
+    # Raised when processor execution returns one or more failed results.
+    class ProcessorFailureError < Error
+      @failures: untyped
+
+      # @return [Array<Object>] failed processor results that triggered the error.
+      attr_reader failures: Array[untyped]
+
+      # @param failures [Array<Object>] failed processor results that should be exposed to Sidekiq retry handling.
+      # @return [void]
+      def initialize: (Array[untyped] failures) -> void
+    end
+  end
+end

data/sig/cdc/sidekiq/processor_job.rbs

@@ -0,0 +1,155 @@
+module CDC
+  module Sidekiq
+    # Sidekiq job mixin that executes work through CDC runtime primitives.
+    #
+    # The job remains a normal Sidekiq job. Sidekiq still owns scheduling,
+    # retries, queues, and persistence. cdc-sidekiq only changes how the job
+    # executes its payload once Sidekiq has started the job.
+    #
+    # @example Process many items through cdc-parallel
+    #   class ReindexUsersJob
+    #     include Sidekiq::Job
+    #     include CDC::Sidekiq::ProcessorJob
+    #
+    #     cdc_processor UserIndexer
+    #     cdc_runtime :parallel
+    #   end
+    #
+    # @example Process I/O-heavy items through cdc-concurrent
+    #   class DeliverWebhooksJob
+    #     include Sidekiq::Job
+    #     include CDC::Sidekiq::ProcessorJob
+    #
+    #     cdc_processor WebhookDeliverer
+    #     cdc_runtime :concurrent
+    #     cdc_concurrency 250
+    #   end
+    module ProcessorJob
+      # Add CDC processor-job class methods to the including job class.
+      #
+      # @param base [Class] Sidekiq job class including this module.
+      # @return [void]
+      def self.included: (untyped base) -> untyped
+
+      # Execute a Sidekiq payload through the configured CDC runtime.
+      #
+      # Array payloads are processed with #process_many when cdc_batch_payloads
+      # is enabled. Other payloads are processed with #process.
+      #
+      # @param payload [Object, Array<Object>] Sidekiq job payload or batch payload.
+      # @return [Object, Array<Object>] CDC processor result or frozen result array.
+      # @raise [MissingProcessorError] when the job does not declare a CDC processor.
+      # @raise [ProcessorFailureError] when raise-on-failure is enabled and one or more results failed.
+      def perform: (untyped payload) -> untyped
+
+      private
+
+      def process_payload: (untyped payload) -> untyped
+
+      def handle_processor_failures: (untyped results) -> (nil | untyped)
+
+      # Class-level declaration helpers for CDC-aware Sidekiq jobs.
+      module ClassMethods
+        @cdc_processor: untyped
+
+        @cdc_runtime: untyped
+
+        @cdc_parallel_size: untyped
+
+        @cdc_concurrency: untyped
+
+        @cdc_timeout: untyped
+
+        @cdc_preserve_order: untyped
+
+        @cdc_batch_payloads: untyped
+
+        @cdc_raise_on_failure: untyped
+
+        # Declare or read the processor used by this job.
+        #
+        # @param value [Class, Object, nil] processor class or processor instance.
+        # @return [Class, Object, nil] configured processor when called without an argument.
+        def cdc_processor: () -> untyped
+                         | (untyped value) -> untyped
+
+        # Declare or read the CDC runtime used by this job.
+        #
+        # @param value [Symbol, String, nil] runtime name, such as :parallel, :concurrent, or :direct.
+        # @return [Symbol, nil] configured runtime when called without an argument.
+        def cdc_runtime: () -> Symbol?
+                       | (Symbol | String value) -> Symbol
+
+        # Declare or read the cdc-parallel worker count for this job.
+        #
+        # @param value [Integer, nil] number of Ractor workers for this job.
+        # @return [Integer, nil] configured worker count when called without an argument.
+        def cdc_parallel_size: () -> Integer?
+                             | (Integer value) -> Integer
+
+        # Declare or read the cdc-concurrent task concurrency for this job.
+        #
+        # @param value [Integer, nil] maximum Async task count for this job.
+        # @return [Integer, nil] configured concurrency when called without an argument.
+        def cdc_concurrency: () -> Integer?
+                          | (Integer value) -> Integer
+
+        # Declare or read the runtime timeout for this job.
+        #
+        # @param value [Float, Integer, nil] timeout in seconds, or nil for no timeout.
+        # @return [Float, nil] configured timeout when called without an argument.
+        def cdc_timeout: () -> Float?
+                      | (Numeric? value) -> Float?
+
+        # Declare or read result ordering for cdc-concurrent.
+        #
+        # @param value [Boolean, nil] true to preserve input order, false to keep completion order.
+        # @return [Boolean, nil] configured ordering policy when called without an argument.
+        def cdc_preserve_order: () -> bool?
+                             | (bool value) -> bool
+
+        # Declare or read whether array payloads use #process_many.
+        #
+        # @param value [Boolean, nil] true to batch array payloads, false to process the array as one item.
+        # @return [Boolean, nil] configured batching policy when called without an argument.
+        def cdc_batch_payloads: () -> bool?
+                             | (bool value) -> bool
+
+        # Declare or read whether failed ProcessorResult objects raise.
+        #
+        # @param value [Boolean, nil] true to raise on failed results so Sidekiq retries the job.
+        # @return [Boolean, nil] configured failure policy when called without an argument.
+        def cdc_raise_on_failure: () -> bool?
+                               | (bool value) -> bool
+
+        # Build the runtime used by one Sidekiq job invocation.
+        #
+        # @return [Runtime] runtime configured for this job class.
+        # @raise [MissingProcessorError] when no processor has been declared.
+        def __cdc_sidekiq_runtime: () -> Runtime
+
+        # @return [Boolean] true when array payloads should use #process_many.
+        def __cdc_sidekiq_batch_payloads: () -> bool
+
+        # @return [Boolean] true when failed results should raise.
+        def __cdc_sidekiq_raise_on_failure: () -> bool
+
+        private
+
+        def __cdc_sidekiq_processor: () -> untyped
+
+        def __cdc_sidekiq_runtime_name: () -> untyped
+
+        def __cdc_sidekiq_parallel_size: () -> untyped
+
+        def __cdc_sidekiq_concurrency: () -> untyped
+
+        def __cdc_sidekiq_timeout: () -> untyped
+
+        def __cdc_sidekiq_preserve_order: () -> untyped
+
+        def configured_boolean: (untyped value, untyped fallback) -> untyped
+      end
+    end
+  end
+end

data/sig/cdc/sidekiq/runtime.rbs

@@ -0,0 +1,85 @@
+module CDC
+  module Sidekiq
+    # Executes a CDC processor through one of the CDC runtime primitives.
+    #
+    # Runtime is intentionally selected outside Sidekiq's own concurrency
+    # setting. Sidekiq concurrency controls how many jobs run at once. This
+    # object controls how one CDC-aware job fans work out internally.
+    class Runtime
+      @processor: untyped
+
+      @runtime: untyped
+
+      @parallel_size: untyped
+
+      @concurrency: untyped
+
+      @timeout: untyped
+
+      @preserve_order: untyped
+
+      # @param processor [Object] CDC processor object that responds to #process.
+      # @param runtime [Symbol] execution runtime, currently :parallel, :concurrent, or :direct.
+      # @param parallel_size [Integer] number of Ractors used by cdc-parallel.
+      # @param concurrency [Integer] number of Async tasks used by cdc-concurrent.
+      # @param timeout [Float, nil] optional timeout passed to the selected runtime.
+      # @param preserve_order [Boolean] whether cdc-concurrent should preserve input order.
+      # @return [void]
+            def initialize: (
+        processor: untyped,
+        runtime: Symbol | String,
+        parallel_size: Integer,
+        concurrency: Integer,
+        timeout: Float?,
+        preserve_order: bool
+      ) -> void
+
+      # Process one work item through the selected runtime.
+      #
+      # @param item [Object] work item passed to the processor.
+      # @return [Object] processor result returned by the selected runtime.
+      def process: (untyped item) -> untyped
+
+      # Process many work items through the selected runtime.
+      #
+      # @param items [Array<Object>] work items passed to the processor.
+      # @return [Array<Object>] processor results returned by the selected runtime.
+      def process_many: (Array[untyped] items) -> Array[untyped]
+
+      private
+
+      attr_reader processor: untyped
+
+      attr_reader runtime: Symbol
+
+      attr_reader parallel_size: Integer
+
+      attr_reader concurrency: Integer
+
+      attr_reader timeout: Float?
+
+      attr_reader preserve_order: bool
+
+      def with_pool: () { (untyped) -> untyped } -> untyped
+
+      def build_pool: () -> untyped
+
+      # Minimal runtime used for tests and simple sequential execution.
+      class DirectPool
+        @processor: untyped
+
+        # @param processor [Object] CDC processor object that responds to #process.
+        # @return [void]
+        def initialize: (untyped processor) -> void
+
+        # @param item [Object] work item passed to the processor.
+        # @return [Object] processor result returned by the processor.
+        def process: (untyped item) -> untyped
+
+        # @param items [Array<Object>] work items passed to the processor.
+        # @return [Array<Object>] processor results returned by the processor.
+        def process_many: (Array[untyped] items) -> Array[untyped]
+      end
+    end
+  end
+end

data/sig/cdc/sidekiq/version.rbs

@@ -0,0 +1,6 @@
+module CDC
+  module Sidekiq
+    # Current cdc-sidekiq gem version.
+    VERSION: "0.1.1"
+  end
+end

data/sig/cdc/sidekiq.rbs

@@ -0,0 +1,22 @@
+module CDC
+  # Integration layer between Sidekiq and CDC execution primitives.
+  module Sidekiq
+    self.@configuration: Configuration
+
+    # Read the process-wide cdc-sidekiq configuration.
+    #
+    # @return [Configuration] mutable global configuration object.
+    def self.configuration: () -> Configuration
+
+    # Configure process-wide defaults for CDC-aware Sidekiq jobs.
+    #
+    # @yieldparam configuration [Configuration] mutable configuration object.
+    # @return [Configuration] configured global configuration object.
+    def self.configure: () ?{ (Configuration) -> void } -> Configuration
+
+    # Reset process-wide configuration to defaults.
+    #
+    # @return [Configuration] new default configuration object.
+    def self.reset_configuration!: () -> Configuration
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cdc-sidekiq
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -13,30 +13,30 @@ dependencies:
   name: cdc-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8.1'
 description: |
   Adds CDC-aware processor jobs and runtime selection to Sidekiq,
   allowing selected jobs to execute payloads directly, through cdc-parallel, or through cdc-concurrent.
@@ -57,6 +57,13 @@ files:
 - lib/cdc/sidekiq/runtime.rb
 - lib/cdc/sidekiq/version.rb
 - lib/cdc_sidekiq.rb
+- sig/cdc/sidekiq.rbs
+- sig/cdc/sidekiq/configuration.rbs
+- sig/cdc/sidekiq/errors.rbs
+- sig/cdc/sidekiq/processor_job.rbs
+- sig/cdc/sidekiq/runtime.rbs
+- sig/cdc/sidekiq/version.rbs
+- sig/cdc_sidekiq.rbs
 homepage: https://github.com/kanutocd/cdc-sidekiq
 licenses:
 - MIT