Struct SceneBuildReport 

pub struct SceneBuildReport {

    pub plugin_persistent_data: Vec<(String, Value)>,
    pub feature_errors: Vec<String>,
    pub unresolved: Vec<String>,
    pub feature_notes: Vec<String>,
    pub feature_fulfilment: Vec<(String, Fulfilment)>,
    pub feature_refusals: Vec<(String, KernelRefusal, Option<String>)>,
    pub feature_approximations: Vec<(String, Vec<Approximation>)>,
    pub display_errors: Vec<String>,
    pub feature_timings: Vec<(String, f64)>,
    pub feature_outputs: Vec<(String, Vec<String>)>,
    pub frames: Vec<(String, Frame)>,
    pub profiles: Vec<(String, SketchProfile)>,
    pub axes: Vec<(String, Axis)>,
    pub paths: Vec<(String, Vec<NurbsCurve>)>,
    pub points: Vec<(String, ScenePoint)>,
    pub wire_harness: Option<WireHarnessReport>,
    pub pmi: Option<PmiReport>,
    pub ports: Option<PortsReport>,
}

Non-fatal diagnostics from a scene build (mirrors the previous app’s run-history reporting: a failed feature halts the remaining features but the solids built so far still display — seeing what a failing history DID build is the point of the artifact).

Fields

plugin_persistent_data: Vec<(String, Value)>

Successful plugin callback state, committed with the accepted scene only.

feature_errors: Vec<String>

Per-feature hard errors, as "<feature id>: <message>".

unresolved: Vec<String>

Unresolved reference-selection names, as "<feature id>: <name>".

feature_notes: Vec<String>

What the kernel REPAIRED while building a feature, as "<feature id>: <what>" — today, a self-crossing the soundness acceptance split and re-trimmed rather than refused. Not an error: the feature SUCCEEDED, with a result the kernel changed on its way out, and a change the user cannot see is the one thing a repair must never be. #[serde(default)] keeps reports serialized before this field crossing the worker boundary.

feature_fulfilment: Vec<(String, Fulfilment)>

What a SUCCESSFUL feature did with what it was asked, when not everything (brep_kernel::FeatureResult::fulfilment): (feature id, fulfilment) in run order, only for the features that report one. A partial is a different answer from the one asked for, so the history tree shows it on the feature’s row and the run report carries it typed. #[serde(default)] for reports serialized before this field.

feature_refusals: Vec<(String, KernelRefusal, Option<String>)>

The kernel’s typed refusal for each feature that failed with one (brep_kernel::FeatureResult::refusal): (feature id, refusal, refused step) in run order — the class, stage and text feature_errors flattens to a line, and the motion step that refused when the feature records one (FeatureResult::refused_step). Features whose refusal is text only do not appear. Additive: #[serde(default)] for reports serialized before it, and omitted when empty.

feature_approximations: Vec<(String, Vec<Approximation>)>

The MEASURED approximations each SUCCESSFUL feature carries (brep_kernel::FeatureResult::approximations): (feature id, approximations) in run order, only for the features that carry any. The result stands and this says by how much, and why, it is not exact — the third kind of report beside a refusal (the result does not stand) and a fulfilment (what was done of what was asked); today the STEP import’s shell-closure gate (import.shell_closure) is the producer. Additive: #[serde(default)] for reports serialized before it, and omitted when empty.

display_errors: Vec<String>

Solids whose display payload (tessellation) failed, as "<solid name>: <message>" — the solid is skipped, not fatal.

feature_timings: Vec<(String, f64)>

Per-feature wall-clock execution time (feature id, milliseconds) in run order, carried through from the kernel’s brep_kernel::HistoryResult timings — the history tree’s “N ms” readout.

feature_outputs: Vec<(String, Vec<String>)>

Per-feature output solid names (feature id, [solid names]) in run order — the history tree’s read-only “Outputs” node.

frames: Vec<(String, Frame)>

Named plane FRAMES this run resolved (frame name, frame), in run order — every DATUM registers three ({id}:XY|XZ|YZ), every PLANE one ({id}), and a SKETCH its own plane ({id}). Surfaced here so the engine can DISPLAY the construction datum/plane frames (filtered to the D/P producing features) as first-class scene citizens — the resolved frames ride brep_kernel::FeatureResult::frames straight through, no kernel change.

profiles: Vec<(String, SketchProfile)>

Solved sketch PROFILES this run produced (sketch id, profile), in run order — every SKETCH feature publishes one under its own id. Surfaced here (exactly like Self::frames) so the engine can display each committed sketch as a SHEET SOLID (planar face + named boundary edges + corner vertices) via sketch_display_payload, no kernel-contract change.

axes: Vec<(String, Axis)>

Named axis LINES this run produced (axis name, line), in run order — a SKETCH publishes one per line geometry (construction included). Surfaced here (exactly like Self::frames/Self::profiles) so the engine can resolve a revolve/sweep axis reference to a world line at annotation-build time, fully headless. #[serde(default)] keeps older serialized reports (pre-axes) deserializing cleanly across the worker boundary.

paths: Vec<(String, Vec<NurbsCurve>)>

Named PATH chains this run produced (path name, curves), in run order — a SKETCH publishes its whole ordered chain under {id} and EACH model segment under {id}:G{gid}. Surfaced here (exactly like Self::profiles) so the engine can draw a committed sketch’s OPEN geometry: an open chain closes no region, so it publishes no profile, and before this the sheet builder had nothing to draw it from — an open sketch was invisible in 3D. #[serde(default)] keeps older serialized reports (pre-paths) deserializing cleanly across the worker boundary.

points: Vec<(String, ScenePoint)>

Named world POINTS this run produced (point name, point), in run order — a SKETCH publishes every solved point under {id}:P{pid} with its construction flag. Surfaced here (exactly like Self::paths) so the engine can draw a committed sketch’s STANDALONE points: a points-only sketch (a hole-placement sketch) has no segment and no profile, so before this the sheet builder had nothing to draw it from — it was invisible and unpickable in 3D. #[serde(default)] keeps older serialized reports (pre-points) deserializing cleanly across the worker boundary.

wire_harness: Option<WireHarnessReport>

The wire-harness tail’s routing report (endpoints, segments, one route per connection, bundles). Read RUNNER-SIDE like everything else here — the tail ran on the runner’s thread — and shipped so the harness panel reads it off the applied run. #[serde(default)] keeps older serialized reports deserializing across the worker boundary.

pmi: Option<PmiReport>

The PMI tail’s resolution of every view’s annotations (None when the document carries no pmi block).

ports: Option<PortsReport>

The PORTS tail’s resolution of the declared-ports block (None when the document declares none). Shipped for the same reason the two above are: the tail is not a feature, so its refused names and unresolved references reach no feature row — the Qualify panel reads them here.

Trait Implementations

impl Clone for SceneBuildReport

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 SceneBuildReport

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

Formats the value using the given formatter.

impl Default for SceneBuildReport

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SceneBuildReport

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SceneBuildReport

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

where __S: Serializer,

Serialize this value into the given Serde serializer.