solid_objects 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f8876ae7a3b7de88ef10870bf9fb32e73e74969571a6b1f21e83cd88f3933ee
-  data.tar.gz: 6c72ffa8e6e77b6f50b2a2c3f76c470aa136cac490006316810751175a391e5d
+  metadata.gz: 8e027a73cc399aa779d8a60acae69f3f379ce505e060123ad49d5d64dcda4809
+  data.tar.gz: 5eb1be4b51649c2c8e6056f0138f130f4f1a8cf2e55e46f86061fc82849658aa
 SHA512:
-  metadata.gz: e66ea0877bc3dd4e45726ea6361650c0fc02ba1ee0fd6dc00c0588f8080626b687d113fcf02941ff2466146adfa10e8cd8a27026b660509d62e8ca425fbe5fcb
-  data.tar.gz: 11a6f7c4e27551cfe4389e58edfacbd10c1b05ab17d0e6cbcc75f25f375257fe959237a5beb076d18941c89d33c76239444de57c2d8cb9d185ff33b239752d64
+  metadata.gz: 7f36f021e2707bbd67fcca022a88a4aa70b5cc35f8175c0ee526defcfb66fb1d3113434d8f700aad1f813ca9ccf49bc6a7e59e8d7c95717f007a660ca7535bd4
+  data.tar.gz: 246e46e83aae40b366992c7c5e763dc65e00945d57b0c0e724595d2f6af0a66ea5c09d5d4dbc5f4c4bdc1ed4de6766d217560e6b376832a98afab158f82e16ea

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.4.3 - 2026-08-07
+
+- Bound SQLite caller-process registration, reuse, heartbeat, and synchronous
+  result observation retries by the original invocation deadline.
+- Load host application actors from `app/actors` before CLI workers start,
+  including development environments with eager loading disabled.
+
 ## 0.4.2 - 2026-08-07
 
 - Decode Action Cable broadcast payloads before parsing observable invalidations

data/README.md

@@ -588,9 +588,9 @@ polling as the fallback. A timeout never cancels the durable invocation.
 durable status, mailbox blocker, and activation-owner diagnostics without
 including message arguments. The configured timeout also bounds adapter
 database lock waits from the enqueue attempt through result observation.
-PostgreSQL uses transaction lock and statement timeouts, SQLite uses its busy
-timeout, and MySQL uses its execution timeout plus InnoDB's one-second minimum
-lock-wait granularity.
+PostgreSQL uses transaction lock and statement timeouts, SQLite retries busy
+coordination operations only until the original call deadline, and MySQL uses
+its execution timeout plus InnoDB's one-second minimum lock-wait granularity.
 
 The durable call can finish after its original caller gives up. Reauthorize and
 recover its eventual result through the durable message identity:
@@ -896,6 +896,11 @@ and marks process rows stopped on graceful shutdown. A hard-killed worker's
 claimed turn is recovered after its process heartbeat or activation lease
 becomes stale.
 
+Before any role starts, the CLI loads actors from the host application's
+`app/actors` directories through Rails' main autoloader. This works when
+development eager loading is disabled and does not require actor references in
+an initializer.
+
 See the [operations guide](docs/operations.md) for monitoring, reconciliation,
 shutdown, retention, and backup guidance.
 

data/docs/correctness.md

@@ -155,10 +155,13 @@ Timeout raises `SolidObjects::SyncTimeout` but does not cancel the message.
 The exception reports actor identity, message ID and sequence, durable status,
 an earlier mailbox blocker, and activation-owner metadata without exposing
 arguments. Its `message_reference` can reauthorize and wait for the eventual
-result. Adapter lock/query deadlines cover the durable enqueue and coordination
-transactions. If enqueue cannot commit, `SyncEnqueueTimeout` is raised and no
-message reference exists. MySQL lock waits have one-second InnoDB granularity.
-Ruby handlers that already started are not preempted.
+result. Adapter lock/query deadlines cover the durable enqueue, caller-process
+registration and heartbeat, activation coordination, and result observation.
+SQLite retries busy coordination operations only within the original call
+deadline and reports `waiting_on=database_contention` when the database cannot
+be inspected at timeout. If enqueue cannot commit, `SyncEnqueueTimeout` is
+raised and no message reference exists. MySQL lock waits have one-second InnoDB
+granularity. Ruby handlers that already started are not preempted.
 
 A synchronous call made while the Solid Objects connection already has an open
 transaction raises `SolidObjects::SyncInsideTransaction` before the message is

