branchproof 0.8.0 → 0.9.0

data/lib/branchproof/decision_syntax.rb

@@ -117,7 +117,8 @@ module Branchproof
                                    encoding),
             range: byte_range(candidate.location, splat_node?(candidate) ? "splat" : nil),
             byte_start: candidate.location.start_offset,
-            byte_length: candidate.location.length
+            byte_length: candidate.location.length,
+            splat: splat_node?(candidate)
           }
         end
         branches << {
@@ -142,9 +143,6 @@ module Branchproof
                           empty: statements_empty?(else_clause.statements) }
                       end
       reasons = unsupported_reasons(node, bytes)
-      reasons << "unsupported_case_splat" if candidates.any? do |candidate|
-        candidate[:range] && candidate[:range][:kind] == "splat"
-      end
       instrumentation = {
         type: "case",
         range: byte_range(node.location),
@@ -171,7 +169,6 @@ module Branchproof
         guarded = pattern.is_a?(Prism::IfNode) || pattern.is_a?(Prism::UnlessNode)
         guard = guarded ? pattern.predicate : nil
         pattern_node = guarded ? pattern.statements&.body&.first : pattern
-        reasons << "unsupported_pattern_guard" if guard
         candidate_node = pattern_node || pattern
         candidates << {
           expression: text_value(bytes.byteslice(candidate_node.location.start_offset, candidate_node.location.length),
@@ -233,16 +230,28 @@ module Branchproof
       rhs = node.value
       operator = bytes.byteslice(node.operator_loc.start_offset, node.operator_loc.length)
       assignment_context = operator == "||=" ? "or_assignment" : "and_assignment"
-      reasons = safe_navigation_assignment?(node) ? ["unsupported_assignment_target"] : []
+      safe_navigation = safe_navigation_assignment?(node)
+      reasons = []
       instrumentation = {
         type: "assignment",
         range: byte_range(node.location),
         rhs: byte_range(rhs.location),
         operator: operator,
         rhs_path: 1,
-        skipped_path: 0
+        skipped_path: 0,
+        receiver: safe_navigation && byte_range(node.receiver.location),
+        alternative_count: safe_navigation ? 3 : 2
       }
-      alternatives = if operator == "||="
+      alternatives = if safe_navigation
+                       skipped = operator == "||=" ? "LHS truthy; RHS skipped" : "LHS falsey; RHS skipped"
+                       executed = operator == "||=" ? "LHS falsey; RHS executed" : "LHS truthy; RHS executed"
+                       [{ expression: "receiver nil", byte_start: node.receiver.location.start_offset,
+                          byte_length: node.receiver.location.length },
+                        { expression: skipped, byte_start: node.location.start_offset,
+                          byte_length: node.location.length },
+                        { expression: executed, byte_start: node.location.start_offset,
+                          byte_length: node.location.length }]
+                     elsif operator == "||="
                        [{ expression: "LHS truthy; RHS skipped", byte_start: node.location.start_offset,
                           byte_length: node.location.length },
                         { expression: "LHS falsey; RHS executed", byte_start: node.location.start_offset,
@@ -253,7 +262,8 @@ module Branchproof
                         { expression: "LHS truthy; RHS executed", byte_start: node.location.start_offset,
                           byte_length: node.location.length }]
                      end
-      ["implicit", assignment_context, alternatives, instrumentation, unsupported_reasons(node, bytes) + reasons]
+      [safe_navigation ? "multiway" : "implicit", assignment_context, alternatives,
+       instrumentation, unsupported_reasons(node, bytes) + reasons]
     end
 
     def rescue_details(node, bytes, encoding)

data/lib/branchproof/default_instrumentation.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# Keep source-boundary and parameter-binding rules together for auditing.
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity
+
+module Branchproof
+  # Defaults stay inline in their original lexical scope. The owner decision
+  # makes body entry edits part of the same original AST edit tree as the
+  # parameter expression edits.
+  module DefaultInstrumentation
+    def rewrite(unit:)
+      decisions = Array(unit[:decisions])
+      defaults = decisions.select do |decision|
+        decision.dig(:instrumentation, :type) == "default" && supported?(decision)
+      end
+      return super unless defaults.any?
+
+      prepared = decisions.map do |decision|
+        next decision unless defaults.include?(decision)
+
+        instrumentation = decision[:instrumentation].merge(flag: default_flag(decision, unit[:original_bytes]))
+        decision.merge(instrumentation: instrumentation)
+      end
+      supported_ids = defaults.map { |decision| decision[:id] }
+      prepared_defaults = prepared.select do |decision|
+        decision.dig(:instrumentation, :type) == "default" && supported_ids.include?(decision[:id])
+      end
+      super(unit: unit.merge(decisions: owner_decisions(prepared, prepared_defaults)))
+    end
+
+    private
+
+    # An enclosing flow renderer can split a callable range at its own
+    # insertion point (for example an iteration callback inside a block). In
+    # that case the owner decision cannot be rendered as one child. Preserve
+    # the original offset by placing its supplied markers at the chunk that
+    # begins at the body entry.
+    def render_children(bytes, start, length, nested, encloses)
+      output = super
+      finish = start + length
+      crossing = nested.select do |child|
+        next false unless child.dig(:instrumentation, :type) == "default_owner"
+
+        owner = child.dig(:instrumentation, :owner)
+        owner && owner[:body_start] == start &&
+          (owner[:byte_start] < start || owner[:byte_start] + owner[:byte_length] > finish)
+      end
+      return output if crossing.empty?
+
+      marker = crossing.flat_map { |owner| owner_markers(owner, encloses[owner] || [], bytes) }.join
+      marker.empty? ? output : "#{marker}#{output}"
+    end
+
+    def encloses_decision?(outer, inner)
+      same_range = outer[:byte_start] == inner[:byte_start] && outer[:byte_length] == inner[:byte_length]
+      if same_range && inner.dig(:instrumentation, :type) == "default_owner"
+        return true unless outer.dig(:instrumentation, :type) == "default_owner"
+      elsif same_range && outer.dig(:instrumentation, :type) == "default_owner"
+        return false
+      end
+      super
+    end
+
+    def render_flow(bytes, decision, nested, encloses)
+      if decision.dig(:instrumentation, :type) == "default_owner"
+        return render_default_owner(bytes, decision, nested, encloses)
+      end
+      return super unless decision.dig(:instrumentation, :type) == "default"
+
+      value = decision.dig(:instrumentation, :value_range)
+      flag = decision.dig(:instrumentation, :flag) || default_flag(decision, bytes)
+      replacement = flow_replacement(bytes, value, nested, encloses) do |expression|
+        "(begin; #{flag} = true; #{self.class::RUNTIME}.default_binding(#{decision[:id].inspect}, 1); " \
+          "#{expression}; end)"
+      end
+      flow_fragments(bytes, decision, nested, [replacement], encloses)
+    end
+
+    def owner_decisions(decisions, defaults)
+      owners = defaults.group_by { |decision| decision.dig(:instrumentation, :owner) }
+      additions = owners.filter_map do |owner, grouped|
+        next unless owner
+
+        first = grouped.min_by { |decision| decision[:byte_start] }
+        next unless first
+
+        first.merge(
+          byte_start: owner[:byte_start], byte_length: owner[:byte_length],
+          expression: nil,
+          instrumentation: first[:instrumentation].merge(type: "default_owner")
+        )
+      end
+      (decisions + additions).sort_by { |decision| [decision[:byte_start], decision[:byte_length]] }
+    end
+
+    def render_default_owner(bytes, decision, nested, encloses)
+      owner = decision.dig(:instrumentation, :owner)
+      return super unless owner
+
+      bindings = nested.filter_map do |child|
+        next unless child.dig(:instrumentation, :type) == "default"
+        next unless child.dig(:instrumentation, :owner) == owner
+
+        [child.dig(:instrumentation, :flag) || default_flag(child, bytes), child[:id]]
+      end
+      marker = bindings.map do |flag, id|
+        "#{self.class::RUNTIME}.default_binding(#{id.inspect}, 0) unless #{flag}; "
+      end.join
+      return flow_fragments(bytes, decision, nested, [], encloses) if marker.empty?
+
+      start = owner[:body_start] || owner[:closing_start]
+      finish = (owner[:body_start] + owner[:body_length] if owner[:equal] && owner[:body_start] && owner[:body_length])
+      replacements = if finish
+                       [{ start: start, length: 0, text: "(begin; #{marker}" },
+                        { start: finish, length: 0, text: "; end)" }]
+                     else
+                       [{ start: start, length: 0, text: marker }]
+                     end
+      flow_fragments(bytes, decision, nested, replacements, encloses)
+    end
+
+    def owner_markers(owner, nested, bytes)
+      nested.filter_map do |child|
+        next unless child.dig(:instrumentation, :type) == "default"
+        next unless child.dig(:instrumentation, :owner) == owner.dig(:instrumentation, :owner)
+
+        flag = child.dig(:instrumentation, :flag) || default_flag(child, bytes)
+        "#{self.class::RUNTIME}.default_binding(#{child[:id].inspect}, 0) unless #{flag}; "
+      end
+    end
+
+    def default_flag(decision, bytes)
+      name = "__branchproof_default_#{decision[:id]}"
+      name += "_" while bytes.include?(name)
+      name
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity

data/lib/branchproof/default_runtime.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Binding events are immediate; no pending state survives a failed default.
+  module DefaultRuntime
+    def default_binding(decision_id, index)
+      enter(decision_id)
+      begin
+        flow_path(decision_id, index)
+      ensure
+        leave(decision_id)
+      end
+      nil
+    end
+  end
+end

data/lib/branchproof/default_syntax.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Each optional parameter has an independent supplied/defaulted obligation.
+  module DefaultSyntax
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    private
+
+    def flow_decision_node?(node)
+      @default_owner_by_node = {}.compare_by_identity if node.is_a?(Prism::ProgramNode)
+      register_default_owner(node) if default_owner_node?(node)
+      default_parameter_node?(node) || super
+    end
+
+    def flow_details(node, bytes, encoding)
+      return super unless default_parameter_node?(node)
+
+      value = node.value
+      alternatives = [
+        { expression: "#{node.name} supplied", byte_start: node.location.start_offset,
+          byte_length: node.location.length },
+        { expression: "#{node.name} default evaluated", byte_start: value.location.start_offset,
+          byte_length: value.location.length }
+      ]
+      owner = @default_owner_by_node && @default_owner_by_node[node]
+      metadata = { type: "default", value_range: byte_range(value.location) }
+      metadata[:owner] = owner if owner
+      ["implicit", "default_argument", alternatives, metadata, unsupported_reasons(node, bytes)]
+    end
+
+    def register_default_owner(owner)
+      @default_owner_by_node ||= {}.compare_by_identity
+      parameters = owner.parameters if owner.respond_to?(:parameters)
+      parameters = parameters.parameters if parameters.is_a?(Prism::BlockParametersNode)
+      return unless parameters.is_a?(Prism::ParametersNode)
+
+      details = default_owner_details(owner)
+      (Array(parameters.optionals) + Array(parameters.keywords)).each do |parameter|
+        next unless default_parameter_node?(parameter)
+
+        @default_owner_by_node[parameter] = details
+      end
+    end
+
+    def default_parameter_node?(node)
+      node.is_a?(Prism::OptionalParameterNode) || node.is_a?(Prism::OptionalKeywordParameterNode)
+    end
+
+    def default_owner_node?(node)
+      node.is_a?(Prism::DefNode) || node.is_a?(Prism::LambdaNode) || node.is_a?(Prism::BlockNode)
+    end
+
+    def default_owner_details(owner)
+      return nil unless owner
+
+      # Only endless `def name(...) = expr` has a body that can be wrapped as
+      # one expression. Lambda/block `closing_loc` values are delimiters, not
+      # endless-definition markers, and must stay on the statement path.
+      equal_loc = owner.is_a?(Prism::DefNode) && owner.equal_loc
+      closing = if owner.is_a?(Prism::DefNode)
+                  owner.end_keyword_loc
+                else
+                  owner.closing_loc
+                end
+      body_start, body_length = default_owner_body_span(owner, closing)
+      details = { byte_start: owner.location.start_offset, byte_length: owner.location.length,
+                  equal: equal_loc ? true : false, body_start: body_start,
+                  body_length: body_length, closing_start: closing&.start_offset }
+      details.freeze
+    end
+
+    # Prism represents a method-level `rescue`/`ensure` as an implicit
+    # BeginNode whose location covers the whole def. Its insertion point is
+    # the actual statements (or rescue/ensure clause), not the def keyword.
+    def default_owner_body_span(owner, closing)
+      body = owner.body
+      if body.is_a?(Prism::BeginNode) && body.begin_keyword_loc.nil?
+        statements = body.statements
+        start = implicit_begin_start(statements, body, closing)
+        finish = closing&.start_offset || (body.location.start_offset + body.location.length)
+        return [start, start && finish ? [finish - start, 0].max : nil]
+      end
+
+      [body&.location&.start_offset, body&.location&.length]
+    end
+
+    def implicit_begin_start(statements, body, closing)
+      [statements&.location&.start_offset, body.rescue_clause&.location&.start_offset,
+       body.ensure_clause&.location&.start_offset, closing&.start_offset].compact.first
+    end
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+end

data/lib/branchproof/evidence.rb

@@ -34,6 +34,7 @@ module Branchproof
       @run_payloads = {}
       @abort_counts = Hash.new(0)
       @diagnostics = []
+      @repetition_cache = {}
       @limited = false
       @attribution_complete = true
     end
@@ -55,6 +56,10 @@ module Branchproof
     end
 
     def record(execution:)
+      if (cached = cached_execution(execution))
+        return record_cached(cached)
+      end
+
       value = symbolize(execution)
       reason = validate_execution(value)
       return reject_record(reason) if reason
@@ -102,6 +107,8 @@ module Branchproof
         phase = value[:phase].to_s
         test[:phase_counts][phase] = test[:phase_counts].fetch(phase, 0) + 1
       end
+      cache_key = execution_cache_key(value)
+      @repetition_cache[cache_key[1]] = { key: cache_key, vector_id: vector_id }
       status("recorded", nil)
     rescue StandardError => e
       diagnose(diagnostic: { code: "record_failure", severity: "error", message: e.message })
@@ -167,6 +174,7 @@ module Branchproof
       @abort_counts.merge!(incoming.fetch(:abort_counts, {})) { |_k, a, b| a.to_i + b.to_i }
       @limited ||= !incoming.dig(:completeness, :observation)
       @attribution_complete &&= incoming.dig(:completeness, :attribution) ? true : false
+      @repetition_cache.clear
       status("merged", nil)
     rescue StandardError => e
       restore_state(backup) if backup
@@ -518,7 +526,8 @@ module Branchproof
       { vectors: deep_dup(@vectors), tests: deep_dup(@tests), run_ids: @run_ids.dup,
         run_payloads: @run_payloads.dup, diagnostics: deep_dup(@diagnostics),
         abort_counts: @abort_counts.dup, limited: @limited, attribution_complete: @attribution_complete,
-        vector_counts_by_decision: @vector_counts_by_decision.dup, owner_associations_count: @owner_associations_count }
+        vector_counts_by_decision: @vector_counts_by_decision.dup, owner_associations_count: @owner_associations_count,
+        repetition_cache: deep_dup(@repetition_cache) }
     end
 
     def restore_state(state)
@@ -530,10 +539,83 @@ module Branchproof
       @abort_counts = state[:abort_counts]
       @vector_counts_by_decision = state[:vector_counts_by_decision]
       @owner_associations_count = state[:owner_associations_count]
+      @repetition_cache = state[:repetition_cache]
       @limited = state[:limited]
       @attribution_complete = state[:attribution_complete]
     end
 
+    def cached_execution(execution)
+      return nil unless execution.is_a?(Hash)
+
+      key = raw_execution_cache_key(execution)
+      return nil unless key
+
+      entry = @repetition_cache[key[1]]
+      return nil unless entry && entry[:key] == key
+
+      vector = @vectors[entry[:vector_id]]
+      return nil unless vector
+
+      [key, vector, raw_execution_attribution(execution)]
+    end
+
+    def record_cached(cached)
+      _key, vector, value = cached
+      vector[:count] += 1
+      if value[:test_id] && @tests.key?(value[:test_id].to_s)
+        test = @tests[value[:test_id].to_s]
+        phase = value[:phase].to_s
+        test[:phase_counts][phase] = test[:phase_counts].fetch(phase, 0) + 1
+      end
+      vector[:unattributed_count] += 1 unless value[:test_id]
+      status("recorded", nil)
+    end
+
+    def raw_execution_cache_key(execution)
+      required = %i[run_id decision_id test_id phase observations outcome status]
+      return nil unless required.all? { |key| execution.key?(key) || execution.key?(key.to_s) }
+
+      status = raw_value(execution, :status)
+      outcome = raw_value(execution, :outcome)
+      return nil unless status.to_s == "completed" && [true, false].include?(outcome)
+
+      observations = raw_value(execution, :observations)
+      return nil unless observations.is_a?(Array)
+
+      test_id = raw_value(execution, :test_id)
+      [raw_value(execution, :run_id).to_s, raw_value(execution, :decision_id).to_s,
+       test_id_marker(test_id), test_id&.to_s, raw_value(execution, :phase).to_s,
+       observations, outcome, status.to_s]
+    end
+
+    def execution_cache_key(value)
+      key = [copy_string(value[:run_id]), copy_string(value[:decision_id]), test_id_marker(value[:test_id]),
+             copy_string(value[:test_id]),
+             copy_string(value[:phase]), deep_dup(value[:observations]), value[:outcome], copy_string(value[:status])]
+      deep_freeze(key)
+    end
+
+    def raw_execution_attribution(execution)
+      { test_id: raw_value(execution, :test_id), phase: raw_value(execution, :phase) }
+    end
+
+    def copy_string(value)
+      value.nil? ? nil : value.to_s.dup
+    end
+
+    def test_id_marker(value)
+      return :nil if value.nil?
+      return :false_test_id if value == false
+
+      :present
+    end
+
+    def raw_value(hash, key)
+      return hash[key] if hash.key?(key)
+
+      hash[key.to_s]
+    end
+
     def deep_freeze(value)
       case value
       when Hash then value.each do |key, item|

data/lib/branchproof/exception_instrumentation.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Style/ConditionalAssignment
+
+require_relative "flow_instrumentation"
+
+module Branchproof
+  # Textual edits for native rescue control flow.  The edits only add calls at
+  # Ruby's own protected-region and handler boundaries; exception matching,
+  # `$!`, retry, ensure ordering, and nonlocal transfers remain Ruby-owned.
+  module ExceptionInstrumentation
+    private
+
+    def render_flow(bytes, decision, nested, encloses)
+      metadata = decision.fetch(:instrumentation)
+      return super unless %w[exception rescue_modifier].include?(metadata[:type])
+
+      if metadata[:type] == "exception"
+        render_exception_flow(bytes, decision, nested, encloses)
+      else
+        render_rescue_modifier_flow(bytes, decision, nested, encloses)
+      end
+    end
+
+    def render_exception_flow(bytes, decision, nested, encloses)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      metadata = decision.fetch(:instrumentation)
+      replacements = []
+      if metadata[:normal_insert_at] && !metadata[:normal_empty]
+        replacements << { start: metadata.fetch(:normal_insert_at), length: 0,
+                          text: "; #{runtime}.exception_path(#{identifier}, 0); " }
+      elsif metadata[:normal_transfer]
+        transfer = metadata.fetch(:normal_transfer)
+        if transfer[:arguments]
+          replacements << flow_replacement(bytes, transfer.fetch(:arguments), nested, encloses) do |arguments|
+            value = transfer[:argument_mode] == :array ? "[#{arguments}]" : "(#{arguments})"
+            "#{runtime}.exception_value(#{identifier}, #{value}, 0)"
+          end
+        else
+          replacements << { start: transfer.fetch(:insert_at), length: 0,
+                            text: "#{runtime}.exception_path(#{identifier}, 0); " }
+        end
+      elsif metadata[:normal_body] && metadata[:normal_body][:byte_length].positive?
+        replacements << flow_replacement(bytes, metadata.fetch(:normal_body), nested, encloses) do |body|
+          "#{runtime}.exception_value(#{identifier}, (begin; #{body}; end), 0)"
+        end
+      end
+      metadata.fetch(:clauses).each do |clause|
+        replacements << { start: clause.fetch(:insert_at), length: 0,
+                          text: "; #{runtime}.exception_path(#{identifier}, #{clause.fetch(:index)}); " }
+      end
+      if metadata[:implicit]
+        entry = "begin; #{runtime}.exception_enter(#{identifier}, #{metadata.fetch(:unhandled_index)}); begin; "
+        entry += "#{runtime}.exception_path(#{identifier}, 0); " if metadata[:normal_empty]
+        entry += metadata[:iteration_callback].fetch(:text) if metadata[:iteration_callback]
+        exit = "; end; rescue ::Exception; #{runtime}.exception_unhandled(#{identifier}); raise; ensure; " \
+               "#{runtime}.exception_leave(#{identifier}); end; "
+        replacements << { start: metadata.fetch(:entry_insert_at), length: 0, text: entry }
+        replacements << { start: metadata.fetch(:exit_insert_at), length: 0, text: exit }
+        flow_fragments(bytes, decision, nested, replacements, encloses)
+      else
+        expression = flow_fragments(bytes, decision, nested, replacements, encloses)
+        exception_frame(decision[:id], expression, metadata.fetch(:unhandled_index))
+      end
+    end
+
+    def render_rescue_modifier_flow(bytes, decision, nested, encloses)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      metadata = decision.fetch(:instrumentation)
+      lhs = metadata.fetch(:expression)
+      rhs = metadata.fetch(:rescue_expression)
+      replacements = [
+        flow_replacement(bytes, lhs, nested, encloses) do |expression|
+          "#{runtime}.exception_value(#{identifier}, (#{expression}), 0)"
+        end,
+        flow_replacement(bytes, rhs, nested, encloses) do |expression|
+          "(begin; #{runtime}.exception_path(#{identifier}, 1); (#{expression}); end)"
+        end
+      ]
+      exception_frame(decision[:id], flow_fragments(bytes, decision, nested, replacements, encloses),
+                      metadata.fetch(:unhandled_index))
+    end
+
+    def exception_frame(decision_id, expression, unhandled_index)
+      runtime = self.class::RUNTIME
+      "(begin; #{runtime}.exception_enter(#{decision_id.inspect}, #{unhandled_index}); begin; " \
+        "#{expression}; " \
+        "rescue ::Exception; #{runtime}.exception_unhandled(#{decision_id.inspect}); raise; ensure; " \
+        "#{runtime}.exception_leave(#{decision_id.inspect}); end; end)"
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Style/ConditionalAssignment

data/lib/branchproof/exception_runtime.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Record native clause selection and escaping exceptions. Generated wrappers
+  # re-raise the same exception; nonlocal transfers remain aborted observations.
+  module ExceptionRuntime
+    def exception_enter(decision_id, unhandled_index)
+      enter(decision_id)
+      frame = current_frame(decision_id)
+      frame[:exception_unhandled_index] = unhandled_index if frame
+      nil
+    end
+
+    def exception_path(decision_id, index)
+      frame = current_frame(decision_id)
+      flow_select(decision_id, index) if frame && !frame[:finished]
+      nil
+    end
+
+    def exception_value(decision_id, value, index)
+      exception_path(decision_id, index)
+      value
+    end
+
+    def exception_finish(decision_id, value)
+      frame = current_frame(decision_id)
+      exception_path(decision_id, 0) if frame && !frame[:finished]
+      value
+    end
+
+    def exception_unhandled(decision_id)
+      frame = current_frame(decision_id)
+      exception_path(decision_id, frame[:exception_unhandled_index]) if frame && !frame[:finished]
+      nil
+    end
+
+    def exception_leave(decision_id)
+      leave(decision_id)
+    end
+  end
+end