herb 0.10.4-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/sig/herb/engine/slots/state_anchor.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/herb/engine/slots/state_anchor.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # Points a diagnostic at the part of an expression that is actually wrong.
+      #
+      # A condition reaches the state compiler as a string that was cut out of an ERB token, so a
+      # Prism node inside it knows only its own offset within that string. This carries the token
+      # the string came from and turns those offsets back into a location in the template. When it
+      # has nothing to work with it answers the whole node's location, which is what every
+      # diagnostic used before.
+      #
+      # A node resolved out of the template's whole Prism program counts from the start of the
+      # template instead, so `rebased` takes the offset those nodes count from.
+      class StateAnchor
+        attr_reader location: Herb::Location?
+
+        # : (Herb::Location?, ?token: Herb::Token?, ?expression: String?, ?context: Symbol, ?base: Integer) -> void
+        def initialize: (Herb::Location?, ?token: Herb::Token?, ?expression: String?, ?context: Symbol, ?base: Integer) -> void
+
+        # : (Integer) -> StateAnchor
+        def rebased: (Integer) -> StateAnchor
+
+        # : () -> bool
+        def condition?: () -> bool
+
+        # : (::Prism::Node) -> Herb::Location?
+        def locate: (::Prism::Node) -> Herb::Location?
+
+        private
+
+        # : (::Prism::Node) -> Integer?
+        def character_offset: (::Prism::Node) -> Integer?
+
+        # : (Integer) -> Herb::Position
+        def advance: (Integer) -> Herb::Position
+      end
+    end
+  end
+end

data/sig/herb/engine/slots/state_compiler.rbs

