branchproof 0.8.0 → 0.9.0

data/lib/branchproof/exception_syntax.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ModuleLength
+
+require "prism"
+
+module Branchproof
+  # Replaces unsupported standalone rescue-clause records with decisions for
+  # Ruby's enclosing protected region.  Ruby chooses a rescue clause as part
+  # of executing BeginNode; a RescueNode by itself is not executable syntax.
+  module ExceptionSyntax
+    private
+
+    def flow_decision_node?(node)
+      return true if exception_region_node?(node)
+      return false if node.is_a?(Prism::RescueNode)
+
+      super
+    end
+
+    def flow_details(node, bytes, encoding)
+      return exception_region_details(node, bytes, encoding) if exception_region_node?(node)
+
+      super
+    end
+
+    def exception_region_node?(node)
+      (node.is_a?(Prism::BeginNode) && (node.rescue_clause || node.ensure_clause)) ||
+        node.is_a?(Prism::RescueModifierNode)
+    end
+
+    def exception_region_details(node, bytes, encoding)
+      return rescue_modifier_details(node, bytes, encoding) if node.is_a?(Prism::RescueModifierNode)
+
+      clauses = []
+      clause = node.rescue_clause
+      while clause
+        clauses << clause
+        clause = clause.child_nodes.find { |child| child.is_a?(Prism::RescueNode) }
+      end
+
+      alternatives = [{ expression: "normal", byte_start: node.location.start_offset,
+                        byte_length: node.location.length }]
+      clauses.each do |clause_node|
+        alternatives << { expression: rescue_label(clause_node, bytes, encoding),
+                          byte_start: clause_node.location.start_offset,
+                          byte_length: clause_node.location.length }
+      end
+      alternatives << { expression: "unhandled", byte_start: node.location.start_offset,
+                        byte_length: node.location.length }
+
+      instrumentation = {
+        type: "exception",
+        range: byte_range(node.location),
+        normal_insert_at: exception_normal_insert_at(node),
+        normal_body: node.statements && byte_range(node.statements.location),
+        normal_transfer: exception_transfer_metadata(node.statements),
+        implicit: node.begin_keyword_loc.nil?,
+        normal_empty: node.begin_keyword_loc.nil? && exception_body_empty?(node),
+        entry_insert_at: node.begin_keyword_loc.nil? && exception_entry_insert_at(node),
+        exit_insert_at: node.begin_keyword_loc.nil? && node.end_keyword_loc&.start_offset,
+        clauses: clauses.each_with_index.map do |clause_node, index|
+          { index: index + 1, insert_at: exception_clause_insert_at(clause_node, node) }
+        end,
+        unhandled_index: alternatives.length - 1
+      }
+      reasons = unsupported_reasons(node, bytes)
+      ["exception", "rescue", alternatives, instrumentation, reasons]
+    end
+
+    def rescue_modifier_details(node, bytes, _encoding)
+      lhs = node.expression
+      rhs = node.rescue_expression
+      alternatives = [
+        { expression: "normal", byte_start: lhs.location.start_offset, byte_length: lhs.location.length },
+        { expression: "rescue", byte_start: rhs.location.start_offset, byte_length: rhs.location.length },
+        { expression: "unhandled", byte_start: node.location.start_offset, byte_length: node.location.length }
+      ]
+      instrumentation = {
+        type: "rescue_modifier",
+        range: byte_range(node.location),
+        expression: byte_range(lhs.location),
+        rescue_expression: byte_range(rhs.location),
+        normal_index: 0,
+        rescue_index: 1,
+        unhandled_index: 2
+      }
+      ["exception", "rescue", alternatives, instrumentation, unsupported_reasons(node, bytes)]
+    end
+
+    def rescue_label(clause, bytes, encoding)
+      exceptions = Array(clause.exceptions)
+      return "rescue" if exceptions.empty?
+
+      names = exceptions.map do |exception|
+        text_value(bytes.byteslice(exception.location.start_offset, exception.location.length), encoding)
+      end
+      "rescue #{names.join(", ")}"
+    end
+
+    def exception_clause_insert_at(clause, node)
+      return clause.statements.location.start_offset unless statements_empty?(clause.statements)
+
+      next_clause = clause.child_nodes.find { |child| child.is_a?(Prism::RescueNode) }
+      return next_clause.keyword_loc.start_offset if next_clause
+      return node.else_clause.else_keyword_loc.start_offset if node.else_clause
+      return node.ensure_clause.ensure_keyword_loc.start_offset if node.ensure_clause
+
+      node.end_keyword_loc.start_offset
+    end
+
+    def exception_else_insert_at(node)
+      clause = node.else_clause
+      return clause.statements.location.start_offset unless statements_empty?(clause.statements)
+
+      node.ensure_clause&.ensure_keyword_loc&.start_offset || node.end_keyword_loc.start_offset
+    end
+
+    def exception_transfer_metadata(statements)
+      transfer = statements && Array(statements.body).last
+      return nil unless transfer_node?(transfer)
+
+      arguments = transfer.respond_to?(:arguments) ? transfer.arguments : nil
+      argument_nodes = arguments && Array(arguments.arguments)
+      scalar_argument = argument_nodes&.length == 1 && !argument_nodes.first.is_a?(Prism::SplatNode)
+      argument_mode = if scalar_argument
+                        :scalar
+                      elsif argument_nodes&.any?
+                        :array
+                      end
+      { insert_at: transfer.location.start_offset,
+        arguments: argument_mode ? byte_range(arguments.location) : nil,
+        argument_mode: argument_mode }
+    end
+
+    def transfer_node?(node)
+      [Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode].any? { |klass| node.is_a?(klass) }
+    end
+
+    def exception_body_empty?(node)
+      node.statements.nil? || statements_empty?(node.statements)
+    end
+
+    def exception_normal_insert_at(node)
+      return exception_else_insert_at(node) if node.else_clause
+      return nil unless exception_body_empty?(node)
+
+      node.rescue_clause&.keyword_loc&.start_offset || node.ensure_clause&.ensure_keyword_loc&.start_offset
+    end
+
+    def exception_entry_insert_at(node)
+      node.statements&.location&.start_offset || exception_normal_insert_at(node) || node.end_keyword_loc.start_offset
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ModuleLength

