ractor_shepherd 0.1.0

data/lib/ractor_shepherd/spec.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module RactorShepherd
+  # What a child is. Immutable and shareable.
+  #
+  # - `type`: `:worker` or `:supervisor`
+  # - `start`: a Class for a worker, a {SupervisorSpec} for a supervisor
+  ChildSpec = Data.define(:id, :type, :start, :args, :kwargs, :restart,
+                          :shutdown_timeout, :start_timeout, :restart_delay)
+
+  # What a supervisor is. `kind` is `:static` or `:dynamic`.
+  SupervisorSpec = Data.define(:kind, :strategy, :children, :max_restarts,
+                               :max_seconds, :max_children, :on_unresponsive)
+
+  # Exponential backoff settings.
+  BackoffSpec = Data.define(:initial, :max, :factor)
+
+  # Validates and builds specs. Every violation is listed in a single {InvalidSpec}.
+  #
+  # This is part of the functional core: no Ractors and no clock reads.
+  # (`Ractor.make_shareable` is used here purely as a conversion.)
+  module Validator
+    RESTARTS = %i[permanent transient temporary].freeze
+    STRATEGIES = %i[one_for_one one_for_all rest_for_one].freeze
+    ON_UNRESPONSIVE = %i[escalate abandon].freeze
+
+    SHAREABLE_HINT = "Procs, Threads and Mutexes cannot cross Ractors. " \
+                     "Pass plain values and hand the behaviour over as a class."
+
+    module_function
+
+    # @return [ChildSpec]
+    def worker_spec(id, klass, args: [], kwargs: {}, restart: :permanent,
+                    shutdown_timeout: 5.0, start_timeout: 5.0, restart_delay: nil, allow_nil_id: false)
+      errors = []
+      cause = nil
+
+      check_id(errors, id, allow_nil: allow_nil_id)
+      check_worker_class(errors, klass)
+      shareable_args, cause = share(errors, "args", args, cause)
+      shareable_kwargs, cause = share(errors, "kwargs", kwargs, cause)
+      check_restart(errors, restart)
+      check_timeout(errors, "shutdown_timeout", shutdown_timeout)
+      check_timeout(errors, "start_timeout", start_timeout)
+      delay = check_restart_delay(errors, restart_delay)
+
+      fail_spec!(errors, "worker #{id.inspect}", cause)
+
+      build(ChildSpec.new(id: id, type: :worker, start: klass,
+                          args: shareable_args, kwargs: shareable_kwargs, restart: restart,
+                          shutdown_timeout: shutdown_timeout, start_timeout: start_timeout,
+                          restart_delay: delay))
+    end
+
+    # @return [ChildSpec] type: :supervisor
+    def supervisor_spec(id, kind: :static, strategy: :one_for_one, children: [], max_restarts: 3,
+                        max_seconds: 5.0, max_children: nil, on_unresponsive: :escalate,
+                        restart: :permanent, shutdown_timeout: :infinity, start_timeout: :infinity,
+                        restart_delay: nil, allow_nil_id: false)
+      errors = []
+      check_id(errors, id, allow_nil: allow_nil_id)
+      inner = supervisor_body(errors, kind: kind, strategy: strategy, children: children,
+                                      max_restarts: max_restarts, max_seconds: max_seconds,
+                                      max_children: max_children, on_unresponsive: on_unresponsive)
+      check_restart(errors, restart)
+      check_timeout(errors, "shutdown_timeout", shutdown_timeout)
+      check_timeout(errors, "start_timeout", start_timeout)
+      delay = check_restart_delay(errors, restart_delay)
+
+      fail_spec!(errors, "supervisor #{id.inspect}", nil)
+
+      build(ChildSpec.new(id: id, type: :supervisor, start: inner,
+                          args: [], kwargs: {}, restart: restart,
+                          shutdown_timeout: shutdown_timeout, start_timeout: start_timeout,
+                          restart_delay: delay))
+    end
+
+    # For a root supervisor: returns a bare {SupervisorSpec}, not wrapped in a ChildSpec.
+    def root_spec(kind: :static, strategy: :one_for_one, children: [], max_restarts: 3,
+                  max_seconds: 5.0, max_children: nil, on_unresponsive: :escalate)
+      errors = []
+      inner = supervisor_body(errors, kind: kind, strategy: strategy, children: children,
+                                      max_restarts: max_restarts, max_seconds: max_seconds,
+                                      max_children: max_children, on_unresponsive: on_unresponsive)
+      fail_spec!(errors, "supervisor", nil)
+      build(inner)
+    end
+
+    # Child ids must be unique within one supervisor.
+    def check_unique_ids(errors, children)
+      ids = children.filter_map { |c| c.id if c.respond_to?(:id) }
+      dups = ids.tally.select { |_, n| n > 1 }.keys
+      errors << "duplicated child ids: #{dups.map(&:inspect).join(", ")}" unless dups.empty?
+    end
+
+    def supervisor_body(errors, kind:, strategy:, children:, max_restarts:, max_seconds:,
+                        max_children:, on_unresponsive:)
+      errors << "kind must be :static or :dynamic (got #{kind.inspect})" unless %i[static dynamic].include?(kind)
+      strategy = check_strategy(errors, strategy, kind)
+      check_children(errors, children, kind)
+      check_non_negative_integer(errors, "max_restarts", max_restarts)
+      check_positive_number(errors, "max_seconds", max_seconds)
+      check_max_children(errors, max_children)
+      unless ON_UNRESPONSIVE.include?(on_unresponsive)
+        errors << "on_unresponsive must be one of #{ON_UNRESPONSIVE.inspect} (got #{on_unresponsive.inspect})"
+      end
+
+      SupervisorSpec.new(kind: kind, strategy: strategy, children: children.dup.freeze,
+                         max_restarts: max_restarts, max_seconds: max_seconds,
+                         max_children: max_children, on_unresponsive: on_unresponsive)
+    end
+
+    def check_id(errors, id, allow_nil: false)
+      return if id.nil? && allow_nil
+      return if id.is_a?(Symbol) || id.is_a?(Integer)
+      return if id.is_a?(String) && id.frozen?
+
+      errors << "id must be a Symbol, an Integer or a frozen String (got #{id.inspect})"
+    end
+
+    def check_worker_class(errors, klass)
+      unless klass.is_a?(Class)
+        errors << "start must be a Class (got #{klass.inspect})"
+        return
+      end
+      return if klass.include?(Worker)
+
+      errors << "#{klass} must include RactorShepherd::Worker"
+    end
+
+    def check_restart(errors, restart)
+      return if RESTARTS.include?(restart)
+
+      errors << "restart must be one of #{RESTARTS.inspect} (got #{restart.inspect})"
+    end
+
+    def check_strategy(errors, strategy, kind)
+      if kind == :dynamic
+        errors << "dynamic supervisors only support :one_for_one (got #{strategy.inspect})" unless
+          strategy == :one_for_one
+        return :one_for_one
+      end
+      errors << "strategy must be one of #{STRATEGIES.inspect} (got #{strategy.inspect})" unless
+        STRATEGIES.include?(strategy)
+      strategy
+    end
+
+    def check_children(errors, children, kind)
+      unless children.is_a?(Array)
+        errors << "children must be an Array (got #{children.inspect})"
+        return
+      end
+      if kind == :dynamic && !children.empty?
+        errors << "dynamic supervisors must start with no children"
+        return
+      end
+      bad = children.grep_v(ChildSpec)
+      errors << "children must all be ChildSpec (got #{bad.map(&:class).uniq.inspect})" unless bad.empty?
+      check_unique_ids(errors, children)
+    end
+
+    def check_timeout(errors, name, value)
+      return if value == :infinity
+      return if value.is_a?(Numeric) && value.positive?
+
+      errors << "#{name} must be a positive Numeric or :infinity (got #{value.inspect})"
+    end
+
+    def check_non_negative_integer(errors, name, value)
+      return if value.is_a?(Integer) && !value.negative?
+
+      errors << "#{name} must be an Integer >= 0 (got #{value.inspect})"
+    end
+
+    def check_positive_number(errors, name, value)
+      return if value.is_a?(Numeric) && value.positive?
+
+      errors << "#{name} must be a positive Numeric (got #{value.inspect})"
+    end
+
+    def check_max_children(errors, value)
+      return if value.nil?
+      return if value.is_a?(Integer) && value >= 1
+
+      errors << "max_children must be nil or an Integer >= 1 (got #{value.inspect})"
+    end
+
+    # @return [nil, Numeric, BackoffSpec]
+    def check_restart_delay(errors, value)
+      case value
+      when nil then nil
+      when Numeric
+        errors << "restart_delay must be >= 0 (got #{value.inspect})" if value.negative?
+        value
+      when Hash then backoff_spec(errors, value)
+      when BackoffSpec then value
+      else
+        errors << "restart_delay must be nil, a Numeric or a Hash (got #{value.inspect})"
+        nil
+      end
+    end
+
+    def backoff_spec(errors, hash)
+      unknown = hash.keys - %i[initial max factor]
+      errors << "restart_delay has unknown keys: #{unknown.inspect}" unless unknown.empty?
+      initial = hash.fetch(:initial, 0.1)
+      max = hash.fetch(:max, 5.0)
+      factor = hash.fetch(:factor, 2.0)
+      errors << "restart_delay[:initial] must be a Numeric >= 0 (got #{initial.inspect})" unless
+        initial.is_a?(Numeric) && !initial.negative?
+      errors << "restart_delay[:max] must be a Numeric >= initial (got #{max.inspect})" unless
+        max.is_a?(Numeric) && initial.is_a?(Numeric) && max >= initial
+      errors << "restart_delay[:factor] must be a Numeric >= 1 (got #{factor.inspect})" unless
+        factor.is_a?(Numeric) && factor >= 1
+      BackoffSpec.new(initial: initial, max: max, factor: factor)
+    end
+
+    # Make a shareable copy without freezing what the caller passed in.
+    def share(errors, name, value, cause)
+      [Ractor.make_shareable(value, copy: true), cause]
+    # Procs and Threads raise TypeError (allocator undefined); Mutexes raise Ractor::Error.
+    rescue Ractor::Error, TypeError => e
+      errors << "#{name} cannot be shared with a Ractor (#{e.class}: #{e.message}). #{SHAREABLE_HINT}"
+      [value, cause || e]
+    end
+
+    def fail_spec!(errors, subject, cause)
+      return if errors.empty?
+
+      message = "invalid #{subject}:\n" + errors.map { |e| "  - #{e}" }.join("\n")
+      raise InvalidSpec, message, cause: cause
+    end
+
+    def build(data)
+      Ractor.make_shareable(data)
+    end
+  end
+end

