Commit, diff and show build only what they touch 8ab265dc4a51

        let (base, base_snapshot) = self.change_base(&change)?;

    }

    /// The base state of `change` (its dependencies) and its rendering, as

    /// much as showing the change needs: the whole tree, and the graphs and

    /// contents of the files the change edits. Other text files are left

    /// unrendered ([`Snapshot::unrendered`]).

    pub fn change_base(&self, change: &Change) -> Result<(State, Snapshot)> {

        let mut base = self.load_state_history(&change.deps)?;

        let edited: std::collections::HashSet<NodeId> =

            change.edits.iter().map(|e| e.node()).collect();

        let nodes: Vec<NodeId> = edited.iter().copied().collect();

        self.load_graphs_of(&mut base, &nodes)?;

        let skip: std::collections::HashSet<NodeId> = base

            .tree()

            .view()

            .entries

            .values()

            .filter(|e| e.kind == crate::objects::NodeKind::File && !edited.contains(&e.node))

            .map(|e| e.node)

            .collect();

        let snapshot = base.materialize_except(&skip);

        Ok((base, snapshot))

    /// that need its statuses, conflicts and base history, and the graphs

    /// of the files it changes: status, log, show, commit, diff, hunks and

    /// discard. Text files known unchanged since the last manifest are

    /// `unrendered` with empty bytes. They are never conflicted, and no

    /// change the working copy makes touches them.

        let snap = self.snapshot_status("oxy commit")?;

        let snap = self.snapshot_status("oxy commit")?;

        let snap = self.snapshot_status("oxy discard")?;

        // Every file of the target is rendered: build the graphs the

        // partial snapshot left out.

        self.load_all_graphs(&mut st)?;

        let (c, base, base_snapshot) = match change {

                let (base, snapshot) = self.change_base(&c)?;

                (c, base, snapshot)

                let snap = self.snapshot_status("oxy diff")?;

                (snap.wc, snap.base, snap.base_snapshot)

/// Commit, diff, hunks and discard use the partial snapshot: a file

/// unchanged since the manifest is neither read nor rendered, and showing

/// a change renders only what it edits, the same as from a full base.

#[cfg(unix)]

#[test]

fn commits_and_diffs_leave_unchanged_files_alone() {

    use std::os::unix::fs::PermissionsExt;

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap().with_home(root.join("home"));

    write(root, "big.txt", b"lots\nof\nlines\n");

    write(root, "a.txt", b"one\ntwo\n");

    repo.commit("base", &[]).unwrap();

    let old = std::time::SystemTime::now() - std::time::Duration::from_secs(30);

    for f in ["big.txt", "a.txt"] {

        fs::File::options()

            .write(true)

            .open(root.join(f))

            .unwrap()

            .set_modified(old)

            .unwrap();

    }

    assert!(repo.snapshot_status("status").unwrap().statuses.is_empty());

    // big.txt cannot be read at all from here on.

    fs::set_permissions(root.join("big.txt"), fs::Permissions::from_mode(0o000)).unwrap();

    write(root, "a.txt", b"one\nTWO\nthree\n");

    let diff = repo.diff_files(None).unwrap();

    assert_eq!(

        diff.iter().map(|f| f.path.as_str()).collect::<Vec<_>>(),

        ["a.txt"]

    );

    let (_, hunks) = repo.hunks().unwrap();

    assert!(!hunks.is_empty() && hunks.iter().all(|h| h.path == "a.txt"));

    let h = repo.commit("edit a", &[]).unwrap();

    // Showing the change needs only a.txt's graph, and renders as a full base does.

    let c = repo.store().get_change(&h).unwrap();

    let full = repo.load_state(&c.deps).unwrap();

    let want = render_change(&c, &full, &full.materialize());

    assert_eq!(repo.describe_change(&h).unwrap(), want);

    let (base, snap) = repo.change_base(&c).unwrap();

    assert!(!base.is_full() && snap.unrendered.contains("big.txt"));

    // Discarding works the same way.

    write(root, "a.txt", b"scratch\n");

    assert_eq!(repo.discard(&["a.txt".into()]).unwrap(), 1);

    assert_eq!(fs::read(root.join("a.txt")).unwrap(), b"one\nTWO\nthree\n");

    fs::set_permissions(root.join("big.txt"), fs::Permissions::from_mode(0o644)).unwrap();

}

- [x] O10h The same for commit, diff, hunks, discard and showing a change: only the graphs the change touches are built (caching materialized states turned out unnecessary).

## 2026-09-29: O10h, commit, diff and show build only what they touch

Commit, working-copy diff, hunks and discard use the partial snapshot of

O10g. Files known unchanged are neither read nor rendered, and only the

graphs of the files the working copy changes are built. Showing a

committed change (`oxy show`, `oxy diff CHANGE`) builds the graphs of the

files that change edits and leaves the rest unrendered.

Same repository as O10g (10 000 files of 40 lines):

| Operation | After O10g | After O10h |

|---|---:|---:|

| diff (working copy) | 0.57 s, 244 MB | 0.22 s, 52 MB |

| commit (one file) | 0.58 s, 245 MB | 0.23 s, 52 MB |

| show (a one-file change) | not measured | 0.53 s, 145 MB |

Caching materialized states, planned alongside, is not needed now that

these commands render almost nothing.

        let rest = repo.snapshot_status("oxy commit")?;

            let (base, snapshot) = repo.change_base(&c)?;

            let snap = repo.snapshot_status("oxy diff")?;