data/docs/operations.md

@@ -23,6 +23,12 @@ Start all configured roles:
 bundle exec solid_objects start
 ```
 
+The command loads the host application's `app/actors` directories before
+starting any runtime role, even when Rails eager loading is disabled. Actors in
+the conventional directory do not need initializer references. The targeted
+loader participates in Rails preparation callbacks so a development reload can
+replace a registered actor class without loading unrelated application code.
+
 Inspect process records and clean stale ownership:
 
 ```bash

data/lib/solid_objects/activation.rb

@@ -13,7 +13,9 @@ module SolidObjects
     # @rbs (lease: Lease) -> void
     def initialize(lease:)
       @lease = lease
-      instance = Instance.find(lease.instance_id)
+      instance = SolidObjects.database_adapter.with_lock_retry do
+        Instance.find(lease.instance_id)
+      end
       @actor_class = SolidObjects.registry.fetch(instance.actor_type)
       @actor = build_actor(instance)
       @last_used_at = monotonic_now
@@ -74,10 +76,12 @@ module SolidObjects
 
     # @rbs () -> void
     def yield_ready_messages
-      now = SolidObjects.database_adapter.database_now
-      ReadyMessage
-        .where(instance_id: lease.instance_id, available_at: ..now)
-        .update_all(available_at: now)
+      SolidObjects.database_adapter.transaction do
+        now = SolidObjects.database_adapter.database_now
+        ReadyMessage
+          .where(instance_id: lease.instance_id, available_at: ..now)
+          .update_all(available_at: now)
+      end
     end
 
     # @rbs (Hash[String, untyped]) -> void

data/lib/solid_objects/actor_registry.rb

@@ -18,7 +18,7 @@ module SolidObjects
 
       mutex.synchronize do
         existing = actors[actor_type]
-        if existing && existing != actor_class
+        if existing && existing != actor_class && !reload_of?(existing, actor_class)
           raise InvalidActor, "#{actor_type.inspect} is already registered by #{existing.name}"
         end
 
@@ -61,5 +61,10 @@ module SolidObjects
 
       raise InvalidActor, "registered actor must inherit from SolidObjects::Actor"
     end
+
+    # @rbs (Class, Class) -> bool
+    def reload_of?(existing, candidate)
+      !existing.name.nil? && existing.name == candidate.name
+    end
   end
 end

data/lib/solid_objects/application_actor_loader.rb

@@ -0,0 +1,53 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class ApplicationActorLoader
+    # @rbs @application: untyped
+    # @rbs @autoloader: untyped
+
+    # @rbs (?application: untyped, ?autoloader: untyped) -> void
+    def initialize(application: Rails.application, autoloader: Rails.autoloaders.main)
+      @application = application
+      @autoloader = autoloader
+    end
+
+    # @rbs () -> void
+    def call
+      actor_directories.each { |directory| autoloader.eager_load_dir(directory) }
+      current_actor_classes.each(&:ensure_registered!)
+    end
+
+    # @rbs () -> void
+    def install
+      application.reloader.to_prepare { call }
+      call
+    end
+
+    private
+
+    attr_reader :application, :autoloader
+
+    # @rbs () -> Array[String]
+    def actor_directories
+      configured_directories = application.paths["app/actors"]&.existent || []
+      conventional_directories = application.paths["app"].existent.select do |application_directory|
+        File.basename(application_directory) == "actors"
+      end
+      managed_directories = autoloader.dirs.map { |directory| File.expand_path(directory) }
+
+      (configured_directories + conventional_directories)
+        .select { |directory| Dir.exist?(directory) }
+        .map { |directory| File.expand_path(directory) }
+        .select { |directory| managed_directories.include?(directory) }
+        .uniq
+    end
+
+    # @rbs () -> Array[Class]
+    def current_actor_classes
+      Actor.descendants.select do |actor_class|
+        actor_class.name &&
+          actor_class.name.safe_constantize.equal?(actor_class)
+      end
+    end
+  end
+end

