solid_objects 0.11.0 → 0.12.1

data/lib/solid_objects/component_registration.rb

@@ -156,8 +156,8 @@ module SolidObjects
       locals.merge("component_key" => component_key).freeze
     end
 
-    # @rbs (Array[ComponentRegistration], Integer, Integer) -> String
-    def batch_refresh_url(registrations, instance_id, revision)
+    # @rbs (registrations: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> String
+    def batch_refresh_url(registrations:, instance_id:, revision:)
       query = URI.encode_www_form(
         [
           [ "instance_id", instance_id ],

data/lib/solid_objects/component_renderer.rb

@@ -60,7 +60,7 @@ module SolidObjects
       authorized = SolidObjects.configuration.authorize_query.call(
         actor_type: snapshot.reference.actor_type,
         actor_id: snapshot.reference.actor_id,
-        message_name: observable_name,
+        operation: observable_name,
         arguments: registration.authorization_arguments,
         authorization_context:
       )

data/lib/solid_objects/component_subscriptions.rb

@@ -50,21 +50,21 @@ module SolidObjects
       revision = invalidation.fetch("revision")
       changed = registrations.select do |registration|
         registration.dependencies.include?(observable_name) &&
-          newer_revision?(registration.dom_id, instance_id, revision)
+          newer_revision?(dom_id: registration.dom_id, instance_id:, revision:)
       end
-      refresh_streams(changed, instance_id, revision)
+      refresh_streams(changed:, instance_id:, revision:)
     end
 
     # @rbs (ActorSnapshot) -> Array[String]
     def reconnect_refreshes(snapshot)
       stale = registrations.select do |registration|
         newer_revision?(
-          registration.dom_id,
-          snapshot.instance_id,
-          snapshot.revision
+          dom_id: registration.dom_id,
+          instance_id: snapshot.instance_id,
+          revision: snapshot.revision
         )
       end
-      refresh_streams(stale, snapshot.instance_id, snapshot.revision)
+      refresh_streams(changed: stale, instance_id: snapshot.instance_id, revision: snapshot.revision)
     end
 
     class << self
@@ -86,36 +86,36 @@ 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(changed, instance_id, revision)
+    # @rbs (changed: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> Array[String]
+    def refresh_streams(changed:, instance_id:, revision:)
       batched, individual = changed.partition(&:batch)
       streams = individual.map do |registration|
-        refresh(registration, instance_id, revision)
+        refresh(registration:, instance_id:, revision:)
       end
       batched.group_by(&:batch).each_value do |group|
-        group.each { |registration| record_revision(registration, instance_id, revision) }
-        streams << TurboStreamRenderer.batch_refresh(group, instance_id, revision)
+        group.each { |registration| record_revision(registration:, instance_id:, revision:) }
+        streams << TurboStreamRenderer.batch_refresh(registrations: group, instance_id:, revision:)
       end
       streams
     end
 
-    # @rbs (ComponentRegistration, Integer, Integer) -> void
-    def record_revision(registration, instance_id, revision)
+    # @rbs (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> void
+    def record_revision(registration:, instance_id:, revision:)
       revisions[registration.dom_id] = [ instance_id, revision ]
     end
 
-    # @rbs (ComponentRegistration, Integer, Integer) -> String
-    def refresh(registration, instance_id, revision)
-      record_revision(registration, instance_id, revision)
+    # @rbs (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> String
+    def refresh(registration:, instance_id:, revision:)
+      record_revision(registration:, instance_id:, revision:)
       TurboStreamRenderer.component_refresh(
-        registration,
-        instance_id,
-        revision
+        registration:,
+        instance_id:,
+        revision:
       )
     end
 
-    # @rbs (String, Integer, Integer) -> bool
-    def newer_revision?(dom_id, instance_id, revision)
+    # @rbs (dom_id: String, instance_id: Integer, revision: Integer) -> bool
+    def newer_revision?(dom_id:, instance_id:, revision:)
       current = revisions.fetch(dom_id)
       (current <=> [ instance_id, revision ]) == -1
     end

data/lib/solid_objects/database_adapters/sqlite.rb

@@ -141,7 +141,13 @@ module SolidObjects
       def deadline_error?(error)
         return false unless SyncDeadline.active?
 
-        busy_error?(error)
+        busy_error?(error) || reconnect_blocked_error?(error)
+      end
+
+      # @rbs (Exception) -> bool
+      def reconnect_blocked_error?(error)
+        error.message.include?("SQLite3::CantOpenException") &&
+          error.message.include?("PRAGMA journal_mode='wal'")
       end
 
       # @rbs (Exception) -> bool

data/lib/solid_objects/dead_letter_manager.rb

@@ -16,13 +16,13 @@ module SolidObjects
 
       original_message = dead_letter.message
       message_reference = Mailbox.new.enqueue(
-        Reference.new(
+        reference: Reference.new(
           actor_type: dead_letter.actor_type,
           actor_id: dead_letter.actor_id
         ),
-        dead_letter.message_name,
-        dead_letter.arguments,
-        kind: original_message.message_kind,
+        operation: dead_letter.operation,
+        arguments: dead_letter.arguments,
+        delivery_mode: original_message.delivery_mode,
         idempotency_key: "dead-letter:#{dead_letter.id}"
       )
       dead_letter.update!(retried_message_id: message_reference.id)

data/lib/solid_objects/doctor.rb

@@ -68,7 +68,7 @@ module SolidObjects
         activation_generation
       ],
       messages: %w[
-        id instance_id message_kind arguments sequence attempt_count request_id
+        id instance_id delivery_mode arguments sequence attempt_count request_id
         result error rejection completed_at rejected_at
       ],
       ready_messages: %w[id message_id instance_id sequence available_at],
@@ -76,7 +76,7 @@ module SolidObjects
         id message_id instance_id process_id activation_token
         activation_generation claimed_at
       ],
-      reminders: %w[id instance_id message_name next_run_at status],
+      reminders: %w[id instance_id operation next_run_at status],
       effects: %w[id message_id instance_id effect_id status available_at],
       broadcasts: %w[id message_id instance_id broadcast_id status available_at],
       dead_letters: %w[id message_id instance_id actor_type actor_id attempts]
@@ -247,10 +247,10 @@ module SolidObjects
       probe_registry.register(kind: "caller", metadata: { execution: "doctor" })
       value = SecureRandom.hex(8)
       message_reference = Mailbox.new.enqueue(
-        ProbeActor.ref(actor_id),
-        :ping,
-        { value: },
-        kind: "sync"
+        reference: ProbeActor.ref(actor_id),
+        operation: :ping,
+        arguments: { value: },
+        delivery_mode: "sync"
       )
       result = SynchronousInvocation
         .new(process_registry: probe_registry)
@@ -314,11 +314,11 @@ module SolidObjects
       }
       {
         authorize_message: actor_arguments.merge(
-          message_name: "ping",
+          operation: "ping",
           arguments: { "value" => "doctor" }
         ),
         authorize_query: actor_arguments.merge(
-          message_name: "value",
+          operation: "value",
           arguments: {}
         ),
         authorize_destroy: actor_arguments,

data/lib/solid_objects/effect_executor.rb

@@ -122,18 +122,18 @@ module SolidObjects
         actor_id: arguments.fetch("actor_id")
       )
       actor_class = SolidObjects.registry.fetch(reference.actor_type)
