prosody 0.3.0-aarch64-linux → 0.5.0-aarch64-linux

data/sig/state.rbs

@@ -0,0 +1,390 @@
+module Prosody
+  type state_config_value = String | Integer | bool
+
+  # --- error taxonomy -----------------------------------------------------
+  # Raised for keyed-state failures a retry cannot resolve (unregistered
+  # collection, identity mismatch, duplicate registration, bad TTL). Never
+  # Terminal: core folds Terminal into Transient.
+  class PermanentStateError < PermanentError
+  end
+
+  # Raised for keyed-state failures that may succeed on retry, plus every
+  # caller mistake (null write, wrong item shape, invalid index, invalid
+  # direction). Never Terminal.
+  class TransientStateError < TransientError
+  end
+
+  # Raised when a JSON null is written to a collection. Null is not storable
+  # (indistinguishable from absence); use clear/delete instead.
+  class NullValueError < TransientStateError
+  end
+
+  class StateAccess < Data
+    attr_reader vend_method: Symbol
+    attr_reader wrapper: Symbol
+    attr_reader published_vend_method: Symbol?
+    attr_reader published_wrapper: Symbol?
+  end
+
+  # Concrete immutable definition object returned by the constructor helpers.
+  class StateDefinition < Data
+    attr_reader name: String
+    attr_reader kind: String
+    attr_reader payload: String
+    attr_reader ttl_seconds: Integer?
+    attr_reader read_uncommitted: bool?
+    attr_reader published: bool?
+    attr_reader read_cache: (Numeric | false)?
+    attr_reader keyset_limit: Integer?
+    attr_reader capacity: Integer?
+    attr_reader access: StateAccess
+
+    def to_state_config: () -> Hash[Symbol, state_config_value]
+  end
+
+  # --- definition interfaces (phantom-typed over the payload) --------------
+  # The runtime returns a single frozen StateDefinition (Data) that structurally
+  # satisfies every interface below; the type parameter is annotation-only.
+  interface _ValueDefinition[T = json_value]
+    def name: () -> String
+    def kind: () -> "value"
+    def payload: () -> "json"
+    def read_cache: () -> (Numeric | false)?
+    def to_state_config: () -> Hash[Symbol, state_config_value]
+  end
+
+  interface _MapDefinition[V = json_value]
+    def name: () -> String
+    def kind: () -> "map"
+    def payload: () -> "json"
+    def read_cache: () -> (Numeric | false)?
+    def to_state_config: () -> Hash[Symbol, state_config_value]
+  end
+
+  interface _DequeDefinition[T = json_value]
+    def name: () -> String
+    def kind: () -> "deque"
+    def payload: () -> "json"
+    def read_cache: () -> (Numeric | false)?
+    def to_state_config: () -> Hash[Symbol, state_config_value]
+  end
+
+  interface _MessageValueDefinition[P = json_value]
+    def name: () -> String
+    def kind: () -> "value"
+    def payload: () -> "message"
+    def to_state_config: () -> Hash[Symbol, state_config_value]
+  end
+
+  interface _MessageMapDefinition[P = json_value]
+    def name: () -> String
+    def kind: () -> "map"
+    def payload: () -> "message"
+    def to_state_config: () -> Hash[Symbol, state_config_value]
+  end
+
+  interface _MessageDequeDefinition[P = json_value]
+    def name: () -> String
+    def kind: () -> "deque"
+    def payload: () -> "message"
+    def to_state_config: () -> Hash[Symbol, state_config_value]
+  end
+
+  # --- definition constructors --------------------------------------------
+  # The `message_*` siblings return the same structural definition interfaces as
+  # their JSON counterparts (the runtime object is one StateDefinition); the
+  # `[P]` type parameter is annotation-only, naming the message payload type.
+  def self.value: [T] (_ToS name, ?ttl: Integer?, ?read_uncommitted: bool?, ?published: bool?, ?read_cache: (Numeric | false)?) -> _ValueDefinition[T]
+  def self.map: [V] (_ToS name, ?ttl: Integer?, ?keyset_limit: Integer?, ?read_uncommitted: bool?, ?published: bool?, ?read_cache: (Numeric | false)?) -> _MapDefinition[V]
+  def self.deque: [T] (_ToS name, ?ttl: Integer?, ?capacity: Integer?, ?read_uncommitted: bool?, ?published: bool?, ?read_cache: (Numeric | false)?) -> _DequeDefinition[T]
+  def self.message_value: [P] (_ToS name, ?ttl: Integer?, ?read_uncommitted: bool?) -> _MessageValueDefinition[P]
+  def self.message_map: [P] (_ToS name, ?ttl: Integer?, ?keyset_limit: Integer?, ?read_uncommitted: bool?) -> _MessageMapDefinition[P]
+  def self.message_deque: [P] (_ToS name, ?ttl: Integer?, ?capacity: Integer?, ?read_uncommitted: bool?) -> _MessageDequeDefinition[P]
+
+  # --- handles ------------------------------------------------------------
+  # A single-value keyed-state handle. Reads return the stored value or nil.
+  # Every op is fiber-yield async: it looks blocking but never blocks the thread.
+  class ValueState[T = json_value]
+    def get: () -> T?
+    def set: (T value) -> void
+    def clear: () -> void
+    def commit: () -> nil
+    def rollback: () -> nil
+
+    # idiomatic conveniences
+    def value: () -> T?              # alias of #get
+    def value=: (T value) -> T      # alias of #set (assignment yields value)
+
+    private
+    def initialize: ((NativeJsonValueState | NativeMessageValueState) native) -> void
+  end
+
+  # A String-keyed ordered-map keyed-state handle.
+  class MapState[V = json_value]
+    include State::Scanning
+
+    def get: (String key) -> V?
+    def get_many: (Array[String] keys) -> Array[V?]
+    def set: (String key, V value) -> void
+    def delete: (String key) -> nil
+    def clear: () -> void
+    def commit: () -> nil
+    def rollback: () -> nil
+    def each_pair: () { (String, V) -> void } -> void
+                 | () -> Enumerator[[ String, V ], void]
+    def reverse_each_pair: () { (String, V) -> void } -> void
+                         | () -> Enumerator[[ String, V ], void]
+    def each_key: () { (String) -> void } -> void
+                | () -> Enumerator[String, void]
+    def reverse_each_key: () { (String) -> void } -> void
+                        | () -> Enumerator[String, void]
+    def each_value: () { (V) -> void } -> void
+                  | () -> Enumerator[V, void]
+    def reverse_each_value: () { (V) -> void } -> void
+                          | () -> Enumerator[V, void]
+
+    # idiomatic Hash-style conveniences (bounded reads only)
+    def []: (String key) -> V?                       # alias of #get
+    def []=: (String key, V value) -> V              # alias of #set (assignment yields value)
+    def store: (String key, V value) -> V            # wrapper over #set, returns value
+    def each: () { (String, V) -> void } -> void     # alias of #each_pair
+            | () -> Enumerator[[ String, V ], void]
+    def values_at: (*String keys) -> Array[V?]
+    def fetch: (String key) -> V
+             | [D] (String key, D default) -> (V | D)
+             | [R] (String key) { (String) -> R } -> (V | R)
+    def key?: (String key) -> bool
+    def has_key?: (String key) -> bool
+    def include?: (String key) -> bool
+    def member?: (String key) -> bool
+    def dig: (String key, *untyped) -> untyped
+    def slice: (*String keys) -> Hash[String, V]
+    def fetch_values: (*String keys) -> Array[V]
+                    | [R] (*String keys) { (String) -> R } -> Array[V | R]
+
+    private
+    def initialize: ((NativeJsonMapState | NativeMessageMapState) native) -> void
+    def traverse: (Symbol direction) { (String, V) -> void } -> void
+                | (Symbol direction) -> Enumerator[[ String, V ], void]
+    def traverse_keys: (Symbol direction) { (String) -> void } -> void
+                     | (Symbol direction) -> Enumerator[String, void]
+  end
+
+  # A deque keyed-state handle.
+  class DequeState[T = json_value]
+    include State::Scanning
+
+    def push: (T value) -> void
+    def unshift: (T value) -> void
+    def pop: () -> T?
+    def shift: () -> T?
+    def length: () -> Integer
+    def size: () -> Integer
+    def empty?: () -> bool
+    def clear: () -> void
+    def commit: () -> nil
+    def rollback: () -> nil
+    def get: (Integer index) -> T?
+    def each: () { (T) -> void } -> void
+            | () -> Enumerator[T, void]
+    def reverse_each: () { (T) -> void } -> void
+                    | () -> Enumerator[T, void]
+
+    # idiomatic Array-style conveniences (bounded reads only). #get and #fetch
+    # take a single Integer index (negatives resolve from the back, Array-style);
+    # #[] and #at are deliberately absent because they would invite a range read
+    # the remote deque cannot honor.
+    def prepend: (T value) -> self   # wrapper over #unshift
+    def append: (T value) -> self    # wrapper over #push
+    def <<: (T value) -> self
+    def first: () -> T?
+    def last: () -> T?
+    def fetch: (Integer index) -> T
+             | [D] (Integer index, D default) -> (T | D)
+             | [R] (Integer index) { (Integer) -> R } -> (T | R)
+
+    private
+    def initialize: ((NativeJsonDequeState | NativeMessageDequeState) native) -> void
+    def at_negative: (Integer index) -> T?
+    def traverse: (Symbol direction) { (T) -> void } -> void
+                | (Symbol direction) -> Enumerator[T, void]
+  end
+
+  interface _NativeValueHandle[T]
+    def get: () -> T?
+    def set: (T value) -> void
+    def clear: () -> void
+    def commit: () -> nil
+    def rollback: () -> nil
+  end
+
+  class NativeJsonValueState
+    include _NativeValueHandle[json_value]
+  end
+
+  class NativeMessageValueState
+    include _NativeValueHandle[Message[json_value]]
+  end
+
+  interface _NativeMapHandle[V, S]
+    def get: (String key) -> V?
+    def contains_key: (String key) -> bool
+    def get_many: (Array[String] keys) -> Array[V?]
+    def set: (String key, V value) -> void
+    def remove: (String key) -> void
+    def clear: () -> void
+    def scan: (Symbol direction) -> S
+    def keys: (Symbol direction) -> NativeMapKeyScan
+    def commit: () -> nil
+    def rollback: () -> nil
+  end
+
+  class NativeJsonMapState
+    include _NativeMapHandle[json_value, NativeJsonMapScan]
+  end
+
+  class NativeMessageMapState
+    include _NativeMapHandle[Message[json_value], NativeMessageMapScan]
+  end
+
+  interface _NativeDequeHandle[T, S]
+    def len: () -> Integer
+    def is_empty: () -> bool
+    def get: (Integer index) -> T?
+    def peek_front: () -> T?
+    def peek_back: () -> T?
+    def push_back: (T value) -> void
+    def push_front: (T value) -> void
+    def pop_front: () -> T?
+    def pop_back: () -> T?
+    def clear: () -> void
+    def scan: (Symbol direction) -> S
+    def commit: () -> nil
+    def rollback: () -> nil
+  end
+
+  class NativeJsonDequeState
+    include _NativeDequeHandle[json_value, NativeJsonDequeScan]
+  end
+
+  class NativeMessageDequeState
+    include _NativeDequeHandle[Message[json_value], NativeMessageDequeScan]
+  end
+
+  interface _NativeScan[T]
+    def next: () -> T?
+    def close: () -> void
+  end
+
+  class NativeJsonDequeScan
+    include _NativeScan[json_value]
+  end
+
+  class NativeJsonMapScan
+    include _NativeScan[[String, json_value]]
+  end
+
+  class NativeMessageDequeScan
+    include _NativeScan[Message[json_value]]
+  end
+
+  class NativeMessageMapScan
+    include _NativeScan[[String, Message[json_value]]]
+  end
+
+  class NativeMapKeyScan
+    include _NativeScan[String]
+  end
+
+  class NativePublishedValue
+    def get: (String key) -> json_value?
+  end
+
+  class NativePublishedMap
+    def get: (String key, String map_key) -> json_value?
+    def get_many: (String key, Array[String] map_keys) -> Array[json_value?]
+    def contains_key: (String key, String map_key) -> bool
+    def scan: (String key, Symbol direction) -> NativeJsonMapScan
+    def keys: (String key, Symbol direction) -> NativeMapKeyScan
+  end
+
+  class NativePublishedDeque
+    def get: (String key, Integer index) -> json_value?
+    def length: (String key) -> Integer
+    def is_empty: (String key) -> bool
+    def peek_front: (String key) -> json_value?
+    def peek_back: (String key) -> json_value?
+    def scan: (String key, Symbol direction) -> NativeJsonDequeScan
+  end
+
+  class PublishedValue[T = json_value]
+    def get: (_ToS key) -> T?
+  end
+
+  class PublishedMap[V = json_value]
+    def get: (_ToS key, _ToS map_key) -> V?
+    def get_many: (_ToS key, Array[_ToS] map_keys) -> Array[V?]
+    def key?: (_ToS key, _ToS map_key) -> bool
+    alias has_key? key?
+    alias include? key?
+    alias member? key?
+    def each_pair: (_ToS key) { (String, V) -> void } -> void
+                 | (_ToS key) -> Enumerator[[String, V], void]
+    def reverse_each_pair: (_ToS key) { (String, V) -> void } -> void
+                         | (_ToS key) -> Enumerator[[String, V], void]
+    def each_key: (_ToS key) { (String) -> void } -> void
+                | (_ToS key) -> Enumerator[String, void]
+    def reverse_each_key: (_ToS key) { (String) -> void } -> void
+                        | (_ToS key) -> Enumerator[String, void]
+    def each_value: (_ToS key) { (V) -> void } -> void
+                  | (_ToS key) -> Enumerator[V, void]
+    def reverse_each_value: (_ToS key) { (V) -> void } -> void
+                          | (_ToS key) -> Enumerator[V, void]
+    alias each each_pair
+  end
+
+  class PublishedDeque[T = json_value]
+    def get: (_ToS key, Integer index) -> T?
+    def length: (_ToS key) -> Integer
+    alias size length
+    def empty?: (_ToS key) -> bool
+    def first: (_ToS key) -> T?
+    def last: (_ToS key) -> T?
+    def each: (_ToS key) { (T) -> void } -> void
+            | (_ToS key) -> Enumerator[T, void]
+    def reverse_each: (_ToS key) { (T) -> void } -> void
+                    | (_ToS key) -> Enumerator[T, void]
+  end
+
+  # --- shared state modules ------------------------------------------------
+  module State
+    # Adds keyed-state vending to the native context.
+    module Vending
+      def state: [T] (_ValueDefinition[T]) -> ValueState[T]
+               | [V] (_MapDefinition[V]) -> MapState[V]
+               | [T] (_DequeDefinition[T]) -> DequeState[T]
+               | [P] (_MessageValueDefinition[P]) -> ValueState[Message[P]]
+               | [P] (_MessageMapDefinition[P]) -> MapState[Message[P]]
+               | [P] (_MessageDequeDefinition[P]) -> DequeState[Message[P]]
+    end
+
+    # Shared native-scan driving mixed into the traversal handles.
+    module Scanning
+      private
+      def scan_each: [T] (Symbol direction, ?Symbol opener) { (T) -> void } -> void
+      def scan_items: [T] (_NativeScan[T] scan) { (T) -> void } -> void
+    end
+  end
+
+  # Reopened to add keyed-state vending (see lib/prosody/state.rb).
+  class Context
+    include State::Vending
+
+    def value_state: (String name) -> NativeJsonValueState
+    def map_state: (String name) -> NativeJsonMapState
+    def deque_state: (String name) -> NativeJsonDequeState
+    def message_value_state: (String name) -> NativeMessageValueState
+    def message_map_state: (String name) -> NativeMessageMapState
+    def message_deque_state: (String name) -> NativeMessageDequeState
+  end
+end

