kumi 0.0.9 → 0.0.10

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

@@ -41,7 +41,8 @@ module Kumi
 
             metadata = {
               type: field_decl.type,
-              domain: field_decl.domain
+              domain: field_decl.domain,
+              access_mode: field_decl.access_mode
             }
 
             # Process children if present
@@ -83,7 +84,8 @@ module Kumi
             # Merge metadata (later declarations override nil values)
             merged = {
               type: field_decl.type || existing[:type],
-              domain: field_decl.domain || existing[:domain]
+              domain: field_decl.domain || existing[:domain],
+              access_mode: field_decl.access_mode || existing[:access_mode]
             }
 
             # Merge children if present

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

@@ -17,9 +17,15 @@ module Kumi
         # 4. Expression types are valid for their context
         class SemanticConstraintValidator < VisitorPass
           def run(errors)
+            # Visit value and trait declarations
             each_decl do |decl|
               visit(decl) { |node| validate_semantic_constraints(node, decl, errors) }
             end
+
+            # Visit input declarations
+            schema.inputs.each do |input_decl|
+              visit(input_decl) { |node| validate_semantic_constraints(node, input_decl, errors) }
+            end
             state
           end
 
@@ -33,6 +39,8 @@ module Kumi
               validate_cascade_condition(node, errors)
             when Kumi::Syntax::CallExpression
               validate_function_call(node, errors)
+            when Kumi::Syntax::InputDeclaration
+              validate_input_declaration(node, errors)
             end
           end
 
@@ -90,6 +98,25 @@ module Kumi
             )
           end
 
+          def validate_input_declaration(input_decl, errors)
+            return unless input_decl.type == :array && input_decl.children.any?
+
+            # Validate that access_mode is consistent with children structure
+            if input_decl.access_mode == :element
+              # Element mode arrays can only have exactly one direct child
+              if input_decl.children.size > 1
+                error_msg = "array with access_mode :element can only have one direct child element, " \
+                            "but found #{input_decl.children.size} children"
+                report_error(errors, error_msg, location: input_decl.loc, type: :semantic)
+              end
+            elsif input_decl.access_mode == :object
+              # Object mode allows multiple children
+            end
+
+            # Recursively validate children
+            input_decl.children.each { |child| validate_input_declaration(child, errors) }
+          end
+
           def boolean_trait_composition?(call_expr)
             # Allow boolean composition functions that operate on trait collections
             %i[all? any? none?].include?(call_expr.fn_name)

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

@@ -6,14 +6,18 @@ module Kumi
       module Passes
         # RESPONSIBILITY: Validate function call arity and argument types against FunctionRegistry
         # DEPENDENCIES: :inferred_types from TypeInferencer
-        # PRODUCES: None (validation only)
+        # PRODUCES: :functions_required - Set of function names used in the schema
         # INTERFACE: new(schema, state).run(errors)
         class TypeChecker < VisitorPass
           def run(errors)
+            functions_required = Set.new
+
             visit_nodes_of_type(Kumi::Syntax::CallExpression, errors: errors) do |node, _decl, errs|
               validate_function_call(node, errs)
+              functions_required.add(node.fn_name)
             end
-            state
+
+            state.with(:functions_required, functions_required)
           end
 
           private

data/lib/kumi/core/analyzer/passes/unsat_detector.rb

@@ -40,12 +40,31 @@ module Kumi
                 atoms = gather_atoms(decl.expression, definitions, Set.new)
                 next if atoms.empty?
 
+                # DEBUG: Add detailed logging for hierarchical broadcasting debugging
+                if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                  puts "DEBUG UNSAT: Checking declaration '#{decl.name}' at #{decl.loc}"
+                  puts "  Expression: #{decl.expression.inspect}"
+                  puts "  Gathered atoms: #{atoms.map(&:inspect)}"
+                  puts "  Input meta: #{@input_meta.keys.inspect}" if @input_meta
+                end
+
                 # Use enhanced solver that can detect cross-variable mathematical constraints
