fn push_policies(

    t: &mut Table<3, Paint<String>>,

    aliases: &impl AliasStore,

) {

        t.push([

            term::format::highlight(Did::from(id).to_string()),

            match alias {

            }

        }

        Target::Policy => {

            }

        }

        Target::Delegates => {

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

            continue;

        }

        if !seeded && !options.all {

            continue;

            if seeded {

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

            } else {

            },

            term::format::secondary(head),

            term::format::italic(proj.description().to_owned()),

    if sync {

        let mut node = radicle::Node::new(profile.socket());

            let alias = name.as_ref().and_then(|n| Alias::from_str(n.as_str()).ok());

            follow::follow(*nid, alias, &mut node, profile)?;

    ]);

    t.divider();

        let id = id.to_string();

        let scope = scope.to_string();

        let policy = policy.to_string();

        }

        Operation::Synchronize(SyncMode::Repo { mode, direction }) => {

            if [SyncDirection::Fetch, SyncDirection::Both].contains(&direction) {

                    anyhow::bail!("repository {rid} is not seeded");

                }

                let results = fetch(rid, mode.clone(), options.timeout, &mut node)?;

impl Allowed {

    pub fn from_config(rid: RepoId, config: &Config<Read>) -> Result<Self, error::Policy> {

        let entry = config

            .map_err(|err| error::Policy::FailedPolicy { rid, err })?;

        match entry.policy {

            Policy::Block => {

                        .follow_policies()

                        .map_err(|err| error::Policy::FailedNodes { rid, err })?;

                    let followed: HashSet<_> = nodes

                        .collect();

                    Ok(Allowed::Followed { remotes: followed })

    pub fn from_config(config: &Config<Read>) -> Result<BlockList, error::Blocked> {

        Ok(config

            .follow_policies()?

            .collect())

    }

}

    let policies = ctx.profile.policies()?;

    let mut repos = Vec::new();

        repos.push(json!({

            "id": id,

            "scope": scope,

        self.filter = Filter::new(

            self.policies

                .seed_policies()?

        );

        Ok(updated)

    }

        self.filter = Filter::new(

            self.policies

                .seed_policies()?

        );

        // Connect to configured peers.

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

                }

                // TODO: Buffer/throttle fetches.

                    "Service::handle_announcement: error accessing repo seeding configuration",

                );

        let missing = self

            .policies

            .seed_policies()?

            .filter(|rid| !inventory.contains(rid));

        for rid in missing {

    }

    fn is_authorized(&self, remote: NodeId, rid: RepoId) -> Result<(), UploadError> {

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

        let doc = repo.canonical_identity_doc()?;

        if !doc.is_visible_to(&remote) || policy == Policy::Block {

/// Repository seeding policy.

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

    pub scope: Scope,

    pub policy: Policy,

}

/// Node following policy.

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

    pub alias: Option<Alias>,

    pub policy: Policy,

}

pub use crate::node::policy::store;

pub use crate::node::policy::store::Error;

pub use crate::node::policy::store::Store;

#[derive(Debug, Error)]

pub enum NamespacesError {

    }

    /// Check if a repository is seeded.

            .map(|entry| entry.policy == Policy::Allow)

    }

    /// Check if a node is followed.

            .map(|entry| entry.policy == Policy::Allow)

    }

    /// Get a node's following information.

    /// Returns the default policy if the node isn't found.

            alias: None,

            policy: self.policy,

        }))

    }

    /// Returns the default policy if the repo isn't found.

            scope: self.scope,

            policy: self.policy,

        }))

        use NamespacesError::*;

        let entry = self

            .map_err(|err| FailedPolicy { rid: *rid, err })?;

        match entry.policy {

            Policy::Block => {

                        .follow_policies()

                        .map_err(|err| FailedNodes { rid: *rid, err })?;

                    let mut followed: HashSet<_> = nodes

                        .collect();

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

use crate::node::{Alias, AliasStore};

use crate::prelude::{NodeId, RepoId};

/// How long to wait for the database lock to be released before failing a read.

const DB_READ_TIMEOUT: time::Duration = time::Duration::from_secs(3);

/// `Config<Write>` can access these functions as well.

impl<T> Store<T> {

    /// Check if a node is followed.

        Ok(matches!(

            self.follow_policy(id)?,

                policy: Policy::Allow,

                ..

            })

    }

    /// Check if a repository is seeded.

        Ok(matches!(

            self.seed_policy(id)?,

                policy: Policy::Allow,

                ..

            })

    }

    /// Get a node's follow policy.

        let mut stmt = self

            .db

            .prepare("SELECT alias, policy FROM `following` WHERE id = ?")?;

                .and_then(|s| Alias::from_str(&s).ok());

            let policy = row.read::<Policy, _>("policy");

                alias,

                policy,

            }));

    }

    /// Get a repository's seeding policy.

        let mut stmt = self

            .db

            .prepare("SELECT scope, policy FROM `seeding` WHERE id = ?")?;

        stmt.bind((1, id))?;

        if let Some(Ok(row)) = stmt.into_iter().next() {

                scope: row.read::<Scope, _>("scope"),

                policy: row.read::<Policy, _>("policy"),

            }));

    }

    /// Get node follow policies.

        let mut stmt = self

            .db

            .prepare("SELECT id, alias, policy FROM `following`")?

                .and_then(|s| Alias::from_str(&s).ok());

            let policy = row.read::<Policy, _>("policy");

        }

        Ok(Box::new(entries.into_iter()))

    }

    // TODO: see if sql can return iterator directly

    /// Get repository seed policies.

        let mut stmt = self

            .db

            .prepare("SELECT id, scope, policy FROM `seeding`")?

            let scope = row.read("scope");

            let policy = row.read::<Policy, _>("policy");

        }

        Ok(Box::new(entries.into_iter()))

    }

        let mut db = Store::open(":memory:").unwrap();

        assert!(db.follow(&id, Some("eve")).unwrap());

        assert!(!db.follow(&id, Some("eve")).unwrap());

        assert!(db.unfollow(&id).unwrap());

    }

    #[test]

        let mut db = Store::open(":memory:").unwrap();

        assert!(db.seed(&id, Scope::All).unwrap());

        assert!(!db.seed(&id, Scope::All).unwrap());

        assert!(db.unseed(&id).unwrap());

    }

    #[test]

            assert!(db.follow(id, None).unwrap());

        }

        let mut entries = db.follow_policies().unwrap();

    }

    #[test]

            assert!(db.seed(id, Scope::All).unwrap());

        }

        let mut entries = db.seed_policies().unwrap();

    }

    #[test]