kumi 0.0.5 → 0.0.7

data/lib/kumi/analyzer/passes/dependency_resolver.rb

@@ -3,18 +3,29 @@
 module Kumi
   module Analyzer
     module Passes
-      # RESPONSIBILITY: Build dependency graph and leaf map, validate references
-      # DEPENDENCIES: :definitions, :input_meta
-      # PRODUCES: :dependency_graph - Hash of name → [DependencyEdge], :leaf_map - Hash of name → Set[nodes]
+      # RESPONSIBILITY: Build dependency graph and detect conditional dependencies in cascades
+      # DEPENDENCIES: :declarations from NameIndexer, :inputs from InputCollector
+      # PRODUCES: :dependencies, :dependents, :leaves - Dependency analysis results
       # INTERFACE: new(schema, state).run(errors)
       class DependencyResolver < PassBase
-        # A Struct to hold rich dependency information
-        DependencyEdge = Struct.new(:to, :type, :via, keyword_init: true)
+        # Enhanced edge with conditional flag and cascade metadata
+        class DependencyEdge
+          attr_reader :to, :type, :via, :conditional, :cascade_owner
+
+          def initialize(to:, type:, via:, conditional: false, cascade_owner: nil)
+            @to = to
+            @type = type
+            @via = via
+            @conditional = conditional
+            @cascade_owner = cascade_owner
+          end
+        end
+
         include Syntax
 
         def run(errors)
-          definitions = get_state(:definitions)
-          input_meta = get_state(:input_meta)
+          definitions = get_state(:declarations)
+          input_meta = get_state(:inputs)
 
           dependency_graph = Hash.new { |h, k| h[k] = [] }
           reverse_dependencies = Hash.new { |h, k| h[k] = [] }
@@ -22,7 +33,7 @@ module Kumi
 
           each_decl do |decl|
             # Traverse the expression for each declaration, passing context down
-            visit_with_context(decl.expression) do |node, context|
+            visit_with_context(decl.expression, { decl_name: decl.name }) do |node, context|
               process_node(node, decl, dependency_graph, reverse_dependencies, leaf_map, definitions, input_meta, errors, context)
             end
           end
@@ -30,38 +41,83 @@ module Kumi
           # Compute transitive closure of reverse dependencies
           transitive_dependents = compute_transitive_closure(reverse_dependencies)
 
-          state.with(:dependency_graph, dependency_graph.transform_values(&:freeze).freeze)
-               .with(:transitive_dependents, transitive_dependents.freeze)
-               .with(:leaf_map, leaf_map.transform_values(&:freeze).freeze)
+          state.with(:dependencies, dependency_graph.transform_values(&:freeze).freeze)
+               .with(:dependents, transitive_dependents.freeze)
+               .with(:leaves, leaf_map.transform_values(&:freeze).freeze)
         end
 
         private
 
-        def process_node(node, decl, graph, reverse_deps, leaves, definitions, input_meta, errors, context)
+        def process_node(node, decl, graph, reverse_deps, leaves, definitions, _input_meta, errors, context)
           case node
-          when Binding
+          when DeclarationReference
             report_error(errors, "undefined reference to `#{node.name}`", location: node.loc) unless definitions.key?(node.name)
-            add_dependency_edge(graph, reverse_deps, decl.name, node.name, :ref, context[:via])
-          when FieldRef
-            report_error(errors, "undeclared input `#{node.name}`", location: node.loc) unless input_meta.key?(node.name)
+
+            # Determine if this is a conditional dependency
+            conditional = context[:in_cascade_branch] || context[:in_cascade_base] || false
+            cascade_owner = conditional ? (context[:cascade_owner] || context[:decl_name]) : nil
+
+            add_dependency_edge(graph, reverse_deps, decl.name, node.name, :ref, context[:via],
+                                conditional: conditional,
+                                cascade_owner: cascade_owner)
+          when InputReference
             add_dependency_edge(graph, reverse_deps, decl.name, node.name, :key, context[:via])
-            leaves[decl.name] << node # put it back
+            leaves[decl.name] << node
+          when InputElementReference
+            # adds the root input declaration as a dependency
+            root_input_declr_name = node.path.first
+            add_dependency_edge(graph, reverse_deps, decl.name, root_input_declr_name, :key, context[:via])
           when Literal
             leaves[decl.name] << node
           end
         end
 
