stellwerk-ruby 0.1.0

data/lib/stellwerk/evaluator.rb

@@ -0,0 +1,748 @@
+# frozen_string_literal: true
+
+require "set"
+require "dentaku"
+require "yaml"
+require "json"
+
+module Stellwerk
+  # Evaluates flows using pre-compiled JSON representation for maximum performance.
+  # Avoids all database queries by working directly with the compiled JSON structure.
+  #
+  # The compiled JSON format:
+  # {
+  #   "version": "1.0",
+  #   "compiled_at": "...",
+  #   "entry_node_ids": [...],
+  #   "nodes": { "node_id": { id, name, type, config, ... } },
+  #   "adjacency": { "node_id": [{ "to": "...", "branch": "..." }] },
+  #   "reverse_adjacency": { "node_id": ["parent_id", ...] },
+  #   "sub_flows": { "flow_id": { ... embedded sub-flow ... } }
+  # }
+  class Evaluator
+    # --------------------------------------------------
+    # Public API
+    # --------------------------------------------------
+    def self.call(compiled_json:, params:, sub_flows: {}, metadata: {})
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = new(compiled_json: compiled_json, params: params, sub_flows: sub_flows, metadata: metadata).evaluate
+      duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+
+      # Track metrics for observability if Metrics is available
+      if defined?(Metrics)
+        status = result.errors.any? ? "error" : "success"
+        Metrics.increment("stellwerk.flow.executions", tags: { status: status })
+        Metrics.timing("stellwerk.flow.execution_time", duration_ms)
+        Metrics.histogram("stellwerk.flow.nodes_evaluated", result.applied_nodes.size)
+      end
+
+      result
+    end
+
+    # --------------------------------------------------
+    # Implementation
+    # --------------------------------------------------
+    def initialize(compiled_json:, params:, sub_flows: {}, metadata: {})
+      @compiled = deep_symbolize_keys(compiled_json)
+      @nodes = (@compiled[:nodes] || {}).transform_keys(&:to_s)
+      @adjacency = @compiled[:adjacency] || {}
+      @reverse_adjacency = @compiled[:reverse_adjacency] || {}
+      @entry_node_ids = @compiled[:entry_node_ids] || []
+      @embedded_sub_flows = @compiled[:sub_flows] || {}
+      @external_sub_flows = sub_flows
+
+      @context = seed_initial_context(metadata, params)
+      @calculator = Dentaku::Calculator.new
+      register_collection_functions!
+      @applied_nodes = []
+      @errors = []
+      @merge_buffers = Hash.new { |h, k| h[k] = [] }
+      @outputs = nil
+    end
+
+    def evaluate
+      return build_result if @nodes.empty?
+
+      if @entry_node_ids.empty?
+        @errors << "No start nodes found in flow"
+        return build_result
+      end
+
+      evaluate_graph
+    end
+
+    private
+
+    def deep_symbolize_keys(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(key, value), result|
+          result[key.to_sym] = deep_symbolize_keys(value)
+        end
+      when Array
+        obj.map { |item| deep_symbolize_keys(item) }
+      else
+        obj
+      end
+    end
+
+    def seed_initial_context(metadata, params)
+      ctx = {}
+
+      # Flow metadata (medium priority)
+      if metadata && !metadata.empty?
+        evaluation_metadata = metadata.reject { |k, _| k.to_s == "sticky_notes" }
+        ctx.merge!(deep_symbolize_keys(evaluation_metadata))
+      end
+
+      # Runtime params (highest priority)
+      ctx.merge!(deep_symbolize_keys(params.to_h))
+
+      ctx
+    end
+
+    def evaluate_graph
+      # Use pre-computed adjacency lists
+      children_by = @adjacency.transform_keys(&:to_s)
+      parents_by = @reverse_adjacency.transform_keys(&:to_s)
+
+      # Token-based traversal
+      token_struct = Struct.new(:node_id, :context, :branch_taken)
+      queue = []
+
+      # Seed queue with entry nodes
+      @entry_node_ids.each do |node_id|
+        queue << token_struct.new(node_id, @context.dup, nil)
+      end
+
+      visited = Set.new
+      final_context = @context.dup
+
+      while (token = queue.shift)
+        node = @nodes[token.node_id]
+        next unless node
+
+        node_type = node[:type] || node["type"]
+        node_id = node[:id] || node["id"]
+
+        # Handle merge nodes specially
+        if node_type == "merge"
+          @merge_buffers[node_id] << { context: token.context, branch: token.branch_taken }
+
+          expected_count = (parents_by[node_id] || []).size
+          if @merge_buffers[node_id].size >= expected_count
+            result = execute_merge_node_with_tokens(node, @merge_buffers[node_id])
+            @merge_buffers.delete(node_id)
+
+            if result[:error]
+              @errors << { node_id: node_id, error: result[:error] }
+              next
+            end
+
+            @applied_nodes << { id: node_id, name: node[:name] || node["name"], type: node_type }
+            visited << node_id
+
+            updated_context = result[:context]
+            final_context.merge!(updated_context)
+
+            (children_by[node_id] || []).each do |child|
+              child_data = child.is_a?(Hash) ? child : deep_symbolize_keys(child)
+              next if (child_data[:branch] || child_data["branch"]).to_s != ""
+              queue << token_struct.new(child_data[:to] || child_data["to"], updated_context.dup, nil)
+            end
+          end
+          next
+        end
+
+        # Execute node
+        result = execute_node(node, token.context)
+
+        next if result[:skip]
+
+        if result[:error]
+          @errors << { node_id: node_id, error: result[:error] }
+          next
+        end
+
+        @applied_nodes << { id: node_id, name: node[:name] || node["name"], type: node_type }
+        visited << node_id
+
+        updated_context = result[:context] || token.context
+        final_context.merge!(updated_context)
+
+        # Handle branching
+        if result[:branch]
+          children = (children_by[node_id] || []).select do |c|
+            c_data = c.is_a?(Hash) ? c : deep_symbolize_keys(c)
+            (c_data[:branch] || c_data["branch"]) == result[:branch]
+          end
+          children.each do |child|
+            child_data = child.is_a?(Hash) ? child : deep_symbolize_keys(child)
+            queue << token_struct.new(child_data[:to] || child_data["to"], updated_context.dup, result[:branch])
+          end
+        else
+          (children_by[node_id] || []).each do |child|
+            child_data = child.is_a?(Hash) ? child : deep_symbolize_keys(child)
+            next if (child_data[:branch] || child_data["branch"]).to_s != ""
+            queue << token_struct.new(child_data[:to] || child_data["to"], updated_context.dup, nil)
+          end
+        end
+      end
+
+      @context = final_context
+      build_result
+    end
+
+    def execute_node(node, context)
+      node_type = node[:type] || node["type"]
+
+      case node_type
+      when "start"     then execute_start_node(node, context)
+      when "calculate" then execute_calculate_node(node, context)
+      when "condition" then execute_condition_node(node, context)
+      when "merge"     then execute_merge_node(node, context)
+      when "end"       then execute_end_node(node, context)
+      when "map"       then execute_map_node(node, context)
+      when "switch"    then execute_switch_node(node, context)
+      else
+        { error: "Unknown node type: #{node_type}" }
+      end
+    rescue StandardError => e
+      Stellwerk.logger.error("Error executing compiled node #{node[:id]}: #{e.message}")
+      { error: e.message }
+    end
+
+    # --------------------------------------------------
+    # Node Executors
+    # --------------------------------------------------
+
+    def execute_start_node(node, context)
+      input_schema = node[:inputs] || node["inputs"] || node.dig(:config, "inputs") || []
+
+      updated_context = context.dup
+
+      input_schema.each do |input_def|
+        input_def = input_def.transform_keys(&:to_s) if input_def.is_a?(Hash)
+        name = input_def["name"]
+        sym_name = name.to_sym
+
+        if !updated_context.key?(sym_name) && input_def.key?("default")
+          updated_context[sym_name] = input_def["default"]
+        end
+
+        if input_def["required"] && !updated_context.key?(sym_name)
+          return { error: "Required input missing: #{name}" }
+        end
+      end
+
+      { context: updated_context }
+    end
+
+    def execute_calculate_node(node, context)
+      formula = node[:formula] || node["formula"] || node.dig(:config, "formula")
+      return { context: context } if formula.nil? || formula.to_s.strip.empty?
+
+      processed_formula = preprocess_collections(normalize_expression(formula))
+      flat_context = flatten_context(context)
+
+      begin
+        result_context = apply_formula(processed_formula, flat_context)
+
+        outputs = {}
+        declared = node[:declared_outputs] || node["declared_outputs"] || []
+        declared.each do |var_name|
+          outputs[var_name.to_sym] = result_context[var_name.to_sym] if result_context.key?(var_name.to_sym)
+        end
+
+        { context: context.merge(outputs) }
+      rescue StandardError => e
+        Stellwerk.logger.warn("Calculate node formula error: #{e.message}")
+        { error: e.message }
+      end
+    end
+
+    def execute_condition_node(node, context)
+      condition = node[:condition] || node["condition"] || node.dig(:config, "condition")
+      return { skip: true } if condition.nil? || condition.to_s.strip.empty?
+
+      processed_condition = preprocess_collections(normalize_expression(condition))
+      flat_context = flatten_context(context)
+
+      begin
+        result = @calculator.evaluate!(processed_condition, flat_context)
+        branch = result ? "true" : "false"
+        { context: context, branch: branch }
+      rescue StandardError => e
+        Stellwerk.logger.warn("Condition node error: #{e.message}")
+        { error: e.message }
+      end
+    end
+
+    def execute_switch_node(node, context)
+      cases = node[:cases] || node["cases"] || node.dig(:config, "cases") || []
+
+      flat_context = flatten_context(context)
+      match_id = nil
+
+      cases.each do |case_def|
+        case_def = case_def.transform_keys(&:to_s) if case_def.is_a?(Hash)
+        condition = case_def["condition"]
+        next if condition.nil? || condition.to_s.strip.empty?
+
+        begin
+          processed_condition = preprocess_collections(normalize_expression(condition))
+          is_match = @calculator.evaluate!(processed_condition, flat_context)
+
+          if is_match
+            match_id = case_def["id"]
+            break
+          end
+        rescue Dentaku::UnboundVariableError => e
+          return { error: "Switch case '#{case_def['label']}' error: #{e.message}" }
+        rescue StandardError => e
+          Stellwerk.logger.warn("Switch node case error: #{e.message}")
+          return { error: "Switch case '#{case_def['label']}' error: #{e.message}" }
+        end
+      end
+
+      branch = match_id || "default"
+      { context: context, branch: branch }
+    end
+
+    def execute_merge_node(node, context)
+      { context: context }
+    end
+
+    def execute_merge_node_with_tokens(node, tokens)
+      strategy = node[:strategy] || node["strategy"] || node.dig(:config, "strategy") || "wait_for_all"
+
+      case strategy
+      when "wait_for_all", "merge_all"
+        merged_context = {}
+        tokens.each { |t| merged_context.merge!(t[:context]) }
+        { context: merged_context }
+
+      when "first_arrival"
+        { context: tokens.first[:context] }
+
+      when "pick_highest", "pick_lowest"
+        selection_expr = node[:join_selection_expr] || node["join_selection_expr"] || node.dig(:config, "join_selection_expr")
+
+        if selection_expr.nil? || selection_expr.to_s.strip.empty?
+          return { error: "Merge strategy '#{strategy}' requires join_selection_expr" }
+        end
+
+        scored_tokens = tokens.map do |token_data|
+          begin
+            processed_expr = preprocess_collections(normalize_expression(selection_expr))
+            flat_context = flatten_context(token_data[:context])
+            score = @calculator.evaluate!(processed_expr, flat_context)
+            { context: token_data[:context], score: score }
+          rescue StandardError => e
+            Stellwerk.logger.warn("Merge selection error: #{e.message}")
+            { context: token_data[:context], score: nil }
+          end
+        end
+
+        valid_tokens = scored_tokens.reject { |t| t[:score].nil? }
+
+        if valid_tokens.empty?
+          return { error: "No valid scores for merge selection" }
+        end
+
+        winner = strategy == "pick_highest" ? valid_tokens.max_by { |t| t[:score] } : valid_tokens.min_by { |t| t[:score] }
+        { context: winner[:context] }
+
+      else
+        merged_context = {}
+        tokens.each { |t| merged_context.merge!(t[:context]) }
+        { context: merged_context }
+      end
+    end
+
+    def execute_end_node(node, context)
+      output_template = node[:output_template] || node["output_template"] || node.dig(:config, "output_template")
+      yaml_template = node[:yaml_template] || node["yaml_template"] || node.dig(:config, "yaml_template")
+      output_mapping = node[:output_mapping] || node["output_mapping"] || node.dig(:config, "output_mapping") || []
+
+      if output_template && !output_template.to_s.strip.empty?
+        @outputs = process_json_template(output_template, context)
+      elsif yaml_template && !yaml_template.to_s.strip.empty?
+        @outputs = process_yaml_template(yaml_template, context)
+      else
+        @outputs = {}
+      end
+
+      outputs_empty = @outputs.nil? || (@outputs.is_a?(Hash) && @outputs.empty?)
+      if outputs_empty && !output_mapping.empty?
+        mapped_outputs = {}
+        output_mapping.each do |mapping|
+          mapping = mapping.transform_keys(&:to_s) if mapping.is_a?(Hash)
+          source = mapping["from"] || mapping["name"]
+          target = mapping["name"]
+          mapped_outputs[target.to_sym] = context[source.to_sym] if context.key?(source.to_sym)
+        end
+        @outputs = mapped_outputs
+      end
+
+      { context: context }
+    end
+
+    def execute_map_node(node, context)
+      source_var = node[:source_variable] || node["source_variable"] || node.dig(:config, "source_variable")
+      item_alias = node[:item_alias] || node["item_alias"] || node.dig(:config, "item_alias") || "item"
+      index_alias = node[:index_alias] || node["index_alias"] || node.dig(:config, "index_alias")
+      output_var = node[:output_variable] || node["output_variable"] || node.dig(:config, "output_variable") || "results"
+      sub_flow_id = node[:sub_flow_id] || node["sub_flow_id"] || node.dig(:config, "sub_flow_id")
+      enrich_source = node[:enrich_source_array] || node["enrich_source_array"] || node.dig(:config, "enrich_source_array") == true
+
+      source_array = context[source_var.to_sym]
+      unless source_array.is_a?(Array)
+        return { error: "MapNode source '#{source_var}' is not an array" }
+      end
+
+      if sub_flow_id && sub_flow_id.to_s.strip != ""
+        # Look up sub-flow from embedded sub_flows or external sub_flows
+        sub_flow_json = @embedded_sub_flows[sub_flow_id.to_s] ||
+                        @embedded_sub_flows[sub_flow_id.to_sym] ||
+                        @external_sub_flows[sub_flow_id.to_s] ||
+                        @external_sub_flows[sub_flow_id.to_sym]
+
+        unless sub_flow_json
+          return { error: "MapNode referenced sub-flow #{sub_flow_id} not found. Embed sub-flows in compiled JSON or pass via sub_flows parameter." }
+        end
+
+        results = []
+        source_array.each_with_index do |item, index|
+          item_context = item.is_a?(Hash) ? deep_symbolize_keys(item) : { item_alias.to_sym => item }
+          item_context[index_alias.to_sym] = index if index_alias && index_alias.to_s.strip != ""
+
+          # Recursively evaluate sub-flow
+          subflow_result = Evaluator.call(
+            compiled_json: sub_flow_json,
+            params: item_context,
+            sub_flows: @external_sub_flows.merge(@embedded_sub_flows)
+          )
+
+          if subflow_result.errors.any?
+            results << { error: subflow_result.errors.map { |e| e.is_a?(Hash) ? e[:error] : e.to_s }.join("; ") }
+          else
+            if enrich_source
+              results << deep_merge_hashes(item, subflow_result.outputs)
+            else
+              results << subflow_result.outputs
+            end
+          end
+        end
+
+        output_context = context.dup
+        output_context[output_var.to_sym] = results
+        { context: output_context }
+      else
+        { error: "MapNode requires a sub-flow" }
+      end
+    end
+
+    # --------------------------------------------------
+    # Helper Methods
+    # --------------------------------------------------
+
+    def apply_formula(formula, context)
+      statements = join_multiline_statements(formula)
+      temp_ctx = context.dup
+
+      statements.each do |statement|
+        next if statement.start_with?("#")
+        break if statement.match?(/^\s*(export|return)\b/i)
+
+        if statement =~ /^(\w+)\s*:?=\s*(.+)$/m
+          var_name = $1.to_sym
+          expr = $2
+          processed_expr = preprocess_collections(expr)
+
+          begin
+            value = @calculator.evaluate!(processed_expr, temp_ctx)
+            # Convert BigDecimal to Float for proper JSON serialization
+            value = value.to_f if value.is_a?(BigDecimal)
+            temp_ctx[var_name] = value
+          rescue StandardError => e
+            Stellwerk.logger.warn("Formula statement error: #{e.message}")
+            raise e
+          end
+        end
+      end
+
+      temp_ctx
+    end
+
+    def join_multiline_statements(formula)
+      lines = formula.to_s.gsub("\r", "\n").split("\n").map(&:strip)
+      statements = []
+      current_statement = ""
+      paren_depth = 0
+
+      lines.each do |line|
+        next if line.empty?
+
+        if line.start_with?("#") && paren_depth == 0
+          statements << line
+          next
+        end
+
+        line_without_comment = line.gsub(/#.*$/, "").strip
+
+        if current_statement.empty?
+          current_statement = line_without_comment
+        else
+          current_statement += " " + line_without_comment
+        end
+
+        paren_depth += line_without_comment.count("(") - line_without_comment.count(")")
+
+        if paren_depth <= 0
+          statements << current_statement unless current_statement.empty?
+          current_statement = ""
+          paren_depth = 0
+        end
+      end
+
+      statements << current_statement unless current_statement.empty?
+      statements
+    end
+
+    def normalize_expression(expr)
+      expr.to_s.gsub("==", "=")
+    end
+
+    def preprocess_collections(expr_str)
+      result = expr_str.dup
+
+      result = result.gsub(/\[([^\[\]*]+)\]/) do |match|
+        inner = $1
+        inner.strip == "*" ? match : "ARRAY(#{inner})"
+      end
+
+      result.gsub(/(\w+)(\[\*\])+(\.\w+)+/) do
+        root = $1
+        path_str = $3
+        fields = path_str.scan(/\.\w+/).map { |f| f[1..-1] }
+
+        if fields.size == 1
+          "project(#{root}, \"#{fields.first}\")"
+        else
+          "deep_project(#{root}, #{fields.map { |f| "\"#{f}\"" }.join(', ')})"
+        end
+      end
+    end
+
+    def flatten_context(ctx)
+      result = {}
+      ctx.each do |key, value|
+        if value.is_a?(Hash)
+          value.each do |nested_key, nested_value|
+            result["#{key}.#{nested_key}".to_sym] = nested_value
+          end
+        else
+          result[key] = value
+        end
+      end
+      result
+    end
+
+    def deep_merge_hashes(base, overlay)
+      return overlay unless base.is_a?(Hash)
+      return base unless overlay.is_a?(Hash)
+
+      base_sym = deep_symbolize_keys(base)
+      overlay_sym = deep_symbolize_keys(overlay)
+
+      base_sym.merge(overlay_sym) do |_key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge_hashes(old_val, new_val)
+        else
+          new_val
+        end
+      end
+    end
+
+    # --------------------------------------------------
+    # Template Processing (from EndNode)
+    # --------------------------------------------------
+
+    def process_json_template(template, context)
+      interpolate_value(template, context)
+    end
+
+    def process_yaml_template(yaml_template, context)
+      return {} if yaml_template.nil? || yaml_template.to_s.strip.empty?
+
+      single_placeholder_match = yaml_template.strip.match(/\A\{\{\s*([\w.]+)\s*\}\}\z/)
+      if single_placeholder_match
+        var_path = single_placeholder_match[1]
+        return resolve_path(var_path, context)
+      end
+
+      begin
+        template = YAML.safe_load(yaml_template)
+        interpolate_value(template, context)
+      rescue Psych::SyntaxError
+        {}
+      end
+    end
+
+    def interpolate_value(value, context)
+      case value
+      when Hash
+        value.transform_values { |v| interpolate_value(v, context) }
+      when Array
+        value.map { |v| interpolate_value(v, context) }
+      when String
+        interpolate_string(value, context)
+      else
+        value
+      end
+    end
+
+    def interpolate_string(value, context)
+      jsonpath_single_match = value.match(/\A\s*\$\.([\w.]+)\s*\z/)
+      mustache_single_match = value.match(/\A\s*\{\{\s*([\w.]+)\s*\}\}\s*\z/)
+
+      if jsonpath_single_match
+        resolve_path(jsonpath_single_match[1], context)
+      elsif mustache_single_match
+        resolve_path(mustache_single_match[1], context)
+      else
+        result = value.dup
+        result = result.gsub(/\$\.([\w.]+)/) do |match|
+          var_path = Regexp.last_match(1)
+          val = resolve_path(var_path, context)
+          format_interpolated_value(val, match)
+        end
+        result = result.gsub(/\{\{\s*([\w.]+)\s*\}\}/) do |match|
+          var_path = Regexp.last_match(1)
+          val = resolve_path(var_path, context)
+          format_interpolated_value(val, match)
+        end
+        result
+      end
+    end
+
+    def format_interpolated_value(val, original_match)
+      if val.nil?
+        original_match
+      elsif val.is_a?(Hash) || val.is_a?(Array)
+        val.to_json
+      else
+        val.to_s
+      end
+    end
+
+    def resolve_path(path, context)
+      parts = path.split(".")
+      current = context
+
+      parts.each do |part|
+        return nil if current.nil?
+
+        current = if current.is_a?(Hash)
+          current[part.to_sym] || current[part]
+        elsif current.respond_to?(part)
+          current.public_send(part)
+        else
+          nil
+        end
+      end
+
+      current
+    end
+
+    # --------------------------------------------------
+    # Collection Functions Registration
+    # --------------------------------------------------
+
+    def register_collection_functions!
+      @calculator.add_function(:ARRAY, :numeric, ->(*args) { args })
+
+      @calculator.add_function(:PROJECT, :numeric, ->(collection, field_name) {
+        Stellwerk::Functions.PROJECT(collection, field_name)
+      })
+
+      @calculator.add_function(:DEEP_PROJECT, :numeric, ->(root, path_string, field_name) {
+        Stellwerk::Functions.DEEP_PROJECT(root, path_string, field_name)
+      })
+
+      @calculator.add_function(:SUM, :numeric, ->(*args) {
+        Stellwerk::Functions.SUM(*args)
+      })
+
+      @calculator.add_function(:COUNT, :numeric, ->(*args) {
+        Stellwerk::Functions.COUNT(*args)
+      })
+
+      @calculator.add_function(:MIN, :numeric, ->(*args) {
+        Stellwerk::Functions.MIN(*args)
+      })
+
+      @calculator.add_function(:MAX, :numeric, ->(*args) {
+        Stellwerk::Functions.MAX(*args)
+      })
+
+      @calculator.add_function(:AVERAGE, :numeric, ->(*args) {
+        Stellwerk::Functions.AVERAGE(*args)
+      })
+
+      @calculator.add_function(:AVG, :numeric, ->(*args) {
+        Stellwerk::Functions.AVERAGE(*args)
+      })
+
+      @calculator.add_function(:FIRST, :numeric, ->(arr) {
+        Stellwerk::Functions.FIRST(arr)
+      })
+
+      @calculator.add_function(:LAST, :numeric, ->(arr) {
+        Stellwerk::Functions.LAST(arr)
+      })
+
+      @calculator.add_function(:TAKE, :numeric, ->(arr, n) {
+        Stellwerk::Functions.TAKE(arr, n)
+      })
+
+      @calculator.add_function(:DISTINCT, :numeric, ->(arr) {
+        Stellwerk::Functions.DISTINCT(arr)
+      })
+
+      @calculator.add_function(:MAP, :numeric, ->(collection, expr) {
+        Stellwerk::Functions.MAP(collection, expr, calculator: @calculator)
+      })
+
+      @calculator.add_function(:FILTER, :numeric, ->(collection, predicate_expr) {
+        Stellwerk::Functions.FILTER(collection, predicate_expr, calculator: @calculator)
+      })
+
+      @calculator.add_function(:REDUCE, :numeric, ->(collection, initial, expr) {
+        Stellwerk::Functions.REDUCE(collection, initial, expr, calculator: @calculator)
+      })
+
+      @calculator.add_function(:SUMIF, :numeric, ->(collection, predicate_expr, projection_expr = nil) {
+        Stellwerk::Functions.SUMIF(collection, predicate_expr, projection_expr, calculator: @calculator)
+      })
+
+      @calculator.add_function(:COUNTIF, :numeric, ->(collection, predicate_expr) {
+        Stellwerk::Functions.COUNTIF(collection, predicate_expr, calculator: @calculator)
+      })
+
+      @calculator.add_function(:TRACE, :numeric, ->(value, label = nil) {
+        Stellwerk::Functions.TRACE(value, label)
+      })
+    end
+
+    def build_result
+      Result.new(
+        applied_nodes: @applied_nodes,
+        context: @context,
+        outputs: @outputs || {},
+        errors: @errors
+      )
+    end
+  end
+end