prosody 0.5.1 → 0.6.0

data/sig/state.rbs

@@ -1,43 +1,38 @@
 module Prosody
   type state_config_value = String | Integer | bool
 
+  # The effect of commit or rollback: :applied when buffered operations were
+  # drained, :no_op when nothing was buffered.
+  type store_outcome = :applied | :no_op
+
+  # Query keywords as the traversal methods collect them.
+  type query_options = Hash[Symbol, String | Integer | Range[String?] | Range[Integer?] | nil]
+
   # --- error taxonomy -----------------------------------------------------
   # Raised for keyed-state failures a retry cannot resolve (unregistered
-  # collection, identity mismatch, duplicate registration, bad TTL). Never
+  # collection, identity mismatch, duplicate registration, bad TTL, JSON null
+  # write; use clear/delete to remove a value). 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.
+  # caller mistake the client detects (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 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
@@ -61,6 +56,14 @@ module Prosody
     def to_state_config: () -> Hash[Symbol, state_config_value]
   end
 
+  interface _SetDefinition
+    def name: () -> String
+    def kind: () -> "set"
+    def payload: () -> nil
+    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"
@@ -96,6 +99,7 @@ module Prosody
   # `[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.set: (_ToS name, ?ttl: Integer?, ?keyset_limit: Integer?, ?read_uncommitted: bool?, ?published: bool?, ?read_cache: (Numeric | false)?) -> _SetDefinition
   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]
@@ -104,12 +108,10 @@ module Prosody
   # --- 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]
+  class ValueState[T = json_value] < State::Handle
     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
@@ -120,35 +122,36 @@ module Prosody
   end
 
   # A String-keyed ordered-map keyed-state handle.
-  class MapState[V = json_value]
+  class MapState[V = json_value] < State::Handle
     include State::Scanning
 
     def get: (String key) -> V?
     def get_many: (Array[String] keys) -> Array[V?]
+    def contains_many: (Array[String] keys) -> Array[bool]
+    def empty?: () -> bool
     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]
+    # Traversals accept optional query keywords (see State::Scanning).
+    def each_pair: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { ([String, V]) -> void } -> void
+                 | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> Enumerator[[ String, V ], void]
+    def reverse_each_pair: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { ([String, V]) -> void } -> void
+                         | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> Enumerator[[ String, V ], void]
+    def each_key: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { (String) -> void } -> void
+                | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> Enumerator[String, void]
+    def reverse_each_key: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { (String) -> void } -> void
+                        | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> Enumerator[String, void]
+    def each_value: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { (V) -> void } -> void
+                  | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> Enumerator[V, void]
+    def reverse_each_value: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { (V) -> void } -> void
+                          | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> 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 each: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { ([String, V]) -> void } -> void     # alias of #each_pair
+            | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> Enumerator[[ String, V ], void]
     def values_at: (*String keys) -> Array[V?]
     def fetch: (String key) -> V
              | [D] (String key, D default) -> (V | D)
@@ -164,14 +167,32 @@ module Prosody
 
     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 presence-only ordered set of String members. Mirrors Ruby's Set.
+  class SetState < State::Handle
+    include State::Scanning
+
+    def add: (String member) -> self
+    def <<: (String member) -> self
+    def delete: (String member) -> self
+    def include?: (String member) -> bool
+    def member?: (String member) -> bool
+    def contains_many: (Array[String] members) -> Array[bool]
+    def empty?: () -> bool
+    def clear: () -> self
+    # Traversals accept optional query keywords (see State::Scanning).
+    def each: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { (String) -> void } -> void
+            | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> Enumerator[String, void]
+    def reverse_each: (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) { (String) -> void } -> void
+                    | (?from: String?, ?after: String?, ?to: String?, ?before: String?, ?range: Range[String?]?, ?prefix: String?, ?limit: Integer?) -> Enumerator[String, void]
+
+    private
+    def initialize: (NativeSetState native) -> void
   end
 
   # A deque keyed-state handle.
-  class DequeState[T = json_value]
+  class DequeState[T = json_value] < State::Handle
     include State::Scanning
 
     def push: (T value) -> void
@@ -182,13 +203,12 @@ module Prosody
     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]
+    # Traversals accept optional position keywords (see State::Scanning).
+    def each: (?from: Integer?, ?after: Integer?, ?to: Integer?, ?before: Integer?, ?range: Range[Integer?]?, ?limit: Integer?) { (T) -> void } -> void
+            | (?from: Integer?, ?after: Integer?, ?to: Integer?, ?before: Integer?, ?range: Range[Integer?]?, ?limit: Integer?) -> Enumerator[T, void]
+    def reverse_each: (?from: Integer?, ?after: Integer?, ?to: Integer?, ?before: Integer?, ?range: Range[Integer?]?, ?limit: Integer?) { (T) -> void } -> void
+                    | (?from: Integer?, ?after: Integer?, ?to: Integer?, ?before: Integer?, ?range: Range[Integer?]?, ?limit: Integer?) -> 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);
@@ -206,16 +226,14 @@ module Prosody
     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