-                impossible = if definitions && !definitions.empty?
-                               Kumi::Core::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
-                             else
-                               Kumi::Core::AtomUnsatSolver.unsat?(atoms)
-                             end
+                if definitions && !definitions.empty?
+                  result = Kumi::Core::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
+                  if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                    puts "  Enhanced solver result: #{result}"
+                  end
+                else
+                  result = Kumi::Core::AtomUnsatSolver.unsat?(atoms)
+                  if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                    puts "  Basic solver result: #{result}"
+                  end
+                end
+                impossible = result
+
+                if impossible && (ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257"))
+                  puts "  -> FLAGGING AS IMPOSSIBLE: #{decl.name}"
+                end
 
                 report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
               end
@@ -63,15 +82,24 @@ module Kumi
             decl.expression.cases[0...-1].each do |when_case|
               next unless when_case.condition
 
-              next unless when_case.condition.fn_name == :all?
+              next unless when_case.condition.fn_name == :cascade_and
 
               when_case.condition.args.each do |arg|
-                next unless arg.is_a?(ArrayExpression)
-
-                arg.elements.each do |element|
-                  next unless element.is_a?(DeclarationReference)
-
-                  trait_name = element.name
+                if arg.is_a?(ArrayExpression)
+                  # Handle array elements (for array broadcasting)
+                  arg.elements.each do |element|
+                    next unless element.is_a?(DeclarationReference)
+
+                    trait_name = element.name
+                    trait = definitions[trait_name]
+                    if trait
+                      conditions << trait.expression
+                      condition_traits << trait_name
+                    end
+                  end
+                elsif arg.is_a?(DeclarationReference)
+                  # Handle direct trait references (simple case)
+                  trait_name = arg.name
                   trait = definitions[trait_name]
                   if trait
                     conditions << trait.expression
@@ -183,8 +211,8 @@ module Kumi
                 # We should NOT add OR children to the stack as they would be treated as AND
                 # OR expressions need separate analysis in the main run() method
                 next
-              elsif current.is_a?(CallExpression) && current.fn_name == :all?
-                # For all? function, add all trait arguments to the stack
+              elsif current.is_a?(CallExpression) && current.fn_name == :cascade_and
+                # cascade_and takes individual arguments (not wrapped in array)
                 current.args.each { |arg| stack << arg }
               elsif current.is_a?(ArrayExpression)
                 # For ArrayExpression, add all elements to the stack
@@ -212,7 +240,18 @@ module Kumi
             # This is the correct behavior: each 'on' condition should be checked separately
             # since only ONE will be evaluated at runtime (they're mutually exclusive by design)
 
-            decl.expression.cases.each_with_index do |when_case, _index|
+            # DEBUG: Add detailed logging for hierarchical broadcasting debugging
+            if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+              puts "DEBUG UNSAT CASCADE: Checking cascade '#{decl.name}' at #{decl.loc}"
+              puts "  Total cases: #{decl.expression.cases.length}"
+            end
+
+            decl.expression.cases.each_with_index do |when_case, index|
+              # DEBUG: Log each case
+              if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                puts "  Case #{index}: condition=#{when_case.condition.inspect}"
+              end
+
               # Skip the base case (it's typically a literal true condition)
               next if when_case.condition.is_a?(Literal) && when_case.condition.value == true
 
@@ -220,52 +259,51 @@ module Kumi
               next if when_case.condition.is_a?(CallExpression) && %i[any? none?].include?(when_case.condition.fn_name)
 
               # Skip single-trait 'on' branches: trait-level unsat detection covers these
-              if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-                # Handle both ArrayExpression (old format) and multiple args (new format)
-                if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ArrayExpression)
-                  list = when_case.condition.args.first
-                  next if list.elements.size == 1
-                elsif when_case.condition.args.size == 1
-                  # Multiple args format
-                  next
-                end
+              if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :cascade_and && (when_case.condition.args.size == 1)
+                # cascade_and uses individual arguments - skip if only one trait
+                next
               end
