╭─────────────────────────────────────────────────────────╮

│ Title   flux capacitor underpowered                     │

│ Issue   d87dcfe8c2b3200e78b128d9b959cfdf7063fefe        │

│ Status  open                                            │

│                                                         │

│ Flux capacitor power requirements exceed current supply │

```

$ rad issue list

```

Let's create a patch, too.

```

$ rad patch

```

Both issue and patch COBs can be listed.

╭──────────────────────────────────────────────────╮

│ Title   spice harvester broken                   │

│ Issue   9de644864342d7a505eb8d58d1ef20e5bb05de2e │

│ Status  open                                     │

│                                                  │

│ Fremen have attacked, maybe we went too far?     │

```

$ rad issue list

```

Let's create a patch, too.

```

$ rad patch

```

Both issue and patch COBs can be listed.

```

$ rad id update --title "Add field" --description "Add a new 'web' field" --payload xyz.radicle.project web '"https://acme.example"'

✓ Identity revision a8a9fee6c4f83578ab132d375f1da0c81282bef3 created

@@ -1,13 +1,14 @@

 {

```

$ rad id update --title "Delete field" --description "Delete 'web'" --payload xyz.radicle.project web null

✓ Identity revision d373c35876833105f8aafed8b610660b5737cd67 created

@@ -1,14 +1,13 @@

 {

To make it public, run `rad publish`.

To push changes, run `git push`.

```

✗ Error: repository is already initialized with remote rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji

```

```

$ rad ls

│ heartwood   rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji   public       f2de534   Radicle Heartwood Protocol & Stack │

╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯

```

  }

}

$ rad inspect --delegates

```

Finally, the `--history` flag allows you to examine the identity document's

╭─────────────────────────────────────────────────────────╮

│ Title   flux capacitor underpowered                     │

│ Issue   d87dcfe8c2b3200e78b128d9b959cfdf7063fefe        │

│ Status  open                                            │

│                                                         │

│ Flux capacitor power requirements exceed current supply │

```

$ rad issue list

```

Show the issue information issue.

╭─────────────────────────────────────────────────────────╮

│ Title   flux capacitor underpowered                     │

│ Issue   d87dcfe8c2b3200e78b128d9b959cfdf7063fefe        │

│ Status  open                                            │

│                                                         │

│ Flux capacitor power requirements exceed current supply │

```

$ rad issue list --assigned

```

Note: this can always be undone with the `unassign` subcommand.

╭─────────────────────────────────────────────────────────╮

│ Title   flux capacitor underpowered                     │

│ Issue   d87dcfe8c2b3200e78b128d9b959cfdf7063fefe        │

│ Labels  good-first-issue                                │

│ Status  open                                            │

│                                                         │

│ Flux capacitor power requirements exceed current supply │

├─────────────────────────────────────────────────────────┤

│ The flux capacitor needs 1.21 Gigawatts                 │

├─────────────────────────────────────────────────────────┤

│ More power!                                             │

╰─────────────────────────────────────────────────────────╯

```

✓ Follow policy updated for z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk (Bob)

```

```

$ rad seed

✗ Stopping node... error: node is not running

```

Some commands also give us a hint if the node isn't running:

``` (fail)

When listing, we see that it has one addition:

```

$ rad patch list

```

When showing the patch, we see that it is `ahead 1, behind 1`, since master has

╭────────────────────────────────────────────────────╮

│ Title     Add Alan                                 │

│ Patch     217f050f8891def8fb863f7c0b4f85c89f97299d │

│ Head      5c88a79d75f5c2b4cc51ee6f163d2db91ee198d7 │

│ Base      f64fb2c8fe28f7c458c72ec8d700373924794943 │

│ Branches  feature/1                                │

├────────────────────────────────────────────────────┤

│ 5c88a79 Add Alan                                   │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

commit 5c88a79d75f5c2b4cc51ee6f163d2db91ee198d7

╭────────────────────────────────────────────────────╮

│ Title     Add Mel                                  │

│ Patch     e22ff008e2a0ed47262890d13263031d7555b555 │

│ Head      7f63fcbcf23fc39eea784c091ad3d20d7e4bd005 │

