branchproof 0.6.0 → 0.8.0

data/lib/branchproof/runtime.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
 require "securerandom"
+require_relative "runtime_flow"
 
 module Branchproof
   # Process-local execution recorder. It deliberately never coerces or stores
   # application values: Ruby's conditional expression is used for truthiness.
   # Captures condition evaluations while preserving application values.
   module Runtime
+    extend RuntimeFlow
+
+    FRAME_STATE_KEY = :branchproof_runtime_frame_state
+
     class << self
       def boot(evidence:)
         return nil if defined?(@booted) && @booted && @evidence.equal?(evidence) && Process.pid == @process_id
@@ -14,8 +19,6 @@ module Branchproof
         @evidence = evidence
         @run_id = evidence.respond_to?(:run_id) ? evidence.run_id.to_s : SecureRandom.hex(16)
         @process_id = Process.pid
-        @frames = {}
-        @contexts = {}
         @diagnostics = []
         @storage_disabled = false
         @booted = true
@@ -23,9 +26,8 @@ module Branchproof
       end
 
       def enter(decision_id)
-        state[:frames] << { decision_id: String(decision_id), context: state[:context]&.dup,
-                            observations: [], outcome: nil, finished: false,
-                            execution_id: SecureRandom.hex(12) }
+        state[:frames] << { decision_id: decision_id, context: state[:context]&.dup,
+                            observations: [], outcome: nil, finished: false }
         nil
       end
 
@@ -33,7 +35,7 @@ module Branchproof
         frame = current_frame(decision_id)
         if frame
           truth = value ? true : false
-          frame[:observations] << [Integer(index), truth]
+          frame[:observations] << [index, truth]
         end
         value
       end
@@ -48,9 +50,10 @@ module Branchproof
       end
 
       def leave(decision_id)
+        detect_fork
         frames = state[:frames]
         frame = frames.pop
-        unless frame && frame[:decision_id] == String(decision_id)
+        unless frame && frame[:decision_id] == decision_id
           latch("runtime_frame_mismatch", "decision frame stack is not balanced")
           cleanup_state
           return nil
@@ -59,12 +62,10 @@ module Branchproof
 
         execution = {
           run_id: @run_id,
-          execution_id: frame[:execution_id],
           decision_id: frame[:decision_id],
           test_id: frame[:context]&.fetch(:test_id, nil),
           phase: frame[:context]&.fetch(:phase, "unattributed") || "unattributed",
-          owner: owner_tuple,
-          observations: frame[:observations].map(&:dup),
+          observations: frame[:observations],
           outcome: frame[:finished] ? frame[:outcome] : nil,
           status: frame[:finished] ? "completed" : "aborted"
         }
@@ -117,38 +118,32 @@ module Branchproof
       private
 
       def state
-        @frames ||= {}
-        if @process_id && Process.pid != @process_id
-          @process_id = Process.pid
-          @run_id = SecureRandom.hex(16)
-          @frames = {}
-          @diagnostics = [{ code: "forked_process", severity: "error",
-                            message: "runtime process identity changed; evidence storage disabled",
-                            source_id: nil, decision_id: nil, execution_id: nil, test_id: nil, details: {} }]
-          @storage_disabled = true
-        end
-        key = [Process.pid, Thread.current, Fiber.current]
-        @frames[key] ||= { frames: [], context: nil }
+        Thread.current[FRAME_STATE_KEY] ||= { frames: [], context: nil }
       end
 
       def cleanup_state
-        key = [Process.pid, Thread.current, Fiber.current]
-        current = @frames[key]
-        @frames.delete(key) if current && current[:frames].empty? && current[:context].nil?
+        current = Thread.current[FRAME_STATE_KEY]
+        Thread.current[FRAME_STATE_KEY] = nil if current && current[:frames].empty? && current[:context].nil?
+      end
+
+      def detect_fork
+        return unless @process_id && Process.pid != @process_id
+
+        @process_id = Process.pid
+        @diagnostics = [{ code: "forked_process", severity: "error",
+                          message: "runtime process identity changed; evidence storage disabled",
+                          source_id: nil, decision_id: nil, execution_id: nil, test_id: nil, details: {} }]
+        @storage_disabled = true
       end
 
       def current_frame(decision_id)
         frame = state[:frames].last
-        return frame if frame && frame[:decision_id] == String(decision_id)
+        return frame if frame && frame[:decision_id] == decision_id
 
         latch("runtime_frame_mismatch", "no active frame for #{decision_id}") if frame
         nil
       end
 
-      def owner_tuple
-        { process_id: Process.pid, thread_id: Thread.current.object_id, fiber_id: Fiber.current.object_id }
-      end
-
       def safely_record(execution)
         result = @evidence.record(execution: execution)
         unless result.is_a?(Hash) && result[:status].to_s == "recorded"

data/lib/branchproof/runtime_flow.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Records native Ruby path selection without evaluating application values twice.
+  module RuntimeFlow
+    def flow_candidate(decision_id, index)
+      frame = current_frame(decision_id)
+      frame[:observations] << [index, false] if frame
+      nil
+    end
+
+    def flow_selected(decision_id)
+      frame = current_frame(decision_id)
+      if frame && !frame[:observations].empty?
+        frame[:observations].last[1] = true
+        frame[:outcome] = true
+        frame[:finished] = true
+      end
+      nil
+    end
+
+    def flow_select(decision_id, index)
+      frame = current_frame(decision_id)
+      if frame
+        frame[:observations] = (0..index).map { |position| [position, position == index] }
+        frame[:outcome] = true
+        frame[:finished] = true
+      end
+      nil
+    end
+
+    def flow_path(decision_id, index)
+      frame = current_frame(decision_id)
+      if frame
+        frame[:observations] = [[0, index.zero?], [1, index == 1]]
+        frame[:outcome] = true
+        frame[:finished] = true
+      end
+      nil
+    end
+
+    def flow_finish(decision_id, value, default_path = nil)
+      frame = current_frame(decision_id)
+      flow_path(decision_id, default_path) if frame && !frame[:finished] && !default_path.nil?
+      value
+    end
+
+    def flow_receiver(decision_id, receiver)
+      enter(decision_id)
+      begin
+        flow_path(decision_id, nil.equal?(receiver) ? 0 : 1)
+      ensure
+        leave(decision_id)
+      end
+      receiver
+    end
+  end
+end