solid_objects 0.11.0 → 0.12.1

data/lib/solid_objects/mailbox.rb

@@ -11,8 +11,8 @@ module SolidObjects
       @database_adapter = database_adapter
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], kind: String, ?available_at: Time?, idempotency_key: String?) -> MessageReference
-    def enqueue(reference, message_name, arguments, kind:, available_at: nil, idempotency_key: nil)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], delivery_mode: String, ?available_at: Time?, idempotency_key: String?) -> MessageReference
+    def enqueue(reference:, operation:, arguments:, delivery_mode:, available_at: nil, idempotency_key: nil)
       actor_class = SolidObjects.registry.fetch(reference.actor_type)
       normalized_arguments = Serialization.dump(
         arguments,
@@ -21,10 +21,10 @@ module SolidObjects
       message = with_instance_retry do
         database_adapter.transaction do
           enqueue_in_transaction(
-            reference,
-            message_name,
-            normalized_arguments,
-            kind:,
+            reference:,
+            operation:,
+            arguments: normalized_arguments,
+            delivery_mode:,
             available_at:,
             idempotency_key:,
             actor_class:
@@ -36,12 +36,12 @@ module SolidObjects
       MessageReference.from_message(message)
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], kind: String, ?available_at: Time?, idempotency_key: String?, ?actor_class: Class?) -> Message
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], delivery_mode: String, ?available_at: Time?, idempotency_key: String?, ?actor_class: Class?) -> Message
     def enqueue_in_transaction(
-      reference,
-      message_name,
-      arguments,
-      kind:,
+      reference:,
+      operation:,
+      arguments:,
+      delivery_mode:,
       available_at: nil,
       idempotency_key: nil,
       actor_class: nil
@@ -55,15 +55,22 @@ module SolidObjects
       instance.lock!
 
       existing = find_idempotent_message(instance, idempotency_key)
-      return validate_idempotent_message!(existing, message_name, kind, normalized_arguments) if existing
+      if existing
+        return validate_idempotent_message!(
+          existing_message: existing,
+          operation:,
+          delivery_mode:,
+          arguments: normalized_arguments
+        )
+      end
 
       enforce_mailbox_limit!(instance)
       create_message(
-        instance,
-        reference,
-        message_name,
-        normalized_arguments,
-        kind:,
+        instance:,
+        reference:,
+        operation:,
+        arguments: normalized_arguments,
+        delivery_mode:,
         available_at:,
         idempotency_key:
       )
@@ -117,12 +124,12 @@ module SolidObjects
       Message.find_by(instance_id: instance.id, idempotency_key:)
     end
 
-    # @rbs (Message, Symbol | String, String, untyped) -> Message
-    def validate_idempotent_message!(message, message_name, kind, arguments)
-      matches = message.message_name == message_name.to_s &&
-        message.message_kind == kind &&
-        message.arguments == arguments
-      return message if matches
+    # @rbs (existing_message: Message, operation: Symbol | String, delivery_mode: String, arguments: untyped) -> Message
+    def validate_idempotent_message!(existing_message:, operation:, delivery_mode:, arguments:)
+      matches = existing_message.operation == operation.to_s &&
+        existing_message.delivery_mode == delivery_mode &&
+        existing_message.arguments == arguments
+      return existing_message if matches
 
       raise IdempotencyConflict, "idempotency key belongs to a different actor invocation"
     end
@@ -136,8 +143,8 @@ module SolidObjects
       raise MailboxFull, "mailbox is full for #{instance.actor_type}(#{instance.actor_id.inspect})"
     end
 
-    # @rbs (Instance, Reference, Symbol | String, untyped, kind: String, available_at: Time?, idempotency_key: String?) -> Message
-    def create_message(instance, reference, message_name, arguments, kind:, available_at:, idempotency_key:)
+    # @rbs (instance: Instance, reference: Reference, operation: Symbol | String, arguments: untyped, delivery_mode: String, available_at: Time?, idempotency_key: String?) -> Message
+    def create_message(instance:, reference:, operation:, arguments:, delivery_mode:, available_at:, idempotency_key:)
       sequence = instance.next_message_sequence
       now = database_adapter.database_now
       scheduled_at = normalize_availability(available_at, now)
@@ -146,8 +153,8 @@ module SolidObjects
         instance:,
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s,
-        message_kind: kind,
+        operation: operation.to_s,
+        delivery_mode:,
         arguments:,
         sequence:,
         max_attempts: SolidObjects.configuration.max_attempts,

data/lib/solid_objects/operation_dispatcher.rb

@@ -0,0 +1,51 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class OperationDispatcher
+    # @rbs @actor_type: String
+    # @rbs @handlers: Hash[Symbol, ActorDefinition::Handler]
+    # @rbs @dispatch: Proc
+
+    # @rbs (actor_type: String, handlers: Hash[Symbol, ActorDefinition::Handler]) { (Symbol, Hash[Symbol, untyped]) -> untyped } -> void
+    def initialize(actor_type:, handlers:, &dispatch)
+      @actor_type = actor_type
+      @handlers = handlers.dup.freeze
+      @dispatch = dispatch
+    end
+
+    # @rbs (Symbol, *untyped, **untyped) -> untyped
+    def method_missing(name, *arguments, **keywords, &block)
+      raise UnknownMessage, "unknown message #{name.inspect} for #{actor_type}" unless handlers.key?(name)
+      if arguments.any? || block
+        raise ArgumentError, "actor operations accept keyword arguments only"
+      end
+
+      dispatch.call(name, keywords)
+    end
+
+    # @rbs (Symbol, bool) -> bool
+    def respond_to_missing?(name, include_private = false)
+      handlers.key?(name) || super
+    end
+
+    private
+
+    attr_reader :actor_type, :handlers, :dispatch
+
+    RESERVED_REFERENCE_METHOD_NAMES = %i[actor_type actor_id async sync destroy snapshot].freeze
+    RESERVED_OPERATION_NAMES = (
+      public_instance_methods(true) +
+      RESERVED_REFERENCE_METHOD_NAMES
+    ).map(&:to_sym).uniq.freeze
+
+    class << self
+      # @rbs (Symbol | String) -> void
+      def validate_operation_name!(name)
+        operation_name = name.to_sym
+        return unless RESERVED_OPERATION_NAMES.include?(operation_name)
+
+        raise InvalidActor, "#{operation_name.inspect} conflicts with actor dispatch"
+      end
+    end
+  end
+end

data/lib/solid_objects/payload_broadcast.rb

@@ -83,7 +83,7 @@ module SolidObjects
       authorized = SolidObjects.configuration.authorize_query.call(
         actor_type: snapshot.reference.actor_type,
         actor_id: snapshot.reference.actor_id,
-        message_name: name,
+        operation: name,
         arguments: {},
         authorization_context:
       )

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

@@ -19,15 +19,16 @@ module SolidObjects
       @shutdown_requested = false
     end
 
-    # @rbs () -> bool
-    def run_once
+    # @rbs (?now: Time?) -> bool
+    def run_once(now: nil)
       return false if stopped?
 
+      now = normalize_test_time(now)
       process_registry.heartbeat
-      reminder = claim_next
+      reminder = claim_next(now:)
       return false unless reminder
 
-      enqueue(reminder).present?
+      enqueue(reminder, now:).present?
     rescue
       release(reminder) if reminder
       raise
@@ -74,13 +75,14 @@ module SolidObjects
 
     attr_reader :process_registry, :database_adapter
 
-    # @rbs () -> Reminder?
-    def claim_next
+    # @rbs (now: Time?) -> Reminder?
+    def claim_next(now:)
       database_adapter.transaction do
-        now = database_adapter.database_now
-        stale_at = now - SolidObjects.configuration.process_alive_threshold
+        database_now = database_adapter.database_now
+        due_at = now || database_now
+        stale_at = database_now - SolidObjects.configuration.process_alive_threshold
         relation = Reminder
-          .where(status: "scheduled", next_run_at: ..now)
+          .where(status: "scheduled", next_run_at: ..due_at)
           .where("claimed_by IS NULL OR claimed_at <= ?", stale_at)
           .order(:next_run_at, :id)
         reminder = database_adapter.lock_candidates(relation).first
@@ -88,17 +90,17 @@ module SolidObjects
 
         reminder.update!(
           claimed_by: process_registry.process_record.id,
-          claimed_at: now
+          claimed_at: database_now
         )
         reminder
       end
     end
 
-    # @rbs (Reminder) -> MessageReference?
-    def enqueue(reminder)
+    # @rbs (Reminder, now: Time?) -> MessageReference?
+    def enqueue(reminder, now:)
       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:)
