Struct SectionIndex 

pub struct SectionIndex {
    pub sections: Vec<Section>,
    pub branch: String,
    pub ahead: usize,
    pub behind: usize,
    pub bisect: Option<BisectState>,
    pub in_flight: Option<InFlightOp>,
    pub upstream: Option<String>,
}

Fields

sections: Vec<Section>

branch: String

ahead: usize

behind: usize

bisect: Option<BisectState>

MG.21f: the bisect in progress, if any.

Repo state rather than a section — this struct already carries branch / ahead / behind for the same reason, and the headerline is where lattice answers “what state is this repo in” (it already carries REBASE IN PROGRESS). A SectionKind would have been the wrong home: every SectionEntry variant carries diff-bearing-file invariants — a path, a stage operation, an expandable patch — and a bisect has none of them.

in_flight: Option<InFlightOp>

MG: the multi-commit operation the repo is stopped inside — merge, rebase, cherry-pick, revert, am — or None when idle.

Repo state like bisect, and here for the same reason: the status buffer is where a user lands to resolve conflicts, and without this it showed unmerged files with nothing saying WHAT they are unmerged from or how to get out.

upstream: Option<String>

The upstream ref this branch tracks (origin/main), when it has one, for the Unmerged into <upstream> header.

Repo state like branch / ahead / behind, and here for the same reason: it is a fact about the repository that a section header renders, not a property of any entry.

Implementations

impl SectionIndex

pub fn format_buffer(&self) -> String

pub fn format_buffer_styled(&self) -> (String, Vec<Vec<StyledSpan>>)

pub fn format_buffer_styled_with( &self, inline: impl Fn(&SectionEntry, SectionKind) -> Option<(String, String)>, lang_registry: Option<&Arc<LangRegistry>>, ) -> (String, Vec<Vec<StyledSpan>>, Vec<(String, usize)>, Vec<Vec<RefineSpan>>)

MG.18d: format the buffer with each entry’s diff inlined where inline supplies one.

A refresh replaces the whole buffer, so any expansion the user had open dies with it — which at hunk granularity means losing your place after every single s. Rebuilding with the expansions is what lets the entry survive: one edit, one span vector, no splice arithmetic against a buffer that is being replaced underneath it, and no collapse-then-expand flicker.

inline(entry, kind) returns (key, diff_text) for an entry that should come back expanded. The returned Vec<(key, line_count)> is the rebuilt expansion bookkeeping — counts are recomputed rather than carried, because staging a hunk makes the diff shorter. DS-fix (2026-08-12): lang_registry is what makes a refreshed expansion look like a freshly-opened one. None degrades to the flat classifier, the same designed degradation hunk_syntax::diff_spans documents — a harness without the grammar service renders the diff the way it always did.

Trait Implementations

impl Clone for SectionIndex

fn clone(&self) -> SectionIndex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SectionIndex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SectionIndex

fn default() -> SectionIndex

Returns the “default value” for a type.