temporalio 1.7.0-aarch64-linux → 1.8.0-aarch64-linux

data/rbi/temporalio/client/activity_execution.rbi

@@ -33,6 +33,9 @@ class Temporalio::Client::ActivityExecution
   sig { returns(T.nilable(Time)) }
   def schedule_time; end
 
+  sig { returns(T.nilable(Time)) }
+  def execution_time; end
+
   sig { returns(T.nilable(Time)) }
   def close_time; end
 
@@ -76,9 +79,30 @@ class Temporalio::Client::ActivityExecution::Description < ::Temporalio::Client:
   sig { returns(T.nilable(Float)) }
   def heartbeat_timeout; end
 
+  sig { returns(T.nilable(Float)) }
+  def start_delay; end
+
   sig { returns(T::Boolean) }
   def has_heartbeat_details?; end
 
+  sig { returns(T::Boolean) }
+  def has_last_failure?; end
+
+  sig { returns(T::Boolean) }
+  def has_input?; end
+
+  sig { params(hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) }
+  def input(hints: T.unsafe(nil)); end
+
+  sig { returns(T::Boolean) }
+  def has_result?; end
+
+  sig { params(result_hint: T.nilable(Object)).returns(T.nilable(Object)) }
+  def result(result_hint: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(Temporalio::Error::Failure)) }
+  def failure; end
+
   sig { params(hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) }
   def heartbeat_details(hints: T.unsafe(nil)); end
 
@@ -94,6 +118,9 @@ class Temporalio::Client::ActivityExecution::Description < ::Temporalio::Client:
   sig { returns(Integer) }
   def attempt; end
 
+  sig { returns(Integer) }
+  def total_heartbeat_count; end
+
   sig { returns(T.nilable(Temporalio::Error::Failure)) }
   def last_failure; end
 

data/rbi/temporalio/client/activity_execution_options.rbi

@@ -0,0 +1,58 @@
+# typed: true
+
+class Temporalio::Client::ActivityExecutionOptions
+  class << self
+    sig do
+      params(options: Temporalio::Api::Activity::V1::ActivityOptions)
+        .returns(Temporalio::Client::ActivityExecutionOptions)
+    end
+    def _from_proto(options); end
+  end
+
+  sig do
+    params(
+      task_queue: T.nilable(String),
+      schedule_to_close_timeout: T.nilable(Float),
+      schedule_to_start_timeout: T.nilable(Float),
+      start_to_close_timeout: T.nilable(Float),
+      heartbeat_timeout: T.nilable(Float),
+      retry_policy: T.nilable(Temporalio::RetryPolicy),
+      priority: Temporalio::Priority,
+      start_delay: T.nilable(Float)
+    ).void
+  end
+  def initialize(
+    task_queue:,
+    schedule_to_close_timeout:,
+    schedule_to_start_timeout:,
+    start_to_close_timeout:,
+    heartbeat_timeout:,
+    retry_policy:,
+    priority:,
+    start_delay:
+  ); end
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :task_queue
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :schedule_to_close_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :schedule_to_start_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :start_to_close_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :heartbeat_timeout
+
+  sig { returns(T.nilable(Temporalio::RetryPolicy)) }
+  attr_reader :retry_policy
+
+  sig { returns(Temporalio::Priority) }
+  attr_reader :priority
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :start_delay
+end

data/rbi/temporalio/client/activity_execution_status.rbi

@@ -8,4 +8,5 @@ module Temporalio::Client::ActivityExecutionStatus
   CANCELED = T.let(T.unsafe(nil), Integer)
   TERMINATED = T.let(T.unsafe(nil), Integer)
   TIMED_OUT = T.let(T.unsafe(nil), Integer)
+  PAUSED = T.let(T.unsafe(nil), Integer)
 end

data/rbi/temporalio/client/activity_handle.rbi

@@ -1,6 +1,8 @@
 # typed: true
 
 class Temporalio::Client::ActivityHandle
