herb 0.10.4 → 0.11.0

data/sig/herb/engine/runtime/session.rbs

@@ -0,0 +1,233 @@
+# Generated from lib/herb/engine/runtime/session.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Runtime
+      # Where everything found while a page renders collects, so that findings from separate
+      # producers end up in one payload rather than one channel each.
+      #
+      # Anything can record into the session that is open, without knowing whether one is open or who
+      # else is recording:
+      #
+      #     Herb::Engine::Runtime::Session.record(diagnostic)
+      #
+      # A scoped session is one somebody opened deliberately, which is what a request or a test does.
+      # Outside of one, recording still works and collects into a session nobody reads, so a producer
+      # never has to guard its own calls.
+      class Session
+        class Measurement < Data
+          attr_reader key(): untyped
+
+          attr_reader origin(): untyped
+
+          attr_reader code(): untyped
+
+          attr_reader message(): untyped
+
+          attr_reader description(): untyped
+
+          attr_reader kind(): untyped
+
+          attr_reader per(): untyped
+
+          attr_reader block(): untyped
+
+          def self.new: (untyped key, untyped origin, untyped code, untyped message, untyped description, untyped kind, untyped per, untyped block) -> instance
+                      | (key: untyped, origin: untyped, code: untyped, message: untyped, description: untyped, kind: untyped, per: untyped, block: untyped) -> instance
+
+          def self.members: () -> [ :key, :origin, :code, :message, :description, :kind, :per, :block ]
+
+          def members: () -> [ :key, :origin, :code, :message, :description, :kind, :per, :block ]
+        end
+
+        STATE_KEY: Symbol
+
+        RACTOR_KEY: Symbol
+
+        THREAD_KEY: Symbol
+
+        attr_reader report: Herb::Engine::Runtime::Report
+
+        attr_reader previous: Session?
+
+        # : () -> Session?
+        def self.stored: () -> Session?
+
+        # : (Session?) -> void
+        def self.store: (Session?) -> void
+
+        # : () -> Session
+        def self.current: () -> Session
+
+        # : [T] () { () -> T } -> Session
+        def self.capture: [T] () { () -> T } -> Session
+
+        # : () -> Session
+        def self.open: () -> Session
+
+        # : () -> Session?
+        def self.close: () -> Session?
+
+        # : (Herb::Diagnostic) -> Herb::Diagnostic
+        def self.record: (Herb::Diagnostic) -> Herb::Diagnostic
+
+        def self.record_compile_diagnostics: (untyped template, untyped entries) -> untyped
+
+        # : (String) -> void
+        def self.read_source: (String) -> void
+
+        # : [T] (String?, Integer, Integer, ?Symbol?, ?end_line: Integer?, ?end_column: Integer?) { () -> T } -> T
+        def self.at: [T] (String?, Integer, Integer, ?Symbol?, ?end_line: Integer?, ?end_column: Integer?) { () -> T } -> T
+
+        # : (String?, Integer, Integer, ?Symbol?, ?end_line: Integer?, ?end_column: Integer?) -> void
+        def self.enter: (String?, Integer, Integer, ?Symbol?, ?end_line: Integer?, ?end_column: Integer?) -> void
+
+        # : [T] (String?, Integer, Integer, ?Symbol?, ?end_line: Integer?, ?end_column: Integer?) { () -> T } -> T
+        def self.output: [T] (String?, Integer, Integer, ?Symbol?, ?end_line: Integer?, ?end_column: Integer?) { () -> T } -> T
+
+        # : () -> void
+        def self.leave: () -> void
+
+        # : [T] (String?, ?String?) { () -> T } -> T
+        def self.render: [T] (String?, ?String?) { () -> T } -> T
+
+        # : (String?, ?String?) -> String
+        def self.enter_render: (String?, ?String?) -> String
+
+        # : () -> void
+        def self.leave_render: () -> void
+
+        # : () -> String?
+        def self.current_node: () -> String?
+
+        # : (Symbol, untyped, origin: String) -> void
+        def self.annotate: (Symbol, untyped, origin: String) -> void
+
+        # : (Symbol, untyped) -> void
+        def self.observe: (Symbol, untyped) -> void
+
+        # : () -> Array[Array[untyped]]
+        def self.stack: () -> Array[Array[untyped]]
+
+        # : (String, String?) -> void
+        def self.source: (String, String?) -> void
+
+        # : () -> bool
+        def self.scoped?: () -> bool
+
+        # : (Symbol, origin: String, ?code: String?, ?message: String?, ?description: (^(Array[untyped]) -> String)?, ?kind: Symbol, ?per: Symbol) { (Array[untyped]) -> String } -> void
+        def self.measurement: (Symbol, origin: String, ?code: String?, ?message: String?, ?description: (^(Array[untyped]) -> String)?, ?kind: Symbol, ?per: Symbol) { (Array[untyped]) -> String } -> void
+
+        # : () -> Array[Herb::Engine::Runtime::Session::Measurement]
+        def self.measurements: () -> Array[Herb::Engine::Runtime::Session::Measurement]
+
+        # : () -> void
+        def self.clear_measurements: () -> void
+
+        # : () -> void
+        def self.reset!: () -> void
+
+        # : (?scoped: bool, ?report: Herb::Engine::Runtime::Report?, ?previous: Session?) -> void
+        def initialize: (?scoped: bool, ?report: Herb::Engine::Runtime::Report?, ?previous: Session?) -> void
+
+        # : () -> bool
+        def scoped?: () -> bool
+
+        # : (Herb::Diagnostic) -> Herb::Diagnostic
+        def record: (Herb::Diagnostic) -> Herb::Diagnostic
+
+        # : (String, String?) -> void
+        def source: (String, String?) -> void
+
+        # : (Symbol) { () -> untyped } -> untyped
+        def channel: (Symbol) { () -> untyped } -> untyped
+
+        # : () -> Array[Herb::Diagnostic]
+        def diagnostics: () -> Array[Herb::Diagnostic]
+
+        # : () -> bool
+        def empty?: () -> bool
+
+        # : (String?, Integer, Integer, ?Symbol?, ?end_line: Integer?, ?end_column: Integer?) -> void
+        def enter: (String?, Integer, Integer, ?Symbol?, ?end_line: Integer?, ?end_column: Integer?) -> void
+
+        # : () -> void
+        def leave: () -> void
+
+        # Every tag still rendering, innermost first, the way `caller` reads.
+        #
+        # A tag that renders a partial is still open while the partial renders, so once more than one
+        # template is instrumented this is a render stack across all of them and not just within one.
+        # Only the innermost frame is what an observation is filed under, so anything wanting the rest
+        # has to take it while it still exists:
+        #
+        #     ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+        #       Herb::Engine::Runtime::Session.observe(:queries, { sql: payload[:sql], stack: Herb::Engine::Runtime::Session.stack })
+        #     end
+        #
+        # Taking it costs an array per observation, which is why it is offered rather than recorded.
+        # : () -> Array[Array[untyped]]
+        def stack: () -> Array[Array[untyped]]
+
+        # Filed under the render it happened in, not only the position it happened at.
+        #
+        # A partial rendered three times has one tag at one position, so keying on position alone
+        # merges all three into one entry reading "3 queries" at one place. That reads as one slow
+        # tag when the finding is a tag that runs once per item, which is the thing worth noticing.
+        # : (Symbol, untyped) -> void
+        def observe: (Symbol, untyped) -> void
+
+        # One render of one template, which is what a node in the payload is.
+        #
+        # A template rendered three times is three nodes, because what gets said about it is said
+        # about an occurrence and not about the file. The id is minted here so there is exactly one
+        # of them per occurrence, rather than one per producer that wants to name it.
+        #
+        # The tag that is open when a render starts is the tag that started it, so the call site
+        # comes for free. Without it the tree would say a partial rendered twice under one parent but
+        # not from where, which `stack` can say and a payload built from the tree alone could not.
+        # : (String?, ?String?) -> String
+        def enter_render: (String?, ?String?) -> String
+
+        # : () -> void
+        def leave_render: () -> void
+
+        # : () -> String?
+        def current_node: () -> String?
+
+        # : (Symbol, untyped, origin: String) -> void
+        def annotate: (Symbol, untyped, origin: String) -> void
+
+        # : () -> Array[Herb::Engine::Runtime::Entry]
+        def entries: () -> Array[Herb::Engine::Runtime::Entry]
+
+        # : () -> Array[Herb::Diagnostic]
+        def apply_measurements: () -> Array[Herb::Diagnostic]
+
+        # Turns what was observed under one key into one diagnostic per tag that saw any.
+        #
+        #     ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+        #       Herb::Engine::Runtime::Session.observe(:queries, payload[:sql]) unless payload[:cached]
+        #     end
+        #
+        #     session.measure(:queries, origin: "Herb Engine", code: "sql-queries") do |queries|
+        #       "#{queries.size} SQL queries"
+        #     end
+        #
+        # A count is a measurement rather than a fault, so what comes out carries a badge and no
+        # severity. Three queries at one tag is worth showing every time and worth worrying about
+        # only sometimes, and which of those it is depends on what the tag is for. Reporting it as a
+        # warning would make that call on the reader's behalf and get it wrong often enough to train
+        # them to ignore it.
+        #
+        # : (Symbol, origin: String, ?code: String?, ?message: String?, ?description: (^(Array[untyped]) -> String)?, ?kind: Symbol, ?per: Symbol) { (Array[untyped]) -> String } -> Array[Herb::Diagnostic]
+        def measure: (Symbol, origin: String, ?code: String?, ?message: String?, ?description: (^(Array[untyped]) -> String)?, ?kind: Symbol, ?per: Symbol) { (Array[untyped]) -> String } -> Array[Herb::Diagnostic]
+
+        private
+
+        # : (Symbol, Symbol) -> Array[[Herb::Engine::Runtime::Entry, Array[untyped]]]
+        def measurable: (Symbol, Symbol) -> Array[[ Herb::Engine::Runtime::Entry, Array[untyped] ]]
+      end
+    end
+  end
+end

