Hexagonal Architecture

Add new domains around repo, inbox and identity
Each domain has:
- One Service struct that is the public facing API for that domain.
- One or multiple traits that we are able to implement in the mentioned Service struct.
- A models module where we store structs, traits and implementations aroun that domain.
The Service structs use the outbound modules to use different types of implementations like Sqlite or Radicle to talk to the outside.

New e2e tests

There are no fixtures anymore (for now). Each tests is started with a blank page where:

test-http-api process is started
fresh ssh-agent process is started
New Radicle identity is created.
New repo created

And finally the changes applied that we want to test for.

In some cases we start a node for cloning a repo and then stop it too. 8 tests (where there are multiple sub tests take around 23.0 s for me so far.)

Written tests so far:

issues (creation, lifecycle, threads, reactions)
patches (creation, lifecycle, threads, reactions, revisions)
theme
onboarding (identity creation, validation)
clipboard

CI

👉 Workflow runs 👉 Branch on GitHub

 checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
 [[package]]
 name = "anymap3"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "170433209e817da6aae2c51aa0dd443009a613425dd041ebfb2492d1c4c11a25"
 [[package]]
 name = "arboard"
 version = "3.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 version = "0.1.0"
 dependencies = [
  "anyhow",
  "anymap3",
  "arboard",
  "axum",
  "hyper",
  "lexopt",

  "radicle-types",
  "serde",
  "serde_json",
  "ssh-key",
  "thiserror 2.0.12",
  "tokio",
  "tower-http",

 use std::str::FromStr;
 use std::ops::Deref as _;
 use radicle::crypto::ssh::{self, Passphrase};
 use radicle::node::Alias;
 use radicle::profile::env;
 use radicle_types::error::Error;
 use radicle::crypto::ssh::Passphrase;
 use tauri::{AppHandle, Manager};
 use crate::AppState;
 use radicle_types::domain::identity::service::Service;
 use radicle_types::domain::identity::traits::IdentityService as _;
 use radicle_types::error::Error;
 use radicle_types::outbound::radicle::Radicle;
 #[tauri::command]
 pub fn authenticate(
     ctx: tauri::State<AppState>,
     passphrase: Option<Passphrase>,
     service: tauri::State<Service<Radicle>>,
     passphrase: Passphrase,
 ) -> Result<(), Error> {
     let profile = &ctx.profile;
     if !profile.keystore.is_encrypted()? {
         return Ok(());
     }
     match ssh::agent::Agent::connect() {
         Ok(mut agent) => {
             if agent.request_identities()?.contains(&profile.public_key) {
                 return Ok(());
             }
             match passphrase {
                 Some(passphrase) => {
                     profile.keystore.secret_key(Some(passphrase.clone()))?;
                     register(&mut agent, profile, passphrase)
                 }
                 None => Err(Error::Crypto(
                     radicle::crypto::ssh::keystore::Error::PassphraseMissing,
                 )),
             }
         }
         Err(e) if e.is_not_running() => Err(Error::AgentNotRunning)?,
         Err(e) => Err(e)?,
     }
     service.authenticate(passphrase)
 }
 #[tauri::command]
 pub(crate) fn init(alias: String, passphrase: Passphrase) -> Result<(), Error> {
     let home = radicle::profile::home()?;
     let alias = Alias::from_str(&alias)?;
     if passphrase.is_empty() {
         return Err(Error::Crypto(
             radicle::crypto::ssh::keystore::Error::PassphraseMissing,
         ));
     }
     let profile = radicle::Profile::init(home, alias, Some(passphrase.clone()), env::seed())?;
     match ssh::agent::Agent::connect() {
         Ok(mut agent) => register(&mut agent, &profile, passphrase.clone())?,
         Err(e) if e.is_not_running() => return Err(Error::AgentNotRunning),
         Err(e) => Err(e)?,
     }
     Ok(())
 pub fn check_agent(profile: tauri::State<radicle::Profile>) -> Result<(), Error> {
     Service::<Radicle>::check_agent(profile.public_key)
 }
 pub fn register(
     agent: &mut ssh::agent::Agent,
     profile: &radicle::Profile,
     passphrase: ssh::Passphrase,
 ) -> Result<(), Error> {
     let secret = profile
         .keystore
         .secret_key(Some(passphrase))
         .map_err(|e| {
             if e.is_crypto_err() {
                 Error::Crypto(radicle::crypto::ssh::keystore::Error::Ssh(
                     ssh_key::Error::Crypto,
                 ))
             } else {
                 e.into()
             }
         })?
         .ok_or(Error::Crypto(radicle::crypto::ssh::keystore::Error::Ssh(
             ssh_key::Error::Crypto,
         )))?;
     agent.register(&secret)?;
 #[tauri::command]
 pub fn init(app: AppHandle, alias: String, passphrase: Passphrase) -> Result<(), Error> {
     let radicle = Radicle::init(alias, passphrase)?;
     app.manage(radicle.profile().deref().clone());
     Ok(())
 }

 use radicle::git;
 use radicle::identity;
 use radicle_types as types;
 use radicle_types::error::Error;
 use radicle_types::traits::thread::Thread;
 use tauri_plugin_clipboard_manager::ClipboardExt;
 use tauri_plugin_dialog::DialogExt;
 use crate::AppState;
 use radicle_types::domain::repo::models::cobs;
 use radicle_types::domain::repo::service::Service;
 use radicle_types::domain::repo::traits::RepoService as _;
 use radicle_types::error::Error;
 use radicle_types::outbound::radicle::Radicle;
 use radicle_types::outbound::sqlite::Sqlite;
 pub mod issue;
 pub mod patch;
 #[tauri::command]
 pub async fn get_embed(
     ctx: tauri::State<'_, AppState>,
     service: tauri::State<'_, Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     name: Option<String>,
     oid: git::Oid,
 ) -> Result<types::cobs::EmbedWithMimeType, Error> {
     ctx.get_embed(rid, name, oid)
 ) -> Result<cobs::EmbedWithMimeType, Error> {
     service.get_embed(rid, name, oid)
 }
 #[tauri::command]
 pub async fn save_embed_by_path(
     ctx: tauri::State<'_, AppState>,
     service: tauri::State<'_, Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     path: PathBuf,
 ) -> Result<git::Oid, Error> {
     ctx.save_embed_by_path(rid, path)
     service.save_embed_by_path(rid, path)
 }
 #[tauri::command]
 pub async fn save_embed_by_clipboard(
     app_handle: tauri::AppHandle,
     ctx: tauri::State<'_, AppState>,
     service: tauri::State<'_, Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     name: String,
 ) -> Result<git::Oid, Error> {

     };
     let path = path.into_path()?;
     ctx.save_embed_to_disk(rid, oid, path)
     service.save_embed_to_disk(rid, oid, path)
 }

 use radicle::git;
 use radicle::identity;
 use radicle::{git, identity, issue};
 use radicle::issue::TYPENAME;
 use radicle_types as types;
 use radicle_types::domain::repo::models::cobs;
 use radicle_types::domain::repo::service::Service;
 use radicle_types::domain::repo::traits::RepoService;
 use radicle_types::error::Error;
 use radicle_types::traits::cobs::Cobs;
 use radicle_types::traits::issue::Issues;
 use radicle_types::traits::issue::IssuesMut;
 use crate::AppState;
 use radicle_types::outbound::radicle::Radicle;
 use radicle_types::outbound::sqlite::Sqlite;
 #[tauri::command]
 pub fn create_issue(
     ctx: tauri::State<AppState>,
     service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     new: types::cobs::issue::NewIssue,
     opts: types::cobs::CobOptions,
 ) -> Result<types::cobs::issue::Issue, Error> {
     ctx.create_issue(rid, new, opts)
     new: cobs::issue::NewIssue,
     opts: cobs::CobOptions,
 ) -> Result<cobs::issue::Issue, Error> {
     service.create_issue(rid, new, opts)
 }
 #[tauri::command]
 pub fn edit_issue(
     ctx: tauri::State<AppState>,
     service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     cob_id: git::Oid,
     action: types::cobs::issue::Action,
     opts: types::cobs::CobOptions,
 ) -> Result<types::cobs::issue::Issue, Error> {
     ctx.edit_issue(rid, cob_id, action, opts)
     action: cobs::issue::Action,
     opts: cobs::CobOptions,
 ) -> Result<cobs::issue::Issue, Error> {
     service.edit_issue(rid, cob_id.into(), action, opts)
 }
 #[tauri::command]
 pub(crate) fn list_issues(
     ctx: tauri::State<AppState>,
     service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     status: Option<types::cobs::query::IssueStatus>,
 ) -> Result<Vec<types::cobs::issue::Issue>, Error> {
     ctx.list_issues(rid, status)
     status: Option<cobs::query::IssueStatus>,
 ) -> Result<Vec<cobs::issue::Issue>, Error> {
     service.list_issues(rid, status)
 }
 #[tauri::command]
 pub(crate) fn issue_by_id(
     ctx: tauri::State<AppState>,
     service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Option<types::cobs::issue::Issue>, Error> {
     ctx.issue_by_id(rid, id)
     id: issue::IssueId,
 ) -> Result<Option<cobs::issue::Issue>, Error> {
     service.issue_by_id(rid, id)
 }
 #[tauri::command]
 pub(crate) fn comment_threads_by_issue_id(
     ctx: tauri::State<AppState>,
     service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Option<Vec<types::cobs::thread::Thread>>, Error> {
     ctx.comment_threads_by_issue_id(rid, id)
     id: issue::IssueId,
 ) -> Result<Option<Vec<cobs::thread::Thread>>, Error> {
     service.comment_threads_by_issue_id(rid, id)
 }
 #[tauri::command]
 pub fn activity_by_issue(
     ctx: tauri::State<AppState>,
     service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Vec<types::cobs::Operation<types::cobs::issue::Action>>, Error> {
     ctx.activity_by_id(rid, &TYPENAME, id)
 ) -> Result<Vec<cobs::Operation<cobs::issue::Action>>, Error> {
     service.activity_by_id(rid, &issue::TYPENAME, id)
 }

 use radicle::patch::TYPENAME;
 use radicle::{cob, git, identity};
 use radicle::{cob, git, identity, patch};
 use radicle_types as types;
 use radicle_types::cobs;
 use radicle_types::domain::patch::models;
 use radicle_types::domain::patch::service::Service;
 use radicle_types::domain::patch::traits::PatchService;
 use radicle_types::domain::repo::models::cobs;
 use radicle_types::domain::repo::service::Service;
 use radicle_types::domain::repo::traits::RepoService as _;
 use radicle_types::error::Error;
 use radicle_types::outbound::radicle::Radicle;
 use radicle_types::outbound::sqlite::Sqlite;
 use radicle_types::traits::cobs::Cobs;
 use radicle_types::traits::patch::Patches;
 use radicle_types::traits::patch::PatchesMut;
 use radicle_types::traits::Profile;
 use crate::AppState;
 #[tauri::command]
 pub async fn list_patches(
     ctx: tauri::State<'_, AppState>,
     sqlite_service: tauri::State<'_, Service<Sqlite>>,
     profile: tauri::State<'_, radicle::Profile>,
     service: tauri::State<'_, Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     status: Option<types::cobs::query::PatchStatus>,
     status: Option<cobs::query::PatchStatus>,
     skip: Option<usize>,
     // None: return all patches, `skip` is ignored.
     take: Option<usize>,
 ) -> Result<types::cobs::PaginatedQuery<Vec<models::patch::Patch>>, Error> {
     let profile = ctx.profile();
     let cursor = skip.unwrap_or(0);
     let aliases = profile.aliases();
 ) -> Result<cobs::PaginatedQuery<Vec<cobs::patch::Patch>>, Error> {
     let aliases = &profile.aliases();
     let patches = match status {
         None => sqlite_service.list(rid)?.collect::<Vec<_>>(),
         Some(s) => sqlite_service
             .list_by_status(rid, s.into())?
         Some(status) => service
             .list_patches_by_status(rid, status.into())?
             .collect::<Vec<_>>(),
         None => service.list_patches(rid)?.collect::<Vec<_>>(),
     };
     match take {
         None => {
             let content = patches
                 .into_iter()
                 .map(|(id, patch)| models::patch::Patch::new(id, &patch, &aliases))
                 .map(|(id, patch)| cobs::patch::Patch::new(&id, &patch, aliases))
                 .collect::<Vec<_>>();
             Ok::<_, Error>(cobs::PaginatedQuery {

             })
         }
         Some(take) => {
             let more = cursor + take < patches.len();
             let total_count = patches.len();
             let cursor = skip.unwrap_or(0);
             let content = patches
                 .into_iter()
                 .map(|(id, patch)| models::patch::Patch::new(id, &patch, &aliases))
                 .skip(cursor)
                 .take(take)
                 .collect::<Vec<_>>();
             Ok::<_, Error>(cobs::PaginatedQuery {
                 cursor,
                 more,
                 content,
             })
             Ok(
                 cobs::PaginatedQuery::<Vec<cobs::patch::Patch>>::map_with_pagination(
                     patches.into_iter(),
                     total_count,
                     cursor,
                     take,
                     |(id, patch)| cobs::patch::Patch::new(&id, &patch, aliases),
                 ),
             )
         }
     }
 }
 #[tauri::command]
 pub fn patch_by_id(
     ctx: tauri::State<AppState>,
     repo_service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Option<models::patch::Patch>, Error> {
     ctx.get_patch(rid, id)
 ) -> Result<Option<cobs::patch::Patch>, Error> {
     repo_service.get_patch_by_id(rid, id.into())
 }
 #[tauri::command]
 pub fn revisions_by_patch(
     ctx: tauri::State<AppState>,
     repo_service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Option<Vec<models::patch::Revision>>, Error> {
     ctx.revisions_by_patch(rid, id)
 ) -> Result<Option<Vec<cobs::patch::Revision>>, Error> {
     repo_service.revisions_by_patch(rid, id.into())
 }
 #[tauri::command]
 pub fn revision_by_patch_and_id(
     ctx: tauri::State<AppState>,
     repo_service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     id: git::Oid,
     revision_id: git::Oid,
 ) -> Result<Option<models::patch::Revision>, Error> {
     ctx.revision_by_id(rid, id, revision_id)
 ) -> Result<Option<cobs::patch::Revision>, Error> {
     repo_service.revision_by_id(rid, id.into(), revision_id.into())
 }
 #[tauri::command]
 pub fn review_by_patch_and_revision_and_id(
     ctx: tauri::State<AppState>,
     repo_service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     id: git::Oid,
     revision_id: git::Oid,
     review_id: cob::patch::ReviewId,
 ) -> Result<Option<models::patch::Review>, Error> {
     ctx.review_by_id(rid, id, revision_id, review_id)
 ) -> Result<Option<cobs::patch::Review>, Error> {
     repo_service.review_by_id(rid, id.into(), revision_id.into(), review_id)
 }
 #[tauri::command]
 pub fn edit_patch(
     ctx: tauri::State<AppState>,
     repo_service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     cob_id: git::Oid,
     action: models::patch::Action,
     action: cobs::patch::Action,
     opts: cobs::CobOptions,
 ) -> Result<models::patch::Patch, Error> {
     ctx.edit_patch(rid, cob_id, action, opts)
 ) -> Result<cobs::patch::Patch, Error> {
     repo_service.edit_patch(rid, cob_id.into(), action, opts)
 }
 #[tauri::command]
 pub fn activity_by_patch(
     ctx: tauri::State<AppState>,
     service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Vec<types::cobs::Operation<models::patch::Action>>, Error> {
     ctx.activity_by_id(rid, &TYPENAME, id)
 ) -> Result<Vec<cobs::Operation<cobs::patch::Action>>, Error> {
     service.activity_by_id(rid, &patch::TYPENAME, id)
 }

 use std::collections::BTreeMap;
 use radicle::identity::DocAt;
 use radicle::issue::cache::Issues;
 use radicle::node;
 use radicle::patch::cache::Patches;
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle::{git, identity};
 use radicle_types::cobs::PaginatedQuery;
 use radicle_types::domain::inbox::models::notification;
 use radicle_types::domain::inbox::service::Service;
 use radicle_types::domain::inbox::traits::InboxService;
 use radicle_types::domain::inbox::traits::InboxService as _;
 use radicle_types::domain::repo::models::cobs;
 use radicle_types::error::Error;
 use radicle_types::outbound::sqlite::Sqlite;
 use radicle_types::AppState;
 #[tauri::command]
 pub fn list_notifications(
     ctx: tauri::State<AppState>,
     sqlite_service: tauri::State<Service<Sqlite>>,
     profile: tauri::State<radicle::Profile>,
     service: tauri::State<Service<Sqlite>>,
     params: notification::RepoGroupParams,
 ) -> Result<
     PaginatedQuery<BTreeMap<git::Qualified<'static>, Vec<notification::NotificationItem>>>,
     cobs::PaginatedQuery<BTreeMap<git::Qualified<'static>, Vec<notification::NotificationItem>>>,
     Error,
 > {
     let profile = &ctx.profile;
     let aliases = profile.aliases();
     let cursor = params.skip.unwrap_or(0);
     let take = params.take.unwrap_or(20);
     let all = sqlite_service.repo_group(params.clone())?;
     let more = cursor + take < all.len();
     let repo = profile.storage.repository(params.repo)?;
     let patches = profile.patches(&repo)?;
     let issues = profile.issues(&repo)?;
     let content = all
         .into_iter()
         .skip(cursor)
         .take(take)
         .map(|(qualified, n)| {
             let items = n
                 .into_iter()
                 .filter_map(|s| {
                     let update: notification::RefUpdate =
                         (qualified.clone().into_refstring(), s.new, s.old).into();
                     let update: radicle::storage::RefUpdate = update.into();
                     let kind =
                         node::notifications::NotificationKind::try_from(qualified.clone()).ok()?;
                     match kind {
                         node::notifications::NotificationKind::Cob { ref typed_id } => {
                             if typed_id.is_patch() {
                                 let actions = notification::actions(
                                     typed_id.type_name.clone(),
                                     typed_id.id,
                                     update.old(),
                                     update.new(),
                                     &repo,
                                     &aliases,
                                 )
                                 .unwrap_or_default();
                                 match patches.get(&typed_id.id) {
                                     Ok(Some(p)) => Some(notification::NotificationItem::Patch(
                                         notification::Patch {
                                             row_id: s.row_id,
                                             id: typed_id.id,
                                             update: update.into(),
                                             timestamp: s.timestamp,
                                             title: p.title().to_string(),
                                             status: (p.state().clone()).into(),
                                             actions,
                                         },
                                     )),
                                     Ok(None) => {
                                         log::error!("No patch found");
                                         None
                                     }
                                     Err(e) => {
                                         log::error!("{}", e);
                                         None
                                     }
                                 }
                             } else if typed_id.is_issue() {
                                 let actions = notification::actions(
                                     typed_id.type_name.clone(),
                                     typed_id.id,
                                     update.old(),
                                     update.new(),
                                     &repo,
                                     &aliases,
                                 )
                                 .unwrap_or_default();
                                 match issues.get(&typed_id.id) {
                                     Ok(Some(i)) => Some(notification::NotificationItem::Issue(
                                         notification::Issue {
                                             row_id: s.row_id,
                                             id: typed_id.id,
                                             update: update.into(),
                                             timestamp: s.timestamp,
                                             title: i.title().to_string(),
                                             status: (*i.state()).into(),
                                             actions,
                                         },
                                     )),
                                     Ok(None) => {
                                         log::error!("No issue found");
                                         None
                                     }
                                     Err(e) => {
                                         log::error!("{}", e);
                                         None
                                     }
                                 }
                             } else {
                                 None
                             }
                         }
                         _ => None,
                     }
                 })
                 .collect::<Vec<_>>();
             (qualified, items)
         })
         .filter(|(_, v)| !v.is_empty())
         .collect::<BTreeMap<git::Qualified<'static>, Vec<notification::NotificationItem>>>();
     Ok(PaginatedQuery {
         cursor,
         more,
         content,
     })
     service.list_notifications(&profile, params)
 }
 #[tauri::command]
 pub fn count_notifications_by_repo(
     ctx: tauri::State<AppState>,
     inbox: tauri::State<Service<Sqlite>>,
     profile: tauri::State<radicle::Profile>,
     service: tauri::State<Service<Sqlite>>,
 ) -> Result<BTreeMap<identity::RepoId, notification::NotificationCount>, Error> {
     let profile = &ctx.profile;
     let result = inbox
         .counts_by_repo()?
         .filter_map(|s| {
             let (rid, count) = s.ok()?;
             let repo = profile.storage.repository(rid).ok()?;
             let DocAt { doc, .. } = repo.identity_doc().ok()?;
             let project = doc.project().ok()?;
             Some((
                 rid,
                 notification::NotificationCount {
                     rid,
                     name: project.name().to_string(),
                     count,
                 },
             ))
         })
         .collect::<BTreeMap<identity::RepoId, notification::NotificationCount>>();
     Ok(result)
     service.count_notifications_by_repo(&profile.storage)
 }
 #[tauri::command]
 pub fn clear_notifications(
     ctx: tauri::State<AppState>,
     profile: tauri::State<radicle::Profile>,
     service: tauri::State<Service<Sqlite>>,
     params: notification::SetStatusNotifications,
 ) -> Result<(), Error> {
     let profile = &ctx.profile;
     let mut notifications = profile.notifications_mut()?;
     match params {
         notification::SetStatusNotifications::Ids(ids) => notifications.clear(&ids)?,
         notification::SetStatusNotifications::Repo(repo) => notifications.clear_by_repo(&repo)?,
         notification::SetStatusNotifications::All => notifications.clear_all()?,
     };
     Ok(())
     service.clear_notifications(&profile, params)
 }

 use radicle::node::NodeId;
 use radicle_types::config::Config;
 use radicle_types::traits::Profile;
 use radicle::node::{AliasStore, NodeId};
 use crate::AppState;
 use radicle_types::config::Config;
 #[tauri::command]
 pub fn config(ctx: tauri::State<AppState>) -> Config {
     ctx.config()
 pub fn config(profile: tauri::State<radicle::Profile>) -> Config {
     Config::get(&profile)
 }
 #[tauri::command]
 pub fn alias(ctx: tauri::State<AppState>, nid: NodeId) -> Option<radicle::node::Alias> {
     ctx.alias(nid)
 pub fn alias(profile: tauri::State<radicle::Profile>, nid: NodeId) -> Option<radicle::node::Alias> {
     profile.alias(&nid)
 }

 use std::collections::BTreeSet;
 use std::str::FromStr;
 use radicle::{git, identity};
 use radicle::git;
 use radicle::identity::project::ProjectName;
 use radicle::identity::{doc, Project, RepoId, Visibility};
 use radicle::rad::InitError;
 use radicle::storage::git::Repository;
 use radicle::storage::refs::branch_of;
 use radicle::storage::{SignRepository, WriteRepository};
 use radicle_types as types;
 use radicle_types::domain::repo::models::{diff, repo};
 use radicle_types::domain::repo::service::Service;
 use radicle_types::domain::repo::traits::RepoService as _;
 use radicle_types::error::Error;
 use radicle_types::traits::repo::{Repo, Show};
 use crate::AppState;
 use radicle_types::outbound::radicle::Radicle;
 use radicle_types::outbound::sqlite::Sqlite;
 #[tauri::command]
 pub fn list_repos(
     ctx: tauri::State<AppState>,
     show: Show,
 ) -> Result<Vec<types::repo::RepoInfo>, Error> {
     ctx.list_repos(show)
     service: tauri::State<Service<Radicle, Sqlite>>,
     show: repo::Show,
 ) -> Result<Vec<repo::RepoInfo>, Error> {
     service.list_repos(show)
 }
 #[tauri::command]
 pub fn repo_count(ctx: tauri::State<AppState>) -> Result<types::repo::RepoCount, Error> {
     ctx.repo_count()
 pub fn repo_count(
     service: tauri::State<Service<Radicle, Sqlite>>,
 ) -> Result<repo::RepoCount, Error> {
     service.repo_count()
 }
 #[tauri::command]
 pub fn repo_by_id(
     ctx: tauri::State<AppState>,
     rid: RepoId,
 ) -> Result<types::repo::RepoInfo, Error> {
     ctx.repo_by_id(rid)
     service: tauri::State<Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
 ) -> Result<repo::RepoInfo, Error> {
     service.repo_by_id(rid)
 }
 #[tauri::command]
 pub async fn diff_stats(
     ctx: tauri::State<'_, AppState>,
     rid: RepoId,
     service: tauri::State<'_, Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     base: git::Oid,
     head: git::Oid,
 ) -> Result<types::diff::Stats, Error> {
     ctx.diff_stats(rid, base, head)
 ) -> Result<diff::Stats, Error> {
     service.diff_stats(rid, base, head)
 }
 #[tauri::command]
 pub async fn list_commits(
     ctx: tauri::State<'_, AppState>,
     rid: RepoId,
     base: String,
     head: String,
 ) -> Result<Vec<types::repo::Commit>, Error> {
     ctx.list_commits(rid, base, head)
     service: tauri::State<'_, Service<Radicle, Sqlite>>,
     rid: identity::RepoId,
     base: git::Oid,
     head: git::Oid,
 ) -> Result<Vec<repo::Commit>, Error> {
     service.list_commits(rid, base, head)
 }
 #[tauri::command]
 pub(crate) async fn create_repo(
     ctx: tauri::State<'_, AppState>,
     service: tauri::State<'_, Service<Radicle, Sqlite>>,
     name: String,
     description: String,
 ) -> Result<(), Error> {
     let profile = &ctx.profile;
     let storage = &profile.storage;
     let signer = ctx.profile.signer()?;
     let config = radicle::git::raw::Config::open_default()?;
     // SAFETY: "master" is always a valid RefString
     let default_branch = git::RefString::try_from(

     )
     .unwrap();
     let name = ProjectName::from_str(&name)?;
     if description.len() > doc::MAX_STRING_LENGTH {
         return Err(Error::ProjectError(
             radicle::identity::project::ProjectError::Description("Cannot exceed 255 characters."),
         ));
     }
     let visibility = Visibility::Private {
         allow: BTreeSet::default(),
     };
     let proj = Project::new(name, description, default_branch.clone()).map_err(|errs| {
         InitError::ProjectPayload(
             errs.into_iter()
                 .map(|err| err.to_string())
                 .collect::<Vec<_>>()
                 .join(", "),
         )
     })?;
     let doc = radicle::identity::Doc::initial(proj, profile.public_key.into(), visibility);
     let (project, identity) = Repository::init(&doc, &storage, &signer)?;
     let tree_id = {
         let mut index = project.backend.index()?;
         index.write_tree()
     }?;
     let sig = project.backend.signature()?;
     let tree = project.backend.find_tree(tree_id)?;
     project.set_remote_identity_root_to(signer.public_key(), identity)?;
     project.set_identity_head_to(identity)?;
     let base = project
         .backend
         .commit(Some("HEAD"), &sig, &sig, "Initial commit", &tree, &[])?;
     let ns_head = branch_of(&ctx.profile.public_key, &default_branch);
     project
         .backend
         .reference(ns_head.as_str(), base, false, "Created namespace ref")?;
     project.set_head()?;
     project.sign_refs(&signer)?;
     Ok(())
     service.create_repo(name, description, default_branch, None)
 }

 use std::collections::BTreeMap;
 use std::ops::Deref as _;
 use radicle::cob::cache::COBS_DB_FILE;
 use radicle::identity::RepoId;
 use radicle::identity;
 use radicle::node::{Handle, Node, NOTIFICATIONS_DB_FILE};
 use radicle::storage::ReadStorage;
 use tauri::{AppHandle, Emitter, Manager};
 use radicle_types::config::Config;
 use radicle_types::domain;
 use radicle_types::error::Error;
 use radicle_types::traits::Profile;
 use radicle_types::{domain, AppState};
 use radicle_types::outbound::radicle::Radicle;
 use radicle_types::outbound::sqlite::Sqlite;
 #[tauri::command]
 pub(crate) fn startup(app: AppHandle) -> Result<Config, Error> {
 pub(crate) fn load_profile(app: AppHandle) -> Result<Config, Error> {
     let profile = radicle::Profile::load()?;
     let repositories = profile.storage.repositories()?;
     let public_key = profile.public_key;
     let config = Config::get(&profile);
     app.manage(profile);
     let inbox_db = radicle_types::outbound::sqlite::Sqlite::reader(
         profile.node().join(NOTIFICATIONS_DB_FILE),
     )?;
     let cob_db =
         radicle_types::outbound::sqlite::Sqlite::reader(profile.cobs().join(COBS_DB_FILE))?;
     Ok(config)
 }
 #[tauri::command]
 pub(crate) fn create_services(
     app: AppHandle,
     profile: tauri::State<radicle::Profile>,
 ) -> Result<(), Error> {
     let inbox_db = Sqlite::reader(profile.node().join(NOTIFICATIONS_DB_FILE))?;
     let cob_db = Sqlite::reader(profile.cobs().join(COBS_DB_FILE))?;
     let radicle = Radicle::new(profile.deref().clone());
     let inbox_service = domain::inbox::service::Service::new(inbox_db);
     let patch_service = domain::patch::service::Service::new(cob_db);
     let repo_service = domain::repo::service::Service::new(radicle.clone(), cob_db);
     let identity_service = domain::identity::service::Service::new(radicle);
     app.manage(inbox_service);
     app.manage(repo_service);
     app.manage(identity_service);
     Ok(())
 }
 #[tauri::command]
 pub(crate) fn create_event_emitters(
     app: AppHandle,
     profile: tauri::State<radicle::Profile>,
 ) -> Result<(), Error> {
     let node_handle = app.app_handle().clone();
     let sync_handle = app.app_handle().clone();
     let events_handle = app.app_handle().clone();

     tauri::async_runtime::spawn(async move {
         loop {
             let mut sync_status =
                 BTreeMap::<RepoId, Option<radicle_types::cobs::repo::SyncStatus>>::new();
             let mut sync_status = BTreeMap::<
                 identity::RepoId,
                 Option<radicle_types::domain::repo::models::repo::SyncStatus>,
             >::new();
             for repo in &repositories {
                 if let Ok(seeds) = node_seeds.seeds(repo.rid).map(Into::<Vec<_>>::into) {
                     if let Some(status) =

+	`pub mod service;`
+	`pub mod traits;`

         }
     });
     let state = AppState { profile };
     app.manage(state.clone());
     Ok(state.config())
     Ok(())
 }

 mod commands;
 use radicle_types::AppState;
 use commands::{auth, cob, diff, inbox, profile, repo, startup, thread};
 #[cfg_attr(mobile, tauri::mobile_entry_point)]

         .invoke_handler(tauri::generate_handler![
             auth::authenticate,
             auth::init,
             auth::check_agent,
             cob::get_embed,
             cob::issue::activity_by_issue,
             cob::issue::comment_threads_by_issue_id,

             repo::list_repos,
             repo::repo_by_id,
             repo::repo_count,
             startup::startup,
             startup::load_profile,
             startup::create_services,
             startup::create_event_emitters,
             thread::create_issue_comment,
             thread::create_patch_comment,
         ])

 use radicle::profile::Aliases;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 use radicle::cob;
 use radicle::identity;
 use radicle::node::{Alias, AliasStore};
 pub mod diff;
 pub mod issue;
 pub mod repo;
 pub mod stream;
 pub mod thread;
 #[derive(Debug, Clone, Serialize, TS, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "cob/")]
 pub struct Author {
     #[ts(as = "String")]
     did: identity::Did,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     #[ts(as = "Option<String>", optional)]
     alias: Option<Alias>,
 }
 impl Author {
     pub fn new(did: &identity::Did, aliases: &impl AliasStore) -> Self {
         Self {
             did: *did,
             alias: aliases.alias(did),
         }
     }
     pub fn did(&self) -> &identity::Did {
         &self.did
     }
 }
 pub trait FromRadicleAction<A> {
     fn from_radicle_action(value: A, aliases: &Aliases) -> Self;
 }
 /// Everything that can be done in the system is represented by an `Op`.
 /// Operations are applied to an accumulator to yield a final state.
 #[derive(Debug, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "cob/")]
 pub struct Operation<A> {
     #[ts(as = "String")]
     pub id: cob::EntryId,
     pub actions: Vec<A>,
     pub author: Author,
     #[ts(type = "number")]
     pub timestamp: cob::Timestamp,
 }
 #[derive(Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "cob/")]
 pub struct EmbedWithMimeType {
     pub content: Vec<u8>,
     pub mime_type: Option<String>,
 }
 #[derive(TS, Serialize)]
 #[doc = "A type alias for the TS type `never`."]
 #[ts(export)]
 #[ts(export_to = "cob/")]
 pub enum Never {}
 #[derive(TS, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "cob/")]
 pub struct CobOptions {
     #[ts(as = "Option<bool>")]
     #[ts(optional)]
     announce: Option<bool>,
 }
 impl CobOptions {
     pub fn announce(&self) -> bool {
         self.announce.unwrap_or(true)
     }
 }
 #[derive(Serialize, Deserialize, TS, Debug, PartialEq, Clone)]
 #[ts(export)]
 #[ts(export_to = "cob/")]
 pub struct PaginatedQuery<T> {
     pub cursor: usize,
     pub more: bool,
     pub content: T,
 }
 pub mod query {
     use serde::{Deserialize, Serialize};
     use radicle::issue;
     use radicle::patch;
     #[derive(Default, Serialize, Deserialize)]
     #[serde(rename_all = "camelCase")]
     pub enum IssueStatus {
         Closed,
         #[default]
         Open,
         All,
     }
     impl IssueStatus {
         pub fn matches(&self, issue: &issue::State) -> bool {
             match self {
                 Self::Open => matches!(issue, issue::State::Open),
                 Self::Closed => matches!(issue, issue::State::Closed { .. }),
                 Self::All => true,
             }
         }
     }
     #[derive(Default, Serialize, Deserialize, Clone)]
     #[serde(rename_all = "camelCase")]
     pub enum PatchStatus {
         #[default]
         Open,
         Draft,
         Archived,
         Merged,
     }
     impl From<patch::Status> for PatchStatus {
         fn from(value: patch::Status) -> Self {
             match value {
                 patch::Status::Archived => Self::Archived,
                 patch::Status::Draft => Self::Draft,
                 patch::Status::Merged => Self::Merged,
                 patch::Status::Open => Self::Open,
             }
         }
     }
     impl From<PatchStatus> for patch::Status {
         fn from(value: PatchStatus) -> Self {
             match value {
                 PatchStatus::Archived => Self::Archived,
                 PatchStatus::Draft => Self::Draft,
                 PatchStatus::Merged => Self::Merged,
                 PatchStatus::Open => Self::Open,
             }
         }
     }
 }

 use std::collections::BTreeSet;
 use radicle::node::AliasStore;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 use radicle::cob;
 use radicle::identity;
 use radicle::issue;
 use crate::cobs;
 use super::Author;
 use super::FromRadicleAction;
 #[derive(TS, Serialize)]
 #[ts(export)]
 #[ts(export_to = "cob/issue/")]
 #[serde(rename_all = "camelCase")]
 pub struct Issue {
     id: String,
     author: cobs::Author,
     title: String,
     state: cobs::issue::State,
     assignees: Vec<cobs::Author>,
     body: cobs::thread::Comment,
     #[ts(type = "number")]
     comment_count: usize,
     #[ts(as = "Vec<String>")]
     labels: Vec<cob::Label>,
     #[ts(type = "number")]
     timestamp: cob::Timestamp,
 }
 impl Issue {
     pub fn new(id: &issue::IssueId, issue: &issue::Issue, aliases: &impl AliasStore) -> Self {
         let (root_oid, root_comment) = issue.root();
         Self {
             id: id.to_string(),
             author: cobs::Author::new(issue.author().id(), aliases),
             title: issue.title().to_string(),
             state: (*issue.state()).into(),
             assignees: issue
                 .assignees()
                 .map(|did| cobs::Author::new(did, aliases))
                 .collect::<Vec<_>>(),
             body: cobs::thread::Comment::<cobs::Never>::new(
                 *root_oid,
                 root_comment.clone(),
                 aliases,
             ),
             comment_count: issue.replies().count(),
             labels: issue.labels().cloned().collect::<Vec<_>>(),
             timestamp: issue.timestamp(),
         }
     }
 }
 #[derive(Debug, Default, Serialize, Deserialize, TS)]
 #[serde(rename_all = "camelCase", tag = "status")]
 #[ts(export)]
 #[ts(export_to = "cob/issue/")]
 pub enum State {
     Closed {
         reason: CloseReason,
     },
     #[default]
     Open,
 }
 impl From<State> for issue::State {
     fn from(value: State) -> Self {
         match value {
             State::Closed { reason } => Self::Closed {
                 reason: reason.into(),
             },
             State::Open => Self::Open,
         }
     }
 }
 impl From<issue::State> for State {
     fn from(value: issue::State) -> Self {
         match value {
             issue::State::Closed { reason } => Self::Closed {
                 reason: reason.into(),
             },
             issue::State::Open => Self::Open,
         }
     }
 }
 #[derive(Debug, Serialize, Deserialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "cob/issue/")]
 pub enum CloseReason {
     Other,
     Solved,
 }
 impl From<CloseReason> for issue::CloseReason {
     fn from(value: CloseReason) -> Self {
         match value {
             CloseReason::Other => Self::Other,
             CloseReason::Solved => Self::Solved,
         }
     }
 }
 impl From<issue::CloseReason> for CloseReason {
     fn from(value: issue::CloseReason) -> Self {
         match value {
             issue::CloseReason::Other => Self::Other,
             issue::CloseReason::Solved => Self::Solved,
         }
     }
 }
 #[derive(TS, Serialize, Deserialize)]
 #[ts(export)]
 #[ts(export_to = "cob/issue/")]
 #[serde(rename_all = "camelCase")]
 pub struct NewIssue {
     pub title: String,
     pub description: String,
     #[ts(as = "Option<Vec<String>>", optional)]
     pub labels: Vec<cob::Label>,
     #[ts(as = "Option<Vec<String>>", optional)]
     pub assignees: Vec<identity::Did>,
     #[ts(as = "Option<_>", optional)]
     pub embeds: Vec<cobs::thread::Embed>,
 }
 #[derive(Debug, Serialize, Deserialize, TS)]
 #[serde(tag = "type", rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "cob/issue/")]
 pub enum Action {
     #[serde(rename = "assign")]
     Assign { assignees: BTreeSet<Author> },
     #[serde(rename = "edit")]
     Edit { title: String },
     #[serde(rename = "lifecycle")]
     Lifecycle { state: cobs::issue::State },
     #[serde(rename = "label")]
     Label {
         #[ts(as = "Vec<String>")]
         labels: BTreeSet<cob::Label>,
     },
     #[serde(rename_all = "camelCase")]
     #[serde(rename = "comment")]
     Comment {
         body: String,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         #[ts(as = "Option<String>", optional)]
         reply_to: Option<cob::thread::CommentId>,
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
         #[ts(as = "Option<_>", optional)]
         embeds: Vec<cobs::thread::Embed>,
     },
     #[serde(rename = "comment.edit")]
     CommentEdit {
         #[ts(as = "String")]
         id: cob::thread::CommentId,
         body: String,
         #[ts(as = "Option<_>", optional)]
         embeds: Vec<cobs::thread::Embed>,
     },
     #[serde(rename = "comment.redact")]
     CommentRedact {
         #[ts(as = "String")]
         id: cob::thread::CommentId,
     },
     #[serde(rename = "comment.react")]
     CommentReact {
         #[ts(as = "String")]
         id: cob::thread::CommentId,
         #[ts(as = "String")]
         reaction: cob::Reaction,
         active: bool,
     },
 }
 impl FromRadicleAction<radicle::issue::Action> for Action {
     fn from_radicle_action(
         value: radicle::issue::Action,
         aliases: &radicle::profile::Aliases,
     ) -> Self {
         match value {
             radicle::issue::Action::Assign { assignees } => Self::Assign {
                 assignees: assignees
                     .iter()
                     .map(|a| Author::new(a, aliases))
                     .collect::<BTreeSet<_>>(),
             },
             radicle::issue::Action::Comment {
                 body,
                 reply_to,
                 embeds,
             } => Self::Comment {
                 body,
                 reply_to,
                 embeds: embeds.into_iter().map(Into::into).collect::<Vec<_>>(),
             },
             radicle::issue::Action::CommentEdit { id, body, embeds } => Self::CommentEdit {
                 id,
                 body,
                 embeds: embeds.into_iter().map(Into::into).collect::<Vec<_>>(),
             },
             radicle::issue::Action::CommentReact {
                 id,
                 reaction,
                 active,
             } => Self::CommentReact {
                 id,
                 reaction,
                 active,
             },
             radicle::issue::Action::CommentRedact { id } => Self::CommentRedact { id },
             radicle::issue::Action::Label { labels } => Self::Label { labels },
             radicle::issue::Action::Lifecycle { state } => Self::Lifecycle {
                 state: state.into(),
             },
             radicle::issue::Action::Edit { title } => Self::Edit { title },
         }
     }
 }

 use localtime::LocalTime;
 #[derive(Debug, PartialEq, Eq, Clone, serde::Serialize, serde::Deserialize, ts_rs::TS)]
 #[serde(tag = "status")]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "repo/")]
 pub enum SyncStatus {
     /// We're in sync.
     #[serde(rename_all = "camelCase")]
     Synced {
         /// At what ref was the remote synced at.
         at: SyncedAt,
     },
     /// We're out of sync.
     #[serde(rename_all = "camelCase")]
     OutOfSync {
         /// Local head of our `rad/sigrefs`.
         local: SyncedAt,
         /// Remote head of our `rad/sigrefs`.
         remote: SyncedAt,
     },
 }
 impl From<radicle::node::SyncStatus> for SyncStatus {
     fn from(value: radicle::node::SyncStatus) -> Self {
         match value {
             radicle::node::SyncStatus::Synced { at } => SyncStatus::Synced { at: at.into() },
             radicle::node::SyncStatus::OutOfSync { local, remote } => SyncStatus::OutOfSync {
                 local: local.into(),
                 remote: remote.into(),
             },
         }
     }
 }
 /// Holds an oid and timestamp.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, ts_rs::TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "repo/")]
 pub struct SyncedAt {
     #[ts(as = "String")]
     pub oid: radicle::git::Oid,
     #[serde(with = "radicle::serde_ext::localtime::time")]
     #[ts(type = "number")]
     pub timestamp: LocalTime,
 }
 impl From<radicle::node::SyncedAt> for SyncedAt {
     fn from(value: radicle::node::SyncedAt) -> Self {
         Self {
             oid: value.oid,
             timestamp: value.timestamp,
         }
     }
 }

 pub mod error;
 mod iter;
 pub use iter::ActionsIter;
 use iter::Walk;
 use std::fmt::Debug;
 use std::marker::PhantomData;
 use radicle::cob::{ObjectId, TypeName};
 use radicle::git::Oid;
 use radicle::profile::Aliases;
 use radicle::storage::git::Repository;
 use serde::Deserialize;
 use crate::domain::inbox::models::notification::ActionWithAuthor;
 /// Helper trait for anything can provide its initial commit. Generally, this is
 /// the root of a COB object.
 pub trait HasRoot {
     /// Return the root `Oid` of the COB.
     fn root(&self) -> Oid;
 }
 /// Provide the stream of actions that are related to a given COB.
 ///
 /// The whole history of actions can be retrieved via [`CobStream::all`].
 ///
 /// To constrain the history, use one of [`CobStream::since`],
 /// [`CobStream::until`], or [`CobStream::range`].
 pub trait CobStream: HasRoot {
     /// Any error that can occur when iterating over the actions.
     type IterError: std::error::Error + Send + Sync + 'static;
     /// The associated `Action` type for the COB.
     type Action: for<'de> Deserialize<'de>;
     /// The iterator that walks over the actions.
     type Iter: Iterator<Item = Result<Self::Action, Self::IterError>>;
     /// Get an iterator of all actions from the inception of the collaborative
     /// object.
     fn all(&self) -> Result<Self::Iter, error::Stream>;
     /// Get an iterator of all actions from the given `oid`, in the
     /// collaborative object's history.
     fn since(&self, oid: Oid) -> Result<Self::Iter, error::Stream>;
     /// Get an iterator of all actions until the given `oid`, in the
     /// collaborative object's history.
     fn until(&self, oid: Oid) -> Result<Self::Iter, error::Stream>;
     /// Get an iterator of all actions `from` the given `Oid`, `until` the
     /// other `Oid`, in the collaborative object's history.
     fn range(&self, from: Oid, until: Oid) -> Result<Self::Iter, error::Stream>;
 }
 /// The range for iterating over a COB's action history.
 ///
 /// Construct via [`CobRange::new`] to use for constructing a [`Stream`].
 #[derive(Clone, Debug)]
 pub struct CobRange {
     root: Oid,
     until: iter::Until,
 }
 impl CobRange {
     /// Construct a `CobRange` for a given COB [`TypeName`] and its
     /// [`ObjectId`] identifier.
     ///
     /// The range will be from the root, given by the [`ObjectId`], to the
     /// reference tips of all remote namespaces.
     pub fn new(typename: &TypeName, object_id: &ObjectId) -> Self {
         let glob = radicle::storage::refs::cobs(typename, object_id);
         Self {
             root: **object_id,
             until: iter::Until::Glob(glob),
         }
     }
 }
 impl HasRoot for CobRange {
     fn root(&self) -> Oid {
         self.root
     }
 }
 /// A stream over a COB's actions.
 ///
 /// The generic parameter `A` is filled by the COB's corresponding `Action`
 /// type.
 ///
 /// The `Stream` implements [`CobStream`], so iterators over the actions can be
 /// constructed via the [`CobStream`] methods.
 ///
 /// To construct a `Stream`, use [`Stream::new`].
 pub struct Stream<'a, A> {
     repo: &'a Repository,
     aliases: &'a Aliases,
     range: CobRange,
     typename: TypeName,
     marker: PhantomData<A>,
 }
 impl<'a, A> Stream<'a, A> {
     /// Construct a new stream providing the underlying `repo`, a [`CobRange`],
     /// and the [`TypeName`] of the COB that is being streamed.
     pub fn new(
         repo: &'a Repository,
         range: CobRange,
         typename: TypeName,
         aliases: &'a Aliases,
     ) -> Self {
         Self {
             repo,
             range,
             typename,
             aliases,
             marker: PhantomData,
         }
     }
 }
 impl<A> HasRoot for Stream<'_, A> {
     fn root(&self) -> Oid {
         self.range.root()
     }
 }
 impl<'a, A> CobStream for Stream<'a, A>
 where
     A: for<'de> Deserialize<'de>,
     A: Debug,
 {
     type IterError = error::Actions;
     type Action = ActionWithAuthor<A>;
     type Iter = ActionsIter<'a, A>;
     fn all(&self) -> Result<Self::Iter, error::Stream> {
         Ok(ActionsIter::new(
             Walk::from(self.range.clone())
                 .iter(self.repo)
                 .map_err(error::Stream::new)?,
             self.typename.clone(),
             self.repo,
             self.aliases,
         ))
     }
     fn since(&self, oid: Oid) -> Result<Self::Iter, error::Stream> {
         Ok(ActionsIter::new(
             Walk::from(self.range.clone())
                 .since(oid)
                 .iter(self.repo)
                 .map_err(error::Stream::new)?,
             self.typename.clone(),
             self.repo,
             self.aliases,
         ))
     }
     fn until(&self, oid: Oid) -> Result<Self::Iter, error::Stream> {
         Ok(ActionsIter::new(
             Walk::from(self.range.clone())
                 .until(oid)
                 .iter(self.repo)
                 .map_err(error::Stream::new)?,
             self.typename.clone(),
             self.repo,
             self.aliases,
         ))
     }
     fn range(&self, from: Oid, until: Oid) -> Result<Self::Iter, error::Stream> {
         Ok(ActionsIter::new(
             Walk::new(from, until.into())
                 .iter(self.repo)
                 .map_err(error::Stream::new)?,
             self.typename.clone(),
             self.repo,
             self.aliases,
         ))
     }
 }

 use serde_json as json;
 use thiserror::Error;
 use radicle::git::raw as git2;
 use radicle::git::Oid;
 #[derive(Debug, Error)]
 #[error("failed to construct stream: {err}")]
 pub struct Stream {
     #[source]
     err: Box<dyn std::error::Error + Send + Sync + 'static>,
 }
 impl Stream {
     pub fn new<E>(err: E) -> Self
     where
         E: std::error::Error + Send + Sync + 'static,
     {
         Stream { err: err.into() }
     }
 }
 #[derive(Debug, Error)]
 pub enum Actions {
     #[error("failed to get a commit while iterating over stream: {err}")]
     Commit {
         #[source]
         err: git2::Error,
     },
     #[error("failed to get associated tree for commit {oid}: {err}")]
     Tree {
         oid: Oid,
         #[source]
         err: git2::Error,
     },
     #[error("failed to get COB manifest entry in tree {oid}: {err}")]
     ManifestPath {
         oid: Oid,
         #[source]
         err: git2::Error,
     },
     #[error("failed to deserialize the COB manifest {oid}: {err}")]
     Manfiest {
         oid: Oid,
         #[source]
         err: json::Error,
     },
     #[error(transparent)]
     TreeAction(#[from] TreeAction),
 }
 #[derive(Debug, Error)]
 pub enum TreeAction {
     #[error("could not peel the tree entry to an object: {err}")]
     InvalidEntry {
         #[source]
         err: git2::Error,
     },
     #[error("expected git blob but found {obj}")]
     InvalidObject { obj: String },
     #[error(transparent)]
     Action(#[from] Action),
 }
 #[derive(Debug, Error)]
 #[error("failed to deserialize action {oid}: {err}")]
 pub struct Action {
     oid: Oid,
     #[source]
     err: json::Error,
 }
 impl Action {
     pub fn new(oid: Oid, err: json::Error) -> Self {
         Self { oid, err }
     }
 }

 use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::path::Path;
 use serde::Deserialize;
 use serde_json as json;
 use radicle::cob::change::Storage;
 use radicle::cob::{Manifest, Op, TypeName};
 use radicle::git::raw as git2;
 use radicle::git::{Oid, PatternString};
 use radicle::profile::Aliases;
 use radicle::storage::git::Repository;
 use crate::cobs::Author;
 use crate::domain::inbox::models::notification::ActionWithAuthor;
 use super::error;
 use super::CobRange;
 /// A `Walk` specifies a range to construct a [`WalkIter`].
 #[derive(Clone, Debug)]
 pub(super) struct Walk {
     from: Oid,
     until: Until,
 }
 /// Specify the end of a range by either providing an [`Oid`] tip, or a
 /// reference glob via a [`PatternString`].
 #[derive(Clone, Debug)]
 pub enum Until {
     Tip(Oid),
     Glob(PatternString),
 }
 impl From<Oid> for Until {
     fn from(tip: Oid) -> Self {
         Self::Tip(tip)
     }
 }
 impl From<PatternString> for Until {
     fn from(glob: PatternString) -> Self {
         Self::Glob(glob)
     }
 }
 /// A revwalk over a set of commits, including the commit that is being walked
 /// from.
 pub(super) struct WalkIter<'a> {
     /// Git repository for looking up the commit object during the revwalk.
     repo: &'a Repository,
     /// The root commit that is being walked from.
     ///
     /// N.b. This is required since ranges are non-inclusive in Git, and if the
     /// `^` notation is used with a root commit, then it will result in an
     /// error.
     from: Option<Oid>,
     /// The revwalk that is being iterated over.
     inner: git2::Revwalk<'a>,
 }
 impl From<CobRange> for Walk {
     fn from(history: CobRange) -> Self {
         Self::new(history.root, history.until)
     }
 }
 impl Walk {
     /// Construct a new `Walk`, `from` the given commit, `until` the end of a
     /// given range.
     pub(super) fn new(from: Oid, until: Until) -> Self {
         Self { from, until }
     }
     /// Change the `Oid` that the walk starts from.
     pub(super) fn since(mut self, from: Oid) -> Self {
         self.from = from;
         self
     }
     /// Change the `Until` that the walk finishes on.
     pub(super) fn until(mut self, until: impl Into<Until>) -> Self {
         self.until = until.into();
         self
     }
     /// Get the iterator for the walk.
     pub(super) fn iter(self, repo: &Repository) -> Result<WalkIter<'_>, git2::Error> {
         let mut walk = repo.backend.revwalk()?;
         // N.b. ensure that we start from the `self.from` commit.
         walk.set_sorting(git2::Sort::TOPOLOGICAL.union(git2::Sort::REVERSE))?;
         match self.until {
             Until::Tip(tip) => walk.push_range(&format!("{}..{}", self.from, tip))?,
             Until::Glob(glob) => {
                 walk.push(*self.from)?;
                 walk.push_glob(glob.as_str())?
             }
         }
         Ok(WalkIter {
             repo,
             from: Some(self.from),
             inner: walk,
         })
     }
 }
 impl<'a> Iterator for WalkIter<'a> {
     type Item = Result<git2::Commit<'a>, git2::Error>;
     fn next(&mut self) -> Option<Self::Item> {
         // N.b. ensure that we start using the `from` commit and use the revwalk
         // after that.
         if let Some(from) = self.from.take() {
             return Some(self.repo.backend.find_commit(*from));
         }
         let oid = self.inner.next()?;
         Some(oid.and_then(|oid| self.repo.backend.find_commit(oid)))
     }
 }
 /// Iterate over all actions for a given range of commits.
 pub struct ActionsIter<'a, A> {
     /// The [`WalkIter`] provides each commit that it is being walked over for a
     /// given range.
     walk: WalkIter<'a>,
     /// For each commit in `walk`, a [`TreeActionsIter`] is then constructed to
     /// iterate over, returning each action in that tree.
     tree: Option<TreeActionsIter<'a, A>>,
     /// The walk can iterate over other COBs, e.g. an Identity COB, so this is
     /// used to filter for the correct type.
     typename: TypeName,
     repo: &'a Repository,
     aliases: &'a Aliases,
 }
 impl<'a, A> ActionsIter<'a, A> {
     pub(super) fn new(
         walk: WalkIter<'a>,
         typename: TypeName,
         repo: &'a Repository,
         aliases: &'a Aliases,
     ) -> Self {
         Self {
             walk,
             tree: None,
             typename,
             repo,
             aliases,
         }
     }
     fn matches_manifest(&self, tree: &git2::Tree) -> Result<bool, error::Actions> {
         let entry = match tree.get_path(Path::new("manifest")) {
             Ok(entry) => entry,
             Err(err) if matches!(err.code(), git2::ErrorCode::NotFound) => return Ok(false),
             Err(err) => {
                 return Err(error::Actions::ManifestPath {
                     oid: tree.id().into(),
                     err,
                 })
             }
         };
         let object = entry
             .to_object(&self.walk.repo.backend)
             .map_err(|err| error::TreeAction::InvalidEntry { err })?;
         let blob = object
             .into_blob()
             .map_err(|obj| error::TreeAction::InvalidObject {
                 obj: obj
                     .kind()
                     .map_or("unknown".to_string(), |kind| kind.to_string()),
             })?;
         let manifest = serde_json::from_slice::<Manifest>(blob.content()).map_err(|err| {
             error::Actions::Manfiest {
                 oid: blob.id().into(),
                 err,
             }
         })?;
         Ok(manifest.type_name == self.typename)
     }
 }
 impl<A> Iterator for ActionsIter<'_, A>
 where
     A: for<'de> Deserialize<'de>,
     A: Debug,
 {
     type Item = Result<ActionWithAuthor<A>, error::Actions>;
     fn next(&mut self) -> Option<Self::Item> {
         // Are we currently iterating over a tree?
         match self.tree {
             // Yes, so we check that tree iterator
             Some(ref mut iter) => match iter.next() {
                 // Return the action from the tree iterator
                 Some(a) => Some(a.map_err(error::Actions::from)),
                 // The tree iterator is exhausted, so we set it to None, and
                 // recurse to check the next commit iterator.
                 None => {
                     self.tree = None;
                     self.next()
                 }
             },
             // No, so we check the commit iterator
             None => {
                 match self.walk.next() {
                     Some(Ok(commit)) => match commit.tree() {
                         Ok(tree) => {
                             // Skip commits that are not for this COB type
                             match Self::matches_manifest(self, &tree) {
                                 Ok(matches) => {
                                     if !matches {
                                         return self.next();
                                     }
                                 }
                                 Err(err) => return Some(Err(err)),
                             }
                             let entry = self.repo.load(commit.id().into()).ok()?;
                             let op = Op::from(entry);
                             let author = Author::new(&op.author.into(), self.aliases);
                             // Set the tree iterator and walk over that
                             self.tree =
                                 Some(TreeActionsIter::new(self.walk.repo, tree, op, author));
                             // Hide this commit so we do not double process it
                             self.walk.inner.hide(commit.id()).ok();
                             self.next()
                         }
                         Err(err) => Some(Err(error::Actions::Tree {
                             oid: commit.id().into(),
                             err,
                         })),
                     },
                     // Something was wrong with the commit
                     Some(Err(err)) => Some(Err(error::Actions::Commit { err })),
                     // The walk iterator is also finished, so the whole process is finished
                     None => None,
                 }
             }
         }
     }
 }
 /// Iterator over tree entries to load each action.
 struct TreeActionsIter<'a, A> {
     /// The repository is required to get the underlying object of the tree
     /// entry.
     repo: &'a Repository,
     /// The Git tree from which the actions are being extracted.
     tree: git2::Tree<'a>,
     op: Op<Vec<u8>>,
     author: Author,
     /// Use an index to keep track of which entry is being processed. Note that
     /// `TreeIter` is *not* used since it poses many borrow-checker challenge.
     /// Instead, `self.tree.iter()` is called and the iterator is indexed into.
     index: usize,
     /// Use a marker for the generic `A` action type.
     marker: PhantomData<A>,
 }
 impl<'a, A> TreeActionsIter<'a, A> {
     fn new(repo: &'a Repository, tree: git2::Tree<'a>, op: Op<Vec<u8>>, author: Author) -> Self
     where
         A: for<'de> Deserialize<'de>,
     {
         Self {
             repo,
             tree,
             op,
             author,
             index: 0,
             marker: PhantomData,
         }
     }
 }
 impl<A> Iterator for TreeActionsIter<'_, A>
 where
     A: for<'de> Deserialize<'de>,
 {
     type Item = Result<ActionWithAuthor<A>, error::TreeAction>;
     fn next(&mut self) -> Option<Self::Item> {
         let entry = self.tree.iter().nth(self.index)?;
         self.index += 1;
         // N.b. if `from_tree_entry` is `None` we have filtered the entry so we
         // go the `next` entry
         from_tree_entry(self.repo, entry, self.op.clone(), self.author.clone())
             .or_else(|| self.next())
     }
 }
 /// Helper to construct the action for the tree entry, if it should be an action
 /// entry.
 ///
 /// The entry is only an action if it is a blob and its name is numerical.
 fn from_tree_entry<A>(
     repo: &Repository,
     entry: git2::TreeEntry,
     op: Op<Vec<u8>>,
     author: Author,
 ) -> Option<Result<ActionWithAuthor<A>, error::TreeAction>>
 where
     A: for<'de> Deserialize<'de>,
 {
     let as_action = |entry: git2::TreeEntry| -> Result<ActionWithAuthor<A>, error::TreeAction> {
         let object = entry
             .to_object(&repo.backend)
             .map_err(|err| error::TreeAction::InvalidEntry { err })?;
         let blob = object
             .into_blob()
             .map_err(|obj| error::TreeAction::InvalidObject {
                 obj: obj
                     .kind()
                     .map_or("unknown".to_string(), |kind| kind.to_string()),
             })?;
         action(&blob, op, author).map_err(error::TreeAction::from)
     };
     let name = entry.name()?;
     // An entry is only considered an action if it:
     //   a) Is a blob
     //   b) Its name is numeric, e.g. 1, 2, 3, etc.
     let is_action =
         entry.filemode() == i32::from(git2::FileMode::Blob) && name.chars().all(|c| c.is_numeric());
     is_action.then(|| as_action(entry))
 }
 /// Helper to deserialize an action from a blob's contents.
 fn action<A>(
     blob: &git2::Blob,
     op: Op<Vec<u8>>,
     author: Author,
 ) -> Result<ActionWithAuthor<A>, error::Action>
 where
     A: for<'de> Deserialize<'de>,
 {
     let action = json::from_slice::<A>(blob.content())
         .map_err(|err| error::Action::new(blob.id().into(), err))?;
     Ok(ActionWithAuthor {
         author,
         timestamp: op.timestamp,
         oid: op.id,
         action,
     })
 }

     #[ts(type = "{ default: 'allow', scope: 'followed' | 'all' } | { default: 'block' }")]
     pub seeding_policy: DefaultSeedingPolicy,
 }
 impl Config {
     pub fn get(profile: &radicle::Profile) -> Self {
         Self {
             public_key: profile.public_key,
             seeding_policy: profile.config.node.seeding_policy,
             alias: profile.config.node.alias.clone(),
         }
     }
 }

 use std::{ops::Range, path::PathBuf};
 use radicle_surf as surf;
 use serde::Serialize;
 use ts_rs::TS;
 use radicle::git;
 #[derive(Serialize, TS)]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Diff {
     pub files: Vec<FileDiff>,
     pub stats: Stats,
 }
 impl Stats {
     pub fn new(stats: &radicle_surf::diff::Stats) -> Self {
         Self {
             files_changed: stats.files_changed,
             insertions: stats.insertions,
             deletions: stats.deletions,
         }
     }
 }
 impl From<surf::diff::Diff> for Diff {
     fn from(value: surf::diff::Diff) -> Self {
         Self {
             files: value.files().cloned().map(Into::into).collect::<Vec<_>>(),
             stats: (*value.stats()).into(),
         }
     }
 }
 #[derive(Serialize, TS)]
 #[serde(
     tag = "status",
     rename_all_fields = "camelCase",
     rename_all = "camelCase"
 )]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub enum FileDiff {
     Added(Added),
     Deleted(Deleted),
     Modified(Modified),
     Moved(Moved),
     Copied(Copied),
 }
 impl From<surf::diff::FileDiff> for FileDiff {
     fn from(value: surf::diff::FileDiff) -> Self {
         match value {
             surf::diff::FileDiff::Added(surf::diff::Added { path, diff, new }) => {
                 Self::Added(Added {
                     path,
                     diff: diff.into(),
                     new: new.into(),
                 })
             }
             surf::diff::FileDiff::Deleted(surf::diff::Deleted { path, diff, old }) => {
                 Self::Deleted(Deleted {
                     path,
                     diff: diff.into(),
                     old: old.into(),
                 })
             }
             surf::diff::FileDiff::Modified(surf::diff::Modified {
                 path,
                 diff,
                 old,
                 new,
             }) => Self::Modified(Modified {
                 path,
                 diff: diff.into(),
                 old: old.into(),
                 new: new.into(),
             }),
             surf::diff::FileDiff::Moved(surf::diff::Moved {
                 old_path,
                 old,
                 new_path,
                 new,
                 diff,
             }) => Self::Moved(Moved {
                 old_path,
                 old: old.into(),
                 new_path,
                 new: new.into(),
                 diff: diff.into(),
             }),
             surf::diff::FileDiff::Copied(surf::diff::Copied {
                 old_path,
                 new_path,
                 old,
                 new,
                 diff,
             }) => Self::Copied(Copied {
                 old_path,
                 new_path,
                 old: old.into(),
                 new: new.into(),
                 diff: diff.into(),
             }),
         }
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(
     tag = "type",
     rename_all_fields = "camelCase",
     rename_all = "camelCase"
 )]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub enum DiffContent {
     Binary,
     Plain {
         hunks: Hunks,
         stats: FileStats,
         eof: EofNewLine,
     },
     Empty,
 }
 impl From<surf::diff::DiffContent> for DiffContent {
     fn from(value: surf::diff::DiffContent) -> Self {
         match value {
             surf::diff::DiffContent::Plain { hunks, stats, eof } => Self::Plain {
                 hunks: hunks.into(),
                 stats: stats.into(),
                 eof: eof.into(),
             },
             surf::diff::DiffContent::Binary => Self::Binary,
             surf::diff::DiffContent::Empty => Self::Empty,
         }
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct DiffFile {
     #[ts(as = "String")]
     pub oid: git::Oid,
     pub mode: FileMode,
 }
 impl From<surf::diff::DiffFile> for DiffFile {
     fn from(value: surf::diff::DiffFile) -> Self {
         Self {
             oid: value.oid,
             mode: value.mode.into(),
         }
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Added {
     pub path: PathBuf,
     pub diff: DiffContent,
     pub new: DiffFile,
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Deleted {
     pub path: PathBuf,
     pub diff: DiffContent,
     pub old: DiffFile,
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Moved {
     pub old_path: PathBuf,
     pub old: DiffFile,
     pub new_path: PathBuf,
     pub new: DiffFile,
     pub diff: DiffContent,
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Copied {
     pub old_path: PathBuf,
     pub new_path: PathBuf,
     pub old: DiffFile,
     pub new: DiffFile,
     pub diff: DiffContent,
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Modified {
     pub path: PathBuf,
     pub diff: DiffContent,
     pub old: DiffFile,
     pub new: DiffFile,
 }
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Stats {
     pub files_changed: usize,
     pub insertions: usize,
     pub deletions: usize,
 }
 impl From<surf::diff::Stats> for Stats {
     fn from(value: surf::diff::Stats) -> Self {
         Self {
             files_changed: value.files_changed,
             insertions: value.insertions,
             deletions: value.deletions,
         }
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all_fields = "camelCase", rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub enum FileMode {
     Blob,
     BlobExecutable,
     Tree,
     Link,
     Commit,
 }
 impl From<surf::diff::FileMode> for FileMode {
     fn from(value: surf::diff::FileMode) -> Self {
         match value {
             surf::diff::FileMode::Blob => Self::Blob,
             surf::diff::FileMode::BlobExecutable => Self::BlobExecutable,
             surf::diff::FileMode::Tree => Self::Tree,
             surf::diff::FileMode::Link => Self::Link,
             surf::diff::FileMode::Commit => Self::Commit,
         }
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all_fields = "camelCase", rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub enum EofNewLine {
     OldMissing,
     NewMissing,
     BothMissing,
     NoneMissing,
 }
 impl From<surf::diff::EofNewLine> for EofNewLine {
     fn from(value: surf::diff::EofNewLine) -> Self {
         match value {
             surf::diff::EofNewLine::OldMissing => Self::OldMissing,
             surf::diff::EofNewLine::NewMissing => Self::NewMissing,
             surf::diff::EofNewLine::BothMissing => Self::BothMissing,
             surf::diff::EofNewLine::NoneMissing => Self::NoneMissing,
         }
     }
 }
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct FileStats {
     pub additions: usize,
     pub deletions: usize,
 }
 impl From<surf::diff::FileStats> for FileStats {
     fn from(value: surf::diff::FileStats) -> Self {
         Self {
             additions: value.additions,
             deletions: value.deletions,
         }
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(
     tag = "type",
     rename_all_fields = "camelCase",
     rename_all = "camelCase"
 )]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub enum Modification {
     Addition(Addition),
     Deletion(Deletion),
     Context {
         line: String,
         line_no_old: u32,
         line_no_new: u32,
         highlight: Option<crate::syntax::Line>,
     },
 }
 impl From<surf::diff::Modification> for Modification {
     fn from(value: surf::diff::Modification) -> Self {
         match value {
             surf::diff::Modification::Addition(surf::diff::Addition { line, line_no }) => {
                 Modification::Addition(Addition {
                     line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                     line_no,
                     highlight: None,
                 })
             }
             surf::diff::Modification::Deletion(surf::diff::Deletion { line, line_no }) => {
                 Modification::Deletion(Deletion {
                     line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                     line_no,
                     highlight: None,
                 })
             }
             surf::diff::Modification::Context {
                 line,
                 line_no_old,
                 line_no_new,
             } => Modification::Context {
                 line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                 line_no_old,
                 line_no_new,
                 highlight: None,
             },
         }
     }
 }
 #[derive(Serialize, Clone, Debug, PartialEq, Eq, TS)]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Hunks(pub Vec<Hunk>);
 impl From<Vec<Hunk>> for Hunks {
     fn from(hunks: Vec<Hunk>) -> Self {
         Self(hunks)
     }
 }
 impl From<surf::diff::Hunks<surf::diff::Modification>> for Hunks {
     fn from(value: surf::diff::Hunks<surf::diff::Modification>) -> Self {
         Self(value.0.into_iter().map(Into::into).collect::<Vec<_>>())
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Hunk {
     pub header: String,
     pub lines: Vec<Modification>,
     pub old: Range<u32>,
     pub new: Range<u32>,
 }
 impl From<surf::diff::Hunk<surf::diff::Modification>> for Hunk {
     fn from(value: surf::diff::Hunk<surf::diff::Modification>) -> Self {
         Self {
             header: String::from_utf8_lossy(value.header.as_bytes()).to_string(),
             lines: value.lines.into_iter().map(Into::into).collect::<Vec<_>>(),
             old: value.old,
             new: value.new,
         }
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Line(pub(crate) Vec<u8>);
 impl Line {
     /// Create a new line.
     pub fn new(item: Vec<u8>) -> Self {
         Self(item)
     }
 }
 impl From<surf::diff::Line> for Line {
     fn from(value: surf::diff::Line) -> Self {
         Self(value.as_bytes().to_vec())
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Addition {
     pub line: String,
     pub line_no: u32,
     pub highlight: Option<crate::syntax::Line>,
 }
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "diff/")]
 pub struct Deletion {
     pub line: String,
     pub line_no: u32,
     pub highlight: Option<crate::syntax::Line>,
 }

 use radicle::crypto::ssh::Passphrase;
 use radicle::crypto::PublicKey;
 use crate::error::Error;
 use super::traits::IdentityService;
 #[derive(Debug, Clone)]
 pub struct Service<I>
 where
     I: IdentityService,
 {
     auth: I,
 }
 impl<I> Service<I>
 where
     I: IdentityService,
 {
     pub fn check_agent(public_key: PublicKey) -> Result<(), Error> {
         match radicle::crypto::ssh::agent::Agent::connect() {
             Ok(mut agent) => {
                 if agent.request_identities()?.contains(&public_key) {
                     Ok(())
                 } else {
                     Err(Error::KeysNotRegistered)
                 }
             }
             Err(e) if e.is_not_running() => Err(Error::AgentNotRunning)?,
             Err(e) => Err(e)?,
         }
     }
 }
 impl<I> Service<I>
 where
     I: IdentityService,
 {
     pub fn new(auth: I) -> Self {
         Self { auth }
     }
 }
 impl<I> IdentityService for Service<I>
 where
     I: IdentityService,
 {
     fn authenticate(&self, passphrase: Passphrase) -> Result<(), Error> {
         self.auth.authenticate(passphrase)
     }
 }

 use std::fmt::Debug;
 use radicle::cob::Timestamp;
 use radicle::node::notifications::NotificationId;
 use radicle::profile::Aliases;
 use radicle::{cob, git, identity, node, storage};
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 use crate::cobs::stream::{self, CobStream};
 use crate::cobs::{self, Author};
 use crate::domain::patch::models;
 use crate::domain::repo::models::stream::CobStream as _;
 use crate::domain::repo::models::{cobs, stream};
 #[derive(Serialize, Deserialize, TS)]
 #[serde(rename_all = "camelCase")]

     pub repo: identity::RepoId,
 }
 #[derive(Clone, Debug, serde::Deserialize)]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct RepoGroupParams {
     pub repo: identity::RepoId,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub skip: Option<usize>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub take: Option<usize>,
 }

     #[ts(type = "number")]
     pub timestamp: localtime::LocalTime,
     pub title: String,
     pub status: models::patch::State,
     pub actions: Vec<ActionWithAuthor<models::patch::Action>>,
     pub status: cobs::patch::State,
     pub actions: Vec<ActionWithAuthor<cobs::patch::Action>>,
 }
 /// Type of notification.

     > {
         self.inbox.repo_group(params)
     }
     fn list_notifications(
         &self,
         profile: &radicle::Profile,
         params: RepoGroupParams,
     ) -> Result<
         crate::domain::repo::models::cobs::PaginatedQuery<
             std::collections::BTreeMap<
                 git::Qualified<'static>,
                 Vec<super::models::notification::NotificationItem>,
             >,
         >,
         crate::error::Error,
     > {
         self.inbox.list_notifications(profile, params)
     }
     fn count_notifications_by_repo(
         &self,
         storage: &radicle::Storage,
     ) -> Result<
         std::collections::BTreeMap<
             radicle::identity::RepoId,
             super::models::notification::NotificationCount,
         >,
         crate::error::Error,
     > {
         self.inbox.count_notifications_by_repo(storage)
     }
     fn clear_notifications(
         &self,
         profile: &radicle::Profile,
         params: SetStatusNotifications,
     ) -> Result<(), crate::error::Error> {
         self.inbox.clear_notifications(profile, params)
     }
 }

 use radicle::identity;
 use radicle::patch;
 use radicle::patch::Patch;
 use radicle::patch::PatchId;
 use crate::domain::patch::traits::{PatchService, PatchStorage};
 #[derive(Debug, Clone)]
 pub struct Service<I>
 where
     I: PatchStorage,
 {
     patches: I,
 }
 impl<I> Service<I>
 where
     I: PatchStorage,
 {
     pub fn new(patches: I) -> Self {
         Self { patches }
     }
 }
 impl<I> PatchService for Service<I>
 where
     I: PatchStorage,
 {
     fn list(
         &self,
         rid: identity::RepoId,
     ) -> Result<impl Iterator<Item = (PatchId, Patch)>, super::models::patch::ListPatchesError>
     {
         self.patches.list(rid)
     }
     fn list_by_status(
         &self,
         rid: identity::RepoId,
         status: patch::Status,
     ) -> Result<impl Iterator<Item = (PatchId, Patch)>, super::models::patch::ListPatchesError>
     {
         self.patches.list_by_status(rid, status)
     }
 }

 use std::fs;
 use std::path::{Path, PathBuf};
 use radicle::git;
 use radicle_surf as surf;
 use serde::Serialize;
 use tree_sitter_highlight as ts;
 use ts_rs::TS;
 use crate as types;
 /// Highlight groups enabled.
 const HIGHLIGHTS: &[&str] = &[
     "attribute",
     "comment",
     "comment.documentation",
     "constant",
     "constant.builtin",
     "constructor",
     "declare",
     "embedded",
     "escape",
     "export",
     "float.literal",
     "function",
     "function.builtin",
     "function.macro",
     "function.method",
     "identifier",
     "indent.and",
     "indent.begin",
     "indent.branch",
     "indent.end",
     "integer_literal",
     "keyword",
     "keyword.coroutine",
     "keyword.debug",
     "keyword.exception",
     "keyword.repeat",
     "local.definition",
     "local.reference",
     "local.scope",
     "label",
     "module",
     "none",
     "number",
     "operator",
     "property",
     "punctuation",
     "punctuation.bracket",
     "punctuation.delimiter",
     "punctuation.special",
     "shorthand_property_identifier",
     "statement",
     "string",
     "string.special",
     "tag",
     "tag.delimiter",
     "tag.error",
     "text",
     "text.literal",
     "text.title",
     "type",
     "type.builtin",
     "type.qualifier",
     "type_annotation",
     "variable",
     "variable.builtin",
     "variable.parameter",
 ];
 /// A structure encapsulating an item and styling.
 #[derive(Clone, TS, Debug, Serialize, Eq, PartialEq)]
 #[ts(export)]
 #[ts(export_to = "syntax/")]
 pub struct Paint {
     pub item: String,
     pub style: Option<String>,
 }
 impl Paint {
     /// Constructs a new `Paint` structure encapsulating `item` with no set styling.
     pub fn new(item: String) -> Paint {
         Paint { item, style: None }
     }
     /// Sets the style of `self` to `style`.
     pub fn with_style(mut self, style: String) -> Paint {
         self.style = Some(style);
         self
     }
 }
 /// A styled string that does not contain any `'\n'`.
 #[derive(Clone, Debug, Serialize, Eq, PartialEq, TS)]
 #[ts(export)]
 #[ts(export_to = "syntax/")]
 pub struct Label(Paint);
 impl Label {
     /// Create a new label.
     pub fn new(s: &str) -> Self {
         Self(Paint::new(cleanup(s)))
     }
     /// Style a label.
     pub fn style(self, style: String) -> Self {
         Self(self.0.with_style(style))
     }
 }
 impl From<String> for Label {
     fn from(value: String) -> Self {
         Self::new(value.as_str())
     }
 }
 impl From<&str> for Label {
     fn from(value: &str) -> Self {
         Self::new(value)
     }
 }
 /// A line of text that has styling and can be displayed.
 #[derive(Clone, Debug, Serialize, Default, PartialEq, TS, Eq)]
 #[ts(export)]
 #[ts(export_to = "syntax/")]
 pub struct Line {
     items: Vec<Label>,
 }
 impl Line {
     /// Create a new line.
     pub fn new(item: impl Into<Label>) -> Self {
         Self {
             items: vec![item.into()],
         }
     }
 }
 impl IntoIterator for Line {
     type Item = Label;
     type IntoIter = Box<dyn Iterator<Item = Label>>;
     fn into_iter(self) -> Self::IntoIter {
         Box::new(self.items.into_iter())
     }
 }
 impl<T: Into<Label>> From<T> for Line {
     fn from(value: T) -> Self {
         Self::new(value)
     }
 }
 impl From<Vec<Label>> for Line {
     fn from(items: Vec<Label>) -> Self {
         Self { items }
     }
 }
 /// Cleanup the input string for display as a label.
 fn cleanup(input: &str) -> String {
     input.chars().filter(|c| *c != '\n' && *c != '\r').collect()
 }
 /// Syntax highlighted file builder.
 #[derive(Default)]
 struct Builder {
     /// Output lines.
     lines: Vec<Line>,
     /// Current output line.
     line: Vec<Label>,
     /// Current label.
     label: Vec<u8>,
     /// Current stack of styles.
     styles: Vec<String>,
 }
 impl Builder {
     /// Run the builder to completion.
     fn run(
         mut self,
         highlights: impl Iterator<Item = Result<ts::HighlightEvent, ts::Error>>,
         code: &[u8],
     ) -> Result<Vec<Line>, ts::Error> {
         for event in highlights {
             match event? {
                 ts::HighlightEvent::Source { start, end } => {
                     for (i, byte) in code.iter().enumerate().skip(start).take(end - start) {
                         if *byte == b'\n' {
                             self.advance();
                             // Start on new line.
                             self.lines.push(Line::from(self.line.clone()));
                             self.line.clear();
                         } else if i == code.len() - 1 {
                             // File has no `\n` at the end.
                             self.label.push(*byte);
                             self.advance();
                             self.lines.push(Line::from(self.line.clone()));
                         } else {
                             // Add to existing label.
                             self.label.push(*byte);
                         }
                     }
                 }
                 ts::HighlightEvent::HighlightStart(h) => {
                     let name = HIGHLIGHTS[h.0];
                     self.advance();
                     self.styles.push(name.to_string());
                 }
                 ts::HighlightEvent::HighlightEnd => {
                     self.advance();
                     self.styles.pop();
                 }
             }
         }
         Ok(self.lines)
     }
     /// Advance the state by pushing the current label onto the current line,
     /// using the current styling.
     fn advance(&mut self) {
         if !self.label.is_empty() {
             // Take the top-level style when there are more than one.
             let style = self.styles.first().cloned().unwrap_or_default();
             self.line
                 .push(Label::new(String::from_utf8_lossy(&self.label).as_ref()).style(style));
             self.label.clear();
         }
     }
 }
 /// Syntax highlighter based on `tree-sitter`.
 pub struct Highlighter {
     configs: std::collections::HashMap<String, ts::HighlightConfiguration>,
 }
 impl Default for Highlighter {
     fn default() -> Self {
         Self::new()
     }
 }
 impl Highlighter {
     pub fn new() -> Self {
         let configs: std::collections::HashMap<String, ts::HighlightConfiguration> = [
             ("rust", Self::config("rust")),
             ("json", Self::config("json")),
             ("jsdoc", Self::config("jsdoc")),
             ("typescript", Self::config("typescript")),
             ("javascript", Self::config("javascript")),
             ("markdown", Self::config("markdown")),
             ("css", Self::config("css")),
             ("go", Self::config("go")),
             ("regex", Self::config("regex")),
             ("shell", Self::config("shell")),
             ("c", Self::config("c")),
             ("python", Self::config("python")),
             ("svelte", Self::config("svelte")),
             ("ruby", Self::config("ruby")),
             ("tsx", Self::config("tsx")),
             ("html", Self::config("html")),
             ("toml", Self::config("toml")),
         ]
         .into_iter()
         .filter_map(|(lang, cfg)| cfg.map(|c| (lang.to_string(), c)))
         .collect();
         Highlighter { configs }
     }
     /// Highlight a source code file.
     pub fn highlight(&mut self, path: &Path, code: &[u8]) -> Result<Vec<Line>, ts::Error> {
         let mut highlighter = ts::Highlighter::new();
         // Check for a language if none found return plain lines.
         let Some(language) = Self::detect(path, code) else {
             let Ok(code) = std::str::from_utf8(code) else {
                 return Err(ts::Error::Unknown);
             };
             return Ok(code.lines().map(Line::new).collect());
         };
         // Check if there is a configuration if none found return plain lines.
         let Some(config) = &mut Self::config(&language) else {
             let Ok(code) = std::str::from_utf8(code) else {
                 return Err(ts::Error::Unknown);
             };
             return Ok(code.lines().map(Line::new).collect());
         };
         config.configure(HIGHLIGHTS);
         let highlights = highlighter.highlight(config, code, None, |language| {
             let l: &'static str = std::boxed::Box::leak(language.to_string().into_boxed_str());
             self.configs.get(l)
         })?;
         Builder::default().run(highlights, code)
     }
     /// Detect language.
     fn detect(path: &Path, _code: &[u8]) -> Option<String> {
         match path.extension().and_then(|e| e.to_str()) {
             Some("rs") => Some(String::from("rust")),
             Some("svelte") => Some(String::from("svelte")),
             Some("ts" | "js") => Some(String::from("typescript")),
             Some("json") => Some(String::from("json")),
             Some("regex") => Some(String::from("regex")),
             Some("sh" | "bash") => Some(String::from("shell")),
             Some("md" | "markdown") => Some(String::from("markdown")),
             Some("go") => Some(String::from("go")),
             Some("c") => Some(String::from("c")),
             Some("py") => Some(String::from("python")),
             Some("rb") => Some(String::from("ruby")),
             Some("tsx") => Some(String::from("tsx")),
             Some("html") | Some("htm") | Some("xml") => Some(String::from("html")),
             Some("css") => Some(String::from("css")),
             Some("toml") => Some(String::from("toml")),
             _ => None,
         }
     }
     /// Get a language configuration.
     fn config(language: &str) -> Option<ts::HighlightConfiguration> {
         match language {
             "rust" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_rust::LANGUAGE.into(),
                     language,
                     tree_sitter_rust::HIGHLIGHTS_QUERY,
                     tree_sitter_rust::INJECTIONS_QUERY,
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "json" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_json::LANGUAGE.into(),
                     language,
                     tree_sitter_json::HIGHLIGHTS_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "javascript" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_javascript::LANGUAGE.into(),
                     language,
                     tree_sitter_javascript::HIGHLIGHT_QUERY,
                     tree_sitter_javascript::INJECTIONS_QUERY,
                     tree_sitter_javascript::LOCALS_QUERY,
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "typescript" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
                     language,
                     tree_sitter_typescript::HIGHLIGHTS_QUERY,
                     "",
                     tree_sitter_typescript::LOCALS_QUERY,
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "markdown" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_md::LANGUAGE.into(),
                     language,
                     tree_sitter_md::HIGHLIGHT_QUERY_BLOCK,
                     tree_sitter_md::INJECTION_QUERY_BLOCK,
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "css" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_css::LANGUAGE.into(),
                     language,
                     tree_sitter_css::HIGHLIGHTS_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "go" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_go::LANGUAGE.into(),
                     language,
                     tree_sitter_go::HIGHLIGHTS_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "shell" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_bash::LANGUAGE.into(),
                     language,
                     tree_sitter_bash::HIGHLIGHT_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "c" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_c::LANGUAGE.into(),
                     language,
                     tree_sitter_c::HIGHLIGHT_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "python" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_python::LANGUAGE.into(),
                     language,
                     tree_sitter_python::HIGHLIGHTS_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "regex" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_regex::LANGUAGE.into(),
                     language,
                     tree_sitter_regex::HIGHLIGHTS_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "svelte" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_svelte_ng::LANGUAGE.into(),
                     language,
                     tree_sitter_svelte_ng::HIGHLIGHTS_QUERY,
                     tree_sitter_svelte_ng::INJECTIONS_QUERY,
                     tree_sitter_svelte_ng::LOCALS_QUERY,
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "ruby" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_ruby::LANGUAGE.into(),
                     language,
                     tree_sitter_ruby::HIGHLIGHTS_QUERY,
                     "",
                     tree_sitter_ruby::LOCALS_QUERY,
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "jsdoc" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_jsdoc::LANGUAGE.into(),
                     language,
                     tree_sitter_jsdoc::HIGHLIGHTS_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "tsx" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_typescript::LANGUAGE_TSX.into(),
                     language,
                     tree_sitter_typescript::HIGHLIGHTS_QUERY,
                     tree_sitter_javascript::INJECTIONS_QUERY,
                     tree_sitter_typescript::LOCALS_QUERY,
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "html" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_html::LANGUAGE.into(),
                     language,
                     tree_sitter_html::HIGHLIGHTS_QUERY,
                     tree_sitter_html::INJECTIONS_QUERY,
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             "toml" => Some(
                 ts::HighlightConfiguration::new(
                     tree_sitter_toml_ng::LANGUAGE.into(),
                     language,
                     tree_sitter_toml_ng::HIGHLIGHTS_QUERY,
                     "",
                     "",
                 )
                 .expect("Highlighter::config: highlight configuration must be valid"),
             ),
             _ => None,
         }
     }
 }
 /// Blob returned by the [`Repo`] trait.
 #[derive(PartialEq, Eq, Debug)]
 pub enum Blob {
     Binary,
     Empty,
     Plain(Vec<u8>),
 }
 /// A repository of Git blobs.
 pub trait Repo {
     /// Lookup a blob from the repo.
     fn blob(&self, oid: git::Oid) -> Result<Blob, git::raw::Error>;
     /// Lookup a file in the workdir.
     fn file(&self, path: &Path) -> Option<Blob>;
 }
 impl Repo for git::raw::Repository {
     fn blob(&self, oid: git::Oid) -> Result<Blob, git::raw::Error> {
         let blob = self.find_blob(*oid)?;
         if blob.is_binary() {
             Ok(Blob::Binary)
         } else {
             let content = blob.content();
             if content.is_empty() {
                 Ok(Blob::Empty)
             } else {
                 Ok(Blob::Plain(blob.content().to_vec()))
             }
         }
     }
     fn file(&self, path: &Path) -> Option<Blob> {
         self.workdir()
             .and_then(|dir| fs::read(dir.join(path)).ok())
             .map(|content| {
                 // A file is considered binary if there is a zero byte in the first 8 kilobytes
                 // of the file. This is the same heuristic Git uses.
                 let binary = content.iter().take(8192).any(|b| *b == 0);
                 if binary {
                     Blob::Binary
                 } else {
                     Blob::Plain(content)
                 }
             })
     }
 }
 /// Blobs passed down to the hunk renderer.
 #[derive(Debug)]
 pub struct Blobs<T> {
     pub old: Option<T>,
     pub new: Option<T>,
 }
 impl<T> Blobs<T> {
     pub fn new(old: Option<T>, new: Option<T>) -> Self {
         Self { old, new }
     }
 }
 impl Blobs<(PathBuf, Blob)> {
     pub fn highlight(&self, hi: &mut Highlighter) -> Blobs<Vec<Line>> {
         let mut blobs = Blobs::default();
         if let Some((path, Blob::Plain(content))) = &self.old {
             blobs.old = hi.highlight(path, content).ok();
         }
         if let Some((path, Blob::Plain(content))) = &self.new {
             blobs.new = hi.highlight(path, content).ok();
         }
         blobs
     }
     pub fn from_paths<R: Repo>(
         old: Option<(&Path, git::Oid)>,
         new: Option<(&Path, git::Oid)>,
         repo: &R,
     ) -> Blobs<(PathBuf, Blob)> {
         Blobs::new(
             old.and_then(|(path, oid)| {
                 repo.blob(oid)
                     .ok()
                     .or_else(|| repo.file(path))
                     .map(|blob| (path.to_path_buf(), blob))
             }),
             new.and_then(|(path, oid)| {
                 repo.blob(oid)
                     .ok()
                     .or_else(|| repo.file(path))
                     .map(|blob| (path.to_path_buf(), blob))
             }),
         )
     }
 }
 impl<T> Default for Blobs<T> {
     fn default() -> Self {
         Self {
             old: None,
             new: None,
         }
     }
 }
 pub trait ToPretty {
     /// The output of the render process.
     type Output: Serialize;
     /// Context that can be passed down from parent objects during rendering.
     type Context;
     /// Render to pretty diff output.
     fn pretty<R: Repo>(
         &self,
         hi: &mut Highlighter,
         context: &Self::Context,
         repo: &R,
     ) -> Self::Output;
 }
 impl ToPretty for surf::diff::Diff {
     type Output = super::diff::Diff;
     type Context = ();
     fn pretty<R: Repo>(
         &self,
         hi: &mut Highlighter,
         context: &Self::Context,
         repo: &R,
     ) -> Self::Output {
         let files = self
             .files()
             .map(|f| f.pretty(hi, context, repo))
             .collect::<Vec<_>>();
         types::domain::repo::models::diff::Diff {
             files,
             stats: (*self.stats()).into(),
         }
     }
 }
 impl ToPretty for surf::diff::FileDiff {
     type Output = super::diff::FileDiff;
     type Context = ();
     fn pretty<R: Repo>(
         &self,
         hi: &mut Highlighter,
         _context: &Self::Context,
         repo: &R,
     ) -> Self::Output {
         match self {
             surf::diff::FileDiff::Added(f) => {
                 types::domain::repo::models::diff::FileDiff::Added(f.pretty(hi, &(), repo))
             }
             surf::diff::FileDiff::Deleted(f) => {
                 super::diff::FileDiff::Deleted(f.pretty(hi, &(), repo))
             }
             surf::diff::FileDiff::Modified(f) => {
                 super::diff::FileDiff::Modified(f.pretty(hi, &(), repo))
             }
             surf::diff::FileDiff::Moved(f) => super::diff::FileDiff::Moved(f.pretty(hi, &(), repo)),
             surf::diff::FileDiff::Copied(f) => {
                 super::diff::FileDiff::Copied(f.pretty(hi, &(), repo))
             }
         }
     }
 }
 impl ToPretty for surf::diff::DiffContent {
     type Output = super::diff::DiffContent;
     type Context = Blobs<(PathBuf, Blob)>;
     fn pretty<R: Repo>(
         &self,
         hi: &mut Highlighter,
         blobs: &Self::Context,
         repo: &R,
     ) -> Self::Output {
         match self {
             surf::diff::DiffContent::Plain {
                 hunks: surf::diff::Hunks(hunks),
                 eof,
                 stats,
             } => {
                 let blobs = blobs.highlight(hi);
                 let hunks = hunks
                     .iter()
                     .map(|h| h.pretty(hi, &blobs, repo))
                     .collect::<Vec<_>>();
                 super::diff::DiffContent::Plain {
                     hunks: hunks.into(),
                     stats: (*stats).into(),
                     eof: (*eof).clone().into(),
                 }
             }
             surf::diff::DiffContent::Binary => super::diff::DiffContent::Binary,
             surf::diff::DiffContent::Empty => super::diff::DiffContent::Empty,
         }
     }
 }
 impl ToPretty for surf::diff::Moved {
     type Output = super::diff::Moved;
     type Context = ();
     fn pretty<R: Repo>(&self, hi: &mut Highlighter, _: &Self::Context, repo: &R) -> Self::Output {
         let old = Some((self.old_path.as_path(), self.old.oid));
         let new = Some((self.new_path.as_path(), self.new.oid));
         let blobs = Blobs::from_paths(old, new, repo);
         super::diff::Moved {
             old_path: self.old_path.clone(),
             old: self.old.clone().into(),
             new_path: self.new_path.clone(),
             new: self.new.clone().into(),
             diff: self.diff.pretty(hi, &blobs, repo),
         }
     }
 }
 impl ToPretty for surf::diff::Added {
     type Output = super::diff::Added;
     type Context = ();
     fn pretty<R: Repo>(&self, hi: &mut Highlighter, _: &Self::Context, repo: &R) -> Self::Output {
         let old = None;
         let new = Some((self.path.as_path(), self.new.oid));
         let blobs = Blobs::from_paths(old, new, repo);
         super::diff::Added {
             path: self.path.clone(),
             diff: self.diff.pretty(hi, &blobs, repo),
             new: self.new.clone().into(),
         }
     }
 }
 impl ToPretty for surf::diff::Deleted {
     type Output = super::diff::Deleted;
     type Context = ();
     fn pretty<R: Repo>(&self, hi: &mut Highlighter, _: &Self::Context, repo: &R) -> Self::Output {
         let old = Some((self.path.as_path(), self.old.oid));
         let new = None;
         let blobs = Blobs::from_paths(old, new, repo);
         super::diff::Deleted {
             path: self.path.clone(),
             diff: self.diff.pretty(hi, &blobs, repo),
             old: self.old.clone().into(),
         }
     }
 }
 impl ToPretty for surf::diff::Modified {
     type Output = super::diff::Modified;
     type Context = ();
     fn pretty<R: Repo>(&self, hi: &mut Highlighter, _: &Self::Context, repo: &R) -> Self::Output {
         let old = Some((self.path.as_path(), self.old.oid));
         let new = Some((self.path.as_path(), self.new.oid));
         let blobs = Blobs::from_paths(old, new, repo);
         super::diff::Modified {
             path: self.path.clone(),
             diff: self.diff.pretty(hi, &blobs, repo),
             new: self.new.clone().into(),
             old: self.old.clone().into(),
         }
     }
 }
 impl ToPretty for surf::diff::Copied {
     type Output = super::diff::Copied;
     type Context = ();
     fn pretty<R: Repo>(&self, hi: &mut Highlighter, _: &Self::Context, repo: &R) -> Self::Output {
         let old = Some((self.old_path.as_path(), self.old.oid));
         let new = Some((self.new_path.as_path(), self.new.oid));
         let blobs = Blobs::from_paths(old, new, repo);
         super::diff::Copied {
             old_path: self.old_path.clone(),
             new_path: self.new_path.clone(),
             diff: self.diff.pretty(hi, &blobs, repo),
             new: self.new.clone().into(),
             old: self.old.clone().into(),
         }
     }
 }
 impl ToPretty for surf::diff::Hunk<surf::diff::Modification> {
     type Output = super::diff::Hunk;
     type Context = Blobs<Vec<Line>>;
     fn pretty<R: Repo>(
         &self,
         hi: &mut Highlighter,
         blobs: &Self::Context,
         repo: &R,
     ) -> Self::Output {
         let lines = self
             .lines
             .clone()
             .into_iter()
             .map(|l| l.pretty(hi, blobs, repo))
             .collect::<Vec<_>>();
         super::diff::Hunk {
             header: String::from_utf8_lossy(self.header.as_bytes()).to_string(),
             new: self.new.clone(),
             old: self.old.clone(),
             lines,
         }
     }
 }
 impl ToPretty for surf::diff::Modification {
     type Output = super::diff::Modification;
     type Context = Blobs<Vec<Line>>;
     fn pretty<R: Repo>(
         &self,
         _hi: &mut Highlighter,
         blobs: &<radicle_surf::diff::Modification as ToPretty>::Context,
         _repo: &R,
     ) -> Self::Output {
         match self {
             surf::diff::Modification::Deletion(surf::diff::Deletion { line, line_no }) => {
                 if let Some(lines) = &blobs.old.as_ref() {
                     super::diff::Modification::Deletion(super::diff::Deletion {
                         line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                         highlight: Some(lines[*line_no as usize - 1].clone()),
                         line_no: *line_no,
                     })
                 } else {
                     super::diff::Modification::Deletion(super::diff::Deletion {
                         line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                         line_no: *line_no,
                         highlight: None,
                     })
                 }
             }
             surf::diff::Modification::Addition(surf::diff::Addition { line, line_no }) => {
                 if let Some(lines) = &blobs.new.as_ref() {
                     super::diff::Modification::Addition(super::diff::Addition {
                         line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                         line_no: *line_no,
                         highlight: Some(lines[*line_no as usize - 1].clone()),
                     })
                 } else {
                     super::diff::Modification::Addition(super::diff::Addition {
                         line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                         line_no: *line_no,
                         highlight: None,
                     })
                 }
             }
             surf::diff::Modification::Context {
                 line,
                 line_no_new,
                 line_no_old,
             } => {
                 // Nb. we can check in the old or the new blob, we choose the new.
                 if let Some(lines) = &blobs.new.as_ref() {
                     super::diff::Modification::Context {
                         line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                         line_no_new: *line_no_new,
                         line_no_old: *line_no_old,
                         highlight: Some(lines[*line_no_new as usize - 1].clone()),
                     }
                 } else {
                     super::diff::Modification::Context {
                         line: String::from_utf8_lossy(line.as_bytes()).to_string(),
                         line_no_new: *line_no_new,
                         line_no_old: *line_no_old,
                         highlight: None,
                     }
                 }
             }
         }
     }
 }

 use radicle::git;
 use radicle::identity;
 use radicle::issue::IssueId;
 use radicle::patch::{Patch, PatchId, ReviewId, RevisionId, Status};
 use serde::de::DeserializeOwned;
 use crate::error::Error;
 use super::traits::cobs::RepoActivity;
 use super::traits::issue::RepoIssues;
 use super::traits::patch::RepoPatches;
 use super::traits::patch::RepoPatchesLister;
 use super::traits::repo::RepoStorage;
 use super::traits::thread::RepoThreads;
 use super::traits::RepoService;
 #[derive(Debug, Clone)]
 pub struct Service<R, S>
 where
     R: RepoActivity,
     R: RepoPatches,
     R: RepoIssues,
     R: RepoThreads,
     R: RepoStorage,
     S: RepoPatchesLister,
 {
     cobs: R,
     patches: R,
     issues: R,
     threads: R,
     storage: R,
     patches_lister: S,
 }
 impl<R, S> Service<R, S>
 where
     R: RepoActivity + Clone,
     R: RepoPatches + Clone,
     R: RepoIssues + Clone,
     R: RepoThreads + Clone,
     R: RepoStorage + Clone,
     S: RepoPatchesLister,
 {
     pub fn new(radicle: R, sqlite: S) -> Self {
         Self {
             cobs: radicle.clone(),
             patches: radicle.clone(),
             issues: radicle.clone(),
             storage: radicle.clone(),
             threads: radicle,
             patches_lister: sqlite,
         }
     }
 }
 impl<R, S> RepoService for Service<R, S>
 where
     R: RepoActivity + Clone,
     R: RepoPatches + Clone,
     R: RepoIssues + Clone,
     R: RepoThreads + Clone,
     R: RepoStorage + Clone,
     S: RepoPatchesLister,
 {
     fn create_repo(
         &self,
         name: String,
         description: String,
         default_branch: git::RefString,
         signature: Option<radicle::git::raw::Signature>,
     ) -> Result<(), Error> {
         self.storage
             .create_repo(name, description, default_branch, signature)
     }
     fn get_embed(
         &self,
         rid: identity::RepoId,
         name: Option<String>,
         oid: git::Oid,
     ) -> Result<super::models::cobs::EmbedWithMimeType, Error> {
         self.threads.get_embed(rid, name, oid)
     }
     fn create_issue(
         &self,
         rid: identity::RepoId,
         new: super::models::cobs::issue::NewIssue,
         opts: super::models::cobs::CobOptions,
     ) -> Result<super::models::cobs::issue::Issue, Error> {
         self.issues.create_issue(rid, new, opts)
     }
     fn edit_issue(
         &self,
         rid: identity::RepoId,
         cob_id: IssueId,
         action: super::models::cobs::issue::Action,
         opts: super::models::cobs::CobOptions,
     ) -> Result<super::models::cobs::issue::Issue, Error> {
         self.issues.edit_issue(rid, cob_id, action, opts)
     }
     fn issue_by_id(
         &self,
         rid: identity::RepoId,
         id: IssueId,
     ) -> Result<Option<super::models::cobs::issue::Issue>, Error> {
         self.issues.issue_by_id(rid, id)
     }
     fn list_issues(
         &self,
         rid: identity::RepoId,
         status: Option<super::models::cobs::query::IssueStatus>,
     ) -> Result<Vec<super::models::cobs::issue::Issue>, Error> {
         self.issues.list_issues(rid, status)
     }
     fn edit_patch(
         &self,
         rid: identity::RepoId,
         cob_id: PatchId,
         action: super::models::cobs::patch::Action,
         opts: super::models::cobs::CobOptions,
     ) -> Result<super::models::cobs::patch::Patch, Error> {
         self.patches.edit_patch(rid, cob_id, action, opts)
     }
     fn review_by_id(
         &self,
         rid: identity::RepoId,
         id: PatchId,
         revision_id: RevisionId,
         review_id: ReviewId,
     ) -> Result<Option<super::models::cobs::patch::Review>, Error> {
         self.patches.review_by_id(rid, id, revision_id, review_id)
     }
     fn get_patch_by_id(
         &self,
         rid: identity::RepoId,
         id: PatchId,
     ) -> Result<Option<super::models::cobs::patch::Patch>, Error> {
         self.patches.get_patch_by_id(rid, id)
     }
     fn revisions_by_patch(
         &self,
         rid: identity::RepoId,
         id: PatchId,
     ) -> Result<Option<Vec<super::models::cobs::patch::Revision>>, Error> {
         self.patches.revisions_by_patch(rid, id)
     }
     fn revision_by_patch_and_id(
         &self,
         rid: identity::RepoId,
         id: PatchId,
         revision_id: RevisionId,
     ) -> Result<Option<super::models::cobs::patch::Revision>, Error> {
         self.patches.revision_by_patch_and_id(rid, id, revision_id)
     }
     fn revision_by_id(
         &self,
         rid: identity::RepoId,
         id: PatchId,
         revision_id: RevisionId,
     ) -> Result<Option<super::models::cobs::patch::Revision>, Error> {
         self.patches.revision_by_id(rid, id, revision_id)
     }
     fn list_patches(
         &self,
         rid: identity::RepoId,
     ) -> Result<impl Iterator<Item = (PatchId, Patch)>, super::models::cobs::patch::ListPatchesError>
     {
         self.patches_lister.list(rid)
     }
     fn list_patches_by_status(
         &self,
         rid: identity::RepoId,
         status: Status,
     ) -> Result<impl Iterator<Item = (PatchId, Patch)>, super::models::cobs::patch::ListPatchesError>
     {
         self.patches_lister.list_by_status(rid, status)
     }
     fn list_repos(
         &self,
         show: super::models::repo::Show,
     ) -> Result<Vec<super::models::repo::RepoInfo>, Error> {
         self.storage.list_repos(show)
     }
     fn repo_count(&self) -> Result<super::models::repo::RepoCount, Error> {
         self.storage.repo_count()
     }
     fn repo_by_id(&self, rid: identity::RepoId) -> Result<super::models::repo::RepoInfo, Error> {
         self.storage.repo_by_id(rid)
     }
     fn diff_stats(
         &self,
         rid: identity::RepoId,
         base: git::Oid,
         head: git::Oid,
     ) -> Result<super::models::diff::Stats, Error> {
         self.storage.diff_stats(rid, base, head)
     }
     fn get_diff(
         &self,
         rid: identity::RepoId,
         options: super::models::diff::DiffOptions,
     ) -> Result<super::models::diff::Diff, Error> {
         self.storage.get_diff(rid, options)
     }
     fn list_commits(
         &self,
         rid: identity::RepoId,
         base: git::Oid,
         head: git::Oid,
     ) -> Result<Vec<super::models::repo::Commit>, Error> {
         self.storage.list_commits(rid, base, head)
     }
     fn save_embed_to_disk(
         &self,
         rid: identity::RepoId,
         oid: git::Oid,
         path: std::path::PathBuf,
     ) -> Result<(), Error> {
         self.threads.save_embed_to_disk(rid, oid, path)
     }
     fn save_embed_by_path(
         &self,
         rid: identity::RepoId,
         path: std::path::PathBuf,
     ) -> Result<git::Oid, Error> {
         self.threads.save_embed_by_path(rid, path)
     }
     fn save_embed_by_bytes(
         &self,
         rid: identity::RepoId,
         name: String,
         bytes: Vec<u8>,
     ) -> Result<git::Oid, Error> {
         self.threads.save_embed_by_bytes(rid, name, bytes)
     }
     fn create_issue_comment(
         &self,
         rid: identity::RepoId,
         new: super::models::cobs::thread::NewIssueComment,
         opts: super::models::cobs::CobOptions,
     ) -> Result<super::models::cobs::thread::Comment<super::models::cobs::Never>, Error> {
         self.threads.create_issue_comment(rid, new, opts)
     }
     fn create_patch_comment(
         &self,
         rid: identity::RepoId,
         new: super::models::cobs::thread::NewPatchComment,
         opts: super::models::cobs::CobOptions,
     ) -> Result<
         super::models::cobs::thread::Comment<super::models::cobs::thread::CodeLocation>,
         Error,
     > {
         self.threads.create_patch_comment(rid, new, opts)
     }
     fn comment_threads_by_issue_id(
         &self,
         rid: identity::RepoId,
         id: IssueId,
     ) -> Result<Option<Vec<super::models::cobs::thread::Thread>>, Error> {
         self.storage.comment_threads_by_issue_id(rid, id)
     }
     fn activity_by_id<A: DeserializeOwned, B: super::models::cobs::FromRadicleAction<A>>(
         &self,
         rid: identity::RepoId,
         type_name: &radicle::cob::TypeName,
         id: git::Oid,
     ) -> Result<Vec<super::models::cobs::Operation<B>>, Error> {
         self.cobs.activity_by_id(rid, type_name, id)
     }
 }