+  UPDATABLE_OPTION_PATHS = T.let(T.unsafe(nil), T::Hash[Symbol, String])
+
   sig do
     params(
       client: Temporalio::Client,
@@ -28,8 +30,22 @@ class Temporalio::Client::ActivityHandle
   end
   def result(result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
 
-  sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Client::ActivityExecution::Description) }
-  def describe(rpc_options: T.unsafe(nil)); end
+  sig do
+    params(
+      include_input: T::Boolean,
+      include_outcome: T::Boolean,
+      include_heartbeat_details: T::Boolean,
+      include_last_failure: T::Boolean,
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::ActivityExecution::Description)
+  end
+  def describe(
+    include_input: T.unsafe(nil),
+    include_outcome: T.unsafe(nil),
+    include_heartbeat_details: T.unsafe(nil),
+    include_last_failure: T.unsafe(nil),
+    rpc_options: T.unsafe(nil)
+  ); end
 
   sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
   def cancel(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
@@ -37,6 +53,31 @@ class Temporalio::Client::ActivityHandle
   sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
   def terminate(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
 
+  sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
+  def pause(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      reason: T.nilable(String),
+      jitter: T.nilable(Float),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).void
+  end
+  def unpause(reason: T.unsafe(nil), jitter: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      updates: Temporalio::Client::ActivityOptions::Update,
+      restore_original: T::Boolean,
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::ActivityExecutionOptions)
+  end
+  def update_options(
+    *updates,
+    restore_original: T.unsafe(nil),
+    rpc_options: T.unsafe(nil)
+  ); end
+
   private
 
   sig do

data/rbi/temporalio/client/activity_options.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Temporalio
+  class Client
+    module ActivityOptions
+      class Key
+        sig { returns(String) }
+        def name; end
+
+        sig do
+          params(
+            name: String,
+            to_proto: T.proc.params(proto: Temporalio::Api::Activity::V1::ActivityOptions, value: Object).void
+          ).void
+        end
+        def initialize(name, &to_proto); end
+
+        sig { params(value: Object).returns(Temporalio::Client::ActivityOptions::Update) }
+        def value_set(value); end
+
+        sig { returns(Temporalio::Client::ActivityOptions::Update) }
+        def value_unset; end
+
+        sig { params(proto: Temporalio::Api::Activity::V1::ActivityOptions, value: Object).void }
+        def _apply(proto, value); end
+      end
+
+      class Update
+        sig { returns(Temporalio::Client::ActivityOptions::Key) }
+        def key; end
+
+        sig { returns(T.nilable(Object)) }
+        def value; end
+
+        sig { params(key: Temporalio::Client::ActivityOptions::Key, value: T.nilable(Object)).void }
+        def initialize(key, value); end
+      end
+
+      TASK_QUEUE = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      SCHEDULE_TO_CLOSE_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      SCHEDULE_TO_START_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      START_TO_CLOSE_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      HEARTBEAT_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      START_DELAY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      RETRY_POLICY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      PRIORITY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+    end
+  end
+end

data/rbi/temporalio/client/interceptor.rbi

@@ -834,6 +834,18 @@ class Temporalio::Client::Interceptor::DescribeActivityInput < ::Data
   sig { returns(T.nilable(String)) }
   def activity_run_id; end
 
+  sig { returns(T::Boolean) }
+  def include_input; end
+
+  sig { returns(T::Boolean) }
+  def include_outcome; end
+
+  sig { returns(T::Boolean) }
+  def include_heartbeat_details; end
+
+  sig { returns(T::Boolean) }
+  def include_last_failure; end
+
   sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
   def rpc_options; end
 
@@ -849,6 +861,88 @@ class Temporalio::Client::Interceptor::DescribeActivityInput < ::Data
   end
 end
 
+class Temporalio::Client::Interceptor::PauseActivityInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(T.nilable(String)) }
+  def reason; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PauseActivityInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PauseActivityInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+class Temporalio::Client::Interceptor::UnpauseActivityInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(T.nilable(String)) }
+  def reason; end
+
+  sig { returns(T.nilable(Float)) }
+  def jitter; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UnpauseActivityInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UnpauseActivityInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+class Temporalio::Client::Interceptor::UpdateActivityOptionsInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(Temporalio::Api::Activity::V1::ActivityOptions) }
+  def activity_options; end
+
+  sig { returns(Google::Protobuf::FieldMask) }
+  def update_mask; end
+
+  sig { returns(T::Boolean) }
+  def restore_original; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UpdateActivityOptionsInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UpdateActivityOptionsInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+
 class Temporalio::Client::Interceptor::CancelActivityInput < ::Data
   sig { returns(String) }
   def activity_id; end