+    def commit: () -> store_outcome
+    def rollback: () -> store_outcome
   end
 
   class NativeJsonValueState
@@ -229,14 +247,16 @@ module Prosody
   interface _NativeMapHandle[V, S]
     def get: (String key) -> V?
     def contains_key: (String key) -> bool
+    def is_empty: () -> bool
     def get_many: (Array[String] keys) -> Array[V?]
+    def contains_many: (Array[String] keys) -> Array[bool]
     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
+    def scan: (Symbol direction, query_options query) -> S
+    def keys: (Symbol direction, query_options query) -> NativeMapKeyScan
+    def commit: () -> store_outcome
+    def rollback: () -> store_outcome
   end
 
   class NativeJsonMapState
@@ -247,6 +267,18 @@ module Prosody
     include _NativeMapHandle[Message[json_value], NativeMessageMapScan]
   end
 
+  class NativeSetState
+    def contains: (String member) -> bool
+    def contains_many: (Array[String] members) -> Array[bool]
+    def is_empty: () -> bool
+    def insert: (String member) -> void
+    def remove: (String member) -> void
+    def clear: () -> void
+    def keys: (Symbol direction, query_options query) -> NativeMapKeyScan
+    def commit: () -> store_outcome
+    def rollback: () -> store_outcome
+  end
+
   interface _NativeDequeHandle[T, S]
     def len: () -> Integer
     def is_empty: () -> bool
@@ -258,9 +290,9 @@ module Prosody
     def pop_front: () -> T?
     def pop_back: () -> T?
     def clear: () -> void
-    def scan: (Symbol direction) -> S
-    def commit: () -> nil
-    def rollback: () -> nil
+    def scan: (Symbol direction, query_options query) -> S
+    def commit: () -> store_outcome
+    def rollback: () -> store_outcome
   end
 
   class NativeJsonDequeState
@@ -272,7 +304,7 @@ module Prosody
   end
 
   interface _NativeScan[T]
-    def next: () -> T?
+    def next_chunk: () -> Array[T]?
     def close: () -> void
   end
 
@@ -296,72 +328,19 @@ module Prosody
     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
+    # The base class of the owned handles.
+    class Handle
+      def commit: () -> store_outcome
+      def rollback: () -> store_outcome
+    end
+
     # Adds keyed-state vending to the native context.
     module Vending
       def state: [T] (_ValueDefinition[T]) -> ValueState[T]
                | [V] (_MapDefinition[V]) -> MapState[V]
+               | (_SetDefinition) -> SetState
                | [T] (_DequeDefinition[T]) -> DequeState[T]
                | [P] (_MessageValueDefinition[P]) -> ValueState[Message[P]]
                | [P] (_MessageMapDefinition[P]) -> MapState[Message[P]]
@@ -369,10 +348,15 @@ module Prosody
     end
 
     # Shared native-scan driving mixed into the traversal handles.
+    # Query keywords apply in iteration order and narrow the selection. Map
+    # and set traversals take String keys and `prefix:`. Deque traversals take
+    # non-negative positions from the front.
     module Scanning
       private
-      def scan_each: [T] (Symbol direction, ?Symbol opener) { (T) -> void } -> void
-      def scan_items: [T] (_NativeScan[T] scan) { (T) -> void } -> void
+      def traverse: (Symbol opener, *untyped args) { (untyped) -> void } -> void
+                  | (Symbol opener, *untyped args) -> Enumerator[untyped, void]
+      def traverse_values: (*untyped args) { (untyped) -> void } -> void
+                         | (*untyped args) -> Enumerator[untyped, void]
     end
   end
 
@@ -380,8 +364,11 @@ module Prosody
   class Context
     include State::Vending
 
+    private
+
     def value_state: (String name) -> NativeJsonValueState
     def map_state: (String name) -> NativeJsonMapState
+    def set_state: (String name) -> NativeSetState
     def deque_state: (String name) -> NativeJsonDequeState
     def message_value_state: (String name) -> NativeMessageValueState
     def message_map_state: (String name) -> NativeMessageMapState

data/typecheck/payload_types.rb

@@ -5,6 +5,7 @@
 
 ORDER_BACKLOG = Prosody.message_deque("order-backlog")
 ORDER_TOTALS = Prosody.map("order-totals")
+ORDER_IDS = Prosody.set("order-ids")
 
 class TypedOrderHandler < Prosody::EventHandler
   def on_excise(_context, message)
@@ -15,17 +16,25 @@ class TypedOrderHandler < Prosody::EventHandler
   def on_message(context, message)
     payload = message.payload
     order_id = payload["order_id"]