data/steep_expectations.yml

@@ -0,0 +1,57 @@
+---
+- file: typecheck_negative/payload_types.rb
+  diagnostics:
+  - range:
+      start:
+        line: 10
+        character: 41
+      end:
+        line: 10
+        character: 51
+    severity: ERROR
+    message: |-
+      Cannot pass a value of type `::Object` as an argument of type `::Prosody::json_value`
+        ::Object <: ::Prosody::json_value
+          ::Object <: (nil | bool | ::Integer | ::Float | ::String | ::Array[::Prosody::json_value] | ::Hash[::String, ::Prosody::json_value])
+            ::Object <: nil
+    code: Ruby::ArgumentTypeMismatch
+  - range:
+      start:
+        line: 13
+        character: 22
+      end:
+        line: 13
+        character: 38
+    severity: ERROR
+    message: |-
+      Cannot pass a value of type `::String` as an argument of type `::Integer`
+        ::String <: ::Integer
+          ::Object <: ::Integer
+            ::BasicObject <: ::Integer
+    code: Ruby::ArgumentTypeMismatch
+  - range:
+      start:
+        line: 14
+        character: 42
+      end:
+        line: 14
+        character: 57
+    severity: ERROR
+    message: |-
+      Cannot pass a value of type `::negative_event` as an argument of type `::Prosody::Message[untyped]`
+        ::negative_event <: ::Prosody::Message[untyped]
+          { "amount" => ::Integer } <: ::Prosody::Message[untyped]
+            ::Hash["amount", ::Integer] <: ::Prosody::Message[untyped]
+              ::Object <: ::Prosody::Message[untyped]
+                ::BasicObject <: ::Prosody::Message[untyped]
+    code: Ruby::ArgumentTypeMismatch
+  - range:
+      start:
+        line: 18
+        character: 12
+      end:
+        line: 18
+        character: 19
+    severity: ERROR
+    message: Type `::Prosody::ExciseMessage` does not have method `payload`
+    code: Ruby::NoMethod

