Status after a large commit without reading or holding its text 86e1824f2d0b

                        if lines.is_empty() {

                            return schema("insert with no lines");

                        }

/// A resolver may also return no lines, leaving a placeholder for a reader

/// that fills it in later (history-only states, spec §11).

        let history = state.is_history_only();

                // A history-only state reads text only for the graphs it

                // builds; either way the hash is the one asked for.

                let (c, texts) = if history {

                    self.store.get_change_lazy(&h)?

                } else {

                    (self.store.get_change(&h)?, Vec::new())

                };

                state.add_known(h, c, texts);

    /// Change the header flags, and set the graph key of each path in

    /// `keys` (after a commit, the new base's keys of the files it holds as

    /// they are on disk).

    pub(crate) fn rewrite_manifest(

        &self,

        conflicted: bool,

        uncommitted: bool,

        keys: &HashMap<String, String>,

    ) -> Result<()> {

                let f: Vec<&str> = line.splitn(6, '\t').collect();

                match (f.len() == 6).then(|| keys.get(f[5])).flatten() {

                    Some(k) => out.push_str(&format!(

                        "{}\t{}\t{}\t{}\t{k}\t{}\n",

                        f[0], f[1], f[2], f[3], f[5]

                    )),

                    None => {

                        out.push_str(line);

                        out.push('\n');

                    }

                }

    /// The graph key of each text file of the state at `heads`, by path,

    /// from a history-only load that builds no graph. Files with an `eol`

    /// attribute are left out: their bytes on disk are not the rendering.

    fn committed_graph_keys(&self, heads: &[ChangeHash]) -> Result<HashMap<String, String>> {

        let _t = crate::timing::phase("commit: graph keys");

        let st = self.load_state_history(heads)?;

        let attrs = self.disk_attributes();

        Ok(st

            .tree()

            .view()

            .entries

            .iter()

            .filter(|(p, e)| {

                e.kind == NodeKind::File && !e.mode.opaque && attrs.lookup(p).eol.is_none()

            })

            .filter_map(|(p, e)| {

                let k = st.graph_key(&e.node)?;

                Some((p.clone(), crate::hash::ObjectRef(k).to_hex()))

            })

            .collect())

    }

            let conflicted = snap.base_snapshot.is_conflicted() && !snap.resolves;

            // The files on disk are now exactly the new base's renderings:

            // record their graph keys, so the next snapshot neither reads nor

            // renders them (oxygen#35).

            let keys = if conflicted {

                HashMap::new()

            } else {

                self.committed_graph_keys(&wc.deps).unwrap_or_default()

            };

            self.rewrite_manifest(conflicted, false, &keys)?;

/// oxygen#35: a history-only state keeps no inserted text. It reads a

/// stored insert's text blob only when it builds that file's graph, and

/// builds the same graph a full load does.

#[test]

fn history_only_states_read_text_only_for_the_graphs_they_build() {

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

    let big: String = (0..3000).map(|i| format!("big line {i}\n")).collect();

    let other: String = (0..3000).map(|i| format!("other line {i}\n")).collect();

    write(root, "big.txt", big.as_bytes());

    write(root, "other.txt", other.as_bytes());

    let h = repo.commit("two large files", &[]).unwrap();

    write(root, "big.txt", format!("{big}one more\n").as_bytes());

    let h2 = repo.commit("append", &[]).unwrap();

    let full = repo.load_state_full(&[h2]).unwrap().materialize();

    let text = |snap: &crate::state::Snapshot, p: &str| match &snap.files[p].content {

        FileContent::Text { bytes, .. } => bytes.clone(),

        other => panic!("{other:?}"),

    };

    // Built on demand, every graph renders as the full load's.

    let mut hist = repo.load_state_history(&[h2]).unwrap();

    let big_node = full.files["big.txt"].node;

    assert!(hist.graph_key(&big_node).is_some(), "not built yet");

    repo.load_all_graphs(&mut hist).unwrap();

    let rendered = hist.materialize();

    for p in ["big.txt", "other.txt"] {

        assert_eq!(text(&rendered, p), text(&full, p), "{p}");

    }

    // Without other.txt's text blob, history still loads and big.txt still

    // builds: nothing read the other text.

    let (_, texts) = repo.store().get_change_lazy(&h).unwrap();

    assert_eq!(texts.len(), 2);

    let content = |r: &ObjectRef| -> Vec<u8> {

        let blob = crate::objects::Blob::decode(&repo.store().get(r).unwrap().1).unwrap();

        blob.chunks

            .iter()

            .flat_map(|c| repo.store().get(c).unwrap().1)

            .collect()

    };

    let other_text = texts

        .iter()

        .map(|(r, _)| *r)

        .find(|r| content(r).windows(12).any(|w| w == b"other line 1"))

        .unwrap();

    fs::remove_file(repo.store().path_for(&other_text)).unwrap();

    let mut hist = repo.load_state_history(&[h2]).unwrap();

    repo.load_graphs_of(&mut hist, &[big_node]).unwrap();

    assert!(repo

        .load_graphs_of(&mut hist, &[full.files["other.txt"].node])

        .is_err());

}

/// oxygen#35: the first status after a commit read and rendered every

/// file (79 s and more than 14 GB on the Linux tree), because the

/// manifest had no graph keys for files the commit added.

#[test]

fn a_commit_leaves_a_manifest_the_next_status_trusts() {

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

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

    let files = ["a.txt", "b.txt", "d/c.txt"];

    for p in files {

        write(root, p, format!("{p}\n").as_bytes());

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

        fs::File::options()

            .write(true)

            .open(root.join(p))

            .unwrap()

            .set_modified(old)

            .unwrap();

    }

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

    let (_, _, m) = repo.read_manifest().unwrap().unwrap();

    assert!(

        m.entries.values().all(|e| e.graph.is_some()),

        "keys recorded at commit"

    );

    // Unreadable files prove the next status reads none of them.

    for p in files {

        fs::set_permissions(root.join(p), fs::Permissions::from_mode(0o000)).unwrap();

    }

    let snap = repo.snapshot_status("status").unwrap();

    for p in files {

        fs::set_permissions(root.join(p), fs::Permissions::from_mode(0o644)).unwrap();

    }

    assert!(!snap.changed && snap.statuses.is_empty());

    assert_eq!(snap.base_snapshot.unrendered.len(), files.len());

}

/// A stored insert's text blob and line count.

type TextRef = (ObjectRef, u32);

    /// The text blob and line count of each insert in `edits` left without

    /// its lines, in order: read when the graph is built.

    texts: Vec<(ObjectRef, u32)>,

    /// Whether this state builds file graphs only when asked

    /// ([`State::new_history_only`]), even if it has none waiting.

    pub fn is_history_only(&self) -> bool {

        self.deferred.is_some()

    }

        let mut refs: Vec<ObjectRef> = taken

        // Text blobs of inserts read without their lines, after the bases.

        let bases = refs.len();

        refs.extend(

            taken

                .iter()

                .flat_map(|(_, d)| d.texts.iter().map(|(r, _)| *r)),

        );

        };

        if blobs.len() != refs.len() {

            return Err(ObjectError::Schema("graph blobs: wrong count".into()));

        let mut texts = blobs.split_off(bases).into_iter();

        let mut blobs = blobs.into_iter();

        for (node, mut d) in taken.drain(..) {

            // Fill in the lines of inserts read without them, in order.

            let mut want = std::mem::take(&mut d.texts).into_iter();

            for (_, edits) in d.edits.iter_mut() {

                for e in edits.iter_mut() {

                    if let Edit::Insert { lines, .. } = e {

                        if lines.is_empty() {

                            let (_, count) = want.next().ok_or_else(|| {

                                ObjectError::Schema("an insert's text is missing".into())

                            })?;

                            let content = texts.next().ok_or_else(|| {

                                ObjectError::Schema("text blobs: wrong count".into())

                            })?;

                            *lines = crate::objects::text_lines(&content, count)?;

                        }

                    }

                }

            }

        self.add_known(h, change, Vec::new());

        h

    }

    /// Add a change read from the store under hash `h`, without hashing it

    /// again (for a version 2 change that means chunking all its text).

    /// `texts` names, in order, the inserts left without their lines (see

    /// [`crate::store::Store::get_change_lazy`]); only a history-only state

    /// takes them, and only for graphs it has not built.

    pub fn add_known(&mut self, h: ChangeHash, change: Change, texts: Vec<(ObjectRef, u32)>) {

            return;

        self.apply_with(h, change, texts);

                    texts: Vec::new(),

    fn apply_with(&mut self, h: ChangeHash, c: Change, texts: Vec<(ObjectRef, u32)>) {

            // History only: edits of files not built wait, grouped per file,

            // with the texts of inserts read without their lines.

            let mut texts = texts.into_iter();

            let mut per_node: HashMap<NodeId, (Vec<Edit>, Vec<TextRef>)> = HashMap::new();

                    e => {

                        let slot = per_node.entry(e.node()).or_default();

                        if matches!(&e, Edit::Insert { lines, .. } if lines.is_empty()) {

                            slot.1.extend(texts.next());

                        }

                        slot.0.push(e);

                    }

            for (node, (edits, node_texts)) in per_node {

                    Some(g) => {

                        assert!(

                            node_texts.is_empty(),

                            "a change read without its text applied to a built graph"

                        );

                        apply_file_edits(Arc::make_mut(g), h, edits)

                    }

                    None => {

                        let d = deferred.entry(node).or_default();

                        d.edits.push((h, edits));

                        d.texts.extend(node_texts);

                    }

        assert!(

            texts.is_empty(),

            "a change read without its text applied to a full state"

        );

    /// A change whose stored inserts are left without their lines (empty

    /// placeholders), with each one's text blob and line count in order:

    /// for history-only states, which read text only for the graphs they

    /// build.

    pub fn get_change_lazy(&self, r: &ObjectRef) -> Result<(Change, Vec<(ObjectRef, u32)>)> {

        let bytes = self.get_typed(r, ObjectType::Change)?;

        let mut texts = Vec::new();

        let c = Change::decode_with(&bytes, &mut |text, count| {

            texts.push((*text, count));

            Ok(Vec::new())

        })

        .map_err(|e| StoreError::Corrupt(*r, e.to_string()))?;

        Ok((c, texts))

    }

### Status after the commit (2026-09-29, oxygen#35)

A profile with the counting allocator (`--features alloc-stats`,

`OXY_TIMINGS=1`) of the first clean `status`, before it was killed:

| Phase | Time | Live after | Allocated |

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

| Load base history | 17.5 s | 3.2 GB | 16 GB in 96 M allocations |

| Read working copy | 79.5 s | 4.9 GB | 1.8 GB |

| Load and render base | killed at 14 GB | | |

It had two causes, and both are fixed:

- **History held every line.** A history-only state now reads a stored

  insert's text blob only when it builds that file's graph, and a load no

  longer hashes each change again, which for format 2 means chunking all

  its text.

- **The manifest had no graph keys.** They are now recorded at commit, so

  the next status neither reads nor renders an unchanged file.

| Clean `status` on the Linux tip | Time | Peak RSS |

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

| Before | killed at 14 GB | |

| After | 3.7 s | 768 MB |

| Git | 0.3 s | 31 MB |

Still to do: status to the 0.4 s and 300 MB target; `fsck` is killed at

14 GB; the first commit takes 57 s and 10.2 GB.