@@ -109,12 +111,12 @@ module SolidObjects
         locked_reminder = Reminder.lock.find_by(id: reminder.id)
         next unless locked_reminder
         verify_claim!(locked_reminder)
-        now = database_adapter.database_now
+        schedule_now = 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:
         )
@@ -122,7 +124,7 @@ module SolidObjects
         locked_reminder.update!(
           status: recurring ? "scheduled" : "completed",
           occurrence: locked_reminder.occurrence + 1,
-          next_run_at: recurring ? next_run_at(locked_reminder, now) : locked_reminder.next_run_at,
+          next_run_at: recurring ? next_run_at(locked_reminder, schedule_now) : locked_reminder.next_run_at,
           claimed_by: nil,
           claimed_at: nil
         )
@@ -164,5 +166,17 @@ module SolidObjects
       missed_intervals = ((now - next_run) / interval).floor + 1
       next_run + (missed_intervals * interval)
     end
+
+    # @rbs (Time?) -> Time?
+    def normalize_test_time(now)
+      return unless now
+
+      time = now.to_time
+      return time if time.to_f.finite?
+
+      raise ArgumentError
+    rescue ArgumentError, NoMethodError, RangeError
+      raise ArgumentError, "reminder test time must be a valid time"
+    end
   end
 end

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/test_helper.rb