-        def add_dependency_edge(graph, reverse_deps, from, to, type, via)
-          edge = DependencyEdge.new(to: to, type: type, via: via)
+        def add_dependency_edge(graph, reverse_deps, from, to, type, via, conditional: false, cascade_owner: nil)
+          edge = DependencyEdge.new(
+            to: to,
+            type: type,
+            via: via,
+            conditional: conditional,
+            cascade_owner: cascade_owner
+          )
           graph[from] << edge
           reverse_deps[to] << from
         end
 
-        # Compute transitive closure: for each key, find ALL declarations that depend on it
+        # Custom visitor that understands cascade structure
+        def visit_with_context(node, context = {}, &block)
+          return unless node
+
+          yield(node, context)
+
+          case node
+          when CascadeExpression
+            # Visit condition nodes and result expressions (non-base cases)
+            node.cases[0...-1].each do |when_case|
+              if when_case.condition
+                # Visit condition normally
+                visit_with_context(when_case.condition, context, &block)
+              end
+              # Visit result expressions as conditional dependencies
+              conditional_context = context.merge(in_cascade_branch: true, cascade_owner: context[:decl_name])
+              visit_with_context(when_case.result, conditional_context, &block)
+            end
+
+            # Visit base case with conditional flag
+            if node.cases.last
+              base_context = context.merge(in_cascade_base: true)
+              visit_with_context(node.cases.last.result, base_context, &block)
+            end
+          when CallExpression
+            new_context = context.merge(via: node.fn_name)
+            node.children.each { |child| visit_with_context(child, new_context, &block) }
+          else
+            node.children.each { |child| visit_with_context(child, context, &block) } if node.respond_to?(:children)
+          end
+        end
+
         def compute_transitive_closure(reverse_dependencies)
           transitive = {}
-
-          # Collect all keys first to avoid iteration issues
           all_keys = reverse_dependencies.keys
 
           all_keys.each do |key|
@@ -75,7 +131,6 @@ module Kumi
 
               visited.add(current)
 
-              # Get direct dependents
               direct_dependents = reverse_dependencies[current] || []
               direct_dependents.each do |dependent|
                 next if visited.include?(dependent)
@@ -90,21 +145,6 @@ module Kumi
 
           transitive
         end
-
-        # Custom visitor that passes context (like function name) down the tree
-        def visit_with_context(node, context = {}, &block)
-          return unless node
-
-          yield(node, context)
-
-          new_context = if node.is_a?(Expressions::CallExpression)
-                          { via: node.fn_name }
-                        else
-                          context
-                        end
-
-          node.children.each { |child| visit_with_context(child, new_context, &block) }
-        end
       end
     end
   end

data/lib/kumi/analyzer/passes/input_collector.rb

@@ -5,17 +5,15 @@ module Kumi
     module Passes
       # RESPONSIBILITY: Collect field metadata from input declarations and validate consistency
       # DEPENDENCIES: :definitions
-      # PRODUCES: :input_meta - Hash mapping field names to {type:, domain:} metadata
+      # PRODUCES: :inputs - Hash mapping field names to {type:, domain:} metadata
       # INTERFACE: new(schema, state).run(errors)
       class InputCollector < PassBase
-        include Syntax::TerminalExpressions
-
         def run(errors)
           input_meta = {}
 
           schema.inputs.each do |field_decl|
-            unless field_decl.is_a?(FieldDecl)
-              report_error(errors, "Expected FieldDecl node, got #{field_decl.class}", location: field_decl.loc)
+            unless field_decl.is_a?(Kumi::Syntax::InputDeclaration)
+              report_error(errors, "Expected InputDeclaration node, got #{field_decl.class}", location: field_decl.loc)
               next
             end
 
@@ -23,40 +21,103 @@ module Kumi
             existing = input_meta[name]
 
             if existing
-              # Check for compatibility
-              if existing[:type] != field_decl.type && field_decl.type && existing[:type]
-                report_error(errors,
-                             "Field :#{name} declared with conflicting types: #{existing[:type]} vs #{field_decl.type}",
-                             location: field_decl.loc)
-              end
+              # Check for compatibility and merge
+              merged_meta = merge_field_metadata(existing, field_decl, errors)
+              input_meta[name] = merged_meta if merged_meta
+            else
+              # New field - collect its metadata
+              input_meta[name] = collect_field_metadata(field_decl, errors)
+            end
+          end
+
+          state.with(:inputs, freeze_nested_hash(input_meta))
+        end
 
