Struct FeatureResult 

pub struct FeatureResult {

    pub id: String,
    pub feature_type: String,
    pub added: Vec<AddedSolid>,
    pub removed: Vec<String>,
    pub error: Option<String>,
    pub unresolved: Vec<String>,
    pub reused: bool,
    pub profiles: Vec<(String, SketchProfile)>,
    pub frames: Vec<(String, Frame)>,
    pub axes: Vec<(String, Axis)>,
    pub paths: Vec<(String, Vec<NurbsCurve>)>,
    pub path_segment_names: Vec<(String, Vec<Option<String>>)>,
    pub points: Vec<(String, ScenePoint)>,
    pub components: Vec<ComponentRecord>,
}

Fields

id: String

feature_type: String

added: Vec<AddedSolid>

removed: Vec<String>

Names of prior solids this feature consumed/superseded (removed from the scene-map; their handles are freed by the loop).

error: Option<String>

Set on a hard failure. execute_history records it and HALTS the remaining features (mirrors the abort-on-error loop). Never a panic.

unresolved: Vec<String>

reference_selection names this feature could not resolve against the scene-map. NOT an error/halt — the caller runs a snapshot-repair pass and re-dispatches (migration-plan Stage 5 gate).

reused: bool

True when this result was REPLAYED from the incremental history cache (the feature and everything it references are unchanged since the last run). The handles are the same resident solids — the caller can skip re-tessellation.

profiles: Vec<(String, SketchProfile)>

Sketch profiles this feature produced (a SKETCH feature emits one under its name; solid features emit none). INTERNAL side-channel: #[serde(skip)] so it never crosses the wasm boundary to the caller — [SceneMap::apply] ingests it into scene.profiles for downstream profile-consumers (extrude/revolve/…).

frames: Vec<(String, Frame)>

Named plane frames this feature produced (DATUM emits three, PLANE one). Same INTERNAL #[serde(skip)] side-channel — ingested into scene.frames so a later SKETCH can resolve its plane by name, fully headless.

axes: Vec<(String, Axis)>

Named axis lines this feature produced (a SKETCH emits one per line geometry). Same INTERNAL #[serde(skip)] side-channel — ingested into scene.axes so a later revolve/sweep can resolve its axis by name.

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

Named path chains this feature produced (a SKETCH publishes its ordered open/closed geometry chain). Same INTERNAL #[serde(skip)] side-channel — ingested into scene.paths for sweep/path_sweep/rib trajectory resolution.

path_segment_names: Vec<(String, Vec<Option<String>>)>

The SOURCE NAME of each curve in a published path chain, parallel to the matching Self::paths entry ({sketchId}:G{gid} for a sketch segment, None for a curve with no name behind it). Same INTERNAL #[serde(skip)] side-channel — ingested into scene.path_segment_names so a multi-segment consumer (the SWEEP) can name the geometry each PATH SEGMENT built after that segment, instead of after its position in the chain.

points: Vec<(String, ScenePoint)>

Named world points this feature produced (a SKETCH publishes every point as {sketchId}:P{pid}, construction flag included — see ScenePoint). Same side-channel — ingested into scene.points for hole-center / placement resolution and drawn by the committed-sketch display.

components: Vec<ComponentRecord>

Component records this feature produced (an ACOMP feature emits one per instance; its members ride added like any solids). Same INTERNAL #[serde(skip)] side-channel — ingested into scene.components so the component surface (component.rs) resolves against the live scene.

Implementations

impl FeatureResult

pub fn empty(id: impl Into<String>, feature_type: impl Into<String>) -> Self

An empty successful result (no solids, no error) — the shape a non-solid pass-through feature returns.

pub fn error( id: impl Into<String>, feature_type: impl Into<String>, message: impl Into<String>, ) -> Self

A hard failure. Halts the history loop.

pub fn pass_through( id: impl Into<String>, feature_type: impl Into<String>, ) -> Self

A non-solid construction feature (datum/plane/sketch/spline/port/helix): a descriptor pass-through with no resident handle. The loop continues.

pub fn not_yet_migrated( id: impl Into<String>, feature_type: impl Into<String>, ) -> Self

A solid-producing (or no-kernel) feature not yet ported to Rust. Halts the loop with a clear message — replaced when a fan-out agent implements the feature’s features/<feat>.rs.

Trait Implementations

impl Clone for FeatureResult

fn clone(&self) -> FeatureResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FeatureResult

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

Formats the value using the given formatter.

impl Serialize for FeatureResult

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

where __S: Serializer,

Serialize this value into the given Serde serializer.