``` ~bob

$ rad node events -n 2 --timeout 1

{"type":"refsAnnounced","nid":"z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi","rid":"rad:zhbMU4DUXrzB8xT6qAJh6yZ7bFMK","refs":[{"remote":"z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk","at":"161b775a3509c8098de67f57f750972bba015b31"}],"timestamp":[..]}

```

Bob then opens a patch.

    if announce {

        match node.announce_refs(rid) {

            Err(e) if e.is_connection_err() => {}

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

        }

        ),

        other => {

            let exe = format!("{NAME}-{exe}");

            match status {

                Ok(status) => {

            }

        },

        Command::AnnounceRefs { rid } => {

        }

        Command::AnnounceInventory => {

            if let Err(e) = handle.announce_inventory() {

            let stream = BufReader::new(stream);

            let line = stream.lines().next().unwrap().unwrap();

        }

        for rid in &rids {

use crossbeam_channel as chan;

use radicle::node::{ConnectOptions, ConnectResult, Seeds};

use reactor::poller::popol::PopolWaker;

use thiserror::Error;

        receiver.recv().map_err(Error::from)

    }

    }

    fn announce_inventory(&mut self) -> Result<(), Error> {

/// Commands sent to the service by the operator.

pub enum Command {

    /// Announce repository references for given repository to peers.

    /// Announce local repositories to peers.

    AnnounceInventory,

    /// Announce local inventory to peers.

impl fmt::Debug for Command {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            Self::AnnounceInventory => write!(f, "AnnounceInventory"),

            Self::SyncInventory(_) => write!(f, "SyncInventory(..)"),

            Self::Connect(id, addr, opts) => write!(f, "Connect({id}, {addr}, {opts:?})"),

                    .expect("Service::command: error untracking node");

                resp.send(untracked).ok();

            }

                }

            Command::AnnounceInventory => {

                if let Err(err) = self

                    .storage

                // This event is used for showing sync progress to users.

                match message.is_synced(&self.node_id(), &self.storage) {

                    Ok(synced) => {

                            self.emitter.emit(Event::RefsSynced {

                                rid: message.rid,

                                remote: *announcer,

                            });

                        }

                    }

        &mut self,

        rid: Id,

        remotes: impl IntoIterator<Item = NodeId>,

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

        let doc = repo.identity_doc()?;

        let peers = self.sessions.connected().map(|(_, p)| p);

        let msg = AnnouncementMessage::from(RefsAnnouncement {

            rid,

            timestamp,

        });

        let ann = msg.signed(&self.signer);

            }),

        );

    }

    fn sync_and_announce(&mut self) {

use std::{fmt, io, mem};

use radicle::storage::refs::RefsAt;

use crate::crypto;

        &self,

        remote: &NodeId,

        storage: S,

        let repo = match storage.repository(self.rid) {

            // If the repo doesn't exist, we're not in sync.

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

            Ok(r) => r,

        };

        if let Some(theirs) = self.refs.iter().find(|refs_at| refs_at.remote == *remote) {

            let ours = RefsAt::new(&repo, *remote)?;

        }

    }

}

use std::sync::{Arc, Mutex};

use std::{io, time};

use crate::identity::Id;

use crate::node::{Alias, Config, ConnectOptions, ConnectResult, Event, FetchResult, Seeds};

use crate::runtime::HandleError;

        Ok(self.tracking_nodes.lock().unwrap().remove(&id))

    }

        self.updates.lock().unwrap().push(id);

    }

    fn announce_inventory(&mut self) -> Result<(), Self::Error> {

    events

        .wait(

            |e| {

                    assert_eq!(remote, &bob.id);

                    assert_eq!(rid, &acme);

use crate::crypto::PublicKey;

use crate::identity::Id;

use crate::profile;

use crate::storage::RefUpdate;

pub use address::{KnownAddress, SyncedAt};

    /// Untrack the given node.

    fn untrack_node(&mut self, id: NodeId) -> Result<bool, Self::Error>;

    /// Notify the service that a project has been updated, and announce local refs.

    /// Announce local inventory.

    fn announce_inventory(&mut self) -> Result<(), Self::Error>;

    /// Notify the service that our inventory was updated.

        let events = self.subscribe(timeout)?;

        let mut seeds = seeds.into_iter().collect::<BTreeSet<_>>();

        callback(AnnounceEvent::Announced);

        for e in events {

            match e {

                    callback(AnnounceEvent::RefsSynced { remote });

                }

        Ok(response.updated)

    }

    }

    fn announce_inventory(&mut self) -> Result<(), Error> {

use crossbeam_channel as chan;

use crate::node;

use crate::prelude::*;

use crate::storage::{refs, RefUpdate};

    RefsSynced {

        remote: NodeId,

        rid: Id,

    },

    SeedDiscovered {

        rid: Id,

///

/// It can also be used for communicating announcements of updates

/// references to other nodes.

#[serde(rename_all = "camelCase")]

pub struct RefsAt {

    /// The remote namespace of the `rad/sigrefs`.