-      message_name = arguments.fetch("message_name")
-      unless actor_class.definition.messages.key?(message_name.to_sym)
-        raise UnknownMessage, "unknown actor-to-actor message #{message_name.inspect}"
+      operation = arguments.fetch("operation")
+      unless actor_class.definition.messages.key?(operation.to_sym)
+        raise UnknownMessage, "unknown actor-to-actor operation #{operation.inspect}"
       end
 
       available_at = arguments["available_at"]
       available_at = Time.iso8601(available_at) if available_at
       Mailbox.new.enqueue(
-        reference,
-        message_name,
-        arguments.fetch("arguments"),
-        kind: "internal",
+        reference:,
+        operation:,
+        arguments: arguments.fetch("arguments"),
+        delivery_mode: "internal",
         available_at:,
         idempotency_key: effect.effect_id
       ).id
@@ -150,10 +150,14 @@ module SolidObjects
         locked_effect = Effect.lock.find(effect.id)
         verify_claim!(locked_effect)
         result_message = enqueue_result_message(
-          locked_effect,
-          locked_effect.success_message_name,
-          "success",
-          { "effect_id" => locked_effect.effect_id, "result" => serialized_result }
+          effect: locked_effect,
+          operation: locked_effect.success_operation,
+          outcome: "success",
+          arguments: {
+            "effect_id" => locked_effect.effect_id,
+            "arguments" => locked_effect.arguments,
+            "result" => serialized_result
+          }
         )
         locked_effect.update!(
           status: "completed",
@@ -188,10 +192,14 @@ module SolidObjects
         }
         if dead
           result_message = enqueue_result_message(
-            locked_effect,
-            locked_effect.failure_message_name,
-            "failure",
-            { "effect_id" => locked_effect.effect_id, "error" => error_details }
+            effect: locked_effect,
+            operation: locked_effect.failure_operation,
+            outcome: "failure",
+            arguments: {
+              "effect_id" => locked_effect.effect_id,
+              "arguments" => locked_effect.arguments,
+              "error" => error_details
+            }
           )
         end
         locked_effect.update!(
@@ -216,18 +224,18 @@ module SolidObjects
       raise LostActivation, "effect claim changed"
     end
 
-    # @rbs (Effect, String?, String, Hash[String, untyped]) -> Message?
-    def enqueue_result_message(effect, message_name, outcome, arguments)
-      return unless message_name
+    # @rbs (effect: Effect, operation: String?, outcome: String, arguments: Hash[String, untyped]) -> Message?
+    def enqueue_result_message(effect:, operation:, outcome:, arguments:)
+      return unless operation
 
       Mailbox.new.enqueue_in_transaction(
-        Reference.new(
+        reference: Reference.new(
           actor_type: effect.instance.actor_type,
           actor_id: effect.instance.actor_id
         ),
-        message_name,
-        arguments,
-        kind: "internal",
+        operation:,
+        arguments:,
+        delivery_mode: "internal",
         idempotency_key: "effect:#{effect.effect_id}:#{outcome}"
       )
     end

data/lib/solid_objects/errors.rb

@@ -68,19 +68,19 @@ module SolidObjects
     # @rbs @timeout: Numeric
     # @rbs @actor_type: String
     # @rbs @actor_id: String
-    # @rbs @message_name: String
+    # @rbs @operation: String
 
-    attr_reader :timeout, :actor_type, :actor_id, :message_name
+    attr_reader :timeout, :actor_type, :actor_id, :operation
 
-    # @rbs (timeout: Numeric, actor_type: String, actor_id: String, message_name: String) -> void
-    def initialize(timeout:, actor_type:, actor_id:, message_name:)
+    # @rbs (timeout: Numeric, actor_type: String, actor_id: String, operation: String) -> void
+    def initialize(timeout:, actor_type:, actor_id:, operation:)
       @timeout = timeout
       @actor_type = actor_type
       @actor_id = actor_id
-      @message_name = message_name
+      @operation = operation
       super(
         "actor invocation could not be durably enqueued within #{timeout} seconds for " \
-          "#{actor_type}(#{actor_id.inspect}).#{message_name}"
+          "#{actor_type}(#{actor_id.inspect}).#{operation}"
       )
     end
   end
@@ -89,7 +89,7 @@ module SolidObjects
     # @rbs @timeout: Numeric
     # @rbs @actor_type: String
     # @rbs @actor_id: String
-    # @rbs @message_name: String
+    # @rbs @operation: String
     # @rbs @message_id: Integer
     # @rbs @request_id: String
     # @rbs @sequence: Integer
@@ -101,7 +101,7 @@ module SolidObjects
     attr_reader :timeout,
       :actor_type,
       :actor_id,
-      :message_name,
+      :operation,
       :message_id,
       :request_id,
       :sequence,
@@ -110,12 +110,12 @@ module SolidObjects
       :activation,
       :blocker
 
-    # @rbs (timeout: Numeric, actor_type: String, actor_id: String, message_name: String, message_id: Integer, request_id: String, sequence: Integer, status: String, waiting_on: String, activation: Hash[String, untyped], blocker: Hash[String, untyped]?) -> void
+    # @rbs (timeout: Numeric, actor_type: String, actor_id: String, operation: String, message_id: Integer, request_id: String, sequence: Integer, status: String, waiting_on: String, activation: Hash[String, untyped], blocker: Hash[String, untyped]?) -> void
     def initialize(
       timeout:,
       actor_type:,
       actor_id:,
-      message_name:,
+      operation:,
       message_id:,
       request_id:,
       sequence:,
@@ -127,7 +127,7 @@ module SolidObjects
       @timeout = timeout
       @actor_type = actor_type
       @actor_id = actor_id
-      @message_name = message_name
+      @operation = operation
       @message_id = message_id
       @request_id = request_id
       @sequence = sequence
@@ -137,7 +137,7 @@ module SolidObjects
       @blocker = Serialization.readonly_copy(blocker)
       super(
         "actor invocation timed out after #{timeout} seconds for " \
-          "#{actor_type}(#{actor_id.inspect}).#{message_name} " \
+          "#{actor_type}(#{actor_id.inspect}).#{operation} " \
           "message_id=#{message_id} sequence=#{sequence} status=#{status} waiting_on=#{waiting_on}"
       )
     end
@@ -157,17 +157,17 @@ module SolidObjects
   class SyncInsideTransaction < Error
     # @rbs @actor_type: String
     # @rbs @actor_id: String
-    # @rbs @message_name: String
+    # @rbs @operation: String
 
-    attr_reader :actor_type, :actor_id, :message_name
+    attr_reader :actor_type, :actor_id, :operation
 
-    # @rbs (actor_type: String, actor_id: String, message_name: String) -> void
-    def initialize(actor_type:, actor_id:, message_name:)
+    # @rbs (actor_type: String, actor_id: String, operation: String) -> void
+    def initialize(actor_type:, actor_id:, operation:)
       @actor_type = actor_type
       @actor_id = actor_id
-      @message_name = message_name
+      @operation = operation
       super(
-        "cannot synchronously invoke #{actor_type}(#{actor_id.inspect}).#{message_name} " \
+        "cannot synchronously invoke #{actor_type}(#{actor_id.inspect}).#{operation} " \
           "inside an open database transaction; call it before the transaction or enqueue it with async"
       )
     end
@@ -176,27 +176,27 @@ module SolidObjects
   class ApplicationWriteForbidden < NonRetryableError
     # @rbs @actor_type: String
     # @rbs @actor_id: String
-    # @rbs @message_name: String
+    # @rbs @operation: String
 
-    attr_reader :actor_type, :actor_id, :message_name
+    attr_reader :actor_type, :actor_id, :operation
 
-    # @rbs (actor_type: String, actor_id: String, message_name: String) -> void
-    def initialize(actor_type:, actor_id:, message_name:)
+    # @rbs (actor_type: String, actor_id: String, operation: String) -> void
+    def initialize(actor_type:, actor_id:, operation:)
       @actor_type = actor_type
       @actor_id = actor_id
-      @message_name = message_name
+      @operation = operation
       super(
-        "#{actor_type}(#{actor_id.inspect}).#{message_name} attempted an Active Record write; " \
+        "#{actor_type}(#{actor_id.inspect}).#{operation} attempted an Active Record write; " \
           "mutate actor state, stage a commit action, or emit a durable effect instead"
       )
     end
   end
 
   class CommitActionUnavailable < NonRetryableError
-    # @rbs (actor_type: String, actor_id: String, message_name: String) -> void
-    def initialize(actor_type:, actor_id:, message_name:)
+    # @rbs (actor_type: String, actor_id: String, operation: String) -> void
+    def initialize(actor_type:, actor_id:, operation:)
       super(
-        "#{actor_type}(#{actor_id.inspect}).#{message_name} staged a commit action, " \
+        "#{actor_type}(#{actor_id.inspect}).#{operation} staged a commit action, " \
           "but Solid Objects uses a separate database from Active Record"
       )
     end
@@ -205,6 +205,9 @@ module SolidObjects
   class UnknownCommitAction < NonRetryableError
   end
 
+  class InvalidRejectionCode < NonRetryableError
+  end
+
   class Rejected < Error
     # @rbs @code: String
     # @rbs @details: Hash[String, untyped]

data/lib/solid_objects/executor.rb

@@ -55,17 +55,17 @@ module SolidObjects
     # @rbs (MessageContext) -> untyped
     def invoke_actor(message_context)
       Context.with(actor:, message: message_context) do
-        actor.invoke(message.message_name, message.arguments)
+        actor.invoke(message.operation, message.arguments)
       end
     end
 
     # @rbs (Hash[String, untyped]) -> void
     def ensure_query_did_not_mutate_state!(state_before)
-      return unless message.message_kind == "sync"
-      return unless actor.class.definition.queries.key?(message.message_name.to_sym)
+      return unless message.delivery_mode == "sync"
+      return unless actor.class.definition.queries.key?(message.operation.to_sym)
       return if actor.state.to_h == state_before
 
-      raise InvalidActor, "query #{message.message_name.inspect} mutated actor state"
+      raise InvalidActor, "query #{message.operation.inspect} mutated actor state"
     end
 
     # @rbs (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
@@ -82,7 +82,7 @@ module SolidObjects
         max_bytes: SolidObjects.configuration.max_state_bytes
       )
       serialized_result = Serialization.dump(
-        (message.message_kind == "sync") ? result : nil,
+        (message.delivery_mode == "sync") ? result : nil,
         max_bytes: SolidObjects.configuration.max_result_bytes
       )
       effect_intents = actor.drain_effect_intents
@@ -112,15 +112,17 @@ module SolidObjects
           error: nil,
           completed_at: SolidObjects.database_adapter.database_now
         )
-        enqueued_effects.concat(enqueue_effects(locked_message, instance, effect_intents))
+        enqueued_effects.concat(
+          enqueue_effects(message: locked_message, instance:, intents: effect_intents)
+        )
         moved_reminders.concat(schedule_reminders(instance, reminder_intents))
         enqueued_effects.concat(
-          enqueue_actor_messages(locked_message, instance, outbound_message_intents)
+          enqueue_actor_messages(message: locked_message, instance:, intents: outbound_message_intents)
         )
         enqueue_broadcasts(
-          locked_message,
-          instance,
-          observable_changes,
+          message: locked_message,
+          instance:,
+          observable_changes:,
           state_changed:
         )
         claimed_message.destroy!
@@ -163,12 +165,12 @@ module SolidObjects
 
       intents.each do |intent|
         handler = SolidObjects.commit_action_registry.fetch(intent.name)
-        execute_commit_action(intent, handler, context)
+        execute_commit_action(intent:, handler:, context:)
       end
     end
 
-    # @rbs (Actor::CommitActionIntent, Proc, CommitActionContext) -> untyped
-    def execute_commit_action(intent, handler, context)
+    # @rbs (intent: Actor::CommitActionIntent, handler: Proc, context: CommitActionContext) -> untyped
+    def execute_commit_action(intent:, handler:, context:)
       payload = {
         commit_action_name: intent.name,
         message_id: message.id,
@@ -198,21 +200,21 @@ module SolidObjects
       raise CommitActionUnavailable.new(
         actor_type: message.actor_type,
         actor_id: message.actor_id,
-        message_name: message.message_name
+        operation: message.operation
       )
     end
 
-    # @rbs (Message, Instance, Array[Actor::EffectIntent]) -> Array[Effect]
-    def enqueue_effects(locked_message, instance, intents)
+    # @rbs (message: Message, instance: Instance, intents: Array[Actor::EffectIntent]) -> Array[Effect]
+    def enqueue_effects(message:, instance:, intents:)
       intents.map do |intent|
         Effect.create!(
-          message: locked_message,
+          message:,
           instance:,
           effect_id: SecureRandom.uuid,
           name: intent.name,
           arguments: intent.arguments,
-          success_message_name: intent.success_message_name,
-          failure_message_name: intent.failure_message_name,
+          success_operation: intent.success_operation,
+          failure_operation: intent.failure_operation,
           status: "pending",
           max_attempts: SolidObjects.configuration.max_attempts,
           available_at: SolidObjects.database_adapter.database_now
@@ -237,7 +239,7 @@ module SolidObjects
         reminder.assign_attributes(
           actor_type: instance.actor_type,
           actor_id: instance.actor_id,
-          message_name: intent.name,
+          operation: intent.name,
           arguments: intent.arguments,
           next_run_at: intent.at,
           interval_seconds: intent.interval_seconds,
@@ -268,18 +270,18 @@ module SolidObjects
       }
     end
 
-    # @rbs (Message, Instance, Array[Actor::OutboundMessageIntent]) -> Array[Effect]
-    def enqueue_actor_messages(locked_message, instance, intents)
+    # @rbs (message: Message, instance: Instance, intents: Array[Actor::OutboundMessageIntent]) -> Array[Effect]
+    def enqueue_actor_messages(message:, instance:, intents:)
       intents.map do |intent|
         Effect.create!(
-          message: locked_message,
+          message:,
           instance:,
           effect_id: SecureRandom.uuid,
           name: EffectExecutor::ACTOR_MESSAGE_EFFECT,
           arguments: {
             "actor_type" => intent.actor_type,
             "actor_id" => intent.actor_id,
-            "message_name" => intent.message_name,
+            "operation" => intent.operation,
             "arguments" => intent.arguments,
             "available_at" => intent.available_at&.iso8601(6),
             "idempotency_key" => intent.idempotency_key
@@ -291,20 +293,26 @@ module SolidObjects
       end
     end
 
-    # @rbs (Message, Instance, Hash[String, untyped], state_changed: bool) -> void
-    def enqueue_broadcasts(locked_message, instance, observable_changes, state_changed:)
+    # @rbs (message: Message, instance: Instance, observable_changes: Hash[String, untyped], state_changed: bool) -> void
+    def enqueue_broadcasts(message:, instance:, observable_changes:, state_changed:)
       broadcasts = observable_changes
       if broadcasts.empty? && state_changed && payload_broadcasts?
         broadcasts = { PayloadBroadcast::REVISION_OBSERVABLE => {} }
       end
 
       broadcasts.each do |observable_name, value|
+        stored_value = if observable_name != PayloadBroadcast::REVISION_OBSERVABLE &&
+            actor.class.definition.broadcasts_observable_value?(observable_name)
+          value
+        else
+          {}
+        end
         Broadcast.create!(
-          message: locked_message,
+          message:,
           instance:,
           broadcast_id: SecureRandom.uuid,
           observable_name:,
-          value:,
+          value: stored_value,
           state_version: actor.class.state_version,
           activation_generation: activation.lease.generation,
           status: "pending",
@@ -332,7 +340,7 @@ module SolidObjects
 
         if error.is_a?(NonRetryableError) ||
             locked_message.attempt_count >= locked_message.max_attempts
-          create_dead_letter(locked_message, error_details, now)
+          create_dead_letter(message: locked_message, error_details:, now:)
           dead = true
         else
           ReadyMessage.create!(
@@ -410,20 +418,20 @@ module SolidObjects
       )
     end
 
-    # @rbs (Message, Hash[String, untyped], Time) -> DeadLetter
-    def create_dead_letter(locked_message, error_details, now)
+    # @rbs (message: Message, error_details: Hash[String, untyped], now: Time) -> DeadLetter
+    def create_dead_letter(message:, error_details:, now:)
       DeadLetter.create!(
-        message: locked_message,
-        instance: locked_message.instance,
-        actor_type: locked_message.actor_type,
-        actor_id: locked_message.actor_id,
-        message_name: locked_message.message_name,
-        arguments: locked_message.arguments,
-        attempts: locked_message.attempt_count,
+        message:,
+        instance: message.instance,
+        actor_type: message.actor_type,
+        actor_id: message.actor_id,
+        operation: message.operation,
+        arguments: message.arguments,
+        attempts: message.attempt_count,
         exception_class: error_details.fetch("class"),
         exception_message: error_details.fetch("message"),
         backtrace: error_details.fetch("backtrace"),
-        first_failed_at: locked_message.last_failed_at || now,
+        first_failed_at: message.last_failed_at || now,
         last_failed_at: now
       )
     end

data/lib/solid_objects/lease.rb

@@ -11,7 +11,7 @@ module SolidObjects
         now:,
         database_adapter:, duration: SolidObjects.configuration.lease_duration
       )
-        return if held_by_another_live_owner?(instance, activation_token, now)
+        return if held_by_another_live_owner?(instance:, activation_token:, now:)
 
         generation = instance.activation_generation + 1
         expires_at = now + duration
@@ -61,8 +61,8 @@ module SolidObjects
 
       private
 
-      # @rbs (Instance, String, Time) -> bool
-      def held_by_another_live_owner?(instance, activation_token, now)
+      # @rbs (instance: Instance, activation_token: String, now: Time) -> bool
+      def held_by_another_live_owner?(instance:, activation_token:, now:)
         instance.activation_owner_id.present? &&
           instance.activation_token != activation_token &&
           instance.activation_expires_at.present? &&