let id = options.id;

    let storage = &profile.storage;

    let remote = options.remote.unwrap_or(profile.did());

        .repository(id)?

        .identity_doc()

    let payload = doc.project()?;

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

    spinner.finish();

    let remotes = doc

        .into_iter()

        .map(|did| *did)

        .filter(|id| id != profile.id())

        &profile.storage,

    )?;

    let delegates = doc

        .iter()

        .map(|d| **d)

        .filter(|id| id != profile.id())

    (

        raw::Repository,

        storage::git::Repository,

        Project,

    ),

    CloneError,

use anyhow::{anyhow, Context};

use radicle::cob::identity::{self, IdentityMut, Revision, RevisionId};

use radicle::storage::refs;

use radicle::storage::{ReadRepository, ReadStorage as _, WriteRepository};

use radicle::{cob, Profile};

use radicle_surf::diff::Diff;

use radicle_term::Element;

use serde_json as json;

            payload,

        } => {

            let proposal = {

                proposal.threshold = threshold.unwrap_or(proposal.threshold);

                if !allow.is_disjoint(&disallow) {

                        proposal.visibility = Visibility::Public;

                    }

                }

                if let Some(errs) = verify_delegates(&proposal, &repo)? {

                    term::error(format!("failed to verify delegates for {rid}"));

                    term::error(format!(

                }

                proposal

            };

            if proposal == current.doc {

                if !options.quiet {

                    term::print(term::format::italic(

    Ok(revision)

}

    let mut attrs = term::Table::<2, term::Label>::new(Default::default());

    attrs.push([

    let accepted = revision.accepted().collect::<Vec<_>>();

    let rejected = revision.rejected().collect::<Vec<_>>();

    let unknown = previous

        .iter()

        .filter(|id| !accepted.contains(id) && !rejected.contains(id))

        .collect::<Vec<_>>();

fn update<R: WriteRepository + cob::Store, G: Signer>(

    title: Option<String>,

    description: Option<String>,

    current: &mut IdentityMut<R>,

    signer: &G,

) -> anyhow::Result<Revision> {

    repo: &radicle::storage::git::Repository,

) -> anyhow::Result<()> {

    let previous = if let Some(previous) = previous {

        let previous = serde_json::to_string_pretty(&previous.doc)?;

        Some(previous)

    } else {

        None

    };

    let current = serde_json::to_string_pretty(&current.doc)?;

    let tmp = tempfile::tempdir()?;

    }

}

    repo: &S,

) -> anyhow::Result<Option<Vec<VerificationError>>>

where

use anyhow::{anyhow, bail, Context as _};

use serde_json as json;

use radicle::explorer::ExplorerUrl;

use radicle::git::RefString;

use radicle::identity::project::ProjectName;

use radicle::node::events::UploadPack;

use radicle::node::policy::Scope;

use radicle::node::{Event, Handle, NodeId, DEFAULT_SUBSCRIBE_TIMEOUT};

use radicle::storage::ReadStorage as _;

use radicle::{profile, Node};

            if options.seed {

                profile.seed(rid, options.scope, &mut node)?;

                    profile.add_inventory(rid, &mut node)?;

                }

            }

pub fn announce(

    rid: RepoId,

    node: &mut Node,

    config: &profile::Config,

) -> anyhow::Result<()> {

        match sync(rid, node, config) {

            Ok(SyncResult::Synced {

                result: Some(url), ..

    } else {

        term::info!(

            "You have created a {} repository.",

        );

        term::info!(

            "This repository will only be visible to you, \

        }

        Target::Payload => {

            let (_, doc) = repo(rid, storage)?;

        }

        Target::Identity => {

            let (_, doc) = repo(rid, storage)?;

        Target::Delegates => {

            let (_, doc) = repo(rid, storage)?;

            let aliases = profile.aliases();

                if let Some(alias) = aliases.alias(did) {

                    println!(

                        "{} {}",

        }

        Target::Visibility => {

            let (_, doc) = repo(rid, storage)?;

        }

        Target::History => {

            let (repo, _) = repo(rid, storage)?;

        ..

    } in repos

    {

            continue;

        }

            continue;

        }

        if refs.is_none() && !options.all && !options.seeded {

            term::format::bold(proj.name().to_owned()),

            term::format::tertiary(rid.urn()),

            if seeded {

            } else {

                term::format::dim("local").into()

            },

    let repo = profile.storage.repository_mut(rid)?;

    let mut identity = Identity::load_mut(&repo)?;

        return Err(Error::WithHint {

            err: anyhow!("repository is already public"),

            hint: "to announce the repository to the network, run `rad sync --inventory`",

        }

        .into());

    }

        return Err(anyhow!("only the repository delegate can publish it"));

    }

        return Err(Error::WithHint {

            err: anyhow!(

                "only repositories with a single delegate can be published with this command"

    let signer = profile.signer()?;

    // Update identity document.

    identity.update("Publish repository", "", &doc, &signer)?;

    repo.sign_refs(&signer)?;

    term::success!(

        "Repository is now {}",

    );

    if !node.is_running() {

    let outcome = if updated { "updated" } else { "exists" };

    if let Ok(repo) = profile.storage.repository(rid) {

            profile.add_inventory(rid, node)?;

            term::success!("Inventory updated with {}", term::format::tertiary(rid));

        }

    let rid = repo.id();

    let doc = repo.identity_doc()?;

    let mut settings = settings.with_profile(profile);

        // All seeds.

        let all = node.seeds(rid)?;

        if all.is_empty() {

    } else {

        node.sessions()?

            .into_iter()

            .map(|s| s.nid)

            .collect()

    };

use std::sync::Arc;

use bstr::BString;

use radicle::git::Oid;

use radicle::storage::git::Repository;

use radicle::storage::ReadRepository;

        self.interrupt.store(true, atomic::Ordering::Relaxed);

    }

        Ok(self.repo.identity_doc_at(head)?.doc)

    }

                remote: self.remote,

                err: Box::new(err),

            })?;

            Ok(Updates::build(

                refs.iter()

                    .filter_map(|r| r.as_special_ref_update(is_delegate)),

use gix_protocol::handshake;

use radicle::crypto::PublicKey;

use radicle::git::{Oid, Qualified};

use radicle::prelude::Verified;

use radicle::storage;

            .canonical()?

            .ok_or(error::Protocol::MissingRadId)?;

        // TODO: not sure we should allow to block *any* peer from the

        // delegate set. We could end up ignoring delegates.

        let delegates = anchor

            .iter()

            .filter(|id| !handle.is_blocked(id))

            .map(|did| PublicKey::from(*did))

        // The local peer does not need to count towards the threshold

        // since they must be valid already.

        let threshold = if is_delegate {

        } else {

        };

        let signed_refs = self.run_special_refs(

            handle,

        self.state.canonical_rad_id().copied()

    }

        self.handle.verified(head)

    }

        let tip = self.refname_to_id(refs::REFS_RAD_ID.clone())?;

        let cached_tip = self.canonical_rad_id();

/// N.b. if the repository does not have the project payload or a

/// deserialization error occurs, then this will return `None`.

fn validate_project_default_branch(

    sigrefs: &SignedRefs<Verified>,

) -> Option<Validation> {

    let proj = anchor.project().ok()?;

use log::*;

use nonempty::NonEmpty;

use radicle::node;

use radicle::node::address;

use radicle::node::address::Store as _;

use radicle::storage::RepositoryError;

use radicle_fetch::policy::SeedingPolicy;

use crate::node::routing;

use crate::node::routing::InsertResult;

use crate::node::{

                continue;

            }

            // Add public repositories to inventory.

                inventory.insert(rid);

            } else {

                private.insert(rid);

                // Announce our new inventory if this fetch was a full clone.

                // Only update and announce inventory for public repositories.

                    debug!(target: "service", "Updating and announcing inventory for cloned repository {rid}..");

                    if let Err(e) = self.add_inventory(rid) {

    }

    /// Announce our own refs for the given repo.

        let (refs, timestamp) = self.announce_refs(rid, doc, [self.node_id()])?;

        // Update refs database with our signed refs branches.

    fn announce_refs(

        &mut self,

        rid: RepoId,

        remotes: impl IntoIterator<Item = NodeId>,

    ) -> Result<(Vec<RefsAt>, Timestamp), Error> {

        let (ann, refs) = self.refs_announcement_for(rid, remotes)?;

            ann,

            peers.filter(|p| {

                // Only announce to peers who are allowed to view this repo.

            }),

            self.db.gossip_mut(),

        );

                        .get(rid)

                        .ok()

                        .flatten()

                        .unwrap_or(false)

                } else {

                    // Announcement doesn't concern a specific repository, let it through.

    /// Get event emitter.

    fn emitter(&self) -> &Emitter<Event>;

    /// Get a repository from storage.

    /// Get the clock.

    fn clock(&self) -> &LocalTime;

    /// Get the clock mutably.

        &self.emitter

    }

        self.storage.get(rid)

    }

#[derive(Debug)]

pub struct Lookup {

    /// Whether the project was found locally or not.

    /// A list of remote peers on which the project is known to exist.

    pub remote: Vec<NodeId>,

}

    // Pretend Alice cloned Bob's repos.

    let repos = gen::<[MockRepository; 3]>(1);

    for (i, mut repo) in repos.into_iter().enumerate() {

        alice.storage_mut().repos.insert(bob_inv[i], repo);

    }

    assert_matches!(

    alice.receive(eve.id(), Message::Subscribe(Subscribe::all()));

    // The first repo is not visible to Eve.

    alice.storage_mut().repos.insert(bob_inv[0], repo1);

    // The second repo is visible to Eve.

    };

    alice.storage_mut().repos.insert(bob_inv[1], repo2);

    alice.elapse(service::GOSSIP_INTERVAL);

        }

        let repo = self.storage.repository(rid)?;

        let doc = repo.identity_doc()?;

            Err(UploadError::Unauthorized(remote, rid))

        } else {

            Ok(())

                        if dst == canonical_ref && delegates.contains(&me) && delegates.len() > 1 {

                            let head = working.find_reference(src.as_str())?;

                            let head = head.peel_to_commit()?.id();

                            let converges = canonical::converges(

                                canonical

                                    .tips()

                                canonical.modify_vote(me, head.into());

                            }

                                Ok(canonical_oid) => {

                                    // Canonical head is an ancestor of head.

                                    let is_ff = head == *canonical_oid

use crypto::{PublicKey, Signature};

use once_cell::sync::Lazy;

use radicle_cob::{Embed, ObjectId, TypeName};

use radicle_git_ext as git_ext;

use radicle_git_ext::Oid;

use serde::{Deserialize, Serialize};

use thiserror::Error;

use crate::{

    cob,

    cob::{

        ActorId, Timestamp, Uri,

    },

    identity::{

        Did,

    },

    storage::{ReadRepository, RepositoryError, WriteRepository},

            root,

            current: root,

            heads: revision

                .iter()

                .copied()

                .map(|did| (did, root))

    }

    pub fn initialize<'a, R: WriteRepository + cob::Store, G: Signer>(

        store: &'a R,

        signer: &G,

    ) -> Result<IdentityMut<'a, R>, cob::store::Error> {

    }

    /// The current document.

        &self.current().doc

    }

                "the first operation must contain only one action",

            ));

        }

        if root.blob != blob {

            return Err(ApplyError::Init("invalid object id specified in revision"));

        }

        }

        assert_eq!(root.commit, op.id);

        if founder.as_key() != &op.author {

            return Err(ApplyError::Init("delegate does not match committer"));

        }

    ) -> Result<(), ApplyError> {

        let current = self.current().clone();

            return Err(ApplyError::UnexpectedState);

        }

        match action {

    /// Author of this proposed revision.

    pub author: Author,

    /// New [`Doc`] that will replace `previous`' document.

    /// Physical timestamp of this proposal revision.

    pub timestamp: Timestamp,

    /// Parent revision.

}

impl std::ops::Deref for Revision {

    fn deref(&self) -> &Self::Target {

        &self.doc

        description: String,

        author: Author,

        blob: Oid,

        state: State,

        signature: Signature,

        parent: Option<RevisionId>,

        // Mark as rejected if it's impossible for this revision to be accepted

        // with the current delegate set. Note that if the delegate set changes,

        // this proposal will be marked as `stale` anyway.

            self.state = State::Rejected;

        }

        Ok(())

        &mut self,

        title: impl ToString,

        description: impl ToString,

        parent: Option<RevisionId>,

        repo: &R,

        signer: &G,

        &mut self,

        title: impl ToString,

        description: impl ToString,

        signer: &G,

    ) -> Result<RevisionId, Error> {

        let parent = self.current;

        let bob = MockSigner::default();

        let signer = &node.signer;

        let mut identity = Identity::load_mut(&*repo).unwrap();

        let title = "Identity update";

        let description = "";

        let r0 = identity.current;

        assert!(identity.current().is_accepted());

        // Using an identical document to the current one fails.

        identity

            .unwrap_err();

        assert_eq!(identity.current, r0);

        // Change threshold to `2`, even though there's only one delegate. This should

        // fail as it makes the master branch immutable.

        doc.threshold = 2;

        // Let's add another delegate.

        // The update should go through now.

        assert!(identity.revision(&r1).unwrap().is_accepted());

        assert_eq!(identity.current, r1);

        // With two delegates now, we need two signatures for any update to go through.

        // So this next update shouldn't be accepted as canonical until the second delegate

        // signs it.

        doc.visibility = Visibility::private([]);

        // R1 is still the head.

        assert_eq!(identity.current, r1);

        assert_eq!(identity.revision(&r2).unwrap().state, State::Active);

        assert_eq!(repo.canonical_identity_head().unwrap(), r1);

        // Now let's add a signature on R2 from Bob.

        identity.accept(&r2, &bob).unwrap();

        assert_eq!(identity.revision(&r2).unwrap().state, State::Accepted);

        assert_eq!(repo.canonical_identity_head().unwrap(), r2);

        assert_eq!(

        );

    }

        let eve = MockSigner::default();

        let signer = &node.signer;

        let mut identity = Identity::load_mut(&*repo).unwrap();

        let title = "Identity update";

        let description = "";

        // Let's add another delegate.

        assert_eq!(identity.current, r1);

        doc.visibility = Visibility::private([]);

        let r2 = identity

            .unwrap();

        // 1/2 rejected means that we can never reach the required 2/2 votes.

        assert_eq!(r2.state, State::Rejected);

        // Now let's add another delegate.

        let r3 = identity

            .unwrap();

        let _ = identity.accept(&r3, &bob).unwrap();

        assert_eq!(identity.current, r3);

        doc.visibility = Visibility::Public;

        let r3 = identity

            .unwrap();

        // 1/3 rejected means that we can still reach the 2/3 required votes.

        let bob = &network.bob;

        let mut alice_identity = Identity::load_mut(&*alice.repo).unwrap();

        let a1 = alice_identity

            .unwrap();

        bob.repo.fetch(alice);

        let mut bob_identity = Identity::load_mut(&*bob.repo).unwrap();

        let bob_doc = bob_identity.doc().clone();

        // Alice changes the document without making Bob aware.

        alice_doc.visibility = Visibility::private([]);

        let a2 = alice_identity

            .unwrap();

        // Bob makes the same change without knowing Alice already did.

        let b1 = bob_identity

            .unwrap();

        // Bob gets Alice's data.

        let eve = &network.eve;

        let mut alice_identity = Identity::load_mut(&*alice.repo).unwrap();

        let a0 = alice_identity.root;

        let a1 = alice_identity

            .unwrap();

        alice_doc.visibility = Visibility::private([eve.signer.public_key().into()]);

        let a2 = alice_identity

            .unwrap();

        bob.repo.fetch(alice);

        let eve = &network.eve;

        let mut alice_identity = Identity::load_mut(&*alice.repo).unwrap();

        let a0 = alice_identity.root;

        let a1 = alice_identity // Change description to change traversal order.

            .unwrap();

        let a2 = alice_identity

            .unwrap();

        bob.repo.fetch(eve);

        assert_eq!(bob_identity.current, a2);

        let mut eve_identity = Identity::load_mut(&*eve.repo).unwrap();

        eve_doc.visibility = Visibility::private([eve.signer.public_key().into()]);

        let e1 = eve_identity

            .unwrap();

        // Eve's revision is active.

        assert!(eve_identity.revision(&e1).unwrap().is_active());

        // her revision is no longer valid.

        assert_eq!(eve_identity.timeline, vec![a0, a1, a2, b1, e1]);

        assert_eq!(eve_identity.revision(&e1), None);

    }

    #[test]

        let eve = &network.eve;

        let mut alice_identity = Identity::load_mut(&*alice.repo).unwrap();

        let a0 = alice_identity.root;

        let a1 = alice_identity

            .unwrap();

        alice_doc.visibility = Visibility::private([]);

        let a2 = alice_identity

            .unwrap();

        bob.repo.fetch(eve);

        assert!(eve_identity.revision(&a2).unwrap().is_active());

        // Then she submits a new revision.

        eve_doc.visibility = Visibility::private([eve.signer.public_key().into()]);

        let e2 = eve_identity

            .unwrap();

        assert!(eve_identity.revision(&e2).unwrap().is_active());

        let eve = &network.eve;

        let mut alice_identity = Identity::load_mut(&*alice.repo).unwrap();

        alice.repo.fetch(bob);

        alice.repo.fetch(eve);

        let a0 = alice_identity.root;

        let a1 = alice_identity

            .unwrap();

        bob.repo.fetch(alice);

        eve.repo.fetch(alice);

        let mut bob_identity = Identity::load_mut(&*bob.repo).unwrap();

        //  a2 e1

        //  | /

        // Bob and Alice change the document visibility. Eve is not aware.

        bob_doc.visibility = Visibility::private([]);

        let b1 = bob_identity

            .unwrap();

        alice.repo.fetch(bob);

        eve.repo.fetch(bob);

        // In the meantime, Eve does the same thing on her side.

        let mut eve_identity = Identity::load_mut(&*eve.repo).unwrap();

        eve_doc.visibility = Visibility::private([]);

        let e1 = eve_identity

            .unwrap();

        assert_eq!(eve_identity.revisions().count(), 4);

        assert_eq!(eve_identity.revision(&e1).unwrap().state, State::Active);

        let repo = storage.repository(id).unwrap();

        let mut identity = Identity::load_mut(&repo).unwrap();

        let prj = doc.project().unwrap();

        // Make a change to the description and sign it.

        let desc = prj.description().to_owned() + "!";

        let prj = prj.update(None, desc, None).unwrap();

        doc.payload.insert(PayloadId::project(), prj.clone().into());

        identity

            .unwrap();

        // Add Bob as a delegate, and sign it.

        doc.threshold = 2;

        // Add Eve as a delegate.

        // Update with both Bob and Alice's signature.

        identity.accept(&revision, &bob).unwrap();

        // Update description again with signatures by Eve and Bob.

        doc.payload.insert(PayloadId::project(), prj.into());

        let revision = identity

            .unwrap();

        identity.accept(&revision, &eve).unwrap();

use crate::cob::thread::{Comment, CommentId, Thread};

use crate::cob::{op, store, ActorId, Embed, EntryId, ObjectId, TypeName};

use crate::crypto::Signer;

use crate::storage::{HasRepoId, RepositoryError, WriteRepository};

pub use cache::Cache;

        &self,

        action: &Action,

        actor: &ActorId,

    ) -> Result<Authorization, Error> {

            // A delegate is authorized to do all actions.

            return Ok(Authorization::Allow);

        }

        author: ActorId,

        timestamp: Timestamp,

        _concurrent: &[&cob::Entry],

        _repo: &R,

    ) -> Result<(), Error> {

        match action {

        &self,

        action: &Action,

        actor: &ActorId,

    ) -> Result<Authorization, Error> {

            // A delegate is authorized to do all actions.

            return Ok(Authorization::Allow);

        }

        author: ActorId,

        timestamp: Timestamp,

        _concurrent: &[&cob::Entry],

        repo: &R,

    ) -> Result<(), Error> {

        match action {

                    },

                );

                // Discard revisions that weren't merged by a threshold of delegates.

                match merges.into_keys().collect::<Vec<_>>().as_slice() {

                    [] => {

        let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let mut alice = Actor::new(MockSigner::default());

        let rid = gen::<RepoId>(1);

            gen::<Project>(1),

            1,

            identity::Visibility::Public,

        )

pub use crypto::PublicKey;

pub use did::Did;

pub use project::Project;

pub use crate::cob::identity::{Error, Identity, IdentityMut};

use std::collections::{BTreeMap, BTreeSet};

use std::fmt;

use std::ops::{Deref, Not};

use std::path::Path;

use std::str::FromStr;

use crate::canonical::formatter::CanonicalFormatter;

use crate::cob::identity;

use crate::crypto;

use crate::git;

use crate::identity::{project::Project, Did};

use crate::storage;

pub enum DocError {

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

    Json(#[from] serde_json::Error),

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

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

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

    Missing,

}

impl DocError {

    /// Whether this error is caused by the document not being found.

    pub fn is_not_found(&self) -> bool {

    NotFound(PayloadId),

}

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

#[serde(transparent)]

pub struct Payload {

    /// The document blob at this commit.

    pub blob: Oid,

    /// The parsed document.

}

impl Deref for DocAt {

    fn deref(&self) -> &Self::Target {

        &self.doc

    }

}

    fn from(value: DocAt) -> Self {

        value.doc

    }

}

        &self.doc

    }

}

    }

}

#[serde(rename_all = "camelCase")]

    /// The payload section.

    pub payload: BTreeMap<PayloadId, Payload>,

    /// The delegates section.

    /// The signature threshold.

    pub threshold: usize,

    /// Repository visibility.

    pub visibility: Visibility,

}