funicular 0.2.1 → 0.3.0

data/mrblib/vdom.rb

@@ -6,6 +6,69 @@ module Funicular
 
     URL_ATTRIBUTES = %w[href src action formaction data poster xlink:href]
 
+    # VDOM input is normally authored by application code, but props and tags
+    # can also be assembled from hashes. Validate names before either the DOM
+    # renderer or the SSR serializer sees them so an attacker-controlled key
+    # cannot become HTML syntax.
+    SCRIPTING_ELEMENTS = %w[script]
+
+    def self.valid_tag_name?(name)
+      str = name.to_s
+      return false if str.empty?
+
+      index = 0
+      str.each_byte do |byte|
+        alpha = (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122)
+        digit = byte >= 48 && byte <= 57
+        return false unless alpha || (index > 0 && (digit || byte == 45))
+        index += 1
+      end
+      true
+    end
+
+    def self.valid_attribute_name?(name)
+      str = name.to_s
+      return false if str.empty?
+
+      str.each_byte do |byte|
+        alpha = (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122)
+        digit = byte >= 48 && byte <= 57
+        punctuation = byte == 45 || byte == 46 || byte == 58 || byte == 95
+        return false unless alpha || digit || punctuation
+      end
+      true
+    end
+
+    def self.event_attribute?(name)
+      name.to_s.downcase.start_with?('on')
+    end
+
+    def self.unsafe_url?(name, value)
+      return false unless URL_ATTRIBUTES.include?(name.to_s.downcase)
+
+      # Browsers discard ASCII tabs and newlines while parsing URLs, so test
+      # the same canonical form rather than only a literal "javascript:".
+      raw = value.to_s
+      start = 0
+      start += 1 while (byte = raw.getbyte(start)) && byte <= 32
+
+      normalized = (raw[start..-1] || "")
+                        .gsub("\t", "")
+                        .gsub("\n", "")
+                        .gsub("\r", "")
+                        .gsub("\f", "")
+                        .strip
+                        .downcase
+      normalized.start_with?('javascript:') || normalized.start_with?('vbscript:')
+    end
+
+    def self.blocked_attribute?(name, value)
+      normalized_name = name.to_s.downcase
+      event_attribute?(normalized_name) ||
+        normalized_name == 'srcdoc' ||
+        unsafe_url?(normalized_name, value)
+    end
+
     class VNode
       attr_reader :type, :key
 
@@ -20,8 +83,20 @@ module Funicular
       def initialize(tag, props = {}, children = [])
         super(:element)
         @tag = tag.to_s
+        unless VDOM.valid_tag_name?(@tag)
+          raise ArgumentError, "Invalid VDOM tag name: #{@tag.inspect}"
+        end
+        if SCRIPTING_ELEMENTS.include?(@tag.downcase)
+          raise ArgumentError, "Unsafe VDOM tag: #{@tag.inspect}"
+        end
+
         @key = props.delete(:key)
         @props = props || {}
+        @props.each_key do |name|
+          unless VDOM.valid_attribute_name?(name)
+            raise ArgumentError, "Invalid VDOM attribute name: #{name.inspect}"
+          end
+        end
         @children = normalize_children(children || [])
       end
 
@@ -71,26 +146,29 @@ module Funicular
     end
 
     class Component < VNode
-      attr_reader :component_class, :props
-      attr_accessor :instance
+      attr_reader :component_class, :props, :children
+      attr_accessor :instance, :runtime
 
-      def initialize(component_class, props = {})
+      def initialize(component_class, props = {}, children = [])
         super(:component)
         @component_class = component_class
         @key = props.delete(:key)
         @props = props
+        @children = children || []
         @instance = nil
+        @runtime = nil
       end
 
       def ==(other)
         return false unless other.is_a?(Component)
-        @component_class == other.component_class && @props == other.props
+        @component_class == other.component_class && @props == other.props && @children == other.children
       end
     end
 
     class Renderer
-      def initialize(doc = nil)
+      def initialize(doc = nil, runtime = nil)
         @doc = doc || JS.document
+        @runtime = runtime
         @error_boundary_stack = []
       end
 
@@ -122,13 +200,14 @@ module Funicular
 
         element.props.each do |key, value|
           key_str = key.to_s
