Use the loaded state for last change, blame and tree rows (oxy-core log_for_path_of, blame_of, log_of): cold file pages no longer rebuild the state b19606f28101

        FileBody::Text(String::from_utf8_lossy(&bytes).into_owned())

    };

    let labels = head_labels(repo)?;

        .and_then(|h| loaded.state.get(&h).map(|meta| change_view(repo, &h, meta, loaded.state.heads().contains(&h), &labels)));

    let name = path.rsplit('/').next().unwrap_or(path).to_string();

    Ok(FileView {

}

/// The newest change touching `path` in the state, from a cache of 4 MiB.

    static C: std::sync::OnceLock<crate::render::cache::Lru<Last>> = std::sync::OnceLock::new();

    let cache = C.get_or_init(|| crate::render::cache::Lru::new(4 << 20));

    let key = state_path_key(b"last1", heads, path);

}

struct BlameLines(Vec<BlameLine>);

}

/// `Repo::blame_in`, cached by state and path (64 MiB).

    static C: std::sync::OnceLock<crate::render::cache::Lru<BlameLines>> = std::sync::OnceLock::new();

    let cache = C.get_or_init(|| crate::render::cache::Lru::new(64 << 20));

    let key = state_path_key(b"blame1", heads, path);

    let mut failure = None;

        }

    });

    if let Some(e) = failure {

    let snapshot = &loaded.snapshot;

    // Newest change touching each node, from one pass over the log.

    let mut newest: HashMap<oxy_core::ids::NodeId, (ChangeHash, u64)> = HashMap::new();

        let Ok(c) = repo.store().get_change(&e.hash) else { continue };

        let when = e.change.hlc.wall_ms;

        for node in c.tree_ops.iter().map(|o| o.node()).chain(c.edits.iter().map(|x| x.node())) {

pub fn blame(repo: &Repo, cache: &StateCache, target: RefTarget, path: &str, render_limit: u64) -> Result<Blame> {

    let heads = target.heads.clone();

    let file = file(repo, cache, target, path, render_limit)?;

    let mut before = HashMap::new();

    for l in &lines {

        before.entry(l.hash).or_insert_with(|| repo.store().get_change(&l.hash).ok().and_then(|c| state_spec(&c.deps)));