+
               # Gather atoms from this individual condition only
               condition_atoms = gather_atoms(when_case.condition, definitions, Set.new, [])
-              # DEBUG
-              # if when_case.condition.is_a?(CallExpression) && [:all?, :any?, :none?].include?(when_case.condition.fn_name)
-              #   puts "  Args: #{when_case.condition.args.inspect}"
-              #   puts "  Atoms found: #{condition_atoms.inspect}"
-              # end
 
-              # Only flag if this individual condition is impossible
-              # if !condition_atoms.empty?
-              #   is_unsat = Kumi::Core::AtomUnsatSolver.unsat?(condition_atoms)
-              #   puts "  Is unsat? #{is_unsat}"
-              # end
+              # DEBUG: Add detailed logging for hierarchical broadcasting debugging
+              if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                puts "    Condition atoms: #{condition_atoms.map(&:inspect)}"
+              end
+
               # Use enhanced solver for cascade conditions too
-              impossible = if definitions && !definitions.empty?
-                             Kumi::Core::ConstraintRelationshipSolver.unsat?(condition_atoms, definitions, input_meta: @input_meta)
-                           else
-                             Kumi::Core::AtomUnsatSolver.unsat?(condition_atoms)
-                           end
+              if definitions && !definitions.empty?
+                result = Kumi::Core::ConstraintRelationshipSolver.unsat?(condition_atoms, definitions, input_meta: @input_meta)
+                if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                  puts "    Enhanced solver result: #{result}"
+                end
+              else
+                result = Kumi::Core::AtomUnsatSolver.unsat?(condition_atoms)
+                if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                  puts "    Basic solver result: #{result}"
+                end
+              end
+              impossible = result
               next unless !condition_atoms.empty? && impossible
 
               # For multi-trait on-clauses, report the trait names rather than the value name
-              if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-                # Handle both ArrayExpression (old format) and multiple args (new format)
-                trait_bindings = if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ArrayExpression)
-                                   when_case.condition.args.first.elements
-                                 else
-                                   when_case.condition.args
-                                 end
+              if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :cascade_and
+                # cascade_and uses individual arguments
+                trait_bindings = when_case.condition.args
 
                 if trait_bindings.all?(DeclarationReference)
                   traits = trait_bindings.map(&:name).join(" AND ")
+                  if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                    puts "    -> FLAGGING AS IMPOSSIBLE CASCADE CONDITION: #{traits}"
+                  end
                   report_error(errors, "conjunction `#{traits}` is impossible", location: decl.loc)
                   next
                 end
               end
+              if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
+                puts "    -> FLAGGING AS IMPOSSIBLE CASCADE: #{decl.name}"
+              end
               report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc)
             end
           end
@@ -275,6 +313,12 @@ module Kumi
             when InputReference, DeclarationReference
               val = @evaluator.evaluate(node)
               val == :unknown ? node.name : val
+            when InputElementReference
+              # For hierarchical paths like input.companies.regions.offices.teams.department,
+              # create a unique identifier that represents the specific path
+              # This prevents false positives where different paths are treated as the same :unknown
+              path_identifier = node.path.join(".").to_s
+              path_identifier.to_sym
             when Literal
               node.value
             else