data/sig/herb/engine/runtime.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/herb/engine/runtime.rb with RBS::Inline
+
+module Herb
+  class Engine
+    # Everything a compiled template talks to while it renders.
+    #
+    # A constant under here is named by generated Ruby, so an application serving templates that
+    # were compiled ahead of time needs this and nothing else the engine ships:
+    #
+    #     require "herb/engine/runtime"
+    module Runtime
+    end
+  end
+end

data/sig/herb/engine/scoped_style/channel.rbs

@@ -0,0 +1,45 @@
+# Generated from lib/herb/engine/scoped_style/channel.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module ScopedStyle
+      # The CSS every scoped block on a page narrowed, collected once however many times the files
+      # holding them rendered.
+      #
+      # A template compiled with `deliver: :hoist` registers here as it renders:
+      #
+      #     ::Herb::Engine::ScopedStyle::Channel.record("data-herb-scope-1a2b3c4d", ".title[data-herb-scope-1a2b3c4d]{color:red}")
+      #
+      # It is a channel on the session the page is collecting into, so it registers itself the first
+      # time anything records, and nothing in `Report` or `Session` has to know it exists.
+      class Channel
+        NAME: Symbol
+
+        ATTRIBUTE: String
+
+        ANCHOR: Symbol
+
+        # : (String, String) -> void
+        def self.record: (String, String) -> void
+
+        # : () -> void
+        def initialize: () -> void
+
+        # : (String, String) -> void
+        def add: (String, String) -> void
+
+        # : () -> Hash[String, String]
+        def styles: () -> Hash[String, String]
+
+        # : () -> Symbol
+        def anchor: () -> Symbol
+
+        # : () -> bool
+        def empty?: () -> bool
+
+        # : () -> String
+        def to_html: () -> String
+      end
+    end
+  end
+end

