Keep prepared assembly geometry through selection changes

crates/engine/src/world_placement_cache_tests.rs

@@ -38,9 +38,11 @@ fn world_placement_cache_preserves_pending_picks_materials_scratch_and_named_joi
     let top = placed.body.faces(0.001).unwrap().into_iter().find(|face| face.plane_normal.is_some_and(|n| n.z > 0.99)).unwrap().index;
     run(&mut session, "select.set", json!({"items":[{"type":"face","body":name,"index":top,"point":[pick.x,pick.y,pick.z]}]}));
     assert!(matches!(&session.selection[0], crate::Sel::Face { body, index, .. } if body == &name && *index == top));
+    assert!(Arc::ptr_eq(&world, &session.world_state()), "selection changes must not discard prepared placements");
     let scratch = session.scratch();
     assert_eq!(scratch.pending_moves, pending);
     let scratch_world = scratch.world_state();
+    assert!(Arc::ptr_eq(&world, &scratch_world));
     let scratch_body = scratch_world.body(&name).unwrap();
     assert!(scratch_body.mesh().bounds().min.dist(bounds.min) < 1e-9);
     assert_eq!(crate::doc::naming::face_names(scratch_body), source_names);
@@ -63,3 +65,113 @@ fn world_placement_cache_preserves_pending_picks_materials_scratch_and_named_joi
     assert!(reopened.world_state().body(&name).unwrap().mesh().bounds().min.dist(bounds.min + Vec3::new(5., 0., 0.)) < 1e-9);
     assert_eq!(reopened.model.results.iter().filter(|r| r.error.is_some()).count(), 0);
 }