@@ -1056,6 +1150,19 @@ class Temporalio::Client::Interceptor::Outbound
   sig { params(input: Temporalio::Client::Interceptor::TerminateActivityInput).void }
   def terminate_activity(input); end
 
+  sig { params(input: Temporalio::Client::Interceptor::PauseActivityInput).void }
+  def pause_activity(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::UnpauseActivityInput).void }
+  def unpause_activity(input); end
+
+
+  sig do
+    params(input: Temporalio::Client::Interceptor::UpdateActivityOptionsInput)
+      .returns(Temporalio::Client::ActivityExecutionOptions)
+  end
+  def update_activity_options(input); end
+
   sig { params(input: Temporalio::Client::Interceptor::ListActivitiesInput).returns(T::Enumerator[Temporalio::Client::ActivityExecution]) }
   def list_activities(input); end
 

data/sig/temporalio/client/activity_execution.rbs

@@ -9,6 +9,7 @@ module Temporalio
       def activity_run_id: -> String?
       def activity_type: -> String
       def schedule_time: -> Time?
+      def execution_time: -> Time?
       def close_time: -> Time?
       def status: -> ActivityExecutionStatus::enum
       def search_attributes: -> SearchAttributes?
@@ -25,12 +26,21 @@ module Temporalio
         def schedule_to_start_timeout: -> Float?
         def start_to_close_timeout: -> Float?
         def heartbeat_timeout: -> Float?
+        def start_delay: -> Float?
         def has_heartbeat_details?: -> bool
+        def has_last_failure?: -> bool
+        def has_input?: -> bool
+        def input: (?hints: Array[Object]?) -> Array[Object?]
+        def has_result?: -> bool
+        def result: (?result_hint: Object?) -> Object?
+        def failure: -> Error::Failure?
         def heartbeat_details: (?hints: Array[Object]?) -> Array[Object?]
         def retry_policy: -> RetryPolicy
         def last_heartbeat_time: -> Time?
         def last_started_time: -> Time?
         def attempt: -> Integer
+
+        def total_heartbeat_count: -> Integer
         def last_failure: -> Error::Failure?
         def expiration_time: -> Time?
         def last_worker_identity: -> String?

data/sig/temporalio/client/activity_execution_options.rbs

@@ -0,0 +1,27 @@
+module Temporalio
+  class Client
+    class ActivityExecutionOptions
+      attr_reader task_queue: String?
+      attr_reader schedule_to_close_timeout: Float?
+      attr_reader schedule_to_start_timeout: Float?
+      attr_reader start_to_close_timeout: Float?
+      attr_reader heartbeat_timeout: Float?
+      attr_reader retry_policy: RetryPolicy?
+      attr_reader priority: Priority
+      attr_reader start_delay: Float?
+
+      def self._from_proto: (untyped options) -> ActivityExecutionOptions
+
+      def initialize: (
+        task_queue: String?,
+        schedule_to_close_timeout: Float?,
+        schedule_to_start_timeout: Float?,
+        start_to_close_timeout: Float?,
+        heartbeat_timeout: Float?,
+        retry_policy: RetryPolicy?,
+        priority: Priority,
+        start_delay: Float?
+      ) -> void
+    end
+  end
+end

data/sig/temporalio/client/activity_execution_status.rbs

@@ -10,6 +10,7 @@ module Temporalio
       CANCELED: enum
       TERMINATED: enum
       TIMED_OUT: enum
+      PAUSED: enum
     end
   end
 end

data/sig/temporalio/client/activity_handle.rbs

@@ -1,6 +1,8 @@
 module Temporalio
   class Client
     class ActivityHandle
+      UPDATABLE_OPTION_PATHS: Hash[Symbol, String]
+
       attr_reader id: String
       attr_reader run_id: String?
       attr_reader result_hint: Object?