data/typecheck/payload_types.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# This file is checked by Steep as a consumer of Prosody's public signatures.
+# It is not loaded at runtime.
+
+ORDER_BACKLOG = Prosody.message_deque("order-backlog")
+ORDER_TOTALS = Prosody.map("order-totals")
+
+class TypedOrderHandler < Prosody::EventHandler
+  def on_excise(_context, message)
+    message.key
+    {"accepted" => true}
+  end
+
+  def on_message(context, message)
+    payload = message.payload
+    order_id = payload["order_id"]
+    total = payload["total"]
+
+    # Message-backed state preserves the handler's payload type.
+    backlog = context.state(ORDER_BACKLOG)
+    backlog.push(message)
+    oldest = backlog.first
+
+    # This call is a regression constraint: state(ORDER_TOTALS) must infer as
+    # MapState[Integer], not untyped or a generic JSON-valued state handle.
+    consume_totals(context.state(ORDER_TOTALS))
+
+    consume_order(order_id, total)
+    oldest_payload = oldest&.payload
+    consume_order(oldest_payload["order_id"], oldest_payload["total"]) if oldest_payload
+    {"accepted" => true}
+  end
+
+  def on_timer(_context, _timer)
+  end
+
+  private
+
+  def consume_order(order_id, total)
+    "#{order_id.upcase}:#{total + 1}"
+  end
+
+  def consume_totals(totals)
+    totals.set("latest", 1)
+    nil
+  end
+end
+
+class DefaultPayloadConsumer
+  def payload(message)
+    message.payload
+  end
+end

