Struct SceneNode 

pub struct SceneNode {

    pub id: SceneNodeId,
    pub parent: Option<SceneNodeId>,
    pub children: Vec<SceneNodeId>,
    pub depth: usize,
    pub kind: NodeKind,
    pub name: String,
    pub labels: String,
    pub status: PhaseStatus,
    pub op_count: usize,
    pub duration_secs: Option<f64>,
    pub op_names: Vec<String>,
    pub own_names: Vec<String>,
    pub seq: Option<usize>,
    pub yaml_path: Vec<PathSegment>,
    pub outcome: Option<PhaseOutcome>,
    pub active: bool,
}

One node in the scene tree.

Fields

id: SceneNodeId

parent: Option<SceneNodeId>

children: Vec<SceneNodeId>

depth: usize

kind: NodeKind

name: String

For Phase: the phase name. For Scope: a description like "for_each color=red" or "do_while empty".

labels: String

For Phase: dimensional labels (e.g. "k=10, table=fknn"). For Scope: empty (the description is in name).

status: PhaseStatus

op_count: usize

duration_secs: Option<f64>

op_names: Vec<String>

For Phase: the ordered list of op template names in this phase’s stanza (one entry per ParsedOp). Empty for Scope and Root. Populated at pre-map time so the TUI’s scenario view can drill into a phase and show its ops without having to reach back into the workload model.

own_names: Vec<String>

Names defined at this scope: own bindings, iter vars, and externs that the scope’s specs / op templates reference. Excludes inherited cascade-propagation names (workload params auto-injected at intermediate scopes solely so descendants see them). Populated from the scope’s installed kernel via program.own_output_names(). Empty for Root. Used by the TUI / dryrun renderer to show “what’s defined here” without listing every name that’s merely visible.

seq: Option<usize>

1-based sequence number assigned to Phase nodes at pre-map time, in DFS order. None for Scope and Root entries.

The TUI shows this as [N/total] next to the phase name and as phase X/Y in the header counter, so the operator can at any moment see which step of the planned scenario is in flight relative to the whole. The numbering is stable for the lifetime of one session (assigned once during pre-map), so a UI that displays “phase 47” on screen N and “phase 48” on screen N+1 is always referring to the same two phases — not a fresh re-numbering per draw.

yaml_path: Vec<PathSegment>

Fully-qualified structural location of this node in the workload YAML — outer-first chain of scenarios, for_each/for_combinations clauses, do-loops, and (terminal) the phase name itself. Populated for Phase nodes; ancestor Scope nodes carry partial paths (everything down to but not including the phase name).

Used by the checkpoint resume planner — yaml_path plus the leaf-first coord-path string is the per-phase identity tuple that decides whether a saved checkpoint entry applies to a freshly-pre-mapped phase. See SRD-44 §“Phase identity”.

outcome: Option<PhaseOutcome>

SRD-76 — structured terminal-state record. None while the phase is pending or running; populated exactly once at phase end by the executor’s set_phase_outcome call. Carries the per-phase PhaseStatus, wall-clock duration, and the chronological error list.

Co-existence with the legacy status / duration_secs fields: the legacy fields stay as the load-bearing renderer surface (TUI / stderr observer / scene-tree-prints) until Push 4 lands the new readouts that read this slot directly. set_phase_outcome keeps the two in sync; new consumers should read from here.

active: bool

Whether this node is active for execution under the session’s phases=<pattern> filter (default true). Set by the planning walker before any phase runs:

• Phase nodes get active = pattern.is_match(name) (or true when no pattern is set).
• Scope nodes are active iff any descendant phase is active; otherwise they’re elided from the execution walk along with their subtree.

Inactive nodes are still in the tree (so coordinate chains, scope-init kernels, and parent context stay intact for active siblings under the same scope) but the executor skips their phase activation.

Trait Implementations

impl Clone for SceneNode

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 SceneNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SceneNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SceneNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.