data/lib/branchproof/extended_alternative_runtime.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Runtime hooks for decisions whose native evaluation has a third path.
+  # Runtime includes this module explicitly; it is kept separate so the
+  # ordinary two-path helpers remain unchanged.
+  module ExtendedAlternativeRuntime
+    def flow_assignment_receiver(decision_id, receiver)
+      flow_select(decision_id, 0) if nil.equal?(receiver)
+      receiver
+    end
+
+    def flow_assignment_path(decision_id, index)
+      flow_select(decision_id, index)
+    end
+
+    def flow_assignment_finish(decision_id, value, default_path = nil)
+      frame = current_frame(decision_id)
+      flow_select(decision_id, default_path) if frame && !frame[:finished] && !default_path.nil?
+      value
+    end
+  end
+end

data/lib/branchproof/flow_instrumentation.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Keep each bounded source rewrite together so its evaluation order can be audited.
-# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+# rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ModuleLength
 
 module Branchproof
   # Source-location edits around Ruby's native matching and assignment operations.
@@ -19,11 +19,27 @@ module Branchproof
         flow_fragments(bytes, decision, nested, replacements, encloses)
       when "assignment"
         rhs = metadata.fetch(:rhs)
-        replacements = [flow_replacement(bytes, rhs, nested, encloses) do |expression|
-          "(begin; #{self.class::RUNTIME}.flow_path(#{decision[:id].inspect}, 1); (#{expression}); end)"
-        end]
+        identifier = decision[:id].inspect
+        replacements = []
+        if metadata[:receiver]
+          receiver = metadata.fetch(:receiver)
+          replacements << flow_replacement(bytes, receiver, nested, encloses) do |expression|
+            "#{self.class::RUNTIME}.flow_assignment_receiver(#{identifier}, (#{expression}))"
+          end
+          replacements << flow_replacement(bytes, rhs, nested, encloses) do |expression|
+            "(begin; #{self.class::RUNTIME}.flow_assignment_path(#{identifier}, 2); (#{expression}); end)"
+          end
+        else
+          replacements << flow_replacement(bytes, rhs, nested, encloses) do |expression|
+            "(begin; #{self.class::RUNTIME}.flow_path(#{identifier}, 1); (#{expression}); end)"
+          end
+        end
         expression = flow_fragments(bytes, decision, nested, replacements, encloses)
