SOLIDWORKS Bridge

@@ -5574,31 +5574,56 @@ impl ComBackend {                     ));                 }                 self.ensure_active(&doc, st)?;-                let after_origin = Self::features_after_origin(&doc)?;-                let names: Vec<String> = after_origin.iter().filter_map(|f| f.string("Name", &[])).collect();-                let mut deleted = 0usize;-                if !after_origin.is_empty() {-                    let _ = Self::clear_selection(&doc);-                    for f in &after_origin {-                        let _ = f.call("Select2", &[&Var::boolean(true), &Var::i4(0)]);+                // IN PASSES (0.10.8). Measured: one DeleteSelection2 returned true+                // and left a top-level sketch (one a previous script left+                // unconsumed). Each pass selects what is LEFT — a feature by+                // IFeature::Select2, and if that refuses, by name with its own+                // selection type (a sketch as "SKETCH") — and deletes it with+                // swDeleteSelectionOptions_e swDelete_Children 1 | swDelete_Absorbed 2+                // (help.solidworks.com, swconst; DeleteSelection2, 2006 SP1, "does+                // not ask the user to confirm the deletion").+                let ext = doc.obj("Extension", &[])?.ok_or_else(|| HostError::msg("no ModelDocExtension"))?;+                let mut last_ok = true;+                let cleared = crate::modeling::clear_in_passes(+                    || Ok::<_, HostError>(Self::features_after_origin(&doc)?.iter().filter_map(|f| f.string("Name", &[])).collect()),+                    |names, _pass| {+                        let _ = Self::clear_selection(&doc);+                        for f in Self::features_after_origin(&doc)? {+                            let Some(name) = f.string("Name", &[]) else { continue };+                            if !names.contains(&name) {+                                continue;+                            }+                            let selected = f.call("Select2", &[&Var::boolean(true), &Var::i4(0)]).ok().and_then(|v| v.as_bool()) == Some(true);+                            if !selected {+                                let kind = match f.string("GetTypeName2", &[]).as_deref() {+                                    Some("ProfileFeature") => "SKETCH",+                                    Some("3DProfileFeature") => "3DSKETCH",+                                    Some("RefPlane") => "PLANE",+                                    Some("RefAxis") => "AXIS",+                                    _ => "BODYFEATURE",+                                };+                                let _ = Self::select_named(&doc, &name, kind, true, 0);+                            }+                        }+                        last_ok = ext.call("DeleteSelection2", &[&Var::i4(1 | 2)])?.as_bool().unwrap_or(false);+                        let _ = Self::clear_selection(&doc);+                        Ok(())+                    },+                    5,+                );+                let cleared = match cleared {+                    Ok(c) => c,+                    Err(crate::modeling::ClearError::Host(e)) => return Err(e),+                    Err(crate::modeling::ClearError::Stuck { passes, left, .. }) => {+                        return Err(HostError::coded(+                            "clear_part_incomplete",+                            format!(+                                "clear_part could not delete every feature after {passes} passes (DeleteSelection2 last returned {last_ok}; still there: {})",+                                left.join(", ")+                            ),+                        ))                     }-                    // swDeleteSelectionOptions_e: swDelete_Children 1 | swDelete_Absorbed 2-                    // (help.solidworks.com, swconst) — the sketches a feature-                    // absorbed, and anything built on it, go too. DeleteSelection2-                    // (2006 SP1) "does not ask the user to confirm the deletion".-                    let ext = doc.obj("Extension", &[])?.ok_or_else(|| HostError::msg("no ModelDocExtension"))?;-                    let ok = ext.call("DeleteSelection2", &[&Var::i4(1 | 2)])?.as_bool().unwrap_or(false);-                    let _ = Self::clear_selection(&doc);-                    let left = Self::features_after_origin(&doc)?;-                    if !ok || !left.is_empty() {-                        let still: Vec<String> = left.iter().filter_map(|f| f.string("Name", &[])).collect();-                        return Err(HostError::msg(format!(-                            "clear_part could not delete every feature (DeleteSelection2 returned {ok}; still there: {})",-                            still.join(", ")-                        )));-                    }-                    deleted = names.len();-                }+                };                 let bodies = doc.call("GetBodies2", &[&Var::i4(0), &Var::boolean(false)]).map(|b| b.as_array().len()).unwrap_or(0);                 // The script's own memory of planes, axes and sketches is about                 // features that no longer exist.@@ -5607,8 +5632,9 @@ impl ComBackend {                 *st = ScriptState::default();                 st.restore_active = keep_active;                 st.created_here = created_here;-                Ok(json!({"cleared": title, "featuresDeleted": deleted, "deleted": names, "bodiesLeft": bodies,-                          "route": "DeleteSelection2(swDelete_Children | swDelete_Absorbed)"}))+                Ok(json!({"cleared": title, "featuresDeleted": cleared.deleted.len(), "deleted": cleared.deleted,+                          "passes": cleared.passes, "bodiesLeft": bodies,+                          "route": "DeleteSelection2(swDelete_Children | swDelete_Absorbed), repeated until the tree is empty"}))             }              Op::Sketch { plane, entities, .. } => {

@@ -3939,10 +3939,27 @@ impl MockBackend {                                 if d.doc_type != "part" {                                     return Err(HostError::msg(format!("clear_part works on a part; '{}' is not one", d.title)));                                 }-                                let mut model: crate::comhost::mock_model::Model =+                                let model: crate::comhost::mock_model::Model =                                     serde_json::from_value(Value::Object(d.model.clone())).unwrap_or_default();-                                let deleted: Vec<String> = model.features.iter().map(|f| f.name.clone()).collect();-                                model.clear();+                                // THE SAME PASSES the real backend runs. As measured, the+                                // FIRST delete takes the features and leaves an+                                // unconsumed sketch; the next pass, selecting it as a+                                // SKETCH, takes it (`mock-clear-part-stuck`: never).+                                let model_cell = std::cell::RefCell::new(model);+                                let cleared = crate::modeling::clear_in_passes(+                                    || Ok::<_, HostError>(model_cell.borrow().tree_after_origin()),+                                    |_names, pass| {+                                        let mut m = model_cell.borrow_mut();+                                        if pass == 1 {+                                            m.clear();+                                        } else if !fault("mock-clear-part-stuck") {+                                            m.loose_sketches.clear();+                                        }+                                        Ok(())+                                    },+                                    5,+                                );+                                let model = model_cell.into_inner();                                 d.bodies = model.bodies_json();                                 d.dimensions = Map::new();                                 if let Value::Object(m) = serde_json::to_value(&model).unwrap_or(Value::Null) {@@ -3950,8 +3967,21 @@ impl MockBackend {                                 }                                 d.dirty = true;                                 run = fresh_run();-                                json!({"cleared": d.title, "featuresDeleted": deleted.len(), "deleted": deleted, "bodiesLeft": 0,-                                       "route": "DeleteSelection2(swDelete_Children | swDelete_Absorbed)"})+                                match cleared {+                                    Ok(c) => json!({"cleared": d.title, "featuresDeleted": c.deleted.len(), "deleted": c.deleted,+                                                    "passes": c.passes, "bodiesLeft": 0,+                                                    "route": "DeleteSelection2(swDelete_Children | swDelete_Absorbed), repeated until the tree is empty"}),+                                    Err(crate::modeling::ClearError::Stuck { passes, left, .. }) => {+                                        return Err(HostError::coded(+                                            "clear_part_incomplete",+                                            format!(+                                                "clear_part could not delete every feature after {passes} passes (DeleteSelection2 last returned true; still there: {})",+                                                left.join(", ")+                                            ),+                                        ))+                                    }+                                    Err(crate::modeling::ClearError::Host(e)) => return Err(e),+                                }                             }                             Op::SetProp { name, value } => {                                 let path = self.resolve(&target)?;@@ -3997,7 +4027,15 @@ impl MockBackend {                                 let d = self.docs.iter_mut().find(|d| d.path == path).ok_or_else(|| HostError::msg("document vanished"))?;                                 let mut model: crate::comhost::mock_model::Model =                                     serde_json::from_value(Value::Object(d.model.clone())).unwrap_or_default();-                                let r = crate::comhost::mock_model::apply(&mut model, &mut run, op, active).map_err(HostError::msg)?;+                                let applied = crate::comhost::mock_model::apply(&mut model, &mut run, op, active);+                                // What a FAILED step left in the tree (an unconsumed+                                // sketch) stays there, as it does in SOLIDWORKS.+                                if applied.is_err() {+                                    if let Value::Object(m) = serde_json::to_value(&model).unwrap_or(Value::Null) {+                                        d.model = m;+                                    }+                                }+                                let r = applied.map_err(HostError::msg)?;                                 if let Op::SetMaterial { name, .. } = op {                                     d.material = Some(name.clone());                                 }@@ -4028,6 +4066,22 @@ impl MockBackend {                         }                     }                 }+                // A SKETCH DRAWN AND NEVER CONSUMED stays in the tree, unabsorbed+                // (0.10.8) — the shape that survived a clear_part live.+                if let Some(p) = run.pending.take() {+                    if let Ok(path) = self.resolve(&pin_arg(&pinned)) {+                        if let Some(d) = self.docs.iter_mut().find(|d| d.path == path) {+                            let mut model: crate::comhost::mock_model::Model =+                                serde_json::from_value(Value::Object(d.model.clone())).unwrap_or_default();+                            if !model.loose_sketches.contains(&p.name) {+                                model.loose_sketches.push(p.name.clone());+                            }+                            if let Value::Object(m) = serde_json::to_value(&model).unwrap_or(Value::Null) {+                                d.model = m;+                            }+                        }+                    }+                }                 // Put the user's active document back.                 if let Some(prev) = was_active {                     if self.find(&prev).is_some() && pinned.is_some() && !created.is_object() {

@@ -526,6 +526,51 @@ impl Selector for ProfileSelector {     } } +/// What clear_part did (0.10.8).+#[derive(Clone, Debug, PartialEq)]+pub struct Cleared {+    pub passes: usize,+    pub deleted: Vec<String>,+}++/// clear_part could not empty the part.+#[derive(Clone, Debug, PartialEq)]+pub enum ClearError<E> {+    /// Something is still there after `passes` passes.+    Stuck { passes: usize, left: Vec<String>, deleted: Vec<String> },+    Host(E),+}++/// CLEAR_PART IN PASSES (0.10.8), shared by the COM host and the simulator.+///+/// MEASURED 2026-10-14 (0.10.7's self-test on SOLIDWORKS 2026): three checks+/// failed because one DeleteSelection2 over every feature after the origin+/// returned TRUE and left a top-level SKETCH behind (Sketch13, Sketch4,+/// Sketch9) — a sketch the previous check left unconsumed. So: walk, delete,+/// walk again, and repeat on whatever is left, up to `max_passes`. It succeeds+/// ONLY when the walk comes back empty. `deleted` is what each pass actually+/// removed (present before it, gone after it).+pub fn clear_in_passes<E>(+    mut remaining: impl FnMut() -> Result<Vec<String>, E>,+    mut delete: impl FnMut(&[String], usize) -> Result<(), E>,+    max_passes: usize,+) -> Result<Cleared, ClearError<E>> {+    let mut left = remaining().map_err(ClearError::Host)?;+    let mut deleted: Vec<String> = Vec::new();+    let mut passes = 0;+    while !left.is_empty() {+        if passes >= max_passes {+            return Err(ClearError::Stuck { passes, left, deleted });+        }+        passes += 1;+        delete(&left, passes).map_err(ClearError::Host)?;+        let after = remaining().map_err(ClearError::Host)?;+        deleted.extend(left.iter().filter(|n| !after.contains(n)).cloned());+        left = after;+    }+    Ok(Cleared { passes, deleted })+}+ /// Read the interop probe's output (`guid=…`, `itype=…`, `tlflags=…`) into /// the IID and whether the interface can be called through IDispatch: /// InterfaceType Dual (0) or IDispatch (2), or TypeLibType FDual (0x40) /@@ -735,6 +780,44 @@ mod tests {         assert!(edge_ray([0.0; 3], &[[0.0, 0.0, 3.0], [0.0; 3]]).is_some());     } +    #[test]+    fn clear_part_repeats_until_the_tree_is_empty() {+        use std::cell::RefCell;+        // THE MEASURED CASE: the first delete takes the features and leaves a sketch.+        let tree = RefCell::new(vec!["Boss-Extrude1".to_string(), "Cut-Extrude1".to_string(), "Sketch13".to_string()]);+        let r = clear_in_passes(+            || Ok::<_, String>(tree.borrow().clone()),+            |names: &[String], pass| {+                let mut t = tree.borrow_mut();+                if pass == 1 {+                    t.retain(|n| n.starts_with("Sketch") && names.contains(n));+                } else {+                    t.clear();+                }+                Ok(())+            },+            5,+        );+        assert_eq!(r, Ok(Cleared { passes: 2, deleted: vec!["Boss-Extrude1".into(), "Cut-Extrude1".into(), "Sketch13".into()] }));+        // Nothing there: no pass at all.+        assert_eq!(clear_in_passes(|| Ok::<_, String>(vec![]), |_: &[String], _| Ok(()), 5), Ok(Cleared { passes: 0, deleted: vec![] }));+        // Something that never goes: stuck after exactly max passes, and SAID.+        let calls = RefCell::new(0);+        let r = clear_in_passes(+            || Ok::<_, String>(vec!["Sketch9".to_string()]),+            |_: &[String], _| {+                *calls.borrow_mut() += 1;+                Ok(())+            },+            5,+        );+        assert_eq!(r, Err(ClearError::Stuck { passes: 5, left: vec!["Sketch9".into()], deleted: vec![] }));+        assert_eq!(*calls.borrow(), 5);+        // A host failure stops it, as a host failure.+        let r = clear_in_passes(|| Ok::<_, String>(vec!["A".into()]), |_: &[String], _| Err("COM said no".to_string()), 5);+        assert_eq!(r, Err(ClearError::Host("COM said no".to_string())));+    }+     #[test]     fn the_iid_probe_is_read_strictly() {         let g = "guid=4c1e9cc6-3d6d-11d5-9a8c-00c04f80e3e7\nitype=0\n";

@@ -203,10 +203,11 @@ pub fn selftest(ctx: &Ctx, args: &Value) -> Value {                 }             }             let target = if reuse { shared.clone() } else { None };-            if target.is_none() {+            let docs = geometry_check(ctx, &mut run, &check, memory_override.as_deref(), target.as_deref());+            if docs.fresh {                 memory_log.documents_created += 1;             }-            let clear_failed = geometry_check(ctx, &mut run, &check, memory_override.as_deref(), target.as_deref());+            let clear_failed = docs.clear_failed;             let after = crate::memory::sample(crate::launchos::os().as_ref());             if let Some(last) = run.results.last_mut() {                 last["swPrivateMbAfter"] = json!(after.sw_private_mb);@@ -286,8 +287,8 @@ pub fn selftest(ctx: &Ctx, args: &Value) -> Value {             run.call(ctx, "re-activate the document that was active before", "swx_activate_document", json!({"name": prev}));         }         // HYGIENE (0.10.7): release every COM reference the run held. MEASURED-        // 2026-10-14: a respawn freed ~210 MB of SOLIDWORKS's memory and never-        // touched SOLIDWORKS itself.+        // 2026-10-14: a respawn freed 210 MB once and 0 MB once — never touching+        // SOLIDWORKS, and not a saving to rely on; what it freed is reported.         memory_log.com_respawn = Some(respawn_com_host(ctx));         return finish_with(level, &sw, ready, true, started, run, None, memory_log.to_json(memory_override.as_deref()));     }@@ -436,7 +437,7 @@ fn respawn_com_host(ctx: &Ctx) -> Value {     let r = crate::verbs::dispatch(         ctx,         "swx_com_respawn",-        &json!({"reason": "swx_selftest: release the COM references the run held (measured: about 210 MB)"}),+        &json!({"reason": "swx_selftest: release the COM references the run held"}),     );     let after = crate::memory::sample(crate::launchos::os().as_ref());     json!({@@ -838,20 +839,52 @@ fn titles(ctx: &Ctx) -> Vec<String> { }  /// One check: build, MEASURE, compare, close what it made.-fn geometry_check(ctx: &Ctx, run: &mut Run, c: &Check, memory_override: Option<&str>, reuse: Option<&str>) -> bool {+/// What a check did with documents.+struct CheckDocs {+    /// The shared part could not be cleared: it is replaced, not reused again.+    clear_failed: bool,+    /// The check ran in a part of its own (a fresh document was created).+    fresh: bool,+}++/// The part named in "…still there: Sketch13)" — what clear_part left.+fn clear_leftover(error: &str) -> String {+    error+        .split("still there: ")+        .nth(1)+        .map(|t| t.trim_end_matches(')').trim().to_string())+        .filter(|t| !t.is_empty())+        .unwrap_or_else(|| error.chars().take(160).collect())+}++fn geometry_check(ctx: &Ctx, run: &mut Run, c: &Check, memory_override: Option<&str>, reuse: Option<&str>) -> CheckDocs {     let t = Instant::now();     let before = titles(ctx);-    let mut sargs = match reuse {+    let with_override = |mut a: Value| -> Value {+        if let Some(r) = memory_override {+            a["ignoreMemoryPressure"] = json!(true);+            a["reason"] = json!(r);+        }+        a+    };+    let sargs = with_override(match reuse {         // In the shared part: its new_part becomes clear_part.         Some(doc) => json!({"script": c.script, "reuseDocument": doc}),         // A part of its own (visible: a hidden part cannot be modelled).         None => json!({"script": c.script}),-    };-    if let Some(r) = memory_override {-        sargs["ignoreMemoryPressure"] = json!(true);-        sargs["reason"] = json!(r);+    });+    let mut r = crate::verbs::dispatch(ctx, "swx_run_script", &sargs);+    // THE SHARED PART COULD NOT BE CLEARED (0.10.8): that is not this check's+    // failure. MEASURED: three checks of 0.10.7's live run failed on a sketch+    // the PREVIOUS check left behind. The check runs again in a fresh part, and+    // the row says so; it fails only on its own geometry.+    let mut fallback: Option<String> = None;+    if reuse.is_some() {+        if let Some(e) = r.get("error").and_then(|e| e.as_str()).filter(|e| e.contains("(clear_part) failed")) {+            fallback = Some(format!("fresh part — clear_part left {}", clear_leftover(e)));+            r = crate::verbs::dispatch(ctx, "swx_run_script", &with_override(json!({"script": c.script})));+        }     }-    let r = crate::verbs::dispatch(ctx, "swx_run_script", &sargs);     let ok = r.get("success").and_then(|v| v.as_bool()) != Some(false);     let doc = r.get("documentName").and_then(|d| d.as_str()).map(String::from);     let mut fails: Vec<String> = Vec::new();@@ -1016,6 +1049,7 @@ fn geometry_check(ctx: &Ctx, run: &mut Run, c: &Check, memory_override: Option<&         "expected": expected,         "measured": measured,         "fails": fails,+        "reuseFallback": fallback,     }));-    reuse.is_some() && r.get("error").and_then(|e| e.as_str()).map(|e| e.contains("(clear_part) failed")).unwrap_or(false)+    CheckDocs { clear_failed: fallback.is_some(), fresh: reuse.is_none() || fallback.is_some() } }