"radicle-remote-helper",

  "radicle-term",

]

[profile.container]

inherits = "release"

    }

    // Editing via the editor.

    issue.transaction("Edit", signer, |tx| {

        tx.edit(title)?;

            let labels = issue

                .labels()

                .cloned()

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

            issue.label(labels, &signer)?;

            let labels = patch

                .labels()

                .cloned()

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

            patch.label(labels, &signer)?;

        Ok(mut issue) => {

            let labels = issue

                .labels()

                .cloned()

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

            issue.label(labels, &signer)?;

        Ok(mut patch) => {

            let labels = patch

                .labels()

                .cloned()

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

            patch.label(labels, &signer)?;

            }

            let Some(line) = Modification::try_decode(r)? else {

            };

            let line = match line {

pub fn pubkey(val: &OsString) -> anyhow::Result<NodeId> {

    let Ok(did) = did(val) else {

        let nid = nid(val)?;

    };

    Ok(did.as_key().to_owned())

}

                    let name = HIGHLIGHTS[h.0];

                    self.advance();

                }

                ts::HighlightEvent::HighlightEnd => {

                    self.advance();

impl PartialOrd for PublicKey {

    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {

    }

}

            }

            refs::ReceivedRefname::RadId => None,

        })

    let mut updates = Updates::default();

        }

        let up = step.prepare_updates(self, &handle.repo, &refs)?;

        Ok(fetched)

    }

        {

            use gix_pack::index::File;

            for oid in wants_haves.wants {

                if idx.lookup(oid::to_object_id(oid)).is_none() {

                    return Err(io::Error::new(

                "description": rev.description(),

                "base": rev.base(),

                "oid": rev.head(),

                "discussions": rev.discussion().comments()

                  .map(|(id, comment)| Comment::new(id, comment,  aliases))

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

        .inventory()?

        .into_iter()

        .filter_map(|id| {

            if !doc.delegates.iter().any(|d| *d == delegate) {

                return None;

            }

            let delegates = doc.delegates;

            let trackings = routing.count(&id).unwrap_or_default();

        .inventory()?

        .into_iter()

        .filter_map(|id| {

            let delegates = doc.delegates;

            let trackings = routing.count(&id).unwrap_or_default();

}

fn seed_with_signer<G: Signer>(dir: &Path, profile: radicle::Profile, signer: &G) -> Context {

    let tracking_db = dir.join("radicle").join("node").join("tracking.db");

    let routing_db = dir.join("radicle").join("node").join("routing.db");

        log::info!(target: "node", "Default tracking policy set to '{}'", &policy);

        log::info!(target: "node", "Initializing service ({:?})..", network);

            .ok()

            .and_then(|ann| NodeAnnouncement::decode(&mut ann.as_slice()).ok())

            .and_then(|ann| {

                    .filter(|(nid, _)| !self.sessions.contains_key(nid))

                    .filter(|(nid, _)| nid != &self.node_id())

                    .fold(HashMap::new(), |mut acc, (nid, addr)| {

                        acc

                    })

            }

    #[cfg(not(debug_assertions))]

    pub const POW_PARAMS: (u8, u32, u32) = (15, 8, 1);

    /// Salt used for generating PoW.

    /// Verify this announcement's signature.

    pub fn verify(&self) -> bool {

            return;

        };

            log::warn!(target: "wire", "Peer {nid} is not connected; ignoring fetch result");

            return;

        };

                } => {

                    log::trace!(target: "wire", "Processing fetch for {rid} from {remote}..");

                    let (stream, channels) = streams.open();

                    log::debug!(target: "wire", "Opened new stream with id {stream} for {rid} and remote {remote}");

        }

        let Some(cmd) = self::default_editor() else {

        };

        // We duplicate the stderr file descriptor to pass it to the child process, otherwise, if

use std::ffi::OsStr;

use std::{env, fmt, io, process};

use inquire::ui::{ErrorMessageRenderConfig, StyleSheet, Styled};

}

pub fn prefixed(prefix: &str, text: &str) -> String {

}

pub fn help(name: &str, version: &str, description: &str, usage: &str) {

    fn from_root<R: ReadRepository>(op: Op, repo: &R) -> Result<Self, Self::Error> {

        let mut actions = op.actions.into_iter();

        };

        if parent.is_some() {

            return Err(ApplyError::Init(

    fn from_root<R: ReadRepository>(op: Op, repo: &R) -> Result<Self, Self::Error> {

        let doc = op.identity_doc(repo)?.ok_or(Error::MissingIdentity)?;

        let mut actions = op.actions.into_iter();

            return Err(Error::Init("the first action must be of type `comment`"));

        };

        let comment = Comment::new(op.author, body, None, None, embeds, op.timestamp);

impl<A: Eq> PartialOrd for Op<A> {

    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {

    }

}

    fn from_root<R: ReadRepository>(op: Op, repo: &R) -> Result<Self, Self::Error> {

        let doc = op.identity_doc(repo)?.ok_or(Error::MissingIdentity)?;

        let mut actions = op.actions.into_iter();

            return Err(Error::Init("the first action must be of type `revision`"));

        };

        let Some(Action::Edit { title, target }) = actions.next() else {

        let timestamp = op.timestamp;

        let identity = op.identity.ok_or(Error::MissingIdentity)?;

        let mut actions = op.actions.into_iter();

            return Err(Error::Init("missing initial comment"));

        };

}

impl Book {

    /// Open an address book at the given path. Creates a new address book if it

    /// doesn't exist.

}

impl Table {

    /// Open a routing file store at the given path. Creates a new empty store

    /// if an existing store isn't found.

}

impl Config<Read> {

    /// Same as [`Self::open`], but in read-only mode. This is useful to have multiple

    /// open databases, as no locking is required.

}

impl Config<Write> {

    /// Open a policy store at the given path. Creates a new store if it

    /// doesn't exist.

    pub fn is_not_found(&self) -> bool {

        match self {

            Self::Io(e) if e.kind() == io::ErrorKind::NotFound => true,

            Self::Doc(e) if e.is_not_found() => true,

            _ => false,

        }

    WriteRepository, WriteStorage,

};

pub use crate::storage::Error;

use super::{RemoteId, RemoteRepository, ValidateRepository};

    fn references_glob(

        &self,

        let mut refs = Vec::new();

        for r in self.backend.references_glob(pattern)? {

        Err(DocError::Missing.into())

    }

        self.backend

            .merge_base(**left, **right)

            .map(Oid::from)

    }

}

        let m1 = fixtures::commit("M1", &[*c2, *b2], &repo);

        let m2 = fixtures::commit("M2", &[*a1, *b2], &repo);

        let mut rng = fastrand::Rng::new();

        for _ in 0..100 {

            let count = rng.usize(1..=choices.len());

impl Url {

    /// URL scheme.

    /// Return this URL with the given namespace added.

    pub fn with_namespace(mut self, namespace: Namespace) -> Self {

impl Url {

    /// URL scheme.

}

impl fmt::Display for Url {

    /// Add a remote `node` with `signed_refs` for the repo `rid`.

    pub fn insert_remote(&mut self, rid: Id, node: NodeId, refs: refs::SignedRefsAt) {

    }

}