let remote = options.remote.unwrap_or(*profile.id());

    let doc = storage

        .repository(id)?

        .context("project could not be found in local storage")?;

    let payload = doc.project()?;

    let path = PathBuf::from(payload.name());

use thiserror::Error;

use radicle::git::raw;

use radicle::identity::doc::{DocError, Id};

use radicle::node;

use radicle::node::{FetchResult, Handle as _, Node};

use radicle::prelude::*;

use radicle::rad;

use radicle::storage;

use crate::commands::rad_checkout as checkout;

use crate::project;

    #[error("payload: {0}")]

    Payload(#[from] doc::PayloadError),

    #[error("project error: {0}")]

    #[error("no seeds found for {0}")]

    NotFound(Id),

}

        }

    }

    let proj = doc.project()?;

    let path = Path::new(proj.name());

    let signer = term::signer(&profile)?;

    let repository = profile.storage.repository(id)?;

    let _project = repository

        .context(format!("couldn't load project {id} from local state"))?;

    let repository = profile.storage.repository(id)?;

    let mut patches = Patches::open(*profile.id(), &repository)?;

    let signer = term::signer(&profile)?;

    let repository = profile.storage.repository(id)?;

    let _project = repository

        .context(format!("couldn't load project {id} from local state"))?;

    let mut patches = Patches::open(*profile.id(), &repository)?;

//! represents the type of resource the collaborative objects are

//! relating to, for example a software project.

//!

//! ## History Traversal

//!

//! The [`History`] of a [`CollaborativeObject`] -- accessed via

pub mod change;

pub use change::Change;

pub mod history;

pub use history::{Contents, Entry, History};

use git_ext::Oid;

use crate::change::store::Manifest;

pub mod error;

///

/// The `args` are the metadata for this [`CollaborativeObject`]. See

/// [`Create`] for further information.

    storage: &S,

    signer: &G,

    identifier: &S::Identifier,

    args: Create,

) -> Result<CollaborativeObject, error::Create>

where

    S: Store,

    G: crypto::Signer,

{

    let Create { ref typename, .. } = &args;

    let init_change = storage

        .map_err(error::Create::from)?;

    let object_id = init_change.id().into();

    let history = History::new_from_root(

        *init_change.id(),

        init_change.signature.key,

        init_change.contents,

        init_change.timestamp,

    );

// This file is part of radicle-link, distributed under the GPLv3 with Radicle

// Linking Exception. For full terms see the included LICENSE file.

use nonempty::NonEmpty;

use super::error;

///

/// The `args` are the metadata for this [`CollaborativeObject`]

/// udpate. See [`Update`] for further information.

    storage: &S,

    signer: &G,

    identifier: &S::Identifier,

    args: Update,

) -> Result<CollaborativeObject, error::Update>

where

    S: Store,

    G: crypto::Signer,