│ Base      f64fb2c8fe28f7c458c72ec8d700373924794943 │

│ Branches  feature/2                                │

│ 7f63fcb Add Mel                                    │

│ 5c88a79 Add Alan                                   │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

╭────────────────────────────────────────────────────╮

│ Title     Add Mel #2                               │

│ Patch     a467ffa260c4fbe355b6fb550ba0c4956078717e │

│ Head      7f63fcbcf23fc39eea784c091ad3d20d7e4bd005 │

│ Base      5c88a79d75f5c2b4cc51ee6f163d2db91ee198d7 │

│ Branches  feature/2                                │

├────────────────────────────────────────────────────┤

│ 7f63fcb Add Mel                                    │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

╭────────────────────────────────────────────────────╮

│ Title     Add README, just for the fun             │

│ Patch     183d343ab47d7fe18baf1b24b7209ad033d7fe5c │

│ Head      27857ec9eb04c69cacab516e8bf4b5fd36090f66 │

│ Base      f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354 │

│ Branches  add-readme                               │

│ 27857ec Add README, just for the fun               │

│ 3e674d1 Define power requirements                  │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Add README, just for the fun                              │

│ Patch     183d343ab47d7fe18baf1b24b7209ad033d7fe5c                  │

│ Head      27857ec9eb04c69cacab516e8bf4b5fd36090f66                  │

│ Base      3e674d1a1df90807e934f9ae5da2591dd6848a33                  │

│ Branches  add-readme                                                │

├─────────────────────────────────────────────────────────────────────┤

│ 27857ec Add README, just for the fun                                │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to ebe76f9c2148eb595d7a745f82275786bf3458c3 (27857ec) now │

╰─────────────────────────────────────────────────────────────────────╯

```

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Define power requirements                                 │

│ Patch     aa45913e757cacd46972733bddee5472c78fa32a                  │

│ Head      639f44a25145a37f747f3c84265037a9461e44c5                  │

│ Branches  patch/aa45913                                             │

│ Commits   ahead 3, behind 0                                         │

│ 27857ec Add README, just for the fun                                │

│ 3e674d1 Define power requirements                                   │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to 3156bed9d64d4675d6cf56612d217fc5f4e8a53a (27857ec) now │

│ ↑ updated to 2f5324f61e05cda65b667eeea02570d077a8e724 (639f44a) now │

╰─────────────────────────────────────────────────────────────────────╯

╭────────────────────────────────────────────────────╮

│ Title     Nothing yet                              │

│ Patch     97e18f8598237a396a1c0ac1509c89028e666c97 │

│ Head      2a465832b5a76abe25be44a3a5d224bbd7741ba7 │

│ Branches  cloudhead/draft                          │

│ Commits   ahead 1, behind 0                        │

├────────────────────────────────────────────────────┤

│ 2a46583 Nothing to see here..                      │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

╭────────────────────────────────────────────────────╮

│ Title     Nothing yet                              │

│ Patch     97e18f8598237a396a1c0ac1509c89028e666c97 │

│ Head      2a465832b5a76abe25be44a3a5d224bbd7741ba7 │

│ Branches  cloudhead/draft                          │

│ Commits   ahead 1, behind 0                        │

├────────────────────────────────────────────────────┤

│ 2a46583 Nothing to see here..                      │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

╭────────────────────────────────────────────────────╮

│ Title     Nothing yet                              │

│ Patch     97e18f8598237a396a1c0ac1509c89028e666c97 │

│ Head      2a465832b5a76abe25be44a3a5d224bbd7741ba7 │

│ Branches  cloudhead/draft                          │

│ Commits   ahead 1, behind 0                        │

├────────────────────────────────────────────────────┤

│ 2a46583 Nothing to see here..                      │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Add README, just for the fun                              │

│ Patch     89f7afb1511b976482b21f6b2f39aef7f4fb88a2                  │

│ Head      8945f6189adf027892c85ac57f7e9341049c2537                  │

│ Branches  changes                                                   │

│ Commits   ahead 2, behind 0                                         │

│ 8945f61 Define the LICENSE                                          │

│ 03c02af Add README, just for the fun                                │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to 5d78dd5376453e25df5988ec86951c99cb73742c (8945f61) now │

╰─────────────────────────────────────────────────────────────────────╯

```

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Add Metadata                                              │