-        flow_frame(decision[:id], expression, default_path: 0)
+        if metadata[:receiver]
+          flow_assignment_frame(decision[:id], expression, default_path: 1)
+        else
+          flow_frame(decision[:id], expression, default_path: 0)
+        end
       when "case"
         render_case_flow(bytes, decision, nested, metadata, encloses)
       when "case_match"
@@ -38,7 +54,12 @@ module Branchproof
       runtime = self.class::RUNTIME
       replacements = metadata.fetch(:candidates).map do |candidate|
         flow_replacement(bytes, candidate, nested, encloses) do |expression|
-          "(begin; #{runtime}.flow_candidate(#{identifier}, #{candidate[:index]}); (#{expression}); end)"
+          if candidate[:splat]
+            splat_expression = expression.sub(/\A\*/, "")
+            "*(begin; #{runtime}.flow_candidate(#{identifier}, #{candidate[:index]}); (#{splat_expression}); end)"
+          else
+            "(begin; #{runtime}.flow_candidate(#{identifier}, #{candidate[:index]}); (#{expression}); end)"
+          end
         end
       end
       metadata.fetch(:branches).each do |branch|
@@ -101,7 +122,15 @@ module Branchproof
         "#{runtime}.flow_finish(#{decision_id.inspect}, (#{expression}), #{default_path.inspect}); ensure; " \
         "#{runtime}.leave(#{decision_id.inspect}); end; end)"
     end
+
+    def flow_assignment_frame(decision_id, expression, default_path: nil)
+      runtime = self.class::RUNTIME
+      "(begin; #{runtime}.enter(#{decision_id.inspect}); begin; " \
+        "#{runtime}.flow_assignment_finish(#{decision_id.inspect}, (#{expression}), " \
+        "#{default_path.inspect}); ensure; " \
+        "#{runtime}.leave(#{decision_id.inspect}); end; end)"
+    end
   end
 end
 
-# rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+# rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/ModuleLength

data/lib/branchproof/instrumenter.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "flow_instrumentation"
+require_relative "iteration_instrumentation"
+require_relative "exception_instrumentation"
+require_relative "default_instrumentation"
+require_relative "value_instrumentation"
 
 module Branchproof
   # Applies the smallest possible source edits around inventoried expressions.
@@ -8,6 +12,10 @@ module Branchproof
   # never evaluates application code or introduces a Ruby scope.
   class Instrumenter
     include FlowInstrumentation
+    include IterationInstrumentation
+    include ExceptionInstrumentation
+    prepend DefaultInstrumentation
+    prepend ValueInstrumentation
 
     RUNTIME = "::Branchproof::Runtime"
 
@@ -54,8 +62,29 @@ module Branchproof
     def build_enclosures(decisions)
       encloses = {}.compare_by_identity
       enclosed = {}.compare_by_identity
-      decisions.each do |outer|
-        contained = decisions.select { |inner| encloses_decision?(outer, inner) }
+      indexed = decisions.each_index.group_by { |index| decisions[index][:byte_start] }
+      active = []
+      relations = Array.new(decisions.length) { [] }
+
+      indexed.sort_by { |start, _indices| start }.each do |start, indices|
+        active.reject! do |index|
+          decision = decisions[index]
+          decision[:byte_start] + decision[:byte_length] < start
+        end
+        active.concat(indices)
+        indices.each do |inner_index|
+          inner = decisions[inner_index]
+          active.each do |outer_index|
+            outer = decisions[outer_index]
+            next unless encloses_decision?(outer, inner)
+
+            relations[outer_index] << inner_index
+          end
+        end
+      end
+
+      decisions.each_with_index do |outer, outer_index|
+        contained = relations[outer_index].sort.map { |inner_index| decisions[inner_index] }
         encloses[outer] = contained
         contained.each { |inner| enclosed[inner] = true }
       end