{

    let Update {

        ref typename,

        .ok_or(error::Update::NoSuchObject)?;

    let change = storage.store(

        signer,

        change::Template {

            tips: object.tips().iter().cloned().collect(),

use git_ext::Oid;

use serde::{Deserialize, Serialize};

use crate::test::storage::{self, Storage};

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Person {

        &self.payload.name

    }

}

use git_ext::Oid;

use serde::{Deserialize, Serialize};

use crate::test;

use crate::test::storage::{self, Storage};

        &self.payload.name

    }

}

    let cob = create(

        &storage,

        &signer,

        &proj.identifier(),

        Create {

            history_type: "test".to_string(),

    let issue_1 = create(

        &storage,

        &signer,

        &proj.identifier(),

        Create {

            history_type: "test".to_string(),

    let issue_2 = create(

        &storage,

        &signer,

        &proj.identifier(),

        Create {

            history_type: "test".to_string(),

    let cob = create(

        &storage,

        &signer,

        &proj.identifier(),

        Create {

            history_type: "test".to_string(),

    let updated = update(

        &storage,

        &signer,

        &proj.identifier(),

        Update {

            changes: nonempty!(b"issue 1".to_vec()),

    let cob = create(

        &storage,

        &terry_signer,

        &terry_proj.identifier(),

        Create {

            contents: nonempty!(b"issue 1".to_vec()),

    let updated = update(

        &storage,

        &neil_signer,

        &neil_proj.identifier(),

        Update {

            changes: nonempty!(b"issue 2".to_vec()),

    #[error(transparent)]

    CobStore(#[from] radicle::cob::store::Error),

    #[error(transparent)]

    /// Project doc error.

    #[error(transparent)]

use crate::clock::Timestamp;

use crate::crypto;

use crate::crypto::{Signer, Verified};

use crate::identity::{Doc, Id};

use crate::node;

use crate::node::{Address, Features, FetchResult, Seed, Seeds};

    fn sessions(&self) -> &Sessions;

    /// Get the current inventory.

    fn inventory(&self) -> Result<Inventory, storage::Error>;

    /// Get the clock.

    fn clock(&self) -> &LocalTime;

    /// Get the clock mutably.

        self.storage.inventory()

    }

        self.storage.get(&self.node_id(), proj)

    }

    #[error(transparent)]

    Routing(#[from] routing::Error),

    #[error(transparent)]

}

/// Information on a peer, that we may or may not be connected to.

use netservices::{NetSession, SplitIo};

use radicle::crypto::Signer;

use radicle::storage::{Namespaces, ReadRepository, RefUpdate, WriteRepository, WriteStorage};

use radicle::{git, Storage};

use reactor::poller::popol;

    #[error(transparent)]

    Io(#[from] io::Error),

    #[error(transparent)]

}

impl FetchError {

pub use cob::{create, get, list, remove, update};

pub use cob::{

};

pub use common::*;

pub use op::{ActorId, Op, OpId};

use rand::{RngCore as _, SeedableRng};

use serde::{Deserialize, Serialize};

use crate::cob::common::Author;

use crate::cob::op::{Nonce, Op, OpId, Ops};

use crate::cob::CollaborativeObject;

use crate::cob::{ActorId, Create, History, ObjectId, TypeName, Update};

use crate::crypto::PublicKey;

use crate::git;

use crate::prelude::*;

use crate::storage::git as storage;

/// History type for standard radicle COBs.

pub const HISTORY_TYPE: &str = "radicle";

/// Storage for collaborative objects of a specific type `T` in a single repository.

pub struct Store<'a, T> {

    whoami: PublicKey,

    raw: &'a storage::Repository,

    witness: PhantomData<T>,

    rng: StdRng,

    /// Open a new generic store.

    pub fn open(whoami: PublicKey, store: &'a storage::Repository) -> Result<Self, Error> {

        let rng = rng::std();

        Ok(Self {

            whoami,

            raw: store,

            witness: PhantomData,

        cob::update(

            self.raw,

            signer,

            signer.public_key(),

            Update {

                object_id,

        let cob = cob::create(

            self.raw,

            signer,

            signer.public_key(),

            Create {

                history_type: HISTORY_TYPE.to_owned(),

use crate::crypto;

use crate::crypto::{Signature, Verified};

use crate::git;

pub use crypto::PublicKey;

pub use did::Did;

pub use project::Project;

/// Untrusted, well-formed input.

    Git(#[from] git2::Error),

    #[error("git: {0}")]

    GitExt(#[from] git::Error),

    #[error("root hash `{0}` does not match project")]

    MismatchedRoot(Oid),

    #[error("the document root is missing")]

    MissingRoot,

    #[error("root commit is missing one or more delegate signatures")]

    MissingRootSignatures,

    #[error("commit signature for {0} is invalid: {1}")]

    InvalidSignature(PublicKey, crypto::Error),

    #[error("threshold not reached: {0} signatures for a threshold of {1}")]

    ThresholdNotReached(usize, usize),

    #[error("identity document error: {0}")]

    Doc(#[from] doc::DocError),

}

#[derive(Clone, Debug, PartialEq, Eq)]

    pub signatures: HashMap<PublicKey, Signature>,

}

impl Identity<Oid> {

    pub fn verified(self, id: doc::Id) -> Result<Identity<doc::Id>, IdentityError> {

        // The root hash must be equal to the id.

        repo: &R,

    ) -> Result<Identity<Oid>, IdentityError> {

        let head = Doc::<Untrusted>::head(remote, repo)?;

        let mut history = repo.revwalk(head)?.collect::<Vec<_>>();

        // Retrieve root document.

use crate::crypto::{Signer, Verified};

use crate::git;

use crate::identity::doc::{DocError, Id};

use crate::identity::project::Project;

use crate::storage::git::transport;

use crate::storage::refs::SignedRefs;

use crate::storage::WriteRepository;

use crate::storage::{BranchName, ReadRepository as _, RemoteId};

    #[error("doc: {0}")]

    Doc(#[from] DocError),

    #[error("project: {0}")]

    #[error("project payload: {0}")]

    ProjectPayload(String),

    #[error("git: {0}")]

    #[error("project `{0}` was not found in storage")]

    NotFound(Id),

    #[error("project identity error: {0}")]

    #[error("project identity document error: {0}")]

    Doc(#[from] DocError),

    #[error("git: invalid reference")]

    #[error("project `{0}` was not found in storage")]

    NotFound(Id),

    #[error("project error: {0}")]

}

/// Checkout a project from storage as a working copy.

use thiserror::Error;

use crypto::{PublicKey, Signer, Unverified, Verified};

pub use radicle_git_ext::Oid;

use crate::collections::HashMap;

use crate::git::{Qualified, RefError, RefString};

use crate::identity;

use crate::identity::doc::DocError;

use crate::storage::refs::Refs;

use self::refs::SignedRefs;

    Storage(#[from] Error),

    // TODO: This should wrap a more specific error.

    #[error("repository head: {0}")]

}

pub type RemoteId = PublicKey;

        &self,

        remote: &RemoteId,

        rid: Id,

    /// Check whether storage contains a repository.

    /// Get the inventory of repositories hosted under this storage.

    fn inventory(&self) -> Result<Inventory, Error>;

    /// Open or create a read-only repository.

    /// head using [`ReadRepository::canonical_head`].

    ///

    /// Returns the [`Oid`] as well as the qualified reference name.

    /// Compute the canonical head of this repository.

    ///

    /// Ignores any existing `HEAD` reference.

    ///

    /// Returns the [`Oid`] as well as the qualified reference name.

    /// Get the `reference` for the given `remote`.

    ///

    fn remotes(&self) -> Result<Remotes<Verified>, refs::Error>;

    /// Get the repository's identity document.

}

/// Allows read-write access to a repository.

pub trait WriteRepository: ReadRepository {

    /// Set the repository head to the canonical branch.

    /// This computes the head based on the delegate set.

    /// Sign the repository's refs under the `refs/rad/sigrefs` branch.

    fn sign_refs<G: Signer>(&self, signer: &G) -> Result<SignedRefs<Verified>, Error>;

    /// Get the underlying git repository.

        self.deref().path_of(rid)

    }

        self.deref().contains(rid)

    }

        &self,

        remote: &RemoteId,

        proj: Id,

        self.deref().get(remote, proj)

    }

use crate::git;

use crate::identity;

use crate::identity::{Identity, IdentityError, Project};

use crate::storage::refs;

use crate::storage::refs::{Refs, SignedRefs};

    }

}

#[derive(Debug, Clone)]

pub struct Storage {

    path: PathBuf,

        paths::repository(&self, rid)

    }

        if paths::repository(&self, rid).exists() {

            let _ = self.repository(*rid)?.head()?;

            return Ok(true);

        Ok(false)

    }

        let repo = match self.repository(proj) {

            Ok(doc) => doc,

            Err(e) if e.is_not_found() => return Ok(None),

            Err(e) => return Err(e.into()),

        };

            Ok(doc) => Ok(Some(doc)),

            Err(e) if e.is_not_found() => Ok(None),

            Err(e) => Err(e),

        Ok(refs)

    }

        Identity::load(remote, self)

    }

        let proj = doc.project()?;

        Ok(proj)

    }

        let (doc, _) = identity::Doc::load(remote, self)?;

        let verified = doc.verified()?;

    }

    /// Return the canonical identity [`git::Oid`] and document.

        let mut heads = Vec::new();

        for remote in self.remote_ids()? {

            let remote = remote?;

            let oid = Doc::<Unverified>::head(&remote, self)?;

            heads.push(oid.into());

        }

        // Keep track of the longest identity branch.

        for head in &heads {

            let base = self.raw().merge_base(*head, longest)?;

                //            o (base)

                //            |

                //

            }

        }

    }

    pub fn remote_ids(

                return Err(VerifyError::MissingRef(remote, name));

            }

            // Verify identity history of remote.

        }

        Ok(())

        Ok(Remotes::from_iter(remotes))

    }

        Repository::identity_doc(self)

    }

        // If `HEAD` is already set locally, just return that.

        if let Ok(head) = self.backend.head() {

            if let Ok((name, oid)) = git::refs::qualified_from(&head) {

        self.canonical_head()

    }

        // TODO: In the `fork` function for example, we call Repository::project_identity again,

        // This should only be necessary once.

        let (_, doc) = self.identity_doc()?;

}

impl WriteRepository for Repository {

        let head_ref = refname!("HEAD");

        let (branch_ref, head) = self.canonical_head()?;

use crate::crypto::{Signer, Verified};

use crate::identity::doc::{Doc, Id};

pub use crate::storage::*;

        self.path().join(rid.canonical())

    }

        Ok(self.inventory.contains_key(rid))

    }

        Ok(self.inventory.get(&proj).cloned())

    }

        Ok(true)

    }

        todo!()

    }

        todo!()

    }

    fn identity_doc(

        &self,

        todo!()

    }

}

        todo!()

    }

        todo!()

    }