restate-sdk 0.7.0 → 0.9.0

data/lib/restate.rb

@@ -1,7 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require 'sorbet-runtime'
 require_relative 'restate/version'
 require_relative 'restate/errors'
 require_relative 'restate/serde'
@@ -31,8 +30,6 @@ require_relative 'restate/client'
 # because +Thread.current[]+ is NOT inherited by child fibers, which prevents
 # accidental context leaks when Async spawns child tasks for run blocks.
 module Restate # rubocop:disable Metrics/ModuleLength
-  extend T::Sig
-
   module_function
 
   # Create an endpoint, optionally binding services.
@@ -40,13 +37,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   #
   # @param services [Array<Class>] service classes or instances to bind
   # @return [Endpoint]
-  sig do
-    params(
-      services: T.untyped,
-      protocol: T.nilable(String),
-      identity_keys: T.nilable(T::Array[String])
-    ).returns(Endpoint)
-  end
   def endpoint(*services, protocol: nil, identity_keys: nil)
     ep = Endpoint.new
     ep.streaming_protocol if protocol == 'bidi'
@@ -65,15 +55,13 @@ module Restate # rubocop:disable Metrics/ModuleLength
   #     c.ingress_url = "http://localhost:8080"
   #     c.admin_url   = "http://localhost:9070"
   #   end
-  sig { params(_block: T.proc.params(arg0: Config).void).void }
-  def configure(&_block)
+  def configure(&)
     yield config
   end
 
   # Returns the global configuration. Creates a default one on first access.
-  sig { returns(Config) }
   def config
-    @config = T.let(@config, T.nilable(Config)) unless defined?(@config)
+    @config = nil unless defined?(@config)
     @config ||= Config.new
   end
 
@@ -84,7 +72,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   #   Restate.client.service(Greeter).greet("World")
   #   Restate.client.resolve_awakeable(id, payload)
   #   Restate.client.create_deployment("http://localhost:9080")
-  sig { returns(Client) }
   def client
     cfg = config
     Client.new(ingress_url: cfg.ingress_url, admin_url: cfg.admin_url,
@@ -94,9 +81,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   # ── Context accessor (internal) ──
 
   # @!visibility private
-  sig do
-    params(service_kind: T.nilable(String), handler_kind: T.nilable(String)).returns(ServerContext)
-  end
   def fetch_context!(service_kind: nil, handler_kind: nil) # rubocop:disable Metrics
     ctx = Thread.current[:restate_context]
     unless ctx
@@ -118,32 +102,23 @@ module Restate # rubocop:disable Metrics/ModuleLength
       end
     end
 
-    T.cast(ctx, ServerContext)
+    ctx
   end
 
   # ── Durable execution ──
 
   # Execute a durable side effect. The block runs at most once; the result
   # is journaled and replayed on retries. Returns a DurableFuture.
-  sig do
-    params(name: String, serde: T.untyped, retry_policy: T.nilable(RunRetryPolicy),
-           background: T::Boolean, action: T.proc.returns(T.untyped)).returns(DurableFuture)
-  end
   def run(name, serde: JsonSerde, retry_policy: nil, background: false, &action)
     fetch_context!.run(name, serde: serde, retry_policy: retry_policy, background: background, &action)
   end
 
   # Convenience shortcut for +run(...).await+. Returns the result directly.
-  sig do
-    params(name: String, serde: T.untyped, retry_policy: T.nilable(RunRetryPolicy),
-           background: T::Boolean, action: T.proc.returns(T.untyped)).returns(T.untyped)
-  end
   def run_sync(name, serde: JsonSerde, retry_policy: nil, background: false, &action)
     fetch_context!.run_sync(name, serde: serde, retry_policy: retry_policy, background: background, &action)
   end
 
   # Durable timer that survives handler restarts.
-  sig { params(seconds: Numeric).returns(DurableFuture) }
   def sleep(seconds)
     fetch_context!.sleep(seconds)
   end
@@ -151,43 +126,36 @@ module Restate # rubocop:disable Metrics/ModuleLength
   # ── State operations (VirtualObject / Workflow) ──
 
   # Durably retrieve a state entry. Returns nil if unset.
-  sig { params(name: String, serde: T.untyped).returns(T.untyped) }
   def get(name, serde: JsonSerde)
     fetch_context!.get(name, serde: serde)
   end
 
   # Durably retrieve a state entry, returning a DurableFuture instead of blocking.
-  sig { params(name: String, serde: T.untyped).returns(DurableFuture) }
   def get_async(name, serde: JsonSerde)
     fetch_context!.get_async(name, serde: serde)
   end
 
   # Durably set a state entry.
-  sig { params(name: String, value: T.untyped, serde: T.untyped).void }
   def set(name, value, serde: JsonSerde)
     fetch_context!.set(name, value, serde: serde)
   end
 
   # Durably remove a single state entry.
-  sig { params(name: String).void }
   def clear(name)
     fetch_context!.clear(name)
   end
 
   # Durably remove all state entries.
-  sig { void }
   def clear_all
     fetch_context!.clear_all
   end
 
   # List all state entry names.
-  sig { returns(T.untyped) }
   def state_keys
     fetch_context!.state_keys
   end
 
   # List all state entry names, returning a DurableFuture.
-  sig { returns(DurableFuture) }
   def state_keys_async
     fetch_context!.state_keys_async
   end
@@ -195,12 +163,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   # ── Service communication ──
 
   # Durably call a handler on a Restate service.
-  sig do
-    params(service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
-           arg: T.untyped, key: T.nilable(String), idempotency_key: T.nilable(String),
-           headers: T.nilable(T::Hash[String, String]),
-           input_serde: T.untyped, output_serde: T.untyped).returns(DurableCallFuture)
-  end
   def service_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil,
                    input_serde: NOT_SET, output_serde: NOT_SET)
     ctx = fetch_context!