data/lib/solid_objects/caller_process.rb

@@ -52,19 +52,21 @@ module SolidObjects
     def reusable_registry?
       return false unless registry&.process_record
 
-      registry.process_record.reload.shutdown_state == "running"
+      SolidObjects.database_adapter.with_lock_retry do
+        registry.process_record.reload.shutdown_state == "running"
+      end
     rescue ActiveRecord::RecordNotFound
       false
     end
 
     # @rbs () -> ProcessRegistry
     def register
-      @registry = ProcessRegistry.new
-      registry.register(
+      process_registry = ProcessRegistry.new
+      process_registry.register(
         kind: "caller",
         metadata: { execution: "synchronous" }
       )
-      registry
+      @registry = process_registry
     end
 
     # @rbs () -> void

data/lib/solid_objects/cli.rb

@@ -1,6 +1,7 @@
 # rbs_inline: enabled
 
 require "thor"
+require "solid_objects/application_actor_loader"
 
 module SolidObjects
   class CLI < Thor
@@ -133,6 +134,7 @@ module SolidObjects
       end
 
       require path
+      ApplicationActorLoader.new.install
     end
 
     # @rbs (Symbol, Integer) -> Integer

data/lib/solid_objects/client.rb

@@ -65,27 +65,33 @@ module SolidObjects
 
     # @rbs (MessageReference, timeout: Numeric, ?authorization_context: untyped) -> untyped
     def wait(message_reference, timeout:, authorization_context: nil)
-      message = Message.find(message_reference.id)
-      validate_message_reference!(message_reference, message)
-      reference = Reference.new(
-        actor_type: message.actor_type,
-        actor_id: message.actor_id
-      )
-      actor_class = SolidObjects.registry.fetch(reference.actor_type)
-      query = actor_class.definition.queries.key?(message.message_name.to_sym)
-      actor_message = actor_class.definition.messages.key?(message.message_name.to_sym)
-      unless query || actor_message
-        raise UnknownMessage, "unknown message #{message.message_name.inspect}"
+      SyncDeadline.with(timeout:) do
+        message = SolidObjects.database_adapter.with_lock_retry do
+          Message.find(message_reference.id)
+        end
+        validate_message_reference!(message_reference, message)
+        reference = Reference.new(
+          actor_type: message.actor_type,
+          actor_id: message.actor_id
+        )
+        actor_class = SolidObjects.registry.fetch(reference.actor_type)
+        query = actor_class.definition.queries.key?(message.message_name.to_sym)
+        actor_message = actor_class.definition.messages.key?(message.message_name.to_sym)
+        unless query || actor_message
+          raise UnknownMessage, "unknown message #{message.message_name.inspect}"
+        end
+        authorize!(
+          query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
+          reference,
+          message.message_name,
+          message.arguments,
+          authorization_context:
+        )
+        reject_sync_inside_transaction!(reference, message.message_name)
+        SynchronousInvocation.new.call(message_reference, timeout:)
       end
-      authorize!(
-        query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
-        reference,
-        message.message_name,
-        message.arguments,
-        authorization_context:
-      )
-      reject_sync_inside_transaction!(reference, message.message_name)
-      SynchronousInvocation.new.call(message_reference, timeout:)
+    rescue DatabaseDeadlineExceeded
+      raise SyncDiagnostics.new.database_contention_for(message_reference, timeout:)
     end
 
     # @rbs (Reference, ?authorization_context: untyped) -> StateSnapshot

data/lib/solid_objects/database_adapter.rb

@@ -52,6 +52,16 @@ module SolidObjects
       value.is_a?(Time) ? value.utc : Time.parse("#{value} UTC").utc
     end
 
+    # @rbs () { () -> untyped } -> untyped
+    def with_lock_retry
+      yield
+    end
+
+    # @rbs () { () -> untyped } -> untyped
+    def with_lock_probe
+      yield
+    end
+
     # @rbs () { () -> untyped } -> untyped
     def transaction(&block)
       raise DatabaseDeadlineExceeded, "synchronous invocation deadline expired" if SyncDeadline.expired?

data/lib/solid_objects/database_adapters/sqlite.rb

@@ -4,6 +4,8 @@ module SolidObjects
   module DatabaseAdapters
     class Sqlite < DatabaseAdapter
       LOCK_RETRY_INTERVAL = 0.001
+      LOCK_RETRY_MUTEX = Thread::Mutex.new
+      LOCK_RETRY_CONDITION = Thread::ConditionVariable.new
 
       # @rbs () -> String
       def current_time_expression
@@ -14,14 +16,51 @@ module SolidObjects
       def transaction(&block)
         return super unless SyncDeadline.active?
 
-        super
+        with_lock_retry { super }
+      end
+
+      # @rbs () { () -> untyped } -> untyped
+      def with_lock_retry
+        return yield unless SyncDeadline.active?
+
+        raise DatabaseDeadlineExceeded, "synchronous invocation deadline expired" if SyncDeadline.expired?
+
+        with_connection do |connection|
+          with_transaction_deadline(connection) { yield }
+        end
       rescue DatabaseDeadlineExceeded
         raise if SyncDeadline.expired?
 
-        sleep [ LOCK_RETRY_INTERVAL, SyncDeadline.remaining ].min
+        wait_before_retry
+        retry
+      rescue => error
+        raise unless deadline_error?(error)
+
+        if SyncDeadline.expired?
+          raise DatabaseDeadlineExceeded,
+            "database lock wait exceeded the synchronous invocation deadline",
+            cause: error
+        end
+
+        wait_before_retry
         retry
       end
 
+      # @rbs () { () -> untyped } -> untyped
+      def with_lock_probe
+        return yield unless SyncDeadline.active?
+
+        with_connection do |connection|
+          with_transaction_deadline(connection) { yield }
+        end
+      rescue => error
+        raise unless deadline_error?(error)
+
+        raise DatabaseDeadlineExceeded,
+          "database remained locked at the synchronous invocation deadline",
+          cause: error
+      end
+
       private
 
       # @rbs (untyped) { () -> untyped } -> untyped
@@ -47,6 +86,16 @@ module SolidObjects
         end
         false
       end
+
+      # @rbs () -> void
+      def wait_before_retry
+        LOCK_RETRY_MUTEX.synchronize do
+          LOCK_RETRY_CONDITION.wait(
+            LOCK_RETRY_MUTEX,
+            [ LOCK_RETRY_INTERVAL, SyncDeadline.remaining ].min
+          )
+        end
+      end
     end
   end
 end

data/lib/solid_objects/process_registry.rb

@@ -80,18 +80,21 @@ module SolidObjects
 
     # @rbs (?kind: String, ?metadata: Hash[String | Symbol, untyped]) -> Process
     def register(kind: "worker", metadata: {})
-      now = SolidObjects.database_adapter.database_now
-      @process_record = Process.create!(
-        id: SecureRandom.uuid,
-        kind:,
-        hostname: Socket.gethostname,
-        pid: ::Process.pid,
-        started_at: now,
-        last_heartbeat_at: now,
-        metadata: Serialization.dump(default_metadata.merge(metadata))
-      )
+      process_record = SolidObjects.database_adapter.with_lock_retry do
+        now = SolidObjects.database_adapter.database_now
+        Process.create!(
+          id: SecureRandom.uuid,
+          kind:,
+          hostname: Socket.gethostname,
+          pid: ::Process.pid,
+          started_at: now,
+          last_heartbeat_at: now,
+          metadata: Serialization.dump(default_metadata.merge(metadata))
+        )
+      end
+      @process_record = process_record
       @last_heartbeat_at = monotonic_now
-      @process_record
+      process_record
     end
 
     # @rbs () -> bool
@@ -99,9 +102,13 @@ module SolidObjects
       return false unless process_record
       return false if heartbeat_recent?
 
-      process_record.update(
-        last_heartbeat_at: SolidObjects.database_adapter.database_now
-      ).tap { @last_heartbeat_at = monotonic_now }
+      updated = SolidObjects.database_adapter.with_lock_retry do
+        process_record.update(
+          last_heartbeat_at: SolidObjects.database_adapter.database_now
+        )
+      end
+      @last_heartbeat_at = monotonic_now if updated
+      updated
     end
 
     # @rbs () -> bool

data/lib/solid_objects/sync_diagnostics.rb

@@ -10,6 +10,62 @@ module SolidObjects
       status = message_status(message)
       waiting_on = waiting_reason(message, instance, blocker)
       activation = activation_details(instance)
+      build_error(
+        message,
+        timeout:,
+        status:,
+        waiting_on:,
+        activation:,
+        blocker: blocker_details(blocker)
+      )
+    end
+
+    # @rbs (Message, timeout: Numeric) -> SyncTimeout
+    def database_contention(message, timeout:)
+      build_error(
+        message,
+        timeout:,
+        status: "unknown",
+        waiting_on: "database_contention",
+        activation: {},
+        blocker: nil
+      )
+    end
+
+    # @rbs (MessageReference, timeout: Numeric) -> SyncTimeout
+    def database_contention_for(message_reference, timeout:)
+      error = SyncTimeout.new(
+        timeout:,
+        actor_type: message_reference.actor_type,
+        actor_id: message_reference.actor_id,
+        message_name: "unknown",
+        message_id: message_reference.id,
+        request_id: message_reference.request_id,
+        sequence: message_reference.sequence,
+        status: "unknown",
+        waiting_on: "database_contention",
+        activation: {},
+        blocker: nil
+      )
+      SolidObjects.instrument(
+        :"sync.timeout",
+        message_id: message_reference.id,
+        request_id: message_reference.request_id,
+        actor_type: message_reference.actor_type,
+        actor_id: message_reference.actor_id,
+        sequence: message_reference.sequence,
+        status: "unknown",
+        waiting_on: "database_contention",
+        activation_owner_id: nil,
+        activation_generation: nil
+      )
+      error
+    end
+
+    private
+
+    # @rbs (Message, timeout: Numeric, status: String, waiting_on: String, activation: Hash[String, untyped], blocker: Hash[String, untyped]?) -> SyncTimeout
+    def build_error(message, timeout:, status:, waiting_on:, activation:, blocker:)
       error = SyncTimeout.new(
         timeout:,
         actor_type: message.actor_type,
@@ -21,7 +77,7 @@ module SolidObjects
         status:,
         waiting_on:,
         activation:,
-        blocker: blocker_details(blocker)
+        blocker:
       )
       SolidObjects.instrument(
         :"sync.timeout",
@@ -38,8 +94,6 @@ module SolidObjects
       error
     end
 
-    private
-
     # @rbs (Message) -> String
     def message_status(message)
       return "rejected" if message.rejected?

data/lib/solid_objects/synchronous_invocation.rb

@@ -22,33 +22,49 @@ module SolidObjects
     # @rbs (MessageReference, timeout: Numeric) -> untyped
     def call_before_deadline(message_reference, timeout:)
       deadline = monotonic_now + SyncDeadline.remaining
+      message = nil
 
       loop do
-        message = load_message(message_reference)
-        return completed_result(message) if message.completed? || message.dead?
-
-        remaining = deadline - monotonic_now
-        unless remaining.positive?
-          message = load_message(message_reference)
-          return completed_result(message) if message.completed? || message.dead?
+        unless (deadline - monotonic_now).positive?
+          final_message = load_message_at_deadline(message_reference)
+          return completed_result(final_message) if final_message&.completed? || final_message&.dead?
 
-          raise SyncDiagnostics.new.call(message, timeout:)
+          raise final_message ?
+            diagnose_timeout(final_message, timeout:) :
+            contention_timeout(message, message_reference, timeout:)
         end
 
+        message = load_message(message_reference)
+        return completed_result(message) if message.completed? || message.dead?
+
         processed = assist(message, deadline:)
         remaining = deadline - monotonic_now
         wait(remaining) if processed.zero? && remaining.positive?
       end
     rescue DatabaseDeadlineExceeded
-      message = load_message(message_reference)
-      return completed_result(message) if message.completed? || message.dead?
-
-      raise SyncDiagnostics.new.call(message, timeout:)
+      raise message ?
+        diagnose_timeout(message, timeout:) :
+        contention_timeout(message, message_reference, timeout:)
     end
 
     # @rbs (MessageReference) -> Message
     def load_message(message_reference)
-      Message.uncached { Message.find(message_reference.id) }
+      SolidObjects.database_adapter.with_lock_retry do
+        Message.uncached do
+          Message.includes(:dead_letter).find(message_reference.id)
+        end
+      end
+    end
+
+    # @rbs (MessageReference) -> Message?
+    def load_message_at_deadline(message_reference)
+      SolidObjects.database_adapter.with_lock_probe do
+        Message.uncached do
+          Message.includes(:dead_letter).find(message_reference.id)
+        end
+      end
+    rescue DatabaseDeadlineExceeded
+      nil
     end
 
     # @rbs (Message) -> untyped
@@ -104,6 +120,22 @@ module SolidObjects
       )
     end
 
+    # @rbs (Message, timeout: Numeric) -> SyncTimeout
+    def diagnose_timeout(message, timeout:)
+      SolidObjects.database_adapter.with_lock_probe do
+        SyncDiagnostics.new.call(message, timeout:)
+      end
+    rescue DatabaseDeadlineExceeded
+      SyncDiagnostics.new.database_contention(message, timeout:)
+    end
+
+    # @rbs (Message?, MessageReference, timeout: Numeric) -> SyncTimeout
+    def contention_timeout(message, message_reference, timeout:)
+      return SyncDiagnostics.new.database_contention(message, timeout:) if message
+
+      SyncDiagnostics.new.database_contention_for(message_reference, timeout:)
+    end
+
     # @rbs () -> Float
     def monotonic_now
       ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)

