Struct ChildWatch 

pub struct ChildWatch { /* private fields */ }

What: The watcher of one child process. Why: One watch serves every wait on the same child: a long-lived reader marks one wait per request, a one-shot command marks one wait. Dropping the watch ends its thread and hands the longest quiet gap it saw to the ledger, if the watch was named.

In TS you’d write (pseudocode):

class ChildWatch implements Disposable { begin(); end(); get expired(): boolean }

Implementations

impl ChildWatch

pub fn start(waiting_for: &str, pid: u32, terms: WatchTerms) -> Self

Start watching pid, a child that holds no Git lock: see start_with_locks.

pub fn start_with_locks( waiting_for: &str, pid: u32, terms: WatchTerms, locks: LockLedger, ) -> Self

Start watching pid: waits marked with begin and end are announced as waiting for waiting_for, the child is ended when it shows no sign of work for the terms’ window, and the lock files the child leaves when it is ended are swept by locks. A watch whose thread cannot start watches nothing, and the waits it marks run unannounced and unended.

pub fn kept_as(self, step: &str) -> Self

Keep the longest quiet gap of this watch in the ledger under step when the watch is dropped.

pub fn never_stop(&self)

Announce the waits of this child but never end it for being quiet: a step that is not safe to run twice (a reference update, a commit Git builds) is ended in the middle of its write only by the person.

pub fn within(self, ceiling: Duration) -> Self

Give every wait of this child a ceiling: the child is ended when one wait has lasted this long, whatever it shows and whether or not a quiet child may be ended (owner, 2026-11-03: “nothing should ever wait forever or indefinitely”).

pub fn ceiling_hit(&self) -> bool

Whether the child was ended because its ceiling passed.

pub fn begin(&self)

Mark the start of a wait on the child.

pub fn end(&self)

Mark the end of the wait.

pub fn expired(&self) -> bool

Whether a wait showed no sign of work for the window and the child was ended.

pub fn limit(&self) -> Duration

The quiet window.

Trait Implementations

impl Drop for ChildWatch

Stops the watcher thread, waits for it, and keeps the longest quiet gap it saw.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.