-          if key_str.start_with?('on')
+          normalized_key = key_str.downcase
+          if VDOM.event_attribute?(normalized_key)
             # Event handlers are handled by Funicular::Component and should not be set as attributes.
             # warn "Funicular: Attempted to set event handler '#{key_str}' as an attribute. This will be ignored."
-          elsif URL_ATTRIBUTES.include?(key_str) && value.to_s.strip.downcase.start_with?('javascript:')
-            # Prevent XSS attacks by blocking javascript: URIs in URL attributes
+          elsif VDOM.blocked_attribute?(normalized_key, value)
+            # Prevent active HTML content and unsafe URL schemes.
             puts "[WARN] Funicular: Blocked potentially malicious value for attribute '#{key_str}'."
-          elsif BOOLEAN_ATTRIBUTES.include?(key_str)
+          elsif BOOLEAN_ATTRIBUTES.include?(normalized_key)
             # Handle boolean attributes
             if value.nil? || value.to_s == "false"
               # Do not set attribute (leave it absent)
@@ -176,6 +255,8 @@ module Funicular
 
       def render_component(component_vnode, parent)
         instance = component_vnode.component_class.new(component_vnode.props)
+        instance.runtime = component_vnode.runtime || @runtime || Funicular::Runtime.new
+        instance.children = component_vnode.children
         component_vnode.instance = instance
 
         is_error_boundary = instance.is_a?(Funicular::ErrorBoundary)

data/mrblib/view_context.rb

@@ -0,0 +1,135 @@
+module Funicular
+  class ViewContext
+    HTML_TAGS = %w[
+      div span p a data
+      h1 h2 h3 h4 h5 h6
+      ul ol li
+      table thead tbody tr th td
+      form input textarea button select option label
+      header footer nav section article aside
+      img video audio canvas
+      br hr
+    ]
+
+    def initialize(component)
+      @component = component
+    end
+
+    def state
+      @component.state
+    end
+
+    def props
+      @component.props
+    end
+
+    def resources
+      @component.resources
+    end
+
+    def styles
+      @component.styles
+    end
+
+    def routes
+      @component.runtime.routes
+    end
+
+    def tag(name, props = {}, &block)
+      build_element(name, props, &block)
+    end
+
+    HTML_TAGS.each do |tag_name|
+      define_method(tag_name) do |props = {}, &block|
+        tag(tag_name, props, &block) # steep:ignore
+      end
+    end
+
+    def component(component_class, props = {}, &block)
+      unless component_class.is_a?(Class) && component_class.ancestors.include?(Funicular::Component)
+        raise "h.component expects a Funicular::Component class"
+      end
+
+      children = if block
+        capture(&block)
+      else
+        [] #: Array[Funicular::VDOM::child_t]
+      end
+      vnode = VDOM::Component.new(component_class, props, children)
+      vnode.runtime = @component.runtime
+      add_child(vnode)
+      vnode
+    end
+
+    def form_for(model_key, options = {}, &block)
+      @component.build_form_for(self, model_key, options, &block)
+    end
+
+    def suspense(name, fallback:, error: nil, &block)
+      @component.render_suspense(self, name, fallback: fallback, error: error, &block)
+    end
+
+    def link_to(path, **options, &block)
+      @component.build_link_to(self, path, **options, &block)
+    end
+
+    def button_to(path, method: :post, **options, &block)
+      @component.build_button_to(self, path, method: method, **options, &block)
+    end
+
+    def capture(&block)
+      children = [] #: Array[Funicular::VDOM::child_t]
+      previous = @component.current_children
+      @component.current_children = children
+      result = block.call(self)
+      @component.current_children = previous
+
+      if result && !result.equal?(children) && children.empty?
+        if result.is_a?(Array)
+          result.each do |item|
+            if item.is_a?(String)
+              children << item
+            else
+              normalized = @component.normalize_vnode_for_view(item)
+              children << normalized if normalized
+            end
+          end
+        elsif result.is_a?(String)
+          children << result
+        else
+          normalized = @component.normalize_vnode_for_view(result)
+          children << normalized if normalized
+        end
+      end
+      children
+    ensure
+      @component.current_children = previous
+    end
+
+    def add_child(child)
+      @component.add_child_from_view(child)
+    end
+
+    private
+
+    def build_element(tag_name, props = {}, &block)
+      children = if block
+        capture(&block)
+      else
+        [] #: Array[Funicular::VDOM::child_t]
+      end
+      normalized_props = normalize_props(props || {})
+      element = VDOM::Element.new(tag_name.to_s, normalized_props, children)
+      add_child(element)
+      element
+    end
+
+    def normalize_props(props)
+      normalized = {} #: Hash[Symbol, untyped]
+      props.each do |key, value|
+        normalized[key] = key == :class && value.is_a?(StyleValue) ? value.to_s : value
+      end
+      normalized
+    end
+  end
+end