│ Patch     89f7afb1511b976482b21f6b2f39aef7f4fb88a2                  │

│ Head      8945f6189adf027892c85ac57f7e9341049c2537                  │

│ Branches  changes                                                   │

│ Commits   ahead 2, behind 0                                         │

│ 8945f61 Define the LICENSE                                          │

│ 03c02af Add README, just for the fun                                │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to 5d78dd5376453e25df5988ec86951c99cb73742c (8945f61) now │

╰─────────────────────────────────────────────────────────────────────╯

```

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Add Metadata                                              │

│ Patch     89f7afb1511b976482b21f6b2f39aef7f4fb88a2                  │

│ Head      8945f6189adf027892c85ac57f7e9341049c2537                  │

│ Branches  changes                                                   │

│ Commits   ahead 2, behind 0                                         │

│ 8945f61 Define the LICENSE                                          │

│ 03c02af Add README, just for the fun                                │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to 5d78dd5376453e25df5988ec86951c99cb73742c (8945f61) now │

╰─────────────────────────────────────────────────────────────────────╯

```

╭────────────────────────────────────────────────────╮

│ Title     Not a real change                        │

│ Patch     b6a23eb08656de0ef1fcc0b5fe8820841e5cb2e5 │

│ Head      51b2f0f77b9849bfaa3e9d3ff68ee2f57771d20c │

│ Branches  feature/1                                │

│ Commits   ahead 1, behind 0                        │

├────────────────────────────────────────────────────┤

│ 51b2f0f Not a real change                          │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Not a real change                                         │

│ Patch     b6a23eb08656de0ef1fcc0b5fe8820841e5cb2e5                  │

│ Head      4d272148458a17620541555b1f0905c01658aa9f                  │

│ Branches  feature/1                                                 │

│ Commits   ahead 2, behind 0                                         │

│ 4d27214 Rename readme file                                          │

│ 51b2f0f Not a real change                                           │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to ea7def3857f62f404606d7cd6490cd0de4eaebd1 (4d27214) now │

╰─────────────────────────────────────────────────────────────────────╯

```

╭────────────────────────────────────────────────────╮

│ Title     Add things #1                            │

│ Patch     6035d2f582afbe01ff23ea87528ae523d76875b6 │

│ Head      42d894a83c9c356552a57af09ccdbd5587a99045 │

│ Branches  feature/1                                │

│ Commits   ahead 1, behind 0                        │

├────────────────────────────────────────────────────┤

│ 42d894a Add things                                 │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

```

$ rad patch

```

To update our patch, we simply push commits to the upstream branch:

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Add more things                                           │

│ Patch     95808913573cead52ad7b42c7b475260ec45c4b2                  │

│ Head      02bef3fac41b2f98bb3c02b868a53ddfecb55b5f                  │

│ Branches  feature/2                                                 │

│ Commits   ahead 2, behind 0                                         │

│ 02bef3f Improve code                                                │

│ 8b0ea80 Add more things                                             │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to d7040c6c97629c2b94f86fb639bebbff5de39697 (02bef3f) now │

╰─────────────────────────────────────────────────────────────────────╯

```

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Add more things                                           │

│ Patch     95808913573cead52ad7b42c7b475260ec45c4b2                  │

│ Head      9304dbc445925187994a7a93222a3f8bde73b785                  │

│ Branches  feature/2                                                 │

│ Commits   ahead 2, behind 0                                         │

│ 9304dbc Amended commit                                              │

│ 8b0ea80 Add more things                                             │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to d7040c6c97629c2b94f86fb639bebbff5de39697 (02bef3f) now │

│ ↑ updated to 670d02794aa05afd6e0851f4aa848bc87c4712c7 (9304dbc) now │

╰─────────────────────────────────────────────────────────────────────╯

```

$ rad patch

```