@@ -89,7 +118,7 @@ module Branchproof
 
         chunks << bytes.byteslice(cursor, cstart - cursor)
         original = render_children(bytes, cstart, clen, nested, encloses)
-        chunks << condition_wrapper(decision[:id], condition[:index], original)
+        chunks << condition_wrapper(decision, condition, original)
         cursor = cstart + clen
       end
       chunks << render_children(bytes, cursor, length - (cursor - start), nested, encloses)
@@ -131,8 +160,24 @@ module Branchproof
       end
     end
 
-    def condition_wrapper(decision_id, index, expression)
-      "#{RUNTIME}.condition(#{decision_id.inspect}, #{index}, (#{expression}))"
+    def condition_wrapper(decision, condition, expression)
+      return "(begin; #{expression}; end)" if nonlocal_transfer?(expression)
+
+      identifier = decision[:id].inspect
+      index = condition[:index]
+      case condition[:contextual]
+      when "implicit_regexp", "flip_flop"
+        # These operations require Ruby's conditional context: a bare regexp
+        # implicitly matches $_ and a flip-flop retains its state across calls.
+        "(if (#{expression}) then #{RUNTIME}.condition(#{identifier}, #{index}, true) " \
+        "else #{RUNTIME}.condition(#{identifier}, #{index}, false) end)"
+      else
+        "#{RUNTIME}.condition(#{identifier}, #{index}, (#{expression}))"
+      end
+    end
+
+    def nonlocal_transfer?(expression)
+      expression.lstrip.match?(/\A(?:return|break|next|redo|retry)\b/n)
     end
 
     def frame(decision_id, expression)

data/lib/branchproof/iteration_instrumentation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Keep matching and iteration in the original lexical scope.
+  module IterationInstrumentation
+    private
+
+    # rubocop:disable Metrics/MethodLength
+    def render_flow(bytes, decision, nested, encloses)
+      metadata = decision.fetch(:instrumentation)
+      case metadata[:type]
+      when "iteration"
+        render_iteration(bytes, decision, nested, encloses)
+      when "required_pattern"
+        expression = render_children(bytes, decision[:byte_start], decision[:byte_length], nested, encloses)
+        runtime = self.class::RUNTIME
+        identifier = decision[:id].inspect
+        "(begin; #{runtime}.enter(#{identifier}); begin; #{expression}; " \
+          "#{runtime}.flow_select(#{identifier}, 0); nil; rescue ::NoMatchingPatternError; " \
+          "#{runtime}.flow_select(#{identifier}, 1); raise; ensure; #{runtime}.leave(#{identifier}); end; end)"
+      else
+        super
+      end
+    end
+
+    # rubocop:enable Metrics/MethodLength
+
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- nested exception callback seam
+    def render_iteration(bytes, decision, nested, encloses)
+      metadata = decision.fetch(:instrumentation)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      alternative_count = metadata[:lazy] ? 1 : 2
+      marker = "#{runtime}.flow_iteration_callback(#{identifier}, #{alternative_count})"
+      suffix = metadata[:empty] ? "nil; " : ""
+      callback = "; #{marker}; #{suffix}"
+      exception_child = nested.find do |child|
+        child[:instrumentation]&.fetch(:type, nil) == "exception" &&
+          child[:instrumentation].fetch(:implicit, false) &&
+          contains?(child[:byte_start], child[:byte_length], metadata[:insert_at], 0)
+      end
+      if exception_child
+        instrumentation = exception_child.fetch(:instrumentation)
+        callback_child = exception_child.merge(instrumentation: instrumentation.merge(
+          iteration_callback: { insert_at: metadata[:insert_at], text: callback }
+        ))
+        nested = nested.map { |child| child.equal?(exception_child) ? callback_child : child }
+        encloses = encloses.merge(callback_child => encloses[exception_child])
+      end
+      edits = exception_child ? [] : [{ start: metadata[:insert_at], length: 0, text: callback }]
+      if metadata[:receiver]
+        receiver = metadata.fetch(:receiver)
+        edits << flow_replacement(bytes, receiver, nested, encloses) do |expression|
+          "#{runtime}.flow_iteration_begin(#{identifier}, (#{expression}), #{alternative_count})"
+        end
+      end
+      expression = flow_fragments(bytes, decision, nested, edits, encloses)
+      if metadata[:receiver]
+        "(begin; begin; #{runtime}.flow_iteration_finish(#{identifier}, (#{expression}), 0); ensure; " \
+          "#{runtime}.flow_iteration_leave(#{identifier}); end; end)"
+      else
+        flow_frame(decision[:id], expression, default_path: 0)
+      end
+    end
+  end
+end