data/sig/component.rbs

@@ -3,65 +3,66 @@ module Funicular
     class StateAccessor
       def initialize: (Hash[Symbol, untyped] state_hash) -> void
       def []: (Symbol key) -> untyped
-      def method_missing: (Symbol method, *untyped args) -> untyped
-      def respond_to_missing?: (Symbol method, ?bool include_private) -> bool
-      def errors: () -> Hash[Symbol, String]
+      def fetch: (Symbol key, ?untyped default) -> untyped
+      def key?: (Symbol key) -> bool
+      def to_h: () -> Hash[Symbol, untyped]
     end
 
-    HTML_TAGS: Array[String]
+    class ResourceAccessor
+      def initialize: (Hash[Symbol, untyped] data, Hash[Symbol, Symbol] states, Hash[Symbol, untyped] errors) -> void
+      def []: (Symbol key) -> untyped
+      def fetch: (Symbol key, ?untyped default) -> untyped
+      def loading?: (Symbol key) -> bool
+      def error?: (Symbol key) -> bool
+      def error: (Symbol key) -> untyped
+    end
 
     attr_accessor props: Hash[Symbol, untyped]
     attr_accessor vdom: VDOM::VNode | VDOM::Text | nil
     attr_accessor dom_element: JS::Element
     attr_accessor mounted: bool
+    attr_accessor runtime: Runtime
+    attr_accessor children: Array[VDOM::child_t]
+    attr_accessor current_children: Array[VDOM::child_t]?
     attr_reader refs: Hash[Symbol, JS::Element]
-    @event_listeners: Array[Integer]
-    @child_components: Array[Component]
-    @suspense_data: Hash[Symbol, untyped]
-    @suspense_states: Hash[Symbol, Symbol]
-    @suspense_errors: Hash[Symbol, untyped]
-    @suspense_pending_timers: Array[Integer]
-    self.@suspense_definitions: Hash[Symbol, suspense_definition]
 
-    def initialize: (?Hash[Symbol, untyped] props) -> void
+    type suspense_definition = { loader: untyped, on_resolve: untyped, min_delay: Integer? }
 
-    # Styles DSL class methods
+    def initialize: (?Hash[Symbol, untyped] props) -> void
     def self.styles: () { (StyleBuilder) -> void } -> void
     def self.styles_definitions: () -> Hash[Symbol, Hash[Symbol, untyped]]
-
-    # Suspense DSL class methods
-    # Note: Using untyped for Proc types to avoid instance_exec block type mismatch warnings
-    type suspense_definition = { loader: untyped, on_resolve: untyped, min_delay: Integer? }
     def self.use_suspense: (Symbol name, untyped loader, ?on_resolve: untyped, ?min_delay: Integer) -> void
     def self.suspense_definitions: () -> Hash[Symbol, suspense_definition]
 
     def state: () -> StateAccessor
-
-    # Styles DSL instance method
-    def s: () -> StyleAccessor
-
-    # Public API
+    def resources: () -> ResourceAccessor
+    def styles: () -> StyleAccessor
     def initialize_state: () -> Hash[Symbol, untyped]
+    def seed_state: (Hash[untyped, untyped]? state_hash) -> self
 
-    # Suspense instance methods
     def load_suspense_data: () -> void
     def load_single_suspense: (Symbol name, ?suspense_definition? definition) -> void
     def reload_suspense: (Symbol name) -> void
     def suspense_loading?: (*Symbol names) -> bool
     def suspense_error?: (Symbol name) -> bool
     def suspense_error: (Symbol name) -> untyped
