### Better Support for Bare Repositories

Some improvements to supporting bare repositories have been made for `rad` and

`git-remote-rad`. For `rad`, the `rad clone` command has learned a new flag

### Display Full Node IDs

shortened forms of NIDs and addresses when the output is transient, and the full

form where it is presented to the user. This will allow you to be able to copy

and paste these identifiers.

---

**Note**: the script currently outputs warnings about the `strip` command for

---

### Release Branch

*patch releases*, e.g. `1.5.1`, `1.5.2`, etc.

The branch must be named `releases/x.y`, similar to the tagged release, where

After the `x.y.0` release is made, it may be beneficial, or even necessary, to

release patch releases of the binaries. These patch releases must be compatible

included.

These changes may have been made on `master` and back-ported to the

# Install dependencies.

RUN apk update && apk add --no-cache git musl-dev xz asciidoctor

ARG ZIG_VERSION="0.13.0"

RUN wget -q https://ziglang.org/download/${ZIG_VERSION}/zig-linux-x86_64-${ZIG_VERSION}.tar.xz && \

    tar -xf zig-linux-x86_64-${ZIG_VERSION}.tar.xz && \

 * [new tag]         v1.0 -> v1.0

```

~~~

fetch = +refs/tags/*:refs/remotes/<name>/tags/*

```(stderr)

$ jj git init --git-repo heartwood heartwood.jj

```(stderr)

$ jj git init --colocate

✓ Successfully cleaned rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji

```

repository, has no effect on the storage at all:

``` ~eve (fail)

        └── sigrefs

```

```

$ rad remote add z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk --name bob --no-sync --fetch

          "default": 128

        },

        "outbound": {

          "type": "integer",

          "format": "uint",

          "minimum": 0,

        └── sigrefs

```

project and push to our own fork.

Later, Bob meets Eve at a conference and she wants to take part in the

project. For Bob to propose Eve, similar steps need to happen as