data/sig/herb/engine/scoped_style/collector.rbs

@@ -0,0 +1,45 @@
+# Generated from lib/herb/engine/scoped_style/collector.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module ScopedStyle
+      # The CSS a set of templates scoped, gathered without rendering any of them.
+      #
+      # A scope and its CSS are decided when a file is compiled, so everything a stylesheet needs is
+      # knowable ahead of time. This compiles each file for that and nothing else, which is what makes
+      # it possible to write the CSS into an asset and have templates emit none of it:
+      #
+      #     collector = Herb::Engine::ScopedStyle::Collector.new(transform: transform, project_path: root)
+      #
+      #     collector.add("app/views/posts/_card.html.erb")
+      #     collector.add("app/views/posts/index.html.erb")
+      #
+      #     collector.to_css #=> the one stylesheet those files add up to
+      #
+      # Which files to give it, and where the stylesheet goes, is the job of whatever integrates Herb
+      # with a framework. This knows how to compile and what to keep.
+      class Collector < Engine::Collector
+        # : (transform: untyped, ?project_path: (String | Pathname)?, **untyped) -> void
+        def initialize: (transform: untyped, ?project_path: (String | Pathname)?, **untyped) -> void
+
+        # : ((String | Pathname), ?String?) -> Array[String]
+        def add: (String | Pathname, ?String?) -> Array[String]
+
+        # : () -> Hash[String, String]
+        def styles: () -> Hash[String, String]
+
+        # : () -> Hash[String, Array[String]]
+        def files: () -> Hash[String, Array[String]]
+
+        # : () -> bool
+        def empty?: () -> bool
+
+        # : () -> String
+        def to_css: () -> String
+
+        # : () -> String
+        def inspect: () -> String
+      end
+    end
+  end
+end