data/typecheck/payload_types.rbs

@@ -0,0 +1,22 @@
+type order_event = {
+  "order_id" => String,
+  "total" => Integer
+}
+type handler_response = { "accepted" => bool }
+
+ORDER_BACKLOG: Prosody::_MessageDequeDefinition[order_event]
+ORDER_TOTALS: Prosody::_MapDefinition[Integer]
+
+class TypedOrderHandler < Prosody::EventHandler[order_event, handler_response]
+  def on_message: (Prosody::Context context, Prosody::Message[order_event] message) -> handler_response
+  def on_excise: (Prosody::Context context, Prosody::ExciseMessage message) -> handler_response
+
+  private
+
+  def consume_order: (String order_id, Integer total) -> String
+  def consume_totals: (Prosody::MapState[Integer] totals) -> nil
+end
+
+class DefaultPayloadConsumer
+  def payload: (Prosody::Message message) -> Prosody::json_value
+end

data/typecheck_negative/payload_types.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Deliberately invalid calls. Diagnostics are committed in
+# steep_expectations.yml, so Steep fails if these errors disappear.
+NEGATIVE_TOTALS = Prosody.map("negative-totals")
+NEGATIVE_MESSAGES = Prosody.message_deque("negative-messages")
+
+class NegativeTypeChecks
+  def check(client, context, message)
+    client.send_message("events", "key", Object.new)
+    # @type var totals: Prosody::MapState[Integer]
+    totals = context.state(NEGATIVE_TOTALS)
+    totals.set("key", "not-an-integer")
+    context.state(NEGATIVE_MESSAGES).push(message.payload)
+  end
+
+  def check_excise(message)
+    message.payload
+  end
+end