data/lib/solid_objects/version.rb

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

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

@@ -32,5 +32,8 @@ module SolidObjects
 
     # @rbs (untyped) -> void
     def validate_actor_class!: (untyped) -> void
+
+    # @rbs (Class, Class) -> bool
+    def reload_of?: (Class, Class) -> bool
   end
 end

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

@@ -0,0 +1,30 @@
+# Generated from lib/solid_objects/application_actor_loader.rb with RBS::Inline
+
+module SolidObjects
+  class ApplicationActorLoader
+    @application: untyped
+
+    @autoloader: untyped
+
+    # @rbs (?application: untyped, ?autoloader: untyped) -> void
+    def initialize: (?application: untyped, ?autoloader: untyped) -> void
+
+    # @rbs () -> void
+    def call: () -> void
+
+    # @rbs () -> void
+    def install: () -> void
+
+    private
+
+    attr_reader application: untyped
+
+    attr_reader autoloader: untyped
+
+    # @rbs () -> Array[String]
+    def actor_directories: () -> Array[String]
+
+    # @rbs () -> Array[Class]
+    def current_actor_classes: () -> Array[Class]
+  end
+end

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

@@ -5,10 +5,10 @@ module SolidObjects
     # @rbs (untyped) -> DatabaseAdapter
     def self.for: (untyped) -> DatabaseAdapter
 
