diff --git a/crates/gitbutler-branch-actions/src/actions.rs b/crates/gitbutler-branch-actions/src/actions.rs
index e756f119f..4809a5cfc 100644
--- a/crates/gitbutler-branch-actions/src/actions.rs
+++ b/crates/gitbutler-branch-actions/src/actions.rs
@@ -1,14 +1,12 @@
-use super::r#virtual as branch;
-use crate::branch::get_uncommited_files_raw;
+use super::r#virtual as vbranch;
+use crate::branch;
 use crate::{
-    base::{
-        get_base_branch_data, set_base_branch, set_target_push_remote, update_base_branch,
-        BaseBranch,
-    },
-    branch::get_uncommited_files,
+    base,
+    base::BaseBranch,
     branch_manager::BranchManagerExt,
     file::RemoteBranchFile,
-    remote::{get_branch_data, list_local_branches, RemoteBranch, RemoteBranchData},
+    remote,
+    remote::{RemoteBranch, RemoteBranchData},
     VirtualBranchesExt,
 };
 use anyhow::{Context, Result};
@@ -28,592 +26,506 @@ use gitbutler_repo::{RepoActionsExt, RepositoryExt};
 use std::path::PathBuf;
 use tracing::instrument;
 
-#[derive(Clone, Copy, Default)]
-pub struct VirtualBranchActions;
-
-impl VirtualBranchActions {
-    pub fn create_commit(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        message: &str,
-        ownership: Option<&BranchOwnershipClaims>,
-        run_hooks: bool,
-    ) -> Result<git2::Oid> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Creating a commit requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let snapshot_tree = ctx.project().prepare_snapshot(guard.read_permission());
-        let result =
-            branch::commit(&ctx, branch_id, message, ownership, run_hooks).map_err(Into::into);
-        let _ = snapshot_tree.and_then(|snapshot_tree| {
-            ctx.project().snapshot_commit_creation(
-                snapshot_tree,
-                result.as_ref().err(),
-                message.to_owned(),
-                None,
-                guard.write_permission(),
-            )
-        });
-        result
-    }
-
-    pub fn can_apply_remote_branch(
-        &self,
-        project: &Project,
-        branch_name: &RemoteRefname,
-    ) -> Result<bool> {
-        let ctx = CommandContext::open(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Testing branch mergability requires open workspace mode")?;
-        branch::is_remote_branch_mergeable(&ctx, branch_name).map_err(Into::into)
-    }
-
-    pub fn list_virtual_branches(
-        &self,
-        project: &Project,
-    ) -> Result<(Vec<branch::VirtualBranch>, Vec<gitbutler_diff::FileDiff>)> {
-        let ctx = open_with_verify(project)?;
-
-        assure_open_workspace_mode(&ctx)
-            .context("Listing virtual branches requires open workspace mode")?;
-
-        branch::list_virtual_branches(&ctx, project.exclusive_worktree_access().write_permission())
-            .map_err(Into::into)
-    }
-
-    pub fn list_virtual_branches_cached(
-        &self,
-        project: &Project,
-        worktree_changes: Option<DiffByPathMap>,
-    ) -> Result<(Vec<branch::VirtualBranch>, Vec<gitbutler_diff::FileDiff>)> {
-        let ctx = open_with_verify(project)?;
-
-        assure_open_workspace_mode(&ctx)
-            .context("Listing virtual branches requires open workspace mode")?;
-
-        branch::list_virtual_branches_cached(
-            &ctx,
-            project.exclusive_worktree_access().write_permission(),
-            worktree_changes,
+pub fn create_commit(
+    project: &Project,
+    branch_id: BranchId,
+    message: &str,
+    ownership: Option<&BranchOwnershipClaims>,
+    run_hooks: bool,
+) -> Result<git2::Oid> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Creating a commit requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let snapshot_tree = ctx.project().prepare_snapshot(guard.read_permission());
+    let result =
+        vbranch::commit(&ctx, branch_id, message, ownership, run_hooks).map_err(Into::into);
+    let _ = snapshot_tree.and_then(|snapshot_tree| {
+        ctx.project().snapshot_commit_creation(
+            snapshot_tree,
+            result.as_ref().err(),
+            message.to_owned(),
+            None,
+            guard.write_permission(),
         )
+    });
+    result
+}
+
+pub fn can_apply_remote_branch(project: &Project, branch_name: &RemoteRefname) -> Result<bool> {
+    let ctx = CommandContext::open(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Testing branch mergability requires open workspace mode")?;
+    vbranch::is_remote_branch_mergeable(&ctx, branch_name).map_err(Into::into)
+}
+
+pub fn list_virtual_branches(
+    project: &Project,
+) -> Result<(Vec<vbranch::VirtualBranch>, Vec<gitbutler_diff::FileDiff>)> {
+    let ctx = open_with_verify(project)?;
+
+    assure_open_workspace_mode(&ctx)
+        .context("Listing virtual branches requires open workspace mode")?;
+
+    vbranch::list_virtual_branches(&ctx, project.exclusive_worktree_access().write_permission())
         .map_err(Into::into)
-    }
+}
 
-    pub fn create_virtual_branch(
-        &self,
-        project: &Project,
-        create: &BranchCreateRequest,
-    ) -> Result<BranchId> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Creating a branch requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let branch_manager = ctx.branch_manager();
-        let branch_id = branch_manager
-            .create_virtual_branch(create, guard.write_permission())?
-            .id;
-        Ok(branch_id)
-    }
+pub fn list_virtual_branches_cached(
+    project: &Project,
+    worktree_changes: Option<DiffByPathMap>,
+) -> Result<(Vec<vbranch::VirtualBranch>, Vec<gitbutler_diff::FileDiff>)> {
+    let ctx = open_with_verify(project)?;
 
-    /// Deletes a local branch reference and it's associated virtual branch.
-    /// If there is a virtual branch and it is applied, this function will return an error.
-    /// If there is no such local reference, this function will return an error.
-    pub fn delete_local_branch(
-        &self,
-        project: &Project,
-        refname: &Refname,
-        given_name: String,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        let repo = ctx.repository();
-        let handle = ctx.project().virtual_branches();
-        let vbranch = handle.list_all_branches()?.into_iter().find(|branch| {
-            branch
-                .source_refname
-                .as_ref()
-                .map_or(false, |source_refname| source_refname == refname)
-        });
+    assure_open_workspace_mode(&ctx)
+        .context("Listing virtual branches requires open workspace mode")?;
 
-        if let Some(vbranch) = vbranch {
-            // Disallow deletion of branches that are applied in workspace
-            if vbranch.in_workspace {
-                return Err(anyhow::anyhow!(
-                    "Cannot delete a branch that is applied in workspace"
-                ));
-            }
-            // Deletes the virtual branch entry from the application state
-            handle.delete_branch_entry(&vbranch.id)?;
+    vbranch::list_virtual_branches_cached(
+        &ctx,
+        project.exclusive_worktree_access().write_permission(),
+        worktree_changes,
+    )
+    .map_err(Into::into)
+}
+
+pub fn create_virtual_branch(project: &Project, create: &BranchCreateRequest) -> Result<BranchId> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Creating a branch requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let branch_manager = ctx.branch_manager();
+    let branch_id = branch_manager
+        .create_virtual_branch(create, guard.write_permission())?
+        .id;
+    Ok(branch_id)
+}
+
+/// Deletes a local branch reference and it's associated virtual branch.
+/// If there is a virtual branch and it is applied, this function will return an error.
+/// If there is no such local reference, this function will return an error.
+pub fn delete_local_branch(project: &Project, refname: &Refname, given_name: String) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    let repo = ctx.repository();
+    let handle = ctx.project().virtual_branches();
+    let vbranch = handle.list_all_branches()?.into_iter().find(|branch| {
+        branch
+            .source_refname
+            .as_ref()
+            .map_or(false, |source_refname| source_refname == refname)
+    });
+
+    if let Some(vbranch) = vbranch {
+        // Disallow deletion of branches that are applied in workspace
+        if vbranch.in_workspace {
+            return Err(anyhow::anyhow!(
+                "Cannot delete a branch that is applied in workspace"
+            ));
         }
-
-        // If a branch reference for this can be found, delete it
-        if let Ok(mut branch) = repo.find_branch(&given_name, git2::BranchType::Local) {
-            branch.delete()?;
-        };
-        Ok(())
+        // Deletes the virtual branch entry from the application state
+        handle.delete_branch_entry(&vbranch.id)?;
     }
 
-    #[instrument(skip(project), err(Debug))]
-    pub fn get_base_branch_data(project: &Project) -> Result<BaseBranch> {
-        let ctx = CommandContext::open(project)?;
-        get_base_branch_data(&ctx)
-    }
+    // If a branch reference for this can be found, delete it
+    if let Ok(mut branch) = repo.find_branch(&given_name, git2::BranchType::Local) {
+        branch.delete()?;
+    };
+    Ok(())
+}
 
-    pub fn list_remote_commit_files(
-        &self,
-        project: &Project,
-        commit_oid: git2::Oid,
-    ) -> Result<Vec<RemoteBranchFile>> {
-        let ctx = CommandContext::open(project)?;
-        crate::file::list_remote_commit_files(ctx.repository(), commit_oid).map_err(Into::into)
-    }
+#[instrument(skip(project), err(Debug))]
+pub fn get_base_branch_data(project: &Project) -> Result<BaseBranch> {
+    let ctx = CommandContext::open(project)?;
+    base::get_base_branch_data(&ctx)
+}
 
-    pub fn set_base_branch(
-        &self,
-        project: &Project,
-        target_branch: &RemoteRefname,
-    ) -> Result<BaseBranch> {
-        let ctx = CommandContext::open(project)?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::SetBaseBranch),
+pub fn list_remote_commit_files(
+    project: &Project,
+    commit_oid: git2::Oid,
+) -> Result<Vec<RemoteBranchFile>> {
+    let ctx = CommandContext::open(project)?;
+    crate::file::list_remote_commit_files(ctx.repository(), commit_oid).map_err(Into::into)
+}
+
+pub fn set_base_branch(project: &Project, target_branch: &RemoteRefname) -> Result<BaseBranch> {
+    let ctx = CommandContext::open(project)?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::SetBaseBranch),
+        guard.write_permission(),
+    );
+    base::set_base_branch(&ctx, target_branch)
+}
+
+pub fn set_target_push_remote(project: &Project, push_remote: &str) -> Result<()> {
+    let ctx = CommandContext::open(project)?;
+    base::set_target_push_remote(&ctx, push_remote)
+}
+
+pub fn integrate_upstream_commits(project: &Project, branch_id: BranchId) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Integrating upstream commits requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::MergeUpstream),
+        guard.write_permission(),
+    );
+    vbranch::integrate_upstream_commits(&ctx, branch_id).map_err(Into::into)
+}
+
+pub fn update_base_branch(project: &Project) -> Result<Vec<ReferenceName>> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Updating base branch requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::UpdateWorkspaceBase),
+        guard.write_permission(),
+    );
+    base::update_base_branch(&ctx, guard.write_permission()).map_err(Into::into)
+}
+
+pub fn update_virtual_branch(project: &Project, branch_update: BranchUpdateRequest) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Updating a branch requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let snapshot_tree = ctx.project().prepare_snapshot(guard.read_permission());
+    let old_branch = ctx
+        .project()
+        .virtual_branches()
+        .get_branch_in_workspace(branch_update.id)?;
+    let result = vbranch::update_branch(&ctx, &branch_update);
+    let _ = snapshot_tree.and_then(|snapshot_tree| {
+        ctx.project().snapshot_branch_update(
+            snapshot_tree,
+            &old_branch,
+            &branch_update,
+            result.as_ref().err(),
             guard.write_permission(),
-        );
-        set_base_branch(&ctx, target_branch)
-    }
+        )
+    });
+    result?;
+    Ok(())
+}
 
-    pub fn set_target_push_remote(&self, project: &Project, push_remote: &str) -> Result<()> {
-        let ctx = CommandContext::open(project)?;
-        set_target_push_remote(&ctx, push_remote)
-    }
-
-    pub fn integrate_upstream_commits(&self, project: &Project, branch_id: BranchId) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Integrating upstream commits requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::MergeUpstream),
-            guard.write_permission(),
-        );
-        branch::integrate_upstream_commits(&ctx, branch_id).map_err(Into::into)
-    }
-
-    pub fn update_base_branch(&self, project: &Project) -> Result<Vec<ReferenceName>> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Updating base branch requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::UpdateWorkspaceBase),
-            guard.write_permission(),
-        );
-        update_base_branch(&ctx, guard.write_permission()).map_err(Into::into)
-    }
-
-    pub fn update_virtual_branch(
-        &self,
-        project: &Project,
-        branch_update: BranchUpdateRequest,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Updating a branch requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let snapshot_tree = ctx.project().prepare_snapshot(guard.read_permission());
-        let old_branch = ctx
+pub fn update_branch_order(
+    project: &Project,
+    branch_updates: Vec<BranchUpdateRequest>,
+) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Updating branch order requires open workspace mode")?;
+    for branch_update in branch_updates {
+        let branch = ctx
             .project()
             .virtual_branches()
             .get_branch_in_workspace(branch_update.id)?;
-        let result = branch::update_branch(&ctx, &branch_update);
-        let _ = snapshot_tree.and_then(|snapshot_tree| {
-            ctx.project().snapshot_branch_update(
-                snapshot_tree,
-                &old_branch,
-                &branch_update,
-                result.as_ref().err(),
-                guard.write_permission(),
-            )
-        });
-        result?;
-        Ok(())
-    }
-
-    pub fn update_branch_order(
-        &self,
-        project: &Project,
-        branch_updates: Vec<BranchUpdateRequest>,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Updating branch order requires open workspace mode")?;
-        for branch_update in branch_updates {
-            let branch = ctx
-                .project()
-                .virtual_branches()
-                .get_branch_in_workspace(branch_update.id)?;
-            if branch_update.order != Some(branch.order) {
-                branch::update_branch(&ctx, &branch_update)?;
-            }
+        if branch_update.order != Some(branch.order) {
+            vbranch::update_branch(&ctx, &branch_update)?;
         }
-        Ok(())
     }
+    Ok(())
+}
 
-    pub fn delete_virtual_branch(&self, project: &Project, branch_id: BranchId) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Deleting a branch order requires open workspace mode")?;
-        let branch_manager = ctx.branch_manager();
-        let mut guard = project.exclusive_worktree_access();
-        let default_target = ctx.project().virtual_branches().get_default_target()?;
-        let target_commit = ctx.repository().find_commit(default_target.sha)?;
-        branch_manager.delete_branch(branch_id, guard.write_permission(), &target_commit)
-    }
+pub fn delete_virtual_branch(project: &Project, branch_id: BranchId) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Deleting a branch order requires open workspace mode")?;
+    let branch_manager = ctx.branch_manager();
+    let mut guard = project.exclusive_worktree_access();
+    let default_target = ctx.project().virtual_branches().get_default_target()?;
+    let target_commit = ctx.repository().find_commit(default_target.sha)?;
+    branch_manager.delete_branch(branch_id, guard.write_permission(), &target_commit)
+}
 
-    pub fn unapply_ownership(
-        &self,
-        project: &Project,
-        ownership: &BranchOwnershipClaims,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx).context("Unapply a patch requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::DiscardHunk),
+pub fn unapply_ownership(project: &Project, ownership: &BranchOwnershipClaims) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Unapply a patch requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::DiscardHunk),
+        guard.write_permission(),
+    );
+    vbranch::unapply_ownership(&ctx, ownership, guard.write_permission()).map_err(Into::into)
+}
+
+pub fn reset_files(project: &Project, branch_id: BranchId, files: &[PathBuf]) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Resetting a file requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::DiscardFile),
+        guard.write_permission(),
+    );
+    vbranch::reset_files(&ctx, branch_id, files, guard.write_permission()).map_err(Into::into)
+}
+
+pub fn amend(
+    project: &Project,
+    branch_id: BranchId,
+    commit_oid: git2::Oid,
+    ownership: &BranchOwnershipClaims,
+) -> Result<git2::Oid> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Amending a commit requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::AmendCommit),
+        guard.write_permission(),
+    );
+    vbranch::amend(&ctx, branch_id, commit_oid, ownership)
+}
+
+pub fn move_commit_file(
+    project: &Project,
+    branch_id: BranchId,
+    from_commit_oid: git2::Oid,
+    to_commit_oid: git2::Oid,
+    ownership: &BranchOwnershipClaims,
+) -> Result<git2::Oid> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Amending a commit requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::MoveCommitFile),
+        guard.write_permission(),
+    );
+    vbranch::move_commit_file(&ctx, branch_id, from_commit_oid, to_commit_oid, ownership)
+        .map_err(Into::into)
+}
+
+pub fn undo_commit(project: &Project, branch_id: BranchId, commit_oid: git2::Oid) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Undoing a commit requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let snapshot_tree = ctx.project().prepare_snapshot(guard.read_permission());
+    let result: Result<()> = vbranch::undo_commit(&ctx, branch_id, commit_oid).map_err(Into::into);
+    let _ = snapshot_tree.and_then(|snapshot_tree| {
+        ctx.project().snapshot_commit_undo(
+            snapshot_tree,
+            result.as_ref(),
+            commit_oid,
             guard.write_permission(),
-        );
-        branch::unapply_ownership(&ctx, ownership, guard.write_permission()).map_err(Into::into)
-    }
+        )
+    });
+    result
+}
 
-    pub fn reset_files(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        files: &[PathBuf],
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Resetting a file requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::DiscardFile),
+pub fn insert_blank_commit(
+    project: &Project,
+    branch_id: BranchId,
+    commit_oid: git2::Oid,
+    offset: i32,
+) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Inserting a blank commit requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::InsertBlankCommit),
+        guard.write_permission(),
+    );
+    vbranch::insert_blank_commit(&ctx, branch_id, commit_oid, offset).map_err(Into::into)
+}
+
+pub fn create_change_reference(
+    project: &Project,
+    branch_id: BranchId,
+    name: ReferenceName,
+    change_id: String,
+) -> Result<ChangeReference> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Requires an open workspace mode")?;
+    gitbutler_repo::create_change_reference(&ctx, branch_id, name, change_id)
+}
+
+pub fn push_change_reference(
+    project: &Project,
+    branch_id: BranchId,
+    name: ReferenceName,
+    with_force: bool,
+) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    gitbutler_repo::push_change_reference(&ctx, branch_id, name, with_force)
+}
+
+pub fn update_change_reference(
+    project: &Project,
+    branch_id: BranchId,
+    name: ReferenceName,
+    new_change_id: String,
+) -> Result<ChangeReference> {
+    let ctx = open_with_verify(project)?;
+    gitbutler_repo::update_change_reference(&ctx, branch_id, name, new_change_id)
+}
+
+pub fn reorder_commit(
+    project: &Project,
+    branch_id: BranchId,
+    commit_oid: git2::Oid,
+    offset: i32,
+) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Reordering a commit requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::ReorderCommit),
+        guard.write_permission(),
+    );
+    vbranch::reorder_commit(&ctx, branch_id, commit_oid, offset).map_err(Into::into)
+}
+
+pub fn reset_virtual_branch(
+    project: &Project,
+    branch_id: BranchId,
+    target_commit_oid: git2::Oid,
+) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Resetting a branch requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::UndoCommit),
+        guard.write_permission(),
+    );
+    vbranch::reset_branch(&ctx, branch_id, target_commit_oid).map_err(Into::into)
+}
+
+pub fn convert_to_real_branch(project: &Project, branch_id: BranchId) -> Result<ReferenceName> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Converting branch to a real branch requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let snapshot_tree = ctx.project().prepare_snapshot(guard.read_permission());
+    let branch_manager = ctx.branch_manager();
+    let result = branch_manager.convert_to_real_branch(branch_id, guard.write_permission());
+
+    let _ = snapshot_tree.and_then(|snapshot_tree| {
+        ctx.project().snapshot_branch_unapplied(
+            snapshot_tree,
+            result.as_ref(),
             guard.write_permission(),
-        );
-        branch::reset_files(&ctx, branch_id, files, guard.write_permission()).map_err(Into::into)
-    }
+        )
+    });
 
-    pub fn amend(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        commit_oid: git2::Oid,
-        ownership: &BranchOwnershipClaims,
-    ) -> Result<git2::Oid> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Amending a commit requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::AmendCommit),
-            guard.write_permission(),
-        );
-        branch::amend(&ctx, branch_id, commit_oid, ownership)
-    }
+    result
+}
 
-    pub fn move_commit_file(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        from_commit_oid: git2::Oid,
-        to_commit_oid: git2::Oid,
-        ownership: &BranchOwnershipClaims,
-    ) -> Result<git2::Oid> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Amending a commit requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::MoveCommitFile),
-            guard.write_permission(),
-        );
-        branch::move_commit_file(&ctx, branch_id, from_commit_oid, to_commit_oid, ownership)
-            .map_err(Into::into)
-    }
+pub fn push_virtual_branch(
+    project: &Project,
+    branch_id: BranchId,
+    with_force: bool,
+    askpass: Option<Option<BranchId>>,
+) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Pushing a branch requires open workspace mode")?;
+    vbranch::push(&ctx, branch_id, with_force, askpass)
+}
 
-    pub fn undo_commit(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        commit_oid: git2::Oid,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Undoing a commit requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let snapshot_tree = ctx.project().prepare_snapshot(guard.read_permission());
-        let result: Result<()> =
-            branch::undo_commit(&ctx, branch_id, commit_oid).map_err(Into::into);
-        let _ = snapshot_tree.and_then(|snapshot_tree| {
-            ctx.project().snapshot_commit_undo(
-                snapshot_tree,
-                result.as_ref(),
-                commit_oid,
-                guard.write_permission(),
-            )
-        });
-        result
-    }
+pub fn list_local_branches(project: Project) -> Result<Vec<RemoteBranch>> {
+    let ctx = CommandContext::open(&project)?;
+    remote::list_local_branches(&ctx)
+}
 
-    pub fn insert_blank_commit(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        commit_oid: git2::Oid,
-        offset: i32,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Inserting a blank commit requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::InsertBlankCommit),
-            guard.write_permission(),
-        );
-        branch::insert_blank_commit(&ctx, branch_id, commit_oid, offset).map_err(Into::into)
-    }
+pub fn get_remote_branch_data(project: &Project, refname: &Refname) -> Result<RemoteBranchData> {
+    let ctx = CommandContext::open(project)?;
+    remote::get_branch_data(&ctx, refname)
+}
 
-    pub fn create_change_reference(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        name: ReferenceName,
-        change_id: String,
-    ) -> Result<ChangeReference> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx).context("Requires an open workspace mode")?;
-        gitbutler_repo::create_change_reference(&ctx, branch_id, name, change_id)
-    }
+pub fn squash(project: &Project, branch_id: BranchId, commit_oid: git2::Oid) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Squashing a commit requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::SquashCommit),
+        guard.write_permission(),
+    );
+    vbranch::squash(&ctx, branch_id, commit_oid).map_err(Into::into)
+}
 
