Walk the working copy in parallel, and keep its stats 8b276e0106d1

        // The walk itself runs on every core: each entry is found and

        // statted on its own.

        enum Found {

            File(String, PathBuf, fs::Metadata),

            Symlink(String, Vec<u8>),

        }

        let found: std::sync::Mutex<Vec<Found>> = std::sync::Mutex::new(Vec::new());

        let failed: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);

        let (root, sparse) = (&self.root, &self.config.sparse_paths);

        let in_scope = |p: &str| {

            sparse.is_empty()

                || sparse

                    .iter()

                    .any(|s| p == s || p.starts_with(&format!("{s}/")))

        };

        wb.build_parallel().run(|| {

            let (found, failed) = (&found, &failed);

            Box::new(move |entry| {

                use ignore::WalkState;

                let step = || -> std::result::Result<Option<Found>, String> {

                    let entry = entry.map_err(|e| e.to_string())?;

                    let path = entry.path();

                    if path == root {

                        return Ok(None);

                    }

                    let rel: String = path

                        .strip_prefix(root)

                        .unwrap()

                        .components()

                        .map(|c| c.as_os_str().to_string_lossy().to_string())

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

                        .join("/");

                    let Some(ft) = entry.file_type() else {

                        return Ok(None);

                    };

                    if ft.is_dir() || !in_scope(&rel) {

                        return Ok(None);

                    }

                    if ft.is_symlink() {

                        let target = fs::read_link(path).map_err(|e| e.to_string())?;

                        return Ok(Some(Found::Symlink(

                            rel,

                            target.to_string_lossy().as_bytes().to_vec(),

                        )));

                    }

                    if ft.is_file() {

                        let meta = entry.metadata().map_err(|e| e.to_string())?;

                        return Ok(Some(Found::File(rel, path.to_path_buf(), meta)));

                    }

                    Ok(None)

                };

                match step() {

                    Ok(Some(f)) => found.lock().unwrap().push(f),

                    Ok(None) => {}

                    Err(e) => {

                        failed.lock().unwrap().get_or_insert(e);

                        return WalkState::Quit;

                    }

                }

                WalkState::Continue

            })

        });

        if let Some(e) = failed.into_inner().unwrap() {

            return fail(e);

        }

        for f in found.into_inner().unwrap() {

            match f {

                Found::File(rel, path, meta) => files.push((rel, path, meta)),

                Found::Symlink(rel, target) => {

                    out.insert(rel, FsEntry::new(NodeKind::Symlink, false, target));

    let stat = Some((meta.len(), prompt::mtime_ns(meta)));

    let mut e = match stat_cached(rel, meta, cache) {

    };

    // The stat the manifest records: taken before the read, so a file that

    // changes meanwhile is read again next time.

    e.stat = stat;

    Ok(e)

        let keys_phase = crate::timing::phase("snapshot: tree view and graph keys");

        drop(keys_phase);

        let manifest = {

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

            self.read_manifest()?.map(|(_, _, m)| m)

        };

        let record = crate::timing::phase("snapshot: hash and record");

        drop(record);

### One file changed (2026-09-30, oxygen#35)

A status with one file changed (MAINTAINERS) took 4.1 s: the walk ran

on one thread (0.83 s), and the manifest was written by statting all

96 000 files again (0.57 s). The walk now runs in parallel and each

file's stat is carried from the walk into the manifest. It now takes

2.5 s: the base's history 0.5 s, its tree view and graph keys 0.38 s,

the walk 0.35 s, rendering the changed file 0.47 s, the diff 0.18 s,

and the manifest 0.14 s. (Git: 0.23 s.)