@@ -209,12 +171,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   end
 
   # Fire-and-forget send to a Restate service handler.
-  sig do
-    params(service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
-           arg: T.untyped, key: T.nilable(String), delay: T.nilable(Numeric),
-           idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
-           input_serde: T.untyped).returns(SendHandle)
-  end
   def service_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil,
                    headers: nil, input_serde: NOT_SET)
     ctx = fetch_context!
@@ -223,12 +179,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   end
 
   # Durably call a handler on a Restate virtual object.
-  sig do
-    params(service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
-           key: String, arg: T.untyped, idempotency_key: T.nilable(String),
-           headers: T.nilable(T::Hash[String, String]),
-           input_serde: T.untyped, output_serde: T.untyped).returns(DurableCallFuture)
-  end
   def object_call(service, handler, key, arg, idempotency_key: nil, headers: nil,
                   input_serde: NOT_SET, output_serde: NOT_SET)
     ctx = fetch_context!
@@ -237,12 +187,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   end
 
   # Fire-and-forget send to a Restate virtual object handler.
-  sig do
-    params(service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
-           key: String, arg: T.untyped, delay: T.nilable(Numeric),
-           idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
-           input_serde: T.untyped).returns(SendHandle)
-  end
   def object_send(service, handler, key, arg, delay: nil, idempotency_key: nil,
                   headers: nil, input_serde: NOT_SET)
     ctx = fetch_context!
@@ -251,12 +195,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   end
 
   # Durably call a handler on a Restate workflow.
-  sig do
-    params(service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
-           key: String, arg: T.untyped, idempotency_key: T.nilable(String),
-           headers: T.nilable(T::Hash[String, String]),
-           input_serde: T.untyped, output_serde: T.untyped).returns(DurableCallFuture)
-  end
   def workflow_call(service, handler, key, arg, idempotency_key: nil, headers: nil,
                     input_serde: NOT_SET, output_serde: NOT_SET)
     ctx = fetch_context!
@@ -266,12 +204,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   end
 
   # Fire-and-forget send to a Restate workflow handler.
-  sig do
-    params(service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
-           key: String, arg: T.untyped, delay: T.nilable(Numeric),
-           idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
-           input_serde: T.untyped).returns(SendHandle)
-  end
   def workflow_send(service, handler, key, arg, delay: nil, idempotency_key: nil,
                     headers: nil, input_serde: NOT_SET)
     ctx = fetch_context!