```

$ rad patch show aa45913e757cacd46972733bddee5472c78fa32a -p

╭────────────────────────────────────────────────────╮

│ Title     Define power requirements                │

│ Patch     aa45913e757cacd46972733bddee5472c78fa32a │

│ Head      3e674d1a1df90807e934f9ae5da2591dd6848a33 │

│ Branches  flux-capacitor-power                     │

│ Commits   ahead 1, behind 0                        │

├────────────────────────────────────────────────────┤

│ 3e674d1 Define power requirements                  │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

commit 3e674d1a1df90807e934f9ae5da2591dd6848a33

```

$ rad patch list --authored

```

We can also see that it set an upstream for our patch branch:

╭────────────────────────────────────────────────────╮

│ Title     Define power requirements                │

│ Patch     aa45913e757cacd46972733bddee5472c78fa32a │

│ Labels    fun                                      │

│ Head      3e674d1a1df90807e934f9ae5da2591dd6848a33 │

│ Branches  flux-capacitor-power                     │

├────────────────────────────────────────────────────┤

│ 3e674d1 Define power requirements                  │

├────────────────────────────────────────────────────┤

╰────────────────────────────────────────────────────╯

```

```

$ rad patch comment aa45913 --message 'I cannot wait to get back to the 90s!' --no-announce

╭───────────────────────────────────────╮

│ I cannot wait to get back to the 90s! │

╰───────────────────────────────────────╯

$ rad patch comment aa45913 --message 'My favorite decade!' --reply-to 686ec1c -q --no-announce

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Define power requirements                                 │

│ Patch     aa45913e757cacd46972733bddee5472c78fa32a                  │

│ Labels    fun                                                       │

│ Head      27857ec9eb04c69cacab516e8bf4b5fd36090f66                  │

│ Branches  flux-capacitor-power, patch/aa45913                       │

│ 27857ec Add README, just for the fun                                │

│ 3e674d1 Define power requirements                                   │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to 6e5a3b7b2ce27b32e7ccc2f0b3f4594897dde638 (27857ec) now │

╰─────────────────────────────────────────────────────────────────────╯

$ rad patch list

```

If you make a mistake on the patch description, you can always change it!

╭─────────────────────────────────────────────────────────────────────╮

│ Title     Define power requirements                                 │

│ Patch     aa45913e757cacd46972733bddee5472c78fa32a                  │

│ Labels    fun                                                       │

│ Head      27857ec9eb04c69cacab516e8bf4b5fd36090f66                  │

│ Branches  flux-capacitor-power, patch/aa45913                       │

│ 27857ec Add README, just for the fun                                │

│ 3e674d1 Define power requirements                                   │

├─────────────────────────────────────────────────────────────────────┤

│ ↑ updated to 6e5a3b7b2ce27b32e7ccc2f0b3f4594897dde638 (27857ec) now │

╰─────────────────────────────────────────────────────────────────────╯

```

```

$ rad inspect --visibility

private

$ rad publish

✓ Repository is now public

! Warning: Your node is not running. Start your node with `rad node start` to announce your repository to the network

$ rad inspect --visibility

public

```

If we try to publish again, we get an error:

``` (fail)

```

$ rad id update --visibility private --title "Privatise" --description "Reverting the rad publish event"

✓ Identity revision 774cc1e72641d97d7dc9377745b7f454a9171747 created

@@ -1,13 +1,16 @@

 {

│ heartwood   rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji   local        f2de534   Radicle Heartwood Protocol & Stack │

╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯

```

use radicle::prelude::Doc;

use radicle::{profile, Node};

use crate::commands;

use crate::git;