data/lib/kumi/core/cascade_executor_builder.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    # Builds cascade execution lambdas from analysis metadata
+    class CascadeExecutorBuilder
+      include NestedStructureUtils
+
+      def self.build_executor(strategy, analysis_state)
+        new(strategy, analysis_state).build
+      end
+
+      def initialize(strategy, analysis_state)
+        @strategy = strategy
+        @analysis_state = analysis_state
+      end
+
+      def build
+        case @strategy[:mode]
+        when :hierarchical
+          build_hierarchical_executor
+        when :nested_array, :deep_nested_array
+          build_nested_array_executor
+        when :simple_array
+          build_simple_array_executor
+        else
+          build_scalar_executor
+        end
+      end
+
+      private
+
+      def build_hierarchical_executor
+        lambda do |cond_results, res_results, base_result, pairs|
+          # Find the result structure to use as template (deepest structure)
+          all_values = (res_results + cond_results + [base_result].compact).select { |v| v.is_a?(Array) }
+          result_template = all_values.max_by { |v| calculate_array_depth(v) }
+
+          return execute_scalar_cascade(cond_results, res_results, base_result, pairs) unless result_template
+
+          # Apply hierarchical cascade logic using the result structure as template
+          map_nested_structure(result_template) do |*indices|
+            result = nil
+
+            # Check conditional cases first with hierarchical broadcasting for conditions
+            pairs.each_with_index do |(_cond, _res), pair_idx|
+              cond_val = navigate_with_hierarchical_broadcasting(cond_results[pair_idx], indices, result_template)
+              next unless cond_val
+
+              res_val = navigate_nested_indices(res_results[pair_idx], indices)
+              result = res_val
+              break
+            end
+
+            # If no conditional case matched, use base case
+            result = navigate_nested_indices(base_result, indices) if result.nil? && base_result
+
+            result
+          end
+        end
+      end
+
+      def build_nested_array_executor
+        lambda do |cond_results, res_results, base_result, pairs|
+          # For nested arrays, we need to find the structure template
+          structure_template = find_structure_template(cond_results + res_results + [base_result].compact)
+          return execute_scalar_cascade(cond_results, res_results, base_result, pairs) unless structure_template
+
+          # Apply cascade logic recursively through the nested structure
+          map_nested_structure(structure_template) do |*indices|
+            result = nil
+
+            # Check conditional cases first
+            pairs.each_with_index do |(_cond, _res), pair_idx|
+              cond_val = navigate_nested_indices(cond_results[pair_idx], indices)
+              next unless cond_val
+
+              res_val = navigate_nested_indices(res_results[pair_idx], indices)
+              result = res_val
+              break
+            end
+
+            # If no conditional case matched, use base case
+            result = navigate_nested_indices(base_result, indices) if result.nil? && base_result
+
+            result
+          end
+        end
+      end
+
+      def build_simple_array_executor
+        lambda do |cond_results, res_results, base_result, pairs|
+          array_length = determine_array_length(cond_results + res_results + [base_result].compact)
+
+          (0...array_length).map do |i|
+            result = nil
+            # Check conditional cases first
+            pairs.each_with_index do |(_cond, _res), pair_idx|
+              cond_val = extract_element_at_index(cond_results[pair_idx], i)
+              next unless cond_val
+
+              res_val = extract_element_at_index(res_results[pair_idx], i)
+              result = res_val
+              break
+            end
+
+            # If no conditional case matched, use base case
+            result = extract_element_at_index(base_result, i) if result.nil? && base_result
+
+            result
+          end
+        end
+      end
+
+      def build_scalar_executor
+        lambda do |cond_results, res_results, base_result, pairs|
+          pairs.each_with_index do |(_cond, _res), pair_idx|
+            return res_results[pair_idx] if cond_results[pair_idx]
+          end
+          base_result
+        end
+      end
+
+      def execute_scalar_cascade(cond_results, res_results, base_result, pairs)
+        pairs.each_with_index do |(_cond, _res), pair_idx|
+          return res_results[pair_idx] if cond_results[pair_idx]
+        end
+        base_result
+      end
+    end
+  end
+end

data/lib/kumi/core/compiler/expression_compiler.rb