data/lib/ractor_shepherd/supervisor_ref.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RactorShepherd
+  # What `which_children` reports about one child.
+  ChildInfo = Data.define(:id, :type, :status, :ref, :restart_count)
+
+  # Maps an error name reported by a supervisor back to its class.
+  REMOTE_ERRORS = Ractor.make_shareable(
+    [ChildNotFound, ChildUnavailable, InvalidOperation, InvalidSpec,
+     MaxChildrenReached, ProtocolError, StartError].to_h { |klass| [klass.name, klass] }
+  )
+
+  # A handle on a supervisor.
+  #
+  # It is shareable, so it can be handed to children or sent to other Ractors.
+  # Every query is a synchronous call over the control port, with a default
+  # timeout of five seconds.
+  SupervisorRef = Data.define(:name, :path, :ractor, :control_port) do
+    # @return [Array<ChildInfo>]
+    def which_children(timeout: 5) = request([:which_children], timeout)
+
+    # @return [Hash] { specs:, active:, workers:, supervisors: }
+    def count_children(timeout: 5) = request([:count_children], timeout)
+
+    # @return [Ractor, SupervisorRef, nil] nil while the child is being restarted
+    def whereis(id, timeout: 5) = request([:whereis, id], timeout)
+
+    # Build a lazily resolved address.
+    #
+    #   sup.lookup(:jobs, :poller).cast([:refresh])
+    #
+    # @return [Address]
+    def lookup(*path, retries: 3, resolve_timeout: 1.0)
+      Address.new(self, path, retries: retries, resolve_timeout: resolve_timeout)
+    end
+
+    # @return [Object] the id of the child that was added
+    def start_child(child_spec, timeout: 5) = request([:start_child, child_spec], timeout)
+
+    def terminate_child(id, timeout: 5) = request([:terminate_child, id], timeout)
+    def restart_child(id, timeout: 5) = request([:restart_child, id], timeout)
+    def delete_child(id, timeout: 5) = request([:delete_child, id], timeout)
+
+    # Stop every child in reverse order, then the supervisor, and wait for it to finish.
+    #
+    # Returns true right away if it had already stopped.
+    def stop(reason = :normal, timeout: :infinity)
+      port = Ractor::Port.new
+      timer = nil
+      return true unless ractor.monitor(port) # already finished
+
+      timer = Runtime::Timer.for_current_ractor.after(timeout, port, Runtime::Protocol.timeout(0)) unless
+        timeout == :infinity
+      return true unless send_shutdown(reason) # it finished just before we asked
+
+      case port.receive
+      in [Runtime::Protocol::TIMEOUT, _] then raise CallTimeout, "#{path} did not stop within #{timeout}s"
+      else true # a monitor notification: it stopped
+      end
+    ensure
+      timer&.cancel
+      # unmonitor is unusable (see Runtime::Call). Just close the port.
+      port&.close
+    end
+
+    # Leaves one monitor registration behind when the supervisor is alive,
+    # because unmonitor is unusable (see Runtime::Call).
+    def alive?
+      port = Ractor::Port.new
+      ractor.monitor(port)
+    ensure
+      port&.close
+    end
+
+    # Wait for the supervisor to finish.
+    #
+    # Call this only from the Ractor that started it: once another Ractor has
+    # taken a Ractor's value, nobody else can.
+    #
+    # @raise [SupervisorCrashed] if it escalated instead of stopping
+    def join
+      ractor.value
+      self
+    rescue Ractor::RemoteError => e
+      raise SupervisorCrashed, "#{path} crashed: #{e.cause.class}: #{e.cause.message}", cause: e.cause
+    end
+
+    private
+
+    def send_shutdown(reason)
+      control_port << Runtime::Protocol.shutdown(reason)
+      true
+    rescue Ractor::ClosedError
+      false
+    end
+
+    def request(body, timeout)
+      case Runtime::Call.perform(ractor, control_port, body, timeout: timeout, down_error: SupervisorDown)
+      in [:ok, value] then value
+      in [:error, error_class, message] then raise(REMOTE_ERRORS.fetch(error_class, Error), message)
+      end
+    end
+  end
+end