-    @connection_pool: untyped
-
     @fixed_connection: untyped
 
+    @connection_pool: untyped
+
     # @rbs (untyped) -> void
     def initialize: (untyped) -> void
 
@@ -24,6 +24,12 @@ module SolidObjects
     # @rbs () -> Time
     def database_now: () -> Time
 
+    # @rbs () { () -> untyped } -> untyped
+    def with_lock_retry: () { () -> untyped } -> untyped
+
+    # @rbs () { () -> untyped } -> untyped
+    def with_lock_probe: () { () -> untyped } -> untyped
+
     # @rbs () { () -> untyped } -> untyped
     def transaction: () { () -> untyped } -> untyped
 

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

@@ -5,12 +5,22 @@ module SolidObjects
     class Sqlite < DatabaseAdapter
       LOCK_RETRY_INTERVAL: ::Float
 
+      LOCK_RETRY_MUTEX: untyped
+
+      LOCK_RETRY_CONDITION: untyped
+
       # @rbs () -> String
       def current_time_expression: () -> String
 
       # @rbs () { () -> untyped } -> untyped
       def transaction: () { () -> untyped } -> untyped
 
+      # @rbs () { () -> untyped } -> untyped
+      def with_lock_retry: () { () -> untyped } -> untyped
+
+      # @rbs () { () -> untyped } -> untyped
+      def with_lock_probe: () { () -> untyped } -> untyped
+
       private
 
       # @rbs (untyped) { () -> untyped } -> untyped