@@ -0,0 +1,146 @@
+module Kumi
+  module Core
+    module Compiler
+      module ExpressionCompiler
+        private
+
+        def compile_list(expr)
+          fns = expr.elements.map { |e| compile_expr(e) }
+          ->(ctx) { fns.map { |fn| fn.call(ctx) } }
+        end
+
+        def compile_call(expr)
+          fn_name = expr.fn_name
+          arg_fns = expr.args.map { |a| compile_expr(a) }
+
+          # Get compilation metadata once
+          compilation_meta = @analysis.state[:broadcasts]&.dig(:compilation_metadata, @current_declaration)
+
+          # Check if this is a vectorized operation
+          if vectorized_operation?(expr)
+            # Build vectorized executor at COMPILATION time
+            executor = Core::VectorizedFunctionBuilder.build_executor(fn_name, compilation_meta, @analysis.state)
+
+            lambda do |ctx|
+              # Evaluate arguments and use pre-built executor at RUNTIME
+              values = arg_fns.map { |fn| fn.call(ctx) }
+              executor.call(values, expr.loc)
+            end
+          else
+            # Use pre-computed function call strategy
+            function_strategy = compilation_meta&.dig(:function_call_strategy) || {}
+
+            if function_strategy[:flattening_required]
+              flattening_info = @analysis.state[:broadcasts][:flattening_declarations][@current_declaration]
+              ->(ctx) { invoke_function_with_flattening(fn_name, arg_fns, ctx, expr.loc, expr.args, flattening_info) }
+            else
+              ->(ctx) { invoke_function(fn_name, arg_fns, ctx, expr.loc) }
+            end
+          end
+        end
+
+        def compile_cascade(expr)
+          # Use metadata to determine if this cascade is vectorized
+          broadcast_meta = @analysis.state[:broadcasts]
+          cascade_info = @current_declaration && broadcast_meta&.dig(:vectorized_operations, @current_declaration)
+          is_vectorized = cascade_info && cascade_info[:source] == :cascade_with_vectorized_conditions_or_results
+
+          # Separate conditional cases from base case
+          conditional_cases = expr.cases.select(&:condition)
+          base_case = expr.cases.find { |c| c.condition.nil? }
+
+          # Compile conditional pairs
+          pairs = conditional_cases.map do |c|
+            condition_fn = if is_vectorized
+                             transform_vectorized_condition(c.condition)
+                           else
+                             compile_expr(c.condition)
+                           end
+            result_fn = compile_expr(c.result)
+            [condition_fn, result_fn]
+          end
+
+          # Compile base case
+          base_fn = base_case ? compile_expr(base_case.result) : nil
+
+          if is_vectorized
+            # Capture the current declaration name in the closure
+            current_decl_name = @current_declaration
+
+            # Get pre-computed cascade strategy
+            compilation_meta = @analysis.state[:broadcasts]&.dig(:compilation_metadata, current_decl_name)
+            cascade_info = compilation_meta&.dig(:cascade_info) || {}
+
+            # Build executor at COMPILATION time (outside the lambda)
+            strategy = @analysis.state[:broadcasts][:cascade_strategies][current_decl_name]
+            executor = strategy ? Core::CascadeExecutorBuilder.build_executor(strategy, @analysis.state) : nil
+
+            # Metadata-driven vectorized cascade evaluation
+            lambda do |ctx|
+              # Evaluate all conditions and results
+              cond_results = pairs.map { |cond, _res| cond.call(ctx) }
+              res_results = pairs.map { |_cond, res| res.call(ctx) }
+              base_result = base_fn&.call(ctx)
+
+              if ENV["DEBUG_CASCADE"]
+                puts "DEBUG: Vectorized cascade evaluation for #{current_decl_name}:"
+                cond_results.each_with_index { |cr, i| puts "  cond_results[#{i}]: #{cr.inspect}" }
+                res_results.each_with_index { |rr, i| puts "  res_results[#{i}]: #{rr.inspect}" }
+                puts "  base_result: #{base_result.inspect}"
+                puts "  Pre-computed cascade_info: #{cascade_info.inspect}"
+              end
+
+              # Use pre-built executor at RUNTIME
+              if executor
+                executor.call(cond_results, res_results, base_result, pairs)
+              else
+                # Fallback for cases without strategy
+                pairs.each_with_index do |(_cond, _res), pair_idx|
+                  return res_results[pair_idx] if cond_results[pair_idx]
+                end
+                base_result
+              end
+            end
+          else
+            # Non-vectorized cascade - standard evaluation
+            lambda do |ctx|
+              pairs.each { |cond, res| return res.call(ctx) if cond.call(ctx) }
+              # If no conditional case matched, return base case
+              base_fn&.call(ctx)
+            end
+          end
+        end
+
+        def transform_vectorized_condition(condition_expr)
+          if condition_expr.is_a?(Kumi::Syntax::CallExpression) &&
+             condition_expr.fn_name == :cascade_and
+
+            puts "    transform_vectorized_condition: handling cascade_and with #{condition_expr.args.length} args" if ENV["DEBUG_CASCADE"]
+
+            # For cascade_and in vectorized contexts, we need to compile it as a structure-level operation
+            # rather than element-wise operation
+            return compile_cascade_and_for_hierarchical_broadcasting(condition_expr)
+          end
+
+          # Otherwise compile normally
+          compile_expr(condition_expr)
+        end
+
+        def compile_cascade_and_for_hierarchical_broadcasting(condition_expr)
+          # Compile individual trait references
+          trait_fns = condition_expr.args.map { |arg| compile_expr(arg) }
+
+          lambda do |ctx|
+            # Evaluate all traits to get their array structures
+            trait_values = trait_fns.map { |fn| fn.call(ctx) }
+
+            fn = Kumi::Registry.fetch(:cascade_and)
+            result = fn.call(*trait_values)
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/compiler/function_invoker.rb

