SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Open saved designs from the model they were saved with (#3053) (#3102)
bherbrucke98e065584c6
diff --git a/apps/solidcraft-cli/src/main.rs b/apps/solidcraft-cli/src/main.rsindex dec00af12d..9030066b91 100644--- a/apps/solidcraft-cli/src/main.rs+++ b/apps/solidcraft-cli/src/main.rs@@ -654,24 +654,27 @@ pub(crate) fn cmd_bench_open(args: &[String]) -> Result<(), String> {let t = std::time::Instant::now();// The file as read, held until the timeline has evaluated it (as the import command does).let mut read = None;- let doc = if step {+ let (doc, saved) = if step {let imported = solidcraft_engine::io::step_import_feature(&bytes, path).map_err(|e| e.to_string())?;let mut doc = solidcraft_engine::doc::Document::new(&imported.name);doc.add_feature(imported.kind, Some(&imported.name)).map_err(|e| e.to_string())?;read = Some(imported.import);- doc+ (doc, None)} else {- solidcraft_engine::io::read_design(&bytes).map_err(|e| e.to_string())?+ // As Open reads it: with the model the file keeps.+ solidcraft_engine::io::read_design_file(path, None::<fn(solidcraft_engine::io::DesignPreview)>).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()}));+ println!("{}", json!({"step": "parse", "ms": parse_ms, "features": doc.features.len(), "saved_model": saved.is_some()}));if args.iter().any(|a| a == "--parse-only") {return Ok(());}let t = std::time::Instant::now();- let s = Session::new(doc);+ let s = Session::opened(doc, saved.as_ref());drop(read);- println!("{}", json!({"step": "evaluate", "ms": t.elapsed().as_secs_f64() * 1000.0}));+ // Taken from the file: nothing evaluated (SOLIDCRAFT_NO_MODEL_CACHE evaluates anyway).+ let adopted = saved.is_some() && s.model.last_recomputed == 0;+ println!("{}", json!({"step": "evaluate", "ms": t.elapsed().as_secs_f64() * 1000.0, "adopted": adopted}));for r in &s.model.results {println!("{}", json!({"step": "feature", "id": r.id, "name": r.name, "ms": r.ms, "error": r.error}));}diff --git a/apps/solidcraft-cli/tests/model_cache.rs b/apps/solidcraft-cli/tests/model_cache.rsnew file mode 100644index 0000000000..6d4bab4eb8--- /dev/null+++ b/apps/solidcraft-cli/tests/model_cache.rs@@ -0,0 +1,209 @@+//! A design opened from the model its file keeps is the design evaluated again: the same+//! results, the same bodies (to the bit), the same face names and volumes after every feature,+//! and the same after an edit made to both.++use std::path::{Path, PathBuf};+use std::sync::Arc;++use serde_json::{Value, json};+use solidcraft_engine::Session;+use solidcraft_engine::doc::{ModelBody, ModelState};++fn corpus() -> Vec<PathBuf> {+ let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/corpus");+ let mut v: Vec<PathBuf> =+ std::fs::read_dir(&dir).unwrap().flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "solidcraft")).collect();+ v.sort();+ v+}++fn temp(name: &str) -> PathBuf {+ std::env::temp_dir().join(format!("solidcraft-model-cache-{}-{name}.solidcraft", std::process::id()))+}++fn open(path: &Path) -> Session {+ let mut s = Session::default();+ s.execute("doc.open", &json!({"path": path.to_string_lossy()})).unwrap_or_else(|e| panic!("{}: {e}", path.display()));+ s+}++fn body(name: &str, b: &ModelBody) -> Value {+ let measured = solidcraft_engine::kernel::measure(&b.body).ok();+ json!({+ "name": b.name, "feature": b.feature, "component": b.component, "source": b.source_name, "transferred": b.transferred,+ "brep": solidcraft_engine::kernel::encode_native_body(&b.body).map(|bytes| format!("{:x}", sha(&bytes))).unwrap_or_else(|e| format!("{name}: {e}")),+ "faces": *solidcraft_engine::doc::naming::face_names(b),+ "volume": measured.as_ref().map(|m| m.volume.to_bits()), "area": measured.as_ref().map(|m| m.area.to_bits()),+ "look": b.imported.as_ref().map(|l| format!("{l:?}")),+ })+}++fn sha(bytes: &[u8]) -> u128 {+ use std::hash::{Hash, Hasher};+ let mut h = std::collections::hash_map::DefaultHasher::new();+ bytes.hash(&mut h);+ let a = h.finish();+ bytes.len().hash(&mut h);+ (u128::from(a) << 64) | u128::from(h.finish())+}++fn state(name: &str, st: &Arc<ModelState>) -> Value {+ json!({+ "bodies": st.bodies.iter().map(|b| body(name, b)).collect::<Vec<_>>(),+ "sketches": st.sketches.iter().map(|s| json!([s.feature, s.name, s.plane, s.sketch, s.report, s.profiles.len()])).collect::<Vec<_>>(),+ "counter": st.body_counter, "sheets": st.sheets, "threads": st.threads, "construct": format!("{:?}", st.construct),+ })+}++/// Everything a model holds that the rest of the app reads.+fn model(name: &str, s: &Session) -> Value {+ let results: Vec<Value> = s+ .model+ .results+ .iter()+ .map(|r| json!({"id": r.id, "name": r.name, "error": r.error, "warning": r.warning, "skipped": r.skipped, "state": state(name, &r.state)}))+ .collect();+ json!({"results": results, "world": state(name, &s.world_state())})+}++/// The same edit on both: a parameter's value when the design has one, else a new body.+fn edit(s: &mut Session) {+ let param = s.doc.params.first().map(|p| (p.name.clone(), p.expr.clone()));+ match param {+ Some((name, expr)) => {+ s.execute("parameters.change", &json!({"name": name, "expression": format!("({expr}) * 1.05")})).unwrap();+ }+ None => {+ s.execute("solid.box", &json!({"length": 7, "width": 8, "height": 9, "operation": "new"})).unwrap();+ }+ }+}++fn check(name: &str, mut built: Session) {+ let path = temp(name);+ built.execute("file.save_as", &json!({"path": path.to_string_lossy()})).unwrap();+ let bytes = std::fs::read(&path).unwrap();+ assert!(solidcraft_engine::io::read_design_geometry(&bytes).is_some(), "{name}: the save keeps the model");+ let mut cached = open(&path);+ assert_eq!(cached.model.last_recomputed, 0, "{name}: opened without evaluating");+ let mut rebuilt = Session::new(solidcraft_engine::io::read_design(&bytes).unwrap());+ assert!(rebuilt.model.last_recomputed > 0);+ assert_eq!(model(name, &cached), model(name, &rebuilt), "{name}: opened from the file's model");+ edit(&mut cached);+ edit(&mut rebuilt);+ assert_eq!(model(name, &cached), model(name, &rebuilt), "{name}: after the same edit");+ cached.execute("edit.undo", &json!({})).unwrap();+ rebuilt.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(model(name, &cached), model(name, &rebuilt), "{name}: after undoing it");+ let _ = std::fs::remove_file(&path);+ let _ = std::fs::remove_file(format!("{}.bak", path.display()));+}++#[test]+fn corpus_designs_open_from_their_model_as_evaluated() {+ for p in corpus() {+ let name = p.file_stem().unwrap_or_default().to_string_lossy().to_string();+ let s = open(&p);+ // Names saved before format 14 are found again through names worked out from geometry on+ // demand, which a saved model does not keep.+ let legacy = s.doc.to_json().contains(&format!("\"{}", solidcraft_engine::doc::naming::LEGACY_MARK));+ if s.model.results.iter().any(|r| r.error.is_some()) || legacy {+ // Not kept: a model with errors, or names saved before format 14.+ let path = temp(&name);+ let mut s = s;+ s.execute("file.save_as", &json!({"path": path.to_string_lossy()})).unwrap();+ assert!(solidcraft_engine::io::read_design_geometry(&std::fs::read(&path).unwrap()).is_none(), "{name}");+ let _ = std::fs::remove_file(&path);+ let _ = std::fs::remove_file(format!("{}.bak", path.display()));+ continue;+ }+ check(&name, s);+ }+}++#[test]+fn sample_designs_open_from_their_model_as_evaluated() {+ for sample in solidcraft_engine::sample::samples() {+ let mut s = Session::default();+ for c in (sample.script)()["commands"].as_array().unwrap() {+ s.execute(c["command"].as_str().unwrap(), &c["params"]).unwrap_or_else(|e| panic!("{}: {e}", sample.name));+ }+ check(sample.name, s);+ }+}++#[test]+fn imported_assemblies_open_from_their_model_as_evaluated() {+ // A STEP assembly of the hinge sample: parts placed several times.+ let mut source = Session::default();+ let hinge = solidcraft_engine::sample::samples().into_iter().find(|s| s.name == "Hinge Assembly").unwrap();+ for c in (hinge.script)()["commands"].as_array().unwrap() {+ source.execute(c["command"].as_str().unwrap(), &c["params"]).unwrap();+ }+ let step = std::env::temp_dir().join(format!("solidcraft-model-cache-{}-hinge.step", std::process::id()));+ source.execute("file.export", &json!({"path": step.to_string_lossy()})).unwrap();+ let mut s = Session::default();+ s.execute("file.insert_step", &json!({"path": step.to_string_lossy()})).unwrap();+ s.execute("file.insert_step", &json!({"path": step.to_string_lossy(), "matrix": [1, 0, 0, 200, 0, 1, 0, 0, 0, 0, 1, 0]})).unwrap();+ let _ = std::fs::remove_file(&step);+ check("imported hinge", s);+}++/// Opened from its model, a design evaluates only from the first feature an edit changes: the+/// saved states before it are kept as they were read (the same states, not evaluated again).+#[test]+fn an_edit_after_opening_evaluates_from_the_feature_it_changes() {+ let plate = solidcraft_engine::sample::samples().into_iter().find(|s| s.name == "Sample Plate").unwrap();+ let mut built = Session::default();+ for c in (plate.script)()["commands"].as_array().unwrap() {+ built.execute(c["command"].as_str().unwrap(), &c["params"]).unwrap();+ }+ let path = temp("incremental");+ built.execute("file.save_as", &json!({"path": path.to_string_lossy()})).unwrap();+ let n = built.doc.features.len();+ assert!(n >= 4);+ let mut s = open(&path);+ assert_eq!(s.model.last_recomputed, 0);+ let read: Vec<Arc<ModelState>> = s.model.results.iter().map(|r| r.state.clone()).collect();+ // How many of the first features still have the states read from the file.+ let kept = |s: &Session| s.model.results.iter().zip(&read).take_while(|(r, st)| Arc::ptr_eq(&r.state, st)).count();+ // The marker moved back and forth: the features before it are as read.+ s.execute("timeline.rollback", &json!({"position": n - 2})).unwrap();+ assert_eq!(kept(&s), n - 2, "rolled back");+ s.execute("timeline.rollback", &json!({})).unwrap();+ assert_eq!(kept(&s), n, "rolled forward: the features after the marker take their saved results again");+ // Suppressing the second-to-last feature keeps every state before it.+ let k = s.doc.features[n - 2].id;+ s.execute("timeline.suppress", &json!({"feature": k, "suppressed": true})).unwrap();+ assert_eq!(kept(&s), n - 2, "evaluated from the suppressed feature on");+ s.execute("edit.undo", &json!({})).unwrap();+ // A new feature at the end starts from the final state read from the file.+ let mut s = open(&path);+ let read: Vec<Arc<ModelState>> = s.model.results.iter().map(|r| r.state.clone()).collect();+ s.execute("solid.box", &json!({"length": 3, "width": 3, "height": 3, "operation": "new"})).unwrap();+ assert_eq!(s.model.results.len(), n + 1);+ assert!(s.model.results.iter().zip(&read).all(|(r, st)| Arc::ptr_eq(&r.state, st)), "only the new feature evaluated");+ let _ = std::fs::remove_file(&path);+ let _ = std::fs::remove_file(format!("{}.bak", path.display()));+}++/// An edit made after opening and undone finds the saved results again: undo evaluates nothing.+#[test]+fn undoing_an_edit_after_opening_reuses_the_saved_results() {+ let plate = solidcraft_engine::sample::samples().into_iter().find(|s| s.name == "Sample Plate").unwrap();+ let mut built = Session::default();+ for c in (plate.script)()["commands"].as_array().unwrap() {+ built.execute(c["command"].as_str().unwrap(), &c["params"]).unwrap();+ }+ let path = temp("undo");+ built.execute("file.save_as", &json!({"path": path.to_string_lossy()})).unwrap();+ let mut s = open(&path);+ let read: Vec<Arc<ModelState>> = s.model.results.iter().map(|r| r.state.clone()).collect();+ let first = s.doc.features[1].id;+ s.execute("timeline.suppress", &json!({"feature": first, "suppressed": true})).unwrap();+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(s.model.last_recomputed, 0, "taken from the saved results");+ assert!(s.model.results.iter().zip(&read).all(|(r, st)| Arc::ptr_eq(&r.state, st)), "the very states read from the file");+ let _ = std::fs::remove_file(&path);+ let _ = std::fs::remove_file(format!("{}.bak", path.display()));+}diff --git a/crates/doc/src/construct.rs b/crates/doc/src/construct.rsindex 6c441bf3e9..e5f589bb25 100644--- a/crates/doc/src/construct.rs+++ b/crates/doc/src/construct.rs@@ -92,14 +92,14 @@ pub enum PointDef {}/// Resolved construction geometry, kept in the model state by feature.-#[derive(Clone, Debug, PartialEq)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub enum ConstructGeom {Plane(Plane),Axis { origin: Vec3, dir: Vec3 },Point(Vec3),}-#[derive(Clone, Debug, PartialEq)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct Construct {pub feature: u64,pub name: String,diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 8fa1512eef..82dd4c7db3 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -7,7 +7,7 @@ use std::collections::BTreeMap;use std::hash::{Hash, Hasher};use std::sync::{Arc, OnceLock};-use serde::Serialize;+use serde::{Deserialize, Serialize};use solidcraft_geom::tess::TessPlan;use solidcraft_geom::{Mesh, Plane, Region2, UnitVec3, Vec2, Vec3, regions_apart};use solidcraft_kernel::{self as kernel, Body, BoolOp};@@ -208,7 +208,7 @@ pub struct SolvedSketch {}/// A cosmetic thread: on which cylinder, its size, and the threaded part of the axis.-#[derive(Clone, Debug, PartialEq, Serialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct ThreadInfo {pub feature: u64,pub body: String,@@ -615,7 +615,7 @@ impl ModelState {/// [`quantize`]); the rest keep theirs.fn stamp(&mut self, before: &Arc<ModelState>, f: &Feature, key: u64, mats: Vec<Mat>) {let feature = f.id;- let depth = before.bodies.iter().filter_map(|b| b.names.origin.as_ref().map(|o| o.depth)).max().unwrap_or(0) + 1;+ let depth = before.bodies.iter().filter_map(|b| b.names.depth()).max().unwrap_or(0) + 1;let sheets = if f.kind.is_sheet() { self.sheets.clone() } else { Vec::new() };let origin = Arc::new(crate::naming::NamingOrigin { feature: f.clone(), before: before.clone(), depth, mats, sheets });// Pieces a cut left are named after their faces, not the kernel's shell order (unless@@ -4596,8 +4596,11 @@ fn replay(Ok(())}+#[path = "model_cache.rs"]+mod model_cache;#[path = "eval_more.rs"]mod more;+pub use model_cache::SavedModel;#[path = "eval_surface.rs"]mod surface;diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsindex 163a534336..38bbb4505e 100644--- a/crates/doc/src/lib.rs+++ b/crates/doc/src/lib.rs@@ -58,10 +58,10 @@ pub use assembly::{};pub use document::*;pub use eval::{- EdgeRef, FeatureResult, Model, ModelBody, ModelState, PlacedBodies, RevolveExtent, SolvedSketch, ThreadInfo, curve_pick_error, edge_names_for,- edge_refs, face_point_names, face_point_state, hole_direction_at, import_body_names, metric_thread_sizes, object_height, parse_metric_thread,- pattern_matrices, revolve_extent, revolve_extent_with_convention, select_profiles, sketch_hole_direction, sketch_line_plane, state_in_frame,- state_in_frame_at, suggested_thread, through_all_distance, world_state, world_state_reusing,+ EdgeRef, FeatureResult, Model, ModelBody, ModelState, PlacedBodies, RevolveExtent, SavedModel, SolvedSketch, ThreadInfo, curve_pick_error,+ edge_names_for, edge_refs, face_point_names, face_point_state, hole_direction_at, import_body_names, metric_thread_sizes, object_height,+ parse_metric_thread, pattern_matrices, revolve_extent, revolve_extent_with_convention, select_profiles, sketch_hole_direction, sketch_line_plane,+ state_in_frame, state_in_frame_at, suggested_thread, through_all_distance, world_state, world_state_reusing,};pub use expr::Expr;pub use names::{BodyName, FeatureName, SketchId};diff --git a/crates/doc/src/model_cache.rs b/crates/doc/src/model_cache.rsnew file mode 100644index 0000000000..fbd49f87be--- /dev/null+++ b/crates/doc/src/model_cache.rs@@ -0,0 +1,424 @@+//! A model as a design file keeps it: every feature's result and the state after it, so a design+//! opens without evaluating its timeline again (docs/design-container.md, "Model cache").+//!+//! The records are JSON; the kernel bodies they hold are a separate list ([`SavedModel::bodies`]),+//! which the file stores in SolidCraft's exact native B-rep encoding. A body that several states+//! hold (one that later features pass through unchanged) is recorded once, as are its face names+//! and the solved sketches the states share. Face names are kept as worked out, not as the+//! history they were worked out from: a model taken from a file names every face as the model+//! that was saved did.++use super::*;+use crate::history_names::{FaceInfo, Names};+use serde_json::{Value as Json, json};+use std::collections::HashMap;++/// A model's results and states as records, and the kernel bodies they refer to by index.+pub struct SavedModel {+ pub records: Json,+ pub bodies: Vec<Body>,+}++/// Records refer to these at most.+const MAX_ITEMS: usize = 1_000_000;+/// Bodies and sketches all the states hold together, at most (a state is a list of clones).+const MAX_HELD: usize = 50_000_000;++fn hex(v: u64) -> String {+ format!("{v:016x}")+}++fn unhex(v: &Json) -> Result<u64> {+ v.as_str().and_then(|s| u64::from_str_radix(s, 16).ok()).ok_or_else(|| bad("saved model: key"))+}++fn bad(what: &str) -> DocError {+ DocError::Invalid(what.into())+}++/// A design whose stored face or edge names were saved before format 14 (marked+/// [`crate::naming::LEGACY_MARK`]) finds them through names worked out from geometry on demand,+/// which a saved model does not keep.+fn has_legacy_names(doc: &Document) -> bool {+ let mark = format!("\"{}", crate::naming::LEGACY_MARK);+ doc.features.iter().any(|f| match &f.kind {+ FeatureKind::Import { .. } => f.face_names.iter().any(|n| n.starts_with(crate::naming::LEGACY_MARK)),+ _ => serde_json::to_string(f).is_ok_and(|j| j.contains(&mark)),+ })+}++/// What tells two model bodies apart in a record: a body a feature passes through unchanged is a+/// clone sharing its mesh cell and names, so this finds it without writing its record again.+#[derive(PartialEq, Eq, Hash)]+struct BodyKey {+ mesh: usize,+ names: usize,+ imported: usize,+ key: u64,+ feature: u64,+ component: u64,+ transferred: bool,+ name: String,+ source_name: Option<String>,+ source_transform: [u64; 16],+}++impl BodyKey {+ fn of(b: &ModelBody) -> Self {+ let mut source_transform = [0; 16];+ for (bits, v) in source_transform.iter_mut().zip(b.source_transform.iter().flatten()) {+ *bits = v.to_bits();+ }+ BodyKey {+ mesh: Arc::as_ptr(&b.mesh) as usize,+ names: b.names.id(),+ imported: b.imported.as_ref().map_or(0, |l| Arc::as_ptr(l) as usize),+ key: b.key,+ feature: b.feature,+ component: b.component,+ transferred: b.transferred,+ name: b.name.clone(),+ source_name: b.source_name.clone(),+ source_transform,+ }+ }+}++/// Indices as runs of consecutive ones (`[first, count]`): a state lists mostly the bodies of the+/// state before it, in order.+fn runs(indices: &[usize]) -> Vec<[usize; 2]> {+ let mut out: Vec<[usize; 2]> = Vec::new();+ for &i in indices {+ match out.last_mut() {+ Some([first, count]) if *first + *count == i => *count += 1,+ _ => out.push([i, 1]),+ }+ }+ out+}++#[derive(Default)]+struct Writer {+ bodies: Vec<Body>,+ model_bodies: Vec<Json>,+ model_body_index: HashMap<BodyKey, usize>,+ names: Vec<Json>,+ names_index: HashMap<usize, usize>,+ sketches: Vec<Json>,+ sketch_index: HashMap<usize, usize>,+ states: Vec<Json>,+ state_index: HashMap<usize, usize>,+}++impl Writer {+ fn names(&mut self, b: &ModelBody) -> usize {+ let id = b.names.id();+ if let Some(i) = self.names_index.get(&id) {+ return *i;+ }+ let names = crate::naming::names(b);+ let info: Vec<Json> = names.info.iter().map(|i| json!([i.aliases, i.bounds, i.verified])).collect();+ self.names.push(json!({"faces": *names.faces, "info": info}));+ self.names_index.insert(id, self.names.len() - 1);+ self.names.len() - 1+ }++ fn model_body(&mut self, b: &ModelBody) -> Option<usize> {+ if b.body.is_mesh() {+ return None;+ }+ let key = BodyKey::of(b);+ if let Some(i) = self.model_body_index.get(&key) {+ return Some(*i);+ }+ let names = self.names(b);+ let mut r = json!({+ "name": b.name, "feature": b.feature, "component": b.component, "key": hex(b.key), "names": names,+ });+ if let Some(depth) = b.names.depth() {+ r["depth"] = json!(depth);+ }+ if let Some(source) = &b.source_name {+ r["source_name"] = json!(source);+ }+ if b.source_transform != crate::IDENTITY {+ r["source_transform"] = json!(b.source_transform);+ }+ if b.transferred {+ r["transferred"] = json!(true);+ }+ if let Some(look) = &b.imported {+ let faces: Vec<Json> = look.faces.iter().map(|(name, (color, opacity))| json!([name, color, opacity])).collect();+ r["imported"] = json!({"color": look.color, "opacity": look.opacity, "faces": faces});+ }+ r["body"] = json!(self.bodies.len());+ self.bodies.push(b.body.clone());+ self.model_bodies.push(r);+ self.model_body_index.insert(key, self.model_bodies.len() - 1);+ Some(self.model_bodies.len() - 1)+ }++ fn sketch(&mut self, s: &Arc<SolvedSketch>) -> Option<usize> {+ let id = Arc::as_ptr(s) as usize;+ if let Some(i) = self.sketch_index.get(&id) {+ return Some(*i);+ }+ let r = json!({+ "feature": s.feature, "name": s.name, "plane": serde_json::to_value(s.plane).ok()?,+ "sketch": serde_json::to_value(&s.sketch).ok()?, "report": serde_json::to_value(&s.report).ok()?,+ });+ self.sketches.push(r);+ self.sketch_index.insert(id, self.sketches.len() - 1);+ Some(self.sketches.len() - 1)+ }++ fn state(&mut self, st: &Arc<ModelState>) -> Option<usize> {+ let id = Arc::as_ptr(st) as usize;+ if let Some(i) = self.state_index.get(&id) {+ return Some(*i);+ }+ let bodies = st.bodies.iter().map(|b| self.model_body(b)).collect::<Option<Vec<_>>>()?;+ let sketches = st.sketches.iter().map(|s| self.sketch(s)).collect::<Option<Vec<_>>>()?;+ let r = json!({+ "bodies": runs(&bodies), "sketches": runs(&sketches), "body_counter": st.body_counter,+ "sheets": serde_json::to_value(&st.sheets).ok()?, "construct": serde_json::to_value(&st.construct).ok()?,+ "threads": serde_json::to_value(&st.threads).ok()?,+ "sketch_keys": st.sketch_keys.iter().map(|(f, k)| json!([f, hex(*k)])).collect::<Vec<_>>(),+ "blend_edges": serde_json::to_value(&st.blend_edges).ok()?, "fitted": serde_json::to_value(&st.fitted).ok()?,+ "tapered": serde_json::to_value(&st.tapered).ok()?,+ });+ self.states.push(r);+ self.state_index.insert(id, self.states.len() - 1);+ Some(self.states.len() - 1)+ }+}++impl Model {+ /// The model as a design file keeps it: `None` unless it is `doc`'s evaluation without an+ /// error, holds no mesh bodies, and `doc` keeps no names saved before format 14. Works out+ /// the face names not asked for yet (a saved model keeps them as worked out).+ pub fn saved(&self, doc: &Document) -> Option<SavedModel> {+ if self.results.is_empty() || self.results.iter().any(|r| r.error.is_some()) || !self.is_current(doc) || has_legacy_names(doc) {+ return None;+ }+ kernel::guard("save the model", || {+ let mut w = Writer::default();+ let mut features = Vec::with_capacity(self.results.len());+ for r in &self.results {+ let state = w.state(&r.state).ok_or_else(|| kernel::KernelError::Invalid("not kept".into()))?;+ let mut f = json!({"id": r.id, "fingerprint": hex(r.fingerprint), "ms": r.ms, "skipped": r.skipped, "state": state});+ if let Some(w) = &r.warning {+ f["warning"] = json!(w);+ }+ if r.boolean_diagnostics != kernel::BooleanDiagnostics::default() {+ f["diagnostics"] = serde_json::to_value(&r.boolean_diagnostics).map_err(|e| kernel::KernelError::Invalid(e.to_string()))?;+ }+ features.push(f);+ }+ let records = json!({+ "features": features, "states": w.states, "model_bodies": w.model_bodies, "names": w.names, "sketches": w.sketches,+ });+ Ok(SavedModel { records, bodies: w.bodies })+ })+ .ok()+ }+}++impl SavedModel {+ /// The states the records hold, every record checked.+ fn states(&self) -> Result<Vec<Arc<ModelState>>> {+ let (records, bodies) = (&self.records, &self.bodies);+ let list = |key: &str| records.get(key).and_then(Json::as_array).filter(|l| l.len() <= MAX_ITEMS).ok_or_else(|| bad("saved model: list"));+ let index = |v: Option<&Json>, len: usize| {+ v.and_then(Json::as_u64).and_then(|i| usize::try_from(i).ok()).filter(|i| *i < len).ok_or_else(|| bad("saved model: index"))+ };+ let text =+ |v: Option<&Json>| v.and_then(Json::as_str).filter(|s| s.len() <= 1 << 16).map(str::to_owned).ok_or_else(|| bad("saved model: text"));+ let parse = |v: Option<&Json>| v.cloned().ok_or_else(|| bad("saved model: missing"));+ let mut names = Vec::new();+ for n in list("names")? {+ let faces: Vec<String> = serde_json::from_value(parse(n.get("faces"))?).map_err(|_| bad("saved model: names"))?;+ let info: Vec<(Vec<String>, std::collections::BTreeSet<String>, bool)> =+ serde_json::from_value(parse(n.get("info"))?).map_err(|_| bad("saved model: names"))?;+ if info.len() != faces.len() {+ return Err(bad("saved model: names"));+ }+ let info = info.into_iter().map(|(aliases, bounds, verified)| FaceInfo { aliases, bounds, verified }).collect();+ names.push(Arc::new(Names { faces: Arc::new(faces), info }));+ }+ let mut sketches = Vec::new();+ for s in list("sketches")? {+ let sketch: solidcraft_sketch::Sketch = serde_json::from_value(parse(s.get("sketch"))?).map_err(|_| bad("saved model: sketch"))?;+ sketches.push(Arc::new(SolvedSketch {+ feature: s.get("feature").and_then(Json::as_u64).ok_or_else(|| bad("saved model: sketch"))?,+ name: text(s.get("name"))?,+ plane: serde_json::from_value(parse(s.get("plane"))?).map_err(|_| bad("saved model: sketch"))?,+ report: serde_json::from_value(parse(s.get("report"))?).map_err(|_| bad("saved model: sketch"))?,+ profiles: find_profiles(&sketch),+ ends: solidcraft_sketch::loose_ends(&sketch),+ sketch,+ }));+ }+ let mut model_bodies = Vec::new();+ for r in list("model_bodies")? {+ let body = bodies.get(index(r.get("body"), bodies.len())?).cloned().ok_or_else(|| bad("saved model: body"))?;+ let mut b =+ ModelBody::new(text(r.get("name"))?, body, r.get("feature").and_then(Json::as_u64).ok_or_else(|| bad("saved model: feature"))?);+ b.component = r.get("component").and_then(Json::as_u64).ok_or_else(|| bad("saved model: component"))?;+ b.key = unhex(r.get("key").unwrap_or(&Json::Null))?;+ let depth =+ r.get("depth").map(|d| d.as_u64().and_then(|d| usize::try_from(d).ok()).ok_or_else(|| bad("saved model: depth"))).transpose()?;+ b.names = crate::naming::NameCell::saved(+ names.get(index(r.get("names"), names.len())?).cloned().ok_or_else(|| bad("saved model: names"))?,+ depth,+ );+ b.source_name = r.get("source_name").map(|s| text(Some(s))).transpose()?;+ if let Some(m) = r.get("source_transform") {+ let m: crate::Mat = serde_json::from_value(m.clone()).map_err(|_| bad("saved model: transform"))?;+ if m.iter().flatten().any(|x| !x.is_finite()) {+ return Err(bad("saved model: transform"));+ }+ b.source_transform = m;+ }+ b.transferred = r.get("transferred").and_then(Json::as_bool).unwrap_or(false);+ // Measured once here, so every state holding it adds it up for the cache's budget.+ b.bytes = b.body.retained_bytes();+ if let Some(look) = r.get("imported") {+ let faces: Vec<(String, [f32; 3], f32)> = serde_json::from_value(parse(look.get("faces"))?).map_err(|_| bad("saved model: look"))?;+ b.imported = Some(Arc::new(crate::appearance::ImportedLook {+ color: serde_json::from_value(parse(look.get("color"))?).map_err(|_| bad("saved model: look"))?,+ opacity: serde_json::from_value(parse(look.get("opacity"))?).map_err(|_| bad("saved model: look"))?,+ faces: faces.into_iter().map(|(name, color, opacity)| (name, (color, opacity))).collect(),+ }));+ }+ model_bodies.push(b);+ }+ let mut states = Vec::new();+ let mut held = 0usize;+ for s in list("states")? {+ // Runs of consecutive indices, each within the list it indexes.+ let ids = |key: &str, len: usize| -> Result<Vec<usize>> {+ let mut out = Vec::new();+ for run in s.get(key).and_then(Json::as_array).ok_or_else(|| bad("saved model: state"))? {+ let first = index(run.get(0), len)?;+ let count = run.get(1).and_then(Json::as_u64).and_then(|n| usize::try_from(n).ok()).ok_or_else(|| bad("saved model: run"))?;+ if first.checked_add(count).is_none_or(|end| end > len) || out.len().saturating_add(count) > MAX_ITEMS {+ return Err(bad("saved model: run"));+ }+ out.extend(first..first + count);+ }+ Ok(out)+ };+ let field = |key: &str| parse(s.get(key));+ let invalid = |_| bad("saved model: state");+ let mut sketch_keys = BTreeMap::new();+ for k in s.get("sketch_keys").and_then(Json::as_array).ok_or_else(|| bad("saved model: state"))? {+ sketch_keys+ .insert(k.get(0).and_then(Json::as_u64).ok_or_else(|| bad("saved model: state"))?, unhex(k.get(1).unwrap_or(&Json::Null))?);+ }+ let st = ModelState {+ bodies: ids("bodies", model_bodies.len())?.into_iter().filter_map(|i| model_bodies.get(i).cloned()).collect(),+ sketches: ids("sketches", sketches.len())?.into_iter().filter_map(|i| sketches.get(i).cloned()).collect(),+ body_counter: index(s.get("body_counter"), usize::MAX)?,+ sheets: serde_json::from_value(field("sheets")?).map_err(invalid)?,+ construct: serde_json::from_value(field("construct")?).map_err(invalid)?,+ threads: serde_json::from_value(field("threads")?).map_err(invalid)?,+ sketch_keys,+ blend_edges: serde_json::from_value(field("blend_edges")?).map_err(invalid)?,+ fitted: serde_json::from_value(field("fitted")?).map_err(invalid)?,+ tapered: serde_json::from_value(field("tapered")?).map_err(invalid)?,+ };+ held = held.saturating_add(st.bodies.len()).saturating_add(st.sketches.len());+ if held > MAX_HELD {+ return Err(bad("saved model: states"));+ }+ states.push(Arc::new(st));+ }+ Ok(states)+ }++ /// The model's final state (what a picture of it shows), without checking that it is a+ /// document's evaluation.+ pub fn final_state(&self) -> Result<Arc<ModelState>> {+ let states = self.states()?;+ let features = self.records.get("features").and_then(Json::as_array).ok_or_else(|| bad("saved model: features"))?;+ let last = features.iter().rev().find(|f| f.get("skipped").and_then(Json::as_bool) == Some(false));+ match last {+ Some(f) => f+ .get("state")+ .and_then(Json::as_u64)+ .and_then(|i| states.get(usize::try_from(i).ok()?))+ .cloned()+ .ok_or_else(|| bad("saved model: state")),+ None => Ok(Arc::new(ModelState::default())),+ }+ }+}++impl Model {+ /// The model a design file kept for `doc` ([`Model::saved`]), taken as `doc`'s evaluation:+ /// every feature's result as saved, nothing evaluated. Refused (an error) unless every+ /// feature's fingerprint is the one `doc` gives it now, and every record is well formed.+ pub fn adopt(doc: &Document, saved: &SavedModel) -> Result<Model> {+ let states = saved.states()?;+ let records = &saved.records;+ let index = |v: Option<&Json>, len: usize| {+ v.and_then(Json::as_u64).and_then(|i| usize::try_from(i).ok()).filter(|i| *i < len).ok_or_else(|| bad("saved model: index"))+ };+ let text =+ |v: Option<&Json>| v.and_then(Json::as_str).filter(|s| s.len() <= 1 << 16).map(str::to_owned).ok_or_else(|| bad("saved model: text"));+ let features = records.get("features").and_then(Json::as_array).ok_or_else(|| bad("saved model: features"))?;+ if features.len() != doc.features.len() {+ return Err(bad("saved model: features"));+ }+ let (vals, param_errors) = evaluation_values(doc);+ let step_digests = StepDigests::of(doc, &StepDigests::default());+ let marker = doc.marker.unwrap_or(usize::MAX);+ let ctx = context_digest(doc, &vals);+ let mut cache = EvalCache::default();+ let mut before = Arc::new(ModelState::default());+ let mut prev = 0;+ let mut results = Vec::with_capacity(features.len());+ for (i, (f, r)) in doc.features.iter().zip(features).enumerate() {+ prev = chain_fingerprint(doc, &vals, f, prev, i >= marker, &step_digests);+ if r.get("id").and_then(Json::as_u64) != Some(f.id) || unhex(r.get("fingerprint").unwrap_or(&Json::Null))? != prev {+ return Err(bad("saved model: the document changed"));+ }+ let ms = r.get("ms").and_then(Json::as_f64).filter(|ms| ms.is_finite()).ok_or_else(|| bad("saved model: time"))?;+ let result = FeatureResult {+ id: f.id,+ name: f.name.clone(),+ error: None,+ warning: r.get("warning").map(|w| text(Some(w))).transpose()?,+ boolean_diagnostics: match r.get("diagnostics") {+ Some(d) => serde_json::from_value(d.clone()).map_err(|_| bad("saved model: diagnostics"))?,+ None => Default::default(),+ },+ ms,+ skipped: r.get("skipped").and_then(Json::as_bool).ok_or_else(|| bad("saved model: skipped"))?,+ stale: false,+ fingerprint: prev,+ state: states.get(index(r.get("state"), states.len())?).cloned().ok_or_else(|| bad("saved model: state"))?,+ };+ // Each result where an evaluation would have put it, so an edit undone (or set back)+ // finds it again rather than evaluating the feature anew.+ if !result.skipped {+ let local = fingerprint(0, f, &vals, false, &step_digests) ^ placement_digest(doc, f);+ cache.put(+ cache_key(f, prev, local, ctx, &before),+ CachedEval {+ error: None,+ warning: result.warning.clone(),+ boolean_diagnostics: result.boolean_diagnostics.clone(),+ ms,+ bytes: result.state.retained_bytes(),+ state: result.state.clone(),+ },+ );+ before = result.state.clone();+ }+ results.push(result);+ }+ Ok(Model { results, param_errors, step_digests, cache: Arc::new(std::sync::Mutex::new(cache)), ..Model::default() })+ }+}diff --git a/crates/doc/src/naming.rs b/crates/doc/src/naming.rsindex 263b4bb6b9..71d32e6eea 100644--- a/crates/doc/src/naming.rs+++ b/crates/doc/src/naming.rs@@ -46,6 +46,9 @@ pub struct NameCell {legacy: Arc<OnceLock<Arc<Vec<String>>>>,/// The body this one is a moved copy of (its legacy names are that body's).copy_of: Option<Arc<ModelBody>>,+ /// How deep the chain of features that named it is, for names taken from a saved model+ /// (which has no origin): see [`NameCell::depth`].+ saved_depth: Option<usize>,}impl NameCell {@@ -69,6 +72,19 @@ impl NameCell {pub fn same(body: &ModelBody) -> Self {NameCell { copy_of: Some(Arc::new(body.clone())), ..NameCell::default() }}+ /// Names a saved model kept (worked out when it was saved), at `depth` in the chain of+ /// features that named them.+ pub(crate) fn saved(names: Arc<Names>, depth: Option<usize>) -> Self {+ NameCell { saved_depth: depth, ..Self::shared(names) }+ }+ /// How deep the chain of features that named the body is (`None`: not made by a feature).+ pub(crate) fn depth(&self) -> Option<usize> {+ self.origin.as_ref().map(|o| o.depth).or(self.saved_depth)+ }+ /// Identity of the names: clones of a cell share them.+ pub(crate) fn id(&self) -> usize {+ Arc::as_ptr(&self.names) as usize+ }fn shared(names: Arc<Names>) -> Self {let cell = OnceLock::new();let _ = cell.set(names);diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rsindex b4bfd40afe..130e265470 100644--- a/crates/doc/src/sheet.rs+++ b/crates/doc/src/sheet.rs@@ -316,7 +316,7 @@ impl SheetSettings {/// The shape of the relief cut where two bends meet at a corner of the base (a rule's/// `corner_relief_shape`).-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize)]+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "lowercase")]pub enum ReliefShape {/// Nothing is cut: the bends end square at the corner.@@ -418,7 +418,7 @@ impl Document {}/// A flange: a bend along a panel edge and the flat panel past it (flat coordinates).-#[derive(Clone, Debug, PartialEq, Serialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct SheetFlange {/// The flange it hangs off (None = the base panel).pub parent: Option<usize>,@@ -469,7 +469,7 @@ pub struct EdgeFlange {}/// A sheet metal body (see the module docs).-#[derive(Clone, Debug, PartialEq, Serialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct SheetBody {pub body: String,pub rule: String,@@ -483,21 +483,21 @@ pub struct SheetBody {pub holes: Vec<Region2>,/// Planar machining in flat coordinates, with depths measured from the flat bottom./// Derived from feature history; these records are not a document schema change.- #[serde(skip_serializing_if = "Vec::is_empty")]+ #[serde(default, skip_serializing_if = "Vec::is_empty")]pub pockets: Vec<SheetPocket>,/// Straight bores drilled into a panel along its plane (a hole into a rim), in flat/// coordinates, each kept inside its own panel's material so the folded part and its flat/// pattern both carry it (#560). Derived from feature history, like `pockets`.- #[serde(skip_serializing_if = "Vec::is_empty")]+ #[serde(default, skip_serializing_if = "Vec::is_empty")]pub bores: Vec<SheetBore>,/// Perforation fields (#732), flat coordinates; their holes are computed on demand and never cut into the B-rep.- #[serde(skip_serializing_if = "Vec::is_empty")]+ #[serde(default, skip_serializing_if = "Vec::is_empty")]pub perforations: Vec<SheetPerforation>,/// Regions (flat coordinates) that text cut or machined, letters with their counters as/// holes: a record of where the sheet's text went, so that its DXF can write the letters on/// layers of their own (see [`SheetBody::letters`]). The cut-outs and pockets themselves are/// in `holes` and `pockets`. Derived from feature history, like `pockets`.- #[serde(skip_serializing_if = "Vec::is_empty")]+ #[serde(default, skip_serializing_if = "Vec::is_empty")]pub labels: Vec<Region2>,/// Unfolded.pub flat: bool,@@ -524,7 +524,7 @@ pub struct SheetBody {/// A straight round bore of one panel (None = the base), in flat coordinates: a cylinder from/// `base` along the unit `axis` for `height`, cut only from that panel's material.-#[derive(Clone, Copy, Debug, PartialEq, Serialize)]+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]pub struct SheetBore {pub panel: Option<usize>,pub base: Vec3,@@ -534,7 +534,7 @@ pub struct SheetBore {}/// A perforation field from a `sheet.perforate` feature (#732).-#[derive(Clone, Debug, PartialEq, Serialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct SheetPerforation {pub feature: u64,pub diameter: f64,@@ -543,7 +543,7 @@ pub struct SheetPerforation {pub square: bool,}-#[derive(Clone, Debug, PartialEq, Serialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct SheetPocket {pub region: Region2,pub z0: f64,diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rsindex 100c6435b1..73d3daa66e 100644--- a/crates/engine/src/cmd/file.rs+++ b/crates/engine/src/cmd/file.rs@@ -267,11 +267,11 @@ fn open(s: &mut Session, p: &Value) -> Result<Value> {}return Ok(out);}- let mut doc = solidcraft_io::read_design_file(path, s.open_preview.take()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ let (mut doc, saved) = solidcraft_io::read_design_file(path, s.open_preview.take()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;if let Some(stem) = default_name_for(&doc.name, path) {doc.name = stem;}- s.replace_design(Session::new(doc));+ s.replace_design(Session::opened(doc, saved.as_ref()));s.path = Some(path.to_string());let errors = s.model.results.iter().filter(|r| r.error.is_some()).count();Ok(json!({"path": path, "features": s.doc.features.len(), "errors": errors, "name": s.doc.name}))@@ -405,17 +405,17 @@ impl Session {let geometry = cache.then(|| saved_geometry(self, &design)).flatten();let preview = preview.then(|| saved_preview(self)).flatten();let thumbnail = cache.then(|| thumbnail::saved(self)).flatten();- solidcraft_io::write_design_container_with_thumbnail(&design, compression, preview.as_ref(), geometry.as_deref(), thumbnail.as_deref())+ solidcraft_io::write_design_container_with_thumbnail(&design, compression, preview.as_ref(), geometry.as_ref(), thumbnail.as_deref())}}/// The evaluated model a save keeps, so opening need not rebuild it: only the finished evaluation/// of `design`, the document saved (no sketch being edited, no uncaptured moves, no feature errors).-fn saved_geometry(s: &Session, design: &Document) -> Option<std::sync::Arc<solidcraft_doc::ModelState>> {- if s.active_sketch.is_some() || !s.pending_moves.is_empty() || s.model.results.iter().any(|r| r.error.is_some()) || !s.model.is_current(design) {+fn saved_geometry(s: &Session, design: &Document) -> Option<solidcraft_doc::SavedModel> {+ if s.active_sketch.is_some() || !s.pending_moves.is_empty() || s.model.state().bodies.is_empty() {return None;}- Some(s.model.state()).filter(|st| !st.bodies.is_empty())+ s.model.saved(design)}/// Cache only warm display geometry. A save never waits for an unevaluated mesh.@@ -849,36 +849,37 @@ mod tests {}#[test]- fn native_cache_does_not_force_meshes_or_supply_editing_state() {- let mut session = Session::new(Document::new("Native cache authority"));+ fn saved_model_needs_no_meshes_and_is_adopted_only_for_its_document() {+ let mut session = Session::new(Document::new("Saved model"));session.execute("solid.box", &json!({"length":10,"width":20,"height":30})).unwrap();let world = session.world_state();assert!(world.bodies.iter().all(|b| b.cached_mesh().is_none()));- let mut cached = (*saved_geometry(&session, &session.doc).unwrap()).clone();let bytes = session.design_container(solidcraft_io::DesignCompression::Fast, false, true).unwrap();- assert!(world.bodies.iter().all(|b| b.cached_mesh().is_none()), "saving native geometry must not triangulate");+ assert!(world.bodies.iter().all(|b| b.cached_mesh().is_none()), "saving the model must not triangulate");assert!(solidcraft_io::read_design_geometry(&bytes).is_some());assert!(solidcraft_io::read_design_geometry(&session.design_container(solidcraft_io::DesignCompression::Fast, false, false).unwrap()).is_none());- cached.bodies[0].body = solidcraft_kernel::box_solid(solidcraft_geom::Vec3::ZERO, solidcraft_geom::Vec3::new(100., 100., 100.)).unwrap();- let bytes =- solidcraft_io::write_design_container_with_cache(&session.doc, solidcraft_io::DesignCompression::Fast, None, Some(&cached)).unwrap();- let path = std::env::temp_dir().join(format!("solidcraft-native-forged-{}.solidcraft", std::process::id()));- std::fs::write(&path, bytes).unwrap();- let seen = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));- let callback_seen = seen.clone();- let mut reopened = Session {- open_preview: Some(Box::new(move |p| {- callback_seen.store(!p.meshes.is_empty(), std::sync::atomic::Ordering::Relaxed);- })),- ..Session::default()- };+ let path = std::env::temp_dir().join(format!("solidcraft-saved-model-{}.solidcraft", std::process::id()));+ std::fs::write(&path, &bytes).unwrap();+ let mut reopened = Session::default();reopened.execute("doc.open", &json!({"path":path})).unwrap();- assert!(seen.load(std::sync::atomic::Ordering::Relaxed));assert_eq!(reopened.doc, session.doc);+ assert!(reopened.model.results.iter().all(|r| r.ms == session.model.results[0].ms), "taken from the file, not evaluated");let measured = reopened.execute("inspect.measure", &json!({})).unwrap();assert!((measured["bodies"][0]["volume_mm3"].as_f64().unwrap() - 6000.).abs() < 1e-6);+ // The model of another document (a value edited in the file) is not taken: the design is+ // evaluated.+ let mut changed = (*session.doc).clone();+ if let Some(solidcraft_doc::FeatureKind::Box { length, .. }) = changed.features.last_mut().map(|f| &mut f.kind) {+ *length = "20".into();+ }+ let saved = saved_geometry(&session, &session.doc).unwrap();+ let other = solidcraft_io::write_design_container_with_cache(&changed, solidcraft_io::DesignCompression::Fast, None, Some(&saved)).unwrap();+ std::fs::write(&path, other).unwrap();+ reopened.execute("doc.open", &json!({"path":path})).unwrap();+ let measured = reopened.execute("inspect.measure", &json!({})).unwrap();+ assert!((measured["bodies"][0]["volume_mm3"].as_f64().unwrap() - 12000.).abs() < 1e-6);std::fs::remove_file(path).unwrap();}@@ -1061,7 +1062,8 @@ mod tests {for x in [0, 20, 40] {s.execute("solid.box", &json!({"length":10,"width":10,"height":10,"corner":[x,0,0]})).unwrap();}- s.execute("file.save", &json!({"path":path})).unwrap();+ // Without its model: the timeline is evaluated (and watched) as it opens.+ s.execute("file.save", &json!({"path":path, "cache": false})).unwrap();let progress = Arc::new(Progress::default());let mut opened = Session::default();diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex a11fba4afa..e34aeb6158 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -359,12 +359,25 @@ impl Default for Session {}impl Session {- pub fn new(mut doc: Document) -> Self {+ pub fn new(doc: Document) -> Self {+ Self::opened(doc, None)+ }++ /// A session on `doc` whose evaluation is the model its file kept (`saved`), when that is+ /// `doc`'s evaluation ([`Model::adopt`]); otherwise the timeline is evaluated.+ /// `SOLIDCRAFT_NO_MODEL_CACHE` set always evaluates.+ pub fn opened(mut doc: Document, saved: Option<&solidcraft_doc::SavedModel>) -> Self {// The session keeps what is hidden (not an undo step); the design file carries it.let visibility = std::mem::take(&mut doc.visibility);let doc = Arc::new(doc);- let mut model = Model::new();- model.evaluate(&doc);+ let adopted = saved+ .filter(|_| solidcraft_geom::env::var_os("NO_MODEL_CACHE").is_none())+ .and_then(|saved| Model::adopt(&doc, saved).map_err(|e| log::info!("the saved model is not used: {e}")).ok());+ let model = adopted.unwrap_or_else(|| {+ let mut model = Model::new();+ model.evaluate(&doc);+ model+ });Session {saved: doc.clone(),doc,diff --git a/crates/io/src/design.rs b/crates/io/src/design.rsindex 50a457fe29..510d800d7e 100644--- a/crates/io/src/design.rs+++ b/crates/io/src/design.rs@@ -113,7 +113,7 @@ pub fn write_design_container_with_cache(doc: &Document,compression: DesignCompression,preview: Option<&DesignPreview>,- geometry: Option<&solidcraft_doc::ModelState>,+ geometry: Option<&solidcraft_doc::SavedModel>,) -> Result<Vec<u8>> {write_design_container_with_thumbnail(doc, compression, preview, geometry, None)}@@ -124,7 +124,7 @@ pub fn write_design_container_with_thumbnail(doc: &Document,compression: DesignCompression,preview: Option<&DesignPreview>,- geometry: Option<&solidcraft_doc::ModelState>,+ geometry: Option<&solidcraft_doc::SavedModel>,thumbnail: Option<&[u8]>,) -> Result<Vec<u8>> {write_container(doc, compression, preview, geometry, thumbnail, MAX_DESIGN_BYTES)@@ -136,7 +136,7 @@ fn write_container(doc: &Document,compression: DesignCompression,preview: Option<&DesignPreview>,- geometry: Option<&solidcraft_doc::ModelState>,+ geometry: Option<&solidcraft_doc::SavedModel>,thumbnail: Option<&[u8]>,budget: usize,) -> Result<Vec<u8>> {@@ -510,7 +510,7 @@ impl<R: Read + Seek> DesignContainerReader<R> {// fallback, generating a bounded provisional mesh without source imports.read_preview(&mut self.reader).ok().or_else(|| {let document = self.reader.document(16 << 20).ok()?;- native_cache::geometry_preview(&document, self.geometry()?).ok()+ native_cache::geometry_preview(&document, &self.geometry()?).ok()})}@@ -519,8 +519,8 @@ impl<R: Read + Seek> DesignContainerReader<R> {thumbnail::read(&mut self.reader).ok()}- /// The cached model state, when this build wrote it for exactly this document.- pub fn geometry(&mut self) -> Option<solidcraft_doc::ModelState> {+ /// The saved model, when this build wrote it for exactly this document.+ pub fn geometry(&mut self) -> Option<solidcraft_doc::SavedModel> {let document = self.reader.document(16 << 20).ok()?;native_cache::read_geometry_with(&mut self.reader, &document).ok()}@@ -536,9 +536,11 @@ pub(super) fn read(bytes: &[u8]) -> Result<Document> {}/// Open from disk (or browser VFS), publishing only provisional display before-/// authoritative blob hydration. Desktop keeps one seekable file handle instead-/// of buffering the complete archive. JSON continues through the normal migrations.-pub fn read_design_file(path: &str, notify: Option<impl FnOnce(DesignPreview)>) -> Result<Document> {+/// authoritative blob hydration, with the model the file keeps when this build saved it for+/// exactly this document ([`solidcraft_doc::Model::adopt`] takes it as the evaluation). Desktop+/// keeps one seekable file handle instead of buffering the complete archive. JSON continues+/// through the normal migrations.+pub fn read_design_file(path: &str, notify: Option<impl FnOnce(DesignPreview)>) -> Result<(Document, Option<solidcraft_doc::SavedModel>)> {#[cfg(not(target_arch = "wasm32"))]let mut source = {crate::vfs::check(path).map_err(invalid)?;@@ -569,16 +571,19 @@ pub fn read_design_file(path: &str, notify: Option<impl FnOnce(DesignPreview)>)source.seek(SeekFrom::Start(0)).map_err(invalid)?;if is_design_container(&prefix) {let mut reader = DesignContainerReader::new(source)?;+ // A design with its model opens without a picture first: the model is the session.+ let model = reader.geometry();if let Some(notify) = notify- && let Some(preview) = reader.preview()+ && model.is_none()+ && let Ok(preview) = read_preview(&mut reader.reader){notify(preview);}- reader.read_document()+ Ok((reader.read_document()?, model))} else {let mut bytes = Vec::new();source.take(MAX_DESIGN_BYTES as u64 + 1).read_to_end(&mut bytes).map_err(invalid)?;- crate::read_design(&bytes)+ Ok((crate::read_design(&bytes)?, None))}}@@ -717,15 +722,31 @@ mod tests {#[test]fn file_reader_refuses_nonfiles_before_notifying_preview() {let directory = std::env::temp_dir();- let result = read_design_file(directory.to_str().unwrap(), Some(|_| panic!("non-file supplied a preview")));+ let result = read_design_file(directory.to_str().unwrap(), Some(|_| panic!("non-file supplied a preview"))).map(|(doc, _)| doc);assert!(result.is_err_and(|e| e.to_string().contains("not a regular file")));}- fn native_geometry() -> solidcraft_doc::ModelState {- let cube = solidcraft_kernel::box_solid(solidcraft_geom::Vec3::ZERO, solidcraft_geom::Vec3::new(10., 20., 30.)).unwrap();- let mut state = solidcraft_doc::ModelState::default();- state.bodies.push(solidcraft_doc::ModelBody::new("Cube".into(), cube, 1));- state+ /// A saved model of one state holding `bodies` (no document evaluated it: enough for the+ /// container, which stores whatever model it is given).+ fn saved_model(bodies: Vec<solidcraft_kernel::Body>) -> solidcraft_doc::SavedModel {+ let records: Vec<Value> = (0..bodies.len())+ .map(|i| json!({"name": format!("Body{i}"), "feature": 1, "component": 0, "key": "0000000000000001", "names": 0, "body": i}))+ .collect();+ let state = json!({+ "bodies": [[0, bodies.len()]], "sketches": [], "body_counter": 7, "sheets": [], "construct": [], "threads": [],+ "sketch_keys": [], "blend_edges": {}, "fitted": {}, "tapered": {},+ });+ solidcraft_doc::SavedModel {+ records: json!({+ "features": [{"id": 1, "fingerprint": "0000000000000000", "ms": 0.0, "skipped": false, "state": 0}],+ "states": [state], "model_bodies": records, "names": [{"faces": [], "info": []}], "sketches": [],+ }),+ bodies,+ }+ }++ fn native_geometry() -> solidcraft_doc::SavedModel {+ saved_model(vec![solidcraft_kernel::box_solid(solidcraft_geom::Vec3::ZERO, solidcraft_geom::Vec3::new(10., 20., 30.)).unwrap()])}#[test]@@ -739,7 +760,7 @@ mod tests {let entries = parts(&bytes);assert!(entries.contains_key("cache/bodies.bin"));assert!(!entries.contains_key("cache/preview.bin"));- assert_eq!(read_design_geometry(&bytes).unwrap().bodies[0].body.face_count(), bodies.bodies[0].body.face_count());+ assert_eq!(read_design_geometry(&bytes).unwrap().bodies[0].body.face_count(), bodies.bodies[0].face_count());assert_eq!(bytes, write_design_container_with_cache(&doc, DesignCompression::Fast, None, Some(&bodies)).unwrap());let count = std::rc::Rc::new(std::cell::Cell::new(0));let mut reader = DesignContainerReader::new(CountingReader { source: Cursor::new(bytes), count: count.clone() }).unwrap();@@ -754,34 +775,26 @@ mod tests {use solidcraft_geom::Vec3;let part = solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.)).unwrap();let share = solidcraft_kernel::DisplayShare::new(part.clone());- let t = [[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [50., 0., 0., 1.]];- let mut state = solidcraft_doc::ModelState::default();- state.body_counter = 7;- for (i, body) in [part.clone(), part.clone()].into_iter().enumerate() {- state.bodies.push(solidcraft_doc::ModelBody::new(format!("Part {i}"), body, 1));- }+ let mut bodies = vec![part.clone(), part.clone()];for x in [50., 90.] {let moved = solidcraft_kernel::transform(&part, Vec3::new(x, 0., 0.), Vec3::ZERO, Vec3::Z, 0.).unwrap();- let mut t = t;- t[3][0] = x;- let mut b = solidcraft_doc::ModelBody::new(format!("Copy {x}"), moved.with_display_share(&share, t), 2);- b.component = 3;- b.source_name = Some("Part".into());- state.bodies.push(b);+ let t = [[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [x, 0., 0., 1.]];+ bodies.push(moved.with_display_share(&share, t));}+ let model = saved_model(bodies);let doc = document();- let bytes = write_design_container_with_cache(&doc, DesignCompression::Fast, None, Some(&state)).unwrap();+ let bytes = write_design_container_with_cache(&doc, DesignCompression::Fast, None, Some(&model)).unwrap();let manifest: Value = serde_json::from_slice(&parts(&bytes)["cache/model.json"]).unwrap();- assert_eq!(manifest["bodies"].as_array().unwrap().len(), 3, "the part and each placed copy, once each");- let read = read_design_geometry(&bytes).unwrap();- assert_eq!(read.body_counter, 7);- assert_eq!(read.bodies.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(), ["Part 0", "Part 1", "Copy 50", "Copy 90"]);- let copies: Vec<_> = read.bodies[2..].iter().map(|b| b.body.display_share().unwrap()).collect();+ assert_eq!(manifest["slices"].as_array().unwrap().len(), 3, "the part and each placed copy, once each");+ let read = DesignContainerReader::new(Cursor::new(&bytes)).unwrap().geometry().unwrap();+ assert_eq!(read.records, model.records);+ assert_eq!(read_design_geometry(&bytes).unwrap().body_counter, 7);+ let copies: Vec<_> = read.bodies[2..].iter().map(|b| b.display_share().unwrap()).collect();assert_eq!(copies[0].0.id(), copies[1].0.id(), "copies show one display again");assert_eq!(copies[1].1[3][0], 90.);- assert_eq!((read.bodies[3].component, read.bodies[3].source_name.as_deref(), read.bodies[3].feature), (3, Some("Part"), 2));- for (a, b) in state.bodies.iter().zip(&read.bodies) {- assert_eq!(solidcraft_kernel::encode_native_body(&a.body).unwrap(), solidcraft_kernel::encode_native_body(&b.body).unwrap());+ assert!(read.bodies[0].display_share().is_none());+ for (a, b) in model.bodies.iter().zip(&read.bodies) {+ assert_eq!(solidcraft_kernel::encode_native_body(a).unwrap(), solidcraft_kernel::encode_native_body(b).unwrap());}}diff --git a/crates/io/src/design/native_cache.rs b/crates/io/src/design/native_cache.rsindex 3450e7c1a1..7005349f0f 100644--- a/crates/io/src/design/native_cache.rs+++ b/crates/io/src/design/native_cache.rs@@ -1,10 +1,11 @@-//! The model cache: the evaluated bodies of a design's timeline, saved with it so opening need-//! not rebuild them. Its SolidCraft schema is independent of the producing kernel; its key ties it-//! to the exact document, build and platform that computed it (docs/design-container.md).+//! The model cache: a design's evaluated timeline (every feature's result and the state after+//! it, [`SavedModel`]), saved with it so opening need not evaluate it again. Bodies use+//! SolidCraft's exact native B-rep encoding; the key ties the cache to the exact document, build+//! and platform that computed it (docs/design-container.md).use super::*;-use solidcraft_doc::{ModelBody, ModelState};+use solidcraft_doc::{ModelState, SavedModel};-const FORMAT: &str = "solidcraft-model-cache/1";+const FORMAT: &str = "solidcraft-model-cache/2";const PRODUCER: &str = "solidcraft-truck-adapter/3";const MANIFEST: &str = "cache/model.json";const PAYLOAD: &str = "cache/bodies.bin";@@ -25,53 +26,25 @@ fn matrix(t: &[[f64; 4]; 4]) -> Vec<f64> {t.iter().flatten().copied().collect()}-fn look(look: &solidcraft_doc::appearance::ImportedLook) -> Value {- let faces: Vec<Value> = look.faces.iter().map(|(name, (color, opacity))| json!([name, color, opacity])).collect();- json!({"color": look.color, "opacity": look.opacity, "faces": faces})-}--fn load_look(v: &Value) -> Result<solidcraft_doc::appearance::ImportedLook> {- let unit = |x: f32| x.is_finite() && (0.0..=1.0).contains(&x);- let color = |v: &Value| -> Result<Option<[f32; 3]>> {- let c: Option<[f32; 3]> = serde_json::from_value(v.clone()).map_err(invalid)?;- if c.is_some_and(|c| !c.iter().copied().all(unit)) {- return Err(invalid("cached colour"));- }- Ok(c)- };- let opacity: Option<f32> = serde_json::from_value(v.get("opacity").cloned().unwrap_or(Value::Null)).map_err(invalid)?;- if opacity.is_some_and(|o| !unit(o)) {- return Err(invalid("cached opacity"));- }- let mut faces = BTreeMap::new();- for f in v.get("faces").and_then(Value::as_array).ok_or_else(|| invalid("cached face looks"))? {- let name = f.get(0).and_then(Value::as_str).filter(|n| n.len() <= 1024).ok_or_else(|| invalid("cached face name"))?;- let c = color(f.get(1).unwrap_or(&Value::Null))?.ok_or_else(|| invalid("cached face colour"))?;- let o = f.get(2).and_then(Value::as_f64).map(|o| o as f32).filter(|o| unit(*o)).ok_or_else(|| invalid("cached face opacity"))?;- faces.insert(name.to_owned(), (c, o));- }- Ok(solidcraft_doc::appearance::ImportedLook { color: color(v.get("color").unwrap_or(&Value::Null))?, opacity, faces })-}--/// Encode a model state's bodies. Identical bodies (the same part placed many times, a body a-/// feature passed through) are stored once; a placed copy of a part records the part and its-/// matrix, so it shows that part's display as it did before saving.-pub(super) fn encode_model(state: &ModelState, document: &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {- if state.bodies.is_empty() || state.bodies.len() > MAX_RECORDS {+/// Encode a saved model. Identical bodies (the same part placed many times) are stored once; a+/// placed copy of a part records the part and its matrix, so it shows that part's display as it+/// did before saving.+pub(super) fn encode_model(model: &SavedModel, document: &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {+ if model.bodies.is_empty() || model.bodies.len() > MAX_RECORDS {return Err(invalid("cached body count"));}// What to encode: every body, and the part every placed copy shows.let mut shares: Vec<solidcraft_kernel::DisplayShare> = Vec::new();let mut share_index = std::collections::HashMap::new();- for b in &state.bodies {- if let Some((share, _)) = b.body.display_share() {+ for b in &model.bodies {+ if let Some((share, _)) = b.display_share() {share_index.entry(share.id()).or_insert_with(|| {shares.push(share.clone());shares.len() - 1});}}- let bodies: Vec<&solidcraft_kernel::Body> = state.bodies.iter().map(|b| &b.body).chain(shares.iter().map(|s| s.original())).collect();+ let bodies: Vec<&solidcraft_kernel::Body> = model.bodies.iter().chain(shares.iter().map(|s| s.original())).collect();let encoded = solidcraft_kernel::map_on_threads(&bodies, 16, |b| solidcraft_kernel::encode_native_body(b).ok());let mut data = Vec::new();let mut slices = Vec::new();@@ -90,35 +63,18 @@ pub(super) fn encode_model(state: &ModelState, document: &[u8]) -> Result<(Vec<u}index.push(i);}- let (body_index, share_body) = index.split_at(state.bodies.len());- let mut records = Vec::with_capacity(state.bodies.len());- for (b, i) in state.bodies.iter().zip(body_index) {- if b.name.len() > 1024 {- return Err(invalid("cached body name"));- }- let mut r = json!({"name": b.name, "body": i, "feature": b.feature, "component": b.component});- if let Some(source) = &b.source_name {- r["source_name"] = json!(source);- }- if b.source_transform != solidcraft_doc::IDENTITY {- r["source_transform"] = json!(matrix(&b.source_transform));- }- if b.transferred {- r["transferred"] = json!(true);- }- if let Some(l) = &b.imported {- r["imported"] = look(l);- }- if let Some((share, t)) = b.body.display_share() {- let s = share_index.get(&share.id()).ok_or_else(|| invalid("display share"))?;- r["share"] = json!([s, matrix(&t)]);- }- records.push(r);+ let (body_index, share_body) = index.split_at(model.bodies.len());+ let mut table = Vec::with_capacity(model.bodies.len());+ for (b, i) in model.bodies.iter().zip(body_index) {+ table.push(match b.display_share() {+ Some((share, t)) => json!([i, share_index.get(&share.id()).ok_or_else(|| invalid("display share"))?, matrix(&t)]),+ None => json!([i]),+ });}let manifest = serde_json::to_vec(&json!({"format": FORMAT, "producer": PRODUCER, "app": env!("CARGO_PKG_VERSION"), "build": build(),"document": digest(document), "payload": digest(&data),- "bodies": slices, "shares": share_body, "body_counter": state.body_counter, "state": records,+ "slices": slices, "shares": share_body, "bodies": table, "model": model.records,})).map_err(invalid)?;if manifest.len() > MAX_MANIFEST {@@ -127,13 +83,13 @@ pub(super) fn encode_model(state: &ModelState, document: &[u8]) -> Result<(Vec<uOk((manifest, data))}-/// The cached model state of a design, when it holds one this build computed for exactly this+/// The final state of the model a design keeps, when this build computed it for exactly this/// document. Any failure is a miss, never a document error.-pub fn read_design_geometry(bytes: &[u8]) -> Option<ModelState> {+pub fn read_design_geometry(bytes: &[u8]) -> Option<std::sync::Arc<ModelState>> {if bytes.len() > MAX_DESIGN_BYTES || !is_design_container(bytes) {return None;}- DesignContainerReader::new(Cursor::new(bytes)).ok()?.geometry()+ DesignContainerReader::new(Cursor::new(bytes)).ok()?.geometry()?.final_state().ok()}/// Whether `manifest` is a model cache this build wrote for `document`.@@ -148,12 +104,12 @@ fn current(manifest: &Value, document: &[u8]) -> bool {&& env!("SOLIDCRAFT_SOURCE_COMMIT") != "unknown"}-pub(super) fn read_geometry_with<R: Read + Seek>(reader: &mut PackageReader<R>, document: &[u8]) -> Result<ModelState> {+pub(super) fn read_geometry_with<R: Read + Seek>(reader: &mut PackageReader<R>, document: &[u8]) -> Result<SavedModel> {let container: Value = serde_json::from_slice(&reader.limited_part("container.json", 4096)?).map_err(invalid)?;if container.get("format").and_then(Value::as_str) != Some(VERSION) {return Err(invalid("container version"));}- let manifest: Value = serde_json::from_slice(&reader.limited_part(MANIFEST, MAX_MANIFEST)?).map_err(invalid)?;+ let mut manifest: Value = serde_json::from_slice(&reader.limited_part(MANIFEST, MAX_MANIFEST)?).map_err(invalid)?;if !current(&manifest, document) {return Err(invalid("model cache key"));}@@ -163,16 +119,16 @@ pub(super) fn read_geometry_with<R: Read + Seek>(reader: &mut PackageReader<R>,if manifest.get("payload").and_then(Value::as_str) != Some(digest(&data).as_str()) {return Err(invalid("model cache payload key"));}- let count = |v: &Value| v.as_u64().and_then(|n| usize::try_from(n).ok()).ok_or_else(|| invalid("model cache number"));+ let count = |v: Option<&Value>| v.and_then(Value::as_u64).and_then(|n| usize::try_from(n).ok()).ok_or_else(|| invalid("model cache number"));let slices = manifest- .get("bodies")+ .get("slices").and_then(Value::as_array).filter(|b| !b.is_empty() && b.len() <= MAX_UNIQUE).ok_or_else(|| invalid("cached bodies"))?;let mut end = 0usize;let mut parts = Vec::with_capacity(slices.len());for s in slices {- let (offset, length) = (count(s.get(0).unwrap_or(&Value::Null))?, count(s.get(1).unwrap_or(&Value::Null))?);+ let (offset, length) = (count(s.get(0))?, count(s.get(1))?);if offset != end {return Err(invalid("overlapping cached bodies"));}@@ -183,47 +139,33 @@ pub(super) fn read_geometry_with<R: Read + Seek>(reader: &mut PackageReader<R>,return Err(invalid("trailing cached data"));}let decoded = solidcraft_kernel::map_on_threads(&parts, 16, |bytes| solidcraft_kernel::decode_native_body(bytes).ok());- let bodies = decoded.into_iter().map(Option::flatten).collect::<Option<Vec<_>>>().ok_or_else(|| invalid("cached body"))?;- let body = |v: &Value| bodies.get(count(v)?).ok_or_else(|| invalid("cached body index"));+ let unique = decoded.into_iter().map(Option::flatten).collect::<Option<Vec<_>>>().ok_or_else(|| invalid("cached body"))?;+ let body = |v: Option<&Value>| unique.get(count(v)?).ok_or_else(|| invalid("cached body index"));let shares = manifest.get("shares").and_then(Value::as_array).filter(|s| s.len() <= MAX_UNIQUE).ok_or_else(|| invalid("cached shares"))?.iter()- .map(|i| Ok(solidcraft_kernel::DisplayShare::new(body(i)?.clone())))+ .map(|i| Ok(solidcraft_kernel::DisplayShare::new(body(Some(i))?.clone()))).collect::<Result<Vec<_>>>()?;- let records =- manifest.get("state").and_then(Value::as_array).filter(|s| !s.is_empty() && s.len() <= MAX_RECORDS).ok_or_else(|| invalid("cached state"))?;- let mut state = ModelState::default();- state.body_counter = count(manifest.get("body_counter").unwrap_or(&Value::Null))?;- for r in records {- let name = r.get("name").and_then(Value::as_str).filter(|n| n.len() <= 1024).ok_or_else(|| invalid("cached body name"))?;- let mut kernel_body = body(r.get("body").unwrap_or(&Value::Null))?.clone();- if let Some(share) = r.get("share") {- let s = shares.get(count(share.get(0).unwrap_or(&Value::Null))?).ok_or_else(|| invalid("cached share index"))?;- let numbers: Vec<f64> = serde_json::from_value(share.get(1).cloned().unwrap_or(Value::Null)).map_err(invalid)?;- let t = matrix_of(&numbers)?;- kernel_body = kernel_body.with_display_share(s, t);- }- let feature = r.get("feature").and_then(Value::as_u64).ok_or_else(|| invalid("cached body feature"))?;- let mut b = ModelBody::new(name.to_owned(), kernel_body, feature);- b.component = r.get("component").and_then(Value::as_u64).ok_or_else(|| invalid("cached body component"))?;- b.source_name = match r.get("source_name") {- None => None,- Some(v) => Some(v.as_str().filter(|n| n.len() <= 1024).ok_or_else(|| invalid("cached source name"))?.to_owned()),- };- if let Some(v) = r.get("source_transform") {- let numbers: Vec<f64> = serde_json::from_value(v.clone()).map_err(invalid)?;- b.source_transform = matrix_of(&numbers)?;- }- b.transferred = r.get("transferred").and_then(Value::as_bool).unwrap_or(false);- if let Some(l) = r.get("imported") {- b.imported = Some(Arc::new(load_look(l)?));+ let table = manifest+ .get("bodies")+ .and_then(Value::as_array)+ .filter(|s| !s.is_empty() && s.len() <= MAX_RECORDS)+ .ok_or_else(|| invalid("cached body table"))?;+ let mut bodies = Vec::with_capacity(table.len());+ for entry in table {+ let mut b = body(entry.get(0))?.clone();+ if let Some(share) = entry.get(1) {+ let s = shares.get(count(Some(share))?).ok_or_else(|| invalid("cached share index"))?;+ let numbers: Vec<f64> = serde_json::from_value(entry.get(2).cloned().unwrap_or(Value::Null)).map_err(invalid)?;+ b = b.with_display_share(s, matrix_of(&numbers)?);}- state.bodies.push(b);+ bodies.push(b);}- Ok(state)+ let records = manifest.get_mut("model").map(Value::take).ok_or_else(|| invalid("cached model"))?;+ Ok(SavedModel { records, bodies })}/// A 4 x 4 matrix from its 16 numbers in storage order, finite.@@ -238,9 +180,9 @@ fn matrix_of(numbers: &[f64]) -> Result<[[f64; 4]; 4]> {Ok(t)}-pub(super) fn geometry_preview(document: &[u8], state: ModelState) -> Result<DesignPreview> {+pub(super) fn geometry_preview(document: &[u8], model: &SavedModel) -> Result<DesignPreview> {let doc = Document::from_json(std::str::from_utf8(document).map_err(invalid)?)?;- let world = solidcraft_doc::world_state(&doc, &state);+ let world = solidcraft_doc::world_state(&doc, &*model.final_state()?);let mut preview = DesignPreview::default();let mut triangles = 0usize;let mut display_bytes = 0usize;diff --git a/crates/kernel/src/blend_variable.rs b/crates/kernel/src/blend_variable.rsindex 8aafc19da5..337408aa56 100644--- a/crates/kernel/src/blend_variable.rs+++ b/crates/kernel/src/blend_variable.rs@@ -63,7 +63,7 @@ pub fn fillet_variable(body: &Body, edge_at: Vec3, start: Vec3, r0: f64, r1: f64/// A fillet radius along an edge: a clamped B-spline of the position along it (0 at one end, 1/// at the other), given by its degree, knots and control radii. The radius is a smooth curve/// shaped by its control radii, each pulling it toward itself near its Greville position.-#[derive(Clone, Debug, PartialEq)]+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]pub struct RadiusSpline {pub degree: usize,pub knots: Vec<f64>,@@ -503,7 +503,7 @@ const TAPER_SHARE: f64 = 0.9;const TAPER_SPANS: usize = 8;/// The radius a taper gives one edge: its positions from `start`.-#[derive(Clone, Debug, PartialEq)]+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]pub struct Taper {pub start: Vec3,pub spline: RadiusSpline,diff --git a/crates/kernel/src/boolean_diagnostics.rs b/crates/kernel/src/boolean_diagnostics.rsindex b160980fb6..e2a4b79cc9 100644--- a/crates/kernel/src/boolean_diagnostics.rs+++ b/crates/kernel/src/boolean_diagnostics.rs@@ -3,11 +3,11 @@use std::cell::RefCell;-use serde::Serialize;+use serde::{Deserialize, Serialize};const MAX_EVENTS: usize = 1024;-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize)]+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]#[serde(rename_all = "snake_case")]pub enum BooleanStrategy {RefinedTolerance,@@ -29,7 +29,7 @@ pub enum BooleanStrategy {/// Numerical adjustments used by a successful retry, in millimetres/radians./// Operand shifts are reversed on the result; face shifts are temporary working/// offsets. A tool nudge, in contrast, changes the relative operand placement.-#[derive(Clone, Debug, PartialEq, Serialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct BooleanFallback {pub strategy: BooleanStrategy,pub translation_mm: f64,@@ -73,7 +73,7 @@ impl BooleanFallback {}}-#[derive(Clone, Debug, Default, PartialEq, Serialize)]+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]pub struct BooleanDiagnostics {pub events: Vec<BooleanFallback>,pub truncated: bool,diff --git a/docs/design-container.md b/docs/design-container.mdindex 29cddc7474..c435fdc587 100644--- a/docs/design-container.md+++ b/docs/design-container.md@@ -86,9 +86,10 @@ geometry, used for measurements, or used to seed evaluated model state. The origdesign remains intact until the complete rebuilt session is ready. Cancellation orany change of active document/revision discards both preview and completion.-Normal design reading, CLI and browser opening still rebuild authoritatively.-The model cache can supply provisional display as described below. The saved-picture is not an interactive viewport.+Desktop Open takes the evaluation from the model cache when the file keeps one for+this document and build (see below); otherwise it evaluates the timeline, as+design reading in the CLI and browser does. The saved picture is not an+interactive viewport.## Seekable reader (phase 2, first increment)@@ -121,6 +122,17 @@ being saved (`Model::is_current`). An active sketch, uncaptured moves, featureerrors, mesh bodies or exceeded budgets leave the cache out; the design saves asbefore.+The model is the whole evaluation: every feature's result (warning, boolean+diagnostics, whether it was skipped, its fingerprint) and the state after it+(bodies, solved sketches, construction geometry, sheet metal bodies, threads and+the blend records later features read). States share what they share: a body that+later features pass through unchanged, its face names and a solved sketch are each+recorded once. Face names are kept as worked out (saving works out any not asked+for yet), so a body taken from the file is named exactly as when it was saved.+A design whose stored names predate format 14 (marked `?`) finds them through+names worked out from geometry on demand, which the cache does not keep: it saves+without a model.+Both entries are Deflate-compressed (level one) under either compression policy: theencoded bodies shrink about fourfold (an imported assembly) to tenfold (modelled parts),for a few tens of milliseconds.@@ -134,15 +146,14 @@ SHA-256 of their encoding), and a placed copy of a repeated part (an instance fra STEP assembly) records the part and its matrix, so it shows that part's displayagain instead of being meshed on its own.-`cache/model.json` records `solidcraft-model-cache/1`, the producer revision+`cache/model.json` records `solidcraft-model-cache/2`, the producer revision`solidcraft-truck-adapter/3`, the application version, the build (source commit,CPU architecture and OS), the SHA-256 of the exact `document.json` (whose blobreferences pin every STEP, mesh and image payload) and of `cache/bodies.bin`, the-slices, and the bodies' records: name, feature, component, placement source,-imported look and display share. A cache is read back only when every one of these-matches: the same source compiled for the same platform computes the same numbers,-so another build's cache is a miss. A build of unknown source (a tarball without-git) never reads a cache.+slices, each kernel body's slice and display share, and the model's records. A+cache is read back only when every one of these matches: the same source compiled+for the same platform computes the same numbers, so another build's cache is a+miss. A build of unknown source (a tarball without git) never reads a cache.The fixed budgets of earlier caches (4,096 bodies, 100,000 faces, 64 MiB) scalewith the design now: up to 200,000 body records, 100,000 distinct bodies, a 32 MiB@@ -152,9 +163,34 @@ budgets (256 MiB per part, 512 MiB expanded, 10,000 entries) are unchanged, andcache is left out when it would push the container near them. Decoding runs under`kernel::guard` and is linear in the payload's bytes.-Opening still rebuilds the design from its timeline; the cache supplies the-provisional picture (a bounded mesh of the placed bodies) before that finishes.-Any failure in it is a miss, never a failed open. Earlier `cache/key.json` and+### Opening from the model++Open takes the model as the design's evaluation (`Model::adopt`) when the key+matches and every feature's fingerprint (its definition, the parameters and+imported files it reads, the features before it, the timeline marker) is the one+the opened document gives it now. Nothing is evaluated: the imported STEP text is+resolved and hashed, never parsed. Every feature is up to date, so an edit+evaluates from the first feature it changes, as after any evaluation: a feature+appended or edited at the end evaluates from the saved final state, an edit to+feature k from the saved state before k. Moving the timeline marker, undo and redo+reuse the saved results whose fingerprints come back. `SOLIDCRAFT_NO_MODEL_CACHE`+set evaluates anyway. Any failure (a key or fingerprint mismatch, a malformed+record, a body that does not decode) is a miss: the design is evaluated from its+timeline as before, and only that.++This replaces the earlier rule that a cache never supplies evaluated session+state. It is safe because the cache is the result of evaluating exactly this+document with exactly this build: the hashes tie it to the document (and through+it to every source blob) and to its own payload, the build key to the code that+computed it, the fingerprints to every feature's inputs, and the exact encoding+gives back the bodies number for number. Hashes are not trust: a crafted file can+carry a cache whose geometry disagrees with its timeline, as a crafted STEP file+can carry any geometry. Every decoded body passes the same structural and resource+checks, under `kernel::guard`, and Compute All (`timeline.compute_all`) evaluates+the whole timeline again.++Before the session is ready the cache still supplies the picture (a bounded mesh+of the placed bodies) shown while opening. Earlier `cache/key.json` and`cache/brep.bin` entries are ignored.## Review increments and kernel independence