@@ -0,0 +1,258 @@
+# Generated from lib/herb/engine/slots/state_compiler.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # Compiles the `herb:state` directives a template declares.
+      #
+      # A directive names states with their defaults. This turns them into assignments the template
+      # runs, classifies the conditionals and boolean attributes that read them, folds the counts
+      # that count over a collection, and builds the tables a page needs to resolve any of it for
+      # itself. It knows nothing about markers; it asks the visitor which slot a node is.
+      class StateCompiler
+        STATE_KEYWORDS: Hash[String, Symbol]
+
+        SEEDS_LOCAL: String
+
+        OVERRIDES_LOCAL: String
+
+        BARE_IDENTIFIER: Regexp
+
+        BINDABLE_ATTRIBUTES: Array[String]
+
+        BINDABLE_ELEMENTS: Array[String]
+
+        COLLECTION_SLOT_TYPES: Array[Symbol]
+
+        attr_reader state_presence: Hash[Integer, untyped]
+
+        attr_reader state_values: Hash[Integer, untyped]
+
+        # : (untyped) -> void
+        def initialize: (untyped) -> void
+
+        # : () -> bool
+        def any?: () -> bool
+
+        # : () -> String
+        def declare_internal_block: () -> String
+
+        # : (String) -> String
+        def internal_assignment: (String) -> String
+
+        # : () -> Array[String]
+        def count_signatures: () -> Array[String]
+
+        # : () -> Hash[String, untyped]?
+        def manifest: () -> Hash[String, untyped]?
+
+        # : (untyped, String) -> void
+        def warn_unbindable: (untyped, String) -> void
+
+        # : (untyped) -> bool
+        def bindable_shape?: (untyped) -> bool
+
+        # : (Integer, untyped) -> void
+        def warn_computed_presence: (Integer, untyped) -> void
+
+        # : (untyped) -> bool
+        def bare_presence?: (untyped) -> bool
+
+        # : (untyped, String, Array[String]) -> void
+        def warn_near_miss: (untyped, String, Array[String]) -> void
+
+        # : () -> Hash[String, untyped]
+        def fragment_entries: () -> Hash[String, untyped]
+
+        # : (Array[Hash[String, untyped]]) -> Set[String]
+        def steerable_names: (Array[Hash[String, untyped]]) -> Set[String]
+
+        # : (untyped) -> Array[String]
+        def condition_names: (untyped) -> Array[String]
+
+        # : (Hash[Symbol, untyped], Set[String]) -> bool
+        def steered_conditional?: (Hash[Symbol, untyped], Set[String]) -> bool
+
+        # : (Integer, Hash[Symbol, untyped]) -> Set[Integer]
+        def default_branch_slots: (Integer, Hash[Symbol, untyped]) -> Set[Integer]
+
+        # : (Integer, Integer) -> Set[Integer]
+        def branch_slot_set: (Integer, Integer) -> Set[Integer]
+
+        # : (untyped, Hash[String, StateDirectives::Declaration]) -> bool?
+        def static_condition: (untyped, Hash[String, StateDirectives::Declaration]) -> bool?
+
+        # : (Hash[String, untyped], Hash[String, StateDirectives::Declaration]) -> untyped
+        def static_comparand: (Hash[String, untyped], Hash[String, StateDirectives::Declaration]) -> untyped
+
+        # : (Hash[String, untyped], Hash[String, StateDirectives::Declaration]) -> bool?
+        def static_combo: (Hash[String, untyped], Hash[String, StateDirectives::Declaration]) -> bool?
+
+        # : (String, Hash[String, StateDirectives::Declaration]) -> untyped
+        def static_default: (String, Hash[String, StateDirectives::Declaration]) -> untyped
+
+        # : (untyped, untyped, String) -> bool?
+        def compare_statics: (untyped, untyped, String) -> bool?
+
+        # : (Hash[String, Array[Integer]], Hash[String, untyped], Hash[String, untyped], Set[String]) -> void
+        def branch_orphans: (Hash[String, Array[Integer]], Hash[String, untyped], Hash[String, untyped], Set[String]) -> void
+
+        # : (Hash[Symbol, untyped], (String | Integer)) -> Hash[String, untyped]
+        def declared_entry: (Hash[Symbol, untyped], String | Integer) -> Hash[String, untyped]
+
+        # : (String, String?) -> void
+        def declare_local: (String, String?) -> void
+
+        # : () -> Array[Hash[Symbol, untyped]]
+        def state_count_entries: () -> Array[Hash[Symbol, untyped]]
+
+        # : () -> Hash[Symbol, untyped]
+        def state_declarations: () -> Hash[Symbol, untyped]
+
+        # : () -> Array[String]
+        def seeded_region_states: () -> Array[String]
+
+        # : () -> Hash[Integer, Array[String]]
+        def seeded_item_states: () -> Hash[Integer, Array[String]]
+
+        # : () -> Array[Hash[Symbol, untyped]]
+        def state_entries: () -> Array[Hash[Symbol, untyped]]
+
+        # : () -> Hash[Integer, String]
+        def state_conditional_signatures: () -> Hash[Integer, String]
+
+        # : () -> Hash[Integer, Hash[Symbol, untyped]]
+        def state_conditional_entries: () -> Hash[Integer, Hash[Symbol, untyped]]
+
+        # : (untyped, Array[untyped]) -> void
+        def register_state_directive: (untyped, Array[untyped]) -> void
+
+        # : (StateDirectives::Declaration) -> Herb::Location?
+        def declaration_location: (StateDirectives::Declaration) -> Herb::Location?
+
+        # : (String?) -> Symbol
+        def local_kind: (String?) -> Symbol
+
+        # : (untyped) -> Hash[String, StateDirectives::Declaration]
+        def states_for: (untyped) -> Hash[String, StateDirectives::Declaration]
+
+        # : () -> void
+        def apply_states: () -> void
+
+        # : () -> void
+        def check_deferred_placement: () -> void
+
+        # : () -> void
+        def check_fragments: () -> void
+
+        # : (Array[StateDirectives::Declaration]) -> String?
+        def seeds_marker: (Array[StateDirectives::Declaration]) -> String?
+
+        # : (StateDirectives::Declaration) -> String
+        def state_assignment: (StateDirectives::Declaration) -> String
+
+        # : (StateDirectives::Declaration) -> bool
+        def overridable?: (StateDirectives::Declaration) -> bool
+
+        # : (String) -> StateDirectives::Declaration?
+        def region_declaration: (String) -> StateDirectives::Declaration?
+
+        # : () -> Array[String]
+        def region_state_names: () -> Array[String]
+
+        # : (String) -> bool
+        def counted_state?: (String) -> bool
+
+        # : () -> String
+        def overrides_prelude: () -> String
+
+        # : () -> void
+        def classify_state_conditionals: () -> void
+
+        # : (untyped, Hash[String, StateDirectives::Declaration]) -> Hash[Symbol, untyped]?
+        def state_conditional_for: (untyped, Hash[String, StateDirectives::Declaration]) -> Hash[Symbol, untyped]?
+
+        # : (Array[String], Integer?) -> String
+        def signature_of: (Array[String], Integer?) -> String
+
+        # : (untyped, Integer?) -> Hash[String, untyped]
+        def arm_entry: (untyped, Integer?) -> Hash[String, untyped]
+
+        # : (untyped, Hash[String, StateDirectives::Declaration]) -> Hash[Symbol, untyped]?
+        def state_unless_for: (untyped, Hash[String, StateDirectives::Declaration]) -> Hash[Symbol, untyped]?
+
+        # : (String, StateDirectives::Read, Hash[String, StateDirectives::Declaration], StateAnchor, String) -> nil
+        def presence_error: (String, StateDirectives::Read, Hash[String, StateDirectives::Declaration], StateAnchor, String) -> nil
+
+        # : (untyped, Hash[String, StateDirectives::Declaration]) -> Hash[Symbol, untyped]?
+        def state_case_for: (untyped, Hash[String, StateDirectives::Declaration]) -> Hash[Symbol, untyped]?
+
+        # : (String, Hash[String, StateDirectives::Declaration]) -> StateDirectives::Declaration?
+        def mentioned_state: (String, Hash[String, StateDirectives::Declaration]) -> StateDirectives::Declaration?
+
+        # : (StateDirectives::Declaration?) -> String
+        def read_advice: (StateDirectives::Declaration?) -> String
+
+        # : (untyped, String) -> StateAnchor
+        def condition_anchor: (untyped, String) -> StateAnchor
+
+        # : (untyped) -> String
+        def condition_expression: (untyped) -> String
+
+        # : (untyped) -> untyped
+        def resolved_ruby: (untyped) -> untyped
+
+        # : (untyped) -> untyped
+        def register_count_fold: (untyped) -> untyped
+
+        # : (untyped) -> void
+        def check_state_assignment: (untyped) -> void
+
+        # : (StateDirectives::FoldIncrement, when_read: untyped, location: Herb::Location?) -> void
+        def register_count: (StateDirectives::FoldIncrement, when_read: untyped, location: Herb::Location?) -> void
+
+        # : () -> void
+        def check_state_count_reads: () -> void
+
+        # : (untyped, String) -> void
+        def rewrite_predicate: (untyped, String) -> void
+
+        # : (untyped, String) -> untyped
+        def rewrite_literal_predicate: (untyped, String) -> untyped
+
+        # : (untyped) -> untyped
+        def predicate_token_for: (untyped) -> untyped
+
+        # : (untyped) -> Array[untyped]
+        def interpolation_children: (untyped) -> Array[untyped]
+
+        # : (untyped, Integer, untyped) -> void
+        def register_segment_reads: (untyped, Integer, untyped) -> void
+
+        # : (untyped) -> String
+        def segment_code: (untyped) -> String
+
+        # : (untyped, Hash[String, StateDirectives::Declaration]) -> void
+        def check_interpolated_state_read: (untyped, Hash[String, StateDirectives::Declaration]) -> void
+
+        # : () -> void
+        def check_state_value_reads: () -> void
+
+        # : (untyped, Integer, untyped, String, Hash[String, StateDirectives::Declaration]) -> void
+        def register_state_value: (untyped, Integer, untyped, String, Hash[String, StateDirectives::Declaration]) -> void
+
+        # : () -> void
+        def check_collection_reads: () -> void
+
+        # : (untyped, Integer, untyped, String, Hash[String, StateDirectives::Declaration]) -> nil
+        def register_server_read: (untyped, Integer, untyped, String, Hash[String, StateDirectives::Declaration]) -> nil
+
+        # : (untyped, untyped, String) -> Symbol?
+        def refuse_mixed_boolean: (untyped, untyped, String) -> Symbol?
+
+        # : (untyped, Integer, untyped, String, Hash[String, StateDirectives::Declaration]) -> untyped
+        def convert_boolean_attribute: (untyped, Integer, untyped, String, Hash[String, StateDirectives::Declaration]) -> untyped
+      end
+    end
+  end
+end