-    pub fn push_change_reference(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        name: ReferenceName,
-        with_force: bool,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        gitbutler_repo::push_change_reference(&ctx, branch_id, name, with_force)
-    }
+pub fn update_commit_message(
+    project: &Project,
+    branch_id: BranchId,
+    commit_oid: git2::Oid,
+    message: &str,
+) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Updating a commit message requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::UpdateCommitMessage),
+        guard.write_permission(),
+    );
+    vbranch::update_commit_message(&ctx, branch_id, commit_oid, message).map_err(Into::into)
+}
 
-    pub fn update_change_reference(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        name: ReferenceName,
-        new_change_id: String,
-    ) -> Result<ChangeReference> {
-        let ctx = open_with_verify(project)?;
-        gitbutler_repo::update_change_reference(&ctx, branch_id, name, new_change_id)
-    }
+pub fn fetch_from_remotes(project: &Project, askpass: Option<String>) -> Result<FetchResult> {
+    let ctx = CommandContext::open(project)?;
 
-    pub fn reorder_commit(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        commit_oid: git2::Oid,
-        offset: i32,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Reordering a commit requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::ReorderCommit),
-            guard.write_permission(),
-        );
-        branch::reorder_commit(&ctx, branch_id, commit_oid, offset).map_err(Into::into)
-    }
+    let remotes = ctx.repository().remotes_as_string()?;
+    let fetch_errors: Vec<_> = remotes
+        .iter()
+        .filter_map(|remote| {
+            ctx.fetch(remote, askpass.clone())
+                .err()
+                .map(|err| err.to_string())
+        })
+        .collect();
 
-    pub fn reset_virtual_branch(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        target_commit_oid: git2::Oid,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Resetting a branch requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::UndoCommit),
-            guard.write_permission(),
-        );
-        branch::reset_branch(&ctx, branch_id, target_commit_oid).map_err(Into::into)
-    }
+    let timestamp = std::time::SystemTime::now();
+    let project_data_last_fetched = if fetch_errors.is_empty() {
+        FetchResult::Fetched { timestamp }
+    } else {
+        FetchResult::Error {
+            timestamp,
+            error: fetch_errors.join("\n"),
+        }
+    };
 
-    pub fn convert_to_real_branch(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-    ) -> Result<ReferenceName> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Converting branch to a real branch requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let snapshot_tree = ctx.project().prepare_snapshot(guard.read_permission());
-        let branch_manager = ctx.branch_manager();
-        let result = branch_manager.convert_to_real_branch(branch_id, guard.write_permission());
+    Ok(project_data_last_fetched)
+}
 
-        let _ = snapshot_tree.and_then(|snapshot_tree| {
-            ctx.project().snapshot_branch_unapplied(
-                snapshot_tree,
-                result.as_ref(),
-                guard.write_permission(),
-            )
-        });
+pub fn move_commit(
+    project: &Project,
+    target_branch_id: BranchId,
+    commit_oid: git2::Oid,
+) -> Result<()> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx).context("Moving a commit requires open workspace mode")?;
+    let mut guard = project.exclusive_worktree_access();
+    let _ = ctx.project().create_snapshot(
+        SnapshotDetails::new(OperationKind::MoveCommit),
+        guard.write_permission(),
+    );
+    vbranch::move_commit(&ctx, target_branch_id, commit_oid).map_err(Into::into)
+}
 
-        result
-    }
+#[instrument(level = tracing::Level::DEBUG, skip(project), err(Debug))]
+pub fn create_virtual_branch_from_branch(
+    project: &Project,
+    branch: &Refname,
+    remote: Option<RemoteRefname>,
+) -> Result<BranchId> {
+    let ctx = open_with_verify(project)?;
+    assure_open_workspace_mode(&ctx)
+        .context("Creating a virtual branch from a branch open workspace mode")?;
+    let branch_manager = ctx.branch_manager();
+    let mut guard = project.exclusive_worktree_access();
+    branch_manager
+        .create_virtual_branch_from_branch(branch, remote, guard.write_permission())
+        .map_err(Into::into)
+}
 
-    pub fn push_virtual_branch(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        with_force: bool,
-        askpass: Option<Option<BranchId>>,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Pushing a branch requires open workspace mode")?;
-        branch::push(&ctx, branch_id, with_force, askpass)
-    }
+pub fn get_uncommited_files(project: &Project) -> Result<Vec<RemoteBranchFile>> {
+    let context = CommandContext::open(project)?;
+    let guard = project.exclusive_worktree_access();
+    branch::get_uncommited_files(&context, guard.read_permission())
+}
 
-    pub fn list_local_branches(project: Project) -> Result<Vec<RemoteBranch>> {
-        let ctx = CommandContext::open(&project)?;
-        list_local_branches(&ctx)
-    }
-
-    pub fn get_remote_branch_data(
-        &self,
-        project: &Project,
-        refname: &Refname,
-    ) -> Result<RemoteBranchData> {
-        let ctx = CommandContext::open(project)?;
-        get_branch_data(&ctx, refname)
-    }
-
-    pub fn squash(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        commit_oid: git2::Oid,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Squashing a commit requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::SquashCommit),
-            guard.write_permission(),
-        );
-        branch::squash(&ctx, branch_id, commit_oid).map_err(Into::into)
-    }
-
-    pub fn update_commit_message(
-        &self,
-        project: &Project,
-        branch_id: BranchId,
-        commit_oid: git2::Oid,
-        message: &str,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Updating a commit message requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::UpdateCommitMessage),
-            guard.write_permission(),
-        );
-        branch::update_commit_message(&ctx, branch_id, commit_oid, message).map_err(Into::into)
-    }
-
-    pub fn fetch_from_remotes(
-        &self,
-        project: &Project,
-        askpass: Option<String>,
-    ) -> Result<FetchResult> {
-        let ctx = CommandContext::open(project)?;
-
-        let remotes = ctx.repository().remotes_as_string()?;
-        let fetch_errors: Vec<_> = remotes
-            .iter()
-            .filter_map(|remote| {
-                ctx.fetch(remote, askpass.clone())
-                    .err()
-                    .map(|err| err.to_string())
-            })
-            .collect();
-
-        let timestamp = std::time::SystemTime::now();
-        let project_data_last_fetched = if fetch_errors.is_empty() {
-            FetchResult::Fetched { timestamp }
-        } else {
-            FetchResult::Error {
-                timestamp,
-                error: fetch_errors.join("\n"),
-            }
-        };
-
-        Ok(project_data_last_fetched)
-    }
-
-    pub fn move_commit(
-        &self,
-        project: &Project,
-        target_branch_id: BranchId,
-        commit_oid: git2::Oid,
-    ) -> Result<()> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx).context("Moving a commit requires open workspace mode")?;
-        let mut guard = project.exclusive_worktree_access();
-        let _ = ctx.project().create_snapshot(
-            SnapshotDetails::new(OperationKind::MoveCommit),
-            guard.write_permission(),
-        );
-        branch::move_commit(&ctx, target_branch_id, commit_oid).map_err(Into::into)
-    }
-
-    #[instrument(level = tracing::Level::DEBUG, skip(self, project), err(Debug))]
-    pub fn create_virtual_branch_from_branch(
-        &self,
-        project: &Project,
-        branch: &Refname,
-        remote: Option<RemoteRefname>,
-    ) -> Result<BranchId> {
-        let ctx = open_with_verify(project)?;
-        assure_open_workspace_mode(&ctx)
-            .context("Creating a virtual branch from a branch open workspace mode")?;
-        let branch_manager = ctx.branch_manager();
-        let mut guard = project.exclusive_worktree_access();
-        branch_manager
-            .create_virtual_branch_from_branch(branch, remote, guard.write_permission())
-            .map_err(Into::into)
-    }
-
-    pub fn get_uncommited_files(&self, project: &Project) -> Result<Vec<RemoteBranchFile>> {
-        let context = CommandContext::open(project)?;
-        let guard = project.exclusive_worktree_access();
-        get_uncommited_files(&context, guard.read_permission())
-    }
-
-    /// Like [`get_uncommited_files()`], but returns a type that can be re-used with
-    /// [`crate::list_virtual_branches()`].
-    pub fn get_uncommited_files_reusable(&self, project: &Project) -> Result<DiffByPathMap> {
-        let context = CommandContext::open(project)?;
-        let guard = project.exclusive_worktree_access();
-        get_uncommited_files_raw(&context, guard.read_permission())
-    }
+/// Like [`get_uncommited_files()`], but returns a type that can be re-used with
+/// [`crate::list_virtual_branches()`].
+pub fn get_uncommited_files_reusable(project: &Project) -> Result<DiffByPathMap> {
+    let context = CommandContext::open(project)?;
+    let guard = project.exclusive_worktree_access();
+    branch::get_uncommited_files_raw(&context, guard.read_permission())
 }
 
 fn open_with_verify(project: &Project) -> Result<CommandContext> {
diff --git a/crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs b/crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs
index 819d81744..9d535a9b3 100644
--- a/crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs
+++ b/crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs
@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 
+use crate::r#virtual as vbranch;
 use anyhow::{anyhow, bail, Context, Result};
 use gitbutler_branch::{self, dedup, Branch, BranchCreateRequest, BranchId, BranchOwnershipClaims};
 use gitbutler_commit::commit_headers::HasCommitHeaders;
@@ -14,10 +15,9 @@ use tracing::instrument;
 use super::BranchManager;
 use crate::{
     conflicts::{self, RepoConflictsExt},
-    ensure_selected_for_changes,
     hunk::VirtualBranchHunk,
     integration::update_workspace_commit,
-    set_ownership, undo_commit, VirtualBranchesExt,
+    VirtualBranchesExt,
 };
 
 impl BranchManager<'_> {
@@ -118,7 +118,8 @@ impl BranchManager<'_> {
         };
 
         if let Some(ownership) = &create.ownership {
-            set_ownership(&vb_state, &mut branch, ownership).context("failed to set ownership")?;
+            vbranch::set_ownership(&vb_state, &mut branch, ownership)
+                .context("failed to set ownership")?;
         }
 
         vb_state.set_branch(branch.clone())?;
@@ -489,7 +490,8 @@ impl BranchManager<'_> {
         // apply the branch
         vb_state.set_branch(branch.clone())?;
 
-        ensure_selected_for_changes(&vb_state).context("failed to ensure selected for changes")?;
+        vbranch::ensure_selected_for_changes(&vb_state)
+            .context("failed to ensure selected for changes")?;
         // checkout the merge index
         repo.checkout_index_builder(&mut merge_index)
             .force()
@@ -505,7 +507,7 @@ impl BranchManager<'_> {
 
                 if let Some(headers) = potential_wip_commit.gitbutler_headers() {
                     if headers.change_id == wip_commit_to_unapply {
-                        undo_commit(self.ctx, branch.id, branch.head)?;
+                        vbranch::undo_commit(self.ctx, branch.id, branch.head)?;
                     }
                 }
 
diff --git a/crates/gitbutler-branch-actions/src/branch_manager/branch_removal.rs b/crates/gitbutler-branch-actions/src/branch_manager/branch_removal.rs
index 64960e2f4..0d8e59d79 100644
--- a/crates/gitbutler-branch-actions/src/branch_manager/branch_removal.rs
+++ b/crates/gitbutler-branch-actions/src/branch_manager/branch_removal.rs
@@ -11,9 +11,10 @@ use gitbutler_repo::{RepoActionsExt, RepositoryExt};
 use tracing::instrument;
 
 use super::BranchManager;
+use crate::r#virtual as vbranch;
 use crate::{
     conflicts::{self},
-    ensure_selected_for_changes, get_applied_status,
+    get_applied_status,
     hunk::VirtualBranchHunk,
     VirtualBranchesExt,
 };
@@ -47,7 +48,8 @@ impl BranchManager<'_> {
         vb_state.update_ordering()?;
 
         // Ensure we still have a default target
-        ensure_selected_for_changes(&vb_state).context("failed to ensure selected for changes")?;
+        vbranch::ensure_selected_for_changes(&vb_state)
+            .context("failed to ensure selected for changes")?;
 
         crate::integration::update_workspace_commit(&vb_state, self.ctx)?;
 
@@ -132,7 +134,8 @@ impl BranchManager<'_> {
 
         self.ctx.delete_branch_reference(&branch)?;
 
-        ensure_selected_for_changes(&vb_state).context("failed to ensure selected for changes")?;
+        vbranch::ensure_selected_for_changes(&vb_state)
+            .context("failed to ensure selected for changes")?;
 
         Ok(())
     }
diff --git a/crates/gitbutler-branch-actions/src/lib.rs b/crates/gitbutler-branch-actions/src/lib.rs
index b30155506..b74450273 100644
--- a/crates/gitbutler-branch-actions/src/lib.rs
+++ b/crates/gitbutler-branch-actions/src/lib.rs
@@ -1,9 +1,27 @@
 //! GitButler internal library containing functionality related to branches, i.e. the virtual branches implementation
 mod actions;
-pub use actions::VirtualBranchActions;
+// This is our API
+pub use actions::{
+    amend, can_apply_remote_branch, convert_to_real_branch, create_change_reference, create_commit,
+    create_virtual_branch, create_virtual_branch_from_branch, delete_local_branch,
+    delete_virtual_branch, fetch_from_remotes, get_base_branch_data, get_remote_branch_data,
+    get_uncommited_files, get_uncommited_files_reusable, insert_blank_commit,
+    integrate_upstream_commits, list_local_branches, list_remote_commit_files,
+    list_virtual_branches, list_virtual_branches_cached, move_commit, move_commit_file,
+    push_change_reference, push_virtual_branch, reorder_commit, reset_files, reset_virtual_branch,
+    set_base_branch, set_target_push_remote, squash, unapply_ownership, undo_commit,
+    update_base_branch, update_branch_order, update_change_reference, update_commit_message,
+    update_virtual_branch,
+};
 
 mod r#virtual;
-pub use r#virtual::*;
+pub use r#virtual::{BranchStatus, VirtualBranch, VirtualBranchHunksByPathMap, VirtualBranches};
+/// Avoid using these!
+/// This was previously `pub use r#virtual::*;`
+pub mod internal {
+    pub use super::r#virtual::*;
+    pub use super::remote::list_local_branches;
+}
 
 mod branch_manager;
 pub use branch_manager::{BranchManager, BranchManagerExt};
@@ -18,7 +36,7 @@ mod file;
 pub use file::{Get, RemoteBranchFile};
 
 mod remote;
-pub use remote::{list_local_branches, RemoteBranch, RemoteBranchData, RemoteCommit};
+pub use remote::{RemoteBranch, RemoteBranchData, RemoteCommit};
 
 pub mod conflicts;
 
diff --git a/crates/gitbutler-branch-actions/tests/extra/mod.rs b/crates/gitbutler-branch-actions/tests/extra/mod.rs
index 1b41d3c57..d60cd080e 100644
--- a/crates/gitbutler-branch-actions/tests/extra/mod.rs
+++ b/crates/gitbutler-branch-actions/tests/extra/mod.rs
@@ -16,9 +16,7 @@ use gitbutler_branch::{
     BranchCreateRequest, BranchOwnershipClaims, BranchUpdateRequest, Target, VirtualBranchesHandle,
 };
 use gitbutler_branch_actions::{
-    commit, get_applied_status, integrate_upstream_commits, is_remote_branch_mergeable,
-    list_virtual_branches, unapply_ownership, update_branch, update_workspace_commit,
-    verify_branch, BranchManagerExt, Get,
+    get_applied_status, internal, update_workspace_commit, verify_branch, BranchManagerExt, Get,
 };
 use gitbutler_commit::{commit_ext::CommitExt, commit_headers::CommitHeadersV2};
 use gitbutler_reference::{Refname, RemoteRefname};
@@ -48,16 +46,16 @@ fn commit_on_branch_then_change_file_then_get_status() -> Result<()> {
         "line0\nline1\nline2\nline3\nline4\n",
     )?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches[0];
     assert_eq!(branch.files.len(), 1);
     assert_eq!(branch.commits.len(), 0);
 
     // commit
-    commit(ctx, branch1_id, "test commit", None, false)?;
+    internal::commit(ctx, branch1_id, "test commit", None, false)?;
 
     // status (no files)
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches[0];
     assert_eq!(branch.files.len(), 0);
     assert_eq!(branch.commits.len(), 1);
@@ -68,7 +66,7 @@ fn commit_on_branch_then_change_file_then_get_status() -> Result<()> {
     )?;
 
     // should have just the last change now, the other line is committed
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches[0];
     assert_eq!(branch.files.len(), 1);
     assert_eq!(branch.commits.len(), 1);
@@ -127,7 +125,7 @@ fn track_binary_files() -> Result<()> {
     let mut file = std::fs::File::create(Path::new(&project.path).join("image.bin"))?;
     file.write_all(&image_data)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches[0];
     assert_eq!(branch.files.len(), 2);
     let img_file = &branch
@@ -144,10 +142,10 @@ fn track_binary_files() -> Result<()> {
     );
 
     // commit
-    commit(ctx, branch1_id, "test commit", None, false)?;
+    internal::commit(ctx, branch1_id, "test commit", None, false)?;
 
     // status (no files)
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission()).unwrap();
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission()).unwrap();
     let commit_id = &branches[0].commits[0].id;
     let commit_obj = ctx.repository().find_commit(commit_id.to_owned())?;
     let tree = commit_obj.tree()?;
@@ -168,9 +166,9 @@ fn track_binary_files() -> Result<()> {
     file.write_all(&image_data)?;
 
     // commit
-    commit(ctx, branch1_id, "test commit", None, false)?;
+    internal::commit(ctx, branch1_id, "test commit", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission()).unwrap();
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission()).unwrap();
     let commit_id = &branches[0].commits[0].id;
     // get tree from commit_id
     let commit_obj = ctx.repository().find_commit(commit_id.to_owned())?;
