Keep prepared assembly geometry through selection changes

crates/engine/src/lib.rs

@@ -150,6 +150,28 @@ pub struct Preview {
     pub after: Arc<ModelState>,
 }
 
+/// Prepared world geometry depends on design/model identity and placement context, not
+/// selection or the view revision. Retained Arcs prevent pointer reuse after a design closes.
+#[derive(Clone)]
+struct WorldCache {
+    doc: Arc<Document>,
+    model: Arc<solvecraft_doc::ModelState>,
+    pending_moves: std::collections::BTreeMap<u64, solvecraft_doc::Mat>,
+    active_component: u64,
+    active_occurrence_path: Option<Vec<u64>>,
+    world: Arc<solvecraft_doc::ModelState>,
+}
+
+impl WorldCache {
+    fn matches(&self, session: &Session, model: &Arc<solvecraft_doc::ModelState>) -> bool {
+        Arc::ptr_eq(&self.doc, &session.doc)
+            && Arc::ptr_eq(&self.model, model)
+            && self.pending_moves == session.pending_moves
+            && self.active_component == session.active_component
+            && self.active_occurrence_path == session.active_occurrence_path
+    }
+}
+
 /// An editing session on one design.
 pub struct Session {
     pub doc: Arc<Document>,
@@ -173,7 +195,7 @@ pub struct Session {
     pub active_occurrence_path: Option<Vec<u64>>,
     /// Occurrence moves not captured yet (Capture Position keeps them, a recompute drops them).
     pub pending_moves: std::collections::BTreeMap<u64, solvecraft_doc::Mat>,
-    world_cache: std::sync::Mutex<Option<(u64, Arc<solvecraft_doc::ModelState>)>>,
+    world_cache: std::sync::Mutex<Option<WorldCache>>,
     occurrence_visibility_cache: std::sync::Mutex<Option<occurrences::VisibilityCache>>,
     /// Features copied with `timeline.copy` (pasted by `timeline.paste`).
     pub clipboard: Vec<solvecraft_doc::Feature>,
@@ -308,10 +330,10 @@ impl Session {
             return st;
         }
         if let Ok(c) = self.world_cache.lock()
-            && let Some((rev, w)) = c.as_ref()
-            && *rev == self.revision
+            && let Some(cached) = c.as_ref()
+            && cached.matches(self, &st)
         {
-            return w.clone();
+            return cached.world.clone();
         }
         let mut w = if self.pending_moves.is_empty() {
             solvecraft_doc::world_state(&self.doc, &st)
@@ -350,7 +372,14 @@ impl Session {
         }
         let w = Arc::new(w);
         if let Ok(mut c) = self.world_cache.lock() {
-            *c = Some((self.revision, w.clone()));
+            *c = Some(WorldCache {
+                doc: self.doc.clone(),
+                model: st,
+                pending_moves: self.pending_moves.clone(),
+                active_component: self.active_component,
+                active_occurrence_path: self.active_occurrence_path.clone(),
+                world: w.clone(),
+            });
         }
         w
     }
@@ -503,7 +532,7 @@ impl Session {
             active_component: self.active_component,
             active_occurrence_path: self.active_occurrence_path.clone(),
             pending_moves: self.pending_moves.clone(),
-            world_cache: Default::default(),
+            world_cache: std::sync::Mutex::new(self.world_cache.lock().ok().and_then(|cache| cache.clone())),
             occurrence_visibility_cache: Default::default(),
             clipboard: self.clipboard.clone(),
             section: None,
@@ -519,12 +548,6 @@ impl Session {
     pub fn invalidate_view(&mut self, previous_revision: u64) {
         let old = self.revision;
         self.revision = old.max(previous_revision) + 1;
-        if let Ok(mut cache) = self.world_cache.lock()
-            && let Some((revision, _)) = cache.as_mut()
-            && *revision == old
-        {
-            *revision = self.revision;
-        }
     }
 
     /// Commit commands evaluated on a scratch copy without losing this session's file,