Struct CommandLine 

pub struct CommandLine {
    pub line: usize,
    pub command: String,
    pub exit: Option<i32>,
}

One executed shell command recovered from OSC-133 marks (#166), for screen-reader command navigation. The consumer jumps prompt-to-prompt over these and announces command + a success/fail signal from exit.

Fields

line: usize

The command’s jump anchor as a document line — the logical-line index of the CommandStart(B) mark within Term::accessible_text, so the consumer reveals the right row of the accessible view (soft-wrapped rows collapse to one logical line). This is core’s analog of VSCode’s bufferToEditorLineMapping; the frame-mode web side has no wrap info to map it itself.

It is an index into a document, so it is only meaningful together with the document it indexes — the one Term::accessible_text returns at the same instant, on the primary screen. Neither half is expressible as a number on this struct (#743), and they are the two that recur; they are not a proof of sufficiency. The hedge was earned: a mark whose row is erased in place also answers about content that is gone — on the primary screen, at one instant, and a re-ask reproduces it, so neither half below reaches it. That was #750, a defect in mark lifetime rather than in dating, and it is fixed at the lifetime: ED now retires the marks on each whole row it blanks, and the command’s text and exit are frozen when the stream reveals them rather than re-read from cells (see Term::command_lines). One residue is deliberate and belongs to this field — EL/ECH retire nothing, so a mark can still name a row they blanked, and this line then resolves onto it:

• the instant. No scalar this engine publishes dates a document line, and the reason is not one axis but two. Eviction moves it by the number of evicted line-ends, which equals the row count except when an evicted row soft-wraps into the next — measured, one eviction took the absolute lines [12, 12, 12, 13] → [11, 11, 11, 12] while this line stayed at 11, and the very next eviction moved both. And flipping a row’s wrap bit, which ordinary output does, moves this line while the absolute lines, evicted_total and marker_epoch all stay put — a motion the absolute space does not have. Carrying the instant is therefore buildable but expensive: a line-end counter and a generation of its own. ADR-0029 defers it (alternative D) and takes the re-ask discharge, which D3 grants this surface on its own merits;
• the screen. The document is [scrollback ++ primary], always. While the alt screen is up Term::accessible_text returns the alt document, and this line indexes the other one. When the alt screen is the taller of the two the index still resolves, onto unrelated content — so this is not a bounds problem a caller can check its way out of.

So: ask for both together, keep them together, and re-ask rather than rebase.

command: String

The typed command text, prompt- and output-excluded (B→C columns).

Frozen at the 133;C that closed the command (#750), not re-read from the cells when you ask. Those cells are not reserved for it: a plain overwrite, ICH, DCH and an erase were each measured making the recorded column range name somebody else’s content, and only the last of the four is a verb any mark-lifetime rule could reach. Bounded at MAX_COMMAND_TEXT chars.

exit: Option<i32>

The CommandFinished(D) exit code, if the shell reported one and the command has finished.

Recorded when 133;D is parsed (#750), onto the mark that closed the command — not paired here at query time. It lives in no cell, so nothing on screen can reconstruct it, and pairing over survivors re-parented a code onto the previous command as soon as a disposal broke the run.

Trait Implementations

impl Clone for CommandLine

fn clone(&self) -> CommandLine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommandLine

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

Formats the value using the given formatter.

impl Eq for CommandLine

impl PartialEq for CommandLine

fn eq(&self, other: &CommandLine) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CommandLine