@@ -18,6 +28,9 @@ module SolidObjects
 
       # @rbs (Exception) -> bool
       def deadline_error?: (Exception) -> bool
+
+      # @rbs () -> void
+      def wait_before_retry: () -> void
     end
   end
 end

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

@@ -5,8 +5,17 @@ module SolidObjects
     # @rbs (Message, timeout: Numeric) -> SyncTimeout
     def call: (Message, timeout: Numeric) -> SyncTimeout
 
+    # @rbs (Message, timeout: Numeric) -> SyncTimeout
+    def database_contention: (Message, timeout: Numeric) -> SyncTimeout
+
+    # @rbs (MessageReference, timeout: Numeric) -> SyncTimeout
+    def database_contention_for: (MessageReference, timeout: Numeric) -> SyncTimeout
+
     private
 
+    # @rbs (Message, timeout: Numeric, status: String, waiting_on: String, activation: Hash[String, untyped], blocker: Hash[String, untyped]?) -> SyncTimeout
+    def build_error: (Message, timeout: Numeric, status: String, waiting_on: String, activation: Hash[String, untyped], blocker: Hash[String, untyped]?) -> SyncTimeout
+
     # @rbs (Message) -> String
     def message_status: (Message) -> String
 

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

@@ -13,6 +13,9 @@ module SolidObjects
     # @rbs (MessageReference) -> Message
     def load_message: (MessageReference) -> Message
 
