Struct CommitAnswer 

pub struct CommitAnswer {

    pub oid: GitOid,
    pub run: RunId,
    pub actor: Address,
    pub model: String,
    pub effort: Option<Effort>,
    pub seq: Seq,
    pub at: TimeMs,
    pub session: Option<SessionName>,
    pub lineage: Vec<RunId>,
    pub spent: UsdMicros,
    pub previous: Option<CommitAt>,
    pub parents: Option<Vec<GitOid>>,
    pub message: Option<String>,
    pub b3: Option<B3Hash>,
}

Which run wrote one commit, in the words the commit’s own git trailers use.

Four of the five trailers appear here; Sprawling-City does not, because whoever asked this question already holds the city. seq is what the trailers cannot carry: where in the one history the line announcing this commit sits, so a reader can go on from there.

Fields

oid: GitOid

run: RunId

actor: Address

Sprawling-Actor: the address the run worked at.

model: String

Sprawling-Model. Empty when the record predates the city writing the model down: an absent id beats an invented one.

effort: Option<Effort>

Sprawling-Effort. Absent leaves the choice to the provider, which is not the same fact as Effort::None.

seq: Seq

Where the line announcing this commit sits in the one history.

at: TimeMs

When that line was written: the record’s own clock, so a list of commits reads as a day rather than as a column of numbers.

session: Option<SessionName>

What a person called this line of work, read off the room the actor worked in. Absent when the run worked at a building’s own address, which is a run nobody opened a session for.

lineage: Vec<RunId>

This run first, then each run it replaced by succession, back to the first. One entry for a run that replaced nobody.

spent: UsdMicros

What the run that wrote this commit has been billed, whole.

The run’s total rather than this commit’s share: a commit is a checkpoint and nothing prices a checkpoint, so dividing the run’s spend between its checkpoints would be a number nobody measured. Zero for a run no priced call is attributed to.

previous: Option<CommitAt>

The commit the same run announced last before this one; None for the run’s first. The two bound what this commit is the result of: Query::Changes from previous.oid to oid says which files moved, and Query::RunHistory read back from seq to previous.seq says which calls the run made meanwhile - as candidates, since another run in the same building may have written in that span too.

parents: Option<Vec<GitOid>>

The commit object’s own parents, in git’s order: an empty list is a root commit. None when the city has no repository beside it, the repository does not hold this object, or it could not be read - the other facts still stand without it.

message: Option<String>

The commit object’s own message, trailers included, read when the parents are and absent for the same reasons, or when it is not UTF-8 (crates/wire/spec/Answer/Commits.lean §8-54).

b3: Option<B3Hash>

The BLAKE3 of the canonical bytes of the line that announced this commit - the digest the next line of the chain carries as prev, not this line’s own prev. A person finds the line by it and checks it was not altered. None only in a frame from a city written before it was answered (crates/wire/Spec.lean §8-78).

Trait Implementations

impl Clone for CommitAnswer

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommitAnswer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommitAnswer

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for CommitAnswer

impl PartialEq for CommitAnswer

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CommitAnswer

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CommitAnswer