-              if existing[:domain] != field_decl.domain && field_decl.domain && existing[:domain]
-                report_error(errors,
-                             "Field :#{name} declared with conflicting domains: #{existing[:domain].inspect} vs #{field_decl.domain.inspect}",
-                             location: field_decl.loc)
+        private
+
+        def collect_field_metadata(field_decl, errors)
+          validate_domain_type(field_decl, errors) if field_decl.domain
+
+          metadata = {
+            type: field_decl.type,
+            domain: field_decl.domain
+          }
+
+          # Process children if present
+          if field_decl.children && !field_decl.children.empty?
+            children_meta = {}
+            field_decl.children.each do |child_decl|
+              unless child_decl.is_a?(Kumi::Syntax::InputDeclaration)
+                report_error(errors, "Expected InputDeclaration node in children, got #{child_decl.class}", location: child_decl.loc)
+                next
               end
+              children_meta[child_decl.name] = collect_field_metadata(child_decl, errors)
+            end
+            metadata[:children] = children_meta
+          end
 
-              # Validate domain type if provided
-              validate_domain_type(field_decl, errors) if field_decl.domain
+          metadata
+        end
 
-              # Merge metadata (later declarations override nil values)
-              input_meta[name] = {
-                type: field_decl.type || existing[:type],
-                domain: field_decl.domain || existing[:domain]
-              }
-            else
-              validate_domain_type(field_decl, errors) if field_decl.domain
-              input_meta[name] = {
-                type: field_decl.type,
-                domain: field_decl.domain
-              }
+        def merge_field_metadata(existing, field_decl, errors)
+          name = field_decl.name
+
+          # Check for type compatibility
+          if existing[:type] != field_decl.type && field_decl.type && existing[:type]
+            report_error(errors,
+                         "Field :#{name} declared with conflicting types: #{existing[:type]} vs #{field_decl.type}",
+                         location: field_decl.loc)
+          end
+
+          # Check for domain compatibility
+          if existing[:domain] != field_decl.domain && field_decl.domain && existing[:domain]
+            report_error(errors,
+                         "Field :#{name} declared with conflicting domains: #{existing[:domain].inspect} vs #{field_decl.domain.inspect}",
+                         location: field_decl.loc)
+          end
+
+          # Validate domain type if provided
+          validate_domain_type(field_decl, errors) if field_decl.domain
+
+          # Merge metadata (later declarations override nil values)
+          merged = {
+            type: field_decl.type || existing[:type],
+            domain: field_decl.domain || existing[:domain]
+          }
+
+          # Merge children if present
+          if field_decl.children && !field_decl.children.empty?
+            existing_children = existing[:children] || {}
+            new_children = {}
+
+            field_decl.children.each do |child_decl|
+              unless child_decl.is_a?(Kumi::Syntax::InputDeclaration)
+                report_error(errors, "Expected InputDeclaration node in children, got #{child_decl.class}", location: child_decl.loc)
+                next
+              end
+
+              child_name = child_decl.name
+              new_children[child_name] = if existing_children[child_name]
+                                           merge_field_metadata(existing_children[child_name], child_decl, errors)
+                                         else
+                                           collect_field_metadata(child_decl, errors)
+                                         end
             end
+
+            merged[:children] = new_children
+          elsif existing[:children]
+            merged[:children] = existing[:children]
           end
 
-          state.with(:input_meta, input_meta.freeze)
+          merged
         end
 
-        private
+        def freeze_nested_hash(hash)
+          hash.each_value do |value|
+            freeze_nested_hash(value) if value.is_a?(Hash)
+          end
+          hash.freeze
+        end
 
         def validate_domain_type(field_decl, errors)
           domain = field_decl.domain

data/lib/kumi/analyzer/passes/name_indexer.rb

@@ -5,7 +5,7 @@ module Kumi
     module Passes
       # RESPONSIBILITY: Build definitions index and detect duplicate names
       # DEPENDENCIES: None (first pass in pipeline)
