Enum StepBound 

pub enum StepBound {
    EndAt(Duration),
    LeaveRunning {
        after: Duration,
        extra: Duration,
    },
    Unbounded,
}

What: How long a watched step is waited for, and what happens at the end. Why: A step that can be run twice is ended at a ceiling (owner, 2026-11-03: “nothing should ever wait forever or indefinitely”). A write in place that cannot be run twice is never ended (owner, 2026-11-04: “Never cut a branch write (Recommended)”): the command that started it returns at its own bound plus a short extra wait with an error that says the result is not known, and the step is left running (owner, commit protocol revision 12, “Short extra wait (Recommended)”); only the commit service’s landing thread, whose clients are told through the protocol, waits for it without a bound.

In TS you’d write (pseudocode):

type StepBound = { kind: 'end-at'; ms } | { kind: 'leave-running'; afterMs; extraMs } | { kind: 'unbounded' };

Variants

EndAt(Duration)

The step is ended, with its whole process tree, when it has run this long, whatever it shows.

LeaveRunning

The command stops waiting after plus extra after the step began and returns an error saying the result is not known; the step is left running and reaped when it ends.

Fields

after: Duration

The command’s own bound.

extra: Duration

The short extra wait for the write the step started.

Unbounded

The step is waited for as long as it lives.

Trait Implementations

impl Clone for StepBound

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StepBound

impl Debug for StepBound

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

Formats the value using the given formatter.

impl Eq for StepBound

impl PartialEq for StepBound

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for StepBound