@@ -280,22 +212,12 @@ module Restate # rubocop:disable Metrics/ModuleLength
   end
 
   # Durably call a handler using raw bytes (no serialization).
-  sig do
-    params(service: String, handler: String, arg: String,
-           key: T.nilable(String), idempotency_key: T.nilable(String),
-           headers: T.nilable(T::Hash[String, String])).returns(DurableCallFuture)
-  end
   def generic_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil)
     fetch_context!.generic_call(service, handler, arg, key: key,
                                                        idempotency_key: idempotency_key, headers: headers)
   end
 
   # Fire-and-forget send using raw bytes (no serialization).
-  sig do
-    params(service: String, handler: String, arg: String,
-           key: T.nilable(String), delay: T.nilable(Numeric),
-           idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String])).returns(SendHandle)
-  end
   def generic_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil, headers: nil)
     fetch_context!.generic_send(service, handler, arg, key: key, delay: delay,
                                                        idempotency_key: idempotency_key, headers: headers)
@@ -304,19 +226,16 @@ module Restate # rubocop:disable Metrics/ModuleLength
   # ── Awakeables ──
 
   # Create an awakeable for external callbacks. Returns [awakeable_id, DurableFuture].
-  sig { params(serde: T.untyped).returns([String, DurableFuture]) }
   def awakeable(serde: JsonSerde)
     fetch_context!.awakeable(serde: serde)
   end
 
   # Resolve an awakeable with a success value.
-  sig { params(awakeable_id: String, payload: T.untyped, serde: T.untyped).void }
   def resolve_awakeable(awakeable_id, payload, serde: JsonSerde)
     fetch_context!.resolve_awakeable(awakeable_id, payload, serde: serde)
   end
 
   # Reject an awakeable with a terminal failure.
-  sig { params(awakeable_id: String, message: String, code: Integer).void }
   def reject_awakeable(awakeable_id, message, code: 500)
     fetch_context!.reject_awakeable(awakeable_id, message, code: code)
   end
@@ -324,25 +243,21 @@ module Restate # rubocop:disable Metrics/ModuleLength
   # ── Promises (Workflow only) ──
 
   # Get a durable promise value, blocking until resolved.
-  sig { params(name: String, serde: T.untyped).returns(T.untyped) }
   def promise(name, serde: JsonSerde)
     fetch_context!.promise(name, serde: serde)
   end
 
   # Peek at a durable promise without blocking. Returns nil if not yet resolved.
-  sig { params(name: String, serde: T.untyped).returns(T.untyped) }
   def peek_promise(name, serde: JsonSerde)
     fetch_context!.peek_promise(name, serde: serde)
   end
 
   # Resolve a durable promise with a value.
-  sig { params(name: String, payload: T.untyped, serde: T.untyped).void }
   def resolve_promise(name, payload, serde: JsonSerde)
     fetch_context!.resolve_promise(name, payload, serde: serde)
   end
 
   # Reject a durable promise with a terminal failure.
-  sig { params(name: String, message: String, code: Integer).void }
   def reject_promise(name, message, code: 500)
     fetch_context!.reject_promise(name, message, code: code)
   end
@@ -350,21 +265,18 @@ module Restate # rubocop:disable Metrics/ModuleLength
   # ── Futures ──
 
   # Wait until any of the given futures completes. Returns [completed, remaining].
-  sig { params(futures: T::Array[DurableFuture]).returns([T::Array[DurableFuture], T::Array[DurableFuture]]) }
   def wait_any(*futures)
-    T.unsafe(fetch_context!).wait_any(*futures)
+    fetch_context!.wait_any(*futures)
   end
 
   # ── Request metadata ──
 
   # Returns metadata about the current invocation (id, headers, raw body).
-  sig { returns(T.untyped) }
   def request
     fetch_context!.request
   end
 
   # Returns the key for this virtual object or workflow invocation.
-  sig { returns(String) }
   def key
     fetch_context!.key
   end
@@ -372,7 +284,6 @@ module Restate # rubocop:disable Metrics/ModuleLength
   # ── Invocation control ──
 
   # Request cancellation of another invocation.
-  sig { params(invocation_id: String).void }
   def cancel_invocation(invocation_id)
     fetch_context!.cancel_invocation(invocation_id)
   end