-      # PRODUCES: :definitions - Hash mapping names to declaration nodes
+      # PRODUCES: :declarations - Hash mapping names to declaration nodes
       # INTERFACE: new(schema, state).run(errors)
       class NameIndexer < PassBase
         def run(errors)
@@ -16,7 +16,7 @@ module Kumi
             definitions[decl.name] = decl
           end
 
-          state.with(:definitions, definitions.freeze)
+          state.with(:declarations, definitions.freeze)
         end
       end
     end

data/lib/kumi/analyzer/passes/pass_base.rb

@@ -27,7 +27,7 @@ module Kumi
         attr_reader :schema, :state
 
         # Iterate over all declarations (attributes and traits) in the schema
-        # @yield [Syntax::Declarations::Attribute|Syntax::Declarations::Trait] Each declaration
+        # @yield [Syntax::Attribute|Syntax::Trait] Each declaration
         def each_decl(&block)
           schema.attributes.each(&block)
           schema.traits.each(&block)

data/lib/kumi/analyzer/passes/semantic_constraint_validator.rb

@@ -10,7 +10,7 @@ module Kumi
       #
       # This pass enforces semantic constraints that must hold regardless of which parser
       # was used to construct the AST. It validates:
-      # 1. Cascade conditions are only trait references (Binding nodes)
+      # 1. Cascade conditions are only trait references (DeclarationReference nodes)
       # 2. Trait expressions evaluate to boolean values (CallExpression nodes)
       # 3. Function names exist in the function registry
       # 4. Expression types are valid for their context
@@ -24,19 +24,19 @@ module Kumi
 
         private
 
-        def validate_semantic_constraints(node, decl, errors)
+        def validate_semantic_constraints(node, _decl, errors)
           case node
-          when Declarations::Trait
+          when Kumi::Syntax::TraitDeclaration
             validate_trait_expression(node, errors)
-          when Expressions::WhenCaseExpression
+          when Kumi::Syntax::CaseExpression
             validate_cascade_condition(node, errors)
-          when Expressions::CallExpression
+          when Kumi::Syntax::CallExpression
             validate_function_call(node, errors)
           end
         end
 
         def validate_trait_expression(trait, errors)