-    def suspense: (fallback: ^() -> void, ?error: ^(untyped) -> void) { () -> void } -> void
+    def render_suspense: (ViewContext h, Symbol name, fallback: untyped, ?error: untyped) { (ViewContext, ResourceAccessor) -> untyped } -> untyped
 
     def patch: (Hash[Symbol, untyped] new_state) -> void
     def mount: (JS::Element container) -> void
     def hydrate: (JS::Element dom_element) -> void
-    def seed_state: (Hash[untyped, untyped]? state_hash) -> self
     def unmount: () -> void
-    def render: () -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
-    def bind_events: (JS::Element dom_element, VDOM::VNode | VDOM::Text | nil vnode) -> void
+    def render: (ViewContext h) -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
     def build_vdom: () -> (VDOM::VNode | VDOM::Text | nil)
 
-    # Lifecycle hooks (public, can be overridden in subclasses)
+    def bind_events: (JS::Element dom_element, VDOM::VNode | VDOM::Text | nil vnode) -> void
+    def collect_refs: (JS::Element dom_element, VDOM::VNode | VDOM::Text | nil vnode, ?Hash[Symbol, JS::Element] refs_map) -> Hash[Symbol, JS::Element]
+    def normalize_vnode_for_view: (untyped value) -> (VDOM::Element | VDOM::Text | VDOM::Component | nil)
+    def add_child_from_view: (untyped child) -> void
+    def build_form_for: (ViewContext h, Symbol model_key, ?Hash[Symbol, untyped] options) { (FormBuilder) -> void } -> VDOM::Element
+    def build_link_to: (ViewContext h, String path, **untyped options) { (ViewContext) -> untyped } -> VDOM::Element
+    def build_button_to: (ViewContext h, String path, ?method: Symbol, **untyped options) { (ViewContext) -> untyped } -> VDOM::Element
+
     def component_will_mount: () -> void
     def component_mounted: () -> void
     def component_will_update: () -> void
@@ -70,22 +71,9 @@ module Funicular
     def component_unmounted: () -> void
     def component_raised: (Exception e) -> void
 
-    # Child component helper
-    def component: (Class component_class, ?Hash[Symbol, untyped] props) ?{ () -> untyped } -> VDOM::Component
-
-    # Rails-style form helper
-    def form_for: (Symbol model_key, ?Hash[Symbol, untyped] options) { (FormBuilder) -> void } -> VDOM::Element
-
-    # Rails-style routing helpers
-    def link_to: (String path, ?method: Symbol, ?navigate: bool, **untyped options) { -> untyped } -> VDOM::Element
-    def method_missing: (Symbol method, *untyped args) -> untyped
-    def respond_to_missing?: (Symbol method, ?bool include_private) -> bool
-
-    # Transition helpers
     def remove_via: (String element_id, String from, String to, ?duration: Integer) ?{ () -> void } -> void
     def add_via: (String element_id, String from, String to, ?duration: Integer) ?{ () -> void } -> void
 
-    # Private methods
     private def handle_link_click: (String path) -> void
     private def handle_link_with_method: (String path, Symbol method) -> void
     private def handle_link_response: (HTTP::Response response, String path, Symbol method) -> void
@@ -93,57 +81,18 @@ module Funicular
     private def re_render: () -> void
     private def normalize_vnode: (untyped value) -> (VDOM::Element | VDOM::Text | VDOM::Component | nil)
     private def add_data_component_attribute: (VDOM::VNode vnode) -> void
-    private def collect_refs: (JS::Element dom_element, VDOM::VNode | VDOM::Text | nil vnode, ?Hash[Symbol, JS::Element] refs_map) -> Hash[Symbol, JS::Element]
     private def cleanup_events: () -> void
     private def cleanup_suspense_timers: () -> void
-    private def add_child: (untyped child) -> void
     private def collect_child_components: (VDOM::VNode | VDOM::Text | nil vnode) -> void
     private def collect_child_components_recursive: (VDOM::VNode | VDOM::Text | nil vnode, Array[Component] components) -> void
-
-    # Hydration helpers
+    private def collect_form_data: (untyped event, Symbol model_key) -> Hash[Symbol, untyped]
+    private def collect_dom_form_data: (untyped event) -> Hash[Symbol, untyped]
+    private def collect_state_form_data: (Symbol model_key) -> Hash[Symbol, untyped]
+    private def event_target: (untyped event) -> untyped
+    private def add_form_field_value: (Hash[Symbol, untyped] data, untyped field) -> void
     private def hydration_match?: (untyped vnode, untyped dom_element) -> bool
     private def warn_hydration_mismatch: (untyped vnode, untyped dom_element) -> void
     private def full_render_fallback: (VDOM::VNode | VDOM::Text | nil new_vdom, untyped server_dom) -> JS::Element
     private def hydrate_child_components: (untyped vnode, untyped dom_element) -> void
