SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
fix: load designs off-thread and cache recent thumbnails as PNGs
bherbruck4b7e1d317d57
diff --git a/apps/solvecraft-cli/src/main.rs b/apps/solvecraft-cli/src/main.rsindex 093ef20087..47a9fe9708 100644--- a/apps/solvecraft-cli/src/main.rs+++ b/apps/solvecraft-cli/src/main.rs@@ -3,7 +3,7 @@//! ```text//! solvecraft-cli run <script.json|design.solvecraft|part.step|mesh.3mf> [--in design|part.step|mesh.3mf] [--out FILE]... [--save FILE] [--quiet]//! solvecraft-cli eval <script.json|design.solvecraft|part.step> (alias: inspect) measurements as JSON-//! solvecraft-cli bench-open <design.solvecraft> [--parse-only] loading timings as JSON lines+//! solvecraft-cli bench-open <design.solvecraft | part.step> [--parse-only] loading timings as JSON lines//! solvecraft-cli snapshot <script|design> --out shot.png [--width W] [--height H] [--view iso|front|top|…]//! solvecraft-cli exec <command> [json-params] run one command on an empty design//! solvecraft-cli commands the command registry as JSON@@ -32,7 +32,7 @@ const USAGE: &str = "usage:solvecraft-cli run <script.json|design.solvecraft|part.step> [--in design.solvecraft|part.step] [--out FILE]... [--save FILE] [--quiet] [--results]solvecraft-cli run --in <design.solvecraft|part.step> [--out FILE]...solvecraft-cli eval <script.json|design.solvecraft|part.step> (alias: inspect; or --in FILE)- solvecraft-cli bench-open <design.solvecraft> [--parse-only]+ solvecraft-cli bench-open <design.solvecraft | part.step> [--parse-only]solvecraft-cli snapshot <script|design> --out shot.png [--width W] [--height H] [--view iso|front|back|top|bottom|left|right]solvecraft-cli exec <command> [json-params]solvecraft-cli commands@@ -357,17 +357,26 @@ fn cmd_bench_edit(args: &[String]) -> Result<(), String> {/// Separate file reading, JSON decoding/repair, timeline evaluation and display meshing.fn cmd_bench_open(args: &[String]) -> Result<(), String> {- let path = args.first().ok_or("usage: solvecraft-cli bench-open <design.solvecraft> [--parse-only]")?;+ let path = args.first().ok_or("usage: solvecraft-cli bench-open <design.solvecraft | part.step> [--parse-only]")?;let t = std::time::Instant::now();let len = std::fs::metadata(path).map_err(|e| format!("{path}: {e}"))?.len();- if len > solvecraft_engine::io::MAX_DESIGN_BYTES as u64 {+ let step = solvecraft_engine::io::is_step_path(path);+ let limit = if step { solvecraft_engine::io::MAX_STEP_BYTES } else { solvecraft_engine::io::MAX_DESIGN_BYTES };+ if len > limit as u64 {return Err(format!("{path}: file too large"));}let bytes = std::fs::read(path).map_err(|e| format!("{path}: {e}"))?;let read_ms = t.elapsed().as_secs_f64() * 1000.0;println!("{}", json!({"step": "read", "ms": read_ms, "bytes": bytes.len()}));let t = std::time::Instant::now();- let doc = solvecraft_engine::io::read_design(&bytes).map_err(|e| e.to_string())?;+ let doc = if step {+ let imported = solvecraft_engine::io::step_import_feature(&bytes, path).map_err(|e| e.to_string())?;+ let mut doc = solvecraft_engine::doc::Document::new(&imported.name);+ doc.add_feature(imported.kind, Some(&imported.name)).map_err(|e| e.to_string())?;+ doc+ } else {+ solvecraft_engine::io::read_design(&bytes).map_err(|e| e.to_string())?+ };let parse_ms = t.elapsed().as_secs_f64() * 1000.0;println!("{}", json!({"step": "parse", "ms": parse_ms, "features": doc.features.len()}));if args.iter().any(|a| a == "--parse-only") {diff --git a/apps/solvecraft/src/main.rs b/apps/solvecraft/src/main.rsindex a3a70162d9..f7e14d3f6a 100644--- a/apps/solvecraft/src/main.rs+++ b/apps/solvecraft/src/main.rs@@ -191,7 +191,7 @@ fn main() -> eframe::Result {app.session.undo.clear();}for f in &files {- app.open_path(f);+ app.open_path_async(f);}// No design given: the start page (not when driven over the control channel, whose// clients expect the design view; `ui.home` shows it there).diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex b72539d2e1..37c6ba5b54 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -19,7 +19,9 @@ pub struct ModelBody {pub body: Body,/// Feature that created it.pub feature: u64,- mesh: OnceLock<Arc<Mesh>>,+ // Timeline snapshots are cloned before meshes are requested. Share the cell itself so+ // meshing any snapshot also warms every unchanged copy of this body.+ mesh: Arc<OnceLock<Arc<Mesh>>>,/// Identity of this body's content for the evaluation cache: the key of the evaluation/// that produced it (kept while later features pass it through unchanged).key: u64,@@ -33,7 +35,7 @@ pub struct ModelBody {impl ModelBody {pub fn new(name: String, body: Body, feature: u64) -> Self {- ModelBody { name, body, feature, mesh: OnceLock::new(), key: 0, names: Default::default(), component: 0, imported: None }+ ModelBody { name, body, feature, mesh: Arc::new(OnceLock::new()), key: 0, names: Default::default(), component: 0, imported: None }}/// Display mesh (chord tolerance 1/1000 of the body size), computed once.pub fn mesh(&self) -> Arc<Mesh> {diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rsindex 9c983111d8..6e318aec49 100644--- a/crates/doc/src/tests.rs+++ b/crates/doc/src/tests.rs@@ -357,3 +357,12 @@ fn input_sketches_lists_every_variant_with_a_sketch_field() {);}}++#[test]+fn timeline_clones_share_meshes_even_when_cloned_before_tessellation() {+ let body = solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(10., 10., 10.)).unwrap();+ let a = crate::eval::ModelBody::new("box".into(), body, 1);+ let b = a.clone();+ assert!(std::sync::Arc::ptr_eq(&a.mesh(), &b.mesh()));+ assert!(!a.mesh().triangles.is_empty());+}diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex beb357bbc2..a69077697e 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -439,6 +439,42 @@ impl Session {}}+ /// Refresh UI caches when adopting a session or switching tabs, without discarding its+ /// already prepared world-space geometry. This does not change the document.+ 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,+ /// saved state, view state, checkpoints or earlier undo steps.+ pub fn accept_computed(&mut self, mut computed: Session) {+ let previous_revision = self.revision;+ self.doc = computed.doc;+ self.model = computed.model;+ self.world_cache = computed.world_cache;+ self.undo.append(&mut computed.undo);+ if self.undo.len() > MAX_UNDO {+ self.undo.drain(..self.undo.len() - MAX_UNDO);+ }+ self.redo = computed.redo;+ self.active_sketch = computed.active_sketch;+ self.selection = computed.selection;+ self.revision = computed.revision;+ self.invalidate_view(previous_revision);+ self.active_component = computed.active_component;+ self.pending_moves = computed.pending_moves;+ for message in computed.log {+ self.echo(message);+ }+ }+/// Live preview: run `commands` (id, parameters) on a scratch copy and return the model/// before and after. Nothing in this session changes (document, undo history, selection)./// A `timeline.redefine` is shown even while the timeline is rolled back to the featurediff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex 26f6317422..66523e7d00 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -2032,3 +2032,40 @@ fn drawing_on_existing_points_connects_to_them() {let si = run(&mut s, "sketch.inspect", json!({}));assert_ne!(si["status"], "conflict", "{si}");}++#[test]+fn computed_import_preserves_file_and_earlier_undo_history() {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10}));+ s.path = Some("existing.solvecraft".into());+ s.mark_saved();+ let saved = s.doc.clone();+ let mut computed = s.scratch();+ run(&mut computed, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [30, 0, 0]}));+ s.accept_computed(computed);+ assert_eq!(s.path.as_deref(), Some("existing.solvecraft"));+ assert!(s.is_dirty());+ assert_eq!(s.model.state().bodies.len(), 2);+ run(&mut s, "edit.undo", json!({}));+ assert!(std::sync::Arc::ptr_eq(&saved, &s.doc));+ assert!(!s.is_dirty());+ run(&mut s, "edit.undo", json!({}));+ assert!(s.model.state().bodies.is_empty());+}++#[test]+fn adopting_a_computed_component_keeps_its_warm_world_geometry() {+ let mut s = Session::default();+ run(&mut s, "component.create", json!({"name": "Part"}));+ run(&mut s, "solid.box", json!({"length":10,"width":10,"height":10}));+ let mut computed = s.scratch();+ run(&mut computed, "solid.box", json!({"length":5,"width":5,"height":5,"corner":[30,0,0]}));+ let prepared = computed.world_state();+ for b in &prepared.bodies {+ let _ = b.mesh();+ }+ s.accept_computed(computed);+ assert!(std::sync::Arc::ptr_eq(&prepared, &s.world_state()));+ s.invalidate_view(100);+ assert!(std::sync::Arc::ptr_eq(&prepared, &s.world_state()));+}diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex 90e1158344..41278c21e2 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -13,6 +13,8 @@ pub(crate) type Solid = mt::Solid;#[derive(Clone, Debug)]pub struct Body {pub(crate) solid: std::sync::Arc<Solid>,+ /// Missing-face check from the orientation mesh, reusable at exactly its tolerance.+ pub(crate) coarse_missing: Option<(f64, usize)>,/// Set for mesh bodies (`solid` is then empty).pub(crate) mesh: Option<std::sync::Arc<crate::meshbody::TriMesh>>,/// Display colour (linear RGB 0..1) from an imported file; operations drop it.@@ -302,11 +304,24 @@ impl Body {if lo.x.is_finite() { (hi - lo).len() } else { 1.0 }};let tol = (span * 0.01).clamp(1e-3, 1.0);- let v = guard("orient", || Ok(mesh_shells(&solid, tol).iter().map(|s| s.to_polygon().volume()).sum::<f64>()))?;+ let (v, missing) = guard("orient", || {+ let shells = mesh_shells(&solid, tol);+ let volume = shells.iter().map(|s| s.to_polygon().volume()).sum::<f64>();+ let missing =+ shells.iter().flat_map(|s| s.face_iter()).filter(|f| f.surface().is_none_or(|m| m.faces().triangle_iter().next().is_none())).count();+ Ok((volume, missing))+ })?;if v < 0.0 {solid.not();}- Ok(Body { solid: std::sync::Arc::new(solid), mesh: None, color: None, paint: None, splits: None })+ Ok(Body {+ solid: std::sync::Arc::new(solid),+ coarse_missing: (v >= 0.0).then_some((tol, missing)),+ mesh: None,+ color: None,+ paint: None,+ splits: None,+ })}/// A deep copy of the solid that can be mutated without affecting other bodies.@@ -506,7 +521,13 @@ impl Body {if self.is_mesh() {return 0;}- let Ok(m) = self.tessellate((self.size() * 1e-2).max(1e-3)) else { return self.face_count() };+ let tol = (self.size() * 1e-2).max(1e-3);+ if let Some((cached_tol, missing)) = self.coarse_missing+ && cached_tol == tol+ {+ return missing;+ }+ let Ok(m) = self.tessellate(tol) else { return self.face_count() };let mut has = vec![false; self.face_count()];for f in &m.tri_face {if let Some(h) = has.get_mut(*f as usize) {diff --git a/crates/kernel/src/meshbody.rs b/crates/kernel/src/meshbody.rsindex 7d2a967d29..4ec210a030 100644--- a/crates/kernel/src/meshbody.rs+++ b/crates/kernel/src/meshbody.rs@@ -101,7 +101,14 @@ pub fn mesh_body(positions: &[Vec3], triangles: &[[u32; 3]]) -> Result<Body> {t.swap(1, 2);}}- Ok(Body { solid: Arc::new(crate::body::Solid::new_unchecked(Vec::new())), mesh: Some(Arc::new(out)), color: None, paint: None, splits: None })+ Ok(Body {+ solid: Arc::new(crate::body::Solid::new_unchecked(Vec::new())),+ coarse_missing: None,+ mesh: Some(Arc::new(out)),+ color: None,+ paint: None,+ splits: None,+ })}/// Wind every connected piece one way: a triangle that runs a side in the same direction as@@ -185,6 +192,13 @@ impl Body {t.swap(1, 2);}}- Some(Body { solid: self.solid.clone(), mesh: Some(Arc::new(out)), color: self.color, paint: self.paint.clone(), splits: self.splits.clone() })+ Some(Body {+ solid: self.solid.clone(),+ coarse_missing: None,+ mesh: Some(Arc::new(out)),+ color: self.color,+ paint: self.paint.clone(),+ splits: self.splits.clone(),+ })}}diff --git a/crates/kernel/src/splitface.rs b/crates/kernel/src/splitface.rsindex c34326514f..2f904cd4df 100644--- a/crates/kernel/src/splitface.rs+++ b/crates/kernel/src/splitface.rs@@ -877,7 +877,10 @@ pub(crate) fn split_any(body: &Body, faces: &[usize], tool: &SplitTool) -> Resul}let shells = std::mem::take(&mut imp.shells);let solid = mt::Solid::new_unchecked(shells.into_iter().map(mt::Shell::from).collect());- Ok((Body { solid: std::sync::Arc::new(solid), mesh: None, color: body.color, paint: None, splits: body.splits.clone() }, imp))+ Ok((+ Body { solid: std::sync::Arc::new(solid), coarse_missing: None, mesh: None, color: body.color, paint: None, splits: body.splits.clone() },+ imp,+ ))})}diff --git a/crates/kernel/src/surfaces.rs b/crates/kernel/src/surfaces.rsindex 6bb964833a..10be23d37a 100644--- a/crates/kernel/src/surfaces.rs+++ b/crates/kernel/src/surfaces.rs@@ -22,7 +22,14 @@ impl Body {/// A body of faces as they are (no orientation fix: a surface has no inside).fn surface_body(faces: Vec<mt::Face>) -> Body {let shell = mt::Shell::from(faces);- Body { solid: std::sync::Arc::new(mt::Solid::new_unchecked(vec![shell])), mesh: None, color: None, paint: None, splits: None }+ Body {+ solid: std::sync::Arc::new(mt::Solid::new_unchecked(vec![shell])),+ coarse_missing: None,+ mesh: None,+ color: None,+ paint: None,+ splits: None,+ }}/// A body from faces: a solid when they close, else a surface.@@ -31,7 +38,14 @@ fn body_of(faces: Vec<mt::Face>) -> Result<Body> {if shell.shell_condition() == mt::ShellCondition::Closed {Body::new(mt::Solid::new_unchecked(vec![shell]))} else {- Ok(Body { solid: std::sync::Arc::new(mt::Solid::new_unchecked(vec![shell])), mesh: None, color: None, paint: None, splits: None })+ Ok(Body {+ solid: std::sync::Arc::new(mt::Solid::new_unchecked(vec![shell])),+ coarse_missing: None,+ mesh: None,+ color: None,+ paint: None,+ splits: None,+ })}}diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsindex 65cd107c92..8eb8b6c9a8 100644--- a/crates/kernel/src/tests.rs+++ b/crates/kernel/src/tests.rs@@ -1549,3 +1549,20 @@ fn raise_band_on_a_rounded_rim() {assert!((v - (v0 + band * 1.5)).abs() < 1e-5 * v, "outside {outside}: {v} vs {}", v0 + band * 1.5);}}++#[test]+fn orientation_mesh_reuses_missing_face_check_at_matching_tolerance() {+ for scale in [0.001, 1.0, 1000.0] {+ let body = box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.) * scale).unwrap();+ let tol = (body.size() * 0.01).max(1e-3);+ let mesh = body.tessellate(tol).unwrap();+ let mut present = vec![false; body.face_count()];+ for face in mesh.tri_face {+ present[face as usize] = true;+ }+ assert_eq!(body.unmeshed_faces(), present.iter().filter(|p| !**p).count());+ if scale == 1.0 {+ assert_eq!(body.coarse_missing, Some((tol, 0)));+ }+ }+}diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rsindex f5316b4fc0..7e8e2cb002 100644--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@ -127,13 +127,24 @@ pub fn handle(app: &mut SolveApp, ctx: &egui::Context, req: &ControlRequest) ->"hover": app.viewport.hover.as_ref().map(|h| format!("{h:?}")),"renderer": if app.viewport.gpu.is_some() { "gpu" } else { "cpu" },"frame_ms": app.frame_ms,+ "file_busy": app.file_load.busy(),"build_ms": app.viewport.build_ms,"preview": {"active": app.preview.active, "busy": app.preview.busy, "error": app.preview.error, "ms": app.preview.ms, "replaced": app.preview.replaced},"home": app.home.open,+ "recent_thumbnails_ready": app.home.ready_recents(),"documents": app.docs.count(),"quit_requested": app.quit_requested,"quitting": app.docs.quitting.is_some(),})),+ "ui.file" => {+ let Some(path) = s("path") else { return err("path is required") };+ if p.get("insert").and_then(Value::as_bool).unwrap_or(false) {+ app.insert_path_async(path);+ } else {+ app.open_path_async(path);+ }+ ok(json!({"busy": app.file_load.busy()}))+ }"ui.documents" => ok(crate::documents::control(app, p)),"ui.home" => {match p.get("open").and_then(Value::as_bool) {diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rsindex 4de61b928e..60a1ca1fea 100644--- a/crates/ui-egui/src/documents.rs+++ b/crates/ui-egui/src/documents.rs@@ -91,7 +91,7 @@ fn swap_in(app: &mut SolveApp, slot: DocSlot) -> DocSlot {};put_view(app, slot.view);// Views cache by revision: the incoming design must not look unchanged.- app.session.revision = app.session.revision.max(out_rev) + 1;+ app.session.invalidate_view(out_rev);app.ui.tab = if app.session.active_sketch.is_some() { "SKETCH".into() } else { "SOLID".into() };out}@@ -141,7 +141,7 @@ pub fn adopt(app: &mut SolveApp, session: Session) {crate::dialogs::cancel(app);app.tool = None;app.session = session;- app.session.revision = app.session.revision.max(rev) + 1;+ app.session.invalidate_view(rev);app.cam = Camera::default();app.fit_view();} else if let Err(e) = open_tab(app, session) {diff --git a/crates/ui-egui/src/file_load.rs b/crates/ui-egui/src/file_load.rsnew file mode 100644index 0000000000..5d2644d3cc--- /dev/null+++ b/crates/ui-egui/src/file_load.rs@@ -0,0 +1,261 @@+//! Interactive file operations run off the window thread. The old design stays intact until+//! the command and display meshes are ready; failures and cancelled jobs never replace it.++use std::collections::VecDeque;+use std::sync::{+ Arc,+ atomic::{AtomicBool, AtomicU8, Ordering},+ mpsc::{Receiver, TryRecvError},+};++use serde_json::Value;+#[cfg(not(target_arch = "wasm32"))]+use serde_json::json;+use solvecraft_engine::{Session, doc::Document};++use crate::SolveApp;++struct Request {+ path: String,+ insert: bool,+}+struct Made {+ session: Session,+ result: Value,+ image: Option<egui::ColorImage>,+}+type Job = Result<Made, String>;+struct Running {+ request: Request,+ base: Arc<Document>,+ before: Vec<String>,+ rx: Receiver<Job>,+ phase: Arc<AtomicU8>,+ cancelled: Arc<AtomicBool>,+}++#[derive(Default)]+pub struct FileLoad {+ queued: VecDeque<Request>,+ running: Option<Running>,+}++impl FileLoad {+ pub fn busy(&self) -> bool {+ self.running.as_ref().is_some_and(|r| !r.cancelled.load(Ordering::Relaxed)) || !self.queued.is_empty()+ }+}++pub fn begin(app: &mut SolveApp, path: &str, insert: bool) {+ #[cfg(target_arch = "wasm32")]+ {+ if insert {+ app.insert_path(path);+ } else {+ app.open_path(path);+ }+ }+ #[cfg(not(target_arch = "wasm32"))]+ {+ if app.file_load.queued.len() >= crate::documents::MAX_OPEN {+ app.set_status("too many queued files", true);+ return;+ }+ app.file_load.queued.push_back(Request { path: path.into(), insert });+ start(app);+ }+}++#[cfg(not(target_arch = "wasm32"))]+fn start(app: &mut SolveApp) {+ if app.file_load.running.is_some() {+ return;+ }+ let Some(request) = app.file_load.queued.pop_front() else { return };+ if !request.insert && app.docs.count() >= crate::documents::MAX_OPEN && !crate::documents::active_is_blank(app) {+ app.set_status("too many open designs; close a tab before opening another", true);+ return;+ }+ let before = if request.insert { app.session.world_state().bodies.iter().map(|b| b.name.clone()).collect() } else { Vec::new() };+ let mut scratch = if request.insert { app.session.scratch() } else { Session::default() };+ if request.insert {+ scratch.selection = app.session.selection.clone();+ }+ let base = app.session.doc.clone();+ let phase = Arc::new(AtomicU8::new(0));+ let worker_phase = phase.clone();+ let cancelled = Arc::new(AtomicBool::new(false));+ let worker_cancelled = cancelled.clone();+ let (tx, rx) = std::sync::mpsc::channel();+ let path = request.path.clone();+ let insert = request.insert;+ let spawned = std::thread::Builder::new().name("file-load".into()).spawn(move || {+ let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| compute(scratch, &path, insert, &worker_phase, &worker_cancelled)))+ .unwrap_or_else(|_| Err("the file operation failed; the current design is unchanged".into()));+ let _ = tx.send(result);+ });+ match spawned {+ Ok(_) => app.file_load.running = Some(Running { request, base, before, rx, phase, cancelled }),+ Err(e) => app.set_status(format!("could not start file operation: {e}"), true),+ }+}++#[cfg(not(target_arch = "wasm32"))]+fn compute(mut session: Session, path: &str, insert: bool, phase: &AtomicU8, cancelled: &AtomicBool) -> Job {+ if cancelled.load(Ordering::Relaxed) {+ return Err("file operation cancelled".into());+ }+ let command = if !insert {+ "doc.open"+ } else if solvecraft_engine::io::is_mesh_path(path) {+ "file.insert_mesh"+ } else {+ "file.insert_step"+ };+ let result = session.execute(command, &json!({"path": path})).map_err(|e| e.to_string())?;+ phase.store(1, Ordering::Relaxed);+ // Fit, picking and the first viewport frame must not trigger cold tessellation on the UI.+ for b in &session.world_state().bodies {+ if cancelled.load(Ordering::Relaxed) {+ return Err("file operation cancelled".into());+ }+ let _ = b.mesh();+ }+ phase.store(2, Ordering::Relaxed);+ let image = if insert { None } else { crate::home::remember(&session) };+ Ok(Made { session, result, image })+}++pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {+ let result = app.file_load.running.as_ref().and_then(|r| match r.rx.try_recv() {+ Ok(job) => Some(job),+ Err(TryRecvError::Empty) => None,+ Err(TryRecvError::Disconnected) => Some(Err("the file operation stopped; the current design is unchanged".into())),+ });+ if let Some(job) = result+ && let Some(running) = app.file_load.running.take()+ {+ match job {+ _ if running.cancelled.load(Ordering::Relaxed) => {}+ Ok(made) if !running.request.insert || Arc::ptr_eq(&app.session.doc, &running.base) => {+ if running.request.insert {+ app.session.accept_computed(made.session);+ app.big_operation = true;+ } else {+ crate::documents::adopt(app, made.session);+ app.home.add_recent(&running.request.path);+ crate::home::install(&mut app.home, ctx, &running.request.path, made.image);+ }+ app.home.open = false;+ app.fit_view();+ crate::stand_up::offer(app, &running.request.path, &running.before);+ let warnings = made.result.get("warnings").and_then(Value::as_array);+ app.set_status(+ if let Some(w) = warnings.filter(|w| !w.is_empty()) {+ format!("imported with {} warning(s): {}", w.len(), w.first().and_then(Value::as_str).unwrap_or(""))+ } else {+ format!("{} done", if running.request.insert { "Insert" } else { "Open" })+ },+ false,+ );+ }+ Ok(_) => app.set_status("the active design changed while importing; the import was discarded", true),+ Err(e) => app.set_status(e, true),+ }+ }+ #[cfg(not(target_arch = "wasm32"))]+ start(app);+ if app.file_load.busy() {+ ctx.request_repaint_after(std::time::Duration::from_millis(16));+ }+}++pub fn show(app: &mut SolveApp, ctx: &egui::Context) {+ let Some(r) = &app.file_load.running else { return };+ let cancelled = r.cancelled.load(Ordering::Relaxed);+ if cancelled && app.file_load.queued.is_empty() {+ return;+ }+ let name = std::path::Path::new(&r.request.path).file_name().map(|p| p.to_string_lossy()).unwrap_or_default();+ let phase = r.phase.load(Ordering::Relaxed);+ let mut cancel = false;+ egui::Modal::new(egui::Id::new("file_loading")).show(ctx, |ui| {+ ui.heading(if cancelled {+ "Waiting for file operation"+ } else if r.request.insert {+ "Inserting geometry"+ } else {+ "Opening design"+ });+ ui.label(name.as_ref());+ ui.horizontal(|ui| {+ ui.spinner();+ ui.label(if cancelled {+ "Waiting for the previous operation to stop..."+ } else {+ match phase {+ 1 => "Preparing the view...",+ 2 => "Preparing the thumbnail...",+ _ => "Reading and building geometry...",+ }+ });+ });+ cancel = ui.button("Cancel").clicked();+ });+ if cancel {+ // Keep the running job until it exits: cancelling must not allow another large+ // import to overlap it in memory. The user can continue editing the current design.+ if let Some(r) = &app.file_load.running {+ r.cancelled.store(true, Ordering::Relaxed);+ }+ app.file_load.queued.clear();+ app.set_status("file operation cancelled", false);+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ #[test]+ fn failed_import_keeps_the_current_document() {+ let mut app = SolveApp::new(Session::default(), Default::default());+ let old = app.session.doc.clone();+ let (tx, rx) = std::sync::mpsc::channel();+ tx.send(Err("bad STEP".into())).unwrap();+ app.file_load.running = Some(Running {+ request: Request { path: "bad.step".into(), insert: true },+ base: old.clone(),+ before: Vec::new(),+ rx,+ phase: Arc::new(AtomicU8::new(0)),+ cancelled: Arc::new(AtomicBool::new(false)),+ });+ tick(&mut app, &egui::Context::default());+ assert!(Arc::ptr_eq(&app.session.doc, &old));+ assert!(!app.file_load.busy());+ assert!(app.status.as_ref().unwrap().0.contains("bad STEP"));+ }+ #[test]+ fn cancelling_discards_a_finished_result_and_keeps_the_worker_slot_until_completion() {+ let mut app = SolveApp::new(Session::default(), Default::default());+ let old = app.session.doc.clone();+ let (tx, rx) = std::sync::mpsc::channel();+ let cancelled = Arc::new(AtomicBool::new(true));+ app.file_load.running = Some(Running {+ request: Request { path: "cancelled.step".into(), insert: true },+ base: old.clone(),+ before: Vec::new(),+ rx,+ phase: Arc::new(AtomicU8::new(0)),+ cancelled,+ });+ assert!(!app.file_load.busy());+ assert!(app.file_load.running.is_some());+ let mut computed = Session::default();+ computed.execute("solid.box", &serde_json::json!({"length":10,"width":10,"height":10})).unwrap();+ tx.send(Ok(Made { session: computed, result: Value::Null, image: None })).unwrap();+ tick(&mut app, &egui::Context::default());+ assert!(app.file_load.running.is_none());+ assert!(Arc::ptr_eq(&old, &app.session.doc));+ }+}diff --git a/crates/ui-egui/src/home.rs b/crates/ui-egui/src/home.rsindex deab41d25f..a0433e9849 100644--- a/crates/ui-egui/src/home.rs+++ b/crates/ui-egui/src/home.rs@@ -31,11 +31,17 @@ pub struct HomeState {queued: Vec<String>,#[cfg(not(target_arch = "wasm32"))]rx: Option<std::sync::mpsc::Receiver<Made>>,+ #[cfg(not(target_arch = "wasm32"))]+ remembering: Option<std::sync::mpsc::Receiver<Made>>,/// A sample picked before its design was ready.wanted: Option<usize>,}impl HomeState {+ pub fn ready_recents(&self) -> usize {+ self.recent.iter().filter(|p| self.thumbs.get(*p).is_some_and(Option::is_some)).count()+ }+pub fn show(&mut self, _rev: u64) {self.open = true;}@@ -67,8 +73,104 @@ pub fn thumbnail(s: &Session) -> Option<egui::ColorImage> {(c.rgba.len() == c.w * c.h * 4).then(|| egui::ColorImage::from_rgba_unmultiplied([c.w, c.h], &c.rgba))}+/// File identity, not just its path: saving or replacing a design invalidates its picture.+#[cfg(not(target_arch = "wasm32"))]+fn cache_path(key: &str) -> Option<std::path::PathBuf> {+ use std::hash::{Hash, Hasher};+ let meta = std::fs::metadata(key).ok()?;+ let mut h = std::collections::hash_map::DefaultHasher::new();+ key.hash(&mut h);+ meta.len().hash(&mut h);+ meta.modified().ok()?.duration_since(std::time::UNIX_EPOCH).ok()?.hash(&mut h);+ let root = std::env::var_os("LOCALAPPDATA")+ .or_else(|| std::env::var_os("XDG_CACHE_HOME"))+ .map(std::path::PathBuf::from)+ .unwrap_or_else(std::env::temp_dir);+ Some(root.join("SolveCraft").join("thumbnails").join(format!("{:016x}.png", h.finish())))+}++#[cfg(not(target_arch = "wasm32"))]+fn cached(key: &str) -> Option<egui::ColorImage> {+ let path = cache_path(key)?;+ if std::fs::metadata(&path).ok()?.len() > 512 * 1024 {+ return None;+ }+ let bytes = std::fs::read(path).ok()?;+ let mut reader = image::ImageReader::with_format(std::io::Cursor::new(bytes), image::ImageFormat::Png);+ let mut limits = image::Limits::default();+ limits.max_image_width = Some(THUMB[0] as u32);+ limits.max_image_height = Some(THUMB[1] as u32);+ limits.max_alloc = Some((THUMB[0] * THUMB[1] * 8) as u64);+ reader.limits(limits);+ let image = reader.decode().ok()?.to_rgba8();+ (image.width() as usize == THUMB[0] && image.height() as usize == THUMB[1])+ .then(|| egui::ColorImage::from_rgba_unmultiplied(THUMB, image.as_raw()))+}++/// Render from the model already built by Open/Save, rather than evaluating its file again.+pub(crate) fn remember(s: &Session) -> Option<egui::ColorImage> {+ #[cfg(not(target_arch = "wasm32"))]+ let identity = s.path.as_deref().and_then(cache_path);+ remember_at(+ s,+ #[cfg(not(target_arch = "wasm32"))]+ identity,+ )+}++fn remember_at(s: &Session, #[cfg(not(target_arch = "wasm32"))] identity: Option<std::path::PathBuf>) -> Option<egui::ColorImage> {+ let img = thumbnail(s)?;+ #[cfg(not(target_arch = "wasm32"))]+ if let Some(path) = identity.filter(|p| s.path.as_deref().and_then(cache_path).as_ref() == Some(p)) {+ let rgba: Vec<u8> = img.pixels.iter().flat_map(|c| c.to_srgba_unmultiplied()).collect();+ if let Some(bytes) = solvecraft_engine::render::png(THUMB[0], THUMB[1], rgba)+ && let Some(dir) = path.parent()+ && std::fs::create_dir_all(dir).is_ok()+ {+ let _ = solvecraft_engine::io::write_atomic(&path, &bytes, false);+ }+ }+ Some(img)+}++pub(crate) fn remember_session(h: &mut HomeState, s: &Session) {+ #[cfg(not(target_arch = "wasm32"))]+ if let Some(path) = &s.path {+ let identity = cache_path(path);+ let mut snapshot = s.scratch();+ snapshot.path = Some(path.clone());+ let key = path.clone();+ let (tx, rx) = std::sync::mpsc::channel();+ if std::thread::Builder::new()+ .name("saved-thumbnail".into())+ .spawn(move || {+ let img = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| remember_at(&snapshot, identity))).ok().flatten();+ let _ = tx.send((key, img, None));+ })+ .is_ok()+ {+ h.remembering = Some(rx);+ h.queued.retain(|k| k != path);+ h.thumbs.insert(path.clone(), None);+ }+ }+ #[cfg(target_arch = "wasm32")]+ {+ let _ = (h, s);+ }+}++pub(crate) fn install(h: &mut HomeState, ctx: &egui::Context, key: &str, img: Option<egui::ColorImage>) {+ let tex = img.map(|i| ctx.load_texture(format!("thumb:{key}"), i, egui::TextureOptions::LINEAR));+ h.thumbs.insert(key.to_string(), tex);+}+/// Build what a key stands for (runs off the UI thread where threads exist).fn make(key: &str) -> Made {+ #[cfg(not(target_arch = "wasm32"))]+ if let Some(img) = cached(key) {+ return (key.to_string(), Some(img), None);+ }let mut s = Session::default();let built = match key.strip_prefix("sample:").and_then(|i| i.parse::<usize>().ok()) {Some(i) => solvecraft_engine::sample::samples().get(i).is_some_and(|smp| {@@ -83,7 +185,7 @@ fn make(key: &str) -> Made {if !built {return (key.to_string(), None, None);}- let img = thumbnail(&s);+ let img = remember(&s);(key.to_string(), img, key.starts_with("sample:").then_some(s))}@@ -92,7 +194,18 @@ fn start_jobs(h: &mut HomeState) {if h.rx.is_some() || h.queued.is_empty() {return;}- let keys = std::mem::take(&mut h.queued);+ let mut keys = std::mem::take(&mut h.queued);+ // Cached recents first, then cold recents, then samples. A sample must never hold up+ // pictures of the user's work; a cold file must not hold up already cached pictures.+ keys.sort_by_key(|k| {+ if k.starts_with("sample:") {+ 2+ } else if cache_path(k).is_some_and(|p| p.exists()) {+ 0+ } else {+ 1+ }+ });let (tx, rx) = std::sync::mpsc::channel();let spawned = std::thread::Builder::new().name("thumbnails".into()).spawn(move || {for k in keys {@@ -112,12 +225,31 @@ fn start_jobs(h: &mut HomeState) {fn poll(app: &mut SolveApp, ctx: &egui::Context) {let mut done: Vec<Made> = Vec::new();#[cfg(not(target_arch = "wasm32"))]+ let mut remembered = None;+ #[cfg(not(target_arch = "wasm32"))]{+ if let Some(rx) = &app.home.remembering {+ match rx.try_recv() {+ Ok(m) => {+ remembered = Some(m);+ app.home.remembering = None;+ }+ Err(std::sync::mpsc::TryRecvError::Disconnected) => app.home.remembering = None,+ Err(std::sync::mpsc::TryRecvError::Empty) => {+ ctx.request_repaint_after(std::time::Duration::from_millis(16));+ }+ }+ }start_jobs(&mut app.home);if let Some(rx) = &app.home.rx {loop {match rx.try_recv() {- Ok(m) => done.push(m),+ Ok(m) => {+ // A cold job started before a save/open cannot overwrite its fresh picture.+ if m.0.starts_with("sample:") || !app.home.thumbs.get(&m.0).is_some_and(Option::is_some) {+ done.push(m);+ }+ }Err(std::sync::mpsc::TryRecvError::Empty) => break,Err(std::sync::mpsc::TryRecvError::Disconnected) => {app.home.rx = None;@@ -126,6 +258,9 @@ fn poll(app: &mut SolveApp, ctx: &egui::Context) {}}}+ if let Some(m) = remembered {+ done.push(m);+ }if app.home.rx.is_some() {ctx.request_repaint_after(std::time::Duration::from_millis(100));}@@ -185,7 +320,7 @@ pub fn open_recent(app: &mut SolveApp, path: &str) {return;}app.home.open = false;- app.open_path(path);+ app.open_path_async(path);}/// The page itself (in place of the toolbar, browser and viewport).@@ -250,7 +385,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {action = Some(Box::new(|app: &mut SolveApp| {if let Some(p) = app.services.pick_open.as_ref().and_then(|f| f()) {app.home.open = false;- app.open_path(&p);+ app.open_path_async(&p);}}));}@@ -416,6 +551,30 @@ fn card(ui: &mut egui::Ui, pic: Pic, name: &str, sub: &str, dim: bool) -> egui::mod tests {use super::*;+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ fn cached_recent_uses_a_separate_png_without_reading_or_changing_design_json() {+ let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();+ let path = std::env::temp_dir().join(format!("solvecraft-thumb-{}-{nonce}.solvecraft", std::process::id()));+ // Deliberately invalid design: a cached recent must not parse/evaluate it.+ let bytes = b"{\"thumbnail_test\":true}";+ std::fs::write(&path, bytes).unwrap();+ let key = path.to_string_lossy().to_string();+ let mut s = Session::default();+ s.execute("solid.box", &serde_json::json!({"length":10,"width":10,"height":10})).unwrap();+ s.path = Some(key.clone());+ let image = remember(&s).unwrap();+ let png = cache_path(&key).unwrap();+ assert_eq!(std::fs::read(&path).unwrap(), bytes);+ let (_, cached_image, session) = make(&key);+ assert!(session.is_none());+ assert_eq!(cached_image.unwrap().pixels, image.pixels);+ std::fs::write(&path, b"changed file identity").unwrap();+ assert!(cached(&key).is_none());+ std::fs::remove_file(path).unwrap();+ std::fs::remove_file(png).unwrap();+ }+#[test]fn recent_list_is_newest_first_and_bounded() {let mut h = HomeState::default();diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 35a254d7a9..34b7b49f1c 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -54,6 +54,7 @@ mod status_tests {assert!(app.session.log.last().is_some_and(|l| l.starts_with("Redo: ") && !l.contains("edit.redo")), "{:?}", app.session.log.last());}}+mod file_load;pub mod palette;pub mod params_dialog;pub mod prefs;@@ -230,6 +231,7 @@ pub struct SolveApp {fitted: bool,/// The start page.pub home: home::HomeState,+ pub file_load: file_load::FileLoad,/// The other open designs (tabs).pub docs: documents::Documents,}@@ -281,6 +283,7 @@ impl SolveApp {styled: false,fitted: false,home: home::HomeState::default(),+ file_load: file_load::FileLoad::default(),docs: documents::Documents::default(),}}@@ -388,6 +391,9 @@ impl SolveApp {/// Run a command programmatically (JSON parameters, no dialogs).pub fn run(&mut self, id: &str, params: Value) -> Result<Value, String> {+ if self.file_load.busy() {+ return Err("a file operation is in progress".into());+ }let t0 = now_ms();let r = self.session.execute(id, ¶ms).map_err(|e| e.to_string());self.big_operation |= now_ms() - t0 >= recovery_ui::BIG_OPERATION_MS;@@ -406,6 +412,9 @@ impl SolveApp {&& let Some(p) = self.session.path.clone(){self.home.add_recent(&p);+ if matches!(id, "file.save" | "file.save_as") {+ home::remember_session(&mut self.home, &self.session);+ }}}Err(e) => {@@ -441,7 +450,7 @@ impl SolveApp {}if matches!(id, "file.insert_step" | "file.insert_mesh") {if let Some(p) = self.services.pick_open.as_ref().and_then(|f| f()) {- self.insert_path(&p);+ self.insert_path_async(&p);}return;}@@ -622,6 +631,13 @@ impl SolveApp {}}+ pub fn open_path_async(&mut self, path: &str) {+ file_load::begin(self, path, false);+ }+ pub fn insert_path_async(&mut self, path: &str) {+ file_load::begin(self, path, true);+ }+/// Insert a STEP file's bodies (an Import base feature) or a 3MF/STL file's meshes into the/// current design.pub fn insert_path(&mut self, path: &str) {@@ -641,9 +657,9 @@ impl SolveApp {pub fn drop_path(&mut self, path: &str) {let import = solvecraft_engine::io::is_step_path(path) || solvecraft_engine::io::is_mesh_path(path);if import && !self.session.doc.features.is_empty() {- self.insert_path(path);+ self.insert_path_async(path);} else {- self.open_path(path);+ self.open_path_async(path);}}@@ -733,6 +749,7 @@ impl SolveApp {/// Per-frame logic before layout.pub fn logic(&mut self, ctx: &egui::Context) {+ file_load::tick(self, ctx);self.esc_handled = false;prefs::apply(self, ctx);if !self.styled || theme::is_dark() != self.ui.dark {@@ -798,6 +815,7 @@ impl SolveApp {let t0 = now_ms();scenario::clear_handles();toolbar::app_bar(self, ui);+ file_load::show(self, ui.ctx());documents::prompt(self, ui.ctx());if self.home.open {home::show(self, ui);diff --git a/crates/ui-egui/src/scenario.rs b/crates/ui-egui/src/scenario.rsindex 476ae7dafe..4508db5710 100644--- a/crates/ui-egui/src/scenario.rs+++ b/crates/ui-egui/src/scenario.rs@@ -865,7 +865,7 @@ pub fn check(h: &mut Harness, e: &Value) -> Result<(), String> {}}}- "quit_requested" | "quitting" => {+ "file_busy" | "quit_requested" | "quitting" => {if ui[k] != *v {return Err(format!("{k}: got {}, want {v}", ui[k]));}diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rsindex 3bd4ccab77..8e3571c662 100644--- a/crates/ui-egui/src/toolbar.rs+++ b/crates/ui-egui/src/toolbar.rs@@ -161,7 +161,7 @@ fn file_menu(app: &mut SolveApp, ctx: &egui::Context) {}if item(ui, "Open…", "Ctrl+O") {if let Some(p) = app.services.pick_open.as_ref().and_then(|f| f()) {- app.open_path(&p);+ app.open_path_async(&p);}close = true;}@@ -531,6 +531,9 @@ fn caret(p: &egui::Painter, c: egui::Pos2, col: Color32) {/// Global keyboard shortcuts (when no text field has focus).pub fn shortcuts(app: &mut SolveApp, ctx: &egui::Context) {+ if app.file_load.busy() {+ return;+ }// The Keyboard Shortcuts window is waiting for a key: it is not a shortcut.if crate::keymap::capturing(app) {return;@@ -554,7 +557,7 @@ pub fn shortcuts(app: &mut SolveApp, ctx: &egui::Context) {Key::Comma => crate::prefs::open_at(app, 0),Key::O => {if let Some(p) = app.services.pick_open.as_ref().and_then(|f| f()) {- app.open_path(&p);+ app.open_path_async(&p);}}_ => {diff --git a/crates/ui-egui/tests/scenarios.rs b/crates/ui-egui/tests/scenarios.rsindex 0574bb2074..604766c8da 100644--- a/crates/ui-egui/tests/scenarios.rs+++ b/crates/ui-egui/tests/scenarios.rs@@ -80,6 +80,7 @@ fn home_tab_and_file_recent_open_designs() {{"expect":{"home":false,"bodies":1}},{"click":{"handle":"tab:home"}},{"click":{"handle":"home:recent:0"}},+ {"until":{"file_busy":false}},{"expect":{"home":false,"bodies":1,"documents":2}},{"click":{"handle":"appbar:folder"}},{"widget":"Open Recent"}@@ -87,6 +88,7 @@ fn home_tab_and_file_recent_open_designs() {.unwrap();h.run(&json!([{"widget":path},+ {"until":{"file_busy":false}},{"expect":{"home":false,"bodies":1,"documents":3}}])).unwrap();diff --git a/crates/ui-egui/tests/scenarios/s09_step_roundtrip_hole.json b/crates/ui-egui/tests/scenarios/s09_step_roundtrip_hole.jsonindex be90b4df70..46de4f33be 100644--- a/crates/ui-egui/tests/scenarios/s09_step_roundtrip_hole.json+++ b/crates/ui-egui/tests/scenarios/s09_step_roundtrip_hole.json@@ -83,6 +83,7 @@{"widget": "Insert STEP\u2026"},+ {"until": {"file_busy": false}},{"debug": 1},diff --git a/crates/ui-egui/tests/scenarios/s15_start_page_sample_save_reopen.json b/crates/ui-egui/tests/scenarios/s15_start_page_sample_save_reopen.jsonindex f74333ca7f..b9b0afdc53 100644--- a/crates/ui-egui/tests/scenarios/s15_start_page_sample_save_reopen.json+++ b/crates/ui-egui/tests/scenarios/s15_start_page_sample_save_reopen.json@@ -18,6 +18,7 @@{"expect": {"bodies": 0}},{"choose_file": "Sample Plate.solvecraft"},{"key": "O", "cmd": true},+ {"until": {"file_busy": false}},{"debug": 1},{"expect": {"bodies": 1, "errors": 0, "param": {"width": 100}}},{"shot": "s15_reopened"}diff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex 3d4490b58e..35a82c202a 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -46,6 +46,7 @@ Commands never open dialogs when run this way. `solvecraft-cli commands` prints| `ui.render` | `path`, `width?`, `height?` | CPU render of the model with the current camera (no window needed) || `ui.confirm` | `accept?`: bool | answers the Delete confirmation (shown when a delete takes other features with it or makes some fail); without `accept`, what it lists || `ui.documents` | `action?`: `new`, `switch`, `close`, `quit`; `index?`; `force?` (close without asking); `answer?`: `save`, `dont_save`, `cancel` (answers "save changes?") | the open designs (tabs): names, unsaved flags, the active one, a pending "save changes?" prompt, whether a quit is asking |+| `ui.file` | `path`; `insert?`: bool | starts an interactive background Open or Insert; poll `ui.inspect.file_busy` for completion; the window stays responsive || `ui.home` | `open?`: bool; `sample?`: index | the start page: show or hide it, open a built-in sample (once built); returns `open` and the recent designs || `ui.shortcut` | `command`, `key?`, `replace?` | a command's key, or rebinds it (`""` clears; a key another command uses is refused unless `replace`) || `ui.help` | `item?`: `about`, `shortcuts` (read only), `report` (copies diagnostics) | the version, commit, build date and diagnostic text |diff --git a/docs/perf.md b/docs/perf.mdindex b1d29feaa3..89fca73755 100644--- a/docs/perf.md+++ b/docs/perf.md@@ -113,3 +113,43 @@ errors) through edits, suppression, roll-back, undo and redo. Setting a sketch dcan still recompute (oracle 61, 62): solving the sketch moves its points by rounding noise, soits inputs are not exactly the old ones. Oracle 59's first parameter edit fails (a recipeexpression the bench's `* 1.02` can't scale) and is left out.+++## Desktop loading and recent thumbnails (2026-10-10)++The Arduino Uno enclosure (19 features, 34 KB) and Raspberry Pi 5 case (24 features,+61 KB) each decode in about 1 ms. A release build spends roughly 12.1 s and 8.2 s,+respectively, evaluating their geometry on this Windows machine. Changing the document+encoding does not eliminate these boolean operations.++Interactive Open, recent-file clicks, drag/drop and STEP/mesh insertion now execute on a+worker, including preparation of the world-space bodies and display meshes. The existing+design stays available until the result is ready; a failed or cancelled job cannot replace+it. Insertion preserves the file, saved state, earlier undo history and view settings.+Timeline copies share their lazy mesh cell, and adopting a prepared session keeps its warm+world-space cache instead of transforming and tessellating its components again on the UI.+A STEP body's missing-face check reuses its orientation tessellation when the tolerances+match and its orientation was not reversed.++Live desktop tests (`ci` profile, with other builds/tests running) opened the Arduino and+Pi case in 15.2 s and 10.5 s. During those jobs, median `ui.inspect` round trips were 20.5 ms+and 8.3 ms; the slowest were 33.7 ms and 28.6 ms. This fixes the window freeze, not the+remaining cost of cold geometry evaluation.++Recent thumbnails are 240 � 150 PNG files in `SolveCraft/thumbnails` under the platform+cache directory (`LOCALAPPDATA` on Windows). Their keys include the source path, file size+and modification time. Open and Save render from the model already in memory. Cached+recents decode the PNG without reading or rebuilding a document, and run before cold+recents and sample thumbnails. Missing or invalid pictures fall back to a background rebuild.+No thumbnail or base64 image is added to the design JSON. A regression test verifies the+source bytes remain unchanged, a cached picture works even without a parseable source+file, and changing the source invalidates the cache.++`solvecraft-cli bench-open` also accepts STEP/IGES. For exchange files its `parse` phase+includes constructing and checking the imported B-rep, not merely decoding STEP syntax.++The live test loaded both cached recent cards in 21 ms and inserted the 2 MB lightweight+Pi STEP (27 bodies) into the case in 279 ms; undo restored the original two bodies. The+full 77 MB board STEP (2689 solid definitions, 45,689 faces) still had not completed after+300 s. Its window continued handling inspection and Cancel, and cancelling preserved the+case. Complex STEP construction remains an outstanding kernel performance problem.