solid_objects 0.10.3 → 0.12.0

data/lib/solid_objects/reference.rb

@@ -16,41 +16,50 @@ module SolidObjects
       freeze
     end
 
-    # @rbs (Symbol | String, ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped, **untyped) -> MessageReference?
-    def async(message_name, available_at: nil, idempotency_key: nil, authorization_context: nil, **arguments)
-      if (actor = Context.current_actor)
-        actor.stage_outbound_message(
-          self,
-          message_name,
-          arguments,
+    # @rbs (?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> OperationDispatcher
+    def async(available_at: nil, idempotency_key: nil, authorization_context: nil)
+      OperationDispatcher.new(
+        actor_type:,
+        handlers: actor_definition.messages
+      ) do |operation, arguments|
+        if (actor = Context.current_actor)
+          actor.stage_outbound_message(
+            reference: self,
+            operation:,
+            arguments:,
+            available_at:,
+            idempotency_key:
+          )
+          next
+        end
+
+        SolidObjects.client.async(
+          reference: self,
+          operation:,
+          arguments:,
           available_at:,
-          idempotency_key:
+          idempotency_key:,
+          authorization_context:
         )
-        return
       end
-
-      SolidObjects.client.async(
-        self,
-        message_name,
-        arguments,
-        available_at:,
-        idempotency_key:,
-        authorization_context:
-      )
     end
 
-    # @rbs (Symbol | String, ?timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped, **untyped) -> untyped
-    def sync(message_name, timeout: 5.seconds, idempotency_key: nil, authorization_context: nil, **arguments)
+    # @rbs (?timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> OperationDispatcher
+    def sync(timeout: 5.seconds, idempotency_key: nil, authorization_context: nil)
       raise ActorCallCycle, "actors cannot synchronously wait for another actor" if Context.current_actor
 
-      SolidObjects.client.sync(
-        self,
-        message_name,
-        arguments,
-        timeout:,
-        idempotency_key:,
-        authorization_context:
-      )
+      OperationDispatcher.new(
+        actor_type:,
+        handlers: actor_definition.messages.merge(actor_definition.queries)
+      ) do |operation, arguments|
+        invoke_synchronously(
+          operation,
+          arguments,
+          timeout:,
+          idempotency_key:,
+          authorization_context:
+        )
+      end
     end
 
     # @rbs (?authorization_context: untyped) -> bool
@@ -66,7 +75,15 @@ module SolidObjects
     # @rbs (Symbol, *untyped, **untyped) -> untyped
     def method_missing(name, *arguments, **keywords)
       return super if arguments.any? || block_given?
-      return sync(name, **keywords) if actor_message?(name) || actor_query?(name)
+      if actor_message?(name) || actor_query?(name)
+        return invoke_synchronously(
+          name,
+          keywords,
+          timeout: 5.seconds,
+          idempotency_key: nil,
+          authorization_context: nil
+        )
+      end
 
       super
     end
@@ -83,6 +100,20 @@ module SolidObjects
 
     private
 
+    # @rbs (Symbol | String, Hash[Symbol, untyped], timeout: Numeric, idempotency_key: String?, authorization_context: untyped) -> untyped
+    def invoke_synchronously(operation, arguments, timeout:, idempotency_key:, authorization_context:)
+      raise ActorCallCycle, "actors cannot synchronously wait for another actor" if Context.current_actor
+
+      SolidObjects.client.sync(
+        reference: self,
+        operation:,
+        arguments:,
+        timeout:,
+        idempotency_key:,
+        authorization_context:
+      )
+    end
+
     # @rbs (Symbol | String) -> bool
     def actor_message?(name)
       actor_definition.messages.key?(name.to_sym)

data/lib/solid_objects/reminder_scheduler.rb

@@ -97,8 +97,8 @@ module SolidObjects
     # @rbs (Reminder) -> MessageReference?
     def enqueue(reminder)
       actor_class = SolidObjects.registry.fetch(reminder.actor_type)
-      unless actor_class.definition.messages.key?(reminder.message_name.to_sym)
-        raise UnknownMessage, "unknown reminder message #{reminder.message_name.inspect}"
+      unless actor_class.definition.messages.key?(reminder.operation.to_sym)
+        raise UnknownMessage, "unknown reminder operation #{reminder.operation.inspect}"
       end
 
       mailbox = Mailbox.new(database_adapter:)
@@ -111,10 +111,10 @@ module SolidObjects
         verify_claim!(locked_reminder)
         now = database_adapter.database_now
         message = mailbox.enqueue_in_transaction(
-          Reference.new(actor_type: instance.actor_type, actor_id: instance.actor_id),
-          locked_reminder.message_name,
-          locked_reminder.arguments,
-          kind: "internal",
+          reference: Reference.new(actor_type: instance.actor_type, actor_id: instance.actor_id),
+          operation: locked_reminder.operation,
+          arguments: locked_reminder.arguments,
+          delivery_mode: "internal",
           idempotency_key: "reminder:#{locked_reminder.id}:#{locked_reminder.occurrence}",
           actor_class:
         )

data/lib/solid_objects/supervisor.rb

@@ -19,12 +19,13 @@ module SolidObjects
       broadcast_worker_count: SolidObjects.configuration.broadcast_worker_count,
       reminder_scheduler_count: SolidObjects.configuration.reminder_scheduler_count
     )