data/sig/restate.rbs

@@ -0,0 +1,202 @@
+# Public API type signatures for the Restate Ruby SDK.
+# Used by Steep for static type checking and by Ruby LSP for IDE completion.
+
+module Restate
+  # ── Endpoint ──
+
+  def self.endpoint: (*untyped services, ?protocol: String?, ?identity_keys: Array[String]?) -> Endpoint
+  def self.configure: () { (Config) -> void } -> void
+  def self.config: () -> Config
+  def self.client: () -> Client
+
+  # ── Durable execution ──
+
+  def self.run: (String name, ?serde: untyped, ?retry_policy: untyped, ?background: bool) { () -> untyped } -> DurableFuture
+  def self.run_sync: (String name, ?serde: untyped, ?retry_policy: untyped, ?background: bool) { () -> untyped } -> untyped
+  def self.sleep: (Numeric seconds) -> DurableFuture
+
+  # ── State operations ──
+
+  def self.get: (String name, ?serde: untyped) -> untyped
+  def self.get_async: (String name, ?serde: untyped) -> DurableFuture
+  def self.set: (String name, untyped value, ?serde: untyped) -> void
+  def self.clear: (String name) -> void
+  def self.clear_all: () -> void
+  def self.state_keys: () -> Array[String]
+  def self.state_keys_async: () -> DurableFuture
+
+  # ── Service communication ──
+
+  def self.service_call: (untyped service, (String | Symbol) handler, untyped arg, ?key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped, ?output_serde: untyped) -> DurableCallFuture
+  def self.service_send: (untyped service, (String | Symbol) handler, untyped arg, ?key: String?, ?delay: Numeric?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped) -> SendHandle
+  def self.object_call: (untyped service, (String | Symbol) handler, String key, untyped arg, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped, ?output_serde: untyped) -> DurableCallFuture
+  def self.object_send: (untyped service, (String | Symbol) handler, String key, untyped arg, ?delay: Numeric?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped) -> SendHandle
+  def self.workflow_call: (untyped service, (String | Symbol) handler, String key, untyped arg, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped, ?output_serde: untyped) -> DurableCallFuture
+  def self.workflow_send: (untyped service, (String | Symbol) handler, String key, untyped arg, ?delay: Numeric?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped) -> SendHandle
+  def self.generic_call: (String service, String handler, String arg, ?key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?) -> DurableCallFuture
+  def self.generic_send: (String service, String handler, String arg, ?key: String?, ?delay: Numeric?, ?idempotency_key: String?, ?headers: Hash[String, String]?) -> SendHandle
+
+  # ── Awakeables ──
+
+  def self.awakeable: (?serde: untyped) -> [String, DurableFuture]
+  def self.resolve_awakeable: (String awakeable_id, untyped payload, ?serde: untyped) -> void
+  def self.reject_awakeable: (String awakeable_id, String message, ?code: Integer) -> void
+
+  # ── Promises ──
+
+  def self.promise: (String name, ?serde: untyped) -> untyped
+  def self.peek_promise: (String name, ?serde: untyped) -> untyped
+  def self.resolve_promise: (String name, untyped payload, ?serde: untyped) -> void
+  def self.reject_promise: (String name, String message, ?code: Integer) -> void
+
+  # ── Futures / Metadata / Control ──
+
+  def self.wait_any: (*DurableFuture futures) -> [Array[DurableFuture], Array[DurableFuture]]
+  def self.request: () -> untyped
+  def self.key: () -> String
+  def self.cancel_invocation: (String invocation_id) -> void
+  def self.fetch_context!: (?service_kind: String?, ?handler_kind: String?) -> untyped
+
+  # ── Errors ──
+
+  class TerminalError < StandardError
+    attr_reader status_code: Integer
+    def initialize: (?String message, ?status_code: Integer) -> void
+  end
+
+  class SuspendedError < StandardError
+    def initialize: () -> void
+  end
+
+  class InternalError < StandardError
+    def initialize: () -> void
+  end
+
+  class DisconnectedError < StandardError
+    def initialize: () -> void
+  end
+
+  # ── Futures ──
+
+  class DurableFuture
+    attr_reader handle: Integer
+    def initialize: (untyped ctx, Integer handle, ?serde: untyped) -> void
+    def await: () -> untyped
+    def completed?: () -> bool
+  end
+
+  class DurableCallFuture < DurableFuture
+    def initialize: (untyped ctx, Integer result_handle, Integer invocation_id_handle, output_serde: untyped) -> void
+    def invocation_id: () -> String
+    def cancel: () -> void
+  end
+
+  class SendHandle
+    def initialize: (untyped ctx, Integer invocation_id_handle) -> void
+    def invocation_id: () -> String
+    def cancel: () -> void
+  end
+
+  # ── Config ──
+
+  class Config
+    attr_accessor ingress_url: String
+    attr_accessor admin_url: String
+    attr_accessor ingress_headers: Hash[String, String]
+    attr_accessor admin_headers: Hash[String, String]
+    def initialize: () -> void
+  end
+
+  # ── Client ──
+
+  class Client
+    def initialize: (?ingress_url: String, ?admin_url: String, ?ingress_headers: Hash[String, String], ?admin_headers: Hash[String, String]) -> void
+    def service: (untyped service) -> ClientServiceProxy
+    def object: (untyped service, String key) -> ClientServiceProxy
+    def workflow: (untyped service, String key) -> ClientServiceProxy
+    def resolve_awakeable: (String awakeable_id, untyped payload) -> void
+    def reject_awakeable: (String awakeable_id, String message, ?code: Integer) -> void
+    def cancel_invocation: (String invocation_id) -> void
+    def kill_invocation: (String invocation_id) -> void
+
+    private
+
+    def resolve_name: (untyped service) -> String
+    def post_ingress: (String path, untyped body) -> untyped
+    def post_admin: (String path, untyped body) -> untyped
+    def parse_response: (Net::HTTPResponse response) -> untyped
+  end
+
+  class ClientServiceProxy
+    def initialize: (String base_url, String service_name, String? key, Hash[String, String] headers) -> void
+  end
+
+  # ── Endpoint ──
+
+  class Endpoint
+    attr_reader services: Hash[String, untyped]
+    attr_reader identity_keys: Array[String]
+    attr_accessor protocol: String?
+    attr_reader middleware: Array[untyped]
+    attr_reader outbound_middleware: Array[untyped]
+    def initialize: () -> void
+    def bind: (*untyped svcs) -> self
+    def streaming_protocol: () -> self
+    def request_response_protocol: () -> self
+    def identity_key: (String key) -> self
+    def use: (untyped klass, *untyped args, **untyped kwargs) -> self
+    def use_outbound: (untyped klass, *untyped args, **untyped kwargs) -> self
+    def app: () -> untyped
+
+    private
+
+    def instantiate_middleware: (untyped klass, Array[untyped] args, Hash[Symbol, untyped] kwargs) -> untyped
+  end
+
+  # ── Service proxies ──
+
+  class ServiceCallProxy
+    def initialize: (untyped service_class, ?key: String?, ?call_method: Symbol) -> void
+  end
+
+  class ServiceSendProxy
+    def initialize: (untyped service_class, ?key: String?, ?send_method: Symbol, ?delay: Numeric?) -> void
+  end
+
+  # ── Service classes (declared but not checked — heavy metaprogramming) ──
+
+  class Service
+  end
+
+  class VirtualObject
+  end
+
+  class Workflow
+  end
+
+  # ── Internal ──
+
+  class Server
+    def initialize: (untyped endpoint) -> void
+  end
+
+  module JsonSerde
+    def self.serialize: (untyped obj) -> String
+    def self.deserialize: (String? buf) -> untyped
+    def self.json_schema: () -> Hash[String, untyped]?
+  end
+
+  module BytesSerde
+    def self.serialize: (untyped obj) -> String
+    def self.deserialize: (String? buf) -> String?
+    def self.json_schema: () -> Hash[String, untyped]?
+  end
+
+  class AttemptFinishedEvent
+    def set?: () -> bool
+    def wait: () -> void
+  end
+
+  NOT_SET: untyped
+  RunRetryPolicy: untyped
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Restate Developers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-20 00:00:00.000000000 Z
+date: 2026-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Build resilient applications with distributed durable async/await using
   Restate
 email:
