SOLIDWORKS Bridge

@@ -66,6 +66,324 @@ pub fn describe(revision: Option<&str>) -> serde_json::Value {     }) } +// ---------------------------------------------------------------------------+// WHAT HAS BEEN MEASURED LIVE (0.10.4) — the ONE table step results+// (`proven`), swx_selftest and swx_describe all report from.+//+// A variant is MEASURED when a live check built it on a real SOLIDWORKS and+// the geometry read back matched (docs/LIVE-RESULTS.md). Anything not in this+// table, or in it with no measurement, is UNMEASURED and says so. The+// grain is the SOLIDWORKS call shape, not the op name: a boss whose direction+// flag is reversed is a different call from the default one, and no live+// boss has run that way yet.+// ---------------------------------------------------------------------------++/// One live run of the modelling battery.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub struct Measurement {+    pub year: u32,+    pub major: u32,+    pub edition: &'static str,+    pub date: &'static str,+    pub bridge: &'static str,+}++impl Measurement {+    pub fn to_json(&self) -> serde_json::Value {+        serde_json::json!({"solidworks": self.year, "major": self.major, "edition": self.edition, "date": self.date, "bridge": self.bridge})+    }+}++/// 2026-10-14, bridge 0.10.3, SOLIDWORKS 2026 (major 34, 3DEXPERIENCE+/// "Connected"): tools/dsl-live-check.py 30/30 and swx_selftest+/// {level:"write"} 43 passed / 0 failed / 1 skipped (docs/LIVE-RESULTS.md).+pub const LIVE_2026_10_14: Measurement = Measurement { year: 2026, major: 34, edition: "connected", date: "2026-10-14", bridge: "0.10.3" };++const M2026: &[Measurement] = &[LIVE_2026_10_14];+const UNMEASURED: &[Measurement] = &[];++/// One variant of one DSL op, and where it was measured live.+pub struct OpFact {+    pub id: &'static str,+    pub what: &'static str,+    /// The live checks that measured it (T-ids of tools/dsl-live-check.py and+    /// swx_selftest {level:"write"}), or why it has none.+    pub checks: &'static str,+    pub measured: &'static [Measurement],+}++pub const OP_FACTS: &[OpFact] = &[+    OpFact { id: "new_part", what: "a new part document", checks: "every check", measured: M2026 },+    OpFact { id: "new_assembly", what: "a new assembly document", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "sketch.plane.front", what: "a sketch on Front Plane", checks: "T01 T03 T10 T14 T27", measured: M2026 },+    OpFact { id: "sketch.plane.top", what: "a sketch on Top Plane", checks: "T02 T13 T24 T30", measured: M2026 },+    OpFact { id: "sketch.plane.right", what: "a sketch on Right Plane (its axes are the documented convention, not a measurement)", checks: "no live check sketches on Right Plane", measured: UNMEASURED },+    OpFact { id: "sketch.plane.named", what: "a sketch on a named plane other than Front/Top/Right", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "sketch.offset.top.positive", what: "a sketch on a plane offset + from Top Plane", checks: "T04 T24", measured: M2026 },+    OpFact { id: "sketch.offset.top.negative", what: "a sketch on a plane offset − from Top Plane (keeps Top Plane's axes)", checks: "T05 T26", measured: M2026 },+    OpFact { id: "sketch.offset.other", what: "a sketch on a plane offset from Front Plane, Right Plane or a named plane", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "sketch.face.top", what: "a sketch on a face parallel to Top Plane, picked by a point (the top face, and the bottom face hidden in an iso view)", checks: "T06 T20 T21 T25 T28 T32", measured: M2026 },+    OpFact { id: "sketch.face.side", what: "a sketch on a face parallel to Front or Right Plane", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "sketch.rect", what: "a rectangle (corner or center anchor)", checks: "T01 T02 T03", measured: M2026 },+    OpFact { id: "sketch.circle", what: "a circle", checks: "T04 T06 T30", measured: M2026 },+    OpFact { id: "sketch.multiProfile", what: "several profiles in one sketch (a ring, disjoint rectangles, the LEGO tubes)", checks: "T13 T14 T24", measured: M2026 },+    OpFact { id: "extrude.one", what: "a boss one way (the plane's normal, or outward from a face)", checks: "T01 T06 T25 and every base block", measured: M2026 },+    OpFact { id: "extrude.one.reversed", what: "a boss whose direction flag is reversed (reverse:true)", checks: "no live boss has run reversed: every one went the default way", measured: UNMEASURED },+    OpFact { id: "extrude.both", what: "a boss both ways (depthMm and depth2Mm)", checks: "T10", measured: M2026 },+    OpFact { id: "extrude.midPlane", what: "a boss symmetric about the sketch plane", checks: "T11", measured: M2026 },+    OpFact { id: "extrude.one.throughAll", what: "a boss through all, one way", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "extrude.both.throughAll", what: "a boss through all, both ways", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "cut.one", what: "a cut one way, the default direction (the plane's −normal, into a face)", checks: "T07 (nothing on that side: the step failed, as it must) and T27's first direction", measured: M2026 },+    OpFact { id: "cut.one.reversed", what: "a cut one way, reversed (reverse:true)", checks: "T08 T24", measured: M2026 },+    OpFact { id: "cut.one.throughAll.reversed", what: "a cut through all, reversed", checks: "T09", measured: M2026 },+    OpFact { id: "cut.both", what: "a cut both ways (depthMm along the cut's own direction, depth2Mm the other)", checks: "T27", measured: M2026 },+    OpFact { id: "cut.midPlane", what: "a cut symmetric about the sketch plane", checks: "T12", measured: M2026 },+    OpFact { id: "select.multiSelectTyped", what: "the picked entities selected by MultiSelect2 with a typed object array", checks: "11 of 11 live selections (T06 T16-T21 T25 T28-T30)", measured: M2026 },+    OpFact { id: "select.entitySelect4", what: "a picked entity selected by IEntity::Select4 (the ladder's 2nd rung)", checks: "never needed live: the first rung worked", measured: UNMEASURED },+    OpFact { id: "select.selectByRay", what: "a picked entity selected by SelectByRay (the ladder's 3rd rung)", checks: "never needed live: the first rung worked", measured: UNMEASURED },+    OpFact { id: "select.selectByIdAtPoint", what: "a picked entity selected by SelectByID2 at the point, through the view (the last rung)", checks: "never needed live: the first rung worked", measured: UNMEASURED },+    OpFact { id: "fillet.allOfFeature", what: "a fillet on every edge of a feature (a box's 12, a cylinder's 2)", checks: "T17 T30", measured: M2026 },+    OpFact { id: "fillet.atPoints", what: "a fillet on edges picked by points", checks: "T32 (swx_selftest)", measured: M2026 },+    OpFact { id: "fillet.FeatureFillet3", what: "the fillet made by IFeatureManager::FeatureFillet3", checks: "T17 T30 T32", measured: M2026 },+    OpFact { id: "fillet.createDefinition", what: "the fillet made by the CreateDefinition(swFmFillet) fallback", checks: "never needed live: FeatureFillet3 worked", measured: UNMEASURED },+    OpFact { id: "chamfer.atPoints", what: "a chamfer on edges picked by points", checks: "T18", measured: M2026 },+    OpFact { id: "chamfer.allOfFeature", what: "a chamfer on every edge of a feature", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "shell.inward", what: "a shell inward, removing faces picked by points (the top face, and the bottom face hidden in an iso view)", checks: "T19 T29", measured: M2026 },+    OpFact { id: "shell.outward", what: "a shell outward", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "linear_pattern.x", what: "a linear pattern along X, one direction (positive or negative spacing)", checks: "T20 T28", measured: M2026 },+    OpFact { id: "circular_pattern.y", what: "a circular pattern about Y", checks: "T21", measured: M2026 },+    OpFact { id: "set_appearance.part", what: "a colour on the part (or on the one body of a single-body part)", checks: "T15 T24", measured: M2026 },+    OpFact { id: "set_appearance.face", what: "a colour on one face picked by a point", checks: "T16", measured: M2026 },+    OpFact { id: "set_appearance.body", what: "a colour on one body of a multi-body part", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "set_material", what: "a material from the SOLIDWORKS library (the body's density follows it)", checks: "T22 T24", measured: M2026 },+    OpFact { id: "set_material.reappliesAppearance", what: "a material after a colour: the bridge re-applies the colour", checks: "T31 (swx_selftest)", measured: M2026 },+    OpFact { id: "set_prop", what: "a custom property", checks: "T24", measured: M2026 },+    OpFact { id: "save_as", what: "save_as as a script step", checks: "not in the live battery (swx_save_as, the verb, is)", measured: UNMEASURED },+    OpFact { id: "rebuild", what: "rebuild as a script step", checks: "not in the live battery", measured: UNMEASURED },+    OpFact { id: "zoom_fit", what: "zoom_fit as a script step", checks: "not in the live battery", measured: UNMEASURED },+];++pub fn op_fact(id: &str) -> Option<&'static OpFact> {+    OP_FACTS.iter().find(|f| f.id == id)+}++/// The labels the selection ladder reports (`modeling::Rung::label`), to fact ids.+fn rung_fact(label: &str) -> &'static str {+    use crate::modeling::Rung;+    for (r, id) in [+        (Rung::MultiSelectTyped, "select.multiSelectTyped"),+        (Rung::EntitySelect4, "select.entitySelect4"),+        (Rung::SelectByRay, "select.selectByRay"),+        (Rung::SelectByIdAtPoint, "select.selectByIdAtPoint"),+    ] {+        if label == r.label() {+            return id;+        }+    }+    "select.unknown"+}++fn axis_name(a: crate::script::Axis) -> &'static str {+    match a {+        crate::script::Axis::X => "x",+        crate::script::Axis::Y => "y",+        crate::script::Axis::Z => "z",+    }+}++fn plane_key(name: &str) -> &'static str {+    match crate::modeling::default_index(name) {+        Some(0) => "front",+        Some(1) => "top",+        Some(2) => "right",+        _ => "named",+    }+}++/// THE VARIANTS ONE STEP EXERCISED — from the op as written and from what+/// SOLIDWORKS was actually asked (the result's direction flag, route and+/// selection rung).+pub fn op_variants(op: &crate::script::Op, result: &serde_json::Value) -> Vec<String> {+    use crate::script::{AppearanceTarget, Direction, EdgeSel, Op, PlaneRef};+    let mut v: Vec<String> = Vec::new();+    match op {+        Op::NewPart => v.push("new_part".into()),+        Op::NewAssembly => v.push("new_assembly".into()),+        Op::Sketch { plane, entities, .. } => {+            v.push(match plane {+                PlaneRef::Named(n) => format!("sketch.plane.{}", plane_key(n)),+                PlaneRef::Offset { from, offset } => match plane_key(from) {+                    "top" => format!("sketch.offset.top.{}", if *offset < 0.0 { "negative" } else { "positive" }),+                    _ => "sketch.offset.other".into(),+                },+                PlaneRef::Face { .. } => {+                    let from = result.pointer("/resolvedPlane/offsetFrom").and_then(|f| f.as_str()).unwrap_or("");+                    if plane_key(from) == "top" { "sketch.face.top".into() } else { "sketch.face.side".into() }+                }+            });+            if entities.iter().any(|e| matches!(e, crate::script::Entity::Rect { .. })) {+                v.push("sketch.rect".into());+            }+            if entities.iter().any(|e| matches!(e, crate::script::Entity::Circle { .. })) {+                v.push("sketch.circle".into());+            }+            if entities.len() > 1 {+                v.push("sketch.multiProfile".into());+            }+        }+        Op::Extrude(e) | Op::Cut(e) => {+            let kind = if matches!(op, Op::Cut(_)) { "cut" } else { "extrude" };+            let dir = match e.direction {+                Direction::One => "one",+                Direction::Both => "both",+                Direction::MidPlane => "midPlane",+            };+            // The flag SOLIDWORKS was given (the COM host reports it); the+            // caller's `reverse` where a backend does not.+            let reversed = result.pointer("/dir/value").and_then(|d| d.as_bool()).unwrap_or(e.reverse);+            let mut id = format!("{kind}.{dir}");+            if e.through_all {+                id.push_str(".throughAll");+            }+            if reversed {+                id.push_str(".reversed");+            }+            v.push(id);+        }+        Op::Fillet { edges, .. } | Op::Chamfer { edges, .. } => {+            let kind = if matches!(op, Op::Fillet { .. }) { "fillet" } else { "chamfer" };+            v.push(format!("{kind}.{}", if matches!(edges, EdgeSel::AtPoints(_)) { "atPoints" } else { "allOfFeature" }));+            if kind == "fillet" {+                match result.get("route").and_then(|r| r.as_str()) {+                    Some("FeatureFillet3") | None => v.push("fillet.FeatureFillet3".into()),+                    Some(_) => v.push("fillet.createDefinition".into()),+                }+            }+        }+        Op::Shell { outward, .. } => v.push(if *outward { "shell.outward".into() } else { "shell.inward".into() }),+        Op::LinearPattern { dirs, .. } => {+            let axes: Vec<&str> = dirs.iter().map(|d| axis_name(d.0)).collect();+            v.push(format!("linear_pattern.{}", axes.join("+")));+        }+        Op::CircularPattern { axis, .. } => v.push(format!("circular_pattern.{}", axis_name(*axis))),+        Op::SetAppearance { target, .. } => v.push(match target {+            AppearanceTarget::Part => "set_appearance.part".into(),+            AppearanceTarget::FaceAt(_) => "set_appearance.face".into(),+            // A single-body part is coloured at the part level (the route says so).+            AppearanceTarget::Body(_) => {+                if result.get("route").and_then(|r| r.as_str()).map(|r| r.starts_with("part")).unwrap_or(false) {+                    "set_appearance.part".into()+                } else {+                    "set_appearance.body".into()+                }+            }+        }),+        Op::SetMaterial { .. } => {+            v.push("set_material".into());+            if result.get("appearanceReapplied").and_then(|a| a.as_array()).map(|a| !a.is_empty()).unwrap_or(false) {+                v.push("set_material.reappliesAppearance".into());+            }+        }+        Op::SetProp { .. } => v.push("set_prop".into()),+        Op::SaveAs { .. } => v.push("save_as".into()),+        Op::Rebuild => v.push("rebuild".into()),+        Op::ZoomFit => v.push("zoom_fit".into()),+    }+    // The selection rung(s), wherever the step reports them.+    for at in ["/selectedVia", "/edges/selectedVia", "/resolvedPlane/selectedVia"] {+        match result.pointer(at) {+            Some(serde_json::Value::String(s)) => v.push(rung_fact(s).into()),+            Some(serde_json::Value::Array(a)) => {+                for s in a.iter().filter_map(|s| s.as_str()) {+                    let id = rung_fact(s).to_string();+                    if !v.contains(&id) {+                        v.push(id);+                    }+                }+            }+            _ => {}+        }+    }+    v+}++/// `proven` for a step that exercised `variants`, on the SOLIDWORKS whose+/// major version is `major`: LIVE only when every variant was measured on+/// that very release.+pub fn proof(variants: &[String], major: Option<u32>) -> serde_json::Value {+    let mut unmeasured: Vec<serde_json::Value> = Vec::new();+    let mut common: Option<Vec<Measurement>> = None;+    for id in variants {+        let (what, measured): (String, Vec<Measurement>) = match op_fact(id) {+            Some(f) => (f.what.to_string(), f.measured.to_vec()),+            None => (format!("{id} (no live check has built this variant)"), Vec::new()),+        };+        if measured.is_empty() {+            unmeasured.push(serde_json::json!({"variant": id, "what": what}));+        }+        common = Some(match common {+            None => measured,+            Some(c) => c.into_iter().filter(|m| measured.contains(m)).collect(),+        });+    }+    let on = common.unwrap_or_default();+    let live = major.map(|m| on.iter().any(|x| x.major == m)).unwrap_or(false);+    let mut out = serde_json::json!({+        "live": live,+        "measuredOn": on.iter().map(Measurement::to_json).collect::<Vec<_>>(),+        "variants": variants,+    });+    if !live {+        let years: Vec<String> = on.iter().map(|m| m.year.to_string()).collect();+        out["why"] = serde_json::json!(if !unmeasured.is_empty() {+            "not measured live: see `unmeasured` — verify this step's geometry with swx_inspect_bodies".to_string()+        } else if on.is_empty() {+            "nothing was measured".to_string()+        } else {+            match major {+                Some(m) => format!("measured on SOLIDWORKS {} only; this is SOLIDWORKS {}", years.join(", "), year_of(m)),+                None => format!("measured on SOLIDWORKS {} only; this SOLIDWORKS's version could not be read", years.join(", ")),+            }+        });+        if !unmeasured.is_empty() {+            out["unmeasured"] = serde_json::Value::Array(unmeasured);+        }+    }+    out+}++/// `proven` for one step of a script.+pub fn step_proof(op: &crate::script::Op, result: &serde_json::Value, major: Option<u32>) -> serde_json::Value {+    proof(&op_variants(op, result), major)+}++/// The whole table, as swx_describe and swx_selftest report it; with the+/// install's major version, each row also says whether it is live HERE.+pub fn live_table(major: Option<u32>) -> serde_json::Value {+    let rows: Vec<serde_json::Value> = OP_FACTS+        .iter()+        .map(|f| {+            let mut r = serde_json::json!({+                "variant": f.id,+                "what": f.what,+                "checks": f.checks,+                "measuredOn": f.measured.iter().map(Measurement::to_json).collect::<Vec<_>>(),+            });+            if let Some(m) = major {+                r["liveOnThisInstall"] = serde_json::json!(f.measured.iter().any(|x| x.major == m));+            }+            r+        })+        .collect();+    serde_json::json!({+        "source": "docs/LIVE-RESULTS.md",+        "measuredVariants": OP_FACTS.iter().filter(|f| !f.measured.is_empty()).count(),+        "unmeasuredVariants": OP_FACTS.iter().filter(|f| f.measured.is_empty()).count(),+        "note": "A step's `proven.live` is true only when every variant it exercised was measured on this SOLIDWORKS release. A variant not listed has never been built live.",+        "variants": rows,+    })+}+ #[cfg(test)] mod tests {     use super::*;@@ -87,4 +405,141 @@ mod tests {         assert_eq!(d["tested"], false);         assert_eq!(d["year"], 2021);     }++    fn ops(script: serde_json::Value) -> Vec<crate::script::Op> {+        crate::script::parse(&script).expect("the test script parses")+    }++    fn ids(op: &crate::script::Op, result: serde_json::Value) -> Vec<String> {+        op_variants(op, &result)+    }++    #[test]+    fn the_table_is_well_formed() {+        for (i, f) in OP_FACTS.iter().enumerate() {+            assert!(OP_FACTS.iter().skip(i + 1).all(|g| g.id != f.id), "duplicate fact {}", f.id);+            assert!(!f.checks.is_empty() && !f.what.is_empty(), "{} says what and where", f.id);+        }+        // The live run of 2026-10-14, exactly as the coordinator recorded it.+        assert_eq!(+            LIVE_2026_10_14.to_json(),+            serde_json::json!({"solidworks": 2026, "major": 34, "edition": "connected", "date": "2026-10-14", "bridge": "0.10.3"})+        );+        // What docs/LIVE-RESULTS.md lists as measured...+        for id in [+            "new_part", "sketch.plane.front", "sketch.plane.top", "sketch.offset.top.positive", "sketch.offset.top.negative",+            "sketch.face.top", "sketch.rect", "sketch.circle", "sketch.multiProfile", "extrude.one", "extrude.both",+            "extrude.midPlane", "cut.one", "cut.one.reversed", "cut.one.throughAll.reversed", "cut.both", "cut.midPlane",+            "set_appearance.part", "set_appearance.face", "set_material", "set_material.reappliesAppearance",+            "fillet.allOfFeature", "fillet.FeatureFillet3", "chamfer.atPoints", "shell.inward", "linear_pattern.x",+            "circular_pattern.y", "set_prop", "select.multiSelectTyped",+        ] {+            assert_eq!(op_fact(id).map(|f| f.measured), Some(M2026), "{id} was measured on 2026");+        }+        // ...and EXACTLY what is not: its "not yet measured" list (throughAll+both+        // on a boss, the ladder's later rungs, the CreateDefinition fillet) plus+        // the variants no live check built — a reversed boss among them.+        let mut unmeasured: Vec<&str> = OP_FACTS.iter().filter(|f| f.measured.is_empty()).map(|f| f.id).collect();+        unmeasured.sort_unstable();+        assert_eq!(+            unmeasured,+            [+                "chamfer.allOfFeature", "extrude.both.throughAll", "extrude.one.reversed", "extrude.one.throughAll",+                "fillet.createDefinition", "new_assembly", "rebuild", "save_as", "select.entitySelect4",+                "select.selectByIdAtPoint", "select.selectByRay", "set_appearance.body", "shell.outward",+                "sketch.face.side", "sketch.offset.other", "sketch.plane.named", "sketch.plane.right", "zoom_fit",+            ]+        );+    }++    #[test]+    fn a_step_is_classified_by_what_solidworks_was_asked() {+        let o = ops(serde_json::json!([+            {"op": "new_part"},+            {"op": "sketch_rect", "plane": "Front Plane", "widthMm": 10, "heightMm": 10},+            {"op": "extrude", "depthMm": 5},+            {"op": "sketch", "plane": "Right Plane", "entities": [{"circle": {"radiusMm": 4}}, {"circle": {"radiusMm": 2}}]},+            {"op": "extrude", "depthMm": 5, "reverse": true},+            {"op": "sketch_circle", "plane": {"offsetFrom": "Top Plane", "offsetMm": -5}, "radiusMm": 2},+            {"op": "cut", "throughAll": true, "reverse": true},+            {"op": "sketch_circle", "plane": {"offsetFrom": "Front Plane", "offsetMm": 5}, "radiusMm": 2},+            {"op": "extrude", "throughAll": true, "direction": "both"},+            {"op": "sketch_circle", "face": {"atPointMm": [0, 10, 0]}, "radiusMm": 2},+            {"op": "fillet", "radiusMm": 1, "edges": {"allOfFeature": "last"}},+            {"op": "chamfer", "distanceMm": 1, "edges": {"atPointsMm": [[0, 0, 10]]}},+            {"op": "shell", "thicknessMm": 1, "removeFacesAtPointsMm": [[0, 10, 0]], "outward": true},+            {"op": "linear_pattern", "feature": "last", "directions": [{"axis": "x", "count": 2, "spacingMm": 5}, {"axis": "z", "count": 2, "spacingMm": 5}]},+            {"op": "circular_pattern", "feature": "last", "axis": "y", "count": 4},+            {"op": "set_appearance", "rgb": [1, 2, 3], "target": {"bodyName": "Boss-Extrude1"}},+            {"op": "set_material", "name": "ABS"}+        ]));+        assert_eq!(ids(&o[0], serde_json::json!({})), ["new_part"]);+        assert_eq!(ids(&o[1], serde_json::json!({})), ["sketch.plane.front", "sketch.rect"]);+        assert_eq!(ids(&o[2], serde_json::json!({"dir": {"value": false}})), ["extrude.one"]);+        assert_eq!(ids(&o[3], serde_json::json!({})), ["sketch.plane.right", "sketch.circle", "sketch.multiProfile"]);+        // The flag SOLIDWORKS was given decides — reported by the COM host...+        assert_eq!(ids(&o[4], serde_json::json!({"dir": {"value": true}})), ["extrude.one.reversed"]);+        // ...and the caller's `reverse` where a backend does not report it.+        assert_eq!(ids(&o[4], serde_json::json!({})), ["extrude.one.reversed"]);+        assert_eq!(ids(&o[2], serde_json::json!({"dir": {"value": true}})), ["extrude.one.reversed"], "a face's flip is the reversed call too");+        assert_eq!(ids(&o[5], serde_json::json!({})), ["sketch.offset.top.negative", "sketch.circle"]);+        assert_eq!(ids(&o[6], serde_json::json!({"dir": {"value": true}})), ["cut.one.throughAll.reversed"]);+        assert_eq!(ids(&o[7], serde_json::json!({})), ["sketch.offset.other", "sketch.circle"]);+        assert_eq!(ids(&o[8], serde_json::json!({})), ["extrude.both.throughAll"]);+        assert_eq!(+            ids(&o[9], serde_json::json!({"resolvedPlane": {"offsetFrom": "Top Plane", "selectedVia": "MultiSelect2(typed array)"}})),+            ["sketch.face.top", "sketch.circle", "select.multiSelectTyped"]+        );+        assert_eq!(ids(&o[9], serde_json::json!({"resolvedPlane": {"offsetFrom": "Front Plane"}}))[0], "sketch.face.side");+        assert_eq!(+            ids(&o[10], serde_json::json!({"route": "FeatureFillet3", "edges": {"selectedVia": "MultiSelect2(typed array)"}})),+            ["fillet.allOfFeature", "fillet.FeatureFillet3", "select.multiSelectTyped"]+        );+        assert_eq!(ids(&o[10], serde_json::json!({"route": "CreateFeature(ISimpleFilletFeatureData2)"})), ["fillet.allOfFeature", "fillet.createDefinition"]);+        assert_eq!(+            ids(&o[11], serde_json::json!({"edges": {"selectedVia": ["IEntity.Select4", "SelectByRay"]}})),+            ["chamfer.atPoints", "select.entitySelect4", "select.selectByRay"]+        );+        assert_eq!(ids(&o[12], serde_json::json!({"selectedVia": "SelectByID2 at the point (view-dependent)"})), ["shell.outward", "select.selectByIdAtPoint"]);+        assert_eq!(ids(&o[13], serde_json::json!({})), ["linear_pattern.x+z"]);+        assert_eq!(ids(&o[14], serde_json::json!({})), ["circular_pattern.y"]);+        assert_eq!(ids(&o[15], serde_json::json!({"route": "part (single-body part)"})), ["set_appearance.part"]);+        assert_eq!(ids(&o[15], serde_json::json!({"route": "body Boss-Extrude1"})), ["set_appearance.body"]);+        assert_eq!(ids(&o[16], serde_json::json!({"appearanceReapplied": []})), ["set_material"]);+        assert_eq!(ids(&o[16], serde_json::json!({"appearanceReapplied": [{"target": "Part"}]})), ["set_material", "set_material.reappliesAppearance"]);+    }++    #[test]+    fn proven_is_live_only_where_every_variant_was_measured_on_this_release() {+        let v = |ids: &[&str]| ids.iter().map(|s| s.to_string()).collect::<Vec<_>>();+        // The coordinator's shape, on SOLIDWORKS 2026.+        let p = proof(&v(&["sketch.face.top", "sketch.circle", "select.multiSelectTyped"]), Some(34));+        assert_eq!(p["live"], true);+        assert_eq!(p["measuredOn"], serde_json::json!([LIVE_2026_10_14.to_json()]));+        assert!(p.get("why").is_none() && p.get("unmeasured").is_none());+        // The same step on SOLIDWORKS 2021: measured elsewhere, not live here.+        let p = proof(&v(&["sketch.face.top", "sketch.circle"]), Some(29));+        assert_eq!(p["live"], false);+        assert_eq!(p["measuredOn"].as_array().map(|a| a.len()), Some(1));+        assert!(p["why"].as_str().unwrap_or("").contains("this is SOLIDWORKS 2021"), "{p}");+        // A version that could not be read is never live.+        assert_eq!(proof(&v(&["new_part"]), None)["live"], false);+        // ONE unmeasured variant makes the step unmeasured, and says which.+        let p = proof(&v(&["fillet.allOfFeature", "fillet.createDefinition"]), Some(34));+        assert_eq!(p["live"], false);+        assert_eq!(p["measuredOn"], serde_json::json!([]));+        assert_eq!(p["unmeasured"][0]["variant"], "fillet.createDefinition");+        // A variant the table does not know has never been built live.+        let p = proof(&v(&["linear_pattern.x+z"]), Some(34));+        assert_eq!(p["live"], false);+        assert!(p["unmeasured"][0]["what"].as_str().unwrap_or("").contains("no live check"));+        // The table, as describe and selftest report it.+        let t = live_table(Some(29));+        assert_eq!(t["variants"].as_array().map(|a| a.len()), Some(OP_FACTS.len()));+        assert!(t["variants"].as_array().unwrap().iter().all(|r| r["liveOnThisInstall"] == false), "nothing is live on 2021 yet");+        let t = live_table(Some(34));+        let live = t["variants"].as_array().unwrap().iter().filter(|r| r["liveOnThisInstall"] == true).count();+        assert_eq!(live, t["measuredVariants"].as_u64().unwrap() as usize);+        assert!(live_table(None)["variants"][0].get("liveOnThisInstall").is_none());+    } }