use crate::terminal as term;

            if options.verbose {

                term::blob(json::to_string_pretty(&proj)?);

            }

            // It's important to seed our own repositories to make sure that our node signals

            // interest for them. This ensures that messages relating to them are relayed to us.

            if options.seed {

            }

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

    let events = node.subscribe(DEFAULT_SUBSCRIBE_TIMEOUT)?;

    let sessions = node.sessions()?;

    spinner.message("Announcing..");

    if !sessions.iter().any(|s| s.is_connected()) {

use anyhow::anyhow;

use radicle::node::config::ConnectAddress;

use radicle::node::Handle as _;

use radicle::node::{Address, Node, NodeId, PeerAddr};

use radicle::prelude::RepoId;

    rad node debug [<option>...]

    rad node connect <nid>@<addr> [<option>...]

    rad node routing [--rid <rid>] [--nid <nid>] [--json] [<option>...]

    rad node events [--timeout <secs>] [-n <count>] [<option>...]

    rad node config [--addresses]

    rad node db <command> [<option>..]

        lines: usize,

    },

    Status,

    Debug,

    Sessions,

    Stop,

    Start,

    #[default]

    Status,

    Debug,

    Sessions,

    Stop,

                    "logs" => op = Some(OperationName::Logs),

                    "config" => op = Some(OperationName::Config),

                    "routing" => op = Some(OperationName::Routing),

                    "start" => op = Some(OperationName::Start),

                    "status" => op = Some(OperationName::Status),

                    "stop" => op = Some(OperationName::Stop),

                options,

                path: path.unwrap_or(PathBuf::from("radicle-node")),

            },

            OperationName::Status => Operation::Status,

            OperationName::Debug => Operation::Debug,

            OperationName::Sessions => Operation::Sessions,

        } => {

            control::start(node, !foreground, verbose, options, &path, &profile)?;

        }

        Operation::Status => {

            control::status(&node, &profile)?;

        }

fn print_table(entries: impl IntoIterator<Item = (RepoId, NodeId)>) {

    let mut t = term::Table::new(term::table::TableOptions::bordered());

        term::format::default(String::from("RID")),

        term::format::default(String::from("NID")),

    ]);

        }

        anyhow::bail!("fatal: repository storage is corrupt");

    }

    term::success!(

        "Repository is now {}",

        term::format::visibility(&doc.visibility)

    );

        term::warning(format!(

            "Your node is not running. Start your node with {} to announce your repository \

            to the network",

use crate::commands::rad_sync as sync;

use crate::node::SyncSettings;

use crate::terminal::args::{Args, Error, Help};

pub const HELP: Help = Help {

    name: "seed",

    node: &mut Node,

    profile: &Profile,

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

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

    term::success!(

        "Seeding policy {outcome} for {} with scope '{scope}'",

        term::format::tertiary(rid),

    Ok(())

}

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

    let store = profile.policies()?;

    let storage = &profile.storage;

    let mut t = term::Table::new(term::table::TableOptions::bordered());

    t.header([

        term::format::default(String::from("Repository")),

        term::format::default(String::from("Name")),

use radicle::{prelude::*, Node};

use crate::terminal::args::{Args, Error, Help};

pub const HELP: Help = Help {

    name: "unseed",

}

pub fn delete(rid: RepoId, node: &mut Node, profile: &Profile) -> anyhow::Result<()> {

        term::success!("Seeding policy for {} removed", term::format::tertiary(rid));

    }

    Ok(())

use crate::git;

use radicle::git::RefStr;

/// Setup a repository remote and tracking branch.

pub struct SetupRemote<'a> {

        Ok((remote, None))

    }

}

}

#[test]

fn rad_init_with_existing_remote() {

    let mut environment = Environment::new();

    let profile = environment.profile(config::profile("alice"));

            Address::from(net::SocketAddr::from(([41, 12, 98, 112], 8776))),

            Address::from_str("seed.cloudhead.io:8776").unwrap(),

        ],

        ..Config::test(Alias::new("alice"))

    });

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

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

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

    // Setup a test project.

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

        .unwrap();

    eve.db

        .routing_mut()

        .unwrap();

    eve.config.peers = node::config::PeerConfig::Static;

    eve.connect(&alice);

    eve.connect(&bob);

    eve.routes_to(&[(acme, carol), (acme, bob.id), (acme, alice.id)]);

    test(

        "examples/rad-clone-partial-fail.md",

            )],

        )

        .unwrap();

    eve.config.peers = node::config::PeerConfig::Static;

    let eve = eve.spawn();

}

#[test]