@@ -88,8 +74,7 @@ files:
 - lib/restate/virtual_object.rb
 - lib/restate/vm.rb
 - lib/restate/workflow.rb
-- lib/tapioca/dsl/compilers/restate.rb
-- rbi/restate-sdk.rbi
+- sig/restate.rbs
 homepage: https://github.com/restatedev/sdk-ruby
 licenses:
 - MIT

data/lib/tapioca/dsl/compilers/restate.rb

@@ -1,115 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-return unless defined?(Tapioca::Dsl::Compiler)
-
-require 'restate'
-
-module Tapioca
-  module Dsl
-    module Compilers
-      # Generates Sorbet sigs for Restate handler methods.
-      #
-      # Handlers take 0 or 1 parameters (the input). Context is implicit
-      # via +Restate.*+ module methods.
-      #
-      # Usage:
-      #   bundle exec tapioca dsl
-      class Restate < Compiler
-        ConstantType = type_member { { fixed: Module } }
-
-        class << self
-          def gather_constants
-            # Load service files so they're visible to all_classes.
-            # In non-Rails apps, Tapioca doesn't auto-load application code.
-            load_service_files
-
-            all_classes.select do |klass|
-              klass.is_a?(Class) && (
-                klass < ::Restate::Service ||
-                klass < ::Restate::VirtualObject ||
-                klass < ::Restate::Workflow
-              )
-            rescue TypeError
-              false
-            end
-          end
-
-          private
-
-          def load_service_files # rubocop:disable Metrics/MethodLength
-            root = Bundler.root.to_s
-            patterns = [
-              "#{root}/*.rb",
-              "#{root}/app/**/*.rb",
-              "#{root}/services/**/*.rb",
-              "#{root}/examples/**/*.rb"
-            ]
-            Dir.glob(patterns).each do |file|
-              next if file.end_with?('config.ru', 'Rakefile')
-
-              require file
-            rescue LoadError, StandardError
-              nil # skip files that can't be loaded
-            end
-          end
-        end
-
-        def decorate # rubocop:disable Metrics/MethodLength
-          root.create_path(constant) do |klass|
-            constant.handlers.each do |name, handler|
-              params = []
-              if handler.arity == 1
-                input_type = resolve_input_type(handler)
-                params << create_param('input', type: input_type)
-              end
-              output_type = resolve_output_type(handler)
-              klass.create_method(name, parameters: params, return_type: output_type)
-            end
-          end
-        end
-
-        private
-
-        # Maps (service kind, handler kind) to the correct context module.
-        def resolve_context_type(klass, handler)
-          if klass < ::Restate::Workflow
-            handler.kind == 'workflow' ? 'Restate::WorkflowContext' : 'Restate::WorkflowSharedContext'
-          elsif klass < ::Restate::VirtualObject
-            handler.kind == 'shared' ? 'Restate::ObjectSharedContext' : 'Restate::ObjectContext'
-          else
-            'Restate::Context'
-          end
-        end
-
-        # Resolves the Sorbet type string for the handler's input serde.
-        def resolve_input_type(handler)
-          type_class = handler.handler_io&.input_serde
-          sorbet_type_name(type_class) || 'T.untyped'
-        end
-
-        # Resolves the Sorbet type string for the handler's output serde.
-        def resolve_output_type(handler)
-          type_class = handler.handler_io&.output_serde
-          sorbet_type_name(type_class) || 'T.untyped'
-        end
-
-        # Returns a Sorbet type string if the serde wraps a known type, nil otherwise.
-        def sorbet_type_name(serde)
-          return nil if serde.nil?
-
-          # TStructSerde exposes .struct_class (T::Struct subclasses are visible to Sorbet)
-          return serde.struct_class.name if serde.is_a?(::Restate::TStructSerde)
-
-          # TypeSerde wraps a primitive type in .type_class
-          if serde.respond_to?(:type_class)
-            name = serde.type_class.name
-            return name if %w[String Integer Float].include?(name)
-          end
-
-          nil
-        end
-      end
-    end
-  end
-end