data/lib/branchproof/iteration_runtime.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Runtime support for callback based iteration, including lazy receivers
+  # whose callbacks execute after the constructing call has returned.
+  module IterationRuntime
+    def flow_iteration_begin(decision_id, receiver, alternative_count = 2)
+      # Case equality bypasses an application's overridden `is_a?` method.
+      # rubocop:disable-next Style/CaseEquality
+      return receiver if alternative_count == 1 || ::Enumerator::Lazy === receiver
+
+      enter(decision_id)
+      receiver
+    end
+
+    # rubocop:disable-next Metrics/MethodLength
+    def flow_iteration_callback(decision_id, alternative_count = 2)
+      frame = iteration_frame(decision_id)
+      if frame
+        return nil if frame[:finished]
+
+        iteration_select(frame, alternative_count.to_i == 1 ? 0 : 1, alternative_count)
+      else
+        enter(decision_id)
+        begin
+          if alternative_count.to_i == 1
+            flow_select(decision_id, 0)
+          else
+            flow_path(decision_id, 1)
+          end
+        ensure
+          leave(decision_id)
+        end
+      end
+      nil
+    end
+
+    def flow_iteration_finish(decision_id, value, default_path = nil)
+      frame = iteration_frame(decision_id)
+      iteration_select(frame, default_path, 2) if frame && !frame[:finished] && !default_path.nil?
+      value
+    end
+
+    def flow_iteration_leave(decision_id)
+      frame = iteration_frame(decision_id)
+      frames = Thread.current[Branchproof::Runtime::FRAME_STATE_KEY]&.fetch(:frames, nil)
+      return nil unless frame && frames&.last.equal?(frame)
+
+      leave(decision_id)
+    end
+
+    private
+
+    # `current_frame` deliberately latches a diagnostic when a helper probes
+    # while another decision is active. Iteration callbacks may be deferred or
+    # nested, so an absent matching frame is an ordinary state here.
+    def iteration_frame(decision_id)
+      frames = Thread.current[Branchproof::Runtime::FRAME_STATE_KEY]&.fetch(:frames, nil)
+      index = frames ? frames.length - 1 : -1
+      while index >= 0
+        frame = frames[index]
+        return frame if frame[:decision_id] == decision_id
+
+        index -= 1
+      end
+      nil
+    end
+
+    def iteration_select(frame, index, alternative_count)
+      frame[:observations] = if alternative_count == 1
+                               [[0, true]]
+                             else
+                               [[0, index.zero?], [1, index == 1]]
+                             end
+      frame[:outcome] = true
+      frame[:finished] = true
+    end
+  end
+end