+    # @rbs (MessageReference) -> Message?
+    def load_message_at_deadline: (MessageReference) -> Message?
+
     # @rbs (Message) -> untyped
     def completed_result: (Message) -> untyped
 
@@ -25,6 +28,12 @@ module SolidObjects
     # @rbs (Numeric) -> void
     def wait: (Numeric) -> void
 
+    # @rbs (Message, timeout: Numeric) -> SyncTimeout
+    def diagnose_timeout: (Message, timeout: Numeric) -> SyncTimeout
+
+    # @rbs (Message?, MessageReference, timeout: Numeric) -> SyncTimeout
+    def contention_timeout: (Message?, MessageReference, timeout: Numeric) -> SyncTimeout
+
     # @rbs () -> Float
     def monotonic_now: () -> Float
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_objects
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Lucas Carlson
@@ -346,6 +346,7 @@ files:
 - lib/solid_objects/actor_registry.rb
 - lib/solid_objects/actor_snapshot.rb
 - lib/solid_objects/actor_view.rb
+- lib/solid_objects/application_actor_loader.rb
 - lib/solid_objects/application_write_guard.rb
 - lib/solid_objects/broadcast_executor.rb
 - lib/solid_objects/caller_process.rb
@@ -415,6 +416,7 @@ files:
 - sig/generated/lib/solid_objects/actor_registry.rbs
 - sig/generated/lib/solid_objects/actor_snapshot.rbs
 - sig/generated/lib/solid_objects/actor_view.rbs
+- sig/generated/lib/solid_objects/application_actor_loader.rbs
 - sig/generated/lib/solid_objects/application_write_guard.rbs
 - sig/generated/lib/solid_objects/broadcast_executor.rbs
 - sig/generated/lib/solid_objects/caller_process.rbs