data/typecheck_negative/payload_types.rbs

@@ -0,0 +1,9 @@
+type negative_event = { "amount" => Integer }
+
+NEGATIVE_TOTALS: Prosody::_MapDefinition[Integer]
+NEGATIVE_MESSAGES: Prosody::_MessageDequeDefinition[negative_event]
+
+class NegativeTypeChecks
+  def check: (Prosody::Client client, Prosody::Context context, Prosody::Message[negative_event] message) -> void
+  def check_excise: (Prosody::ExciseMessage message) -> void
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prosody
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: aarch64-linux
 authors:
 - Joshua Griffith
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-05-18 00:00:00.000000000 Z
+date: 2026-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.39'
+        version: '2.42'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.39'
+        version: '2.42'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-exporter-otlp
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.5'
+        version: '6.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.5'
+        version: '6.6'
 description: |
   Prosody offers Ruby bindings to the Prosody Kafka client, providing features
   for message production and consumption, including configurable retry
@@ -110,13 +110,20 @@ files:
 - ".ruby-version"
 - ".standard.yml"
 - ".taplo.toml"
+- AGENTS.md
 - ARCHITECTURE.md
 - CHANGELOG.md
+- CLAUDE.md
+- CONFIGURATION.md
 - LICENSE
 - Makefile
 - README.md
 - Rakefile
 - docker-compose.yaml
+- examples/keyed_state.rb
+- examples/keyed_state.rbs
+- examples/keyed_state_windowing.rb
+- examples/keyed_state_windowing.rbs
 - lib/prosody.rb
 - lib/prosody/3.2/prosody.so
 - lib/prosody/3.3/prosody.so
@@ -125,14 +132,24 @@ files:
 - lib/prosody/handler.rb
 - lib/prosody/native_stubs.rb
 - lib/prosody/processor.rb
+- lib/prosody/request.rb
 - lib/prosody/sentry.rb
+- lib/prosody/state.rb
 - lib/prosody/version.rb
 - release-please-config.json
 - sig/configuration.rbs
 - sig/handler.rbs
 - sig/processor.rbs
 - sig/prosody.rbs
+- sig/request.rbs
+- sig/sentry.rbs
+- sig/state.rbs
 - sig/version.rbs
+- steep_expectations.yml
+- typecheck/payload_types.rb
+- typecheck/payload_types.rbs
+- typecheck_negative/payload_types.rb
+- typecheck_negative/payload_types.rbs
 homepage: https://github.com/prosody-events/prosody-rb
 licenses:
 - MIT