-          return if trait.expression.is_a?(Expressions::CallExpression)
+          return if trait.expression.is_a?(Kumi::Syntax::CallExpression)
 
           report_error(
             errors,
@@ -48,22 +48,22 @@ module Kumi
 
         def validate_cascade_condition(when_case, errors)
           condition = when_case.condition
-          
+
           case condition
-          when TerminalExpressions::Binding
+          when Kumi::Syntax::DeclarationReference
             # Valid: trait reference
-            return
-          when Expressions::CallExpression
+            nil
+          when Kumi::Syntax::CallExpression
             # Valid if it's a boolean composition of traits (all?, any?, none?)
             return if boolean_trait_composition?(condition)
-            
+
             # For now, allow other CallExpressions - they'll be validated by other passes
-            return
-          when TerminalExpressions::Literal
+            nil
+          when Kumi::Syntax::Literal
             # Allow literal conditions (like true/false) - they might be valid
-            return
+            nil
           else
-            # Only reject truly invalid conditions like FieldRef or complex expressions
+            # Only reject truly invalid conditions like InputReference or complex expressions
             report_error(
               errors,
               "cascade condition must be trait reference",
@@ -75,10 +75,10 @@ module Kumi
 
         def validate_function_call(call_expr, errors)
           fn_name = call_expr.fn_name
-          
+
           # Skip validation if FunctionRegistry is being mocked for testing
           return if function_registry_mocked?
-          
+
           return if FunctionRegistry.supported?(fn_name)
 
           report_error(
@@ -96,15 +96,14 @@ module Kumi
 
         def function_registry_mocked?
           # Check if FunctionRegistry is being mocked (for tests)
-          begin
-            # Try to access a method that doesn't exist in the real registry
-            # If it's mocked, this won't raise an error
-            FunctionRegistry.respond_to?(:confirm_support!)
-          rescue
-            false
-          end
+
+          # Try to access a method that doesn't exist in the real registry
+          # If it's mocked, this won't raise an error
+          FunctionRegistry.respond_to?(:confirm_support!)
+        rescue StandardError
+          false
         end
       end
     end
   end
-end
+end

data/lib/kumi/analyzer/passes/toposorter.rb

@@ -3,17 +3,17 @@
 module Kumi
   module Analyzer
     module Passes
-      # RESPONSIBILITY: Compute topological ordering of declarations from dependency graph
-      # DEPENDENCIES: :dependency_graph from DependencyResolver, :definitions from NameIndexer
-      # PRODUCES: :topo_order - Array of declaration names in evaluation order
+      # RESPONSIBILITY: Compute topological ordering of declarations, allowing safe conditional cycles
+      # DEPENDENCIES: :dependencies from DependencyResolver, :declarations from NameIndexer, :cascades from UnsatDetector
+      # PRODUCES: :evaluation_order - Array of declaration names in evaluation order
       # INTERFACE: new(schema, state).run(errors)
       class Toposorter < PassBase
         def run(errors)
-          dependency_graph = get_state(:dependency_graph, required: false) || {}
-          definitions = get_state(:definitions, required: false) || {}
+          dependency_graph = get_state(:dependencies, required: false) || {}
+          definitions = get_state(:declarations, required: false) || {}
 
           order = compute_topological_order(dependency_graph, definitions, errors)
-          state.with(:topo_order, order)
+          state.with(:evaluation_order, order)
         end
 
         private
@@ -22,17 +22,26 @@ module Kumi
           temp_marks = Set.new
           perm_marks = Set.new
           order = []
+          cascades = get_state(:cascades) || {}
 
-          visit_node = lambda do |node|
+          visit_node = lambda do |node, path = []|
             return if perm_marks.include?(node)
 
             if temp_marks.include?(node)
+              # Check if this is a safe conditional cycle
+              cycle_path = path + [node]
+              return if safe_conditional_cycle?(cycle_path, graph, cascades)
+
+              # Allow this cycle - it's safe due to cascade mutual exclusion
+
               report_unexpected_cycle(temp_marks, node, errors)
+
               return
             end
 
             temp_marks << node
-            Array(graph[node]).each { |edge| visit_node.call(edge.to) }
+            current_path = path + [node]
+            Array(graph[node]).each { |edge| visit_node.call(edge.to, current_path) }
             temp_marks.delete(node)
             perm_marks << node
 
@@ -50,6 +59,33 @@ module Kumi
           order.freeze
         end
 
+        def safe_conditional_cycle?(cycle_path, graph, cascades)
+          return false if cycle_path.nil? || cycle_path.size < 2
+
+          # Find where the cycle starts - look for the first occurrence of the repeated node
+          last_node = cycle_path.last
+          return false if last_node.nil?
+
+          cycle_start = cycle_path.index(last_node)
+          return false unless cycle_start && cycle_start < cycle_path.size - 1
+
+          cycle_nodes = cycle_path[cycle_start..]
+
+          # Check if all edges in the cycle are conditional
+          cycle_nodes.each_cons(2) do |from, to|
+            edges = graph[from] || []
+            edge = edges.find { |e| e.to == to }
+
+            return false unless edge&.conditional
+
+            # Check if the cascade has mutually exclusive conditions
+            cascade_meta = cascades[edge.cascade_owner]
+            return false unless cascade_meta&.dig(:all_mutually_exclusive)
+          end
+
+          true
+        end
+
         def report_unexpected_cycle(temp_marks, current_node, errors)
           cycle_path = temp_marks.to_a.join(" → ") + " → #{current_node}"
 

data/lib/kumi/analyzer/passes/type_checker.rb

@@ -4,12 +4,12 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Validate function call arity and argument types against FunctionRegistry
-      # DEPENDENCIES: :decl_types from TypeInferencer
+      # DEPENDENCIES: :inferred_types from TypeInferencer
       # PRODUCES: None (validation only)
       # INTERFACE: new(schema, state).run(errors)
       class TypeChecker < VisitorPass
         def run(errors)
-          visit_nodes_of_type(Expressions::CallExpression, errors: errors) do |node, _decl, errs|
+          visit_nodes_of_type(Kumi::Syntax::CallExpression, errors: errors) do |node, _decl, errs|
             validate_function_call(node, errs)
           end
           state
@@ -47,11 +47,31 @@ module Kumi
           types = signature[:param_types]
           return if types.nil? || (signature[:arity].negative? && node.args.empty?)
 
+          # Skip type checking for vectorized operations
+          broadcast_meta = get_state(:broadcasts, required: false)
+          return if broadcast_meta && is_part_of_vectorized_operation?(node, broadcast_meta)
+
           node.args.each_with_index do |arg, i|
             validate_argument_type(arg, i, types[i], node.fn_name, errors)
           end
         end
 
+        def is_part_of_vectorized_operation?(node, broadcast_meta)
+          # Check if this node is part of a vectorized or reduction operation
+          # This is a simplified check - in a real implementation we'd need to track context
+          node.args.any? do |arg|
+            case arg
+            when Kumi::Syntax::DeclarationReference
+              broadcast_meta[:vectorized_operations]&.key?(arg.name) ||
+                broadcast_meta[:reduction_operations]&.key?(arg.name)
+            when Kumi::Syntax::InputElementReference
+              broadcast_meta[:array_fields]&.key?(arg.path.first)
+            else
+              false
+            end
+          end
+        end
+
         def validate_argument_type(arg, index, expected_type, fn_name, errors)
           return if expected_type.nil? || expected_type == Kumi::Types::ANY
 
@@ -67,15 +87,15 @@ module Kumi
 
         def get_expression_type(expr)
           case expr
-          when TerminalExpressions::Literal
+          when Kumi::Syntax::Literal
             # Inferred type from literal value
             Kumi::Types.infer_from_value(expr.value)
 
-          when TerminalExpressions::FieldRef
+          when Kumi::Syntax::InputReference
             # Declared type from input block (user-specified)
             get_declared_field_type(expr.name)
 
-          when TerminalExpressions::Binding
+          when Kumi::Syntax::DeclarationReference
             # Inferred type from type inference results
             get_inferred_declaration_type(expr.name)
 
@@ -88,24 +108,24 @@ module Kumi
 
         def get_declared_field_type(field_name)
           # Get explicitly declared type from input metadata
-          input_meta = get_state(:input_meta, required: false) || {}
+          input_meta = get_state(:inputs, required: false) || {}
           field_meta = input_meta[field_name]
           field_meta&.dig(:type) || Kumi::Types::ANY
         end
 
         def get_inferred_declaration_type(decl_name)
           # Get inferred type from type inference results
-          decl_types = get_state(:decl_types, required: true)
+          decl_types = get_state(:inferred_types, required: true)
           decl_types[decl_name] || Kumi::Types::ANY
         end
 
         def describe_expression_type(expr, type)
           case expr
-          when TerminalExpressions::Literal
+          when Kumi::Syntax::Literal
             "`#{expr.value}` of type #{type} (literal value)"
 
-          when TerminalExpressions::FieldRef
-            input_meta = get_state(:input_meta, required: false) || {}
+          when Kumi::Syntax::InputReference
+            input_meta = get_state(:inputs, required: false) || {}
             field_meta = input_meta[expr.name]
 
             if field_meta&.dig(:type)
@@ -117,17 +137,17 @@ module Kumi
               "undeclared input field `#{expr.name}` (inferred as #{type})"
             end
 
-          when TerminalExpressions::Binding
+          when Kumi::Syntax::DeclarationReference
             # This type was inferred from the declaration's expression
             "reference to declaration `#{expr.name}` of inferred type #{type}"
 
-          when Expressions::CallExpression
+          when Kumi::Syntax::CallExpression
             "result of function `#{expr.fn_name}` returning #{type}"
 
-          when Expressions::ListExpression
+          when Kumi::Syntax::ArrayExpression
             "list expression of type #{type}"
 
-          when Expressions::CascadeExpression
+          when Kumi::Syntax::CascadeExpression
             "cascade expression of type #{type}"
 
           else

data/lib/kumi/analyzer/passes/type_consistency_checker.rb

@@ -4,12 +4,12 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Validate consistency between declared and inferred types
-      # DEPENDENCIES: :input_meta from InputCollector, :decl_types from TypeInferencer
+      # DEPENDENCIES: :inputs from InputCollector, :inferred_types from TypeInferencer
       # PRODUCES: None (validation only)
       # INTERFACE: new(schema, state).run(errors)
       class TypeConsistencyChecker < PassBase
         def run(errors)
-          input_meta = get_state(:input_meta, required: false) || {}
+          input_meta = get_state(:inputs, required: false) || {}
 
           # First, validate that all declared types are valid
           validate_declared_types(input_meta, errors)