data/sig/herb/engine/slots/state_directives.rbs

@@ -0,0 +1,278 @@
+# Generated from lib/herb/engine/slots/state_directives.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # Parses `<%# herb:state (name: default, …) %>` directives and classifies how the body
+      # reads the states they declare.
+      class StateDirectives
+        BARE: Regexp
+
+        KINDS: Hash[String, Symbol]
+
+        NODE_KINDS: Hash[String, Symbol]
+
+        class Declaration < Data
+          attr_reader name(): String
+
+          attr_reader kind(): Symbol
+
+          attr_reader default(): String
+
+          attr_reader derived(): untyped
+
+          attr_reader line(): Integer?
+
+          attr_reader column(): Integer?
+
+          def self.new: (String name, Symbol kind, String default, untyped derived, Integer? line, Integer? column) -> instance
+                      | (name: String, kind: Symbol, default: String, derived: untyped, line: Integer?, column: Integer?) -> instance
+
+          def self.members: () -> [ :name, :kind, :default, :derived, :line, :column ]
+
+          def members: () -> [ :name, :kind, :default, :derived, :line, :column ]
+        end
+
+        class Read < Data
+          attr_reader name(): String
+
+          attr_reader comparand(): String?
+
+          attr_reader kind(): Symbol?
+
+          attr_reader operator(): String?
+
+          attr_reader against(): String?
+
+          attr_reader transform(): String?
+
+          attr_reader against_transform(): String?
+
+          def self.new: (String name, String? comparand, Symbol? kind, String? operator, String? against, String? transform, String? against_transform) -> instance
+                      | (name: String, comparand: String?, kind: Symbol?, operator: String?, against: String?, transform: String?, against_transform: String?) -> instance
+
+          def self.members: () -> [ :name, :comparand, :kind, :operator, :against, :transform, :against_transform ]
+
+          def members: () -> [ :name, :comparand, :kind, :operator, :against, :transform, :against_transform ]
+        end
+
+        class Combo < Data
+          attr_reader op(): String
+
+          attr_reader parts(): Array[untyped]
+
+          def self.new: (String op, Array[untyped] parts) -> instance
+                      | (op: String, parts: Array[untyped]) -> instance
+
+          def self.members: () -> [ :op, :parts ]
+
+          def members: () -> [ :op, :parts ]
+        end
+
+        class FoldIncrement < Data
+          attr_reader name(): String
+
+          attr_reader by(): Integer
+
+          def self.new: (String name, Integer by) -> instance
+                      | (name: String, by: Integer) -> instance
+
+          def self.members: () -> [ :name, :by ]
+
+          def members: () -> [ :name, :by ]
+        end
+
+        ORDERED_OPERATORS: Array[Symbol]
+
+        MIRRORED_OPERATORS: Hash[String, String]
+
+        NEGATED_OPERATORS: Hash[String, String]
+
+        FALSY_OPERATOR: String
+
+        PREDICATES: Hash[String, Hash[Symbol, untyped]]
+
+        UNARY_OPERATORS: Hash[String, String]
+
+        NEGATED_UNARY: Hash[String, String]
+
+        TRANSFORMS: Hash[String, Hash[Symbol, untyped]]
+
+        TRANSFORM_SPELLINGS: Hash[String, String]
+
+        class Parsing < Data
+          attr_reader locals(): Hash[String, Symbol]
+
+          attr_reader declared(): Hash[String, Declaration]
+
+          attr_reader names(): Array[String]
+
+          attr_reader enclosing(): Hash[String, Declaration]
+
+          attr_reader visitor(): untyped
+
+          attr_reader location(): Herb::Location?
+
+          def self.new: (Hash[String, Symbol] locals, Hash[String, Declaration] declared, Array[String] names, Hash[String, Declaration] enclosing, untyped visitor, Herb::Location? location) -> instance
+                      | (locals: Hash[String, Symbol], declared: Hash[String, Declaration], names: Array[String], enclosing: Hash[String, Declaration], visitor: untyped, location: Herb::Location?) -> instance
+
+          def self.members: () -> [ :locals, :declared, :names, :enclosing, :visitor, :location ]
+
+          def members: () -> [ :locals, :declared, :names, :enclosing, :visitor, :location ]
+        end
+
+        module Silent
+          # : (String, Herb::Location?, Symbol, **untyped) -> nil
+          def self.slot_error: (String, Herb::Location?, Symbol, **untyped) -> nil
+
+          # : (?Symbol?) -> Integer
+          def self.diagnostic_count: (?Symbol?) -> Integer
+        end
+
+        # : (untyped, Hash[String, Symbol], visitor: untyped, ?enclosing: Hash[String, Declaration]) -> Array[Declaration]
+        def self.parse: (untyped, Hash[String, Symbol], visitor: untyped, ?enclosing: Hash[String, Declaration]) -> Array[Declaration]
+
+        # : (String, Hash[String, Declaration], untyped, (StateAnchor | Herb::Location)?, ?untyped) -> (Read | Combo | Symbol)?
+        def self.condition_read: (String, Hash[String, Declaration], untyped, (StateAnchor | Herb::Location)?, ?untyped) -> (Read | Combo | Symbol)?
+
+        # : (untyped, Hash[String, Declaration], untyped, (StateAnchor | Herb::Location)?) -> (Read | Combo | Symbol)?
+        def self.tree_read: (untyped, Hash[String, Declaration], untyped, (StateAnchor | Herb::Location)?) -> (Read | Combo | Symbol)?
+
+        # : (untyped) -> untyped
+        def self.unwrap_parentheses: (untyped) -> untyped
+
+        # : (untyped, Hash[String, Declaration], untyped, StateAnchor) -> (Combo | Symbol)?
+        def self.combo_read: (untyped, Hash[String, Declaration], untyped, StateAnchor) -> (Combo | Symbol)?
+
+        # : (untyped, untyped, untyped, untyped, StateAnchor) -> nil
+        def self.mixed_combo: (untyped, untyped, untyped, untyped, StateAnchor) -> nil
+
+        # : (untyped, untyped) -> Array[untyped]
+        def self.flatten_combo: (untyped, untyped) -> Array[untyped]
+
+        # : (Read | Combo) -> Array[String]
+        def self.read_names: (Read | Combo) -> Array[String]
+
+        # : (Read | Combo) -> untyped
+        def self.condition_entry: (Read | Combo) -> untyped
+
+        # : (Read) -> untyped
+        def self.comparand_entry: (Read) -> untyped
+
+        # : (String) -> untyped
+        def self.literal_value: (String) -> untyped
+
+        # : (String) -> bool
+        def self.literal?: (String) -> bool
+
+        # : (Read | Combo) -> String
+        def self.condition_source: (Read | Combo) -> String
+
+        # : (String) -> FoldIncrement?
+        def self.fold_increment: (String) -> FoldIncrement?
+
+        # : (String, Hash[String, Declaration]) -> Array[String]
+        def self.assigned_state_names: (String, Hash[String, Declaration]) -> Array[String]
+
+        # : (String, Declaration) -> (Array[String] | Symbol)
+        def self.when_comparands: (String, Declaration) -> (Array[String] | Symbol)
+
+        # : (Symbol?, String) -> String
+        def self.predicate_advice: (Symbol?, String) -> String
+
+        # : ((Read | Combo)) -> Read?
+        def self.never_falsy_read: (Read | Combo) -> Read?
+
+        # : (Declaration) -> bool
+        def self.literal_default?: (Declaration) -> bool
+
+        # : (Declaration, String) -> String
+        def self.default_example: (Declaration, String) -> String
+
+        # : (Declaration) -> bool
+        def self.seeded?: (Declaration) -> bool
+
+        # : (Read) -> String
+        def self.subject_phrase: (Read) -> String
+
+        # : ((Symbol | String)?) -> String
+        def self.kind_article: ((Symbol | String)?) -> String
+
+        # : (String, String, ?untyped) -> String
+        def self.rewrite_reads: (String, String, ?untyped) -> String
+
+        # : (String, Hash[String, Declaration]) -> bool
+        def self.mentions_any?: (String, Hash[String, Declaration]) -> bool
+
+        # : (untyped, Hash[String, Declaration]) -> bool
+        def self.mentions?: (untyped, Hash[String, Declaration]) -> bool
+
+        # : (untyped, String) -> untyped
+        private def self.resolved_expression: (untyped, String) -> untyped
+
+        # : (Array[untyped], Hash[String, Declaration]) -> bool
+        private def self.reads_any?: (Array[untyped], Hash[String, Declaration]) -> bool
+
+        # : (String, String, untyped) -> Array[[Integer, Integer, String]]
+        private def self.read_splices: (String, String, untyped) -> Array[[ Integer, Integer, String ]]
+
+        # : (String) -> Array[untyped]
+        private def self.expression_nodes: (String) -> Array[untyped]
+
+        # : (untyped) -> Array[untyped]
+        private def self.descendants: (untyped) -> Array[untyped]
+
+        # : (untyped) -> String?
+        private def self.bare_name: (untyped) -> String?
+
+        # : (untyped, Parsing) -> Declaration
+        private def self.declaration_for: (untyped, Parsing) -> Declaration
+
+        # : (untyped, Parsing) -> Declaration
+        private def self.classify: (untyped, Parsing) -> Declaration
+
+        # : (String, String, untyped, Herb::Location?, **untyped) -> Declaration
+        private def self.refused: (String, String, untyped, Herb::Location?, **untyped) -> Declaration
+
+        # : (String, String, Herb::Location?, Parsing) -> Declaration?
+        private def self.derived_default: (String, String, Herb::Location?, Parsing) -> Declaration?
+
+        # : (Read | Combo) -> Symbol
+        private def self.derived_kind: (Read | Combo) -> Symbol
+
+        # : (String, String, Herb::Location?, Parsing) -> Declaration
+        private def self.bare_default: (String, String, Herb::Location?, Parsing) -> Declaration
+
+        # : (String) -> untyped
+        private def self.expression_node: (String) -> untyped
+
+        # : (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+        private def self.bare_read: (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+
+        # : (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+        private def self.operand_read: (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+
+        # : (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+        private def self.transform_read: (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+
+        # : (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+        private def self.predicate_read: (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+
+        # : (untyped, Read, untyped, StateAnchor, **untyped) -> nil
+        private def self.nil_check_error: (untyped, Read, untyped, StateAnchor, **untyped) -> nil
+
+        # : (untyped, Hash[String, Declaration], untyped, StateAnchor) -> (Read | Combo)?
+        private def self.negated_read: (untyped, Hash[String, Declaration], untyped, StateAnchor) -> (Read | Combo)?
+
+        # : (Read | Combo) -> (Read | Combo)
+        private def self.negate: (Read | Combo) -> (Read | Combo)
+
+        # : (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+        private def self.equality_read: (untyped, Hash[String, Declaration], untyped, StateAnchor) -> Read?
+
+        # : (untyped, Read, Read, untyped, StateAnchor) -> Read?
+        private def self.state_pair_read: (untyped, Read, Read, untyped, StateAnchor) -> Read?
+      end
+    end
+  end
+end