-
-    # HTML element methods (DSL)
-    def div: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def span: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def p: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def a: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def h1: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def h2: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def h3: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def h4: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def h5: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def h6: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def ul: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def ol: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def li: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def table: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def thead: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def tbody: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def tr: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def th: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def td: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def form: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def input: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def textarea: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def button: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def select: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def option: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def label: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def header: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def footer: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def nav: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def section: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def article: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def aside: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def img: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def video: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def audio: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def canvas: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def br: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
-    def hr: (?Hash[Symbol, untyped] props) ?{ -> untyped } -> VDOM::Element
   end
 end

data/sig/error_boundary.rbs

@@ -5,10 +5,10 @@ module Funicular
     def initialize_state: () -> Hash[Symbol, untyped]
     def catch_error: (Exception error, ?Hash[Symbol, untyped]? error_info) -> bool
     def reset: () -> void
-    def render: () -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
+    def render: (ViewContext h) -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
 
-    private def render_fallback: () -> (VDOM::VNode | String)
-    private def default_fallback: () -> VDOM::VNode
-    private def render_children: () -> VDOM::VNode
+    private def render_fallback: (ViewContext h) -> (VDOM::VNode | String)
+    private def default_fallback: (ViewContext h) -> VDOM::VNode
+    private def render_children: (ViewContext h) -> VDOM::VNode
   end
 end

data/sig/form_builder.rbs

@@ -1,10 +1,11 @@
 module Funicular
   class FormBuilder
     attr_reader component: Component
+    attr_reader view_context: ViewContext
     attr_reader model_key: Symbol
     attr_reader options: Hash[Symbol, untyped]
 
-    def initialize: (Component component, Symbol model_key, ?Hash[Symbol, untyped] options) -> void
+    def initialize: (Component component, ViewContext view_context, Symbol model_key, ?Hash[Symbol, untyped] options) -> void
 
     # Field builder methods
     def text_field: (Symbol field_name, ?Hash[Symbol, untyped] options) -> VDOM::Element

data/sig/html_serializer.rbs

@@ -4,7 +4,8 @@ module Funicular
       VOID_ELEMENTS: Array[String]
       SKIP_PROPS: Array[Symbol]
 
-      def self.serialize: (VNode? vnode) -> String
+      def self.serialize: (VNode? vnode, ?Runtime? runtime) -> String
+      def initialize: (?Runtime? runtime) -> void
       def render: (VNode? vnode) -> String
 
       private

data/sig/http.rbs

@@ -32,6 +32,7 @@ module Funicular
     private def self.now_seconds: () -> Integer
     private def self.cache_hit?: (untyped entry, Integer ttl) -> bool
     private def self.serve_from_cache: (Hash[String, untyped] entry) { (Response) -> void } -> void