data/lib/ractor_shepherd/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RactorShepherd
+  VERSION = "0.1.0"
+end

data/lib/ractor_shepherd/worker.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RactorShepherd
+  # The low level worker interface: you write the loop yourself.
+  #
+  #   class Poller
+  #     include RactorShepherd::Worker
+  #
+  #     def initialize(url) = @url = url
+  #
+  #     def run(ctx)
+  #       until ctx.shutdown_requested?
+  #         fetch(@url)
+  #         ctx.sleep(1.0)
+  #       end
+  #     end
+  #   end
+  #
+  # `initialize` plays the role of OTP's `init`. Do not make a synchronous call
+  # to the supervisor from there: the supervisor is waiting for this child to
+  # finish starting, so the call would deadlock until `start_timeout` fires.
+  module Worker
+    # @param ctx [RactorShepherd::Runtime::Context]
+    def run(ctx)
+      raise NotImplementedError, "#{self.class} must implement #run(ctx)"
+    end
+
+    # Optional cleanup hook.
+    #
+    # @param reason [Symbol, Exception] :normal, :shutdown, or the exception that killed the worker
+    def terminate(reason) = nil # rubocop:disable Lint/UnusedMethodArgument
+  end
+end

data/lib/ractor_shepherd.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "ractor_shepherd/version"
+require_relative "ractor_shepherd/errors"
+require_relative "ractor_shepherd/runtime/compat"
+
+RactorShepherd::Runtime::Compat.check!
+
+require_relative "ractor_shepherd/worker"
+require_relative "ractor_shepherd/core/backoff"
+require_relative "ractor_shepherd/core/event"
+require_relative "ractor_shepherd/core/restart_intensity"
+require_relative "ractor_shepherd/core/restart_policy"
+require_relative "ractor_shepherd/core/strategy_planner"
+require_relative "ractor_shepherd/spec"
+require_relative "ractor_shepherd/runtime/protocol"
+require_relative "ractor_shepherd/runtime/timer"
+require_relative "ractor_shepherd/runtime/call"
+require_relative "ractor_shepherd/runtime/context"
+require_relative "ractor_shepherd/server"
+require_relative "ractor_shepherd/runtime/child_state"
+require_relative "ractor_shepherd/runtime/child_runner"
+require_relative "ractor_shepherd/runtime/supervisor_server"
+require_relative "ractor_shepherd/supervisor_ref"
+require_relative "ractor_shepherd/address"
+require_relative "ractor_shepherd/event_logger"
+require_relative "ractor_shepherd/facade"
+
+# Supervise Ractors the way Erlang/OTP supervisors do.
+#
+# A supervisor starts its children, watches them, restarts them according to a
+# declared policy, and escalates to its own parent when restarting stops helping.
+# Supervisors can themselves be children, so trees are just supervisors all the way down.
+#
+# @see DESIGN.md
+module RactorShepherd
+end

