Struct ExplorationReport 

pub struct ExplorationReport {
    pub workflow: WorkflowKey,
    pub workflow_version: WorkflowVersion,
    pub limits: ExplorationLimits,
    pub states_explored: usize,
    pub transitions_simulated: usize,
    pub max_depth_reached: usize,
    pub truncated: bool,
    pub reached_phases: Vec<Value>,
    pub reached_outcomes: Vec<Value>,
    pub violations: Vec<ExplorationViolation>,
}

Everything one bounded exploration observed.

Fields

workflow: WorkflowKey

The workflow explored.

workflow_version: WorkflowVersion

The version that produced the projections.

limits: ExplorationLimits

The limits the search ran under.

states_explored: usize

Number of distinct states visited.

transitions_simulated: usize

Number of candidate commands simulated.

max_depth_reached: usize

Greatest depth reached.

truncated: bool

true when a limit stopped the search before the frontier was empty. A truncated report proves that nothing it visited is broken, not that nothing is; the unreachable-outcome check is skipped for it.

reached_phases: Vec<Value>

Canonical JSON of every phase projected by a reachable state, in the order first reached.

Why a count of states was not enough

states_explored and truncated say how much was looked at, never where. A workflow’s eleven required fields are eleven steps of a breadth-first search, and the standard budget ran out at depth eight: four phases of the workflow — the optional question, the summary, its rejection and the promotion — were never projected at all. Every invariant reported clean over half a workflow for months, and the catalogue check found nothing because it never reached the phase where something was wrong.

truncated did say so, and it is a blunt instrument: a workflow with a large collection half truncates every time, so the flag stops carrying information. The question worth asking is whether the search saw every phase, and that is Self::reached_phase.

reached_outcomes: Vec<Value>

Canonical JSON of every outcome projected by a reachable state, in the order first reached.

violations: Vec<ExplorationViolation>

Every rule broken, in the order found.

Implementations

impl ExplorationReport

pub fn is_clean(&self) -> bool

Returns true when nothing was violated.

pub fn reached_phase<T: Serialize + ?Sized>(&self, phase: &T) -> bool

Returns true when a reachable state projected phase.

What turns “no violations found” into “no violations found, and here is where I looked”. Assert it for every phase a workflow declares, and a budget that stops short becomes a failing test instead of a clean one.

pub fn reached_outcome<T: Serialize + ?Sized>(&self, outcome: &T) -> bool

Returns true when a reachable state projected outcome.

pub fn describe(&self) -> String

A multi-line summary suitable for an assertion message: the counters, then every violation with its state and shortest path.

Trait Implementations

impl Clone for ExplorationReport

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 ExplorationReport

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExplorationReport

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ExplorationReport

impl PartialEq for ExplorationReport

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ExplorationReport

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 ExplorationReport