@@ -14,12 +16,32 @@ module Temporalio
 
       def result: (?result_hint: Object?, ?rpc_options: RPCOptions?) -> Object?
 
-      def describe: (?rpc_options: RPCOptions?) -> ActivityExecution::Description
+      def describe: (
+        ?include_input: bool,
+        ?include_outcome: bool,
+        ?include_heartbeat_details: bool,
+        ?include_last_failure: bool,
+        ?rpc_options: RPCOptions?
+      ) -> ActivityExecution::Description
 
       def cancel: (?String? reason, ?rpc_options: RPCOptions?) -> void
 
       def terminate: (?String? reason, ?rpc_options: RPCOptions?) -> void
 
+      def pause: (?String? reason, ?rpc_options: RPCOptions?) -> void
+
+      def unpause: (
+        ?reason: String?,
+        ?jitter: Float?,
+        ?rpc_options: RPCOptions?
+      ) -> void
+
+      def update_options: (
+        *ActivityOptions::Update updates,
+        ?restore_original: bool,
+        ?rpc_options: RPCOptions?
+      ) -> ActivityExecutionOptions
+
       private def _process_outcome: (Api::Activity::V1::ActivityExecutionOutcome? outcome, Object? hint) -> Object?
     end
   end

data/sig/temporalio/client/activity_options.rbs

@@ -0,0 +1,30 @@
+module Temporalio
+  class Client
+    module ActivityOptions
+      class Key
+        attr_reader name: String
+
+        def initialize: (String name) { (untyped proto, untyped value) -> void } -> void
+        def value_set: (untyped value) -> Update
+        def value_unset: () -> Update
+        def _apply: (untyped proto, untyped value) -> void
+      end
+
+      class Update
+        attr_reader key: Key
+        attr_reader value: untyped?
+
+        def initialize: (Key key, untyped? value) -> void
+      end
+
+      TASK_QUEUE: Key
+      SCHEDULE_TO_CLOSE_TIMEOUT: Key
+      SCHEDULE_TO_START_TIMEOUT: Key
+      START_TO_CLOSE_TIMEOUT: Key
+      HEARTBEAT_TIMEOUT: Key
+      START_DELAY: Key
+      RETRY_POLICY: Key
+      PRIORITY: Key
+    end
+  end
+end

data/sig/temporalio/client/interceptor.rbs

@@ -481,11 +481,19 @@ module Temporalio
       class DescribeActivityInput
         attr_reader activity_id: String
         attr_reader activity_run_id: String?
+        attr_reader include_input: bool
+        attr_reader include_outcome: bool
+        attr_reader include_heartbeat_details: bool
+        attr_reader include_last_failure: bool
         attr_reader rpc_options: RPCOptions?
 
         def initialize: (
           activity_id: String,
           activity_run_id: String?,
+          include_input: bool,
+          include_outcome: bool,
+          include_heartbeat_details: bool,
+          include_last_failure: bool,
           rpc_options: RPCOptions?
         ) -> void
       end
@@ -518,6 +526,54 @@ module Temporalio
         ) -> void
       end
 
+      class PauseActivityInput
+        attr_reader activity_id: String
+        attr_reader activity_run_id: String?
+        attr_reader reason: String?
+        attr_reader rpc_options: RPCOptions?
+
+        def initialize: (
+          activity_id: String,
+          activity_run_id: String?,
+          reason: String?,
+          rpc_options: RPCOptions?
+        ) -> void
+      end
+
+      class UnpauseActivityInput
+        attr_reader activity_id: String
+        attr_reader activity_run_id: String?
+        attr_reader reason: String?
+        attr_reader jitter: Float?
+        attr_reader rpc_options: RPCOptions?
+
+        def initialize: (
+          activity_id: String,
+          activity_run_id: String?,
+          reason: String?,
+          jitter: Float?,
+          rpc_options: RPCOptions?
+        ) -> void
+      end
+
+      class UpdateActivityOptionsInput
+        attr_reader activity_id: String
+        attr_reader activity_run_id: String?
+        attr_reader activity_options: untyped
+        attr_reader update_mask: untyped
+        attr_reader restore_original: bool
+        attr_reader rpc_options: RPCOptions?
+
+        def initialize: (
+          activity_id: String,
+          activity_run_id: String?,
+          activity_options: untyped,
+          update_mask: untyped,
+          restore_original: bool,
+          rpc_options: RPCOptions?
+        ) -> void
+      end
+
       class ListActivitiesInput
         attr_reader query: String
         attr_reader rpc_options: RPCOptions?
