Status: maps built in path order, fast maps for node lookups (refs #41) 36e51aa806c6

        tracked: &BTreeMap<String, (NodeKind, Option<ObjectRef>)>,

        keys: Option<&HashMap<String, String>>,

    ) -> Result<BTreeMap<String, FsEntry>> {

        let sparse = &self.config.sparse_paths;

        let in_scope = |p: &str| {

            sparse.is_empty()

            Some(l) => l,

            None => walk::list(&self.root, &in_scope)?,

        };

        let keys = keys.filter(|k| {

            let on_disk: HashSet<&str> = files.iter().map(|(r, _, _)| r.as_str()).collect();

            let attrs_unchanged =

        // Reading files is most of a walk's cost; do it in parallel.

        {

            use rayon::prelude::*;

                .par_iter()

                .map(|(rel, path, meta)| {

                    let key = keys

                    Ok((rel.clone(), read_file_entry(rel, path, meta, cache, key)?))

                })

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

                // A cached blob the store lost (gc, a partial clone): read the file after all.

                if e.content.is_empty() && e.blob.is_some_and(|b| !self.store.has(&b)) {

                    e.blob = None;

                }

            }

        }

        drop(_read_phase);

        };

        let tracked: BTreeMap<String, (NodeKind, Option<ObjectRef>)> = {

            let _t = crate::timing::phase("snapshot: tracked paths");

        };

        let mut fs_entries = {

            let _t = crate::timing::phase("snapshot: read working copy");

use ignore::Match;

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

#[derive(Default)]

pub(crate) struct Listing {

    /// Regular files: path relative to the root (with `/`), full path, stat.

    if let Some(e) = ctx.failed.into_inner().unwrap_or_else(|e| e.into_inner()) {

        return fail(e);

    }

}

fn visit<'s>(

    /// Shared between clones: a clone copies a graph only when an edit

    /// changes it (`Arc::make_mut`), so keeping several states that differ

    /// by a few changes costs little more than one.

    replaces: HashMap<NodeId, Vec<ReplaceRecord>>,

    /// Memoised transitive dependencies. A mutex, not a `RefCell`, so a

    /// loaded state can be shared across threads by a host that caches it.

    /// `None` for a full state. For a history-only state (loaded for its

    /// changes and tree), the file graphs not built yet, by node: `files`

    /// holds only those loaded with [`State::load_graphs`].

}

use crate::objects::TextRef;

    /// The deferred block: each node with its graph key and its body,

    /// left encoded (see [`Deferred`]).

        use crate::flat::Reader;

        let _t = crate::timing::phase("index: deferred");

        let all: Arc<[u8]> = Arc::from(bytes);

        let mut r = Reader::new(bytes);

        let n = r.count()?;

        deferred.reserve(n);

        for _ in 0..n {

    /// need no file contents, or only a few files.

    pub fn new_history_only() -> Self {

        State {

            ..Self::default()

        }

    }

            return State::from_checkpoint_payload(bytes);

        }

        let mut st = State::payload_common(m)?;

        for f in o::array(o::field(m, 3, "files")?, "files")? {

            let e = o::array(f, "file")?;

            if e.len() != 2 {

                }

            })

            .collect();

        Snapshot {

            tree,

            files,