cdc-parallel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7b66764665f18a0f84cc6b45c5138d932fb000d01be2bef02a26504e7013c5cb
+  data.tar.gz: 12daffb757cae8c4e9c5330cce505cc964834ac205fc89d3febc29944772f815
+SHA512:
+  metadata.gz: e7e3bd0dcd37187e7f31a9930fdea00680f898ce52c31cf33b232004bd9da4ec07cb132fc1bd71a337c7a8db99b7888618d96fc435132e16eb3038e1ddb8588f
+  data.tar.gz: f9af8ecfb077ef1898d312f45169b6b0b81d3ea641af1e9f00374999cd06542bcda7561fc8878b147f61ebcd4c0f5503f88d3f332f1657be19bc45504d77de49

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
+
+## [Unreleased]
+
+### Added
+
+- Placeholder for future development.
+
+## [0.1.0] - 2026-05-31
+
+### Added
+
+- Initial `CDC::Parallel` namespace.
+- Added `CDC::Parallel::Runtime`.
+- Added `CDC::Parallel::ProcessorPool`.
+- Added `CDC::Parallel::TransactionPool`.
+- Added `CDC::Parallel::Router`.
+- Added `CDC::Parallel::ResultCollector`.
+- Added Parallel-safe processor validation.
+- Added support for `CDC::Core::ChangeEvent` processing.
+- Added support for `CDC::Core::TransactionEnvelope` processing.
+- Added graceful shutdown behavior.
+- Added RBS signatures.
+- Added Minitest suite.
+- Added README and example.
+- Added CI and release workflows.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Kenneth C. Demanawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,163 @@
+# cdc-parallel
+
+[![Gem Version](https://badge.fury.io/rb/cdc-parallel.svg)](https://badge.fury.io/rb/cdc-parallel)
+[![CI](https://github.com/kanutocd/cdc-parallel/workflows/CI/badge.svg)](https://github.com/kanutocd/cdc-parallel/actions)
+[![Coverage Status](https://codecov.io/gh/kanutocd/cdc-parallel/branch/main/graph/badge.svg)](https://codecov.io/gh/kanutocd/cdc-parallel)
+[![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)
+
+Optional high-throughput Ractor runtime for `cdc-core`.
+
+`cdc-parallel` executes `CDC::Core::Processor` objects in Ractors when those processors explicitly declare themselves Ractor-safe.
+
+## Requirements
+
+- Ruby 4.0+
+- `cdc-core`
+- `parallel-pool`
+
+Ruby 4.0+ is required because this gem targets the stabilized Ruby Ractor API.
+
+## Purpose
+
+```text
+cdc-core
+   │
+   ▼
+cdc-parallel
+   │
+   ▼
+parallel Parallel-aware processing
+```
+
+`cdc-parallel` is a runtime adapter. It does not define CDC events and does not parse database streams.
+
+## Installation
+
+```ruby
+gem "cdc-parallel"
+```
+
+## Usage
+
+```ruby
+require "cdc/core"
+require "cdc/parallel"
+
+class MetricsProcessor < CDC::Core::Processor
+  ractor_safe!
+
+  def process(event)
+    CDC::Core::ProcessorResult.success(
+      table: event.table,
+      operation: event.operation
+    )
+  end
+end
+
+runtime =
+  CDC::Parallel::Runtime.new(
+    processor: MetricsProcessor.new,
+    size: 4
+  )
+
+result = runtime.process(event)
+
+runtime.shutdown
+```
+
+## Processor Safety
+
+Only processors that declare `ractor_safe!` can run in this runtime.
+
+```ruby
+class AnalyticsProcessor < CDC::Core::Processor
+  ractor_safe!
+end
+```
+
+Unsafe processors raise:
+
+```ruby
+CDC::Parallel::UnsafeProcessorError
+```
+
+## What Belongs Here
+
+- Ractor processor execution
+- Transaction envelope processing
+- Processor safety validation
+- Graceful shutdown
+- Result normalization
+
+## What Does Not Belong Here
+
+- PostgreSQL connection handling
+- pgoutput parsing
+- pgoutput decoding
+- Rails integration
+- Audit persistence
+- Kafka/Redis/S3 publishing
+
+## Ecosystem Position
+
+```text
+cdc-parallel
+      │
+      ▼
+pgoutput-parser
+      │
+      ▼
+pgoutput-decoder
+      │
+      ▼
+cdc-core
+      │
+      ▼
+cdc-parallel
+      │
+      ▼
+whodunit-chronicles
+```
+
+## Roadmap
+
+- Persistent worker pools using `parallel-pool`
+- Mixed `CompositeProcessor` routing
+- Ratomic-backed queues
+- Ratomic-backed metrics
+- Backpressure policies
+- Transaction ordering strategies
+
+
+## Test Organization
+
+The test suite is grouped by intent so the same structure can be reused across CDC ecosystem gems.
+
+```text
+test/unit/          focused class and branch coverage
+test/integration/   component interaction and runtime integration
+test/behavior/      ecosystem contracts and guardrails
+test/performance/   opt-in smoke benchmarks
+```
+
+Run the default quality suite:
+
+```bash
+bundle exec rake test
+```
+
+Run a specific group:
+
+```bash
+bundle exec rake test:unit
+bundle exec rake test:integration
+bundle exec rake test:behavior
+bundle exec rake test:performance
+```
+
+The default `test` task runs unit, integration, and behavior tests. Performance tests are intentionally separate because they are environment-sensitive.
+
+## License
+
+MIT.

data/lib/cdc/parallel/configuration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CDC
+  module Parallel
+    # Immutable configuration for Ractor runtimes.
+    #
+    # @!attribute size
+    #   @return [Integer] worker count.
+    # @!attribute timeout
+    #   @return [Float, nil] optional wait timeout in seconds.
+    class Configuration < Data.define(:size, :timeout)
+      def initialize(size: Etc.nprocessors, timeout: nil)
+        raise ArgumentError, "size must be an Integer" unless size.is_a?(Integer)
+        raise ArgumentError, "size must be greater than zero" unless size.positive?
+
+        super
+        ::Ractor.make_shareable(self)
+      end
+    end
+  end
+end

data/lib/cdc/parallel/errors.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module CDC
+  module Parallel
+    # Base cdc-parallel error.
+    class Error < StandardError; end
+
+    # Raised when a processor has not declared itself Ractor-safe.
+    class UnsafeProcessorError < Error; end
+
+    # Raised when work is submitted after shutdown.
+    class ShutdownError < Error; end
+
+    # Raised when the runtime receives an unsupported work item.
+    class UnsupportedWorkItemError < Error; end
+
+    # Raised when processor execution fails inside a worker Ractor.
+    class ProcessorExecutionError < Error
+      attr_reader :original_class, :original_message, :original_backtrace
+
+      def initialize(original_class:, original_message:, original_backtrace: [])
+        @original_class = original_class
+        @original_message = original_message
+        @original_backtrace = original_backtrace.freeze
+
+        super("#{original_class}: #{original_message}")
+        set_backtrace(@original_backtrace) unless @original_backtrace.empty?
+      end
+    end
+
+    # Raised when a worker does not return a result before timeout.
+    class TimeoutError < Error; end
+  end
+end

data/lib/cdc/parallel/processor_pool.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module CDC
+  module Parallel
+    # Executes one Ractor-safe processor in isolated Ractor workers.
+    #
+    # This v0.1 implementation intentionally uses one-shot worker Ractors for
+    # deterministic synchronous semantics while preserving the public pool API.
+    # The parallel-pool dependency is kept as the runtime foundation for later
+    # async/throughput-focused versions.
+    class ProcessorPool
+      # @param processor [CDC::Core::Processor]
+      # @param size [Integer]
+      # @param timeout [Float, nil]
+      # @return [void]
+      def initialize(processor:, size: Etc.nprocessors, timeout: nil)
+        validate_processor!(processor)
+
+        @processor = ::Ractor.make_shareable(processor)
+        @configuration = Configuration.new(size:, timeout:)
+        @shutdown = false
+      end
+
+      # Process one ChangeEvent.
+      #
+      # @param event [CDC::Core::ChangeEvent]
+      # @return [CDC::Core::ProcessorResult]
+      def process(event)
+        raise ShutdownError, "processor pool has been shut down" if @shutdown
+
+        work = ::Ractor.make_shareable(event)
+        worker = ::Ractor.new(@processor, work) do |processor, item|
+          CDC::Parallel::ResultCollector.normalize(processor.process(item))
+        rescue StandardError => e
+          CDC::Parallel::ResultCollector.worker_failure(e)
+        end
+
+        ResultCollector.normalize(take(worker))
+      end
+
+      # Shut down the pool.
+      #
+      # @return [void]
+      def shutdown
+        @shutdown = true
+      end
+
+      private
+
+      def validate_processor!(processor)
+        return if processor.class.respond_to?(:ractor_safe?) && processor.class.ractor_safe?
+
+        raise UnsafeProcessorError, "#{processor.class} must declare ractor_safe!"
+      end
+
+      def take(worker)
+        if worker.respond_to?(:value)
+          worker.value
+        else
+          worker.take
+        end
+      end
+    end
+  end
+end

data/lib/cdc/parallel/result_collector.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module CDC
+  module Parallel
+    # Normalizes values returned by workers.
+    class ResultCollector
+      FAILURE_MARKER = :__cdc_parallel_failure__
+
+      # Build a shareable failure payload that can safely cross a Ractor boundary.
+      #
+      # @param error [Exception]
+      # @return [Hash]
+      def self.worker_failure(error)
+        ::Ractor.make_shareable(
+          {
+            type: FAILURE_MARKER,
+            class: error.class.name,
+            message: error.message,
+            backtrace: (error.backtrace || []).map { |line| String(line) }.freeze
+          }
+        )
+      end
+
+      # Normalize a worker return value into a ProcessorResult.
+      #
+      # @param value [Object]
+      # @return [CDC::Core::ProcessorResult]
+      def self.normalize(value)
+        if worker_failure?(value)
+          CDC::Core::ProcessorResult.failure(
+            ProcessorExecutionError.new(
+              original_class: value[:class],
+              original_message: value[:message],
+              original_backtrace: value[:backtrace]
+            )
+          )
+        elsif value.is_a?(CDC::Core::ProcessorResult)
+          value
+        else
+          CDC::Core::ProcessorResult.success(value)
+        end
+      end
+
+      def self.worker_failure?(value)
+        value.is_a?(Hash) && value[:type] == FAILURE_MARKER
+      end
+      private_class_method :worker_failure?
+    end
+  end
+end

data/lib/cdc/parallel/router.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CDC
+  module Parallel
+    # Routes supported CDC objects to the correct runtime pool.
+    class Router
+      # @param processor_pool [ProcessorPool]
+      # @param transaction_pool [TransactionPool]
+      def initialize(processor_pool:, transaction_pool:)
+        @processor_pool = processor_pool
+        @transaction_pool = transaction_pool
+      end
+
+      # Process a supported CDC work item.
+      #
+      # @param item [CDC::Core::ChangeEvent, CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process(item)
+        case item
+        when CDC::Core::ChangeEvent
+          @processor_pool.process(item)
+        when CDC::Core::TransactionEnvelope
+          @transaction_pool.process(item)
+        else
+          raise UnsupportedWorkItemError, "unsupported CDC work item: #{item.class}"
+        end
+      end
+    end
+  end
+end

data/lib/cdc/parallel/runtime.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module CDC
+  module Parallel
+    # High-level Ractor runtime facade for cdc-core processors.
+    class Runtime
+      # @param processor [CDC::Core::Processor]
+      # @param size [Integer]
+      # @param timeout [Float, nil]
+      # @return [void]
+      def initialize(processor:, size: Etc.nprocessors, timeout: nil)
+        @processor_pool = ProcessorPool.new(processor:, size:, timeout:)
+        @transaction_pool = TransactionPool.new(processor:, size:, timeout:)
+        @router = Router.new(processor_pool: @processor_pool, transaction_pool: @transaction_pool)
+        @shutdown = false
+      end
+
+      # Process a ChangeEvent or TransactionEnvelope.
+      #
+      # @param item [CDC::Core::ChangeEvent, CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process(item)
+        raise ShutdownError, "runtime has been shut down" if @shutdown
+
+        @router.process(item)
+      end
+
+      # Alias for transaction-oriented processing.
+      #
+      # @param transaction [CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process_transaction(transaction)
+        process(transaction)
+      end
+
+      # Shut down all runtime resources.
+      #
+      # @return [void]
+      def shutdown
+        return if @shutdown
+
+        @shutdown = true
+        @processor_pool.shutdown
+        @transaction_pool.shutdown
+      end
+    end
+  end
+end

data/lib/cdc/parallel/transaction_pool.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CDC
+  module Parallel
+    # Processes a TransactionEnvelope as a single ordering-preserving unit.
+    class TransactionPool
+      # @param processor [CDC::Core::Processor]
+      # @param size [Integer]
+      # @param timeout [Float, nil]
+      def initialize(processor:, size: Etc.nprocessors, timeout: nil)
+        @processor_pool = ProcessorPool.new(processor:, size:, timeout:)
+      end
+
+      # Process all events inside a transaction envelope.
+      #
+      # @param transaction [CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process(transaction)
+        results = transaction.events.map { |event| @processor_pool.process(event) }.freeze
+        ResultCollector.normalize(results)
+      end
+
+      # Shut down worker resources.
+      #
+      # @return [void]
+      def shutdown
+        @processor_pool.shutdown
+      end
+    end
+  end
+end

data/lib/cdc/parallel/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CDC
+  module Parallel
+    # Current cdc-parallel version.
+    VERSION = "0.1.0"
+  end
+end

data/lib/cdc/parallel.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "etc"
+require "ractor-pool"
+
+require_relative "parallel/version"
+require_relative "parallel/errors"
+require_relative "parallel/configuration"
+require_relative "parallel/result_collector"
+require_relative "parallel/processor_pool"
+require_relative "parallel/transaction_pool"
+require_relative "parallel/router"
+require_relative "parallel/runtime"
+
+module CDC
+  # Optional high-throughput Ractor runtime for cdc-core processors.
+  module Parallel
+  end
+end

data/lib/cdc_parallel.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "cdc/parallel"

data/sig/cdc/parallel/configuration.rbs

@@ -0,0 +1,8 @@
+module CDC
+  module Parallel
+    # Immutable configuration for Ractor runtimes.
+    class Configuration
+      def initialize: (?size: untyped, ?timeout: untyped?) -> void
+    end
+  end
+end

data/sig/cdc/parallel/errors.rbs

@@ -0,0 +1,40 @@
+module CDC
+  module Parallel
+    # Base cdc-parallel error.
+    class Error < StandardError
+    end
+
+    # Raised when a processor has not declared itself Ractor-safe.
+    class UnsafeProcessorError < Error
+    end
+
+    # Raised when work is submitted after shutdown.
+    class ShutdownError < Error
+    end
+
+    # Raised when the runtime receives an unsupported work item.
+    class UnsupportedWorkItemError < Error
+    end
+
+    # Raised when processor execution fails inside a worker Ractor.
+    class ProcessorExecutionError < Error
+      @original_class: untyped
+
+      @original_message: untyped
+
+      @original_backtrace: untyped
+
+      attr_reader original_class: untyped
+
+      attr_reader original_message: untyped
+
+      attr_reader original_backtrace: untyped
+
+      def initialize: (original_class: untyped, original_message: untyped, ?original_backtrace: untyped) -> void
+    end
+
+    # Raised when a worker does not return a result before timeout.
+    class TimeoutError < Error
+    end
+  end
+end

data/sig/cdc/parallel/processor_pool.rbs

@@ -0,0 +1,40 @@
+module CDC
+  module Parallel
+    # Executes one Ractor-safe processor in isolated Ractor workers.
+    #
+    # This v0.1 implementation intentionally uses one-shot worker Ractors for
+    # deterministic synchronous semantics while preserving the public pool API.
+    # The parallel-pool dependency is kept as the runtime foundation for later
+    # async/throughput-focused versions.
+    class ProcessorPool
+      @processor: untyped
+
+      @configuration: untyped
+
+      @shutdown: untyped
+
+      # @param processor [CDC::Core::Processor]
+      # @param size [Integer]
+      # @param timeout [Float, nil]
+      # @return [void]
+      def initialize: (processor: untyped, ?size: untyped, ?timeout: untyped?) -> void
+
+      # Process one ChangeEvent.
+      #
+      # @param event [CDC::Core::ChangeEvent]
+      # @return [CDC::Core::ProcessorResult]
+      def process: (untyped event) -> untyped
+
+      # Shut down the pool.
+      #
+      # @return [void]
+      def shutdown: () -> untyped
+
+      private
+
+      def validate_processor!: (untyped processor) -> (nil | untyped)
+
+      def take: (untyped worker) -> untyped
+    end
+  end
+end

data/sig/cdc/parallel/result_collector.rbs

@@ -0,0 +1,22 @@
+module CDC
+  module Parallel
+    # Normalizes values returned by workers.
+    class ResultCollector
+      FAILURE_MARKER: :__cdc_parallel_failure__
+
+      # Build a shareable failure payload that can safely cross a Ractor boundary.
+      #
+      # @param error [Exception]
+      # @return [Hash]
+      def self.worker_failure: (untyped error) -> untyped
+
+      # Normalize a worker return value into a ProcessorResult.
+      #
+      # @param value [Object]
+      # @return [CDC::Core::ProcessorResult]
+      def self.normalize: (untyped value) -> untyped
+
+      def self.worker_failure?: (untyped value) -> untyped
+    end
+  end
+end

data/sig/cdc/parallel/router.rbs

@@ -0,0 +1,20 @@
+module CDC
+  module Parallel
+    # Routes supported CDC objects to the correct runtime pool.
+    class Router
+      @processor_pool: untyped
+
+      @transaction_pool: untyped
+
+      # @param processor_pool [ProcessorPool]
+      # @param transaction_pool [TransactionPool]
+      def initialize: (processor_pool: untyped, transaction_pool: untyped) -> void
+
+      # Process a supported CDC work item.
+      #
+      # @param item [CDC::Core::ChangeEvent, CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process: (untyped item) -> untyped
+    end
+  end
+end

data/sig/cdc/parallel/runtime.rbs

@@ -0,0 +1,37 @@
+module CDC
+  module Parallel
+    # High-level Ractor runtime facade for cdc-core processors.
+    class Runtime
+      @processor_pool: untyped
+
+      @transaction_pool: untyped
+
+      @router: untyped
+
+      @shutdown: untyped
+
+      # @param processor [CDC::Core::Processor]
+      # @param size [Integer]
+      # @param timeout [Float, nil]
+      # @return [void]
+      def initialize: (processor: untyped, ?size: untyped, ?timeout: untyped?) -> void
+
+      # Process a ChangeEvent or TransactionEnvelope.
+      #
+      # @param item [CDC::Core::ChangeEvent, CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process: (untyped item) -> untyped
+
+      # Alias for transaction-oriented processing.
+      #
+      # @param transaction [CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process_transaction: (untyped transaction) -> untyped
+
+      # Shut down all runtime resources.
+      #
+      # @return [void]
+      def shutdown: () -> (nil | untyped)
+    end
+  end
+end

data/sig/cdc/parallel/transaction_pool.rbs

@@ -0,0 +1,24 @@
+module CDC
+  module Parallel
+    # Processes a TransactionEnvelope as a single ordering-preserving unit.
+    class TransactionPool
+      @processor_pool: untyped
+
+      # @param processor [CDC::Core::Processor]
+      # @param size [Integer]
+      # @param timeout [Float, nil]
+      def initialize: (processor: untyped, ?size: untyped, ?timeout: untyped?) -> void
+
+      # Process all events inside a transaction envelope.
+      #
+      # @param transaction [CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process: (untyped transaction) -> untyped
+
+      # Shut down worker resources.
+      #
+      # @return [void]
+      def shutdown: () -> untyped
+    end
+  end
+end

data/sig/cdc/parallel/version.rbs

@@ -0,0 +1,6 @@
+module CDC
+  module Parallel
+    # Current cdc-parallel version.
+    VERSION: "0.1.0"
+  end
+end

data/sig/cdc/parallel.rbs

@@ -0,0 +1,5 @@
+module CDC
+  # Optional high-throughput Ractor runtime for cdc-core processors.
+  module Parallel
+  end
+end

data/sig/shims/cdc_core.rbs

@@ -0,0 +1,14 @@
+module CDC
+  module Core
+    class ProcessorResult
+      def self.success: (untyped event) -> ProcessorResult
+      def self.failure: (untyped error) -> ProcessorResult
+    end
+
+    class ChangeEvent
+    end
+
+    class TransactionEnvelope
+    end
+  end
+end

data/sig/shims/etc.rbs

@@ -0,0 +1,3 @@
+module Etc
+  def self.nprocessors: () -> Integer
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: cdc-parallel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ken C. Demanawa
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cdc-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: ractor-pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+description: |
+  cdc-parallel provides optional Ractor-backed parallel execution for
+  cdc-core. It accelerates Change Data Capture (CDC) pipelines while
+  preserving the simplicity and composability of the CDC Ecosystem.
+email:
+- kenneth.c.demanawa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/cdc/parallel.rb
+- lib/cdc/parallel/configuration.rb
+- lib/cdc/parallel/errors.rb
+- lib/cdc/parallel/processor_pool.rb
+- lib/cdc/parallel/result_collector.rb
+- lib/cdc/parallel/router.rb
+- lib/cdc/parallel/runtime.rb
+- lib/cdc/parallel/transaction_pool.rb
+- lib/cdc/parallel/version.rb
+- lib/cdc_parallel.rb
+- sig/cdc/parallel.rbs
+- sig/cdc/parallel/configuration.rbs
+- sig/cdc/parallel/errors.rbs
+- sig/cdc/parallel/processor_pool.rbs
+- sig/cdc/parallel/result_collector.rbs
+- sig/cdc/parallel/router.rbs
+- sig/cdc/parallel/runtime.rbs
+- sig/cdc/parallel/transaction_pool.rbs
+- sig/cdc/parallel/version.rbs
+- sig/cdc_parallel.rbs
+- sig/shims/cdc_core.rbs
+- sig/shims/data_define.rbs
+- sig/shims/etc.rbs
+homepage: https://kanutocd.github.io/cdc-parallel/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://kanutocd.github.io/cdc-parallel/
+  source_code_uri: https://github.com/kanutocd/cdc-parallel
+  changelog_uri: https://github.com/kanutocd/cdc-parallel/blob/main/CHANGELOG.md
+  documentation_uri: https://kanutocd.github.io/cdc-parallel/
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Optional parallel runtime for the CDC Ecosystem.
+test_files: []