fn rad_init_private_seed() {

    let mut environment = Environment::new();

    let alice = environment.node(Config::test(Alias::new("alice")));

            }

            CommandResult::ok().to_writer(writer).ok();

        }

            Ok(result) => {

                CommandResult::updated(result).to_writer(writer)?;

            }

            log::warn!(target: "node", "Unused or deprecated configuration attribute {:?}", key);

        }

        log::info!(target: "node", "Opening node database..");

        log::info!(target: "node", "Opening policy database..");

        let policies = home.policies_mut()?;

                .expect("Runtime::init: unable to solve proof-of-work puzzle")

        };

        if config.connect.is_empty() && stores.addresses().is_empty()? {

            log::info!(target: "node", "Address book is empty. Adding bootstrap nodes..");

            .map_err(Error::from)

    }

        let (sender, receiver) = chan::bounded(1);

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

    }

pub mod session;

use std::collections::hash_map::Entry;

use std::net::IpAddr;

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

use std::sync::Arc;

    AnnounceRefs(RepoId, chan::Sender<RefsAt>),

    /// Announce local repositories to peers.

    AnnounceInventory,

    /// Connect to node with the given address.

    Connect(NodeId, Address, ConnectOptions),

    /// Disconnect from node.

        match self {

            Self::AnnounceRefs(id, _) => write!(f, "AnnounceRefs({id})"),

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

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

            Self::Disconnect(id) => write!(f, "Disconnect({id})"),

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

    }

}

impl<D> From<D> for Stores<D> {

    fn from(db: D) -> Self {

        Self(db)

    /// Last time the service routing table was pruned.

    last_prune: LocalTime,

    /// Last time the inventory was announced.

    /// Last timestamp used for announcements.

    last_timestamp: Timestamp,

    /// Time when the service was initialized, or `None` if it wasn't initialized.

            last_sync: LocalTime::default(),

            last_prune: LocalTime::default(),

            last_timestamp,

            started_at: None,     // Updated on initialize.

            last_online_at: None, // Updated on initialize.

            emitter,

    /// simply not announcing it anymore, it will eventually be pruned by nodes.

    pub fn unseed(&mut self, id: &RepoId) -> Result<bool, policy::Error> {

        let updated = self.policies.unseed(id)?;

        Ok(updated)

    }

    /// Lookup a repository, both locally and in the routing table.

    pub fn lookup(&self, rid: RepoId) -> Result<Lookup, LookupError> {

    }

    /// Initialize service with current time. Call this once.

            Err(e) => error!(target: "service", "Error checking refs database: {e}"),

        }

        let announced = self

            .db

            .seeds()

            .seeded_by(&nid)?

            .collect::<Result<HashMap<_, _>, _>>()?;

        for repo in self.storage.repositories()? {

            let rid = repo.rid;

            }

            // Add public repositories to inventory.

            if repo.doc.visibility.is_public() {

            }

            // If we have no owned refs for this repo, then there's nothing to announce.

            let Some(updated_at) = repo.synced_at else {

            }

        }

        // Setup subscription filter for seeded repos.

        self.filter = Filter::new(

        if now - self.last_sync >= SYNC_INTERVAL {

            trace!(target: "service", "Running 'sync' task...");

                error!(target: "service", "Error fetching missing inventory: {e}");

            }

            self.outbox.wakeup(SYNC_INTERVAL);

            self.last_sync = now;

        }

            trace!(target: "service", "Running 'announce' task...");

            self.outbox.wakeup(ANNOUNCE_INTERVAL);

        }

        if now - self.last_prune >= PRUNE_INTERVAL {

                }

            }

            Command::AnnounceInventory => {

            }

            Command::QueryState(query, sender) => {

                sender.send(query(self)).ok();

            }

                if clone && doc.visibility.is_public() {

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

                }

                // It's possible for a fetch to succeed but nothing was updated.

                        return Ok(None);

                    }

                }

                let mut missing = Vec::new();

                for id in message.inventory.as_slice() {

                        ) {

                            // Only if we do not have the repository locally do we fetch here.

                            // If we do have it, only fetch after receiving a ref announcement.

                            }

                        }

                    }

                }

                for rid in missing {

                    debug!(target: "service", "Missing seeded inventory {rid}; initiating fetch..");

                    self.fetch(rid, *announcer, FETCH_TIMEOUT, None);

    /// Add a seed to our routing table.

    fn seed_discovered(&mut self, rid: RepoId, nid: NodeId, time: Timestamp) {