@@ -611,6 +667,12 @@ module Temporalio
 
         def terminate_activity: (TerminateActivityInput input) -> void
 
+        def pause_activity: (PauseActivityInput input) -> void
+
+        def unpause_activity: (UnpauseActivityInput input) -> void
+
+        def update_activity_options: (UpdateActivityOptionsInput input) -> untyped
+
         def list_activities: (ListActivitiesInput input) -> Enumerator[ActivityExecution, ActivityExecution]
 
         def count_activities: (CountActivitiesInput input) -> ActivityExecutionCount

data/sig/temporalio/internal/client/implementation.rbs

@@ -22,6 +22,13 @@ module Temporalio
 
         def terminate_activity: (Temporalio::Client::Interceptor::TerminateActivityInput input) -> void
 
+        def pause_activity: (Temporalio::Client::Interceptor::PauseActivityInput input) -> void
+
+        def unpause_activity: (Temporalio::Client::Interceptor::UnpauseActivityInput input) -> void
+
+
+        def update_activity_options: (Temporalio::Client::Interceptor::UpdateActivityOptionsInput input) -> untyped
+
         def list_activities: (Temporalio::Client::Interceptor::ListActivitiesInput input) -> Enumerator[Temporalio::Client::ActivityExecution, Temporalio::Client::ActivityExecution]
 
         def count_activities: (Temporalio::Client::Interceptor::CountActivitiesInput input) -> Temporalio::Client::ActivityExecutionCount

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: temporalio
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: aarch64-linux
 authors:
 - Temporal Technologies Inc
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-08-20 00:00:00.000000000 Z
+date: 2026-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -139,9 +139,11 @@ files:
 - lib/temporalio/client.rb
 - lib/temporalio/client/activity_execution.rb
 - lib/temporalio/client/activity_execution_count.rb
+- lib/temporalio/client/activity_execution_options.rb
 - lib/temporalio/client/activity_execution_status.rb
 - lib/temporalio/client/activity_handle.rb
 - lib/temporalio/client/activity_id_reference.rb
+- lib/temporalio/client/activity_options.rb
 - lib/temporalio/client/async_activity_handle.rb
 - lib/temporalio/client/connection.rb
 - lib/temporalio/client/connection/cloud_service.rb
@@ -363,9 +365,11 @@ files:
 - rbi/temporalio/client.rbi
 - rbi/temporalio/client/activity_execution.rbi
 - rbi/temporalio/client/activity_execution_count.rbi
+- rbi/temporalio/client/activity_execution_options.rbi
 - rbi/temporalio/client/activity_execution_status.rbi
 - rbi/temporalio/client/activity_handle.rbi
 - rbi/temporalio/client/activity_id_reference.rbi
+- rbi/temporalio/client/activity_options.rbi
 - rbi/temporalio/client/async_activity_handle.rbi
 - rbi/temporalio/client/connection.rbi
 - rbi/temporalio/client/connection/cloud_service.rbi
@@ -582,9 +586,11 @@ files:
 - sig/temporalio/client.rbs
 - sig/temporalio/client/activity_execution.rbs
 - sig/temporalio/client/activity_execution_count.rbs
+- sig/temporalio/client/activity_execution_options.rbs
 - sig/temporalio/client/activity_execution_status.rbs
 - sig/temporalio/client/activity_handle.rbs
 - sig/temporalio/client/activity_id_reference.rbs
+- sig/temporalio/client/activity_options.rbs
 - sig/temporalio/client/async_activity_handle.rbs
 - sig/temporalio/client/connection.rbs
 - sig/temporalio/client/connection/cloud_service.rbs