+
+#[test]
+fn selection_visibility_section_and_view_revisions_reuse_world_geometry() {
+    let mut session = Session::default();
+    run(&mut session, "component.create", json!({"name":"Part"}));
+    run(&mut session, "solid.box", json!({"length":2,"width":3,"height":4,"body_name":"Block","operation":"new"}));
+    let world = session.world_state();
+    let revision = session.revision;
+    run(&mut session, "select.set", json!({"items":[{"type":"body","name":"Block"}]}));
+    assert!(session.revision > revision);
+    assert!(Arc::ptr_eq(&world, &session.world_state()));
+    run(&mut session, "select.clear", json!({}));
+    assert!(Arc::ptr_eq(&world, &session.world_state()));
+    run(&mut session, "browser.visibility", json!({"items":["Block"],"visible":false}));
+    assert!(!session.body_visible("Block"));
+    assert!(Arc::ptr_eq(&world, &session.world_state()));
+    run(&mut session, "inspect.section", json!({"plane":{"origin":[0,0,2],"normal":[0,0,1]}}));
+    assert!(session.section.is_some());
+    assert!(Arc::ptr_eq(&world, &session.world_state()));
+    session.invalidate_view(session.revision + 10);
+    assert!(Arc::ptr_eq(&world, &session.world_state()));
+    assert!(Arc::ptr_eq(&world, &session.scratch().world_state()));
+}
+
+#[test]
+fn world_cache_requires_exact_design_model_pending_and_author_context() {
+    let mut session = Session::default();
+    let created = run(&mut session, "component.create", json!({"name":"Part"}));
+    let component = created["component"].as_u64().unwrap();
+    let first = created["occurrence"].as_u64().unwrap();
+    run(&mut session, "solid.box", json!({"length":2,"width":3,"height":4,"body_name":"Block","operation":"new"}));
+    let sketch = run(&mut session, "sketch.create", json!({"plane":"XY"}))["sketch"].as_u64().unwrap();
+    run(&mut session, "sketch.finish", json!({}));
+    let second = run(&mut session, "occurrence.copy", json!({"occurrence":first}))["occurrence"].as_u64().unwrap();
+    let initial = session.world_state();
+    run(&mut session, "occurrence.move", json!({"occurrence":second,"translate":[10,20,0],"capture":false}));
+    let pending = session.world_state();
+    assert!(!Arc::ptr_eq(&initial, &pending));
+    let name = session.occurrence_placement(&[second]).unwrap().bodies[0].world.clone();
+    assert!(pending.body(&name).unwrap().mesh().bounds().min.dist(Vec3::new(10., 20., 0.)) < 1e-9);
+    run(&mut session, "component.activate", json!({"component":component,"occurrence":second,"path":[second]}));
+    let authored = session.world_state();
+    assert!(!Arc::ptr_eq(&pending, &authored));
+    assert!(authored.sketch(sketch).unwrap().plane.origin.dist(Vec3::new(10., 20., 0.)) < 1e-9);
+    let mut scratch = session.scratch();
+    assert!(Arc::ptr_eq(&authored, &scratch.world_state()));
+    scratch.active_occurrence_path = Some(vec![first]);
+    let scratch_world = scratch.world_state();
+    assert!(!Arc::ptr_eq(&authored, &scratch_world));
+    assert!(scratch_world.sketch(sketch).unwrap().plane.origin.dist(Vec3::ZERO) < 1e-9);
+    assert!(Arc::ptr_eq(&authored, &session.world_state()), "scratch context must not replace the source cache");
+    run(&mut session, "appearance.assign", json!({"bodies":["Block"],"color":"#ff0000"}));
+    let painted = session.world_state();
+    assert!(!Arc::ptr_eq(&authored, &painted));
+    assert_ne!(session.doc.model_body_look(painted.body("Block").unwrap()), None);
+    run(&mut session, "edit.undo", json!({}));
+    let undone = session.world_state();
+    assert!(!Arc::ptr_eq(&painted, &undone));
+    run(&mut session, "edit.redo", json!({}));
+    let redone = session.world_state();
+    assert!(!Arc::ptr_eq(&undone, &redone));
+    assert!(session.doc.model_body_look(redone.body("Block").unwrap()).is_some());
+    let before_edit = session.world_state();
+    run(&mut session, "solid.box", json!({"length":5,"width":6,"height":7,"body_name":"Other","operation":"new"}));
+    let edited = session.world_state();
+    assert!(!Arc::ptr_eq(&before_edit, &edited));
+    assert!(edited.body("Other").is_some());
+    session.doc = Arc::new(crate::doc::Document::from_json(&session.doc.to_json()).unwrap());
+    let replaced = session.world_state();
+    assert!(!Arc::ptr_eq(&edited, &replaced), "equal contents in a different document cannot share the cache key");
+    session.model = crate::doc::Model::default();
+    session.model.evaluate(&session.doc);
+    assert!(!Arc::ptr_eq(&replaced, &session.world_state()), "a new evaluated model must invalidate even when the document Arc is unchanged");
+}
+
+#[test]
+fn adopted_scratch_keeps_its_warm_geometry_and_history_stages_invalidate_it() {
+    let mut session = Session::default();
+    run(&mut session, "component.create", json!({"name":"Part"}));
+    run(&mut session, "solid.box", json!({"length":2,"width":3,"height":4,"body_name":"Block","operation":"new"}));
+    let source = session.world_state();
+    let source_json = session.doc.to_json();
+    let mut scratch = session.scratch();
+    run(&mut scratch, "solid.box", json!({"length":5,"width":6,"height":7,"body_name":"Draft","operation":"new"}));
+    let warmed = scratch.world_state();
+    assert!(!Arc::ptr_eq(&source, &warmed));
+    assert_eq!(session.doc.to_json(), source_json);
+    assert!(Arc::ptr_eq(&source, &session.world_state()));
+    assert!(source.body("Draft").is_none());
+    let feature = warmed.body("Draft").unwrap().feature;
+    session.accept_computed(scratch);
+    assert!(Arc::ptr_eq(&warmed, &session.world_state()), "adoption/view revision must retain the worker's prepared geometry");
+    session.invalidate_view(session.revision + 20);
+    assert!(Arc::ptr_eq(&warmed, &session.world_state()));
+    run(&mut session, "timeline.rollback", json!({"position":1}));
+    let rolled = session.world_state();
+    assert!(!Arc::ptr_eq(&warmed, &rolled));
+    assert!(rolled.body("Block").is_some());
+    assert!(rolled.body("Draft").is_none());
+    run(&mut session, "timeline.rollback", json!({}));
+    let restored = session.world_state();
+    assert!(!Arc::ptr_eq(&rolled, &restored));
+    assert!(restored.body("Draft").is_some());
+    run(&mut session, "timeline.suppress", json!({"feature":feature,"suppressed":true}));
+    let suppressed = session.world_state();
+    assert!(!Arc::ptr_eq(&restored, &suppressed));
+    assert!(suppressed.body("Draft").is_none());
+    run(&mut session, "timeline.suppress", json!({"feature":feature,"suppressed":false}));
+    assert!(session.world_state().body("Draft").is_some());
+}