Struct BranchResolver 

pub struct BranchResolver<'a> { /* private fields */ }

Resolver for finding and recovering lost branches.

The resolver analyzes a trajectory DAG and state machine to find branches that exist in the data but are not actively tracked or have become inaccessible.

Algorithm

1. Discovery: Find all paths in the DAG that aren’t part of active branches
2. Scoring: Rank branches by potential value (length, depth, content)
3. Strategy: Suggest recovery strategies for each branch
4. Recovery: Execute the chosen recovery strategy

Example

let resolver = BranchResolver::new(&machine);

// Find all recoverable branches
let lost = resolver.find_recoverable_branches();

for branch in lost {
    println!("Found lost branch at {:?} with {} nodes",
             branch.fork_point, branch.nodes.len());

    // Recover using suggested strategy
    resolver.recover(&mut machine, &branch)?;
}

Implementations

impl<'a> BranchResolver<'a>

pub fn new(machine: &'a BranchStateMachine) -> Self

Create a new resolver for a state machine.

pub fn find_recoverable_branches(&self) -> Vec<RecoverableBranch>

Find all branches that could be recovered.

This analyzes the DAG to find paths that aren’t actively tracked in the state machine.

pub fn find_unselected_regenerations(&self) -> Vec<RecoverableBranch>

Find branches created by regeneration that weren’t selected.

pub fn recover( &self, machine: &mut BranchStateMachine, recoverable: &RecoverableBranch, ) -> Result<BranchId, BranchError>

Recover a lost branch using its suggested strategy.