A snapshot builds only the paths that may have changed 23ff1288a5dd

#[derive(Clone)]

        self.build_from_entries_with(

            base,

            base_snapshot,

            reuse,

            fs_entries,

            resolve,

            Scope::default(),

        )

            Scope {

                seed: Some(seed),

                dir_needed,

            },

    /// `build_from_entries` for a snapshot most of whose files are known

    /// unchanged (oxygen#41): only the paths that may differ are built

    /// (files read rather than known unchanged, base files gone from disk,

    /// and the directories those may leave empty), against a snapshot of

    /// just those, so a large tree with a few edits costs what they touch.

    fn build_changed_only(

        &self,

        base: &State,

        base_snapshot: &Snapshot,

        reuse: HashMap<String, (NodeId, NodeKind)>,

        fs_entries: &BTreeMap<String, FsEntry>,

    ) -> Result<BuiltChange> {

        // A file known unchanged may still have changed mode: that alters

        // neither its size nor its time.

        let changed: BTreeMap<String, FsEntry> = fs_entries

            .iter()

            .filter(|(p, e)| {

                !e.unchanged

                    || base_snapshot

                        .files

                        .get(*p)

                        .is_none_or(|f| f.kind != e.kind || f.mode.exec != e.exec)

            })

            .map(|(p, e)| (p.clone(), e.clone()))

            .collect();

        let mut files: BTreeMap<String, crate::state::FileState> = BTreeMap::new();

        for p in changed.keys() {

            if let Some(f) = base_snapshot.files.get(p) {

                files.insert(p.clone(), f.clone());

            }

        }

        for (p, f) in &base_snapshot.files {

            if f.kind == NodeKind::Dir || fs_entries.contains_key(p) {

                continue;

            }

            files.insert(p.clone(), f.clone());

            let mut end = p.len();

            while let Some(i) = p[..end].rfind('/') {

                let dir = &p[..i];

                if files.contains_key(dir) {

                    break;

                }

                if let Some(d) = base_snapshot.files.get(dir) {

                    files.insert(dir.to_string(), d.clone());

                }

                end = i;

            }

        }

        let part = Snapshot {

            tree: base_snapshot.tree.clone(),

            files,

            unrendered: BTreeSet::new(),

        };

        // Whether anything on disk is under `dir`.

        let dir_needed = |dir: &str| {

            let prefix = format!("{dir}/");

            fs_entries

                .range(prefix.clone()..)

                .next()

                .is_some_and(|(k, _)| k.starts_with(&prefix))

        };

        self.build_from_entries_with(

            base,

            &part,

            reuse,

            &changed,

            &HashSet::new(),

            Scope {

                seed: None,

                dir_needed: Some(&dir_needed),

            },

        )

    }

        scope: Scope,

        let Scope { seed, dir_needed } = scope;

            if partial && self.config.sparse_paths.is_empty() {

                #[cfg(test)]

                let full =

                    self.build_from_entries(&base, &base_snapshot, reuse.clone(), &fs_entries)?;

                let built = self.build_changed_only(&base, &base_snapshot, reuse, &fs_entries)?;

                #[cfg(test)]

                {

                    // New nodes take random identifiers: compare them by

                    // order of appearance.

                    let norm = |b: &BuiltChange| {

                        let text = format!("{:?} {:?} {:?}", b.tree_ops, b.edits, b.statuses);

                        let mut seen: Vec<String> = Vec::new();

                        let mut out = String::new();

                        let mut rest = text.as_str();

                        while let Some(i) = rest.find("NodeId(") {

                            out.push_str(&rest[..i]);

                            let end = i + rest[i..].find(')').unwrap() + 1;

                            let id = rest[i..end].to_string();

                            let n = seen.iter().position(|x| *x == id).unwrap_or_else(|| {

                                seen.push(id);

                                seen.len() - 1

                            });

                            out.push_str(&format!("N{n}"));

                            rest = &rest[end..];

                        }

                        out.push_str(rest);

                        out

                    };

                    assert_eq!(

                        norm(&built),

                        norm(&full),

                        "a changed-only build is the full one"

                    );

                }

                built

            } else {

                self.build_from_entries(&base, &base_snapshot, reuse, &fs_entries)?

            }

/// How a change is built beyond its entries: for a Git import, the seed

/// its new nodes' identifiers derive from; and, when it is built from part

/// of the tree, whether the new tree has anything under a directory.

#[derive(Default)]

struct Scope<'a> {

    seed: Option<[u8; 32]>,