data/lib/branchproof/iteration_syntax.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Observe entry into source-visible callback bodies, not library internals.
+  module IterationSyntax
+    ITERATORS = %i[each each_with_index times upto downto step map collect select filter reject filter_map
+                   find detect find_index take_while drop_while partition count all? any? none? one? fetch].freeze
+
+    private
+
+    def flow_decision_node?(node)
+      iteration_node?(node) || node.is_a?(Prism::MatchRequiredNode) || super
+    end
+
+    def iteration_node?(node)
+      node.is_a?(Prism::ForNode) ||
+        (node.is_a?(Prism::CallNode) && ITERATORS.include?(node.name) &&
+         node.block.is_a?(Prism::BlockNode) && !node.safe_navigation?)
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def flow_details(node, bytes, encoding)
+      if node.is_a?(Prism::MatchRequiredNode)
+        alternatives = %w[matched mismatch].map { |label| iteration_alternative(node, label) }
+        return ["pattern", "required_pattern", alternatives,
+                { type: "required_pattern", range: byte_range(node.location) }, unsupported_reasons(node, bytes)]
+      end
+      return super unless iteration_node?(node)
+
+      body = node.is_a?(Prism::ForNode) ? node.statements : node.block.body
+      closing = node.is_a?(Prism::ForNode) ? node.end_keyword_loc : node.block.closing_loc
+      lazy = node.is_a?(Prism::CallNode) && lazy_receiver?(node.receiver)
+      fallback = node.is_a?(Prism::CallNode) && node.name == :fetch
+      context = if lazy
+                  "lazy_callback"
+                else
+                  (fallback ? "fetch_fallback" : "iteration")
+                end
+      labels = if lazy
+                 ["callback entered"]
+               else
+                 (fallback ? ["value present", "fallback entered"] : %w[empty entered])
+               end
+      metadata = { type: "iteration", range: byte_range(node.location), lazy: lazy,
+                   insert_at: iteration_insert_at(body, closing),
+                   empty: body.nil? }
+      metadata[:receiver] = byte_range(node.receiver.location) if node.is_a?(Prism::CallNode) && node.receiver
+      [lazy ? "multiway" : "implicit", context, labels.map { |label| iteration_alternative(node, label) },
+       metadata, unsupported_reasons(node, bytes)]
+    end
+
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    def lazy_receiver?(node)
+      node.is_a?(Prism::CallNode) && (node.name == :lazy || lazy_receiver?(node.receiver))
+    end
+
+    # Prism gives a block-level rescue/ensure BeginNode a location beginning at
+    # the `do` keyword. Inserting there would produce `call; callback; do`, so
+    # anchor the callback after the block parameters and before its statements.
+    def iteration_insert_at(body, closing)
+      return closing.start_offset unless body
+
+      if body.is_a?(Prism::BeginNode)
+        statements = body.statements
+        return statements.location.start_offset if statements&.location
+      end
+      body.location.start_offset
+    end
+
+    def iteration_alternative(node, label)
+      { expression: label, byte_start: node.location.start_offset, byte_length: node.location.length }
+    end
+  end
+end

data/lib/branchproof/loader.rb

@@ -47,7 +47,12 @@ module Branchproof
         add_diagnostic("source_drift", "selected source changed after inventory", unit[:source_id])
         return nil
       end
-      rewritten = @instrumenter.rewrite(unit: unit.merge(original_bytes: bytes))
+      begin
+        rewritten = @instrumenter.rewrite(unit: unit.merge(original_bytes: bytes))
+      rescue StandardError => e
+        add_diagnostic("rewrite_failure", "#{e.class}: #{e.message}", unit[:source_id], severity: "error")
+        return nil
+      end
       Array(rewritten[:diagnostics]).each do |diagnostic|
         add_diagnostic(diagnostic[:code], diagnostic[:message], unit[:source_id], severity: diagnostic[:severity])
       end

data/lib/branchproof/runtime.rb

@@ -2,6 +2,11 @@
 
 require "securerandom"
 require_relative "runtime_flow"
+require_relative "extended_alternative_runtime"
+require_relative "exception_runtime"
+require_relative "default_runtime"
+require_relative "value_runtime"
+require_relative "iteration_runtime"
 
 module Branchproof
   # Process-local execution recorder. It deliberately never coerces or stores
@@ -9,6 +14,11 @@ module Branchproof
   # Captures condition evaluations while preserving application values.
   module Runtime
     extend RuntimeFlow
+    extend ExtendedAlternativeRuntime
+    extend ExceptionRuntime
+    extend DefaultRuntime
+    extend ValueRuntime
+    extend IterationRuntime
 
     FRAME_STATE_KEY = :branchproof_runtime_frame_state