``` ~eve

$ rad clone rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji --scope followed

 - <https://github.com/jj-vcs/jj/issues/4075>

 - <https://github.com/jj-vcs/jj/pull/2098>

Git to push.

``` (stderr)

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

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

    setup_remotes(

        project::SetupRemote {

            rid: args.repo,

    Ok(path)

}

pub fn setup_remotes(

    setup: project::SetupRemote,

    remotes: &[NodeId],

    Ok(())

}

pub fn setup_remote(

    setup: &project::SetupRemote,

    remote_id: &NodeId,

    /// Print a log of all raw operations on a COB

    Log {

        #[arg(long, short, value_name = "RID")]

        repo: RepoId,

        /// Update the identity by setting metadata in one of the identity payloads

        ///

        /// [example values: xyz.radicle.project name '"radicle-example"']

        // change with clap v5, so we can hopefully use `Vec<Payload>`.

        // - https://github.com/clap-rs/clap/discussions/5930#discussioncomment-12315889

        // - https://docs.rs/clap/latest/clap/_derive/index.html#arg-types

pub(super) enum ListMode {

    /// List the notifications of the current repository, if in a working

    Contextual,

    All,

    /// List the notifications for a specific repository.

    ByRepo(RepoId),

            }

            if args.set_upstream || git::branch_remote(&repo, proj.default_branch()).is_err() {

                radicle::git::set_upstream(

                    &repo,

                    &*radicle::rad::REMOTE_NAME,

            }

            if args.setup_signing {

                self::setup_signing(profile.id(), &repo, interactive)?;

            }

    )?;

    if args.set_upstream {

        radicle::git::set_upstream(

            &working,

            &*radicle::rad::REMOTE_NAME,

    }

    if args.setup_signing {

        self::setup_signing(profile.id(), &working, interactive)?;

    }

    Ok(())

}

pub fn setup_signing(

    node_id: &NodeId,

    repo: &git::Repository,

    /// Set repository visibility to *public*

    #[arg(long, conflicts_with = "private")]

    public: bool,

    ///

    /// [example values: rad:z3Tr6bC7ctEg2EHmLvknUr29mEDLH, z3Tr6bC7ctEg2EHmLvknUr29mEDLH]

    #[arg(long, value_name = "RID")]

    pub(super) existing: Option<RepoId>,

    #[arg(short = 'u', long)]

    pub(super) set_upstream: bool,

    #[arg(long)]

    pub(super) setup_signing: bool,

    /// Don't ask for confirmation during setup

    /// Show the status

    Status {

        #[arg(long, value_parser = OnlyParser)]

        only: Option<Only>,

    },

        return Ok(());

    }

    let envs = if profile.keystore.is_encrypted()? {

        // without `RAD_PASSPHRASE`.

        let validator = term::io::PassphraseValidator::new(profile.keystore.clone());

        let passphrase = if let Some(phrase) = profile::env::passphrase() {

    }

}

/// Creates the tracking branch if it does not exist.

///

/// > scooby/master...rad/scooby/heads/master

use radicle::git::fmt::RefStr;

use radicle::node::NodeId;

pub struct SetupRemote<'a> {

    /// The repository id.

    pub rid: RepoId,

    pub tracking: Option<BranchName>,

    /// Whether or not to fetch the remote immediately.

    pub fetch: bool,

    pub repo: &'a git::Repository,

}

        if self.fetch {

            remote.fetch::<&str>(&[], None, None)?;

        }

        if let Some(branch) = &self.tracking {

            let tracking_branch = remote_name.join(branch);

            let local_branch = radicle::git::refs::workdir::branch(tracking_branch.as_refstr());

    }

}

/// if we're connected to a TTY.

pub fn signer(profile: &Profile) -> anyhow::Result<BoxedDevice> {

    match profile.signer() {

    /// Keep track of which remotes are being uploaded to, removing any that

    /// have completed.

    remotes: BTreeSet<NodeId>,

    /// throughput.

    timer: Instant,

}

    let eve = environment.relay("eve");

    let home = alice.home.clone();

    let rid = RepoId::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

    environment.repository(&alice);

    test(

    let bob = environment.node("bob");

    let working = environment.tempdir().join("working");

    let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    let mut alice = alice.spawn();

    let bob = environment.node("bob");

    let working = environment.tempdir().join("working");

    let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    let mut alice = alice.spawn();

    let bob = environment.node("bob");

    let working = environment.tempdir().join("working");

    let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    let mut alice = alice.spawn();

    let bob = environment.node("bob");

    let eve = environment.node("eve");

    let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    let mut alice = alice.spawn();

    let mut eve = environment.node("eve");

    let carol = NodeId::from_str("z6MksFqXN3Yhqk8pTJdUGLwBTkRfQvwZXPqR2qMEhbS9wzpT").unwrap();

    let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    let mut alice = alice.spawn();

    std::fs::create_dir_all(base).unwrap();

    std::fs::create_dir_all(working.clone()).unwrap();

    fixtures::repository(&working);

    test("examples/rad-init.md", &working, Some(home), []).unwrap();

    )

    .unwrap();

    fixtures::repository(&working);

    test("examples/rad-init.md", &working, Some(home), []).unwrap();

    log::debug!(target: "test", "Issue {} created", issue.id());

    // Make sure that Bob's issue refs announcement has a different timestamp than his fork's

    std::thread::sleep(std::time::Duration::from_millis(3));

    bob.handle.announce_refs_for(rid, [bob.id]).unwrap();

    let mut alice = environment.node("alice");

    let working = tempfile::tempdir().unwrap();

    alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    let alice = alice.spawn();

    let mut environment = Environment::new();

    let mut alice = environment.node("alice");

    alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    alice.project("nixpkgs", "Home for Nix Packages");

    let alice = alice.spawn();

    let eve = environment.relay("eve");

    let home = alice.home.clone();

    let rid = RepoId::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

    environment.repository(&alice);

    test(

//! is not handled by the process, i.e., no signal handler is installed.

//! The default behaviour in this case is to terminate the process with an

//! exit code of 141 (128 + 13). Such lack of a signal handler is also

//!

//! Rust (since 1.62) ignores `SIGPIPE` by default, see [issue #6529].

//! Ignorance in this case means that the signal handler is set to

    let eve = environment.node("eve");

    let working = environment.tempdir().join("working");

    let acme = RepoId::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

    radicle::test::fixtures::repository(working.join("acme"));

    test(

    /// Path to the working directory of the user with the given alias.

    /// Tests that need to act on multiple repositories should crate

    pub fn work(&self, has_alias: &impl HasAlias) -> PathBuf {

        self.unix_home(has_alias).join("work")

    }

        }

    }

    pub fn profile(&mut self, alias: &'static str) -> Profile {

        self.profile_with(self.config(alias))

    }

        let verified = repo

            .identity_doc_at(

                *s.canonical_rad_id()

            )

            .map_err(|err| error::Prepare::Verification {

                remote: self.remote,

impl ProtocolStage for SigrefsAt {

    fn ls_refs(&self) -> Option<NonEmpty<RefPrefix>> {

        // N.b. the `Oid`s are known but the `rad/sigrefs` are still

        NonEmpty::collect(

            self.refs_at

                .iter()

        )

    }

    // `rad/sigrefs`.

    fn ref_filter(&self, r: Ref) -> Option<ReceivedRef> {

        let (refname, tip) = refs::unpack_ref(r).ok()?;

    pub(crate) controller: reactor::Controller,

    shutdown: Arc<AtomicBool>,

    /// Publishes events to subscribers.

    emitter: Emitter<Event>,

    }

    fn shutdown(self) -> Result<(), Error> {

        if self

            .shutdown

            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)

            s.elapsed() < LocalDuration::from_mins(3)

        });

        if alice.sessions().connected().count() != 4 {

            continue;

        }

                                    ChannelsConfig::new(FETCH_TIMEOUT)

                                        .with_reader_limit(reader_limit),

                                ) else {

                                    continue;

                                };

            // In proxy mode, simply use the configured proxy address.

            // This takes precedence over any global proxy.

            AddressConfig::Proxy { address } => Ok((*address).into()),

            // we treat the address as a regular DNS name.

            AddressConfig::Forward => Ok(global_proxy

                .map(Into::into)

    // Determine what address to establish a TCP connection with, given the remote peer

    // address and our node configuration.

    let inet_addr: NetAddr<InetHost> = match (&remote_addr.host, config.proxy) {

        (HostName::Ip(_), Some(proxy)) => proxy.into(),

        (HostName::Ip(ip), None) => NetAddr::new(InetHost::Ip(*ip), remote_addr.port),

        (HostName::Dns(_), Some(proxy)) => proxy.into(),

                // Notifications are only posted for pulls, not clones.

                if let Some(mut store) = notifs {

                    // Only create notifications for repos that we have

                    // be flooded by all the repos we are seeding.

                    if repo.remote(&storage.info().key).is_ok() {

                        notify(&rid, &applied, &mut store)?;

/// Message stream deserializer.

///

#[derive(Debug)]

pub struct Deserializer<const B: usize, D = Message> {

    unparsed: BoundedVec<u8, B>,

    }

    /// Try to dequeue the next [`QueuedFetch`], but only if the `predicate`

    pub(super) fn try_dequeue<P>(&mut self, predicate: P) -> Option<QueuedFetch>

    where

        P: FnOnce(&QueuedFetch) -> bool,

/// How far back from the present time should we request gossip messages when connecting to a peer,

/// when we come online for the first time.

pub const INITIAL_SUBSCRIBE_BACKLOG_DELTA: LocalDuration = LocalDuration::from_mins(60 * 24);

/// messages further back than strictly necessary, to account for missed messages.

pub const SUBSCRIBE_BACKLOG_DELTA: LocalDuration = LocalDuration::from_mins(3);

/// Minimum amount of time to wait before reconnecting to a peer.

            .routing_mut()

            .remove_inventories(private.iter(), &nid)?;

        self.filter = Filter::allowed_by(self.policies.seed_policies()?);

        // Connect to configured peers.

        let addrs = self.config.connect.clone();

    /// Find the closest `n` peers by proximity in seeding graphs.

    /// Returns a sorted list from the closest peer to the furthest.

    #[allow(unused)]

    pub fn closest_peers(&self, n: usize) -> Vec<NodeId> {

        todo!()

            }

        }

        let relay = match self.db.gossip_mut().announced(announcer, announcement) {

            Ok(Some(id)) => {

                log::debug!(

        let now = self.clock();

        let filter = self.filter();

        // much bandwidth.

        // If we've been previously connected to the network, we'll have received gossip messages.

/// Result of a project lookup.

#[derive(Debug)]

pub struct Lookup {

    pub local: Option<Doc>,

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

    pub remote: Vec<NodeId>,

        ann: &Announcement,

    ) -> Result<Option<AnnouncementId>, Error>;

    fn set_relay(&mut self, id: AnnouncementId, relay: RelayStatus) -> Result<(), Error>;

    /// Return messages that should be relayed.

                "to update, run `git push {upstream} {local_branch}`"

            ));

        }

        else if let Some(branch) =

            rad::setup_patch_upstream(&patch, *head, working, upstream, false)?

        {

    /// with the set of commits of the other [`Did`]s.

    ///

    /// If a quorum is found, then it is also ensured that the new head commit

    /// are considered diverging.

    ///

    /// # Errors

/// What file is used for text output.

static TERMINAL: AtomicI32 = AtomicI32::new(TerminalFile::Stdout as i32);

static ENABLED: AtomicBool = AtomicBool::new(true);

/// Whether paint styling should be forced.

static FORCED: AtomicBool = AtomicBool::new(false);

            {

                use std::os::fd::{AsRawFd as _, FromRawFd as _};

                // we simply pass the `RawFd` of our stderr, `Command` will close our stderr when the

                // child exits.

        })

    }

    fn closed(&self) -> Result<Self::Iter<'_>, Self::Error> {

        self.list_by_status(&State::Closed {

            reason: CloseReason::Other,

/// Operations are applied to an accumulator to yield a final state.

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

pub struct Op<A> {

    pub id: EntryId,

    /// The action carried out by this operation.

    pub actions: NonEmpty<A>,

                // In this case, since there is not enough information to determine

                // whether the action is authorized or not, we simply ignore it.

                // It's likely that the target object was redacted, and we can't

                Ok(())

            }

        }

                    return Ok(());

                };

                if let Some(rev) = rev {

                    // this operation

                    if let btree_map::Entry::Vacant(e) = rev.reviews.entry(author) {

                        let id = ReviewId(entry);

    /// Add actions to this transaction.

    /// Note that we cannot implement [`std::iter::Extend`] because [`Self::push`]

    pub fn extend<I: IntoIterator<Item = T::Action>>(&mut self, actions: I) -> Result<(), Error> {

        for action in actions {

            self.push(action)?;

    /// This error indicates that the operations are not being applied

    /// in causal order, which is a requirement for this CRDT.

    ///

    /// that hasn't happened yet.

    #[error("causal dependency {0:?} missing")]

    Missing(EntryId),

        // Note for the next two cases we only give enough merge base

        // information so that the quorum fails. If we provided all

        let mut cq = CommitQuorum::new([c2, b2].iter(), 2);

        cq.found_merge_bases([MergeBase {

            a: b2.id(),

    /// the `short` alias, both sets of results will return. For the `long`

    /// alias, only its results will return.

    ///

    pub fn test_reverse_lookup(store: &impl AliasStore, AliasInput { short, long }: AliasInput) {

        let (short, short_ids) = short;

        let (long, long_ids) = long;

    /// Max inbound connections.

    pub inbound: LimitConnectionsInbound,

    pub outbound: LimitConnectionsOutbound,

}

        node::Features::SEED

    }

    pub fn user_agent(&self) -> UserAgent {

        match self.user_agent.as_ref() {

            Some(agent) => agent.clone(),

        remote: NodeId,

        /// The status code of the upload-pack process.

        ///

        /// status is used instead.

        status: String,

    },

    /// Construct a `UploadPack::Done` event.

    ///

    /// finished with an error.

    pub fn done(rid: RepoId, remote: NodeId, status: ExitStatus) -> Self {

        Self::Done {

  "repo"               text      not null,

  -- Git reference name related to this update.

  "ref"                text      not null,

  "status"             integer   default null,

  -- Old head of the branch before update (OID or `null`).

  "old"                text,

    /// Complete the [`Announcer`] process returning a [`AnnouncerResult`].

    ///

    /// If the target for the [`Announcer`] has been reached, then the result

    /// [`AnnouncerResult::TimedOut`].

    pub fn timed_out(self) -> AnnouncerResult {

        match self.is_target_reached() {

    /// Check if the [`Announcer`] can continue synchronizing with more nodes.

    /// If there are no more nodes, then [`NoNodes`] is returned in the

    /// the [`ControlFlow::Continue`].

    // TODO(finto): I'm not sure this is needed with the change to the target

    // logic. Since we can reach the replication factor OR the preferred seeds,

}

impl AnnouncerConfig {

    /// [`AnnouncerConfig`]'s preferred seeds with the allowed set from the

    /// [`PrivateNetwork`].

    ///

        }

    }

    ///

    /// `preferred_seeds` is the target set of preferred seeds that [`Announcer`] should

    /// attempt to synchronize with.

}

impl FetcherConfig {

    /// [`FetcherConfig`]'s seeds with the allowed set from the

    /// [`PrivateNetwork`]. It is recommended that

    /// [`FetcherConfig::with_candidates`] is not used to extend the candidate

    }

    {

        let remote_head_ref =

            git::refs::workdir::remote_branch(&REMOTE_NAME, project.default_branch());

            repo.checkout_head(None)?;

        }

        git::set_upstream(&repo, &*REMOTE_NAME, project.default_branch(), branch_ref)?;

    }

    Ok(git::raw::Repository::open(path)?)

}

pub fn setup_patch_upstream<'a>(

    patch: &ObjectId,

    patch_head: crate::git::Oid,

            // The fact that the parent OID is a hash over all previous history

            // makes it *incredibly unlikely* or rather *practically impossible*

            // that the same `/refs` blob re-appears in previous history.

            return Ok(head);

        }

                // for `rad/refs/sigrefs-parent` to target. The zero OID would

                // be a candidate, but it is filtered out in [`Refs`].

                // Upgrading to `FeatureLevel::Parent` is not a good idea

                // would be at that level from the root onwards.

                // Pattern 2:

    pub info: crate::git::UserInfo,

    /// All refs keyed by RID.

    pub repos: HashMap<RepoId, MockRepository>,

}

set -e

install() {

  os="$(uname)"

        # Arch Linux

        pacman -Sy --noconfirm asciidoctor

      fi ;;

      if command -v brew >/dev/null 2>&1; then

        brew install asciidoctor

      fi ;;

- [ ] Isolation between simulations and main network.

- [ ] Different node versions within a simulation.

- [ ] Realistic load generation.

- [ ] Invariant assertion across simulation network.

- [ ] Teardown and Artifact collection.