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 feature_auto_targets: Vec<(String, String)>,
    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.

feature_auto_targets: Vec<(String, String)>

The solid each no-target boolean ran into (brep_kernel::FeatureResult::boolean_auto_target): (feature id, solid name) in run order, only for the features whose boolean named no target and found the part’s ONLY solid. The feature panel shows it on the boolean’s target field as Auto: <name>. 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.