data/sig/herb/engine/slots/state_kinds.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/herb/engine/slots/state_kinds.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # The kinds a `herb:state` default can have, and what each one means to the compiler.
+      module StateKinds
+        PRISM: Hash[String, Symbol]
+
+        NODE: Hash[String, Symbol]
+
+        LITERAL: Array[Symbol]
+
+        UNKNOWN: Array[Symbol]
+
+        FALSY: Array[Symbol]
+
+        NILABLE: Array[Symbol]
+
+        ARTICLES: Hash[String, String]
+      end
+    end
+  end
+end

data/sig/herb/engine/slots/state_operators.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/herb/engine/slots/state_operators.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # The comparison operators a `herb:state` read may use, and what swapping or negating one
+      # turns it into.
+      module StateOperators
+        MIRRORED: Hash[String, String]
+
+        NEGATED: Hash[String, String]
+
+        ORDERED: Array[Symbol]
+
+        COMPARISONS: Array[String]
+      end
+    end
+  end
+end

data/sig/herb/engine/slots/state_overrides.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/herb/engine/slots/state_overrides.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # Resolves the state values a client sent along with a values request.
+      #
+      # The values program evaluates the branch the state picks, so a client that wants the
+      # values for its own branches sends its state and the program initializes each declared
+      # state from it. A host makes that possible by answering `__herb_state_overrides` in the
+      # render context with a hash keyed by template identifier. Everything here degrades to
+      # the compiled defaults, since a missing, malformed or wrongly typed override must never
+      # break a render the defaults could serve.
+      #
+      # A render call that binds or seeds the template's states pushes a `Bindings` frame, and
+      # the frame layers with the client's values. A seed sits under them, since a client that
+      # has written the state since it was seeded knows better. A binding sits over them, since
+      # the client cannot tell two render sites of one partial apart.
+      module StateOverrides
+        HOOK: String
+
+        # : (untyped, String) -> Hash[String, untyped]?
+        def self.resolve: (untyped, String) -> Hash[String, untyped]?
+
+        # : (Hash[String, untyped]?, String, Symbol) { () -> untyped } -> untyped
+        def self.fetch: (Hash[String, untyped]?, String, Symbol) { () -> untyped } -> untyped
+
+        # : (untyped, Symbol) -> untyped
+        def self.coerce: (untyped, Symbol) -> untyped
+      end
+    end
+  end
+end

data/sig/herb/engine/slots/state_predicates.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/herb/engine/slots/state_predicates.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # The Ruby predicates a `herb:state` read may use, and the condition each one resolves into.
+      module StatePredicates
+        TABLE: Hash[String, Hash[Symbol, untyped]]
+
+        NEGATED: Hash[String, String]
+
+        UNARY: Hash[String, String]
+      end
+    end
+  end
+end

data/sig/herb/engine/slots/state_transforms.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/herb/engine/slots/state_transforms.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # The Ruby methods a `herb:state` read may call to transform a state's value before comparing
+      # it, and the operation each one becomes on the wire.
+      module StateTransforms
+        TABLE: Hash[String, Hash[Symbol, untyped]]
+
+        SPELLINGS: Hash[String, String]
+      end
+    end
+  end
+end