-      @components = build_components(
+      @builders = component_builders(
         worker_count:,
         effect_worker_count:,
         broadcast_worker_count:,
         reminder_scheduler_count:
       )
+      @components = build_all(@builders)
       @threads = []
       @monitor = nil
       @started = false
@@ -77,7 +78,7 @@ module SolidObjects
 
     private
 
-    attr_reader :components, :threads
+    attr_reader :components, :threads, :builders
 
     # A role that raises leaves its thread dead. Without replacement the
     # process keeps running while quietly doing less work, so the supervisor
@@ -116,7 +117,11 @@ module SolidObjects
         replaced = @lifecycle.synchronize do
           next false unless @started
 
-          replacement = component.class.new
+          # A component built by this supervisor has a builder, which carries
+          # whatever the constructor was given. A component put in place by
+          # other means has none, so the class is the only thing left to go on.
+          builder = builders[index] || -> { component.class.new }
+          replacement = builder.call
           components[index] = replacement
           threads[index] = supervise(replacement)
           replacement
@@ -250,17 +255,53 @@ module SolidObjects
       nil
     end
 
-    # @rbs (worker_count: Integer, effect_worker_count: Integer, broadcast_worker_count: Integer, reminder_scheduler_count: Integer) -> Array[Worker | EffectExecutor | ReminderScheduler | BroadcastExecutor]
-    def build_components(
+    # A constructor can take a resource, and a later builder can raise. Without
+    # this, the components built first would be dropped while still holding
+    # whatever they took, and nothing would ever give it back.
+    # @rbs (Array[^() -> untyped]) -> Array[untyped]
+    def build_all(builders)
+      built = []
+      builders.each do |builder|
+        # The component joins the list before the contract check, so a
+        # component that fails the check is stopped along with the rest.
+        built << (component = builder.call)
+        SolidObjects.configuration.validate_component!(component)
+      end
+      built
+    rescue Exception # rubocop:disable Lint/RescueException
+      built.each { |component| stop_after_failed_build(component) }
+      raise
+    end
+
+    # The failure that stopped the build is the one worth reporting, so a
+    # failure inside the cleanup never replaces it.
+    # @rbs (untyped) -> void
+    def stop_after_failed_build(component)
+      component.stop if component.respond_to?(:stop)
+    rescue Exception => error # rubocop:disable Lint/RescueException
+      SolidObjects.instrument(
+        :"supervisor.component_cleanup_failed",
+        role: component.class.name,
+        error_class: error.class.name
+      )
+    end
+
+    # Each component keeps the builder that made it, so a replacement after a
+    # crash is built the same way as the original. Components registered
+    # through the configuration run beside the built in ones, under the same
+    # supervision, restart, and shutdown timeout.
+    # @rbs (worker_count: Integer, effect_worker_count: Integer, broadcast_worker_count: Integer, reminder_scheduler_count: Integer) -> Array[^() -> untyped]
+    def component_builders(
       worker_count:,
       effect_worker_count:,
       broadcast_worker_count:,
       reminder_scheduler_count:
     )
-      Array.new(worker_count) { Worker.new } +
-        Array.new(effect_worker_count) { EffectExecutor.new } +
-        Array.new(broadcast_worker_count) { BroadcastExecutor.new } +
-        Array.new(reminder_scheduler_count) { ReminderScheduler.new }
+      Array.new(worker_count) { -> { Worker.new } } +
+        Array.new(effect_worker_count) { -> { EffectExecutor.new } } +
+        Array.new(broadcast_worker_count) { -> { BroadcastExecutor.new } } +
+        Array.new(reminder_scheduler_count) { -> { ReminderScheduler.new } } +
+        SolidObjects.configuration.additional_components
     end
 
     # @rbs () -> void

data/lib/solid_objects/sync_diagnostics.rb

@@ -8,7 +8,7 @@ module SolidObjects
       instance = Instance.uncached { Instance.find(message.instance_id) }
       blocker = earlier_blocker(message)
       status = message_status(message)
-      waiting_on = waiting_reason(message, instance, blocker)
+      waiting_on = waiting_reason(message:, instance:, blocker:)
       activation = activation_details(instance)
       build_error(
         message,
@@ -38,7 +38,7 @@ module SolidObjects
         timeout:,
         actor_type: message_reference.actor_type,
         actor_id: message_reference.actor_id,
-        message_name: "unknown",
+        operation: "unknown",
         message_id: message_reference.id,
         request_id: message_reference.request_id,
         sequence: message_reference.sequence,
@@ -70,7 +70,7 @@ module SolidObjects
         timeout:,
         actor_type: message.actor_type,
         actor_id: message.actor_id,
-        message_name: message.message_name,
+        operation: message.operation,
         message_id: message.id,
         request_id: message.request_id,
         sequence: message.sequence,
@@ -105,8 +105,8 @@ module SolidObjects
       "unknown"
     end
 
-    # @rbs (Message, Instance, Message?) -> String
-    def waiting_reason(message, instance, blocker)
+    # @rbs (message: Message, instance: Instance, blocker: Message?) -> String
+    def waiting_reason(message:, instance:, blocker:)
       return "actor_paused" if instance.paused_at
       return "activation_held" if live_activation?(instance)
       return "earlier_message" if blocker
@@ -179,7 +179,7 @@ module SolidObjects
       {
         "message_id" => blocker.id,
         "sequence" => blocker.sequence,
-        "message_name" => blocker.message_name,
+        "operation" => blocker.operation,
         "status" => message_status(blocker)
       }
     end

data/lib/solid_objects/turbo_stream_renderer.rb

@@ -20,9 +20,9 @@ module SolidObjects
         ""
       else
         observable_value(
-          reference,
-          broadcast.observable_name,
-          broadcast.value
+          reference:,
+          name: broadcast.observable_name,
+          value: broadcast.value
         )
       end
       metadata = Base64.urlsafe_encode64(
@@ -35,16 +35,16 @@ module SolidObjects
       "#{stream}<!--#{INVALIDATION_MARKER}#{metadata}-->"
     end
 
-    # @rbs (Reference, Symbol | String, untyped) -> String
-    def observable_value(reference, name, value)
+    # @rbs (reference: Reference, name: Symbol | String, value: untyped) -> String
+    def observable_value(reference:, name:, value:)
       target = DomIdentity.observable(reference, name)
       content = ERB::Util.html_escape(display_value(value))
       %(<turbo-stream action="replace" target="#{target}"><template><span id="#{target}">#{content}</span></template></turbo-stream>)
     end
 
-    # @rbs (ComponentRegistration, Integer, Integer) -> String
-    def component_refresh(registration, instance_id, revision)
-      return morph_component_refresh(registration, instance_id, revision) if registration.morph?
+    # @rbs (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> String
+    def component_refresh(registration:, instance_id:, revision:)
+      return morph_component_refresh(registration:, instance_id:, revision:) if registration.morph?
 
       target = registration.dom_id
       source = ERB::Util.html_escape(
@@ -54,13 +54,13 @@ module SolidObjects
       %(<turbo-stream action="replace" target="#{target}"><template><turbo-frame id="#{target}" src="#{source}" data-solid-objects-revision="#{revision_value}" data-solid-objects-refresh="replace"></turbo-frame></template></turbo-stream>)
     end
 
-    # @rbs (Array[ComponentRegistration], Integer, Integer) -> String
-    def batch_refresh(registrations, instance_id, revision)
+    # @rbs (registrations: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> String
+    def batch_refresh(registrations:, instance_id:, revision:)
       first = registrations.first
       scope = DomIdentity.scope(first.reference)
       batch = ERB::Util.html_escape(first.batch)
       source = ERB::Util.html_escape(
-        first.batch_refresh_url(registrations, instance_id, revision)
+        first.batch_refresh_url(registrations:, instance_id:, revision:)
       )
       targets = ERB::Util.html_escape(registrations.map(&:dom_id).join(" "))
       %(<turbo-stream action="append" target="#{scope}"><template><solid-objects-batch-refresh data-batch="#{batch}" data-revision="#{instance_id}:#{revision}" data-targets="#{targets}" data-source="#{source}"></solid-objects-batch-refresh></template></turbo-stream>)
@@ -104,8 +104,8 @@ module SolidObjects
     end
     private_class_method :display_value
 
-    # @rbs (ComponentRegistration, Integer, Integer) -> String
-    def morph_component_refresh(registration, instance_id, revision)
+    # @rbs (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> String
+    def morph_component_refresh(registration:, instance_id:, revision:)
       source = ERB::Util.html_escape(
         registration.refresh_url(instance_id, revision)
       )

data/lib/solid_objects/version.rb

@@ -1,5 +1,5 @@
 # rbs_inline: enabled
 
 module SolidObjects
-  VERSION = "0.10.3"
+  VERSION = "0.12.0"
 end

data/lib/solid_objects.rb

@@ -21,6 +21,7 @@ require "solid_objects/serialization"
 require "solid_objects/context"
 require "solid_objects/actor_registry"
 require "solid_objects/state"
+require "solid_objects/operation_dispatcher"
 require "solid_objects/actor_definition"
 require "solid_objects/application_write_guard"
 require "solid_objects/actor"

data/sig/generated/controllers/solid_objects/components_controller.rbs

@@ -39,7 +39,7 @@ module SolidObjects
     # @rbs () -> untyped
     def component_view_context: () -> untyped
 
-    # @rbs (ComponentRegistration, ActorSnapshot, untyped) -> String
-    def component_frame: (ComponentRegistration, ActorSnapshot, untyped) -> String
+    # @rbs (registration: ComponentRegistration, snapshot: ActorSnapshot, rendered: untyped) -> String
+    def component_frame: (registration: ComponentRegistration, snapshot: ActorSnapshot, rendered: untyped) -> String
   end
 end

data/sig/generated/lib/solid_objects/actor.rbs

@@ -7,16 +7,16 @@ module SolidObjects
 
       attr_reader arguments(): untyped
 
-      attr_reader success_message_name(): untyped
+      attr_reader success_operation(): untyped
 
-      attr_reader failure_message_name(): untyped
+      attr_reader failure_operation(): untyped
 
-      def self.new: (untyped name, untyped arguments, untyped success_message_name, untyped failure_message_name) -> instance
-                  | (name: untyped, arguments: untyped, success_message_name: untyped, failure_message_name: untyped) -> instance
+      def self.new: (untyped name, untyped arguments, untyped success_operation, untyped failure_operation) -> instance
+                  | (name: untyped, arguments: untyped, success_operation: untyped, failure_operation: untyped) -> instance
 
-      def self.members: () -> [ :name, :arguments, :success_message_name, :failure_message_name ]
+      def self.members: () -> [ :name, :arguments, :success_operation, :failure_operation ]
 
-      def members: () -> [ :name, :arguments, :success_message_name, :failure_message_name ]
+      def members: () -> [ :name, :arguments, :success_operation, :failure_operation ]
     end
 
     class CommitActionIntent < Data
@@ -56,7 +56,7 @@ module SolidObjects
 
       attr_reader actor_id(): untyped
 
-      attr_reader message_name(): untyped
+      attr_reader operation(): untyped
 
       attr_reader arguments(): untyped
 
@@ -64,12 +64,12 @@ module SolidObjects
 
       attr_reader idempotency_key(): untyped
 
-      def self.new: (untyped actor_type, untyped actor_id, untyped message_name, untyped arguments, untyped available_at, untyped idempotency_key) -> instance
-                  | (actor_type: untyped, actor_id: untyped, message_name: untyped, arguments: untyped, available_at: untyped, idempotency_key: untyped) -> instance
+      def self.new: (untyped actor_type, untyped actor_id, untyped operation, untyped arguments, untyped available_at, untyped idempotency_key) -> instance
+                  | (actor_type: untyped, actor_id: untyped, operation: untyped, arguments: untyped, available_at: untyped, idempotency_key: untyped) -> instance
 
-      def self.members: () -> [ :actor_type, :actor_id, :message_name, :arguments, :available_at, :idempotency_key ]
+      def self.members: () -> [ :actor_type, :actor_id, :operation, :arguments, :available_at, :idempotency_key ]
 
-      def members: () -> [ :actor_type, :actor_id, :message_name, :arguments, :available_at, :idempotency_key ]
+      def members: () -> [ :actor_type, :actor_id, :operation, :arguments, :available_at, :idempotency_key ]
     end
 
     # @rbs (Class) -> void
@@ -157,11 +157,11 @@ module SolidObjects
     # @rbs (Symbol | String, **untyped) -> nil
     def commit_action: (Symbol | String, **untyped) -> nil
 
-    # @rbs (Symbol | String, at: Time, ?every: Numeric?, ?missed: Symbol | String, arguments: Hash[Symbol | String, untyped]) -> nil
-    def schedule: (Symbol | String, at: Time, arguments: Hash[Symbol | String, untyped], ?every: Numeric?, ?missed: Symbol | String) -> nil
+    # @rbs (at: Time, ?every: Numeric?, ?missed: Symbol | String) -> OperationDispatcher
+    def schedule: (at: Time, ?every: Numeric?, ?missed: Symbol | String) -> OperationDispatcher
 
-    # @rbs (Reference, Symbol | String, ?available_at: Time?, ?idempotency_key: String?, **untyped) -> nil
-    def send_to: (Reference, Symbol | String, ?available_at: Time?, ?idempotency_key: String?, **untyped) -> nil
+    # @rbs (Reference, ?available_at: Time?, ?idempotency_key: String?) -> OperationDispatcher
+    def send_to: (Reference, ?available_at: Time?, ?idempotency_key: String?) -> OperationDispatcher
 
     # @rbs (Symbol | String, Hash[String, untyped]) -> untyped
     def invoke: (Symbol | String, Hash[String, untyped]) -> untyped
@@ -178,8 +178,8 @@ module SolidObjects
     # @rbs () -> void
     def deactivate: () -> void
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, idempotency_key: String?) -> OutboundMessageIntent
-    def stage_outbound_message: (Reference, Symbol | String, Hash[Symbol | String, untyped], idempotency_key: String?, ?available_at: Time?) -> OutboundMessageIntent
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], ?available_at: Time?, idempotency_key: String?) -> OutboundMessageIntent
+    def stage_outbound_message: (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], idempotency_key: String?, ?available_at: Time?) -> OutboundMessageIntent
 
     # @rbs () -> Array[EffectIntent]
     def drain_effect_intents: () -> Array[EffectIntent]

data/sig/generated/lib/solid_objects/actor_definition.rbs

@@ -94,8 +94,8 @@ module SolidObjects
     # @rbs (Integer) -> Integer
     def set_state_version: (Integer) -> Integer
 
-    # @rbs (Integer, Integer, Proc) -> StateMigration
-    def add_state_migration: (Integer, Integer, Proc) -> StateMigration
+    # @rbs (from: Integer, to: Integer, block: Proc) -> StateMigration
+    def add_state_migration: (from: Integer, to: Integer, block: Proc) -> StateMigration
 
     # @rbs (Integer, Hash[String, untyped]) -> Hash[String, untyped]
     def migrate_state: (Integer, Hash[String, untyped]) -> Hash[String, untyped]
@@ -118,7 +118,7 @@ module SolidObjects
     # @rbs (Array[Symbol]) -> void
     def validate_attribute_methods!: (Array[Symbol]) -> void
 
-    # @rbs (Hash[Symbol, Handler], Symbol | String, Proc) -> Handler
-    def add_handler: (Hash[Symbol, Handler], Symbol | String, Proc) -> Handler
+    # @rbs (collection: Hash[Symbol, Handler], name: Symbol | String, block: Proc) -> Handler
+    def add_handler: (collection: Hash[Symbol, Handler], name: Symbol | String, block: Proc) -> Handler
   end
 end

data/sig/generated/lib/solid_objects/client.rbs

@@ -7,11 +7,11 @@ module SolidObjects
     # @rbs (?mailbox: Mailbox) -> void
     def initialize: (?mailbox: Mailbox) -> void
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference
-    def async: (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference
+    def async: (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped
-    def sync: (Reference, Symbol | String, Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped
+    def sync: (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped
 
     # @rbs (MessageReference, timeout: Numeric, ?authorization_context: untyped) -> untyped
     def wait: (MessageReference, timeout: Numeric, ?authorization_context: untyped) -> untyped
@@ -26,8 +26,8 @@ module SolidObjects
 
     attr_reader mailbox: untyped
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], idempotency_key: String?, timeout: Numeric) -> MessageReference
-    def enqueue_sync: (Reference, Symbol | String, Hash[Symbol | String, untyped], idempotency_key: String?, timeout: Numeric) -> MessageReference
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], idempotency_key: String?, timeout: Numeric) -> MessageReference
+    def enqueue_sync: (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], idempotency_key: String?, timeout: Numeric) -> MessageReference
 
     # @rbs (MessageReference, Message) -> void
     def validate_message_reference!: (MessageReference, Message) -> void
@@ -35,8 +35,8 @@ module SolidObjects
     # @rbs (Reference, Symbol | String) -> void
     def reject_sync_inside_transaction!: (Reference, Symbol | String) -> void
 
-    # @rbs (Proc, Reference, Symbol | String, Hash[Symbol | String, untyped], authorization_context: untyped) -> void
-    def authorize!: (Proc, Reference, Symbol | String, Hash[Symbol | String, untyped], authorization_context: untyped) -> void
+    # @rbs (hook: Proc, reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], authorization_context: untyped) -> void
+    def authorize!: (hook: Proc, reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], authorization_context: untyped) -> void
 
     # @rbs (Reference, authorization_context: untyped) -> void
     def authorize_destroy!: (Reference, authorization_context: untyped) -> void

