Struct LogDiffReport 

pub struct LogDiffReport {

    pub schema: u64,
    pub verdict: LogDiffVerdict,
    pub refusal: Option<String>,
    pub selected_messages: LogDiffMessageCounts,
    pub records: LogDiffRecords,
    pub inputs: Option<LogDiffInputs>,
    pub comparison: LogDiffComparison,
    pub follow_stopped_because: Option<String>,
    pub first_divergent_record: Option<usize>,
    pub matched_prefix_records: Option<usize>,
    pub first_divergent_syscall: Option<u64>,
    pub first_divergent_scheduler_turn: Option<u64>,
    pub first_divergent_virtual_nanoseconds: Option<u64>,
    pub first_divergent_left_message: Option<String>,
    pub first_divergent_right_message: Option<String>,
}

Fields

schema: u64

verdict: LogDiffVerdict

refusal: Option<String>

selected_messages: LogDiffMessageCounts

records: LogDiffRecords

inputs: Option<LogDiffInputs>

Older reports did not identify their captured bytes. They remain readable, but cannot establish current cross-backend parity.

comparison: LogDiffComparison

follow_stopped_because: Option<String>

first_divergent_record: Option<usize>

matched_prefix_records: Option<usize>

Number of leading selected messages that are equal on both sides, in the units of Self::selected_messages (schema 2 and later).

On a match it equals both selected counts. After a divergence it is the count of selected messages before the first difference; when one selected stream is a strict prefix of the other it is the shorter length, because the extra messages are the divergence. It is None when nothing was measured: a refusal, a pending report, an empty comparison, or a schema-1 report.

This is deliberately not first_divergent_record - 1: first_divergent_record is a raw log-record index that also counts records the comparison did not select, and records.compared is min(available_left, available_right), a bound on what was read rather than a matched length.

Omitted rather than written as null when absent, so that a schema-1 report re-serializes to exactly the bytes it was read from. Stored ledger rows hash the re-serialized typed witness into their evidence identity; writing a new null key would change every historical hash.

first_divergent_syscall: Option<u64>

first_divergent_scheduler_turn: Option<u64>

first_divergent_virtual_nanoseconds: Option<u64>

first_divergent_left_message: Option<String>

first_divergent_right_message: Option<String>

Implementations

impl LogDiffReport

pub fn require_readable_schema(&self) -> Result<(), String>

Refuse a schema this reader does not know. Every reader of a stored report goes through this before trusting its fields.

pub fn require_consistent_matched_prefix(&self) -> Result<(), String>

Check Self::matched_prefix_records against the verdict and counts.

Schema 1 predates the field, so it must be absent there. From schema 2 a comparison verdict must carry it, a match must have matched every selected message on both sides, and a divergence must have matched fewer than the longer side selected. A comparison that selected nothing on either side measured nothing, so it carries no prefix whatever its verdict: 0 of 0 is not a full match.

The schema is checked here too, so that a caller using this check on its own cannot have an unknown schema read as schema 2.

pub fn require_cross_backend_evidence(&self) -> Result<(), String>

Require the exact non-lossy policy used for a cross-backend parity verdict. A report may be typed yet still be unsuitable (empty, truncated, relaxed, or produced under another record envelope).

Trait Implementations

impl Clone for LogDiffReport

fn clone(&self) -> LogDiffReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogDiffReport

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LogDiffReport

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LogDiffReport

impl PartialEq for LogDiffReport

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for LogDiffReport

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 LogDiffReport