+    private def self.parse_response_body: (untyped text) -> untyped
     private def self.request: (String method, String url, Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
   end
 end

data/sig/patcher.rbs

@@ -3,7 +3,7 @@ module Funicular
     BOOLEAN_ATTRIBUTES: Array[String]
 
     class Patcher
-      def initialize: (?JS::Element? doc) -> void
+      def initialize: (?JS::Element? doc, ?Runtime? runtime) -> void
       # `apply` accepts any DOM node so text-node patches (e.g. :replace)
       # can recurse into it; Element-only operations are narrowed inside.
       def apply: (JS::Object element, Array[patch_t] patches) -> JS::Object

data/sig/router.rbs

@@ -2,22 +2,12 @@ module Funicular
   type route_constraints_t = Hash[Symbol, Regexp]
   type route_definition_t = { method: Symbol, path: String, component: singleton(Component), name: String?, pattern_segments: Array[String], constraints: route_constraints_t }
 
-  # URL helper methods are dynamically generated based on route definitions
-  # Example: router.get('/users/:id', to: UserComponent, as: 'user')
-  # generates: user_path(id) -> String
-  module RouteHelpers
-    # Dynamic methods are generated at runtime by Router#generate_url_helper
-    # Method signatures depend on route parameters:
-    # - No parameters: def helper_name_path: () -> String
-    # - With parameters: def helper_name_path: (Integer | String | untyped) -> String
-    def method_missing: (Symbol method, *untyped args) -> String
-    def respond_to_missing?: (Symbol method, ?bool include_private) -> bool
-  end
-
   class Router
     attr_reader routes: Array[route_definition_t]
     attr_reader current_component: Component?
     attr_reader current_path: String?
+    attr_reader url_helpers: Module
+    attr_reader route_helpers: untyped
 
     def initialize: (JS::Element? container) -> void
     def get: (String path, to: singleton(Component), ?as: String?, ?constraints: route_constraints_t?) -> void
@@ -31,7 +21,6 @@ module Funicular
     def start: (?hydrate: bool) -> void
     def stop: () -> void
     def navigate: (String path) -> void
-    def current_hash_path: () -> String
     def current_location_path: () -> String
 
     private def add_route_with_method: (Symbol method, String path, singleton(Component) component_class, String? name, ?route_constraints_t? constraints) -> void

data/sig/runtime.rbs

@@ -0,0 +1,13 @@
+module Funicular
+  class Runtime
+    attr_accessor router: Router?
+
+    def initialize: (?Router? router) -> void
+    def routes: () -> untyped
+  end
+
+  module EmptyRoutes
+    def self.method_missing: (Symbol name, *untyped args) -> untyped
+    def self.respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+  end
+end

data/sig/styles.rbs

@@ -7,11 +7,10 @@ module Funicular
     def to_s: () -> String
   end
 
-  # StyleAccessor provides access to defined styles via method calls
+  # StyleAccessor provides explicit access to defined styles.
   class StyleAccessor
     def initialize: (Hash[Symbol, Hash[Symbol, untyped]] definitions) -> void
-    private def method_missing: (Symbol name, *untyped args) -> StyleValue
-    private def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+    def []: (Symbol name, ?(Symbol | bool) variant) -> StyleValue
   end
 
   # StyleBuilder is used to define styles within the styles {} block
@@ -19,7 +18,7 @@ module Funicular
     @definitions: Hash[Symbol, Hash[Symbol, untyped]]
 
     def initialize: () -> void
+    def define: (Symbol name, ?(String | Hash[Symbol, untyped]) value, **untyped options) -> void
     def to_definitions: () -> Hash[Symbol, Hash[Symbol, untyped]]
-    private def method_missing: (Symbol name, *untyped args) -> void
   end
 end

data/sig/vdom.rbs

@@ -4,6 +4,13 @@ module Funicular
     type child_t = Element | Text | Component | String | Array[Element | Text | Component | String]
 
     URL_ATTRIBUTES: Array[String]
+    SCRIPTING_ELEMENTS: Array[String]
+
+    def self.valid_tag_name?: (untyped name) -> bool
+    def self.valid_attribute_name?: (untyped name) -> bool
+    def self.event_attribute?: (untyped name) -> bool
+    def self.unsafe_url?: (untyped name, untyped value) -> bool
+    def self.blocked_attribute?: (untyped name, untyped value) -> bool
 
     class VNode
       attr_reader type: Symbol
@@ -32,7 +39,7 @@ module Funicular
     class Renderer
       @error_boundary_stack: Array[Funicular::ErrorBoundary]
 
-      def initialize: (?JS::Element? doc) -> void
+      def initialize: (?JS::Element? doc, ?Runtime? runtime) -> void
       def render: (VDOM::VNode | VDOM::Text | nil vnode, ?JS::Element? parent) -> JS::Element
 
       private def current_error_boundary: () -> ErrorBoundary?
@@ -50,9 +57,11 @@ module Funicular
     class Component < VNode
       attr_reader component_class: untyped
       attr_reader props: Hash[Symbol, untyped]
+      attr_reader children: Array[child_t]
       attr_accessor instance: untyped
+      attr_accessor runtime: Runtime?
 
-      def initialize: (untyped component_class, ?Hash[Symbol, untyped] props) -> void
+      def initialize: (untyped component_class, ?Hash[Symbol, untyped] props, ?Array[child_t] children) -> void
       def ==: (untyped other) -> bool
     end
   end