data/sig/generated/lib/solid_objects/component_registration.rbs

@@ -73,8 +73,8 @@ module SolidObjects
     # @rbs () -> Hash[String, untyped]
     def authorization_arguments: () -> Hash[String, untyped]
 
-    # @rbs (Array[ComponentRegistration], Integer, Integer) -> String
-    def batch_refresh_url: (Array[ComponentRegistration], Integer, Integer) -> String
+    # @rbs (registrations: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> String
+    def batch_refresh_url: (registrations: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> String
 
     # @rbs (Integer, Integer) -> String
     def refresh_url: (Integer, Integer) -> String

data/sig/generated/lib/solid_objects/component_subscriptions.rbs

@@ -33,16 +33,16 @@ module SolidObjects
 
     # Live invalidations and reconnect replays share this, so a reconnecting
     # client pays the same number of requests a connected one does.
-    # @rbs (Array[ComponentRegistration], Integer, Integer) -> Array[String]
-    def refresh_streams: (Array[ComponentRegistration], Integer, Integer) -> Array[String]
+    # @rbs (changed: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> Array[String]
+    def refresh_streams: (changed: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> Array[String]
 
-    # @rbs (ComponentRegistration, Integer, Integer) -> void
-    def record_revision: (ComponentRegistration, Integer, Integer) -> void
+    # @rbs (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> void
+    def record_revision: (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> void
 
-    # @rbs (ComponentRegistration, Integer, Integer) -> String
-    def refresh: (ComponentRegistration, Integer, Integer) -> String
+    # @rbs (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> String
+    def refresh: (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> String
 
-    # @rbs (String, Integer, Integer) -> bool
-    def newer_revision?: (String, Integer, Integer) -> bool
+    # @rbs (dom_id: String, instance_id: Integer, revision: Integer) -> bool
+    def newer_revision?: (dom_id: String, instance_id: Integer, revision: Integer) -> bool
   end
 end

data/sig/generated/lib/solid_objects/configuration.rbs

@@ -2,6 +2,10 @@
 
 module SolidObjects
   class Configuration
+    @process_alive_threshold: Float
+
+    @shutdown_timeout: Float
+
     @supervisor_monitor_interval: Float
 
     @retention_interval: Float
@@ -86,10 +90,6 @@ module SolidObjects
 
     @process_heartbeat_interval: Float
 
-    @process_alive_threshold: Float
-
-    @shutdown_timeout: Float
-
     attr_accessor table_name_prefix: untyped
 
     attr_accessor polling_interval: untyped
@@ -178,9 +178,37 @@ module SolidObjects
 
     attr_accessor authorize_administration: untyped
 
+    # @rbs @additional_components: Array[untyped]
+    attr_reader additional_components: untyped
+
     # @rbs () -> void
     def initialize: () -> void
 
+    # Registers a long running component that the supervisor runs beside its own
+    # workers. An extension gem uses this to share one process, rather than ask
+    # an operator to run and monitor a second one.
+    #
+    # The block must return an object that answers `run`, `request_shutdown`,
+    # `stopped?`, and `stop`, which is the contract the built in components
+    # already keep. The supervisor calls the block once for each supervisor it
+    # builds, and again when it replaces a crashed component, so two
+    # supervisors never share one component instance.
+    #
+    # @rbs (?count: Integer) { () -> untyped } -> void
+    def register_component: (?count: Integer) { () -> untyped } -> void
+
+    # The supervisor checks the contract here rather than at registration,
+    # because a component often needs a database connection to exist, and
+    # registration happens while the application boots.
+    # @rbs () -> Array[untyped]
+    def build_additional_components: () -> Array[untyped]
+
+    # A component that misses part of the contract would hang the supervisor at
+    # shutdown, or crash the moment it starts. The build fails instead, where
+    # the caller can read the reason.
+    # @rbs (untyped) -> void
+    def validate_component!: (untyped) -> void
+
     # @rbs () -> self
     def validate!: () -> self
 

data/sig/generated/lib/solid_objects/database_adapters/sqlite.rbs

@@ -49,6 +49,9 @@ module SolidObjects
       # @rbs (Exception) -> bool
       def deadline_error?: (Exception) -> bool
 
+      # @rbs (Exception) -> bool
+      def reconnect_blocked_error?: (Exception) -> bool
+
       # @rbs (Exception) -> bool
       def busy_error?: (Exception) -> bool
 

data/sig/generated/lib/solid_objects/effect_executor.rbs

@@ -76,7 +76,7 @@ module SolidObjects
     # @rbs (Effect) -> void
     def verify_claim!: (Effect) -> void
 
-    # @rbs (Effect, String?, String, Hash[String, untyped]) -> Message?
-    def enqueue_result_message: (Effect, String?, String, Hash[String, untyped]) -> Message?
+    # @rbs (effect: Effect, operation: String?, outcome: String, arguments: Hash[String, untyped]) -> Message?
+    def enqueue_result_message: (effect: Effect, operation: String?, outcome: String, arguments: Hash[String, untyped]) -> Message?
   end
 end