data/sig/herb/engine/scoped_style/visitor.rbs

@@ -0,0 +1,220 @@
+# Generated from lib/herb/engine/scoped_style/visitor.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module ScopedStyle
+      # Scopes a `<style scoped>` block to the markup written in the same file.
+      #
+      #     require "herb/engine/scoped_style/visitor"
+      #
+      #     Herb::Engine.new(source, filename: path, visitors: [
+      #       Herb::Engine::ScopedStyle::Visitor.new(transform: transform)
+      #     ])
+      #
+      # A file holding a scoped block is given a scope attribute, and the block's selectors are
+      # rewritten to require it. There is no single root element to write, because a file is scoped
+      # as a whole. A file with five sibling roots and a file with none behave the same way.
+      #
+      # Every element the file wrote carries the attribute, and every rule is narrowed by it. Markup the
+      # file rendered carries a scope of its own or none, so a block reaches what the file wrote and
+      # nothing else, whatever is nested inside it.
+      #
+      # Narrowing by ancestor would cost fewer attributes, and cannot be had. An element inside a nested
+      # scope is still a descendant of the one outside it, and CSS has no way to say otherwise, so only
+      # an attribute on the element itself tells them apart.
+      #
+      # A file is scoped as a whole, so markup an inlined partial brought with it belongs to the
+      # partial and not to the template it landed in. `Herb::Visitor::Context::Origin` is what says so, which
+      # is why this has to run after `InlineRenderVisitor` and before `Slots::Visitor`, whose parked
+      # markup a client rebuilds from and which therefore has to already carry the attribute.
+      #
+      # Rewriting the selectors is somebody else's job. `transform` is anything answering `call` with
+      # the block's CSS and the selector to narrow it by:
+      #
+      #     transform.call(".title { color: red }", scope: "[data-herb-scope-1a2b3c4d]")
+      #     #=> ".title[data-herb-scope-1a2b3c4d] { color: red }"
+      #
+      # Anything the return value answers to `warnings` is reported, because CSS a transform kept
+      # without acting on it is CSS that does nothing once the page is rendered.
+      #
+      # `LightningCSS::Transformer` answers that, so it can be handed over as it is:
+      #
+      #     Herb::Engine::ScopedStyle::Visitor.new(transform: LightningCSS::Transformer.new(minify: true))
+      #
+      # `scope` is the selector each rule has to be narrowed by, appended to what the rule already
+      # matches.
+      #
+      # Lightning CSS is what narrows a block unless something else is given, so `transform` is for
+      # narrowing it some other way. Without one at all, which is a machine with no `lightningcss` on
+      # it, a block is left exactly as it was written and reported. Scoping the markup while
+      # leaving the CSS alone would turn a scoped block into a global one. A `transform` that raises
+      # is treated the same way, so CSS nobody can read costs the block it was written in and not the
+      # whole template.
+      #
+      # `deliver` says where the narrowed CSS goes. `:inline` leaves the block where it was written,
+      # which needs nothing else installed and writes the block again on every render of the file it
+      # was written in. `:hoist` takes the block out and registers the CSS with the session the page
+      # is collecting into, which writes it once however many times the file renders, and needs
+      # `Herb::Engine::Runtime::Middleware` to put it on the page.
+      class Visitor < Herb::Visitor
+        extend Herb::Visitor::Experimental
+
+        include Herb::Visitor::ContextAware
+
+        include Herb::Visitor::Diagnostics
+
+        ARRAY_PROPERTIES: Array[Symbol]
+
+        NODE_PROPERTIES: Array[Symbol]
+
+        ATTRIBUTE_PREFIX: String
+
+        SCOPED_ATTRIBUTE: String
+
+        ANCHOR_ATTRIBUTE: String
+
+        UNSCOPABLE_ELEMENTS: Array[String]
+
+        OPEN_TAGS: Array[untyped]
+
+        DELIVERIES: Array[Symbol]
+
+        DIGEST_LENGTH: Integer
+
+        class Pending < Data
+          attr_reader node(): untyped
+
+          attr_reader open_tag(): untyped
+
+          attr_reader attribute(): untyped
+
+          attr_reader css(): untyped
+
+          attr_reader file(): untyped
+
+          attr_reader container(): untyped
+
+          def self.new: (untyped node, untyped open_tag, untyped attribute, untyped css, untyped file, untyped container) -> instance
+                      | (node: untyped, open_tag: untyped, attribute: untyped, css: untyped, file: untyped, container: untyped) -> instance
+
+          def self.members: () -> [ :node, :open_tag, :attribute, :css, :file, :container ]
+
+          def members: () -> [ :node, :open_tag, :attribute, :css, :file, :container ]
+        end
+
+        # : () -> bool
+        def self.rewrites_style_blocks?: () -> bool
+
+        # : (?transform: untyped, ?deliver: Symbol) -> void
+        def initialize: (?transform: untyped, ?deliver: Symbol) -> void
+
+        # : () -> Hash[String, String]
+        def styles: () -> Hash[String, String]
+
+        # : (Herb::AST::DocumentNode) -> void
+        def visit_document_node: (Herb::AST::DocumentNode) -> void
+
+        # : (Herb::AST::ERBBlockNode) -> void
+        def visit_erb_block_node: (Herb::AST::ERBBlockNode) -> void
+
+        # : (Herb::AST::HTMLElementNode) -> void
+        def visit_html_element_node: (Herb::AST::HTMLElementNode) -> void
+
+        # : () -> String
+        def inspect: () -> String
+
+        private
+
+        # : () -> String
+        def current_file: () -> String
+
+        # : (Herb::AST::Node) -> Herb::Visitor::Context::Origin::Entry?
+        def enter: (Herb::AST::Node) -> Herb::Visitor::Context::Origin::Entry?
+
+        # : () -> void
+        def leave: () -> void
+
+        # : (Herb::AST::Node, ?Array[untyped]?) -> void
+        def collect: (Herb::AST::Node, ?Array[untyped]?) -> void
+
+        # : (Herb::AST::Node, Symbol) -> untyped
+        def property_of: (Herb::AST::Node, Symbol) -> untyped
+
+        # : (Herb::AST::HTMLElementNode, Array[untyped]?) -> void
+        def scope_style: (Herb::AST::HTMLElementNode, Array[untyped]?) -> void
+
+        # : () -> void
+        def narrow: () -> void
+
+        # : (Pending, String) -> String?
+        def narrowed_css: (Pending, String) -> String?
+
+        # : (Pending, String, String) -> void
+        def place: (Pending, String, String) -> void
+
+        # : (Pending) -> Integer?
+        def position_of: (Pending) -> Integer?
+
+        # : (String, String) -> Herb::AST::ERBContentNode
+        def register_node: (String, String) -> Herb::AST::ERBContentNode
+
+        # : (String) -> Herb::AST::HTMLAttributeNode
+        def anchor_node: (String) -> Herb::AST::HTMLAttributeNode
+
+        # : (Herb::AST::HTMLOpenTagNode, Herb::AST::HTMLAttributeNode, Herb::AST::HTMLAttributeNode) -> void
+        def replace_attribute: (Herb::AST::HTMLOpenTagNode, Herb::AST::HTMLAttributeNode, Herb::AST::HTMLAttributeNode) -> void
+
+        # : (Herb::AST::HTMLOpenTagNode, Herb::AST::HTMLAttributeNode) -> void
+        def remove_attribute: (Herb::AST::HTMLOpenTagNode, Herb::AST::HTMLAttributeNode) -> void
+
+        # : (Herb::AST::HTMLOpenTagNode) -> Herb::AST::HTMLAttributeNode?
+        def scoped_attribute: (Herb::AST::HTMLOpenTagNode) -> Herb::AST::HTMLAttributeNode?
+
+        # : (Herb::AST::HTMLAttributeNode) -> String?
+        def attribute_name: (Herb::AST::HTMLAttributeNode) -> String?
+
+        # : (Herb::AST::HTMLElementNode) -> String?
+        def static_css: (Herb::AST::HTMLElementNode) -> String?
+
+        # : (Herb::AST::HTMLElementNode) -> bool
+        def scopable_file?: (Herb::AST::HTMLElementNode) -> bool
+
+        # : (Herb::AST::HTMLElementNode) -> void
+        def dynamic_style: (Herb::AST::HTMLElementNode) -> void
+
+        # : (Herb::AST::HTMLElementNode) -> void
+        def untransformed_style: (Herb::AST::HTMLElementNode) -> void
+
+        # : () -> untyped
+        def default_transform: () -> untyped
+
+        # : (Herb::AST::HTMLElementNode, StandardError, String) -> nil
+        def untransformable_style: (Herb::AST::HTMLElementNode, StandardError, String) -> nil
+
+        # : (Herb::AST::HTMLElementNode, untyped, String) -> void
+        def warned_style: (Herb::AST::HTMLElementNode, untyped, String) -> void
+
+        # : (String) -> String
+        def scope_selector: (String) -> String
+
+        # : (String) -> String
+        def scope_for: (String) -> String
+
+        # : (untyped) -> Array[untyped]?
+        def attribute_children: (untyped) -> Array[untyped]?
+
+        # : (Herb::AST::HTMLElementNode) -> bool
+        def scopable?: (Herb::AST::HTMLElementNode) -> bool
+
+        # : (String) -> Herb::AST::HTMLAttributeNode
+        def attribute_node: (String) -> Herb::AST::HTMLAttributeNode
+
+        # : (String) -> Herb::AST::LiteralNode
+        def literal_node: (String) -> Herb::AST::LiteralNode
+
+        # : () -> void
+        def report_empty_scopes: () -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# Generated from lib/herb/engine/slots/annotation.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # What the visitor knows about one slot while it is still reading the template.
+      #
+      # A slot's index is its address, and an address cannot be handed out until it is known which
+      # slots survive: collapsing an invariant conditional drops one and merges the branches behind
+      # it. So the walk records annotations, which carry no index and can be marked as it learns
+      # more, and only the final pass turns the survivors into numbered slots.
+      class Annotation
+        attr_reader node: untyped
+
+        attr_accessor type: Symbol
+
+        attr_reader node_path: Array[Integer]
+
+        attr_accessor expression: String?
+
+        attr_accessor attribute: String?
+
+        attr_reader key_source: Symbol?
+
+        attr_reader key_expression: String?
+
+        attr_reader tag: String?
+
+        attr_reader scope: untyped
+
+        attr_reader depth: Integer
+
+        attr_accessor index: Integer?
+
+        attr_accessor name: String?
+
+        attr_accessor dropped: bool
+
+        attr_accessor merged_into: Annotation?
+
+        attr_reader covered: Array[Annotation]
+
+        # : (node: untyped, type: Symbol, node_path: Array[Integer], expression: String?, attribute: String?, key_source: Symbol?, key_expression: String?, tag: String?, scope: untyped, depth: Integer) -> void
+        def initialize: (node: untyped, type: Symbol, node_path: Array[Integer], expression: String?, attribute: String?, key_source: Symbol?, key_expression: String?, tag: String?, scope: untyped, depth: Integer) -> void
+
+        # : () -> bool
+        def gone?: () -> bool
+
+        # : () -> Annotation
+        def survivor: () -> Annotation
+
+        # : () -> bool
+        def structural?: () -> bool
+
+        # : () -> bool
+        def attribute?: () -> bool
+
+        # : () -> bool
+        def anchored?: () -> bool
+
+        # : () -> bool
+        def nameable?: () -> bool
+
+        # : () -> bool
+        def valued?: () -> bool
+
+        # : (Integer) -> untyped
+        def to_slot: (Integer) -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# Generated from lib/herb/engine/slots/bindings.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # The state values a render call hands the partial it renders.
+      #
+      # A caller's compile rewrites `render "card", state: { open: modal_open }` into a call
+      # wrapped by `with`, so the values travel on a stack the partial's own state assignments
+      # read through `StateOverrides.resolve`. Two tables ride on every frame. A bound value
+      # aliases the partial's state to the caller's and wins over anything a client sent, since
+      # the client cannot tell two render sites of one partial apart. A seeded value only sets
+      # the partial's starting point, so a client that has since written the state wins over it.
+      #
+      # The stack lives in fiber storage, which a child fiber or thread inherits, so a render
+      # that streams or captures still sees the frames its caller pushed.
+      module Bindings
+        KEY: Symbol
+
+        class UncoercibleSeedError < StandardError
+        end
+
+        # : (String, ?bound: Hash[String, untyped], ?seeded: Hash[String, untyped]) { () -> untyped } -> untyped
+        def self.with: (String, ?bound: Hash[String, untyped], ?seeded: Hash[String, untyped]) { () -> untyped } -> untyped
+
+        # : (String) -> Hash[Symbol, Hash[String, untyped]]?
+        def self.current: (String) -> Hash[Symbol, Hash[String, untyped]]?
+
+        # : (String, String, untyped) -> void
+        def self.check_seed: (String, String, untyped) -> void
+      end
+    end
+  end
+end