+    demand = context.demand
+    consume_order(order_id, demand.retries) if demand.failure?
     total = payload["total"]
 
     # Message-backed state preserves the handler's payload type.
     backlog = context.state(ORDER_BACKLOG)
     backlog.push(message)
     oldest = backlog.first
+    backlog.reverse_each(range: 0..9, limit: 2) { |pending| pending.payload["order_id"].upcase }
 
     # 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))
 
+    # A set handle takes and yields String members.
+    order_ids = context.state(ORDER_IDS)
+    order_ids << order_id unless order_ids.include?(order_id)
+    order_ids.each(prefix: "order-", limit: 5) { |id| id.upcase }
+
     consume_order(order_id, total)
     oldest_payload = oldest&.payload
     consume_order(oldest_payload["order_id"], oldest_payload["total"]) if oldest_payload
@@ -43,6 +52,9 @@ class TypedOrderHandler < Prosody::EventHandler
 
   def consume_totals(totals)
     totals.set("latest", 1)
+    # Query keywords keep the item types.
+    totals.each_key(prefix: "order:", after: "order:1", limit: 10) { |key| key.upcase }
+    totals.reverse_each_value(range: "a"..."m").each { |total| total + 1 }
     nil
   end
 end

data/typecheck/payload_types.rbs

@@ -6,6 +6,7 @@ type handler_response = { "accepted" => bool }
 
 ORDER_BACKLOG: Prosody::_MessageDequeDefinition[order_event]
 ORDER_TOTALS: Prosody::_MapDefinition[Integer]
+ORDER_IDS: Prosody::_SetDefinition
 
 class TypedOrderHandler < Prosody::EventHandler[order_event, handler_response]
   def on_message: (Prosody::Context context, Prosody::Message[order_event] message) -> handler_response

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prosody
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Joshua Griffith
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.128
+        version: 0.9.130
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.128
+        version: 0.9.130
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -71,42 +71,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.13'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-exporter-otlp
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.34'
+        version: '0.37'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.34'
+        version: '0.37'
 - !ruby/object:Gem::Dependency
   name: sentry-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.6'
+        version: '7.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.6'
+        version: '7.0'
 description: |
   Prosody offers Ruby bindings to the Prosody Kafka client, providing features
   for message production and consumption, including configurable retry
@@ -118,6 +118,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".cargo/config.toml"
+- ".config/rail.toml"
 - ".release-please-manifest.json"
 - ".rspec"
 - ".ruby-version"
@@ -144,17 +145,25 @@ files:
 - ext/prosody/src/admin.rs
 - ext/prosody/src/bridge/callback.rs
 - ext/prosody/src/bridge/mod.rs
-- ext/prosody/src/client/config.rs
+- ext/prosody/src/client/config/connections.rs
+- ext/prosody/src/client/config/middleware.rs
+- ext/prosody/src/client/config/mod.rs
+- ext/prosody/src/client/config/state.rs
 - ext/prosody/src/client/mod.rs
+- ext/prosody/src/client/readers.rs
 - ext/prosody/src/client/request.rs
 - ext/prosody/src/client/support.rs
 - ext/prosody/src/gvl.rs
-- ext/prosody/src/handler/context.rs
+- ext/prosody/src/handler/context/mod.rs
+- ext/prosody/src/handler/context/vending.rs
 - ext/prosody/src/handler/message.rs
 - ext/prosody/src/handler/mod.rs
+- ext/prosody/src/handler/state/deque.rs
 - ext/prosody/src/handler/state/mod.rs
+- ext/prosody/src/handler/state/query.rs
 - ext/prosody/src/handler/state/registration.rs
 - ext/prosody/src/handler/state/scan.rs
+- ext/prosody/src/handler/state/set.rs
 - ext/prosody/src/handler/trigger.rs
 - ext/prosody/src/lib.rs
 - ext/prosody/src/logging.rs
@@ -167,19 +176,29 @@ files:
 - ext/prosody/src/tracing_util.rs
 - ext/prosody/src/util.rs
 - lib/prosody.rb
+- lib/prosody/client.rb
 - lib/prosody/configuration.rb
+- lib/prosody/demand.rb
 - lib/prosody/handler.rb
 - lib/prosody/native_stubs.rb
+- lib/prosody/native_stubs/client.rb
+- lib/prosody/native_stubs/context.rb
+- lib/prosody/native_stubs/message.rb
 - lib/prosody/processor.rb
 - lib/prosody/request.rb
 - lib/prosody/sentry.rb
 - lib/prosody/state.rb
+- lib/prosody/state/deque.rb
+- lib/prosody/state/map.rb
+- lib/prosody/state/set.rb
+- lib/prosody/state/value.rb
 - lib/prosody/version.rb
 - release-please-config.json
 - sig/configuration.rbs
 - sig/handler.rbs
 - sig/processor.rbs
 - sig/prosody.rbs
+- sig/published.rbs
 - sig/request.rbs
 - sig/sentry.rbs
 - sig/state.rbs