@@ -335,7 +333,7 @@ fn hunk_expantion() -> Result<()> {
     assert_eq!(files_by_branch_id[&branch2_id].len(), 0);
 
     // even though selected branch has changed
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch1_id,
@@ -343,7 +341,7 @@ fn hunk_expantion() -> Result<()> {
             ..Default::default()
         },
     )?;
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch2_id,
@@ -483,7 +481,7 @@ fn move_hunks_multiple_sources() -> Result<()> {
     // assert_eq!(files_by_branch_id[&branch2_id][0].hunks.len(), 1);
     assert_eq!(files_by_branch_id[&branch3_id].len(), 0);
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch3_id,
@@ -576,7 +574,7 @@ fn move_hunks_partial_explicitly() -> Result<()> {
     // assert_eq!(files_by_branch_id[&branch1_id][0].hunks.len(), 2);
     assert_eq!(files_by_branch_id[&branch2_id].len(), 0);
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch2_id,
@@ -828,7 +826,7 @@ fn merge_vbranch_upstream_clean_rebase() -> Result<()> {
     vb_state.set_branch(branch.clone())?;
 
     // create the branch
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     assert_eq!(branches.len(), 1);
     let branch1 = &branches[0];
     assert_eq!(
@@ -840,9 +838,9 @@ fn merge_vbranch_upstream_clean_rebase() -> Result<()> {
     assert_eq!(branch1.commits.len(), 1);
     // assert_eq!(branch1.upstream.as_ref().unwrap().commits.len(), 1);
 
-    integrate_upstream_commits(ctx, branch1.id)?;
+    internal::integrate_upstream_commits(ctx, branch1.id)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch1 = &branches[0];
 
     let contents = std::fs::read(Path::new(&project.path).join(file_path))?;
@@ -933,7 +931,7 @@ fn merge_vbranch_upstream_conflict() -> Result<()> {
     branch.head = last_push;
     vb_state.set_branch(branch.clone())?;
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch.id,
@@ -944,16 +942,16 @@ fn merge_vbranch_upstream_conflict() -> Result<()> {
     .unwrap();
 
     // create the branch
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch1 = &branches[0];
 
     assert_eq!(branch1.files.len(), 1);
     assert_eq!(branch1.commits.len(), 1);
     // assert_eq!(branch1.upstream.as_ref().unwrap().commits.len(), 1);
 
-    integrate_upstream_commits(ctx, branch1.id)?;
+    internal::integrate_upstream_commits(ctx, branch1.id)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch1 = &branches[0];
     let contents = std::fs::read(Path::new(&project.path).join(file_path))?;
 
@@ -974,13 +972,13 @@ fn merge_vbranch_upstream_conflict() -> Result<()> {
 
     // make gb see the conflict resolution
     update_workspace_commit(&vb_state, ctx)?;
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     assert!(branches[0].conflicted);
 
     // commit the merge resolution
-    commit(ctx, branch1.id, "fix merge conflict", None, false)?;
+    internal::commit(ctx, branch1.id, "fix merge conflict", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch1 = &branches[0];
     assert!(!branch1.conflicted);
     assert_eq!(branch1.files.len(), 0);
@@ -1015,7 +1013,7 @@ fn unapply_ownership_partial() -> Result<()> {
         .create_virtual_branch(&BranchCreateRequest::default(), guard.write_permission())
         .expect("failed to create virtual branch");
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].files.len(), 1);
     assert_eq!(branches[0].ownership.claims.len(), 1);
@@ -1026,14 +1024,14 @@ fn unapply_ownership_partial() -> Result<()> {
         "line1\nline2\nline3\nline4\nbranch1\n"
     );
 
-    unapply_ownership(
+    internal::unapply_ownership(
         ctx,
         &"test.txt:2-6".parse().unwrap(),
         guard.write_permission(),
     )
     .unwrap();
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].files.len(), 0);
     assert_eq!(branches[0].ownership.claims.len(), 0);
@@ -1078,7 +1076,7 @@ fn unapply_branch() -> Result<()> {
         .expect("failed to create virtual branch")
         .id;
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch2_id,
@@ -1095,7 +1093,7 @@ fn unapply_branch() -> Result<()> {
     let contents = std::fs::read(Path::new(&project.path).join(file_path2))?;
     assert_eq!("line5\nline6\n", String::from_utf8(contents)?);
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
     assert_eq!(branch.files.len(), 1);
     assert!(branch.active);
@@ -1109,7 +1107,7 @@ fn unapply_branch() -> Result<()> {
     let contents = std::fs::read(Path::new(&project.path).join(file_path2))?;
     assert_eq!("line5\nline6\n", String::from_utf8(contents)?);
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     assert!(!branches.iter().any(|b| b.id == branch1_id));
 
     let branch_manager = ctx.branch_manager();
@@ -1126,7 +1124,7 @@ fn unapply_branch() -> Result<()> {
     let contents = std::fs::read(Path::new(&project.path).join(file_path2))?;
     assert_eq!("line5\nline6\n", String::from_utf8(contents)?);
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
     // TODO: expect there to be 0 branches
     assert_eq!(branch.files.len(), 0);
@@ -1165,7 +1163,7 @@ fn apply_unapply_added_deleted_files() -> Result<()> {
         .expect("failed to create virtual branch")
         .id;
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch2_id,
@@ -1173,7 +1171,7 @@ fn apply_unapply_added_deleted_files() -> Result<()> {
             ..Default::default()
         },
     )?;
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch3_id,
@@ -1182,7 +1180,7 @@ fn apply_unapply_added_deleted_files() -> Result<()> {
         },
     )?;
 
-    list_virtual_branches(ctx, guard.write_permission()).unwrap();
+    internal::list_virtual_branches(ctx, guard.write_permission()).unwrap();
 
     let branch_manager = ctx.branch_manager();
     let real_branch_2 =
@@ -1257,7 +1255,7 @@ fn detect_mergeable_branch() -> Result<()> {
         .expect("failed to create virtual branch")
         .id;
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch2_id,
@@ -1344,13 +1342,13 @@ fn detect_mergeable_branch() -> Result<()> {
     };
     vb_state.set_branch(branch4.clone())?;
 
-    let remotes =
-        gitbutler_branch_actions::list_local_branches(ctx).expect("failed to list remotes");
+    let remotes = gitbutler_branch_actions::internal::list_local_branches(ctx)
+        .expect("failed to list remotes");
     let _remote1 = &remotes
         .iter()
         .find(|b| b.name.to_string() == "refs/remotes/origin/remote_branch")
         .unwrap();
-    assert!(!is_remote_branch_mergeable(
+    assert!(!internal::is_remote_branch_mergeable(
         ctx,
         &"refs/remotes/origin/remote_branch".parse().unwrap()
     )
@@ -1361,7 +1359,7 @@ fn detect_mergeable_branch() -> Result<()> {
         .iter()
         .find(|b| b.name.to_string() == "refs/remotes/origin/remote_branch2")
         .unwrap();
-    assert!(is_remote_branch_mergeable(
+    assert!(internal::is_remote_branch_mergeable(
         ctx,
         &"refs/remotes/origin/remote_branch2".parse().unwrap()
     )
@@ -1437,7 +1435,7 @@ fn upstream_integrated_vbranch() -> Result<()> {
         "file3\nversion2\n",
     )?;
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch1_id,
@@ -1447,7 +1445,7 @@ fn upstream_integrated_vbranch() -> Result<()> {
         },
     )?;
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch2_id,
@@ -1457,7 +1455,7 @@ fn upstream_integrated_vbranch() -> Result<()> {
         },
     )?;
 
-    update_branch(
+    internal::update_branch(
         ctx,
         &BranchUpdateRequest {
             id: branch3_id,
@@ -1468,10 +1466,10 @@ fn upstream_integrated_vbranch() -> Result<()> {
     )?;
 
     // create a new virtual branch from the remote branch
-    commit(ctx, branch1_id, "integrated commit", None, false)?;
-    commit(ctx, branch2_id, "non-integrated commit", None, false)?;
+    internal::commit(ctx, branch1_id, "integrated commit", None, false)?;
+    internal::commit(ctx, branch2_id, "non-integrated commit", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
 
     let branch1 = &branches.iter().find(|b| b.id == branch1_id).unwrap();
     assert!(branch1.commits.iter().any(|c| c.is_integrated));
@@ -1517,7 +1515,7 @@ fn commit_same_hunk_twice() -> Result<()> {
         "line1\npatch1\nline2\nline3\nline4\nline5\nmiddle\nmiddle\nmiddle\nmiddle\nline6\nline7\nline8\nline9\nline10\nmiddle\nmiddle\nmiddle\nline11\nline12\n",
     )?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 1);
@@ -1525,9 +1523,9 @@ fn commit_same_hunk_twice() -> Result<()> {
     assert_eq!(branch.commits.len(), 0);
 
     // commit
-    commit(ctx, branch1_id, "first commit to test.txt", None, false)?;
+    internal::commit(ctx, branch1_id, "first commit to test.txt", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 0, "no files expected");
@@ -1547,15 +1545,15 @@ fn commit_same_hunk_twice() -> Result<()> {
         "line1\nPATCH1\nline2\nline3\nline4\nline5\nmiddle\nmiddle\nmiddle\nmiddle\nline6\nline7\nline8\nline9\nline10\nmiddle\nmiddle\nmiddle\nline11\nline12\n",
     )?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 1, "one file should be changed");
     assert_eq!(branch.commits.len(), 1, "commit is still there");
 
-    commit(ctx, branch1_id, "second commit to test.txt", None, false)?;
+    internal::commit(ctx, branch1_id, "second commit to test.txt", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(
@@ -1599,7 +1597,7 @@ fn commit_same_file_twice() -> Result<()> {
         "line1\npatch1\nline2\nline3\nline4\nline5\nmiddle\nmiddle\nmiddle\nmiddle\nline6\nline7\nline8\nline9\nline10\nmiddle\nmiddle\nmiddle\nline11\nline12\n",
     )?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 1);
@@ -1607,9 +1605,9 @@ fn commit_same_file_twice() -> Result<()> {
     assert_eq!(branch.commits.len(), 0);
 
     // commit
-    commit(ctx, branch1_id, "first commit to test.txt", None, false)?;
+    internal::commit(ctx, branch1_id, "first commit to test.txt", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 0, "no files expected");
@@ -1629,15 +1627,15 @@ fn commit_same_file_twice() -> Result<()> {
         "line1\npatch1\nline2\nline3\nline4\nline5\nmiddle\nmiddle\nmiddle\nmiddle\nline6\nline7\nline8\nline9\nline10\nmiddle\nmiddle\nmiddle\npatch2\nline11\nline12\n",
     )?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 1, "one file should be changed");
     assert_eq!(branch.commits.len(), 1, "commit is still there");
 
-    commit(ctx, branch1_id, "second commit to test.txt", None, false)?;
+    internal::commit(ctx, branch1_id, "second commit to test.txt", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(
@@ -1681,7 +1679,7 @@ fn commit_partial_by_hunk() -> Result<()> {
         "line1\npatch1\nline2\nline3\nline4\nline5\nmiddle\nmiddle\nmiddle\nmiddle\nline6\nline7\nline8\nline9\nline10\nmiddle\nmiddle\nmiddle\npatch2\nline11\nline12\n",
     )?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 1);
@@ -1689,7 +1687,7 @@ fn commit_partial_by_hunk() -> Result<()> {
     assert_eq!(branch.commits.len(), 0);
 
     // commit
-    commit(
+    internal::commit(
         ctx,
         branch1_id,
         "first commit to test.txt",
@@ -1697,7 +1695,7 @@ fn commit_partial_by_hunk() -> Result<()> {
         false,
     )?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 1);
@@ -1706,7 +1704,7 @@ fn commit_partial_by_hunk() -> Result<()> {
     assert_eq!(branch.commits[0].files.len(), 1);
     assert_eq!(branch.commits[0].files[0].hunks.len(), 1);
 
-    commit(
+    internal::commit(
         ctx,
         branch1_id,
         "second commit to test.txt",
@@ -1714,7 +1712,7 @@ fn commit_partial_by_hunk() -> Result<()> {
         false,
     )?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     assert_eq!(branch.files.len(), 0);
@@ -1754,9 +1752,9 @@ fn commit_partial_by_file() -> Result<()> {
         .id;
 
     // commit
-    commit(ctx, branch1_id, "branch1 commit", None, false)?;
+    internal::commit(ctx, branch1_id, "branch1 commit", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch1 = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     // branch one test.txt has just the 1st and 3rd hunks applied
@@ -1805,9 +1803,9 @@ fn commit_add_and_delete_files() -> Result<()> {
         .id;
 
     // commit
-    commit(ctx, branch1_id, "branch1 commit", None, false)?;
+    internal::commit(ctx, branch1_id, "branch1 commit", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch1 = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     // branch one test.txt has just the 1st and 3rd hunks applied
@@ -1862,9 +1860,9 @@ fn commit_executable_and_symlinks() -> Result<()> {
         .id;
 
     // commit
-    commit(ctx, branch1_id, "branch1 commit", None, false)?;
+    internal::commit(ctx, branch1_id, "branch1 commit", None, false)?;
 
-    let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     let branch1 = &branches.iter().find(|b| b.id == branch1_id).unwrap();
 
     let commit = &branch1.commits[0].id;
@@ -1960,7 +1958,7 @@ fn verify_branch_commits_to_workspace() -> Result<()> {
     verify_branch(ctx, guard.write_permission()).unwrap();
 
     // one virtual branch with two commits was created
-    let (virtual_branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
+    let (virtual_branches, _) = internal::list_virtual_branches(ctx, guard.write_permission())?;
     assert_eq!(virtual_branches.len(), 1);
 
     let branch = &virtual_branches.first().unwrap();
@@ -2021,7 +2019,7 @@ fn pre_commit_hook_rejection() -> Result<()> {
 
     git2_hooks::create_hook(ctx.repository(), git2_hooks::HOOK_PRE_COMMIT, hook);
 
-    let res = commit(ctx, branch1_id, "test commit", None, true);
+    let res = internal::commit(ctx, branch1_id, "test commit", None, true);
 
     let err = res.unwrap_err();
     assert_eq!(
@@ -2064,7 +2062,7 @@ fn post_commit_hook() -> Result<()> {
 
     assert!(!hook_ran_proof.exists());
 
-    commit(ctx, branch1_id, "test commit", None, true)?;
+    internal::commit(ctx, branch1_id, "test commit", None, true)?;
 
     assert!(hook_ran_proof.exists());
 
@@ -2100,7 +2098,7 @@ fn commit_msg_hook_rejection() -> Result<()> {
 
     git2_hooks::create_hook(ctx.repository(), git2_hooks::HOOK_COMMIT_MSG, hook);
 
-    let res = commit(ctx, branch1_id, "test commit", None, true);
+    let res = internal::commit(ctx, branch1_id, "test commit", None, true);
 
     let err = res.unwrap_err();
     assert_eq!(
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/amend.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/amend.rs
index cad971a81..eda3f01c5 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/amend.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/amend.rs
@@ -8,7 +8,6 @@ fn forcepush_allowed() {
         repository,
         project_id,
         project,
-        controller,
         projects,
         ..
     } = &Test::default();
@@ -20,9 +19,11 @@ fn forcepush_allowed() {
         })
         .unwrap();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     projects
         .update(&projects::UpdateRequest {
@@ -31,30 +32,25 @@ fn forcepush_allowed() {
         })
         .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let commit_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let commit_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
-    controller
-        .push_virtual_branch(project, branch_id, false, None)
-        .unwrap();
+    gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
     {
         // amend another hunk
         fs::write(repository.path().join("file2.txt"), "content2").unwrap();
         let to_amend: BranchOwnershipClaims = "file2.txt:1-2".parse().unwrap();
-        controller
-            .amend(project, branch_id, commit_id, &to_amend)
-            .unwrap();
+        gitbutler_branch_actions::amend(project, branch_id, commit_id, &to_amend).unwrap();
 
-        let branch = controller
-            .list_virtual_branches(project)
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
             .unwrap()
             .0
             .into_iter()
@@ -72,45 +68,42 @@ fn forcepush_forbidden() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
-    controller
-        .update_virtual_branch(
-            project,
-            BranchUpdateRequest {
-                id: branch_id,
-                allow_rebasing: Some(false),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    gitbutler_branch_actions::update_virtual_branch(
+        project,
+        BranchUpdateRequest {
+            id: branch_id,
+            allow_rebasing: Some(false),
+            ..Default::default()
+        },
+    )
+    .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let commit_oid = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
-    controller
-        .push_virtual_branch(project, branch_id, false, None)
-        .unwrap();
+    gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
     {
         fs::write(repository.path().join("file2.txt"), "content2").unwrap();
         let to_amend: BranchOwnershipClaims = "file2.txt:1-2".parse().unwrap();
         assert_eq!(
-            controller
-                .amend(project, branch_id, commit_oid, &to_amend)
+            gitbutler_branch_actions::amend(project, branch_id, commit_oid, &to_amend)
                 .unwrap_err()
                 .to_string(),
             "force-push is not allowed"
@@ -123,26 +116,26 @@ fn non_locked_hunk() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let commit_oid = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -156,12 +149,9 @@ fn non_locked_hunk() {
         // amend another hunk
         fs::write(repository.path().join("file2.txt"), "content2").unwrap();
         let to_amend: BranchOwnershipClaims = "file2.txt:1-2".parse().unwrap();
-        controller
-            .amend(project, branch_id, commit_oid, &to_amend)
-            .unwrap();
+        gitbutler_branch_actions::amend(project, branch_id, commit_oid, &to_amend).unwrap();
 
-        let branch = controller
-            .list_virtual_branches(project)
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
             .unwrap()
             .0
             .into_iter()
@@ -178,26 +168,26 @@ fn locked_hunk() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let commit_oid = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -215,12 +205,9 @@ fn locked_hunk() {
         // amend another hunk
         fs::write(repository.path().join("file.txt"), "more content").unwrap();
         let to_amend: BranchOwnershipClaims = "file.txt:1-2".parse().unwrap();
-        controller
-            .amend(project, branch_id, commit_oid, &to_amend)
-            .unwrap();
+        gitbutler_branch_actions::amend(project, branch_id, commit_oid, &to_amend).unwrap();
 
-        let branch = controller
-            .list_virtual_branches(project)
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
             .unwrap()
             .0
             .into_iter()
@@ -242,26 +229,26 @@ fn non_existing_ownership() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let commit_oid = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -275,8 +262,7 @@ fn non_existing_ownership() {
         // amend non existing hunk
         let to_amend: BranchOwnershipClaims = "file2.txt:1-2".parse().unwrap();
         assert_eq!(
-            controller
-                .amend(project, branch_id, commit_oid, &to_amend)
+            gitbutler_branch_actions::amend(project, branch_id, commit_oid, &to_amend)
                 .unwrap_err()
                 .to_string(),
             "target ownership not found"
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/apply_virtual_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/apply_virtual_branch.rs
index cb5383b84..ecf56b94a 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/apply_virtual_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/apply_virtual_branch.rs
@@ -8,7 +8,6 @@ fn rebase_commit() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -23,22 +22,25 @@ fn rebase_commit() {
         repository.reset_hard(Some(first_commit_oid));
     }
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     let mut branch1_id = {
         // create a branch with some commited work
-        let branch1_id = controller
-            .create_virtual_branch(project, &BranchCreateRequest::default())
-            .unwrap();
+        let branch1_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest::default(),
+        )
+        .unwrap();
         fs::write(repository.path().join("another_file.txt"), "virtual").unwrap();
 
-        controller
-            .create_commit(project, branch1_id, "virtual commit", None, false)
+        gitbutler_branch_actions::create_commit(project, branch1_id, "virtual commit", None, false)
             .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert!(branches[0].active);
@@ -50,9 +52,8 @@ fn rebase_commit() {
 
     let unapplied_branch = {
         // unapply first vbranch
-        let unapplied_branch = controller
-            .convert_to_real_branch(project, branch1_id)
-            .unwrap();
+        let unapplied_branch =
+            gitbutler_branch_actions::convert_to_real_branch(project, branch1_id).unwrap();
 
         assert_eq!(
             fs::read_to_string(repository.path().join("another_file.txt")).unwrap(),
@@ -63,7 +64,7 @@ fn rebase_commit() {
             "one"
         );
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 0);
 
         Refname::from_str(&unapplied_branch).unwrap()
@@ -71,10 +72,10 @@ fn rebase_commit() {
 
     {
         // fetch remote
-        controller.update_base_branch(project).unwrap();
+        gitbutler_branch_actions::update_base_branch(project).unwrap();
 
         // branch is stil unapplied
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 0);
 
         assert_eq!(
@@ -89,12 +90,15 @@ fn rebase_commit() {
 
     {
         // apply first vbranch again
-        branch1_id = controller
-            .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-            .unwrap();
+        branch1_id = gitbutler_branch_actions::create_virtual_branch_from_branch(
+            project,
+            &unapplied_branch,
+            None,
+        )
+        .unwrap();
 
         // it should be rebased
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].files.len(), 0);
@@ -119,7 +123,6 @@ fn rebase_work() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -132,18 +135,22 @@ fn rebase_work() {
         repository.reset_hard(Some(first_commit_oid));
     }
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     let mut branch1_id = {
         // make a branch with some work
-        let branch1_id = controller
-            .create_virtual_branch(project, &BranchCreateRequest::default())
-            .unwrap();
+        let branch1_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest::default(),
+        )
+        .unwrap();
         fs::write(repository.path().join("another_file.txt"), "").unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert!(branches[0].active);
@@ -155,11 +162,10 @@ fn rebase_work() {
 
     let unapplied_branch = {
         // unapply first vbranch
-        let unapplied_branch = controller
-            .convert_to_real_branch(project, branch1_id)
-            .unwrap();
+        let unapplied_branch =
+            gitbutler_branch_actions::convert_to_real_branch(project, branch1_id).unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 0);
 
         assert!(!repository.path().join("another_file.txt").exists());
@@ -170,10 +176,10 @@ fn rebase_work() {
 
     {
         // fetch remote
-        controller.update_base_branch(project).unwrap();
+        gitbutler_branch_actions::update_base_branch(project).unwrap();
 
         // first branch is stil unapplied
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 0);
 
         assert!(!repository.path().join("another_file.txt").exists());
@@ -182,12 +188,15 @@ fn rebase_work() {
 
     {
         // apply first vbranch again
-        branch1_id = controller
-            .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-            .unwrap();
+        branch1_id = gitbutler_branch_actions::create_virtual_branch_from_branch(
+            project,
+            &unapplied_branch,
+            None,
+        )
+        .unwrap();
 
         // workdir should be rebased, and work should be restored
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         // TODO: Should be 1
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/convert_to_real_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/convert_to_real_branch.rs
index c52c4bae5..522826c3c 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/convert_to_real_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/convert_to_real_branch.rs
@@ -4,27 +4,26 @@ use super::*;
 fn unapply_with_data() {
     let Test {
         project,
-        controller,
         repository,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
-    controller
-        .convert_to_real_branch(project, branches[0].id)
-        .unwrap();
+    gitbutler_branch_actions::convert_to_real_branch(project, branches[0].id).unwrap();
 
     assert!(!repository.path().join("file.txt").exists());
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 0);
 }
 
@@ -32,7 +31,6 @@ fn unapply_with_data() {
 fn conflicting() {
     let Test {
         project,
-        controller,
         repository,
         ..
     } = &Test::default();
@@ -47,16 +45,18 @@ fn conflicting() {
         repository.reset_hard(Some(first_commit_oid));
     }
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     let unapplied_branch = {
         // make a conflicting branch, and stash it
 
         std::fs::write(repository.path().join("file.txt"), "conflict").unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         let branch = &branches[0];
         assert_eq!(
@@ -70,16 +70,15 @@ fn conflicting() {
             "@@ -1 +1 @@\n-first\n\\ No newline at end of file\n+conflict\n\\ No newline at end of file\n"
         );
 
-        let unapplied_branch = controller
-            .convert_to_real_branch(project, branch.id)
-            .unwrap();
+        let unapplied_branch =
+            gitbutler_branch_actions::convert_to_real_branch(project, branch.id).unwrap();
 
         Refname::from_str(&unapplied_branch).unwrap()
     };
 
     {
         // update base branch, causing conflict
-        controller.update_base_branch(project).unwrap();
+        gitbutler_branch_actions::update_base_branch(project).unwrap();
 
         assert_eq!(
             std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
@@ -89,9 +88,12 @@ fn conflicting() {
 
     let branch_id = {
         // apply branch, it should conflict
-        let branch_id = controller
-            .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-            .unwrap();
+        let branch_id = gitbutler_branch_actions::create_virtual_branch_from_branch(
+            project,
+            &unapplied_branch,
+            None,
+        )
+        .unwrap();
 
         assert_eq!(
             std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
@@ -101,7 +103,7 @@ fn conflicting() {
         let vb_state = VirtualBranchesHandle::new(project.gb_dir());
         let ctx = CommandContext::open(project).unwrap();
         update_workspace_commit(&vb_state, &ctx).unwrap();
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
 
         assert_eq!(branches.len(), 1);
         let branch = &branches[0];
@@ -116,9 +118,7 @@ fn conflicting() {
 
     {
         // Converting the branch to a real branch should put us back in an unconflicted state
-        controller
-            .convert_to_real_branch(project, branch_id)
-            .unwrap();
+        gitbutler_branch_actions::convert_to_real_branch(project, branch_id).unwrap();
 
         assert_eq!(
             std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
@@ -129,27 +129,22 @@ fn conflicting() {
 
 #[test]
 fn delete_if_empty() {
-    let Test {
+    let Test { project, .. } = &Test::default();
+
+    gitbutler_branch_actions::set_base_branch(
         project,
-        controller,
-        ..
-    } = &Test::default();
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
+    gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
         .unwrap();
 
-    controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
-
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
-    controller
-        .convert_to_real_branch(project, branches[0].id)
-        .unwrap();
+    gitbutler_branch_actions::convert_to_real_branch(project, branches[0].id).unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 0);
 }
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/create_commit.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/create_commit.rs
index 4d4576294..40a3fd9d7 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/create_commit.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/create_commit.rs
@@ -8,40 +8,38 @@ use super::*;
 fn should_lock_updated_hunks() {
     let Test {
         project,
-        controller,
         repository,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     {
         // by default, hunks are not locked
         repository.write_file("file.txt", &["content".to_string()]);
 
-        let branch = get_virtual_branch(controller, project, branch_id);
+        let branch = get_virtual_branch(project, branch_id);
         assert_eq!(branch.files.len(), 1);
         assert_eq!(branch.files[0].path.display().to_string(), "file.txt");
         assert_eq!(branch.files[0].hunks.len(), 1);
         assert!(!branch.files[0].hunks[0].locked);
     }
 
-    controller
-        .create_commit(project, branch_id, "test", None, false)
-        .unwrap();
+    gitbutler_branch_actions::create_commit(project, branch_id, "test", None, false).unwrap();
 
     {
         // change in the committed hunks leads to hunk locking
         repository.write_file("file.txt", &["updated content".to_string()]);
 
-        let branch = controller
-            .list_virtual_branches(project)
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
             .unwrap()
             .0
             .into_iter()
@@ -58,7 +56,6 @@ fn should_lock_updated_hunks() {
 fn should_reset_into_same_branch() {
     let Test {
         project,
-        controller,
         repository,
         ..
     } = &Test::default();
@@ -66,51 +63,54 @@ fn should_reset_into_same_branch() {
     let mut lines = repository.gen_file("file.txt", 7);
     commit_and_push_initial(repository);
 
-    let base_branch = controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
+    let base_branch = gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
+
+    gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
         .unwrap();
 
-    controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
-
-    let branch_2_id = controller
-        .create_virtual_branch(
-            project,
-            &BranchCreateRequest {
-                selected_for_changes: Some(true),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    let branch_2_id = gitbutler_branch_actions::create_virtual_branch(
+        project,
+        &BranchCreateRequest {
+            selected_for_changes: Some(true),
+            ..Default::default()
+        },
+    )
+    .unwrap();
 
     lines[0] = "change 1".to_string();
     repository.write_file("file.txt", &lines);
 
-    controller
-        .create_commit(project, branch_2_id, "commit to branch 2", None, false)
-        .unwrap();
+    gitbutler_branch_actions::create_commit(
+        project,
+        branch_2_id,
+        "commit to branch 2",
+        None,
+        false,
+    )
+    .unwrap();
 
-    let files = get_virtual_branch(controller, project, branch_2_id).files;
+    let files = get_virtual_branch(project, branch_2_id).files;
     assert_eq!(files.len(), 0);
 
     // Set target to branch 1 and verify the file resets into branch 2.
-    controller
-        .update_virtual_branch(
-            project,
-            BranchUpdateRequest {
-                id: branch_2_id,
-                selected_for_changes: Some(true),
-                ..Default::default()
-            },
-        )
+    gitbutler_branch_actions::update_virtual_branch(
+        project,
+        BranchUpdateRequest {
+            id: branch_2_id,
+            selected_for_changes: Some(true),
+            ..Default::default()
+        },
+    )
+    .unwrap();
+
+    gitbutler_branch_actions::reset_virtual_branch(project, branch_2_id, base_branch.base_sha)
         .unwrap();
 
-    controller
-        .reset_virtual_branch(project, branch_2_id, base_branch.base_sha)
-        .unwrap();
-
-    let files = get_virtual_branch(controller, project, branch_2_id).files;
+    let files = get_virtual_branch(project, branch_2_id).files;
     assert_eq!(files.len(), 1);
 }
 
@@ -119,13 +119,8 @@ fn commit_and_push_initial(repository: &TestProject) {
     repository.push();
 }
 
-fn get_virtual_branch(
-    controller: &VirtualBranchActions,
-    project: &Project,
-    branch_id: Id<Branch>,
-) -> VirtualBranch {
-    controller
-        .list_virtual_branches(project)
+fn get_virtual_branch(project: &Project, branch_id: Id<Branch>) -> VirtualBranch {
+    gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/create_virtual_branch_from_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/create_virtual_branch_from_branch.rs
index 94d90f65b..8b03f4894 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/create_virtual_branch_from_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/create_virtual_branch_from_branch.rs
@@ -8,31 +8,29 @@ fn integration() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     let branch_name = {
         // make a remote branch
 
-        let branch_id = controller
-            .create_virtual_branch(project, &BranchCreateRequest::default())
-            .unwrap();
+        let branch_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest::default(),
+        )
+        .unwrap();
 
         std::fs::write(repository.path().join("file.txt"), "first\n").unwrap();
-        controller
-            .create_commit(project, branch_id, "first", None, false)
-            .unwrap();
-        controller
-            .push_virtual_branch(project, branch_id, false, None)
-            .unwrap();
+        gitbutler_branch_actions::create_commit(project, branch_id, "first", None, false).unwrap();
+        gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
-        let branch = controller
-            .list_virtual_branches(project)
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
             .unwrap()
             .0
             .into_iter()
@@ -41,25 +39,21 @@ fn integration() {
 
         let name = branch.upstream.unwrap().name;
 
-        controller
-            .delete_virtual_branch(project, branch_id)
-            .unwrap();
+        gitbutler_branch_actions::delete_virtual_branch(project, branch_id).unwrap();
 
         name
     };
 
     // checkout a existing remote branch
-    let branch_id = controller
-        .create_virtual_branch_from_branch(project, &branch_name, None)
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch_from_branch(project, &branch_name, None)
+            .unwrap();
 
     {
         // add a commit
         std::fs::write(repository.path().join("file.txt"), "first\nsecond").unwrap();
 
-        controller
-            .create_commit(project, branch_id, "second", None, false)
-            .unwrap();
+        gitbutler_branch_actions::create_commit(project, branch_id, "second", None, false).unwrap();
     }
 
     {
@@ -73,12 +67,9 @@ fn integration() {
 
     {
         // merge branch into master
-        controller
-            .push_virtual_branch(project, branch_id, false, None)
-            .unwrap();
+        gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
-        let branch = controller
-            .list_virtual_branches(project)
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
             .unwrap()
             .0
             .into_iter()
@@ -95,10 +86,9 @@ fn integration() {
 
     {
         // should mark commits as integrated
-        controller.fetch_from_remotes(project, None).unwrap();
+        gitbutler_branch_actions::fetch_from_remotes(project, None).unwrap();
 
-        let branch = controller
-            .list_virtual_branches(project)
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
             .unwrap()
             .0
             .into_iter()
@@ -117,7 +107,6 @@ fn no_conflicts() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -131,22 +120,23 @@ fn no_conflicts() {
         repository.checkout(&"refs/heads/master".parse().unwrap());
     }
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert!(branches.is_empty());
 
-    let branch_id = controller
-        .create_virtual_branch_from_branch(
-            project,
-            &"refs/remotes/origin/branch".parse().unwrap(),
-            None,
-        )
-        .unwrap();
+    let branch_id = gitbutler_branch_actions::create_virtual_branch_from_branch(
+        project,
+        &"refs/remotes/origin/branch".parse().unwrap(),
+        None,
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].id, branch_id);
     assert_eq!(branches[0].commits.len(), 1);
@@ -158,7 +148,6 @@ fn conflicts_with_uncommited() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -172,29 +161,29 @@ fn conflicts_with_uncommited() {
         repository.checkout(&"refs/heads/master".parse().unwrap());
     }
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     // create a local branch that conflicts with remote
     {
         std::fs::write(repository.path().join("file.txt"), "conflict").unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
     };
 
     // branch should be created unapplied, because of the conflict
 
-    let new_branch_id = controller
-        .create_virtual_branch_from_branch(
-            project,
-            &"refs/remotes/origin/branch".parse().unwrap(),
-            None,
-        )
-        .unwrap();
-    let new_branch = controller
-        .list_virtual_branches(project)
+    let new_branch_id = gitbutler_branch_actions::create_virtual_branch_from_branch(
+        project,
+        &"refs/remotes/origin/branch".parse().unwrap(),
+        None,
+    )
+    .unwrap();
+    let new_branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -210,7 +199,6 @@ fn conflicts_with_commited() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -224,33 +212,32 @@ fn conflicts_with_commited() {
         repository.checkout(&"refs/heads/master".parse().unwrap());
     }
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     // create a local branch that conflicts with remote
     {
         std::fs::write(repository.path().join("file.txt"), "conflict").unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
 
-        controller
-            .create_commit(project, branches[0].id, "hej", None, false)
+        gitbutler_branch_actions::create_commit(project, branches[0].id, "hej", None, false)
             .unwrap();
     };
 
     // branch should be created unapplied, because of the conflict
 
-    let new_branch_id = controller
-        .create_virtual_branch_from_branch(
-            project,
-            &"refs/remotes/origin/branch".parse().unwrap(),
-            None,
-        )
-        .unwrap();
-    let new_branch = controller
-        .list_virtual_branches(project)
+    let new_branch_id = gitbutler_branch_actions::create_virtual_branch_from_branch(
+        project,
+        &"refs/remotes/origin/branch".parse().unwrap(),
+        None,
+    )
+    .unwrap();
+    let new_branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -263,54 +250,48 @@ fn conflicts_with_commited() {
 
 #[test]
 fn from_default_target() {
-    let Test {
-        project,
-        controller,
-        ..
-    } = &Test::default();
+    let Test { project, .. } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     // branch should be created unapplied, because of the conflict
 
     assert_eq!(
-        controller
-            .create_virtual_branch_from_branch(
-                project,
-                &"refs/remotes/origin/master".parse().unwrap(),
-                None
-            )
-            .unwrap_err()
-            .to_string(),
+        gitbutler_branch_actions::create_virtual_branch_from_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+            None
+        )
+        .unwrap_err()
+        .to_string(),
         "cannot create a branch from default target"
     );
 }
 
 #[test]
 fn from_non_existent_branch() {
-    let Test {
-        project,
-        controller,
-        ..
-    } = &Test::default();
+    let Test { project, .. } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     // branch should be created unapplied, because of the conflict
 
     assert_eq!(
-        controller
-            .create_virtual_branch_from_branch(
-                project,
-                &"refs/remotes/origin/branch".parse().unwrap(),
-                None
-            )
-            .unwrap_err()
-            .to_string(),
+        gitbutler_branch_actions::create_virtual_branch_from_branch(
+            project,
+            &"refs/remotes/origin/branch".parse().unwrap(),
+            None
+        )
+        .unwrap_err()
+        .to_string(),
         "branch refs/remotes/origin/branch was not found"
     );
 }
@@ -320,7 +301,6 @@ fn from_state_remote_branch() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -339,19 +319,20 @@ fn from_state_remote_branch() {
         repository.push();
     }
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch_from_branch(
-            project,
-            &"refs/remotes/origin/branch".parse().unwrap(),
-            None,
-        )
-        .unwrap();
+    let branch_id = gitbutler_branch_actions::create_virtual_branch_from_branch(
+        project,
+        &"refs/remotes/origin/branch".parse().unwrap(),
+        None,
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].id, branch_id);
     assert_eq!(branches[0].commits.len(), 1);
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/delete_virtual_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/delete_virtual_branch.rs
index 15fb8236d..18ae84cb7 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/delete_virtual_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/delete_virtual_branch.rs
@@ -6,25 +6,24 @@ use super::*;
 fn should_unapply_diff() {
     let Test {
         project,
-        controller,
         repository,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     // write some
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
 
-    controller
-        .delete_virtual_branch(project, branches[0].id)
-        .unwrap();
+    gitbutler_branch_actions::delete_virtual_branch(project, branches[0].id).unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 0);
     assert!(!repository.path().join("file.txt").exists());
 
@@ -40,28 +39,28 @@ fn should_unapply_diff() {
 fn should_remove_reference() {
     let Test {
         project,
-        controller,
         repository,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let id = controller
-        .create_virtual_branch(
-            project,
-            &BranchCreateRequest {
-                name: Some("name".to_string()),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    let id = gitbutler_branch_actions::create_virtual_branch(
+        project,
+        &BranchCreateRequest {
+            name: Some("name".to_string()),
+            ..Default::default()
+        },
+    )
+    .unwrap();
 
-    controller.delete_virtual_branch(project, id).unwrap();
+    gitbutler_branch_actions::delete_virtual_branch(project, id).unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 0);
 
     let refnames = repository
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/init.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/init.rs
index 422dbff0a..04af6d24b 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/init.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/init.rs
@@ -7,33 +7,33 @@ fn twice() {
 
     let test_project = TestProject::default();
 
-    let controller = VirtualBranchActions {};
-
     {
         let project = projects
             .add(test_project.path())
             .expect("failed to add project");
-        controller
-            .set_base_branch(&project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
-        assert!(controller
-            .list_virtual_branches(&project)
+        gitbutler_branch_actions::set_base_branch(
+            &project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
+        assert!(gitbutler_branch_actions::list_virtual_branches(&project)
             .unwrap()
             .0
             .is_empty());
         projects.delete(project.id).unwrap();
-        controller.list_virtual_branches(&project).unwrap_err();
+        gitbutler_branch_actions::list_virtual_branches(&project).unwrap_err();
     }
 
     {
         let project = projects.add(test_project.path()).unwrap();
-        controller
-            .set_base_branch(&project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            &project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         // even though project is on gitbutler/workspace, we should not import it
-        assert!(controller
-            .list_virtual_branches(&project)
+        assert!(gitbutler_branch_actions::list_virtual_branches(&project)
             .unwrap()
             .0
             .is_empty());
@@ -47,7 +47,6 @@ fn dirty_non_target() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -55,11 +54,13 @@ fn dirty_non_target() {
 
     fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].files.len(), 1);
     assert_eq!(branches[0].files[0].hunks.len(), 1);
@@ -74,17 +75,18 @@ fn dirty_target() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
     fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].files.len(), 1);
     assert_eq!(branches[0].files[0].hunks.len(), 1);
@@ -97,7 +99,6 @@ fn commit_on_non_target_local() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -105,11 +106,13 @@ fn commit_on_non_target_local() {
     fs::write(repository.path().join("file.txt"), "content").unwrap();
     repository.commit_all("commit on target");
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert!(branches[0].files.is_empty());
     assert_eq!(branches[0].commits.len(), 1);
@@ -122,7 +125,6 @@ fn commit_on_non_target_remote() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -131,11 +133,13 @@ fn commit_on_non_target_remote() {
     repository.commit_all("commit on target");
     repository.push_branch(&"refs/heads/some-feature".parse().unwrap());
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert!(branches[0].files.is_empty());
     assert_eq!(branches[0].commits.len(), 1);
@@ -148,18 +152,19 @@ fn commit_on_target() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
     fs::write(repository.path().join("file.txt"), "content").unwrap();
     repository.commit_all("commit on target");
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert!(branches[0].files.is_empty());
     assert_eq!(branches[0].commits.len(), 1);
@@ -172,7 +177,6 @@ fn submodule() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -181,11 +185,13 @@ fn submodule() {
         test_project.path().display().to_string().parse().unwrap();
     repository.add_submodule(&submodule_url, path::Path::new("submodule"));
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].files.len(), 1);
     assert_eq!(branches[0].files[0].hunks.len(), 1);
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/insert_blank_commit.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/insert_blank_commit.rs
index 716726fcd..f41bb5aa6 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/insert_blank_commit.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/insert_blank_commit.rs
@@ -7,43 +7,41 @@ fn insert_blank_commit_down() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let _commit1_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let _commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file2.txt"), "content2").unwrap();
     fs::write(repository.path().join("file3.txt"), "content3").unwrap();
-    let commit2_id = controller
-        .create_commit(project, branch_id, "commit two", None, false)
-        .unwrap();
+    let commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file4.txt"), "content4").unwrap();
-    let _commit3_id = controller
-        .create_commit(project, branch_id, "commit three", None, false)
-        .unwrap();
+    let _commit3_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
+            .unwrap();
 
-    controller
-        .insert_blank_commit(project, branch_id, commit2_id, 1)
-        .unwrap();
+    gitbutler_branch_actions::insert_blank_commit(project, branch_id, commit2_id, 1).unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -72,43 +70,41 @@ fn insert_blank_commit_up() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let _commit1_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let _commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file2.txt"), "content2").unwrap();
     fs::write(repository.path().join("file3.txt"), "content3").unwrap();
-    let commit2_id = controller
-        .create_commit(project, branch_id, "commit two", None, false)
-        .unwrap();
+    let commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file4.txt"), "content4").unwrap();
-    let _commit3_id = controller
-        .create_commit(project, branch_id, "commit three", None, false)
-        .unwrap();
+    let _commit3_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
+            .unwrap();
 
-    controller
-        .insert_blank_commit(project, branch_id, commit2_id, -1)
-        .unwrap();
+    gitbutler_branch_actions::insert_blank_commit(project, branch_id, commit2_id, -1).unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/mod.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/mod.rs
index 57a6286bb..a7cce95e8 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/mod.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/mod.rs
@@ -1,8 +1,8 @@
 use std::{fs, path, path::PathBuf, str::FromStr};
 
 use gitbutler_branch::{BranchCreateRequest, VirtualBranchesHandle};
+use gitbutler_branch_actions::update_workspace_commit;
 use gitbutler_branch_actions::GITBUTLER_WORKSPACE_COMMIT_TITLE;
-use gitbutler_branch_actions::{update_workspace_commit, VirtualBranchActions};
 use gitbutler_command_context::CommandContext;
 use gitbutler_error::error::Marker;
 use gitbutler_project::{self as projects, Project, ProjectId};
@@ -15,7 +15,6 @@ struct Test {
     project_id: ProjectId,
     project: Project,
     projects: projects::Controller,
-    controller: VirtualBranchActions,
     data_dir: Option<TempDir>,
 }
 
@@ -40,7 +39,6 @@ impl Default for Test {
         Self {
             repository: test_project,
             project_id: project.id,
-            controller: VirtualBranchActions {},
             projects,
             project,
             data_dir: Some(data_dir),
@@ -89,7 +87,6 @@ fn resolve_conflict_flow() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -105,18 +102,22 @@ fn resolve_conflict_flow() {
         repository.reset_hard(Some(first_commit_oid));
     }
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     {
         // make a branch that conflicts with the remote branch, but doesn't know about it yet
-        let branch1_id = controller
-            .create_virtual_branch(project, &BranchCreateRequest::default())
-            .unwrap();
+        let branch1_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest::default(),
+        )
+        .unwrap();
         fs::write(repository.path().join("file.txt"), "conflict").unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert!(branches[0].active);
@@ -124,11 +125,11 @@ fn resolve_conflict_flow() {
 
     let unapplied_branch = {
         // fetch remote. There is now a conflict, so the branch will be unapplied
-        let unapplied_branches = controller.update_base_branch(project).unwrap();
+        let unapplied_branches = gitbutler_branch_actions::update_base_branch(project).unwrap();
         assert_eq!(unapplied_branches.len(), 1);
 
         // there is a conflict now, so the branch should be inactive
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 0);
 
         Refname::from_str(&unapplied_branches[0]).unwrap()
@@ -136,14 +137,17 @@ fn resolve_conflict_flow() {
 
     let branch1_id = {
         // when we apply conflicted branch, it has conflict
-        let branch1_id = controller
-            .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-            .unwrap();
+        let branch1_id = gitbutler_branch_actions::create_virtual_branch_from_branch(
+            project,
+            &unapplied_branch,
+            None,
+        )
+        .unwrap();
 
         let vb_state = VirtualBranchesHandle::new(project.gb_dir());
         let ctx = CommandContext::open(project).unwrap();
         update_workspace_commit(&vb_state, &ctx).unwrap();
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert!(branches[0].active);
         assert!(branches[0].conflicted);
@@ -161,10 +165,15 @@ fn resolve_conflict_flow() {
     {
         // can't commit conflicts
         assert!(matches!(
-            controller
-                .create_commit(project, branch1_id, "commit conflicts", None, false)
-                .unwrap_err()
-                .downcast_ref(),
+            gitbutler_branch_actions::create_commit(
+                project,
+                branch1_id,
+                "commit conflicts",
+                None,
+                false
+            )
+            .unwrap_err()
+            .downcast_ref(),
             Some(Marker::ProjectConflict)
         ));
     }
@@ -172,15 +181,15 @@ fn resolve_conflict_flow() {
     {
         // fixing the conflict removes conflicted mark
         fs::write(repository.path().join("file.txt"), "resolved").unwrap();
-        controller.list_virtual_branches(project).unwrap();
-        let commit_oid = controller
-            .create_commit(project, branch1_id, "resolution", None, false)
-            .unwrap();
+        gitbutler_branch_actions::list_virtual_branches(project).unwrap();
+        let commit_oid =
+            gitbutler_branch_actions::create_commit(project, branch1_id, "resolution", None, false)
+                .unwrap();
 
         let commit = repository.find_commit(commit_oid).unwrap();
         assert_eq!(commit.parent_count(), 2);
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert!(branches[0].active);
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/move_commit_file.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/move_commit_file.rs
index fb7f9b95a..86db3737f 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/move_commit_file.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/move_commit_file.rs
@@ -8,41 +8,42 @@ fn move_file_down() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let commit1_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
     let commit1 = repository.find_commit(commit1_id).unwrap();
 
     // create commit
     fs::write(repository.path().join("file2.txt"), "content2").unwrap();
     fs::write(repository.path().join("file3.txt"), "content3").unwrap();
-    let commit2_id = controller
-        .create_commit(project, branch_id, "commit two", None, false)
-        .unwrap();
+    let commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
+            .unwrap();
     let commit2 = repository.find_commit(commit2_id).unwrap();
 
     // amend another hunk
     let to_amend: BranchOwnershipClaims = "file2.txt:1-2".parse().unwrap();
-    controller
-        .move_commit_file(project, branch_id, commit2_id, commit1_id, &to_amend)
-        .unwrap();
+    gitbutler_branch_actions::move_commit_file(
+        project, branch_id, commit2_id, commit1_id, &to_amend,
+    )
+    .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -66,39 +67,40 @@ fn move_file_up() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
     fs::write(repository.path().join("file2.txt"), "content2").unwrap();
-    let commit1_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file3.txt"), "content3").unwrap();
-    let commit2_id = controller
-        .create_commit(project, branch_id, "commit two", None, false)
-        .unwrap();
+    let commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
+            .unwrap();
 
     // amend another hunk
     let to_amend: BranchOwnershipClaims = "file2.txt:1-2".parse().unwrap();
-    controller
-        .move_commit_file(project, branch_id, commit1_id, commit2_id, &to_amend)
-        .unwrap();
+    gitbutler_branch_actions::move_commit_file(
+        project, branch_id, commit1_id, commit2_id, &to_amend,
+    )
+    .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -119,32 +121,28 @@ fn move_file_up_overlapping_hunks() {
     let Test {
         repository,
         project_id,
-        controller,
+
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
+    gitbutler_branch_actions::set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
 
         .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
+    let branch_id = gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
 
         .unwrap();
 
     // create bottom commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let _commit1_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
+    let _commit1_id = gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
 
         .unwrap();
 
     // create middle commit one
     fs::write(repository.path().join("file2.txt"), "content2\ncontent2a\n").unwrap();
     fs::write(repository.path().join("file3.txt"), "content3").unwrap();
-    let commit2_id = controller
-        .create_commit(project, branch_id, "commit two", None, false)
+    let commit2_id = gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
 
         .unwrap();
 
@@ -155,27 +153,23 @@ fn move_file_up_overlapping_hunks() {
     )
     .unwrap();
     fs::write(repository.path().join("file4.txt"), "content4").unwrap();
-    let commit3_id = controller
-        .create_commit(project, branch_id, "commit three", None, false)
+    let commit3_id = gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
 
         .unwrap();
 
     // create top commit
     fs::write(repository.path().join("file5.txt"), "content5").unwrap();
-    let _commit4_id = controller
-        .create_commit(project, branch_id, "commit four", None, false)
+    let _commit4_id = gitbutler_branch_actions::create_commit(project, branch_id, "commit four", None, false)
 
         .unwrap();
 
     // move one line from middle commit two up to middle commit one
     let to_amend: BranchOwnershipClaims = "file2.txt:1-6".parse().unwrap();
-    controller
-        .move_commit_file(project, branch_id, commit2_id, commit3_id, &to_amend)
+    gitbutler_branch_actions::move_commit_file(project, branch_id, commit2_id, commit3_id, &to_amend)
 
         .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
 
         .unwrap()
         .0
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/move_commit_to_vbranch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/move_commit_to_vbranch.rs
index 853719469..cd2a76ffc 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/move_commit_to_vbranch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/move_commit_to_vbranch.rs
@@ -7,43 +7,40 @@ fn no_diffs() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
     let source_branch_id = branches[0].id;
 
-    let commit_oid = controller
-        .create_commit(project, source_branch_id, "commit", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, source_branch_id, "commit", None, false)
+            .unwrap();
 
-    let target_branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let target_branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
-    controller
-        .move_commit(project, target_branch_id, commit_oid)
-        .unwrap();
+    gitbutler_branch_actions::move_commit(project, target_branch_id, commit_oid).unwrap();
 
-    let destination_branch = controller
-        .list_virtual_branches(project)
+    let destination_branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
         .find(|b| b.id == target_branch_id)
         .unwrap();
 
-    let source_branch = controller
-        .list_virtual_branches(project)
+    let source_branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -61,24 +58,25 @@ fn diffs_on_source_branch() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
     let source_branch_id = branches[0].id;
 
-    let commit_oid = controller
-        .create_commit(project, source_branch_id, "commit", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, source_branch_id, "commit", None, false)
+            .unwrap();
 
     std::fs::write(
         repository.path().join("another file.txt"),
@@ -86,24 +84,20 @@ fn diffs_on_source_branch() {
     )
     .unwrap();
 
-    let target_branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let target_branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
-    controller
-        .move_commit(project, target_branch_id, commit_oid)
-        .unwrap();
+    gitbutler_branch_actions::move_commit(project, target_branch_id, commit_oid).unwrap();
 
-    let destination_branch = controller
-        .list_virtual_branches(project)
+    let destination_branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
         .find(|b| b.id == target_branch_id)
         .unwrap();
 
-    let source_branch = controller
-        .list_virtual_branches(project)
+    let source_branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -121,34 +115,34 @@ fn diffs_on_target_branch() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
     let source_branch_id = branches[0].id;
 
-    let commit_oid = controller
-        .create_commit(project, source_branch_id, "commit", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, source_branch_id, "commit", None, false)
+            .unwrap();
 
-    let target_branch_id = controller
-        .create_virtual_branch(
-            project,
-            &BranchCreateRequest {
-                selected_for_changes: Some(true),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    let target_branch_id = gitbutler_branch_actions::create_virtual_branch(
+        project,
+        &BranchCreateRequest {
+            selected_for_changes: Some(true),
+            ..Default::default()
+        },
+    )
+    .unwrap();
 
     std::fs::write(
         repository.path().join("another file.txt"),
@@ -156,20 +150,16 @@ fn diffs_on_target_branch() {
     )
     .unwrap();
 
-    controller
-        .move_commit(project, target_branch_id, commit_oid)
-        .unwrap();
+    gitbutler_branch_actions::move_commit(project, target_branch_id, commit_oid).unwrap();
 
-    let destination_branch = controller
-        .list_virtual_branches(project)
+    let destination_branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
         .find(|b| b.id == target_branch_id)
         .unwrap();
 
-    let source_branch = controller
-        .list_virtual_branches(project)
+    let source_branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -187,34 +177,34 @@ fn locked_hunks_on_source_branch() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
     let source_branch_id = branches[0].id;
 
-    let commit_oid = controller
-        .create_commit(project, source_branch_id, "commit", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, source_branch_id, "commit", None, false)
+            .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "locked content").unwrap();
 
-    let target_branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let target_branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     assert_eq!(
-        controller
-            .move_commit(project, target_branch_id, commit_oid)
+        gitbutler_branch_actions::move_commit(project, target_branch_id, commit_oid)
             .unwrap_err()
             .to_string(),
         "the source branch contains hunks locked to the target commit"
@@ -226,39 +216,38 @@ fn no_commit() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
     let source_branch_id = branches[0].id;
 
-    controller
-        .create_commit(project, source_branch_id, "commit", None, false)
+    gitbutler_branch_actions::create_commit(project, source_branch_id, "commit", None, false)
         .unwrap();
 
-    let target_branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let target_branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let commit_id_hex = "a99c95cca7a60f1a2180c2f86fb18af97333c192";
     assert_eq!(
-        controller
-            .move_commit(
-                project,
-                target_branch_id,
-                git2::Oid::from_str(commit_id_hex).unwrap()
-            )
-            .unwrap_err()
-            .to_string(),
+        gitbutler_branch_actions::move_commit(
+            project,
+            target_branch_id,
+            git2::Oid::from_str(commit_id_hex).unwrap()
+        )
+        .unwrap_err()
+        .to_string(),
         format!("commit {commit_id_hex} to be moved could not be found")
     );
 }
@@ -268,29 +257,29 @@ fn no_branch() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
     let source_branch_id = branches[0].id;
 
-    let commit_oid = controller
-        .create_commit(project, source_branch_id, "commit", None, false)
-        .unwrap();
+    let commit_oid =
+        gitbutler_branch_actions::create_commit(project, source_branch_id, "commit", None, false)
+            .unwrap();
 
     let id = BranchId::generate();
     assert_eq!(
-        controller
-            .move_commit(project, id, commit_oid)
+        gitbutler_branch_actions::move_commit(project, id, commit_oid)
             .unwrap_err()
             .to_string(),
         format!("branch {id} is not among applied branches")
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/oplog.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/oplog.rs
index c9fb22a3e..b85fb404a 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/oplog.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/oplog.rs
@@ -11,14 +11,16 @@ fn workdir_vbranch_restore() -> anyhow::Result<()> {
     let test = Test::default();
     let Test {
         repository,
-        controller,
+
         project,
         ..
     } = &test;
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     let worktree_dir = repository.path();
     for round in 0..3 {
@@ -27,14 +29,14 @@ fn workdir_vbranch_restore() -> anyhow::Result<()> {
             worktree_dir.join(format!("file{round}.txt")),
             make_lines(line_count),
         )?;
-        let branch_id = controller.create_virtual_branch(
+        let branch_id = gitbutler_branch_actions::create_virtual_branch(
             project,
             &BranchCreateRequest {
                 name: Some(round.to_string()),
                 ..Default::default()
             },
         )?;
-        controller.create_commit(
+        gitbutler_branch_actions::create_commit(
             project,
             branch_id,
             &format!("commit {round}"),
@@ -51,7 +53,7 @@ fn workdir_vbranch_restore() -> anyhow::Result<()> {
             line_count > 20
         );
     }
-    let _empty = controller.create_virtual_branch(project, &Default::default())?;
+    let _empty = gitbutler_branch_actions::create_virtual_branch(project, &Default::default())?;
 
     let snapshots = project.list_snapshots(10, None)?;
     assert_eq!(
@@ -96,18 +98,20 @@ fn make_lines(count: usize) -> Vec<u8> {
 fn basic_oplog() -> anyhow::Result<()> {
     let Test {
         repository,
-        controller,
+
         project,
         ..
     } = &Test::default();
 
-    controller.set_base_branch(project, &"refs/remotes/origin/master".parse()?)?;
+    gitbutler_branch_actions::set_base_branch(project, &"refs/remotes/origin/master".parse()?)?;
 
-    let branch_id = controller.create_virtual_branch(project, &BranchCreateRequest::default())?;
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())?;
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content")?;
-    let _commit1_id = controller.create_commit(project, branch_id, "commit one", None, false)?;
+    let _commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)?;
 
     // dont store large files
     let file_path = repository.path().join("large.txt");
@@ -121,7 +125,8 @@ fn basic_oplog() -> anyhow::Result<()> {
     // create commit with large file
     fs::write(repository.path().join("file2.txt"), "content2")?;
     fs::write(repository.path().join("file3.txt"), "content3")?;
-    let commit2_id = controller.create_commit(project, branch_id, "commit two", None, false)?;
+    let commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)?;
 
     // Create conflict state
     let conflicts_path = repository.path().join(".git").join("conflicts");
@@ -131,22 +136,22 @@ fn basic_oplog() -> anyhow::Result<()> {
 
     // create state with conflict state
     let _empty_branch_id =
-        controller.create_virtual_branch(project, &BranchCreateRequest::default())?;
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())?;
 
     std::fs::remove_file(&base_merge_parent_path)?;
     std::fs::remove_file(&conflicts_path)?;
 
     fs::write(repository.path().join("file4.txt"), "content4")?;
-    let _commit3_id = controller.create_commit(project, branch_id, "commit three", None, false)?;
+    let _commit3_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)?;
 
-    let branch = controller
-        .list_virtual_branches(project)?
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)?
         .0
         .into_iter()
         .find(|b| b.id == branch_id)
         .unwrap();
 
-    let branches = controller.list_virtual_branches(project)?;
+    let branches = gitbutler_branch_actions::list_virtual_branches(project)?;
     assert_eq!(branches.0.len(), 2);
 
     assert_eq!(branch.commits.len(), 3);
@@ -185,7 +190,7 @@ fn basic_oplog() -> anyhow::Result<()> {
     project.restore_snapshot(snapshots[2].clone().commit_id)?;
 
     // the restore removed our new branch
-    let branches = controller.list_virtual_branches(project)?;
+    let branches = gitbutler_branch_actions::list_virtual_branches(project)?;
     assert_eq!(branches.0.len(), 1);
 
     // assert that the conflicts file was removed
@@ -233,12 +238,12 @@ fn basic_oplog() -> anyhow::Result<()> {
 fn restores_gitbutler_workspace() -> anyhow::Result<()> {
     let Test {
         repository,
-        controller,
+
         project,
         ..
     } = &Test::default();
 
-    controller.set_base_branch(project, &"refs/remotes/origin/master".parse()?)?;
+    gitbutler_branch_actions::set_base_branch(project, &"refs/remotes/origin/master".parse()?)?;
 
     assert_eq!(
         VirtualBranchesHandle::new(project.gb_dir())
@@ -246,7 +251,8 @@ fn restores_gitbutler_workspace() -> anyhow::Result<()> {
             .len(),
         0
     );
-    let branch_id = controller.create_virtual_branch(project, &BranchCreateRequest::default())?;
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())?;
     assert_eq!(
         VirtualBranchesHandle::new(project.gb_dir())
             .list_branches_in_workspace()?
@@ -256,7 +262,8 @@ fn restores_gitbutler_workspace() -> anyhow::Result<()> {
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content")?;
-    let _commit1_id = controller.create_commit(project, branch_id, "commit one", None, false)?;
+    let _commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)?;
 
     let repo = git2::Repository::open(&project.path)?;
 
@@ -269,7 +276,8 @@ fn restores_gitbutler_workspace() -> anyhow::Result<()> {
 
     // create second commit
     fs::write(repository.path().join("file.txt"), "changed content")?;
-    let _commit2_id = controller.create_commit(project, branch_id, "commit two", None, false)?;
+    let _commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)?;
 
     // check the workspace commit changed
     let head = repo.head().expect("never unborn");
@@ -347,17 +355,21 @@ fn restores_gitbutler_workspace() -> anyhow::Result<()> {
 fn head_corrupt_is_recreated_automatically() {
     let Test {
         repository,
-        controller,
+
         project,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     let snapshots = project.list_snapshots(10, None).unwrap();
     assert_eq!(
@@ -374,9 +386,11 @@ fn head_corrupt_is_recreated_automatically() {
     )
     .unwrap();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .expect("the snapshot doesn't fail despite the corrupt head");
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .expect("the snapshot doesn't fail despite the corrupt head");
 
     let snapshots = project.list_snapshots(10, None).unwrap();
     assert_eq!(
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/references.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/references.rs
index 4beb41b29..674abb524 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/references.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/references.rs
@@ -9,20 +9,24 @@ mod create_virtual_branch {
     fn simple() {
         let Test {
             project,
-            controller,
+
             repository,
             ..
         } = &Test::default();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let branch_id = controller
-            .create_virtual_branch(project, &BranchCreateRequest::default())
-            .unwrap();
+        let branch_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest::default(),
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch_id);
         assert_eq!(branches[0].name, "Virtual branch");
@@ -39,36 +43,36 @@ mod create_virtual_branch {
     fn duplicate_name() {
         let Test {
             project,
-            controller,
+
             repository,
             ..
         } = &Test::default();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let branch1_id = controller
-            .create_virtual_branch(
-                project,
-                &BranchCreateRequest {
-                    name: Some("name".to_string()),
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        let branch1_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest {
+                name: Some("name".to_string()),
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
-        let branch2_id = controller
-            .create_virtual_branch(
-                project,
-                &BranchCreateRequest {
-                    name: Some("name".to_string()),
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        let branch2_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest {
+                name: Some("name".to_string()),
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 2);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].name, "name");
@@ -94,37 +98,37 @@ mod update_virtual_branch {
     fn simple() {
         let Test {
             project,
-            controller,
+
             repository,
             ..
         } = &Test::default();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let branch_id = controller
-            .create_virtual_branch(
-                project,
-                &BranchCreateRequest {
-                    name: Some("name".to_string()),
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        let branch_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest {
+                name: Some("name".to_string()),
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
-        controller
-            .update_virtual_branch(
-                project,
-                BranchUpdateRequest {
-                    id: branch_id,
-                    name: Some("new name".to_string()),
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        gitbutler_branch_actions::update_virtual_branch(
+            project,
+            BranchUpdateRequest {
+                id: branch_id,
+                name: Some("new name".to_string()),
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch_id);
         assert_eq!(branches[0].name, "new name");
@@ -142,46 +146,45 @@ mod update_virtual_branch {
     fn duplicate_name() {
         let Test {
             project,
-            controller,
+
             repository,
             ..
         } = &Test::default();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let branch1_id = controller
-            .create_virtual_branch(
-                project,
-                &BranchCreateRequest {
-                    name: Some("name".to_string()),
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        let branch1_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest {
+                name: Some("name".to_string()),
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
-        let branch2_id = controller
-            .create_virtual_branch(
-                project,
-                &BranchCreateRequest {
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        let branch2_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest {
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
-        controller
-            .update_virtual_branch(
-                project,
-                BranchUpdateRequest {
-                    id: branch2_id,
-                    name: Some("name".to_string()),
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        gitbutler_branch_actions::update_virtual_branch(
+            project,
+            BranchUpdateRequest {
+                id: branch2_id,
+                name: Some("name".to_string()),
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 2);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].name, "name");
@@ -207,35 +210,32 @@ mod push_virtual_branch {
     fn simple() {
         let Test {
             project,
-            controller,
+
             repository,
             ..
         } = &Test::default();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let branch1_id = controller
-            .create_virtual_branch(
-                project,
-                &BranchCreateRequest {
-                    name: Some("name".to_string()),
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        let branch1_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest {
+                name: Some("name".to_string()),
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
         fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-        controller
-            .create_commit(project, branch1_id, "test", None, false)
-            .unwrap();
-        controller
-            .push_virtual_branch(project, branch1_id, false, None)
-            .unwrap();
+        gitbutler_branch_actions::create_commit(project, branch1_id, "test", None, false).unwrap();
+        gitbutler_branch_actions::push_virtual_branch(project, branch1_id, false, None).unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].name, "name");
@@ -256,70 +256,65 @@ mod push_virtual_branch {
     fn duplicate_names() {
         let Test {
             project,
-            controller,
+
             repository,
             ..
         } = &Test::default();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         let branch1_id = {
             // create and push branch with some work
-            let branch1_id = controller
-                .create_virtual_branch(
-                    project,
-                    &BranchCreateRequest {
-                        name: Some("name".to_string()),
-                        ..Default::default()
-                    },
-                )
-                .unwrap();
+            let branch1_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest {
+                    name: Some("name".to_string()),
+                    ..Default::default()
+                },
+            )
+            .unwrap();
             fs::write(repository.path().join("file.txt"), "content").unwrap();
-            controller
-                .create_commit(project, branch1_id, "test", None, false)
+            gitbutler_branch_actions::create_commit(project, branch1_id, "test", None, false)
                 .unwrap();
-            controller
-                .push_virtual_branch(project, branch1_id, false, None)
+            gitbutler_branch_actions::push_virtual_branch(project, branch1_id, false, None)
                 .unwrap();
             branch1_id
         };
 
         // rename first branch
-        controller
-            .update_virtual_branch(
+        gitbutler_branch_actions::update_virtual_branch(
+            project,
+            BranchUpdateRequest {
+                id: branch1_id,
+                name: Some("updated name".to_string()),
+                ..Default::default()
+            },
+        )
+        .unwrap();
+
+        let branch2_id = {
+            // create another branch with first branch's old name and push it
+            let branch2_id = gitbutler_branch_actions::create_virtual_branch(
                 project,
-                BranchUpdateRequest {
-                    id: branch1_id,
-                    name: Some("updated name".to_string()),
+                &BranchCreateRequest {
+                    name: Some("name".to_string()),
                     ..Default::default()
                 },
             )
             .unwrap();
-
-        let branch2_id = {
-            // create another branch with first branch's old name and push it
-            let branch2_id = controller
-                .create_virtual_branch(
-                    project,
-                    &BranchCreateRequest {
-                        name: Some("name".to_string()),
-                        ..Default::default()
-                    },
-                )
-                .unwrap();
             fs::write(repository.path().join("file.txt"), "updated content").unwrap();
-            controller
-                .create_commit(project, branch2_id, "test", None, false)
+            gitbutler_branch_actions::create_commit(project, branch2_id, "test", None, false)
                 .unwrap();
-            controller
-                .push_virtual_branch(project, branch2_id, false, None)
+            gitbutler_branch_actions::push_virtual_branch(project, branch2_id, false, None)
                 .unwrap();
             branch2_id
         };
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 2);
         // first branch is pushing to old ref remotely
         assert_eq!(branches[0].id, branch1_id);
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/reorder_commit.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/reorder_commit.rs
index 072455fbf..ca7cd9e7c 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/reorder_commit.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/reorder_commit.rs
@@ -7,37 +7,35 @@ fn reorder_commit_down() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let _commit1_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let _commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file2.txt"), "content2").unwrap();
     fs::write(repository.path().join("file3.txt"), "content3").unwrap();
-    let commit2_id = controller
-        .create_commit(project, branch_id, "commit two", None, false)
-        .unwrap();
+    let commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
+            .unwrap();
 
-    controller
-        .reorder_commit(project, branch_id, commit2_id, 1)
-        .unwrap();
+    gitbutler_branch_actions::reorder_commit(project, branch_id, commit2_id, 1).unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -62,37 +60,35 @@ fn reorder_commit_up() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let commit1_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file2.txt"), "content2").unwrap();
     fs::write(repository.path().join("file3.txt"), "content3").unwrap();
-    let _commit2_id = controller
-        .create_commit(project, branch_id, "commit two", None, false)
-        .unwrap();
+    let _commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
+            .unwrap();
 
-    controller
-        .reorder_commit(project, branch_id, commit1_id, -1)
-        .unwrap();
+    gitbutler_branch_actions::reorder_commit(project, branch_id, commit1_id, -1).unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/reset_virtual_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/reset_virtual_branch.rs
index 7c9c31012..f1f1233b8 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/reset_virtual_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/reset_virtual_branch.rs
@@ -9,27 +9,28 @@ fn to_head() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch1_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch1_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let oid = {
         fs::write(repository.path().join("file.txt"), "content").unwrap();
 
         // commit changes
-        let oid = controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap();
+        let oid =
+            gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false)
+                .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 1);
@@ -45,11 +46,9 @@ fn to_head() {
 
     {
         // reset changes to head
-        controller
-            .reset_virtual_branch(project, branch1_id, oid)
-            .unwrap();
+        gitbutler_branch_actions::reset_virtual_branch(project, branch1_id, oid).unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 1);
@@ -67,27 +66,28 @@ fn to_target() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    let base_branch = controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    let base_branch = gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch1_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch1_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     {
         fs::write(repository.path().join("file.txt"), "content").unwrap();
 
         // commit changes
-        let oid = controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap();
+        let oid =
+            gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false)
+                .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 1);
@@ -101,11 +101,10 @@ fn to_target() {
 
     {
         // reset changes to head
-        controller
-            .reset_virtual_branch(project, branch1_id, base_branch.base_sha)
+        gitbutler_branch_actions::reset_virtual_branch(project, branch1_id, base_branch.base_sha)
             .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 0);
@@ -122,28 +121,29 @@ fn to_commit() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch1_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch1_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let first_commit_oid = {
         // commit some changes
 
         fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-        let oid = controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap();
+        let oid =
+            gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false)
+                .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 1);
@@ -161,11 +161,11 @@ fn to_commit() {
         // commit some more
         fs::write(repository.path().join("file.txt"), "more content").unwrap();
 
-        let second_commit_oid = controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap();
+        let second_commit_oid =
+            gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false)
+                .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 2);
@@ -180,11 +180,10 @@ fn to_commit() {
 
     {
         // reset changes to the first commit
-        controller
-            .reset_virtual_branch(project, branch1_id, first_commit_oid)
+        gitbutler_branch_actions::reset_virtual_branch(project, branch1_id, first_commit_oid)
             .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 1);
@@ -202,27 +201,28 @@ fn to_non_existing() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch1_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch1_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     {
         fs::write(repository.path().join("file.txt"), "content").unwrap();
 
         // commit changes
-        let oid = controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap();
+        let oid =
+            gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false)
+                .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 1);
@@ -237,14 +237,13 @@ fn to_non_existing() {
     };
 
     assert_eq!(
-        controller
-            .reset_virtual_branch(
-                project,
-                branch1_id,
-                "fe14df8c66b73c6276f7bb26102ad91da680afcb".parse().unwrap()
-            )
-            .unwrap_err()
-            .to_string(),
+        gitbutler_branch_actions::reset_virtual_branch(
+            project,
+            branch1_id,
+            "fe14df8c66b73c6276f7bb26102ad91da680afcb".parse().unwrap()
+        )
+        .unwrap_err()
+        .to_string(),
         "commit fe14df8c66b73c6276f7bb26102ad91da680afcb not in the branch"
     );
 }
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/selected_for_changes.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/selected_for_changes.rs
index 0cebf4be2..260b6c6ee 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/selected_for_changes.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/selected_for_changes.rs
@@ -7,27 +7,28 @@ fn unapplying_selected_branch_selects_anther() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file one.txt"), "").unwrap();
 
     // first branch should be created as default
-    let b_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let b_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // if default branch exists, new branch should not be created as default
-    let b2_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let b2_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
 
     let b = branches.iter().find(|b| b.id == b_id).unwrap();
 
@@ -36,9 +37,9 @@ fn unapplying_selected_branch_selects_anther() {
     assert!(b.selected_for_changes);
     assert!(!b2.selected_for_changes);
 
-    controller.convert_to_real_branch(project, b_id).unwrap();
+    gitbutler_branch_actions::convert_to_real_branch(project, b_id).unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
 
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].id, b2.id);
@@ -48,27 +49,25 @@ fn unapplying_selected_branch_selects_anther() {
 
 #[test]
 fn deleting_selected_branch_selects_anther() {
-    let Test {
-        project,
-        controller,
-        ..
-    } = &Test::default();
+    let Test { project, .. } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     // first branch should be created as default
-    let b_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let b_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // if default branch exists, new branch should not be created as default
-    let b2_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let b2_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
 
     let b = branches.iter().find(|b| b.id == b_id).unwrap();
 
@@ -77,9 +76,9 @@ fn deleting_selected_branch_selects_anther() {
     assert!(b.selected_for_changes);
     assert!(!b2.selected_for_changes);
 
-    controller.delete_virtual_branch(project, b_id).unwrap();
+    gitbutler_branch_actions::delete_virtual_branch(project, b_id).unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
 
     assert_eq!(branches.len(), 1);
     assert_eq!(branches[0].id, b2.id);
@@ -88,22 +87,19 @@ fn deleting_selected_branch_selects_anther() {
 
 #[test]
 fn create_virtual_branch_should_set_selected_for_changes() {
-    let Test {
-        project,
-        controller,
-        ..
-    } = &Test::default();
+    let Test { project, .. } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     // first branch should be created as default
-    let b_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
-    let branch = controller
-        .list_virtual_branches(project)
+    let b_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -112,11 +108,10 @@ fn create_virtual_branch_should_set_selected_for_changes() {
     assert!(branch.selected_for_changes);
 
     // if default branch exists, new branch should not be created as default
-    let b_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
-    let branch = controller
-        .list_virtual_branches(project)
+    let b_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -125,17 +120,15 @@ fn create_virtual_branch_should_set_selected_for_changes() {
     assert!(!branch.selected_for_changes);
 
     // explicitly don't make this one default
-    let b_id = controller
-        .create_virtual_branch(
-            project,
-            &BranchCreateRequest {
-                selected_for_changes: Some(false),
-                ..Default::default()
-            },
-        )
-        .unwrap();
-    let branch = controller
-        .list_virtual_branches(project)
+    let b_id = gitbutler_branch_actions::create_virtual_branch(
+        project,
+        &BranchCreateRequest {
+            selected_for_changes: Some(false),
+            ..Default::default()
+        },
+    )
+    .unwrap();
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -144,17 +137,15 @@ fn create_virtual_branch_should_set_selected_for_changes() {
     assert!(!branch.selected_for_changes);
 
     // explicitly make this one default
-    let b_id = controller
-        .create_virtual_branch(
-            project,
-            &BranchCreateRequest {
-                selected_for_changes: Some(true),
-                ..Default::default()
-            },
-        )
-        .unwrap();
-    let branch = controller
-        .list_virtual_branches(project)
+    let b_id = gitbutler_branch_actions::create_virtual_branch(
+        project,
+        &BranchCreateRequest {
+            selected_for_changes: Some(true),
+            ..Default::default()
+        },
+    )
+    .unwrap();
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -165,21 +156,18 @@ fn create_virtual_branch_should_set_selected_for_changes() {
 
 #[test]
 fn update_virtual_branch_should_reset_selected_for_changes() {
-    let Test {
+    let Test { project, .. } = &Test::default();
+
+    gitbutler_branch_actions::set_base_branch(
         project,
-        controller,
-        ..
-    } = &Test::default();
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
-
-    let b1_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
-    let b1 = controller
-        .list_virtual_branches(project)
+    let b1_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
+    let b1 = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -187,11 +175,10 @@ fn update_virtual_branch_should_reset_selected_for_changes() {
         .unwrap();
     assert!(b1.selected_for_changes);
 
-    let b2_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
-    let b2 = controller
-        .list_virtual_branches(project)
+    let b2_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
+    let b2 = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -199,19 +186,17 @@ fn update_virtual_branch_should_reset_selected_for_changes() {
         .unwrap();
     assert!(!b2.selected_for_changes);
 
-    controller
-        .update_virtual_branch(
-            project,
-            BranchUpdateRequest {
-                id: b2_id,
-                selected_for_changes: Some(true),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    gitbutler_branch_actions::update_virtual_branch(
+        project,
+        BranchUpdateRequest {
+            id: b2_id,
+            selected_for_changes: Some(true),
+            ..Default::default()
+        },
+    )
+    .unwrap();
 
-    let b1 = controller
-        .list_virtual_branches(project)
+    let b1 = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -219,8 +204,7 @@ fn update_virtual_branch_should_reset_selected_for_changes() {
         .unwrap();
     assert!(!b1.selected_for_changes);
 
-    let b2 = controller
-        .list_virtual_branches(project)
+    let b2 = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -234,21 +218,21 @@ fn unapply_virtual_branch_should_reset_selected_for_changes() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let b1_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let b1_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let b1 = controller
-        .list_virtual_branches(project)
+    let b1 = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -256,12 +240,11 @@ fn unapply_virtual_branch_should_reset_selected_for_changes() {
         .unwrap();
     assert!(b1.selected_for_changes);
 
-    let b2_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let b2_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
-    let b2 = controller
-        .list_virtual_branches(project)
+    let b2 = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -269,10 +252,9 @@ fn unapply_virtual_branch_should_reset_selected_for_changes() {
         .unwrap();
     assert!(!b2.selected_for_changes);
 
-    controller.convert_to_real_branch(project, b1_id).unwrap();
+    gitbutler_branch_actions::convert_to_real_branch(project, b1_id).unwrap();
 
-    assert!(controller
-        .list_virtual_branches(project)
+    assert!(gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -284,30 +266,30 @@ fn hunks_distribution() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches[0].files.len(), 1);
 
-    controller
-        .create_virtual_branch(
-            project,
-            &BranchCreateRequest {
-                selected_for_changes: Some(true),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    gitbutler_branch_actions::create_virtual_branch(
+        project,
+        &BranchCreateRequest {
+            selected_for_changes: Some(true),
+            ..Default::default()
+        },
+    )
+    .unwrap();
     std::fs::write(repository.path().join("another_file.txt"), "content").unwrap();
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches[0].files.len(), 1);
     assert_eq!(branches[1].files.len(), 1);
 }
@@ -317,28 +299,27 @@ fn applying_first_branch() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     std::fs::write(repository.path().join("file.txt"), "content").unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
 
-    let unapplied_branch = controller
-        .convert_to_real_branch(project, branches[0].id)
-        .unwrap();
+    let unapplied_branch =
+        gitbutler_branch_actions::convert_to_real_branch(project, branches[0].id).unwrap();
     let unapplied_branch = Refname::from_str(&unapplied_branch).unwrap();
-    controller
-        .create_virtual_branch_from_branch(project, &unapplied_branch, None)
+    gitbutler_branch_actions::create_virtual_branch_from_branch(project, &unapplied_branch, None)
         .unwrap();
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches.len(), 1);
     assert!(branches[0].active);
     assert!(branches[0].selected_for_changes);
@@ -351,7 +332,6 @@ fn new_locked_hunk_without_modifying_existing() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
@@ -359,44 +339,44 @@ fn new_locked_hunk_without_modifying_existing() {
     repository.commit_all("first commit");
     repository.push();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     lines[0] = "modification 1".to_string();
     repository.write_file("file.txt", &lines);
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches[0].files.len(), 1);
 
-    controller
-        .create_commit(project, branches[0].id, "second commit", None, false)
+    gitbutler_branch_actions::create_commit(project, branches[0].id, "second commit", None, false)
         .expect("failed to create commit");
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches[0].files.len(), 0);
     assert_eq!(branches[0].commits.len(), 1);
 
-    controller
-        .create_virtual_branch(
-            project,
-            &BranchCreateRequest {
-                selected_for_changes: Some(true),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    gitbutler_branch_actions::create_virtual_branch(
+        project,
+        &BranchCreateRequest {
+            selected_for_changes: Some(true),
+            ..Default::default()
+        },
+    )
+    .unwrap();
 
     lines[8] = "modification 2".to_string();
     repository.write_file("file.txt", &lines);
 
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches[0].files.len(), 0);
     assert_eq!(branches[1].files.len(), 1);
 
     lines[0] = "modification 3".to_string();
     repository.write_file("file.txt", &lines);
-    let (branches, _) = controller.list_virtual_branches(project).unwrap();
+    let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
     assert_eq!(branches[0].files.len(), 1);
     assert_eq!(branches[1].files.len(), 1);
 }
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/set_base_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/set_base_branch.rs
index 31de376fc..50be331a4 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/set_base_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/set_base_branch.rs
@@ -2,15 +2,13 @@ use super::*;
 
 #[test]
 fn success() {
-    let Test {
-        project,
-        controller,
-        ..
-    } = &Test::default();
+    let Test { project, .. } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 }
 
 mod error {
@@ -20,20 +18,15 @@ mod error {
 
     #[test]
     fn missing() {
-        let Test {
-            project,
-            controller,
-            ..
-        } = &Test::default();
+        let Test { project, .. } = &Test::default();
 
         assert_eq!(
-            controller
-                .set_base_branch(
-                    project,
-                    &RemoteRefname::from_str("refs/remotes/origin/missing").unwrap(),
-                )
-                .unwrap_err()
-                .to_string(),
+            gitbutler_branch_actions::set_base_branch(
+                project,
+                &RemoteRefname::from_str("refs/remotes/origin/missing").unwrap(),
+            )
+            .unwrap_err()
+            .to_string(),
             "remote branch 'refs/remotes/origin/missing' not found"
         );
     }
@@ -50,7 +43,6 @@ mod go_back_to_workspace {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -60,29 +52,33 @@ mod go_back_to_workspace {
         repository.commit_all("two");
         repository.push();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let vbranch_id = controller
-            .create_virtual_branch(project, &BranchCreateRequest::default())
-            .unwrap();
+        let vbranch_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest::default(),
+        )
+        .unwrap();
 
         std::fs::write(repository.path().join("another file.txt"), "content").unwrap();
-        controller
-            .create_commit(project, vbranch_id, "one", None, false)
-            .unwrap();
+        gitbutler_branch_actions::create_commit(project, vbranch_id, "one", None, false).unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
 
         repository.checkout_commit(oid_one);
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, vbranch_id);
         assert!(branches[0].active);
@@ -93,7 +89,6 @@ mod go_back_to_workspace {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -103,21 +98,25 @@ mod go_back_to_workspace {
         repository.commit_all("two");
         repository.push();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert!(branches.is_empty());
 
         repository.checkout_commit(oid_one);
         std::fs::write(repository.path().join("file.txt"), "tree").unwrap();
 
         assert!(matches!(
-            controller
-                .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-                .unwrap_err()
-                .downcast_ref(),
+            gitbutler_branch_actions::set_base_branch(
+                project,
+                &"refs/remotes/origin/master".parse().unwrap()
+            )
+            .unwrap_err()
+            .downcast_ref(),
             Some(Marker::ProjectConflict)
         ));
     }
@@ -127,7 +126,6 @@ mod go_back_to_workspace {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -137,21 +135,25 @@ mod go_back_to_workspace {
         repository.commit_all("two");
         repository.push();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert!(branches.is_empty());
 
         repository.checkout_commit(oid_one);
         std::fs::write(repository.path().join("another file.txt"), "tree").unwrap();
 
         assert!(matches!(
-            controller
-                .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-                .unwrap_err()
-                .downcast_ref(),
+            gitbutler_branch_actions::set_base_branch(
+                project,
+                &"refs/remotes/origin/master".parse().unwrap()
+            )
+            .unwrap_err()
+            .downcast_ref(),
             Some(Marker::ProjectConflict)
         ));
     }
@@ -161,7 +163,6 @@ mod go_back_to_workspace {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -171,22 +172,26 @@ mod go_back_to_workspace {
         repository.commit_all("two");
         repository.push();
 
-        let base = controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        let base = gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert!(branches.is_empty());
 
         repository.checkout_commit(oid_one);
         std::fs::write(repository.path().join("another file.txt"), "tree").unwrap();
         repository.commit_all("three");
 
-        let base_two = controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        let base_two = gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 0);
         assert_eq!(base_two, base);
     }
@@ -196,7 +201,6 @@ mod go_back_to_workspace {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -206,20 +210,24 @@ mod go_back_to_workspace {
         repository.commit_all("two");
         repository.push();
 
-        let base = controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        let base = gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert!(branches.is_empty());
 
         repository.checkout_commit(oid_one);
 
-        let base_two = controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        let base_two = gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 0);
         assert_eq!(base_two, base);
     }
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/squash.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/squash.rs
index 4e5bf144a..2106b9d8f 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/squash.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/squash.rs
@@ -7,52 +7,46 @@ fn head() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file two.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit two", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file three.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit three", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
             .unwrap()
     };
 
     let commit_four_oid = {
         fs::write(repository.path().join("file four.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit four", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit four", None, false)
             .unwrap()
     };
 
-    controller
-        .squash(project, branch_id, commit_four_oid)
-        .unwrap();
+    gitbutler_branch_actions::squash(project, branch_id, commit_four_oid).unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -75,52 +69,46 @@ fn middle() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
     let commit_two_oid = {
         fs::write(repository.path().join("file two.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit two", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file three.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit three", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file four.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit four", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit four", None, false)
             .unwrap()
     };
 
-    controller
-        .squash(project, branch_id, commit_two_oid)
-        .unwrap();
+    gitbutler_branch_actions::squash(project, branch_id, commit_two_oid).unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -144,7 +132,6 @@ fn forcepush_allowed() {
         repository,
         project_id,
         project,
-        controller,
         projects,
         ..
     } = &Test::default();
@@ -156,52 +143,45 @@ fn forcepush_allowed() {
         })
         .unwrap();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
-    controller
-        .push_virtual_branch(project, branch_id, false, None)
-        .unwrap();
+    gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
     let commit_two_oid = {
         fs::write(repository.path().join("file two.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit two", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file three.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit three", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file four.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit four", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit four", None, false)
             .unwrap()
     };
 
-    controller
-        .squash(project, branch_id, commit_two_oid)
-        .unwrap();
+    gitbutler_branch_actions::squash(project, branch_id, commit_two_oid).unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -225,64 +205,57 @@ fn forcepush_forbidden() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
-    controller
-        .update_virtual_branch(
-            project,
-            BranchUpdateRequest {
-                id: branch_id,
-                allow_rebasing: Some(false),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    gitbutler_branch_actions::update_virtual_branch(
+        project,
+        BranchUpdateRequest {
+            id: branch_id,
+            allow_rebasing: Some(false),
+            ..Default::default()
+        },
+    )
+    .unwrap();
 
     {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
-    controller
-        .push_virtual_branch(project, branch_id, false, None)
-        .unwrap();
+    gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
     let commit_two_oid = {
         fs::write(repository.path().join("file two.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit two", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file three.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit three", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file four.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit four", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit four", None, false)
             .unwrap()
     };
 
     assert_eq!(
-        controller
-            .squash(project, branch_id, commit_two_oid)
+        gitbutler_branch_actions::squash(project, branch_id, commit_two_oid)
             .unwrap_err()
             .to_string(),
         "force push not allowed"
@@ -294,28 +267,27 @@ fn root_forbidden() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let commit_one_oid = {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
     assert_eq!(
-        controller
-            .squash(project, branch_id, commit_one_oid)
+        gitbutler_branch_actions::squash(project, branch_id, commit_one_oid)
             .unwrap_err()
             .to_string(),
         "can not squash root commit"
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/unapply_ownership.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/unapply_ownership.rs
index 112daabd9..545f849d7 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/unapply_ownership.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/unapply_ownership.rs
@@ -8,27 +8,26 @@ use super::Test;
 fn should_unapply_with_commits() {
     let Test {
         project,
-        controller,
         repository,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     fs::write(
         repository.path().join("file.txt"),
         "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n",
     )
     .unwrap();
-    controller
-        .create_commit(project, branch_id, "test", None, false)
-        .unwrap();
+    gitbutler_branch_actions::create_commit(project, branch_id, "test", None, false).unwrap();
 
     // change in the committed hunks leads to hunk locking
     fs::write(
@@ -37,17 +36,15 @@ fn should_unapply_with_commits() {
     )
     .unwrap();
 
-    controller
-        .unapply_ownership(
-            project,
-            &"file.txt:1-5,7-11"
-                .parse::<BranchOwnershipClaims>()
-                .unwrap(),
-        )
-        .unwrap_or_else(|err| panic!("{err:?}"));
+    gitbutler_branch_actions::unapply_ownership(
+        project,
+        &"file.txt:1-5,7-11"
+            .parse::<BranchOwnershipClaims>()
+            .unwrap(),
+    )
+    .unwrap_or_else(|err| panic!("{err:?}"));
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/undo_commit.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/undo_commit.rs
index 1646fba67..fe815c3e3 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/undo_commit.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/undo_commit.rs
@@ -7,43 +7,41 @@ fn undo_commit_simple() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file.txt"), "content").unwrap();
-    let _commit1_id = controller
-        .create_commit(project, branch_id, "commit one", None, false)
-        .unwrap();
+    let _commit1_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file2.txt"), "content2").unwrap();
     fs::write(repository.path().join("file3.txt"), "content3").unwrap();
-    let commit2_id = controller
-        .create_commit(project, branch_id, "commit two", None, false)
-        .unwrap();
+    let commit2_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
+            .unwrap();
 
     // create commit
     fs::write(repository.path().join("file4.txt"), "content4").unwrap();
-    let _commit3_id = controller
-        .create_commit(project, branch_id, "commit three", None, false)
-        .unwrap();
+    let _commit3_id =
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
+            .unwrap();
 
-    controller
-        .undo_commit(project, branch_id, commit2_id)
-        .unwrap();
+    gitbutler_branch_actions::undo_commit(project, branch_id, commit2_id).unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/update_base_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/update_base_branch.rs
index 02bf58c52..8d729c081 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/update_base_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/update_base_branch.rs
@@ -10,7 +10,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -24,27 +23,31 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         {
             // make a branch that conflicts with the remote branch, but doesn't know about it yet
-            controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "conflict").unwrap();
         }
 
         let unapplied_branch = {
             // fetch remote
-            let unapplied_branches = controller.update_base_branch(project).unwrap();
+            let unapplied_branches = gitbutler_branch_actions::update_base_branch(project).unwrap();
             assert_eq!(unapplied_branches.len(), 1);
 
             // should stash conflicting branch
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 0);
 
             Refname::from_str(unapplied_branches[0].as_str()).unwrap()
@@ -52,10 +55,13 @@ mod applied_branch {
 
         {
             // applying the branch should produce conflict markers
-            controller
-                .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-                .unwrap();
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            gitbutler_branch_actions::create_virtual_branch_from_branch(
+                project,
+                &unapplied_branch,
+                None,
+            )
+            .unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert!(branches[0].conflicted);
             assert!(branches[0].base_current);
@@ -72,7 +78,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -86,31 +91,40 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         {
             // make a branch with a commit that conflicts with upstream, and work that fixes
             // that conflict
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "conflict").unwrap();
-            controller
-                .create_commit(project, branch_id, "conflicting commit", None, false)
-                .unwrap();
+            gitbutler_branch_actions::create_commit(
+                project,
+                branch_id,
+                "conflicting commit",
+                None,
+                false,
+            )
+            .unwrap();
         }
 
         let unapplied_branch = {
             // when fetching remote
-            let unapplied_branches = controller.update_base_branch(project).unwrap();
+            let unapplied_branches = gitbutler_branch_actions::update_base_branch(project).unwrap();
             assert_eq!(unapplied_branches.len(), 1);
 
             // should stash the branch.
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 0);
 
             Refname::from_str(unapplied_branches[0].as_str()).unwrap()
@@ -118,10 +132,13 @@ mod applied_branch {
 
         {
             // applying the branch should produce conflict markers
-            controller
-                .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-                .unwrap();
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            gitbutler_branch_actions::create_virtual_branch_from_branch(
+                project,
+                &unapplied_branch,
+                None,
+            )
+            .unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert!(branches[0].conflicted);
             assert!(branches[0].base_current);
@@ -139,7 +156,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -153,35 +169,42 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         {
             // make a branch with a commit that conflicts with upstream, and work that fixes
             // that conflict
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "conflict").unwrap();
-            controller
-                .create_commit(project, branch_id, "conflicting commit", None, false)
-                .unwrap();
+            gitbutler_branch_actions::create_commit(
+                project,
+                branch_id,
+                "conflicting commit",
+                None,
+                false,
+            )
+            .unwrap();
 
-            controller
-                .push_virtual_branch(project, branch_id, false, None)
-                .unwrap();
+            gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
         }
 
         let unapplied_branch = {
             // when fetching remote
-            let unapplied_branches = controller.update_base_branch(project).unwrap();
+            let unapplied_branches = gitbutler_branch_actions::update_base_branch(project).unwrap();
             assert_eq!(unapplied_branches.len(), 1);
 
             // should stash the branch.
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 0);
 
             Refname::from_str(unapplied_branches[0].as_str()).unwrap()
@@ -189,10 +212,13 @@ mod applied_branch {
 
         {
             // applying the branch should produce conflict markers
-            controller
-                .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-                .unwrap();
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            gitbutler_branch_actions::create_virtual_branch_from_branch(
+                project,
+                &unapplied_branch,
+                None,
+            )
+            .unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert!(branches[0].conflicted);
             assert!(branches[0].base_current);
@@ -210,7 +236,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -224,33 +249,42 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         {
             // make a branch with a commit that conflicts with upstream, and work that fixes
             // that conflict
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "conflict").unwrap();
-            controller
-                .create_commit(project, branch_id, "conflicting commit", None, false)
-                .unwrap();
+            gitbutler_branch_actions::create_commit(
+                project,
+                branch_id,
+                "conflicting commit",
+                None,
+                false,
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "fix conflict").unwrap();
         }
 
         let unapplied_branch = {
             // when fetching remote
-            let unapplied_branches = controller.update_base_branch(project).unwrap();
+            let unapplied_branches = gitbutler_branch_actions::update_base_branch(project).unwrap();
             assert_eq!(unapplied_branches.len(), 1);
 
             // should rebase upstream, and leave uncommited file as is
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 0);
 
             Refname::from_str(unapplied_branches[0].as_str()).unwrap()
@@ -258,10 +292,13 @@ mod applied_branch {
 
         {
             // applying the branch should produce conflict markers
-            controller
-                .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-                .unwrap();
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            gitbutler_branch_actions::create_virtual_branch_from_branch(
+                project,
+                &unapplied_branch,
+                None,
+            )
+            .unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert!(branches[0].conflicted);
             assert!(branches[0].base_current);
@@ -279,7 +316,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -293,33 +329,42 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         {
             // make a branch with a commit that conflicts with upstream, and work that fixes
             // that conflict
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "conflict").unwrap();
-            controller
-                .create_commit(project, branch_id, "conflicting commit", None, false)
-                .unwrap();
+            gitbutler_branch_actions::create_commit(
+                project,
+                branch_id,
+                "conflicting commit",
+                None,
+                false,
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "fix conflict").unwrap();
         }
 
         let unapplied_branch = {
             // when fetching remote
-            let unapplied_branches = controller.update_base_branch(project).unwrap();
+            let unapplied_branches = gitbutler_branch_actions::update_base_branch(project).unwrap();
             assert_eq!(unapplied_branches.len(), 1);
 
             // should merge upstream, and leave uncommited file as is.
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 0);
 
             Refname::from_str(unapplied_branches[0].as_str()).unwrap()
@@ -327,10 +372,13 @@ mod applied_branch {
 
         {
             // applying the branch should produce conflict markers
-            controller
-                .create_virtual_branch_from_branch(project, &unapplied_branch, None)
-                .unwrap();
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            gitbutler_branch_actions::create_virtual_branch_from_branch(
+                project,
+                &unapplied_branch,
+                None,
+            )
+            .unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert!(branches[0].conflicted);
             assert!(branches[0].base_current);
@@ -354,7 +402,6 @@ mod applied_branch {
                 repository,
                 project,
                 project_id,
-                controller,
                 projects,
                 ..
             } = &Test::default();
@@ -376,22 +423,30 @@ mod applied_branch {
                 })
                 .unwrap();
 
-            controller
-                .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-                .unwrap();
+            gitbutler_branch_actions::set_base_branch(
+                project,
+                &"refs/remotes/origin/master".parse().unwrap(),
+            )
+            .unwrap();
 
             let branch_id = {
-                let branch_id = controller
-                    .create_virtual_branch(project, &BranchCreateRequest::default())
-                    .unwrap();
+                let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                    project,
+                    &BranchCreateRequest::default(),
+                )
+                .unwrap();
 
                 fs::write(repository.path().join("file2.txt"), "no conflict").unwrap();
 
-                controller
-                    .create_commit(project, branch_id, "no conflicts", None, false)
-                    .unwrap();
-                controller
-                    .push_virtual_branch(project, branch_id, false, None)
+                gitbutler_branch_actions::create_commit(
+                    project,
+                    branch_id,
+                    "no conflicts",
+                    None,
+                    false,
+                )
+                .unwrap();
+                gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None)
                     .unwrap();
 
                 fs::write(repository.path().join("file2.txt"), "still no conflict").unwrap();
@@ -401,12 +456,13 @@ mod applied_branch {
 
             {
                 // fetch remote
-                controller.update_base_branch(project).unwrap();
+                gitbutler_branch_actions::update_base_branch(project).unwrap();
 
                 // rebases branch, since the branch is pushed and force pushing is
                 // allowed
 
-                let (branches, _) = controller.list_virtual_branches(project).unwrap();
+                let (branches, _) =
+                    gitbutler_branch_actions::list_virtual_branches(project).unwrap();
                 assert_eq!(branches.len(), 1);
                 assert_eq!(branches[0].id, branch_id);
                 assert!(branches[0].active);
@@ -429,7 +485,6 @@ mod applied_branch {
             let Test {
                 repository,
                 project,
-                controller,
                 ..
             } = &Test::default();
 
@@ -443,22 +498,30 @@ mod applied_branch {
                 repository.reset_hard(Some(first_commit_oid));
             }
 
-            controller
-                .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-                .unwrap();
+            gitbutler_branch_actions::set_base_branch(
+                project,
+                &"refs/remotes/origin/master".parse().unwrap(),
+            )
+            .unwrap();
 
             let branch_id = {
-                let branch_id = controller
-                    .create_virtual_branch(project, &BranchCreateRequest::default())
-                    .unwrap();
+                let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                    project,
+                    &BranchCreateRequest::default(),
+                )
+                .unwrap();
 
                 fs::write(repository.path().join("file2.txt"), "no conflict").unwrap();
 
-                controller
-                    .create_commit(project, branch_id, "no conflicts", None, false)
-                    .unwrap();
-                controller
-                    .push_virtual_branch(project, branch_id, false, None)
+                gitbutler_branch_actions::create_commit(
+                    project,
+                    branch_id,
+                    "no conflicts",
+                    None,
+                    false,
+                )
+                .unwrap();
+                gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None)
                     .unwrap();
 
                 fs::write(repository.path().join("file2.txt"), "still no conflict").unwrap();
@@ -466,24 +529,24 @@ mod applied_branch {
                 branch_id
             };
 
-            controller
-                .update_virtual_branch(
-                    project,
-                    BranchUpdateRequest {
-                        id: branch_id,
-                        allow_rebasing: Some(false),
-                        ..Default::default()
-                    },
-                )
-                .unwrap();
+            gitbutler_branch_actions::update_virtual_branch(
+                project,
+                BranchUpdateRequest {
+                    id: branch_id,
+                    allow_rebasing: Some(false),
+                    ..Default::default()
+                },
+            )
+            .unwrap();
 
             {
                 // fetch remote
-                controller.update_base_branch(project).unwrap();
+                gitbutler_branch_actions::update_base_branch(project).unwrap();
 
                 // creates a merge commit, since the branch is pushed
 
-                let (branches, _) = controller.list_virtual_branches(project).unwrap();
+                let (branches, _) =
+                    gitbutler_branch_actions::list_virtual_branches(project).unwrap();
                 assert_eq!(branches.len(), 1);
                 assert_eq!(branches[0].id, branch_id);
                 assert!(branches[0].active);
@@ -504,7 +567,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -518,20 +580,29 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         let branch_id = {
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file2.txt"), "no conflict").unwrap();
 
-            controller
-                .create_commit(project, branch_id, "no conflicts", None, false)
-                .unwrap();
+            gitbutler_branch_actions::create_commit(
+                project,
+                branch_id,
+                "no conflicts",
+                None,
+                false,
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file2.txt"), "still no conflict").unwrap();
 
@@ -540,11 +611,11 @@ mod applied_branch {
 
         {
             // fetch remote
-            controller.update_base_branch(project).unwrap();
+            gitbutler_branch_actions::update_base_branch(project).unwrap();
 
             // just rebases branch
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert_eq!(branches[0].id, branch_id);
             assert!(branches[0].active);
@@ -568,7 +639,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -578,29 +648,29 @@ mod applied_branch {
             repository.push();
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         let branch_id = {
             // make a branch that conflicts with the remote branch, but doesn't know about it yet
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "second").unwrap();
 
-            controller
-                .create_commit(project, branch_id, "second", None, false)
-                .unwrap();
-            controller
-                .push_virtual_branch(project, branch_id, false, None)
+            gitbutler_branch_actions::create_commit(project, branch_id, "second", None, false)
                 .unwrap();
+            gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
             {
                 // merge branch upstream
-                let branch = controller
-                    .list_virtual_branches(project)
+                let branch = gitbutler_branch_actions::list_virtual_branches(project)
                     .unwrap()
                     .0
                     .into_iter()
@@ -618,11 +688,11 @@ mod applied_branch {
 
         {
             // fetch remote
-            controller.update_base_branch(project).unwrap();
+            gitbutler_branch_actions::update_base_branch(project).unwrap();
 
             // should remove integrated commit, but leave non integrated work as is
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert_eq!(branches[0].id, branch_id);
             assert!(branches[0].active);
@@ -646,7 +716,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -668,15 +737,19 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         // branch has no conflict
         let branch_id = {
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(
                 repository.path().join("file.txt"),
@@ -684,17 +757,14 @@ mod applied_branch {
             )
             .unwrap();
 
-            controller
-                .create_commit(project, branch_id, "fourth", None, false)
+            gitbutler_branch_actions::create_commit(project, branch_id, "fourth", None, false)
                 .unwrap();
 
             branch_id
         };
 
         // push the branch
-        controller
-            .push_virtual_branch(project, branch_id, false, None)
-            .unwrap();
+        gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
         // another locked conflicting hunk
         fs::write(
@@ -705,19 +775,22 @@ mod applied_branch {
 
         {
             // merge branch remotely
-            let branch = controller.list_virtual_branches(project).unwrap().0[0].clone();
+            let branch = gitbutler_branch_actions::list_virtual_branches(project)
+                .unwrap()
+                .0[0]
+                .clone();
             repository.merge(&branch.upstream.as_ref().unwrap().name);
         }
 
         repository.fetch();
 
         let unapplied_refname = {
-            let unapplied_refnames = controller.update_base_branch(project).unwrap();
+            let unapplied_refnames = gitbutler_branch_actions::update_base_branch(project).unwrap();
             assert_eq!(unapplied_refnames.len(), 1);
 
             // removes integrated commit, leaves non commited work as is
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 0);
             assert_eq!(
                 fs::read_to_string(repository.path().join("file.txt")).unwrap(),
@@ -728,18 +801,17 @@ mod applied_branch {
         };
 
         {
-            controller
-                .create_virtual_branch_from_branch(
-                    project,
-                    &Refname::from_str(unapplied_refname.as_str()).unwrap(),
-                    None,
-                )
-                .unwrap();
+            gitbutler_branch_actions::create_virtual_branch_from_branch(
+                project,
+                &Refname::from_str(unapplied_refname.as_str()).unwrap(),
+                None,
+            )
+            .unwrap();
 
             let vb_state = VirtualBranchesHandle::new(project.gb_dir());
             let ctx = CommandContext::open(project).unwrap();
             update_workspace_commit(&vb_state, &ctx).unwrap();
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert!(branches[0].active);
             assert!(branches[0].conflicted);
@@ -759,7 +831,6 @@ mod applied_branch {
             repository,
             project,
             project_id,
-            controller,
             projects,
             ..
         } = &Test::default();
@@ -771,45 +842,49 @@ mod applied_branch {
             })
             .unwrap();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         let branch_id = {
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "first").unwrap();
 
-            controller
-                .create_commit(project, branch_id, "first", None, false)
+            gitbutler_branch_actions::create_commit(project, branch_id, "first", None, false)
                 .unwrap();
 
             branch_id
         };
 
-        controller
-            .push_virtual_branch(project, branch_id, false, None)
-            .unwrap();
+        gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
         // another non-locked hunk
         fs::write(repository.path().join("file.txt"), "first\nsecond").unwrap();
 
         {
             // push and merge branch remotely
-            let branch = controller.list_virtual_branches(project).unwrap().0[0].clone();
+            let branch = gitbutler_branch_actions::list_virtual_branches(project)
+                .unwrap()
+                .0[0]
+                .clone();
             repository.merge(&branch.upstream.as_ref().unwrap().name);
         }
 
         repository.fetch();
 
         {
-            controller.update_base_branch(project).unwrap();
+            gitbutler_branch_actions::update_base_branch(project).unwrap();
 
             // removes integrated commit, leaves non commited work as is
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert_eq!(branches[0].id, branch_id);
             assert!(branches[0].active);
@@ -824,50 +899,53 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         let branch_id = {
             // make a branch that conflicts with the remote branch, but doesn't know about it yet
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "first").unwrap();
 
-            controller
-                .create_commit(project, branch_id, "first", None, false)
+            gitbutler_branch_actions::create_commit(project, branch_id, "first", None, false)
                 .unwrap();
 
             branch_id
         };
 
-        controller
-            .push_virtual_branch(project, branch_id, false, None)
-            .unwrap();
+        gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
         // another non-locked hunk
         fs::write(repository.path().join("another_file.txt"), "first").unwrap();
 
         {
             // push and merge branch remotely
-            let branch = controller.list_virtual_branches(project).unwrap().0[0].clone();
+            let branch = gitbutler_branch_actions::list_virtual_branches(project)
+                .unwrap()
+                .0[0]
+                .clone();
             repository.merge(&branch.upstream.as_ref().unwrap().name);
         }
 
         repository.fetch();
 
         {
-            controller.update_base_branch(project).unwrap();
+            gitbutler_branch_actions::update_base_branch(project).unwrap();
 
             // removes integrated commit, leaves non commited work as is
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert_eq!(branches[0].id, branch_id);
             assert!(branches[0].active);
@@ -882,7 +960,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -896,30 +973,33 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
         {
             // make a branch that conflicts with the remote branch, but doesn't know about it yet
-            let branch_id = controller
-                .create_virtual_branch(project, &BranchCreateRequest::default())
-                .unwrap();
+            let branch_id = gitbutler_branch_actions::create_virtual_branch(
+                project,
+                &BranchCreateRequest::default(),
+            )
+            .unwrap();
 
             fs::write(repository.path().join("file.txt"), "second").unwrap();
 
-            controller
-                .create_commit(project, branch_id, "second", None, false)
+            gitbutler_branch_actions::create_commit(project, branch_id, "second", None, false)
                 .unwrap();
         };
 
         {
             // fetch remote
-            controller.update_base_branch(project).unwrap();
+            gitbutler_branch_actions::update_base_branch(project).unwrap();
 
             // just removes integrated branch
 
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 0);
         }
     }
@@ -929,7 +1009,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -943,38 +1022,42 @@ mod applied_branch {
             repository.reset_hard(Some(first_commit_oid));
         }
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let branch_id = controller
-            .create_virtual_branch(project, &BranchCreateRequest::default())
-            .unwrap();
+        let branch_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest::default(),
+        )
+        .unwrap();
 
         {
             // open pr
             fs::write(repository.path().join("file2.txt"), "new file").unwrap();
-            controller
-                .create_commit(project, branch_id, "second", None, false)
-                .unwrap();
-            controller
-                .push_virtual_branch(project, branch_id, false, None)
+            gitbutler_branch_actions::create_commit(project, branch_id, "second", None, false)
                 .unwrap();
+            gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
         }
 
         {
             // merge pr
-            let branch = controller.list_virtual_branches(project).unwrap().0[0].clone();
+            let branch = gitbutler_branch_actions::list_virtual_branches(project)
+                .unwrap()
+                .0[0]
+                .clone();
             repository.merge(&branch.upstream.as_ref().unwrap().name);
             repository.fetch();
         }
 
         {
             // fetch remote
-            controller.update_base_branch(project).unwrap();
+            gitbutler_branch_actions::update_base_branch(project).unwrap();
 
             // just removes integrated branch
-            let (branches, _) = controller.list_virtual_branches(project).unwrap();
+            let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 0);
         }
     }
@@ -986,7 +1069,6 @@ mod applied_branch {
         let Test {
             repository,
             project,
-            controller,
             ..
         } = &Test::default();
 
@@ -997,51 +1079,53 @@ mod applied_branch {
         repository.push();
         repository.reset_hard(Some(first_commit_oid));
 
-        controller
-            .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-            .unwrap();
+        gitbutler_branch_actions::set_base_branch(
+            project,
+            &"refs/remotes/origin/master".parse().unwrap(),
+        )
+        .unwrap();
 
-        let branch_1_id = controller
-            .create_virtual_branch(project, &BranchCreateRequest::default())
-            .unwrap();
+        let branch_1_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest::default(),
+        )
+        .unwrap();
 
         fs::write(repository.path().join("file-3.txt"), "three").unwrap();
-        controller
-            .create_commit(project, branch_1_id, "third", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_1_id, "third", None, false)
             .unwrap();
 
-        let branch_2_id = controller
-            .create_virtual_branch(
-                project,
-                &BranchCreateRequest {
-                    selected_for_changes: Some(true),
-                    ..Default::default()
-                },
-            )
-            .unwrap();
+        let branch_2_id = gitbutler_branch_actions::create_virtual_branch(
+            project,
+            &BranchCreateRequest {
+                selected_for_changes: Some(true),
+                ..Default::default()
+            },
+        )
+        .unwrap();
 
         fs::write(repository.path().join("file-4.txt"), "four").unwrap();
 
-        controller
-            .create_commit(project, branch_2_id, "fourth", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_2_id, "fourth", None, false)
             .unwrap();
 
-        controller
-            .push_virtual_branch(project, branch_2_id, false, None)
-            .unwrap();
+        gitbutler_branch_actions::push_virtual_branch(project, branch_2_id, false, None).unwrap();
 
-        let branch = controller.list_virtual_branches(project).unwrap().0[1].clone();
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
+            .unwrap()
+            .0[1]
+            .clone();
 
         repository.merge(&branch.upstream.as_ref().unwrap().name);
         repository.fetch();
 
         // TODO(mg): Figure out why test fails without listing first.
-        controller.list_virtual_branches(project).unwrap();
-        controller.update_base_branch(project).unwrap();
+        gitbutler_branch_actions::list_virtual_branches(project).unwrap();
+        gitbutler_branch_actions::update_base_branch(project).unwrap();
 
         // Verify we have only the first branch left, and that no files
         // are present.
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].files.len(), 0);
     }
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/update_commit_message.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/update_commit_message.rs
index 107210f41..d40d657c1 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/update_commit_message.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/update_commit_message.rs
@@ -8,47 +8,48 @@ fn head() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file two.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit two", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
             .unwrap()
     };
 
     let commit_three_oid = {
         fs::write(repository.path().join("file three.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit three", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
             .unwrap()
     };
     let commit_three = repository.find_commit(commit_three_oid).unwrap();
     let before_change_id = &commit_three.change_id();
 
-    controller
-        .update_commit_message(project, branch_id, commit_three_oid, "commit three updated")
-        .unwrap();
+    gitbutler_branch_actions::update_commit_message(
+        project,
+        branch_id,
+        commit_three_oid,
+        "commit three updated",
+    )
+    .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -79,45 +80,46 @@ fn middle() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
     let commit_two_oid = {
         fs::write(repository.path().join("file two.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit two", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file three.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit three", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
             .unwrap()
     };
 
-    controller
-        .update_commit_message(project, branch_id, commit_two_oid, "commit two updated")
-        .unwrap();
+    gitbutler_branch_actions::update_commit_message(
+        project,
+        branch_id,
+        commit_two_oid,
+        "commit two updated",
+    )
+    .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -141,14 +143,15 @@ fn forcepush_allowed() {
         repository,
         project_id,
         project,
-        controller,
         projects,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
     projects
         .update(&projects::UpdateRequest {
@@ -157,27 +160,27 @@ fn forcepush_allowed() {
         })
         .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let commit_one_oid = {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
-    controller
-        .push_virtual_branch(project, branch_id, false, None)
-        .unwrap();
+    gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
-    controller
-        .update_commit_message(project, branch_id, commit_one_oid, "commit one updated")
-        .unwrap();
+    gitbutler_branch_actions::update_commit_message(
+        project,
+        branch_id,
+        commit_one_oid,
+        "commit one updated",
+    )
+    .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -198,45 +201,46 @@ fn forcepush_forbidden() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
-    controller
-        .update_virtual_branch(
-            project,
-            BranchUpdateRequest {
-                id: branch_id,
-                allow_rebasing: Some(false),
-                ..Default::default()
-            },
-        )
-        .unwrap();
+    gitbutler_branch_actions::update_virtual_branch(
+        project,
+        BranchUpdateRequest {
+            id: branch_id,
+            allow_rebasing: Some(false),
+            ..Default::default()
+        },
+    )
+    .unwrap();
 
     let commit_one_oid = {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
-    controller
-        .push_virtual_branch(project, branch_id, false, None)
-        .unwrap();
+    gitbutler_branch_actions::push_virtual_branch(project, branch_id, false, None).unwrap();
 
     assert_eq!(
-        controller
-            .update_commit_message(project, branch_id, commit_one_oid, "commit one updated",)
-            .unwrap_err()
-            .to_string(),
+        gitbutler_branch_actions::update_commit_message(
+            project,
+            branch_id,
+            commit_one_oid,
+            "commit one updated",
+        )
+        .unwrap_err()
+        .to_string(),
         "force push not allowed"
     );
 }
@@ -246,45 +250,46 @@ fn root() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let commit_one_oid = {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file two.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit two", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit two", None, false)
             .unwrap()
     };
 
     {
         fs::write(repository.path().join("file three.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit three", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit three", None, false)
             .unwrap()
     };
 
-    controller
-        .update_commit_message(project, branch_id, commit_one_oid, "commit one updated")
-        .unwrap();
+    gitbutler_branch_actions::update_commit_message(
+        project,
+        branch_id,
+        commit_one_oid,
+        "commit one updated",
+    )
+    .unwrap();
 
-    let branch = controller
-        .list_virtual_branches(project)
+    let branch = gitbutler_branch_actions::list_virtual_branches(project)
         .unwrap()
         .0
         .into_iter()
@@ -307,28 +312,27 @@ fn empty() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let commit_one_oid = {
         fs::write(repository.path().join("file one.txt"), "").unwrap();
-        controller
-            .create_commit(project, branch_id, "commit one", None, false)
+        gitbutler_branch_actions::create_commit(project, branch_id, "commit one", None, false)
             .unwrap()
     };
 
     assert_eq!(
-        controller
-            .update_commit_message(project, branch_id, commit_one_oid, "",)
+        gitbutler_branch_actions::update_commit_message(project, branch_id, commit_one_oid, "",)
             .unwrap_err()
             .to_string(),
         "commit message can not be empty"
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/upstream.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/upstream.rs
index 64f90e869..c99a4941b 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/upstream.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/upstream.rs
@@ -7,50 +7,43 @@ fn detect_upstream_commits() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch1_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch1_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let oid1 = {
         // create first commit
         fs::write(repository.path().join("file.txt"), "content").unwrap();
-        controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap()
+        gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false).unwrap()
     };
 
     let oid2 = {
         // create second commit
         fs::write(repository.path().join("file.txt"), "content2").unwrap();
-        controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap()
+        gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false).unwrap()
     };
 
     // push
-    controller
-        .push_virtual_branch(project, branch1_id, false, None)
-        .unwrap();
+    gitbutler_branch_actions::push_virtual_branch(project, branch1_id, false, None).unwrap();
 
     let oid3 = {
         // create third commit
         fs::write(repository.path().join("file.txt"), "content3").unwrap();
-        controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap()
+        gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false).unwrap()
     };
 
     {
         // should correctly detect pushed commits
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 3);
@@ -68,43 +61,37 @@ fn detect_integrated_commits() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
-    controller
-        .set_base_branch(project, &"refs/remotes/origin/master".parse().unwrap())
-        .unwrap();
+    gitbutler_branch_actions::set_base_branch(
+        project,
+        &"refs/remotes/origin/master".parse().unwrap(),
+    )
+    .unwrap();
 
-    let branch1_id = controller
-        .create_virtual_branch(project, &BranchCreateRequest::default())
-        .unwrap();
+    let branch1_id =
+        gitbutler_branch_actions::create_virtual_branch(project, &BranchCreateRequest::default())
+            .unwrap();
 
     let oid1 = {
         // create first commit
         fs::write(repository.path().join("file.txt"), "content").unwrap();
-        controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap()
+        gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false).unwrap()
     };
 
     let oid2 = {
         // create second commit
         fs::write(repository.path().join("file.txt"), "content2").unwrap();
-        controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap()
+        gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false).unwrap()
     };
 
     // push
-    controller
-        .push_virtual_branch(project, branch1_id, false, None)
-        .unwrap();
+    gitbutler_branch_actions::push_virtual_branch(project, branch1_id, false, None).unwrap();
 
     {
         // merge branch upstream
-        let branch = controller
-            .list_virtual_branches(project)
+        let branch = gitbutler_branch_actions::list_virtual_branches(project)
             .unwrap()
             .0
             .into_iter()
@@ -117,14 +104,12 @@ fn detect_integrated_commits() {
     let oid3 = {
         // create third commit
         fs::write(repository.path().join("file.txt"), "content3").unwrap();
-        controller
-            .create_commit(project, branch1_id, "commit", None, false)
-            .unwrap()
+        gitbutler_branch_actions::create_commit(project, branch1_id, "commit", None, false).unwrap()
     };
 
     {
         // should correctly detect pushed commits
-        let (branches, _) = controller.list_virtual_branches(project).unwrap();
+        let (branches, _) = gitbutler_branch_actions::list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert_eq!(branches[0].id, branch1_id);
         assert_eq!(branches[0].commits.len(), 3);
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/verify_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/verify_branch.rs
index b95964ff8..de4b1ad47 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/verify_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/verify_branch.rs
@@ -8,13 +8,12 @@ fn should_fail_on_incorrect_branch() {
     let Test {
         repository,
         project,
-        controller,
         ..
     } = &Test::default();
 
     let branch_name: LocalRefname = "refs/heads/somebranch".parse().unwrap();
     repository.checkout(&branch_name);
-    let result = controller.list_virtual_branches(project);
+    let result = gitbutler_branch_actions::list_virtual_branches(project);
 
     let err = result.unwrap_err();
     assert_eq!(
diff --git a/crates/gitbutler-cli/src/command/project.rs b/crates/gitbutler-cli/src/command/project.rs
index 34927badb..46d2ab712 100644
--- a/crates/gitbutler-cli/src/command/project.rs
+++ b/crates/gitbutler-cli/src/command/project.rs
@@ -1,7 +1,6 @@
 use std::path::PathBuf;
 
 use anyhow::{Context, Result};
-use gitbutler_branch_actions::VirtualBranchActions;
 use gitbutler_project::Project;
 use gitbutler_reference::RemoteRefname;
 
@@ -31,11 +30,13 @@ pub fn add(
         .canonicalize()?;
     let project = ctrl.add(path)?;
     if let Some(refname) = refname {
-        VirtualBranchActions.set_base_branch(&project, &refname)?;
+        gitbutler_branch_actions::set_base_branch(&project, &refname)?;
     };
     debug_print(project)
 }
 
 pub fn switch_to_workspace(project: Project, refname: RemoteRefname) -> Result<()> {
-    debug_print(VirtualBranchActions.set_base_branch(&project, &refname)?)
+    debug_print(gitbutler_branch_actions::set_base_branch(
+        &project, &refname,
+    )?)
 }
diff --git a/crates/gitbutler-cli/src/command/vbranch.rs b/crates/gitbutler-cli/src/command/vbranch.rs
index 425780e65..5a91e8dfe 100644
--- a/crates/gitbutler-cli/src/command/vbranch.rs
+++ b/crates/gitbutler-cli/src/command/vbranch.rs
@@ -2,14 +2,14 @@ use anyhow::{bail, Result};
 use gitbutler_branch::{
     Branch, BranchCreateRequest, BranchIdentity, BranchUpdateRequest, VirtualBranchesHandle,
 };
-use gitbutler_branch_actions::{get_branch_listing_details, list_branches, VirtualBranchActions};
+use gitbutler_branch_actions::{get_branch_listing_details, list_branches};
 use gitbutler_command_context::CommandContext;
 use gitbutler_project::Project;
 
 use crate::command::debug_print;
 
 pub fn update_target(project: Project) -> Result<()> {
-    let unapplied = VirtualBranchActions.update_base_branch(&project)?;
+    let unapplied = gitbutler_branch_actions::update_base_branch(&project)?;
     debug_print(unapplied)
 }
 
@@ -19,7 +19,7 @@ pub fn list_all(project: Project) -> Result<()> {
 }
 
 pub fn list_local(project: Project) -> Result<()> {
-    debug_print(VirtualBranchActions::list_local_branches(project)?)
+    debug_print(gitbutler_branch_actions::list_local_branches(project)?)
 }
 
 pub fn details(project: Project, branch_names: Vec<BranchIdentity>) -> Result<()> {
@@ -45,16 +45,18 @@ pub fn list(project: Project) -> Result<()> {
 }
 
 pub fn status(project: Project) -> Result<()> {
-    debug_print(VirtualBranchActions.list_virtual_branches(&project)?)
+    debug_print(gitbutler_branch_actions::list_virtual_branches(&project)?)
 }
 
 pub fn unapply(project: Project, branch_name: String) -> Result<()> {
     let branch = branch_by_name(&project, &branch_name)?;
-    debug_print(VirtualBranchActions.convert_to_real_branch(&project, branch.id)?)
+    debug_print(gitbutler_branch_actions::convert_to_real_branch(
+        &project, branch.id,
+    )?)
 }
 
 pub fn create(project: Project, branch_name: String, set_default: bool) -> Result<()> {
-    let new = VirtualBranchActions.create_virtual_branch(
+    let new = gitbutler_branch_actions::create_virtual_branch(
         &project,
         &BranchCreateRequest {
             name: Some(branch_name),
@@ -74,7 +76,7 @@ pub fn set_default(project: Project, branch_name: String) -> Result<()> {
 }
 
 fn set_default_branch(project: &Project, branch: &Branch) -> Result<()> {
-    VirtualBranchActions.update_virtual_branch(
+    gitbutler_branch_actions::update_virtual_branch(
         project,
         BranchUpdateRequest {
             id: branch.id,
@@ -91,7 +93,7 @@ fn set_default_branch(project: &Project, branch: &Branch) -> Result<()> {
 
 pub fn commit(project: Project, branch_name: String, message: String) -> Result<()> {
     let branch = branch_by_name(&project, &branch_name)?;
-    let (info, skipped) = VirtualBranchActions.list_virtual_branches(&project)?;
+    let (info, skipped) = gitbutler_branch_actions::list_virtual_branches(&project)?;
 
     if !skipped.is_empty() {
         eprintln!(
@@ -129,7 +131,7 @@ pub fn commit(project: Project, branch_name: String, message: String) -> Result<
     }
 
     let run_hooks = false;
-    debug_print(VirtualBranchActions.create_commit(
+    debug_print(gitbutler_branch_actions::create_commit(
         &project,
         branch.id,
         &message,
diff --git a/crates/gitbutler-edit-mode/src/lib.rs b/crates/gitbutler-edit-mode/src/lib.rs
index 2473aa34b..27c390915 100644
--- a/crates/gitbutler-edit-mode/src/lib.rs
+++ b/crates/gitbutler-edit-mode/src/lib.rs
@@ -4,7 +4,8 @@ use anyhow::{bail, Context, Result};
 use bstr::ByteSlice;
 use git2::build::CheckoutBuilder;
 use gitbutler_branch::{signature, Branch, SignaturePurpose, VirtualBranchesHandle};
-use gitbutler_branch_actions::{list_virtual_branches, update_workspace_commit, RemoteBranchFile};
+use gitbutler_branch_actions::internal::list_virtual_branches;
+use gitbutler_branch_actions::{update_workspace_commit, RemoteBranchFile};
 use gitbutler_cherry_pick::RepositoryExt as _;
 use gitbutler_command_context::CommandContext;
 use gitbutler_commit::{
diff --git a/crates/gitbutler-tauri/src/repo.rs b/crates/gitbutler-tauri/src/repo.rs
index a6879c8d4..d52d50bff 100644
--- a/crates/gitbutler-tauri/src/repo.rs
+++ b/crates/gitbutler-tauri/src/repo.rs
@@ -1,6 +1,6 @@
 pub mod commands {
     use anyhow::{Context, Result};
-    use gitbutler_branch_actions::{RemoteBranchFile, VirtualBranchActions};
+    use gitbutler_branch_actions::RemoteBranchFile;
     use gitbutler_project as projects;
     use gitbutler_project::ProjectId;
     use gitbutler_repo::RepoCommands;
@@ -69,6 +69,6 @@ pub mod commands {
     ) -> Result<Vec<RemoteBranchFile>, Error> {
         let project = projects.get(id)?;
 
-        Ok(VirtualBranchActions.get_uncommited_files(&project)?)
+        Ok(gitbutler_branch_actions::get_uncommited_files(&project)?)
     }
 }
diff --git a/crates/gitbutler-tauri/src/virtual_branches.rs b/crates/gitbutler-tauri/src/virtual_branches.rs
index 8cf3d6e4c..115c2c40e 100644
--- a/crates/gitbutler-tauri/src/virtual_branches.rs
+++ b/crates/gitbutler-tauri/src/virtual_branches.rs
@@ -5,7 +5,7 @@ pub mod commands {
     };
     use gitbutler_branch_actions::{
         BaseBranch, BranchListing, BranchListingDetails, BranchListingFilter, RemoteBranch,
-        RemoteBranchData, RemoteBranchFile, VirtualBranchActions, VirtualBranches,
+        RemoteBranchData, RemoteBranchFile, VirtualBranches,
     };
     use gitbutler_command_context::CommandContext;
     use gitbutler_error::error::Code;
@@ -38,7 +38,7 @@ pub mod commands {
         run_hooks: bool,
     ) -> Result<String, Error> {
         let project = projects.get(project_id)?;
-        let oid = VirtualBranchActions.create_commit(
+        let oid = gitbutler_branch_actions::create_commit(
             &project,
             branch,
             message,
@@ -56,8 +56,7 @@ pub mod commands {
         project_id: ProjectId,
     ) -> Result<VirtualBranches, Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions
-            .list_virtual_branches(&project)
+        gitbutler_branch_actions::list_virtual_branches(&project)
             .map_err(Into::into)
             .map(|(branches, skipped_files)| VirtualBranches {
                 branches,
@@ -74,7 +73,7 @@ pub mod commands {
         branch: BranchCreateRequest,
     ) -> Result<BranchId, Error> {
         let project = projects.get(project_id)?;
-        let branch_id = VirtualBranchActions.create_virtual_branch(&project, &branch)?;
+        let branch_id = gitbutler_branch_actions::create_virtual_branch(&project, &branch)?;
         emit_vbranches(&windows, project_id);
         Ok(branch_id)
     }
@@ -89,7 +88,7 @@ pub mod commands {
         given_name: String,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.delete_local_branch(&project, &refname, given_name)?;
+        gitbutler_branch_actions::delete_local_branch(&project, &refname, given_name)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -105,7 +104,7 @@ pub mod commands {
     ) -> Result<BranchId, Error> {
         let project = projects.get(project_id)?;
         let branch_id =
-            VirtualBranchActions.create_virtual_branch_from_branch(&project, &branch, remote)?;
+            gitbutler_branch_actions::create_virtual_branch_from_branch(&project, &branch, remote)?;
         emit_vbranches(&windows, project_id);
         Ok(branch_id)
     }
@@ -119,7 +118,7 @@ pub mod commands {
         branch: BranchId,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.integrate_upstream_commits(&project, branch)?;
+        gitbutler_branch_actions::integrate_upstream_commits(&project, branch)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -131,7 +130,7 @@ pub mod commands {
         project_id: ProjectId,
     ) -> Result<Option<BaseBranch>, Error> {
         let project = projects.get(project_id)?;
-        if let Ok(base_branch) = VirtualBranchActions::get_base_branch_data(&project) {
+        if let Ok(base_branch) = gitbutler_branch_actions::get_base_branch_data(&project) {
             Ok(Some(base_branch))
         } else {
             Ok(None)
@@ -151,11 +150,11 @@ pub mod commands {
         let branch_name = format!("refs/remotes/{}", branch)
             .parse()
             .context("Invalid branch name")?;
-        let base_branch = VirtualBranchActions.set_base_branch(&project, &branch_name)?;
+        let base_branch = gitbutler_branch_actions::set_base_branch(&project, &branch_name)?;
 
         // if they also sent a different push remote, set that too
         if let Some(push_remote) = push_remote {
-            VirtualBranchActions.set_target_push_remote(&project, push_remote)?;
+            gitbutler_branch_actions::set_target_push_remote(&project, push_remote)?;
         }
         emit_vbranches(&windows, project_id);
         Ok(base_branch)
@@ -169,7 +168,7 @@ pub mod commands {
         project_id: ProjectId,
     ) -> Result<Vec<ReferenceName>, Error> {
         let project = projects.get(project_id)?;
-        let unapplied_branches = VirtualBranchActions.update_base_branch(&project)?;
+        let unapplied_branches = gitbutler_branch_actions::update_base_branch(&project)?;
         emit_vbranches(&windows, project_id);
         Ok(unapplied_branches)
     }
@@ -183,7 +182,7 @@ pub mod commands {
         branch: BranchUpdateRequest,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.update_virtual_branch(&project, branch)?;
+        gitbutler_branch_actions::update_virtual_branch(&project, branch)?;
 
         emit_vbranches(&windows, project_id);
         Ok(())
@@ -198,7 +197,7 @@ pub mod commands {
         branches: Vec<BranchUpdateRequest>,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.update_branch_order(&project, branches)?;
+        gitbutler_branch_actions::update_branch_order(&project, branches)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -212,7 +211,7 @@ pub mod commands {
         branch_id: BranchId,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.delete_virtual_branch(&project, branch_id)?;
+        gitbutler_branch_actions::delete_virtual_branch(&project, branch_id)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -226,7 +225,7 @@ pub mod commands {
         branch: BranchId,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.convert_to_real_branch(&project, branch)?;
+        gitbutler_branch_actions::convert_to_real_branch(&project, branch)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -240,7 +239,7 @@ pub mod commands {
         ownership: BranchOwnershipClaims,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.unapply_ownership(&project, &ownership)?;
+        gitbutler_branch_actions::unapply_ownership(&project, &ownership)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -255,7 +254,7 @@ pub mod commands {
         files: Vec<PathBuf>,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.reset_files(&project, branch_id, &files)?;
+        gitbutler_branch_actions::reset_files(&project, branch_id, &files)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -270,9 +269,13 @@ pub mod commands {
         with_force: bool,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions
-            .push_virtual_branch(&project, branch_id, with_force, Some(Some(branch_id)))
-            .map_err(|err| err.context(Code::Unknown))?;
+        gitbutler_branch_actions::push_virtual_branch(
+            &project,
+            branch_id,
+            with_force,
+            Some(Some(branch_id)),
+        )
+        .map_err(|err| err.context(Code::Unknown))?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -285,7 +288,9 @@ pub mod commands {
         branch: RemoteRefname,
     ) -> Result<bool, Error> {
         let project = projects.get(project_id)?;
-        Ok(VirtualBranchActions.can_apply_remote_branch(&project, &branch)?)
+        Ok(gitbutler_branch_actions::can_apply_remote_branch(
+            &project, &branch,
+        )?)
     }
 
     #[tauri::command(async)]
@@ -297,9 +302,7 @@ pub mod commands {
     ) -> Result<Vec<RemoteBranchFile>, Error> {
         let project = projects.get(project_id)?;
         let commit_oid = git2::Oid::from_str(&commit_oid).map_err(|e| anyhow!(e))?;
-        VirtualBranchActions
-            .list_remote_commit_files(&project, commit_oid)
-            .map_err(Into::into)
+        gitbutler_branch_actions::list_remote_commit_files(&project, commit_oid).map_err(Into::into)
     }
 
     #[tauri::command(async)]
@@ -313,7 +316,7 @@ pub mod commands {
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
         let target_commit_oid = git2::Oid::from_str(&target_commit_oid).map_err(|e| anyhow!(e))?;
-        VirtualBranchActions.reset_virtual_branch(&project, branch_id, target_commit_oid)?;
+        gitbutler_branch_actions::reset_virtual_branch(&project, branch_id, target_commit_oid)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -330,7 +333,7 @@ pub mod commands {
     ) -> Result<String, Error> {
         let project = projects.get(project_id)?;
         let commit_oid = git2::Oid::from_str(&commit_oid).map_err(|e| anyhow!(e))?;
-        let oid = VirtualBranchActions.amend(&project, branch_id, commit_oid, &ownership)?;
+        let oid = gitbutler_branch_actions::amend(&project, branch_id, commit_oid, &ownership)?;
         emit_vbranches(&windows, project_id);
         Ok(oid.to_string())
     }
@@ -349,7 +352,7 @@ pub mod commands {
         let project = projects.get(project_id)?;
         let from_commit_oid = git2::Oid::from_str(&from_commit_oid).map_err(|e| anyhow!(e))?;
         let to_commit_oid = git2::Oid::from_str(&to_commit_oid).map_err(|e| anyhow!(e))?;
-        let oid = VirtualBranchActions.move_commit_file(
+        let oid = gitbutler_branch_actions::move_commit_file(
             &project,
             branch_id,
             from_commit_oid,
@@ -371,7 +374,7 @@ pub mod commands {
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
         let commit_oid = git2::Oid::from_str(&commit_oid).map_err(|e| anyhow!(e))?;
-        VirtualBranchActions.undo_commit(&project, branch_id, commit_oid)?;
+        gitbutler_branch_actions::undo_commit(&project, branch_id, commit_oid)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -388,7 +391,7 @@ pub mod commands {
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
         let commit_oid = git2::Oid::from_str(&commit_oid).map_err(|e| anyhow!(e))?;
-        VirtualBranchActions.insert_blank_commit(&project, branch_id, commit_oid, offset)?;
+        gitbutler_branch_actions::insert_blank_commit(&project, branch_id, commit_oid, offset)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -404,7 +407,7 @@ pub mod commands {
         change_id: String,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.create_change_reference(&project, branch_id, name, change_id)?;
+        gitbutler_branch_actions::create_change_reference(&project, branch_id, name, change_id)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -420,7 +423,7 @@ pub mod commands {
         with_force: bool,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.push_change_reference(&project, branch_id, name, with_force)?;
+        gitbutler_branch_actions::push_change_reference(&project, branch_id, name, with_force)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -436,7 +439,12 @@ pub mod commands {
         new_change_id: String,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-        VirtualBranchActions.update_change_reference(&project, branch_id, name, new_change_id)?;
+        gitbutler_branch_actions::update_change_reference(
+            &project,
+            branch_id,
+            name,
+            new_change_id,
+        )?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -453,7 +461,7 @@ pub mod commands {
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
         let commit_oid = git2::Oid::from_str(&commit_oid).map_err(|e| anyhow!(e))?;
-        VirtualBranchActions.reorder_commit(&project, branch_id, commit_oid, offset)?;
+        gitbutler_branch_actions::reorder_commit(&project, branch_id, commit_oid, offset)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -465,7 +473,7 @@ pub mod commands {
         project_id: ProjectId,
     ) -> Result<Vec<RemoteBranch>, Error> {
         let project = projects.get(project_id)?;
-        let branches = VirtualBranchActions::list_local_branches(project)?;
+        let branches = gitbutler_branch_actions::list_local_branches(project)?;
         Ok(branches)
     }
 
@@ -501,7 +509,7 @@ pub mod commands {
         refname: Refname,
     ) -> Result<RemoteBranchData, Error> {
         let project = projects.get(project_id)?;
-        let branch_data = VirtualBranchActions.get_remote_branch_data(&project, &refname)?;
+        let branch_data = gitbutler_branch_actions::get_remote_branch_data(&project, &refname)?;
         Ok(branch_data)
     }
 
@@ -516,7 +524,7 @@ pub mod commands {
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
         let target_commit_oid = git2::Oid::from_str(&target_commit_oid).map_err(|e| anyhow!(e))?;
-        VirtualBranchActions.squash(&project, branch_id, target_commit_oid)?;
+        gitbutler_branch_actions::squash(&project, branch_id, target_commit_oid)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -530,7 +538,7 @@ pub mod commands {
     ) -> Result<BaseBranch, Error> {
         let project = projects.get(project_id)?;
 
-        let project_data_last_fetched = VirtualBranchActions.fetch_from_remotes(
+        let project_data_last_fetched = gitbutler_branch_actions::fetch_from_remotes(
             &project,
             Some(action.unwrap_or_else(|| "unknown".to_string())),
         )?;
@@ -550,7 +558,7 @@ pub mod commands {
             return Err(anyhow!(error).into());
         }
 
-        let base_branch = VirtualBranchActions::get_base_branch_data(&project)?;
+        let base_branch = gitbutler_branch_actions::get_base_branch_data(&project)?;
         Ok(base_branch)
     }
 
@@ -565,7 +573,7 @@ pub mod commands {
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
         let commit_oid = git2::Oid::from_str(&commit_oid).map_err(|e| anyhow!(e))?;
-        VirtualBranchActions.move_commit(&project, target_branch_id, commit_oid)?;
+        gitbutler_branch_actions::move_commit(&project, target_branch_id, commit_oid)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
@@ -582,7 +590,7 @@ pub mod commands {
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
         let commit_oid = git2::Oid::from_str(&commit_oid).map_err(|e| anyhow!(e))?;
-        VirtualBranchActions.update_commit_message(&project, branch_id, commit_oid, message)?;
+        gitbutler_branch_actions::update_commit_message(&project, branch_id, commit_oid, message)?;
         emit_vbranches(&windows, project_id);
         Ok(())
     }
diff --git a/crates/gitbutler-watcher/src/handler.rs b/crates/gitbutler-watcher/src/handler.rs
index f83a6988c..e39fc726b 100644
--- a/crates/gitbutler-watcher/src/handler.rs
+++ b/crates/gitbutler-watcher/src/handler.rs
@@ -2,7 +2,7 @@ use std::{path::PathBuf, sync::Arc};
 
 use super::{events, Change};
 use anyhow::{Context, Result};
-use gitbutler_branch_actions::{RemoteBranchFile, VirtualBranchActions, VirtualBranches};
+use gitbutler_branch_actions::{RemoteBranchFile, VirtualBranches};
 use gitbutler_command_context::CommandContext;
 use gitbutler_diff::DiffByPathMap;
 use gitbutler_error::error::Marker;
@@ -106,7 +106,7 @@ impl Handler {
             .projects
             .get(project_id)
             .context("failed to get project")?;
-        match VirtualBranchActions.list_virtual_branches_cached(&project, worktree_changes) {
+        match gitbutler_branch_actions::list_virtual_branches_cached(&project, worktree_changes) {
             Ok((branches, skipped_files)) => self.emit_app_event(Change::VirtualBranches {
                 project_id: project.id,
                 virtual_branches: VirtualBranches {
@@ -142,7 +142,7 @@ impl Handler {
 
     /// Try to emit uncommited files. Swollow errors if they arrise.
     fn emit_uncommited_files(&self, project: &Project) -> Result<DiffByPathMap> {
-        let files = VirtualBranchActions.get_uncommited_files_reusable(project)?;
+        let files = gitbutler_branch_actions::get_uncommited_files_reusable(project)?;
 
         let _ = self.emit_app_event(Change::UncommitedFiles {
             project_id: project.id,