data/sig/ractor_shepherd.rbs

@@ -0,0 +1,179 @@
+# Signatures for the public API.
+# Runtime:: and Core:: are internal, so they are deliberately left out.
+module RactorShepherd
+  VERSION: String
+
+  type child_id = Symbol | Integer | String
+  type restart_kind = :permanent | :transient | :temporary
+  type strategy = :one_for_one | :one_for_all | :rest_for_one
+  type timeout = Numeric | :infinity
+  type unresponsive_action = :escalate | :abandon
+  type restart_delay = nil | Numeric | Hash[Symbol, Numeric] | BackoffSpec
+  type child_status = :starting | :running | :stopping | :exited | :terminated
+                    | :restart_scheduled | :start_failed | :unresponsive | :removed
+  type event = Hash[Symbol, untyped]
+
+  class Error < StandardError
+  end
+
+  class InvalidSpec < Error
+  end
+
+  class UnsupportedRuby < Error
+  end
+
+  class StartError < Error
+  end
+
+  class SupervisorCrashed < Error
+  end
+
+  class MaxRestartsExceeded < Error
+  end
+
+  class ChildUnresponsive < Error
+  end
+
+  class CallTimeout < Error
+  end
+
+  class SupervisorDown < Error
+  end
+
+  class WorkerDown < Error
+  end
+
+  class ChildNotFound < Error
+  end
+
+  class ChildUnavailable < Error
+  end
+
+  class InvalidOperation < Error
+  end
+
+  class MaxChildrenReached < Error
+  end
+
+  class ProtocolError < Error
+  end
+
+  class ShutdownSignal < Exception
+  end
+
+  class BackoffSpec
+    attr_reader initial: Numeric
+    attr_reader max: Numeric
+    attr_reader factor: Numeric
+  end
+
+  class SupervisorSpec
+    attr_reader kind: (:static | :dynamic)
+    attr_reader strategy: strategy
+    attr_reader children: Array[ChildSpec]
+    attr_reader max_restarts: Integer
+    attr_reader max_seconds: Numeric
+    attr_reader max_children: Integer?
+    attr_reader on_unresponsive: unresponsive_action
+  end
+
+  class ChildSpec
+    attr_reader id: child_id?
+    attr_reader type: (:worker | :supervisor)
+    attr_reader start: (Class | SupervisorSpec)
+    attr_reader args: Array[untyped]
+    attr_reader kwargs: Hash[Symbol, untyped]
+    attr_reader restart: restart_kind
+    attr_reader shutdown_timeout: timeout
+    attr_reader start_timeout: timeout
+    attr_reader restart_delay: restart_delay
+  end
+
+  class ChildInfo
+    attr_reader id: child_id
+    attr_reader type: (:worker | :supervisor)
+    attr_reader status: child_status
+    attr_reader ref: (Ractor | SupervisorRef)?
+    attr_reader restart_count: Integer
+  end
+
+  class SupervisorRef
+    attr_reader name: (Symbol | String)
+    attr_reader path: String
+    attr_reader ractor: Ractor
+    attr_reader control_port: untyped
+
+    def which_children: (?timeout: Numeric) -> Array[ChildInfo]
+    def count_children: (?timeout: Numeric) -> Hash[Symbol, Integer]
+    def whereis: (child_id, ?timeout: Numeric) -> (Ractor | SupervisorRef)?
+    def lookup: (*child_id, ?retries: Integer, ?resolve_timeout: Numeric) -> Address
+    def start_child: (ChildSpec, ?timeout: Numeric) -> child_id
+    def terminate_child: (child_id, ?timeout: Numeric) -> :ok
+    def restart_child: (child_id, ?timeout: Numeric) -> :ok
+    def delete_child: (child_id, ?timeout: Numeric) -> :ok
+    def stop: (?Symbol, ?timeout: timeout) -> bool
+    def alive?: () -> bool
+    def join: () -> SupervisorRef
+  end
+
+  class Address
+    attr_reader path: Array[child_id]
+
+    def ractor: () -> (Ractor | SupervisorRef)
+    def resolve!: () -> (Ractor | SupervisorRef)
+    def cast: (untyped) -> :ok
+    def call: (untyped, ?timeout: timeout) -> untyped
+  end
+
+  interface _Logger
+    def info: (String) -> void
+    def warn: (String) -> void
+    def error: (String) -> void
+  end
+
+  module EventLogger
+    def self.start: (untyped port, ?logger: _Logger) -> Thread
+    def self.level_for: (event) -> (:info | :warn | :error)
+    def self.format_event: (event) -> String
+  end
+
+  module Worker
+    def run: (untyped ctx) -> untyped
+    def terminate: ((Symbol | Exception)) -> untyped
+  end
+
+  module Server
+    include Worker
+
+    def context: () -> untyped
+    def handle_call: (untyped) -> untyped
+    def handle_cast: (untyped) -> untyped
+  end
+
+  def self.worker: (child_id?, Class,
+                    ?args: Array[untyped], ?kwargs: Hash[Symbol, untyped],
+                    ?restart: restart_kind, ?shutdown_timeout: timeout,
+                    ?start_timeout: timeout, ?restart_delay: restart_delay) -> ChildSpec
+
+  def self.supervisor: (child_id, ?strategy: strategy, ?children: Array[ChildSpec],
+                        ?max_restarts: Integer, ?max_seconds: Numeric,
+                        ?on_unresponsive: unresponsive_action, ?restart: restart_kind,
+                        ?shutdown_timeout: timeout, ?start_timeout: timeout,
+                        ?restart_delay: restart_delay) -> ChildSpec
+
+  def self.dynamic_supervisor: (child_id, ?max_children: Integer?, ?max_restarts: Integer,
+                                ?max_seconds: Numeric, ?on_unresponsive: unresponsive_action,
+                                ?restart: restart_kind, ?shutdown_timeout: timeout,
+                                ?start_timeout: timeout, ?restart_delay: restart_delay) -> ChildSpec
+
+  def self.start: (name: (Symbol | String), ?strategy: strategy, ?children: Array[ChildSpec],
+                   ?max_restarts: Integer, ?max_seconds: Numeric,
+                   ?on_unresponsive: unresponsive_action, ?event_port: untyped,
+                   ?boot_timeout: timeout) -> SupervisorRef
+
+  def self.start_dynamic: (name: (Symbol | String), ?max_children: Integer?, ?max_restarts: Integer,
+                           ?max_seconds: Numeric, ?on_unresponsive: unresponsive_action,
+                           ?event_port: untyped, ?boot_timeout: timeout) -> SupervisorRef
+
+  def self.run: (**untyped) { (SupervisorRef) -> untyped } -> untyped
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: ractor_shepherd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: 'ractor_shepherd supervises Ractors the way Erlang/OTP supervisors do:
+  declarative restart strategies, restart intensity, supervision trees and ordered
+  graceful shutdown. No runtime dependencies.'
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/ractor_shepherd.rb
+- lib/ractor_shepherd/address.rb
+- lib/ractor_shepherd/core/backoff.rb
+- lib/ractor_shepherd/core/event.rb
+- lib/ractor_shepherd/core/restart_intensity.rb
+- lib/ractor_shepherd/core/restart_policy.rb
+- lib/ractor_shepherd/core/strategy_planner.rb
+- lib/ractor_shepherd/errors.rb
+- lib/ractor_shepherd/event_logger.rb
+- lib/ractor_shepherd/facade.rb
+- lib/ractor_shepherd/runtime/call.rb
+- lib/ractor_shepherd/runtime/child_runner.rb
+- lib/ractor_shepherd/runtime/child_state.rb
+- lib/ractor_shepherd/runtime/compat.rb
+- lib/ractor_shepherd/runtime/context.rb
+- lib/ractor_shepherd/runtime/protocol.rb
+- lib/ractor_shepherd/runtime/supervisor_server.rb
+- lib/ractor_shepherd/runtime/timer.rb
+- lib/ractor_shepherd/server.rb
+- lib/ractor_shepherd/spec.rb
+- lib/ractor_shepherd/supervisor_ref.rb
+- lib/ractor_shepherd/version.rb
+- lib/ractor_shepherd/worker.rb
+- sig/ractor_shepherd.rbs
+homepage: https://github.com/ydah/ractor_shepherd
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/ractor_shepherd
+  changelog_uri: https://github.com/ydah/ractor_shepherd/blob/main/CHANGELOG.md
+  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.16
+specification_version: 4
+summary: OTP-style supervisor for Ruby Ractors.
+test_files: []