@@ -0,0 +1,55 @@
+module Kumi
+  module Core
+    module Compiler
+      module FunctionInvoker
+        private
+
+        def invoke_function(name, arg_fns, ctx, loc)
+          fn = Kumi::Registry.fetch(name)
+          values = arg_fns.map { |fn| fn.call(ctx) }
+
+          # REMOVED AUTO-FLATTENING: Let operations work on the structure they receive
+          # If flattening is needed, it should be handled by explicit operation modes
+          # in the InputElementReference compilation, not here.
+          fn.call(*values)
+        rescue StandardError => e
+          # Preserve original error class and backtrace while adding context
+          enhanced_message = "Error calling fn(:#{name}) at #{loc}: #{e.message}"
+
+          if e.is_a?(Kumi::Core::Errors::Error)
+            # Re-raise Kumi errors with enhanced message but preserve type
+            e.define_singleton_method(:message) { enhanced_message }
+            raise e
+          else
+            # For non-Kumi errors, wrap in RuntimeError but preserve original error info
+            runtime_error = Errors::RuntimeError.new(enhanced_message)
+            runtime_error.set_backtrace(e.backtrace)
+            runtime_error.define_singleton_method(:cause) { e }
+            raise runtime_error
+          end
+        end
+
+        def invoke_function_with_flattening(name, arg_fns, ctx, loc, _original_args, _flattening_info)
+          fn = Kumi::Registry.fetch(name)
+
+          # Use pre-computed flattening indices from analysis
+          compilation_meta = @analysis.state[:broadcasts]&.dig(:compilation_metadata, @current_declaration)
+          flatten_indices = compilation_meta&.dig(:function_call_strategy, :flatten_argument_indices) || []
+
+          values = arg_fns.map.with_index do |arg_fn, index|
+            value = arg_fn.call(ctx)
+            flatten_indices.include?(index) ? flatten_completely(value) : value
+          end
+
+          fn.call(*values)
+        rescue StandardError => e
+          enhanced_message = "Error calling fn(:#{name}) at #{loc}: #{e.message}"
+          runtime_error = Errors::RuntimeError.new(enhanced_message)
+          runtime_error.set_backtrace(e.backtrace)
+          runtime_error.define_singleton_method(:cause) { e }
+          raise runtime_error
+        end
+      end
+    end
+  end
+end