@@ -68,6 +68,22 @@ module SolidObjects
       runners&.uniq&.each(&:stop)
     end
 
+    # @rbs (now: Time, ?max_reminders: Integer) -> Integer
+    def run_due_reminders(now:, max_reminders: 10_000)
+      unless max_reminders.is_a?(Integer) && max_reminders.positive?
+        raise ArgumentError, "max_reminders must be a positive integer"
+      end
+
+      scheduler = ReminderScheduler.new
+      processed = 0
+      while processed < max_reminders && scheduler.run_once(now:)
+        processed += 1
+      end
+      processed
+    ensure
+      scheduler&.stop
+    end
+
     private
 
     # @rbs (Array[Symbol]) -> Array[Worker | EffectExecutor | ReminderScheduler | BroadcastExecutor]

data/lib/solid_objects/turbo_stream_renderer.rb

@@ -16,14 +16,14 @@ module SolidObjects
         actor_type: broadcast.instance.actor_type,
         actor_id: broadcast.instance.actor_id
       )
-      stream = if broadcast.observable_name == PayloadBroadcast::REVISION_OBSERVABLE
-        ""
-      else
+      stream = if broadcast.broadcasts_value?
         observable_value(
-          reference,
-          broadcast.observable_name,
-          broadcast.value
+          reference:,
+          name: broadcast.observable_name,
+          value: broadcast.value
         )
+      else
+        ""
       end
       metadata = Base64.urlsafe_encode64(
         JSON.generate(
@@ -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.11.0"
+  VERSION = "0.12.1"
 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
@@ -87,8 +87,8 @@ module SolidObjects
     # @rbs (Symbol | String) { (*untyped, **untyped) -> untyped } -> ActorDefinition::Handler
     def self.query: (Symbol | String) { (*untyped, **untyped) -> untyped } -> ActorDefinition::Handler
 
-    # @rbs (Symbol | String) ?{ () -> untyped } -> ActorDefinition::Handler
-    def self.observable: (Symbol | String) ?{ () -> untyped } -> ActorDefinition::Handler
+    # @rbs (Symbol | String, ?broadcast: Symbol) ?{ () -> untyped } -> ActorDefinition::Handler
+    def self.observable: (Symbol | String, ?broadcast: Symbol) ?{ () -> untyped } -> ActorDefinition::Handler
 
     # @rbs (Symbol | String) { (untyped, untyped) -> untyped } -> ActorDefinition::Handler
     def self.broadcast_payload: (Symbol | String) { (untyped, untyped) -> untyped } -> ActorDefinition::Handler
@@ -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]