SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
fix: restore shell and cut wall topology in 0.2.1
bherbruckef8f6ca6f9a9
diff --git a/Cargo.lock b/Cargo.lockindex 03282d76f6..d75e4e5b17 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -3256,7 +3256,7 @@ dependencies = [[[package]]name = "solvecraft"-version = "0.2.0"+version = "0.2.1"dependencies = ["eframe","egui",@@ -3270,7 +3270,7 @@ dependencies = [[[package]]name = "solvecraft-cli"-version = "0.2.0"+version = "0.2.1"dependencies = ["serde_json","solvecraft-engine",@@ -3279,7 +3279,7 @@ dependencies = [[[package]]name = "solvecraft-doc"-version = "0.2.0"+version = "0.2.1"dependencies = ["log","serde",@@ -3294,7 +3294,7 @@ dependencies = [[[package]]name = "solvecraft-engine"-version = "0.2.0"+version = "0.2.1"dependencies = ["log","serde",@@ -3310,7 +3310,7 @@ dependencies = [[[package]]name = "solvecraft-geom"-version = "0.2.0"+version = "0.2.1"dependencies = ["serde","serde_json",@@ -3318,7 +3318,7 @@ dependencies = [[[package]]name = "solvecraft-io"-version = "0.2.0"+version = "0.2.1"dependencies = ["quick-xml 0.38.4","solvecraft-doc",@@ -3330,7 +3330,7 @@ dependencies = [[[package]]name = "solvecraft-kernel"-version = "0.2.0"+version = "0.2.1"dependencies = ["log","serde",@@ -3345,7 +3345,7 @@ dependencies = [[[package]]name = "solvecraft-mcp"-version = "0.2.0"+version = "0.2.1"dependencies = ["serde_json","solvecraft-engine",@@ -3353,7 +3353,7 @@ dependencies = [[[package]]name = "solvecraft-render"-version = "0.2.0"+version = "0.2.1"dependencies = ["image","serde",@@ -3362,7 +3362,7 @@ dependencies = [[[package]]name = "solvecraft-sketch"-version = "0.2.0"+version = "0.2.1"dependencies = ["serde","serde_json",@@ -3373,7 +3373,7 @@ dependencies = [[[package]]name = "solvecraft-ui-egui"-version = "0.2.0"+version = "0.2.1"dependencies = ["egui","egui-wgpu",@@ -3388,7 +3388,7 @@ dependencies = [[[package]]name = "solvecraft-web"-version = "0.2.0"+version = "0.2.1"dependencies = ["eframe","egui",@@ -4760,7 +4760,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"[[package]]name = "xtask"-version = "0.2.0"+version = "0.2.1"dependencies = ["serde_json",]diff --git a/Cargo.toml b/Cargo.tomlindex 7069ee3969..2729950f6e 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -5,7 +5,7 @@ members = ["crates/*", "apps/*", "xtask"]exclude = ["vendor"][workspace.package]-version = "0.2.0"+version = "0.2.1"edition = "2024"license = "MIT OR Apache-2.0"rust-version = "1.90"diff --git a/ROADMAP.md b/ROADMAP.mdindex b82c5bd77b..e448813a20 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -90,6 +90,27 @@ headline counts in-scope tabs only and lists the deferred ones separately.the original electronics enclosure story and animated pointer in the actual English0.2.0 UI, at 4× playback. Publication follows [the release workflow](docs/releasing.md).+## 0.2.1 critical fixes++- Axis view and navigation controls stay anchored to the viewport when feature dialogs or+ the command palette open, at normal and enlarged display scales. Fit still accounts for+ dialog coverage; covered controls do not receive clicks through dialogs.+- Eligible planar faces survive fillet, chamfer and shell operations with exact source+ certificates. Sketches placed directly on the enclosure wall and inner floor follow+ width and wall changes, including after the USB cut and cold reopening.+- Remove artificial straight-wall and rounded-corner subdivisions left by shell and+ extrusion cuts. Identical generated wall segments span adjacent slabs as one physical+ face, with exact full-height supports and boundary stitching. Preserve authored face+ splits and face appearances. Permanent regressions cover material, STEP, reopening and+ unaffected bodies across the extrusion end plane.+- Feature dialogs use the available screen height for their fields, with OK and Cancel+ outside the scrolling region, including enlarged display scales.+- Design format 13 records shell-face attachments. Older designs remain readable;+ newly saved designs require 0.2.1 or later. Ambiguous or unsupported faces still refuse+ attachment rather than guessing a plane.+- Saved projections from a removed strip retain their geometry and report the lost+ reference. Explicitly reselect the wall to repair that projection.+## View navigation- Compact clickable signed X/Y/Z axis tips, smooth drag-to-orbit, and Shift-orbit snapping@@ -99,9 +120,8 @@ headline counts in-scope tabs only and lists the deferred ones separately.## Known limitations-- Some shelled planar faces cannot supply the exact source required for an associative- face sketch. The enclosure demo uses parameter-driven offset planes (`width/2` for the- USB port, `wall` for the mounting bosses), so width and wall edits still rebuild the case.+- Associative shell-face sketches require a unique certified planar source. Nested shell+ attachments and ambiguous coincident sources remain unsupported.- Fillets and chamfers: constant, variable-radius and chord-length fillets; a radius per edge,rounds next to earlier rounds of another radius, and smooth corner patches where three roundsmeet (a sphere for equal radii); straight edges (convex or concave) between planar faces with perpendiculardiff --git a/crates/doc/src/config_certificates.rs b/crates/doc/src/config_certificates.rsindex 6c6b73962b..4588344d9c 100644--- a/crates/doc/src/config_certificates.rs+++ b/crates/doc/src/config_certificates.rs@@ -154,10 +154,19 @@ pub enum FaceCertificate {ExtrudeCap { sketch: u64, high: bool, outer: Vec<String>, holes: Vec<Vec<String>> },ExtrudeSide { sketch: u64, curve: String },Imported { payload_sha256: String, item: u64, face: u64 },+ ShellPlanar { source_producer: u64, source: Box<FaceCertificate>, inner: bool },}impl FaceCertificate {pub fn remap_features(&mut self, features: &std::collections::BTreeMap<u64, u64>) {+ if let Self::ShellPlanar { source_producer, source, .. } = self {+ if let Some(mapped) = features.get(source_producer) {+ *source_producer = *mapped;+ }+ if !matches!(source.as_ref(), Self::ShellPlanar { .. }) {+ source.remap_features(features);+ }+ }if let Self::ExtrudeSide { sketch, .. } | Self::ExtrudeCap { sketch, .. } = self&& let Some(mapped) = features.get(sketch){@@ -175,6 +184,9 @@ impl FaceCertificate {&& payload_sha256.len() == 64&& payload_sha256.bytes().all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))}+ Self::ShellPlanar { source_producer, source, .. } => {+ *source_producer != 0 && !matches!(source.as_ref(), Self::ShellPlanar { .. }) && source.validate().is_ok()+ }};if valid { Ok(()) } else { Err(DocError::Invalid("invalid face source certificate".into())) }}@@ -216,11 +228,83 @@ pub(crate) fn validate_certificate_json(value: &serde_json::Value) -> Result<()>.and_then(serde_json::Value::as_str).is_some_and(|digest| digest.len() == 64 && digest.bytes().all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)))}+ Some("shell_planar") => {+ fields.len() == 4+ && fields.keys().all(|key| ["kind", "source_producer", "source", "inner"].contains(&key.as_str()))+ && nonzero("source_producer")+ && fields.get("inner").and_then(serde_json::Value::as_bool).is_some()+ && fields.get("source").is_some_and(|source| {+ source.as_object().is_some_and(|source| source.get("kind").and_then(serde_json::Value::as_str) != Some("shell_planar"))+ && validate_certificate_json(source).is_ok()+ })+ }_ => false,};if valid { Ok(()) } else { Err(DocError::Invalid("malformed or oversized face source certificate".into())) }}+/// Canonical diagnostic role; producer identity remains in the typed certificate.+pub(crate) fn shell_certificate_role(source: &FaceCertificate, inner: bool) -> Result<String> {+ source.validate()?;+ let role = match source {+ FaceCertificate::Box { axis, high } => {+ let axis = ["x", "y", "z"].get(*axis as usize).ok_or_else(|| DocError::Invalid("invalid shell source axis".into()))?;+ format!("box:{}{axis}", if *high { "+" } else { "-" })+ }+ FaceCertificate::ExtrudeSide { curve, .. } => format!("side:{curve}"),+ FaceCertificate::ExtrudeCap { high, outer, holes, .. } => format!("cap:{}:{}", if *high { "high" } else { "low" }, cap_key(outer, holes)),+ FaceCertificate::Imported { payload_sha256, item, face } => format!("import:{payload_sha256}:{item}:{face}"),+ FaceCertificate::ShellPlanar { .. } => return Err(DocError::Invalid("nested shell source certificates are unsupported".into())),+ };+ Ok(format!("shell:{}:{role}", if inner { "inner" } else { "outer" }))+}++pub(crate) fn flat_source_certificate(source: &solvecraft_kernel::FaceSource) -> Option<(u64, FaceCertificate)> {+ use solvecraft_kernel::FaceSource;+ match source {+ FaceSource::Box { producer: Some(producer), axis, high, .. } => Some((*producer, FaceCertificate::Box { axis: *axis, high: *high })),+ FaceSource::CertifiedExtrudeSide { producer, sketch, curve, .. } => {+ Some((*producer, FaceCertificate::ExtrudeSide { sketch: *sketch, curve: curve.clone() }))+ }+ FaceSource::CertifiedExtrudeCap { producer, sketch, high, outer, holes, .. } => {+ Some((*producer, FaceCertificate::ExtrudeCap { sketch: *sketch, high: *high, outer: outer.clone(), holes: holes.clone() }))+ }+ FaceSource::Imported { producer: Some(producer), payload_sha256: Some(digest), item, face } => {+ Some((*producer, FaceCertificate::Imported { payload_sha256: digest.clone(), item: *item, face: *face }))+ }+ _ => None,+ }+}++pub(crate) fn flat_source_matches(certificate: &FaceCertificate, source: &solvecraft_kernel::FaceSource, producer: u64) -> bool {+ use solvecraft_kernel::FaceSource;+ match (certificate, source) {+ (FaceCertificate::Box { axis, high }, FaceSource::Box { producer: Some(current), axis: current_axis, high: current_high, .. }) => {+ producer == *current && axis == current_axis && high == current_high+ }+ (+ FaceCertificate::ExtrudeSide { sketch, curve },+ FaceSource::CertifiedExtrudeSide { producer: current, sketch: current_sketch, curve: current_curve, .. },+ ) => producer == *current && sketch == current_sketch && curve == current_curve,+ (+ FaceCertificate::ExtrudeCap { sketch, high, outer, holes },+ FaceSource::CertifiedExtrudeCap {+ producer: current,+ sketch: current_sketch,+ high: current_high,+ outer: current_outer,+ holes: current_holes,+ ..+ },+ ) => producer == *current && sketch == current_sketch && high == current_high && outer == current_outer && holes == current_holes,+ (+ FaceCertificate::Imported { payload_sha256, item, face },+ FaceSource::Imported { producer: Some(current), payload_sha256: Some(digest), item: current_item, face: current_face },+ ) => producer == *current && payload_sha256 == digest && item == current_item && face == current_face,+ _ => false,+ }+}+/// Match a generated segment to one exact analytic sketch curve. Coincident/// candidates are ambiguous and never resolved by distance or candidate order.pub(crate) fn exact_sketch_curve(sketch: &SolvedSketch, generated: &Seg2) -> Option<String> {@@ -306,6 +390,7 @@ impl Document {Some(solvecraft_kernel::FaceSource::Imported { producer: Some(producer), .. })| Some(solvecraft_kernel::FaceSource::CertifiedExtrudeSide { producer, .. })| Some(solvecraft_kernel::FaceSource::CertifiedExtrudeCap { producer, .. })+ | Some(solvecraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), .. })| Some(solvecraft_kernel::FaceSource::Box { producer: Some(producer), .. }) => *producer,_ => name.strip_prefix('F')@@ -316,6 +401,8 @@ impl Document {let certificate = self.configuration_face_certificate(body, index)?;if let Some(FaceCertificate::ExtrudeSide { curve, .. }) = &certificate {name = format!("F{origin}:side:{curve}");+ } else if let Some(FaceCertificate::ShellPlanar { source, inner, .. }) = &certificate {+ name = format!("F{origin}:{}", shell_certificate_role(source, *inner)?);} else if !name.starts_with(&format!("F{origin}:")) {name = format!("F{origin}:face:{index}");}@@ -332,6 +419,19 @@ impl Document {let Some(source) = body.body.face_sources().and_then(|sources| sources.get(index)).and_then(Option::as_ref) else {return Ok(None);};+ if let solvecraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), source, inner, .. } = source {+ if !self.feature(*producer).is_some_and(|feature| matches!(feature.kind, FeatureKind::Shell { .. })) {+ return Err(DocError::Invalid("shell source producer missing".into()));+ }+ let (source_producer, source) =+ flat_source_certificate(source).ok_or_else(|| DocError::Invalid("shell has no flat certified source".into()))?;+ if !self.flat_certificate_producer_matches(source_producer, &source) {+ return Err(DocError::Invalid("shell original source producer missing".into()));+ }+ let certificate = FaceCertificate::ShellPlanar { source_producer, source: Box::new(source), inner: *inner };+ certificate.validate()?;+ return Ok(Some(certificate));+ }if let solvecraft_kernel::FaceSource::Imported { item, face, payload_sha256: Some(digest), producer: Some(producer) } = source {if !self.feature(*producer).is_some_and(|feature| matches!(feature.kind, FeatureKind::Import { .. })) {return Err(DocError::Invalid("import source producer missing".into()));@@ -378,6 +478,10 @@ pub(crate) fn payload_digest(payload: &str) -> String {format!("{:x}", Sha256::digest(payload.as_bytes()))}+#[cfg(test)]+#[path = "config_shell_tests.rs"]+mod shell_tests;+#[cfg(test)]mod tests {use super::*;diff --git a/crates/doc/src/config_shell_tests.rs b/crates/doc/src/config_shell_tests.rsnew file mode 100644index 0000000000..c640a06d9f--- /dev/null+++ b/crates/doc/src/config_shell_tests.rs@@ -0,0 +1,459 @@+use super::*;+use crate::{FeatureKind, Model, PlaneRef};+use serde_json::json;+use solvecraft_geom::{Vec2, Vec3};++fn shell_document() -> (Document, u64, u64) {+ let mut doc = Document::new("certified shell");+ doc.set_param("width", "20", Some("mm"), None).unwrap();+ doc.set_param("wall", "2", Some("mm"), None).unwrap();+ let base = doc+ .add_feature(+ serde_json::from_value(json!({"type":"box","corner":[0,0,0],"length":"width","width":"12","height":"10"})).unwrap(),+ Some("Case"),+ )+ .unwrap();+ doc.feature_mut(base).unwrap().body_names = vec!["Case".into()];+ let shell = doc+ .add_feature(+ FeatureKind::Shell {+ faces: vec![Vec3::new(5., 6., 10.)],+ thickness: "wall".into(),+ body: Some("Case".into()),+ direction: "inside".into(),+ tangent_chain: false,+ },+ Some("Shell"),+ )+ .unwrap();+ (doc, base, shell)+}++fn face_index(body: &ModelBody, inner: bool) -> usize {+ body.body+ .face_sources()+ .unwrap()+ .iter()+ .position(|source| {+ matches!(source, Some(solvecraft_kernel::FaceSource::ShellPlanar { inner: current, source, .. })+ if *current == inner && matches!(source.as_ref(), solvecraft_kernel::FaceSource::Box { axis:0,high:true,.. }))+ })+ .unwrap()+}++#[test]+fn shell_planar_raw_bounds_flat_identity_and_clone_remap() {+ let plane = solvecraft_geom::Plane::XY;+ let same = |planes: &[Option<solvecraft_geom::Plane>]| super::super::styles::shell_plane_family(planes.iter().copied());+ assert!(same(&[Some(plane), Some(plane)]));+ assert!(!same(&[]));+ assert!(!same(&[Some(plane), None]));+ for different in [+ solvecraft_geom::Plane { origin: Vec3::X, ..plane },+ solvecraft_geom::Plane { x: -plane.x, y: -plane.y, ..plane },+ solvecraft_geom::Plane { y: -plane.y, ..plane },+ ] {+ assert!(!same(&[Some(plane), Some(different)]));+ }+ let valid = json!({"kind":"shell_planar","source_producer":3,"source":{"kind":"extrude_side","sketch":2,"curve":"c4"},"inner":true});+ assert!(validate_certificate_json(&valid).is_ok());+ let mut certificate: FaceCertificate = serde_json::from_value(valid.clone()).unwrap();+ certificate.remap_features(&[(2, 20), (3, 30)].into_iter().collect());+ assert_eq!(serde_json::to_value(&certificate).unwrap()["source_producer"], 30);+ assert_eq!(serde_json::to_value(&certificate).unwrap()["source"]["sketch"], 20);+ for bad in [+ json!({"kind":"shell_planar","source_producer":0,"source":{"kind":"box","axis":0,"high":true},"inner":false}),+ json!({"kind":"shell_planar","source_producer":3,"source":null,"inner":false}),+ json!({"kind":"shell_planar","source_producer":3,"source":valid,"inner":false}),+ json!({"kind":"shell_planar","source_producer":3,"source":{"kind":"extrude_side","sketch":2,"curve":"x".repeat(1_000_000)},"inner":false}),+ json!({"kind":"shell_planar","source_producer":3,"source":{"kind":"box","axis":0,"high":true,"extra":[[[]]]},"inner":false}),+ ] {+ assert!(validate_certificate_json(&bad).is_err());+ }+}++#[test]+fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {+ let (mut doc, base, shell) = shell_document();+ let mut model = Model::new();+ model.evaluate(&doc);+ assert!(model.results.iter().all(|result| result.error.is_none()), "{:?}", model.results);+ let state = model.state();+ let body = state.body("Case").unwrap();+ let outer = doc.strong_face_target(body, face_index(body, false), Vec3::default()).unwrap();+ let outer_matches: Vec<_> = body.body.face_sources().unwrap().iter().enumerate().filter_map(|(index, source)| {+ matches!(source, Some(solvecraft_kernel::FaceSource::ShellPlanar { inner: false, source, .. }) if matches!(source.as_ref(), solvecraft_kernel::FaceSource::Box { axis: 0, high: true, .. })).then_some((index, body.body.face_plane(index)))+ }).collect();+ assert_eq!(outer_matches.len(), 1, "outer support must be one physical face: {outer_matches:?}");+ assert!(super::super::styles::shell_plane_family(outer_matches.iter().map(|(_, plane)| *plane)));+ let outer_plane = body.body.face_plane(face_index(body, false)).unwrap();+ let outer_anchor = doc.capture_face_anchor(body, face_index(body, false), &outer_plane, &[], 0, &[]).unwrap();+ let projected = crate::project::resolve_anchored_face(&doc, &state, &outer_plane, solvecraft_sketch::LinkKind::Project, &outer_anchor).unwrap();+ let mut linked = solvecraft_sketch::Sketch::new();+ let link = linked.add_link(solvecraft_sketch::LinkKind::Project, projected.source, &projected.geom).unwrap();+ assert!(!linked.update_link(&link, &projected.geom).unwrap());+ let inner_index = face_index(body, true);+ let inner = doc.strong_face_target(body, inner_index, Vec3::default()).unwrap();+ assert_ne!(outer.key(), inner.key());+ assert!(matches!(&inner.certificate, Some(FaceCertificate::ShellPlanar { source_producer,inner:true,.. }) if *source_producer==base));+ assert_eq!(inner.origin_feature, shell);+ let picked = body.body.face_plane(inner_index).unwrap();+ assert!((picked.origin.x - 18.).abs() < 1e-8);+ let anchor = doc.capture_face_anchor(body, inner_index, &picked, &[], 0, &[]).unwrap();+ let mut sketch = solvecraft_sketch::Sketch::new();+ let points: Vec<_> =+ [(2., 2.), (4., 2.), (4., 4.), (2., 4.)].into_iter().map(|(x, y)| sketch.add_point(Vec2::new(x, y), None).unwrap()).collect();+ for edge in 0..4 {+ sketch.add_line_pts(points[edge], points[(edge + 1) % 4], None).unwrap();+ }+ let sk = doc+ .add_feature(+ FeatureKind::Sketch {+ plane: PlaneRef::Face { plane: picked, at: picked.origin, name: None, anchor: Some(Box::new(anchor.clone())) },+ sketch,+ },+ Some("Inner face sketch"),+ )+ .unwrap();+ let boss = doc+ .add_feature(+ FeatureKind::Extrude {+ sketch: sk,+ profiles: crate::ProfileSel::All,+ extent: serde_json::from_value(json!({"distance":"2"})).unwrap(),+ operation: crate::Operation::NewBody,+ targets: vec![],+ },+ Some("Face boss"),+ )+ .unwrap();+ model.evaluate(&doc);+ let before = model.state().bodies.iter().find(|body| body.feature == boss).unwrap().mesh().bounds();+ doc.set_param("width", "30", Some("mm"), None).unwrap();+ doc.set_param("wall", "3", Some("mm"), None).unwrap();+ model.evaluate(&doc);+ let changed = model.state();+ let plane = doc.resolve_face_anchor(&anchor, 0, &changed).unwrap();+ assert!((plane.origin.x - 27.).abs() < 1e-8);+ let after = changed.bodies.iter().find(|body| body.feature == boss).unwrap().mesh().bounds();+ assert!((solvecraft_kernel::measure(&changed.bodies.iter().find(|body| body.feature == boss).unwrap().body).unwrap().volume - 8.).abs() < 1e-8);+ assert!((doc.resolve_face_anchor(&outer_anchor, 0, &changed).unwrap().origin.x - 30.).abs() < 1e-8);+ let changed_outer_plane = doc.resolve_face_anchor(&outer_anchor, 0, &changed).unwrap();+ let refreshed =+ crate::project::resolve_anchored_face(&doc, &changed, &changed_outer_plane, solvecraft_sketch::LinkKind::Project, &outer_anchor).unwrap();+ assert!(!linked.update_link(&link, &refreshed.geom).unwrap(), "same exterior boundary must retain projected IDs");+ assert!((after.min.x - before.min.x - 9.).abs() < 1e-8, "{before:?} -> {after:?}");+ assert!((after.max.x - before.max.x - 9.).abs() < 1e-8, "{before:?} -> {after:?}");+ assert!((after.min.y - before.min.y).abs() < 1e-8 && (after.min.z - before.min.z).abs() < 1e-8);+ let saved = doc.to_json();+ assert!(saved.contains("solvecraft/13"));+ let loaded = crate::format::read(&saved).unwrap();+ let mut cold = Model::new();+ cold.evaluate(&loaded);+ let cold_state = cold.state();+ let cold_bounds = cold_state.bodies.iter().find(|body| body.feature == boss).unwrap().mesh().bounds();+ assert!(after.min.dist(cold_bounds.min) < 1e-9 && after.max.dist(cold_bounds.max) < 1e-9);+ assert!(loaded.resolve_face_anchor(&anchor, 0, &cold_state).unwrap().origin.dist(plane.origin) < 1e-9);+ let mut wrong = anchor.clone();+ wrong.target.origin_feature = base;+ assert!(doc.resolve_face_anchor(&wrong, 0, &changed).is_err());+ let mut wrong_source = anchor.clone();+ if let Some(FaceCertificate::ShellPlanar { source_producer, .. }) = &mut wrong_source.target.certificate {+ *source_producer = shell;+ }+ assert!(doc.resolve_face_anchor(&wrong_source, 0, &changed).is_err());+ doc.feature_mut(shell).unwrap().suppressed = true;+ model.evaluate(&doc);+ let lost = model.state();+ assert!(doc.resolve_face_anchor(&anchor, 0, &lost).is_err());+ assert!(!lost.bodies.iter().any(|body| body.feature == boss), "lost attachment must prevent downstream geometry");+}++#[test]+fn shell_planar_format13_keeps_v12_documents_and_refuses_future() {+ let (doc, _, _) = shell_document();+ let mut legacy: serde_json::Value = serde_json::from_str(&doc.to_json()).unwrap();+ legacy["format"] = json!("solvecraft/12");+ let loaded = crate::format::read(&legacy.to_string()).unwrap();+ let mut current: serde_json::Value = serde_json::from_str(&loaded.to_json()).unwrap();+ assert_eq!(current["format"], "solvecraft/13");+ current["format"] = json!("solvecraft/12");+ assert_eq!(legacy, current, "identity migration must preserve every prior field");+ legacy["format"] = json!("solvecraft/14");+ assert!(crate::format::read(&legacy.to_string()).is_err());+}++#[test]+fn regularized_shell_keeps_legacy_and_explicit_single_face_projections_closed() {+ let (mut doc, _, _) = shell_document();+ let mut model = Model::new();+ for (width, wall) in [(20., 2.), (30., 3.)] {+ doc.set_param("width", &width.to_string(), Some("mm"), None).unwrap();+ doc.set_param("wall", &wall.to_string(), Some("mm"), None).unwrap();+ model.evaluate(&doc);+ let loaded = crate::format::read(&doc.to_json()).unwrap();+ let mut cold = Model::new();+ cold.evaluate(&loaded);+ for state in [model.state(), cold.state()] {+ let body = state.body("Case").unwrap();+ let index = face_index(body, false);+ let mesh = body.mesh();+ assert_eq!(body.body.face_sources().unwrap().iter().filter(|source|matches!(source,Some(solvecraft_kernel::FaceSource::ShellPlanar {inner:false,source,..}) if matches!(source.as_ref(),solvecraft_kernel::FaceSource::Box {axis:0,high:true,..}))).count(),1,"no physical outer-wall strip face may remain");+ let plane = body.body.face_plane(index).unwrap();+ let point = mesh+ .triangles+ .iter()+ .zip(&mesh.tri_face)+ .find_map(|(tri, face)| (*face as usize == index).then(|| mesh.tri(tri)).flatten())+ .map(|[a, b, c]| (a + b + c) / 3.)+ .unwrap();+ let source = solvecraft_sketch::LinkSource::Face { body: "Case".into(), at: point };+ let (values, _) = doc.param_values();+ let legacy = crate::project::resolve(&doc, &values, &state, &plane, solvecraft_sketch::LinkKind::Project, &source).unwrap();+ let explicit = crate::project::resolve_face_indices(&state, &plane, solvecraft_sketch::LinkKind::Project, "Case", &[index]).unwrap();+ assert_eq!(legacy.geom, explicit.geom);+ assert_eq!(explicit.geom.len(), 4, "raw planar piece keeps all four edges");+ let mut sketch = solvecraft_sketch::Sketch::new();+ let link = sketch.add_link(solvecraft_sketch::LinkKind::Project, source, &legacy.geom).unwrap();+ sketch.links[0].face_name = Some(crate::naming::face_names(body)[index].clone());+ let warnings = crate::project::refresh_links(&doc, &values, &state, &plane, &mut sketch);+ assert!(warnings.is_empty(), "{warnings:?}");+ assert!(!sketch.links[0].lost);+ assert!(!sketch.update_link(&link, &explicit.geom).unwrap());+ }+ }+}++#[test]+fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material() {+ let (mut doc, _, shell) = shell_document();+ let mut model = Model::new();+ model.evaluate(&doc);+ let state = model.state();+ let body = state.body("Case").unwrap();+ let index = face_index(body, false);+ let plane = body.body.face_plane(index).unwrap();+ let stem = crate::naming::face_names(body)[index].clone();+ assert_eq!(crate::naming::strip_piece(&stem), stem);+ // Reconstruct the original raw shell before certificate stamping/regularization,+ // and run the unchanged historical naming/capture path on its actual strip.+ let before = model.state_before(shell);+ // Legacy Shell did not propagate construction certificates. Omit transient+ // metadata here; operand paint also disables new wall-run coalescence so+ // this control retains the actual historical raw pieces.+ let raw_source = solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(20., 12., 10.)).unwrap().with_paint(Some(solvecraft_kernel::Paint {+ opacity: 1.,+ faces: vec![solvecraft_kernel::FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }],+ }));+ let raw = solvecraft_kernel::shell(&raw_source, &[Vec3::new(5., 6., 10.)], 2.).unwrap();+ let mut old_body = ModelBody::new("Case".into(), raw, shell);+ old_body.names = crate::naming::NameCell::new(Some(std::sync::Arc::new(crate::naming::NamingOrigin {+ feature: doc.feature(shell).unwrap().clone(),+ before,+ depth: 1,+ mats: vec![],+ })));+ let former = crate::naming::face_name_at_body(&old_body, Vec3::new(20., 6., 1.)).unwrap();+ assert_eq!(former, format!("{stem}#1"), "historical actual strip capture records full piece name");+ let mut sketch = solvecraft_sketch::Sketch::new();+ let corners = [Vec2::new(0., 0.), Vec2::new(12., 0.), Vec2::new(12., 2.), Vec2::new(0., 2.)];+ let geometry: Vec<_> = (0..4).map(|i| solvecraft_sketch::LinkGeom::Line(corners[i], corners[(i + 1) % 4])).collect();+ sketch+ .add_link(+ solvecraft_sketch::LinkKind::Project,+ solvecraft_sketch::LinkSource::Face { body: "Case".into(), at: Vec3::new(20., 6., 1.) },+ &geometry,+ )+ .unwrap();+ sketch.links[0].face_name = Some(former.clone());+ let original = sketch.clone();+ let sk = doc+ .add_feature(+ FeatureKind::Sketch { plane: PlaneRef::Face { plane, at: Vec3::new(20., 6., 1.), name: Some(former), anchor: None }, sketch },+ Some("Saved strip sketch"),+ )+ .unwrap();+ let boss = doc+ .add_feature(+ FeatureKind::Extrude {+ sketch: sk,+ profiles: crate::ProfileSel::All,+ extent: serde_json::from_value(json!({"distance":"1"})).unwrap(),+ operation: crate::Operation::NewBody,+ targets: vec![],+ },+ Some("Saved strip profile material"),+ )+ .unwrap();+ let mut legacy: serde_json::Value = serde_json::from_str(&doc.to_json()).unwrap();+ legacy["format"] = json!("solvecraft/12");+ let mut doc = crate::format::read(&legacy.to_string()).unwrap();+ for width in [20., 30.] {+ doc.set_param("width", &width.to_string(), Some("mm"), None).unwrap();+ doc.set_param("wall", "3", Some("mm"), None).unwrap();+ model.evaluate(&doc);+ let loaded = crate::format::read(&doc.to_json()).unwrap();+ let mut cold = Model::new();+ cold.evaluate(&loaded);+ for current in [&model, &cold] {+ let warning = current.results.iter().find(|r| r.id == sk).unwrap().warning.as_deref().unwrap();+ assert!(warning.contains("no longer exists; last geometry retained"), "{warning}");+ let state = current.state();+ let solved = state.sketch(sk).unwrap();+ assert!(solved.sketch.links[0].lost);+ assert_eq!(solved.sketch.curves, original.curves);+ assert_eq!(solved.sketch.points, original.points);+ let material = state.bodies.iter().find(|body| body.feature == boss).unwrap();+ assert!(+ (solvecraft_kernel::measure(&material.body).unwrap().volume - 24.).abs() < 1e-8,+ "old24mm3 profile must not silently become120mm3 wall profile"+ );+ let bounds = material.mesh().bounds();+ assert!((bounds.min.x - width).abs() < 1e-8 && (bounds.max.x - width - 1.).abs() < 1e-8);+ assert!((bounds.max.y - 12.).abs() < 1e-8 && (bounds.max.z - 2.).abs() < 1e-8);+ }+ }+}++#[test]+fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {+ use solvecraft_kernel::{FacePaint, Paint};+ use solvecraft_sketch::{LinkKind, LinkSource, Sketch};+ let mut doc = Document::new("saved curved strip");+ doc.set_param("width", "80", Some("mm"), None).unwrap();+ doc.set_param("wall", "2", Some("mm"), None).unwrap();+ let base = doc+ .add_feature(+ serde_json::from_value(json!({"type":"box","corner":["-width/2",-30,0],"length":"width","width":"60","height":"30"})).unwrap(),+ Some("Case"),+ )+ .unwrap();+ doc.feature_mut(base).unwrap().body_names = vec!["Case".into()];+ doc.add_feature(+ serde_json::from_value(json!({"type":"fillet","body":"Case","edges":[[40,30,15],[-40,30,15],[-40,-30,15],[40,-30,15]],"radius":"6"}))+ .unwrap(),+ Some("Corners"),+ )+ .unwrap();+ let shell = doc+ .add_feature(+ FeatureKind::Shell {+ faces: vec![Vec3::new(0., 0., 30.)],+ thickness: "wall".into(),+ body: Some("Case".into()),+ direction: "inside".into(),+ tangent_chain: false,+ },+ Some("Shell"),+ )+ .unwrap();+ let mut model = Model::new();+ model.evaluate(&doc);+ assert!(model.results.iter().all(|r| r.error.is_none()), "{:?}", model.results);+ let before = model.state_before(shell);+ // Per-face paint disables the construction optimization: this control keeps+ // the real pre-repair slab faces without forging a name or source witness.+ let old_source = before+ .body("Case")+ .unwrap()+ .body+ .clone()+ .with_paint(Some(Paint { opacity: 1., faces: vec![FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }] }));+ let cavity_box = solvecraft_kernel::box_solid(Vec3::new(-38., -28., 2.), Vec3::new(38., 28., 35.)).unwrap();+ let cavity = solvecraft_kernel::fillet(+ &cavity_box,+ &[Vec3::new(38., 28., 15.), Vec3::new(-38., 28., 15.), Vec3::new(-38., -28., 15.), Vec3::new(38., -28., 15.)],+ 4.,+ )+ .unwrap();+ let raw = solvecraft_kernel::boolean(&old_source, &cavity, solvecraft_kernel::BoolOp::Cut).unwrap().unwrap();+ let mut old_body = ModelBody::new("Case".into(), raw, shell);+ old_body.names = crate::naming::NameCell::new(Some(std::sync::Arc::new(crate::naming::NamingOrigin {+ feature: doc.feature(shell).unwrap().clone(),+ before,+ depth: 1,+ mats: vec![],+ })));+ let t = std::f64::consts::FRAC_1_SQRT_2;+ let at = Vec3::new(34. + 6. * t, 24. + 6. * t, 1.);+ let former = crate::naming::face_name_at_body(&old_body, at).unwrap();+ let stem = crate::naming::strip_piece(&former).to_string();+ assert_ne!(former, stem, "actual old cylindrical strip must have a piece suffix");+ let state = model.state();+ let current = state.body("Case").unwrap();+ let names = crate::naming::face_names(current);+ let index = names.iter().position(|name| name == &stem).unwrap();+ assert!(current.body.face_was_coalesced(index));+ assert!(current.body.face_plane(index).is_none(), "witness grants no planar attachment authority");+ assert!(old_body.body.face_sources().is_none_or(|sources| sources.iter().enumerate().all(|(index, _)| !old_body.body.face_was_coalesced(index))));+ let mut old_state = (*model.state()).clone();+ old_state.bodies = vec![old_body];+ let source = LinkSource::Face { body: "Case".into(), at };+ // Recover the saved projection from the old face's complete raw topology.+ // Display seam suppression must not discard a historical strip boundary.+ let old_body = old_state.body("Case").unwrap();+ let old_index = crate::naming::face_on_body(old_body, &former, at).unwrap().0;+ let mesh = old_body.mesh();+ let mut geometry = Vec::new();+ for (index, faces) in mesh.edge_faces.iter().enumerate() {+ if !faces.contains(&(old_index as u32)) {+ continue;+ }+ let points = &mesh.edges[index];+ let a = solvecraft_geom::Plane::YZ.to_local(*points.first().unwrap());+ let b = solvecraft_geom::Plane::YZ.to_local(*points.last().unwrap());+ let (a, b) = (Vec2::new(a.x, a.y), Vec2::new(b.x, b.y));+ assert!(a.dist(b) > 1e-6);+ for point in points {+ let q = solvecraft_geom::Plane::YZ.to_local(*point);+ let q = Vec2::new(q.x, q.y);+ let direction = b - a;+ let t = ((q - a).dot(direction) / direction.dot(direction)).clamp(0., 1.);+ assert!(q.dist(a + direction * t) < 1e-7, "exact cylindrical quadrant projects to a straight support");+ }+ geometry.push(solvecraft_sketch::LinkGeom::Line(a, b));+ }+ assert_eq!(geometry.len(), 4, "historical curved strip has a complete four-edge rectangular projection");+ let mut sketch = Sketch::new();+ sketch.add_link(LinkKind::Project, source, &geometry).unwrap();+ sketch.links[0].face_name = Some(former);+ let original = sketch.clone();+ let sk = doc+ .add_feature(FeatureKind::Sketch { plane: PlaneRef::Custom { plane: solvecraft_geom::Plane::YZ }, sketch }, Some("Saved corner strip"))+ .unwrap();+ let boss = doc+ .add_feature(+ FeatureKind::Extrude {+ sketch: sk,+ profiles: crate::ProfileSel::All,+ extent: serde_json::from_value(json!({"distance":"1"})).unwrap(),+ operation: crate::Operation::NewBody,+ targets: vec![],+ },+ Some("Retained strip material"),+ )+ .unwrap();+ for (width, wall) in [(80., 2.), (100., 3.)] {+ doc.set_param("width", &width.to_string(), Some("mm"), None).unwrap();+ doc.set_param("wall", &wall.to_string(), Some("mm"), None).unwrap();+ model.evaluate(&doc);+ let loaded = crate::format::read(&doc.to_json()).unwrap();+ let mut cold = Model::new();+ cold.evaluate(&loaded);+ for current in [&model, &cold] {+ let result = current.results.iter().find(|r| r.id == sk).unwrap();+ assert!(result.error.is_none());+ assert!(result.warning.as_deref().unwrap().contains("no longer exists; last geometry retained"));+ let state = current.state();+ let solved = state.sketch(sk).unwrap();+ assert!(solved.sketch.links[0].lost);+ assert_eq!(solved.sketch.points, original.points);+ assert_eq!(solved.sketch.curves, original.curves);+ let material = state.bodies.iter().find(|body| body.feature == boss).unwrap();+ assert!(+ (solvecraft_kernel::measure(&material.body).unwrap().volume - 12.).abs() < 1e-7,+ "two-mm strip cannot expand to a full thirty-mm wall"+ );+ }+ }+}diff --git a/crates/doc/src/config_styles.rs b/crates/doc/src/config_styles.rsindex 18d053f881..0bdf010dc7 100644--- a/crates/doc/src/config_styles.rs+++ b/crates/doc/src/config_styles.rs@@ -5,6 +5,12 @@ use serde::{Deserialize, Serialize};use serde_json::Value;use solvecraft_geom::Vec3;+pub(crate) fn shell_plane_family(planes: impl IntoIterator<Item = Option<solvecraft_geom::Plane>>) -> bool {+ let mut planes = planes.into_iter();+ let Some(Some(first)) = planes.next() else { return false };+ first.origin.is_finite() && first.x.is_finite() && first.y.is_finite() && planes.all(|plane| plane == Some(first))+}+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]#[serde(deny_unknown_fields)]pub struct ConfigFaceTarget {@@ -98,6 +104,20 @@ pub fn validate_styles_json(value: &Value) -> Result<()> {}impl Document {+ pub(crate) fn flat_certificate_producer_matches(&self, producer: u64, certificate: &super::FaceCertificate) -> bool {+ use super::FaceCertificate;+ let Some(feature) = self.feature(producer) else { return false };+ match (certificate, &feature.kind) {+ (FaceCertificate::Box { .. }, FeatureKind::Box { operation: crate::Operation::NewBody, .. }) => true,+ (FaceCertificate::ExtrudeCap { sketch, .. }, FeatureKind::Extrude { sketch: current, extent, operation: crate::Operation::NewBody, .. }) => sketch == current && extent.taper.is_none(),+ (FaceCertificate::ExtrudeSide { sketch, curve }, FeatureKind::Extrude { sketch: current, extent, operation: crate::Operation::NewBody, .. }) => {+ sketch == current && extent.taper.is_none()+ && self.feature(*sketch).is_some_and(|feature| matches!(&feature.kind, FeatureKind::Sketch { sketch, .. } if sketch.curves.iter().any(|candidate| candidate.id == *curve && !candidate.construction && matches!(candidate.kind, solvecraft_sketch::CurveKind::Line { .. } | solvecraft_sketch::CurveKind::Circle { .. } | solvecraft_sketch::CurveKind::Arc { .. }))))+ }+ (FaceCertificate::Imported { .. }, FeatureKind::Import { .. }) => true,+ _ => false,+ }+ }/// Certify named generator lineage; generic index-derived naming is unsupported.pub fn certify_config_face(&self, target: &ConfigFaceTarget) -> Result<()> {target.validate()?;@@ -121,6 +141,11 @@ impl Document {&& self.feature(*sketch).is_some_and(|feature| matches!(&feature.kind, FeatureKind::Sketch { sketch, .. } if sketch.curves.iter().any(|candidate| candidate.id == *curve && !candidate.construction && matches!(candidate.kind, solvecraft_sketch::CurveKind::Line { .. } | solvecraft_sketch::CurveKind::Circle { .. } | solvecraft_sketch::CurveKind::Arc { .. }))))}(super::FaceCertificate::Imported { .. }, FeatureKind::Import { .. }) => role.strip_prefix("face:").is_some_and(|index| index.parse::<usize>().is_ok()),+ (super::FaceCertificate::ShellPlanar { source_producer, source, inner }, FeatureKind::Shell { .. }) => {+ *source_producer != target.origin_feature+ && self.flat_certificate_producer_matches(*source_producer, source)+ && super::shell_certificate_role(source, *inner).is_ok_and(|expected| role == expected)+ }_ => false,};return if valid { Ok(()) } else { Err(DocError::Invalid("face certificate no longer matches its producer".into())) };@@ -156,6 +181,17 @@ impl Document {if body.body.is_mesh() || body.definition_name() != target.body {return Err(DocError::Invalid("configured face definition does not match".into()));}+ if let Some(super::FaceCertificate::ShellPlanar { source_producer, source, inner }) = &target.certificate {+ let indices: Vec<_> = body.body.face_sources().into_iter().flatten().enumerate().filter_map(|(index, current)| {+ matches!(current, Some(solvecraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), source: current_source, inner: current_inner, .. }) if *producer == target.origin_feature && inner == current_inner && super::flat_source_matches(source, current_source, *source_producer)).then_some(index)+ }).collect();+ // A shell can split one original support into several pieces. All pieces+ // must retain the same canonical frame, not merely lie on a common plane.+ if !shell_plane_family(indices.iter().map(|index| body.body.face_plane(*index))) {+ return Err(DocError::Unknown("shell planar face certificate is missing or ambiguous".into()));+ }+ return Ok(indices);+ }if matches!(target.certificate, Some(super::FaceCertificate::Box { .. } | super::FaceCertificate::ExtrudeCap { .. })) {let indices: Vec<_> = body.bodydiff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 34fad23baf..75cd9cf20e 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -2910,6 +2910,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:}o => return Err(DocError::Invalid(format!("unknown shell direction `{o}` (inside, outside or both)"))),};+ let nb = nb.with_shell_certificate(f.id)?;if let Some(slot) = st.bodies.get_mut(i) {*slot = ModelBody::new(mb.name, nb, mb.feature);}@@ -3159,6 +3160,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:FeatureKind::Chamfer { distance2, angle, flip, .. } => chamfer_with(vals, &mb.body, &edges, r, distance2, angle, *flip)?,_ => return Err(DocError::Invalid("blend".into())),};+ let nb = nb.with_preserved_planar_sources(&mb.body)?;let (name, feat) = (mb.name.clone(), mb.feature);if let Some(slot) = st.bodies.get_mut(ti) {*slot = ModelBody::new(name, nb, feat);diff --git a/crates/doc/src/format.rs b/crates/doc/src/format.rsindex c7e487da98..38845b49b8 100644--- a/crates/doc/src/format.rs+++ b/crates/doc/src/format.rs@@ -36,13 +36,16 @@//! - 12: persistent analytic offset boundary roles and association profile references.//! Older analytic chains retain their source/output correspondence and saved geometry;//! migration never invents retired entities or renumbers existing curves.+//! - 13: exact planar shell face anchors retain the shell producer, original certified+//! source and distinct inner/outer role. Version 12 anchors retain their identities;+//! migration never guesses attachments for older designs.use serde_json::Value;use crate::{DocError, Document, Result};/// The format this build writes.-pub const FORMAT: u32 = 12;+pub const FORMAT: u32 = 13;pub fn format_string(n: u32) -> String {format!("solvecraft/{n}")@@ -55,8 +58,8 @@ pub fn version_of(s: &str) -> Option<u32> {/// JSON-level upgrades: entry `i` turns format `i + 1` into `i + 2`.type JsonStep = fn(&mut Value) -> Result<()>;-const JSON_STEPS: [JsonStep; 11] =- [|_| Ok(()), v2_to_v3, v3_to_v4, v4_to_v5, v5_to_v6, |_| Ok(()), |_| Ok(()), |_| Ok(()), |_| Ok(()), |_| Ok(()), |_| Ok(())];+const JSON_STEPS: [JsonStep; 12] =+ [|_| Ok(()), v2_to_v3, v3_to_v4, v4_to_v5, v5_to_v6, |_| Ok(()), |_| Ok(()), |_| Ok(()), |_| Ok(()), |_| Ok(()), |_| Ok(()), |_| Ok(())];/// Old XZ references retain their exact frame, including nested offset and angled planes./// New origin references use +Y; freezing the old frame avoids changing sketch coordinates,diff --git a/crates/doc/src/project.rs b/crates/doc/src/project.rsindex 9d994b743b..ea5176b5a6 100644--- a/crates/doc/src/project.rs+++ b/crates/doc/src/project.rs@@ -141,15 +141,13 @@ fn resolve_uncached(LinkKind::Intersect => section(plane, &mesh, Some(f)),_ => {let mut g = Vec::new();- for e in order::face_edges(&mesh, f, plane)? {- if mesh.seams.get(e).copied().unwrap_or(false) {- continue;- }+ let target = st.bodies.get(bi).ok_or_else(|| lost("the projection body"))?;+ for e in projection_face_edges(target, &mesh, f, plane)? {if let Some(pts) = mesh.edges.get(e) {g.extend(fit_world(plane, pts));}}- g+ if certified_planar_construction(target, f as usize) { merge_family_lines(g)? } else { g }}}}@@ -293,15 +291,13 @@ fn resolve_named_face(st: &ModelState, plane: &Plane, kind: LinkKind, body: &strsection(plane, &mesh, Some(index))} else {let mut geom = Vec::new();- for edge in order::face_edges(&mesh, index, plane)? {- if mesh.seams.get(edge).copied().unwrap_or(false) {- continue;- }+ for edge in projection_face_edges(target, &mesh, index, plane)? {if let Some(points) = mesh.edges.get(edge) {geom.extend(fit_world(plane, points));}}- merge_split_circles(geom)+ let geom = merge_split_circles(geom);+ if certified_planar_construction(target, index as usize) { merge_family_lines(geom)? } else { geom }};if geom.is_empty() {return Err(DocError::Invalid("named face projects to nothing on this sketch plane".into()));@@ -309,6 +305,29 @@ fn resolve_named_face(st: &ModelState, plane: &Plane, kind: LinkKind, body: &strOk(Resolved { geom, wires: Vec::new(), source: LinkSource::Face { body: body.into(), at }, moved: false, face_index })}+fn projection_face_edges(body: &crate::ModelBody, mesh: &Mesh, index: u32, plane: &Plane) -> Result<Vec<usize>> {+ let shell_plane = body+ .body+ .face_sources()+ .and_then(|sources| sources.get(index as usize))+ .is_some_and(|source| matches!(source, Some(solvecraft_kernel::FaceSource::ShellPlanar { .. })));+ if shell_plane { order::raw_face_edges(mesh, index, plane) } else { order::face_edges(mesh, index, plane) }+}++fn certified_planar_construction(body: &crate::ModelBody, index: usize) -> bool {+ body.body.face_sources().and_then(|sources| sources.get(index)).is_some_and(|source| {+ matches!(+ source,+ Some(+ solvecraft_kernel::FaceSource::ShellPlanar { producer: Some(_), .. }+ | solvecraft_kernel::FaceSource::Box { producer: Some(_), .. }+ | solvecraft_kernel::FaceSource::CertifiedExtrudeSide { plane: Some(_), .. }+ | solvecraft_kernel::FaceSource::CertifiedExtrudeCap { .. }+ )+ )+ })+}+pub fn resolve_anchored_face(doc: &Document, st: &ModelState, plane: &Plane, kind: LinkKind, anchor: &crate::FaceAnchor) -> Result<Resolved> {let body = st.body(&anchor.target.body).ok_or_else(|| lost("anchored projection body"))?;let indices = doc.configuration_face_indices(body, &anchor.target)?;@@ -329,21 +348,31 @@ pub fn resolve_face_indices(st: &ModelState, plane: &Plane, kind: LinkKind, body}let selected: std::collections::BTreeSet<_> = indices.iter().copied().collect();let mut geometry = Vec::new();- for index in indices {- let index = u32::try_from(*index).map_err(|_| DocError::Invalid("anchored face index exceeds format bounds".into()))?;- if kind == LinkKind::Intersect {+ if kind == LinkKind::Intersect {+ for index in indices {+ let index = u32::try_from(*index).map_err(|_| DocError::Invalid("anchored face index exceeds format bounds".into()))?;geometry.extend(section(plane, &mesh, Some(index)));+ }+ } else {+ let edges = if let [index] = indices {+ projection_face_edges(+ body,+ &mesh,+ u32::try_from(*index).map_err(|_| DocError::Invalid("face index exceeds format bounds".into()))?,+ plane,+ )?} else {- for edge in order::face_edges(&mesh, index, plane)? {- if mesh.seams.get(edge).copied().unwrap_or(false) {- continue;- }- if let Some(points) = mesh.edges.get(edge) {- geometry.extend(fit_world(plane, points));- }+ order::family_edges(&mesh, &selected, plane)?+ };+ for edge in edges {+ if let Some(points) = mesh.edges.get(edge) {+ geometry.extend(fit_world(plane, points));}}}+ if kind != LinkKind::Intersect && (indices.len() > 1 || indices.first().is_some_and(|index| certified_planar_construction(body, *index))) {+ geometry = merge_family_lines(geometry)?;+ }let point = mesh.triangles.iter()@@ -373,6 +402,75 @@ pub fn refresh_face_anchor_links(refresh_links_in(doc, vals, st, plane, sk, Some(anchor))}+/// Remove degree-two straight stations introduced by coplanar face subdivision.+/// The walk uses endpoint incidence; geometric sorting does not imply adjacency.+fn merge_family_lines(geom: Vec<LinkGeom>) -> Result<Vec<LinkGeom>> {+ if geom.len().saturating_mul(geom.len()).saturating_mul(3) > 10_000_000 {+ return Err(DocError::Invalid("face family straight-boundary work limit exceeded".into()));+ }+ let ends = |curve: &LinkGeom| match curve {+ LinkGeom::Line(a, b) | LinkGeom::Arc { a, b, .. } | LinkGeom::Conic { a, b, .. } => Some((*a, *b)),+ LinkGeom::Spline { pts, periodic: false, .. } => pts.first().zip(pts.last()).map(|(a, b)| (*a, *b)),+ _ => None,+ };+ let scale = geom.iter().filter_map(&ends).flat_map(|(a, b)| [a.len(), b.len()]).fold(1., f64::max);+ let tol = scale * f64::EPSILON * 512.;+ let mut used = vec![false; geom.len()];+ let mut result = Vec::new();+ for (index, curve) in geom.iter().enumerate() {+ if used.get(index).copied().unwrap_or(true) {+ continue;+ }+ if let Some(slot) = used.get_mut(index) {+ *slot = true;+ }+ let LinkGeom::Line(a, b) = curve else {+ result.push(curve.clone());+ continue;+ };+ let mut endpoints = [*a, *b];+ for side in 0..2 {+ let mut current = index;+ for _ in 0..geom.len() {+ let Some(point) = endpoints.get(side).copied() else { break };+ let mut incidence = geom+ .iter()+ .enumerate()+ .filter_map(|(other, curve)| ends(curve).filter(|(a, b)| a.dist(point) <= tol || b.dist(point) <= tol).map(|_| other));+ let (Some(one), Some(two), None) = (incidence.next(), incidence.next(), incidence.next()) else { break };+ let other = if one == current {+ two+ } else if two == current {+ one+ } else {+ break;+ };+ if used.get(other).copied().unwrap_or(true) {+ break;+ }+ let Some(LinkGeom::Line(a, b)) = geom.get(other) else { break };+ let next = if a.dist(point) <= tol { *b } else { *a };+ let Some(opposite) = endpoints.get(1 - side).copied() else { break };+ let (Some(incoming), Some(outgoing)) = ((point - opposite).normalized(), (next - point).normalized()) else { break };+ if incoming.dot(outgoing) <= 0. || incoming.cross(outgoing).abs() > f64::EPSILON * 512. {+ break;+ }+ if let Some(slot) = used.get_mut(other) {+ *slot = true;+ }+ if let Some(slot) = endpoints.get_mut(side) {+ *slot = next;+ }+ current = other;+ }+ }+ if let (Some(a), Some(b)) = (endpoints.first(), endpoints.get(1)) {+ result.push(LinkGeom::Line(*a, *b));+ }+ }+ Ok(result)+}+pub fn refresh_links(doc: &Document, vals: &BTreeMap<String, Value>, st: &ModelState, plane: &Plane, sk: &mut Sketch) -> Vec<String> {refresh_links_in(doc, vals, st, plane, sk, None)}@@ -394,6 +492,18 @@ fn refresh_links_in(&& let (Some(name), LinkSource::Face { body, at }) = (&l.face_name, &mut source){if let Some((index, p, split)) = st.body(body).and_then(|target| crate::naming::face_on_body(target, name, *at)) {+ let stem = crate::naming::strip_piece(name);+ let removed_piece = split+ && name != stem+ && st.body(body).is_some_and(|target| {+ (certified_planar_construction(target, index) || target.body.face_was_coalesced(index))+ && crate::naming::face_names(target).get(index).is_some_and(|current| current == stem)+ });+ if removed_piece {+ sk.set_link_lost(&l.id, true);+ warn.push(format!("projected face piece `{name}` no longer exists; last geometry retained"));+ continue;+ }*at = p;named_face = Some((body.clone(), index, p));if split {diff --git a/crates/doc/src/project_order.rs b/crates/doc/src/project_order.rsindex 70fe483420..173ed93fff 100644--- a/crates/doc/src/project_order.rs+++ b/crates/doc/src/project_order.rs@@ -10,6 +10,36 @@ use crate::{DocError, Result};type Key = (i64, i64, i64);pub(super) fn face_edges(mesh: &Mesh, face: u32, plane: &Plane) -> Result<Vec<usize>> {+ let edges = mesh.face_edges(face).into_iter().filter(|e| !mesh.seams.get(*e).copied().unwrap_or(false)).collect();+ boundary_edges(mesh, edges, plane)+}++/// Full boundary of an explicitly selected analytic planar piece. Display seams+/// hide subdivisions for picking, but cannot remove a raw piece's closing edge.+pub(super) fn raw_face_edges(mesh: &Mesh, face: u32, plane: &Plane) -> Result<Vec<usize>> {+ boundary_edges(mesh, mesh.face_edges(face), plane)+}++/// Exterior of an exact current face family. Shared topological edges are internal;+/// geometric proximity never merges distinct edges or chooses a different face.+pub(super) fn family_edges(mesh: &Mesh, selected: &std::collections::BTreeSet<usize>, plane: &Plane) -> Result<Vec<usize>> {+ let mut edges = Vec::new();+ for (index, faces) in mesh.edge_faces.iter().enumerate() {+ let count = faces.iter().filter(|face| selected.contains(&(**face as usize))).count();+ if count == 0 {+ continue;+ }+ if faces.len() > 2 || (faces.len() == 2 && faces.first() == faces.get(1)) {+ return Err(DocError::Invalid("face family has ambiguous edge adjacency".into()));+ }+ if count == 1 && !mesh.seams.get(index).copied().unwrap_or(false) {+ edges.push(index);+ }+ }+ boundary_edges(mesh, edges, plane)+}++fn boundary_edges(mesh: &Mesh, mut edges: Vec<usize>, plane: &Plane) -> Result<Vec<usize>> {let bounds = mesh.bounds();let origin = bounds.min;let local_origin = plane.to_local(origin);@@ -21,7 +51,6 @@ pub(super) fn face_edges(mesh: &Mesh, face: u32, plane: &Plane) -> Result<Vec<uslet p = p - origin;((p.x / tol).round() as i64, (p.y / tol).round() as i64, (p.z / tol).round() as i64)};- let mut edges: Vec<usize> = mesh.face_edges(face).into_iter().filter(|e| !mesh.seams.get(*e).copied().unwrap_or(false)).collect();if edges.iter().any(|e| !mesh.edges.get(*e).is_some_and(|p| p.len() >= 2 && p.iter().all(|p| p.is_finite()))) {return Err(DocError::Invalid("face projection has an invalid boundary edge".into()));}@@ -119,6 +148,79 @@ pub(super) fn face_edges(mesh: &Mesh, face: u32, plane: &Plane) -> Result<Vec<usmod tests {use super::*;+ #[test]+ fn face_family_omits_only_exact_shared_topological_edges() {+ let mut mesh = Mesh::default();+ for (a, b, faces) in [+ ((0., 0.), (2., 0.), vec![0]),+ ((2., 0.), (2., 1.), vec![0]),+ ((2., 1.), (0., 1.), vec![0, 1]),+ ((0., 1.), (0., 0.), vec![0]),+ ((2., 1.), (2., 2.), vec![1]),+ ((2., 2.), (0., 2.), vec![1]),+ ((0., 2.), (0., 1.), vec![1]),+ ] {+ mesh.edges.push(vec![Vec3::new(a.0, a.1, 0.), Vec3::new(b.0, b.1, 0.)]);+ mesh.positions.extend([Vec3::new(a.0, a.1, 0.), Vec3::new(b.0, b.1, 0.)]);+ mesh.edge_faces.push(faces);+ }+ let selected = [0, 1].into_iter().collect();+ let edges = family_edges(&mesh, &selected, &Plane::XY).unwrap();+ assert_eq!(edges.len(), 6);+ assert!(!edges.contains(&2));+ let geometry: Vec<_> = edges.iter().flat_map(|edge| super::super::fit_world(&Plane::XY, &mesh.edges[*edge])).collect();+ assert_eq!(super::super::merge_family_lines(geometry).unwrap().len(), 4);+ assert_eq!(family_edges(&mesh, &[0].into_iter().collect(), &Plane::XY).unwrap().len(), 4);+ mesh.edge_faces[2] = vec![0, 1, 2];+ assert!(family_edges(&mesh, &selected, &Plane::XY).is_err());+ mesh.edge_faces[2] = vec![0, 0];+ assert!(family_edges(&mesh, &selected, &Plane::XY).is_err());+ }++ #[test]+ fn distinct_crossing_boundaries_are_not_geometrically_cancelled() {+ let mut mesh = Mesh::default();+ for (face, x, y) in [(0, 0., 0.), (1, 1., 1.)] {+ let corners = [Vec3::new(x, y, 0.), Vec3::new(x + 2., y, 0.), Vec3::new(x + 2., y + 2., 0.), Vec3::new(x, y + 2., 0.)];+ mesh.positions.extend(corners);+ for i in 0..4 {+ mesh.edges.push(vec![corners[i], corners[(i + 1) % 4]]);+ mesh.edge_faces.push(vec![face]);+ }+ }+ let edges = family_edges(&mesh, &[0, 1].into_iter().collect(), &Plane::XY).unwrap();+ assert_eq!(edges.len(), 8);+ let geom: Vec<_> = edges.iter().flat_map(|edge| super::super::fit_world(&Plane::XY, &mesh.edges[*edge])).collect();+ let mut sk = solvecraft_sketch::Sketch::new();+ let link = sk+ .add_link(solvecraft_sketch::LinkKind::Project, solvecraft_sketch::LinkSource::Face { body: "ambiguous".into(), at: Vec3::ZERO }, &geom)+ .unwrap();+ assert!(sk.update_link(&link, &geom).is_err());+ }++ #[test]+ fn family_line_normalization_preserves_corners_arcs_branches_and_retracing() {+ use solvecraft_geom::Vec2;+ use solvecraft_sketch::LinkGeom;+ let line = |a, b| LinkGeom::Line(Vec2::new(a, 0.), Vec2::new(b, 0.));+ assert_eq!(super::super::merge_family_lines(vec![line(0., 1.), line(2., 1.)]).unwrap(), vec![line(0., 2.)]);+ for geometry in [+ vec![line(0., 1.), line(1., 0.5)],+ vec![line(0., 1.), LinkGeom::Line(Vec2::new(1., 0.), Vec2::new(2., 1e-8))],+ vec![line(0., 1.), line(1., 2.), LinkGeom::Line(Vec2::new(1., 0.), Vec2::new(1., 1.))],+ vec![line(0., 1.), line(1., 2.), LinkGeom::Conic { a: Vec2::new(1., 0.), apex: Vec2::new(2., 1.), b: Vec2::new(3., 1.), rho: 0.5 }],+ vec![+ line(0., 1.),+ line(1., 2.),+ LinkGeom::Spline { pts: vec![Vec2::new(1., 0.), Vec2::new(2., 1.), Vec2::new(3., 1.)], control: false, degree: 2, periodic: false },+ ],+ vec![line(0., 1.), LinkGeom::Arc { c: Vec2::new(1., 1.), a: Vec2::new(1., 0.), b: Vec2::new(2., 1.) }],+ vec![line(0., 1.), line(1.00001, 2.)],+ ] {+ assert_eq!(super::super::merge_family_lines(geometry.clone()).unwrap(), geometry);+ }+ }+fn rectangles() -> Mesh {let mut mesh = Mesh::default();for (x, y) in [(40.0, 30.0), (38.0, 28.0), (4.0, 2.0)] {diff --git a/crates/engine/src/cmd/face_tests.rs b/crates/engine/src/cmd/face_tests.rsindex 031e7011ca..f165125506 100644--- a/crates/engine/src/cmd/face_tests.rs+++ b/crates/engine/src/cmd/face_tests.rs@@ -10,7 +10,7 @@ fn run(s: &mut Session, command: &str, params: Value) -> Value {}fn check(s: &mut Session, want: f64, hole: bool, height: f64) {s.refresh();- assert!(s.model.results.iter().all(|result| result.error.is_none()));+ assert!(s.model.results.iter().all(|result| result.error.is_none() && result.warning.is_none()), "{:?}", s.model.results);let state = s.model.state();let got: f64 = state.bodies.iter().map(|b| solvecraft_kernel::measure(&b.body).unwrap().volume).sum();// Legacy linked outlines fit tessellated curves; enforce the existing 1e-4 material envelope.@@ -22,10 +22,10 @@ fn check(s: &mut Session, want: f64, hole: bool, height: f64) {}}#[test]-fn generated_face_profiles_keep_certified_and_internal_legacy_links_live_after_edit_and_reopen() {+fn generated_face_profiles_keep_exact_links_live_after_edit_and_reopen() {for hole in [false, true] {let mut s = Session::default();- run(&mut s, "solid.box", json!({"length":40,"width":30,"height":20,"name":"Base"}));+ let base = run(&mut s, "solid.box", json!({"length":40,"width":30,"height":20,"name":"Base"}))["feature"].as_u64().unwrap();if hole {run(&mut s, "sketch.create", json!({"plane":"XY"}));run(&mut s, "sketch.circle.center", json!({"center":[20,15],"radius":5}));@@ -37,9 +37,11 @@ fn generated_face_profiles_keep_certified_and_internal_legacy_links_live_after_elet FeatureKind::Extrude { sketch, .. } = pad.kind else { panic!("extrude") };let generated = s.doc.feature(sketch).unwrap();let FeatureKind::Sketch { plane, sketch: profile } = &generated.kind else { panic!("sketch") };- assert!(matches!(plane,PlaneRef::Face{anchor,..} if anchor.is_some()!=hole));+ let PlaneRef::Face { anchor: Some(anchor), .. } = plane else { panic!("the original Box cap remains exact after a hole cut") };+ assert_eq!(anchor.target.origin_feature, base);+ assert!(matches!(anchor.target.certificate, Some(solvecraft_doc::config::FaceCertificate::Box { axis: 2, high: true })));assert!(!profile.links.is_empty());- assert!(profile.links.iter().all(|link| link.auto_face != hole && !link.lost));+ assert!(profile.links.iter().all(|link| link.auto_face && !link.lost));let area = 1200.0 - if hole { 25.0 * PI } else { 0.0 };check(&mut s, area * 30.0, hole, 30.0);run(&mut s, "timeline.edit", json!({"feature":"Base","set":{"height":"25","length":"50"}}));@@ -48,7 +50,7 @@ fn generated_face_profiles_keep_certified_and_internal_legacy_links_live_after_elet edited = s.model.state();assert!(edited.bodies.iter().any(|body| body.body.contains(Vec3::new(49.0, 5.0, 34.0))));assert!(!edited.bodies.iter().any(|body| body.body.contains(Vec3::new(51.0, 5.0, 34.0))));- assert!(edited.sketch(sketch).unwrap().sketch.links.iter().all(|link| !link.lost));+ assert!(edited.sketch(sketch).unwrap().sketch.links.iter().all(|link| link.auto_face && !link.lost));let solved = edited.sketch(sketch).unwrap().plane;assert!((solved.origin.z - 25.0).abs() < 1e-6);let before = s.model.state();diff --git a/crates/engine/src/cmd/sketch_face_tests.rs b/crates/engine/src/cmd/sketch_face_tests.rsindex 32ed9218b5..e2798552ba 100644--- a/crates/engine/src/cmd/sketch_face_tests.rs+++ b/crates/engine/src/cmd/sketch_face_tests.rs@@ -399,3 +399,184 @@ fn angled_attachment_tracks_source_plane_and_reopens() {let reopened = Session::new(solvecraft_doc::Document::from_json(&s.doc.to_json()).unwrap());assert_eq!(reopened.model.state().sketch(id).unwrap().plane, placed);}++#[test]+fn rounded_enclosure_shell_side_and_floor_attach_through_width_wall_and_reopen() {+ use solvecraft_doc::{FeatureKind, config::FaceCertificate, face_anchor::plane_face_anchor};+ let mut s = Session::default();+ for (name, expression) in [("width", "80 mm"), ("depth", "60 mm"), ("height", "30 mm"), ("wall", "2 mm")] {+ run(&mut s, "parameters.add", json!({"name":name,"expression":expression}));+ }+ let base = run(&mut s, "sketch.create", json!({"plane":"XY","name":"Outline"}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.rectangle.center", json!({"center":[0,0],"corner":[40,30]}));+ run(&mut s, "sketch.dimension", json!({"entities":["l1"],"value":"width"}));+ run(&mut s, "sketch.dimension", json!({"entities":["l2"],"value":"depth"}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch":base,"distance":"height","operation":"new","body_name":"Case"}));+ run(&mut s, "solid.fillet", json!({"body":"Case","edges":[[40,30,15],[-40,30,15],[-40,-30,15],[40,-30,15]],"radius":6}));+ run(&mut s, "solid.shell", json!({"body":"Case","faces":[[0,0,30]],"thickness":"wall","name":"Hollow"}));+ assert_eq!(s.model.state().body("Case").unwrap().body.face_count(), 19, "rounded Shell has no separate base strips");+ let pick = |s: &Session, normal: Vec3, point: Vec3| {+ let state = s.model.state();+ let body = state.body("Case").unwrap();+ let face = body+ .body+ .faces(0.01)+ .unwrap()+ .into_iter()+ .find(|f| f.plane_normal.is_some_and(|n| n.dot(normal) > 0.999) && (f.centroid - point).dot(normal).abs() < 1e-6)+ .unwrap();+ json!({"body":"Case","index":face.index,"face":[point.x,point.y,point.z]})+ };+ let side_pick = pick(&s, Vec3::X, Vec3::new(40., 10., 20.));+ let side = run(&mut s, "sketch.create", json!({"name":"USB","plane":side_pick,"project_edges":true}))["sketch"].as_u64().unwrap();+ let port_plane = s.model.state().sketch(side).unwrap().plane;+ let p0 = port_plane.to_local(Vec3::new(40., -6., 8.5));+ let p1 = port_plane.to_local(Vec3::new(40., 6., 15.5));+ let port_curves = run(&mut s, "sketch.rectangle.two_point", json!({"p0":[p0.x,p0.y],"p1":[p1.x,p1.y]}))["curves"].clone();+ run(&mut s, "sketch.finish", json!({}));+ run(+ &mut s,+ "solid.extrude",+ json!({"sketch":side,"profiles":[{"curves":port_curves}],"distance":"wall","direction":"negative","operation":"cut","targets":["Case"],"name":"USBcut"}),+ );+ let floor_pick = pick(&s, Vec3::Z, Vec3::new(6., -9., 2.));+ let floor = run(&mut s, "sketch.create", json!({"name":"Bosses","plane":floor_pick,"project_edges":true}))["sketch"].as_u64().unwrap();+ let boss_curves = run(&mut s, "sketch.circle.center", json!({"center":[30,20],"radius":3.5}))["curves"].clone();+ let centre = format!("{}.center", boss_curves[0].as_str().unwrap());+ run(&mut s, "sketch.dimension", json!({"entities":["origin",centre],"type":"horizontal","value":"width / 2 - 10 mm"}));+ run(&mut s, "sketch.dimension", json!({"entities":["origin",centre],"type":"vertical","value":"depth / 2 - 10 mm"}));+ run(&mut s, "sketch.finish", json!({}));+ run(+ &mut s,+ "solid.extrude",+ json!({"sketch":floor,"profiles":[{"curves":boss_curves}],"distance":12,"operation":"join","targets":["Case"],"name":"Boss"}),+ );+ run(+ &mut s,+ "solid.pattern.rectangular",+ json!({"features":["Boss"],"dir1":[-1,0,0],"count1":2,"spacing1":"width - 20 mm","dir2":[0,-1,0],"count2":2,"spacing2":"depth - 20 mm","name":"BossPattern"}),+ );+ for id in [side, floor] {+ let FeatureKind::Sketch { plane, .. } = &s.doc.feature(id).unwrap().kind else { panic!() };+ assert!(matches!(plane_face_anchor(plane).unwrap().target.certificate, Some(FaceCertificate::ShellPlanar { .. })));+ }+ run(&mut s, "parameters.change", json!({"name":"width","expression":"100 mm"}));+ run(&mut s, "parameters.change", json!({"name":"wall","expression":"3 mm"}));+ let reopened = Session::new(solvecraft_doc::Document::from_json(&s.doc.to_json()).unwrap());+ for session in [&s, &reopened] {+ for id in [side, floor] {+ let result = session.model.result(id).unwrap();+ assert!(result.error.is_none(), "{}: {:?}", result.name, result.error);+ assert!(result.warning.is_none(), "{}: {:?}", result.name, result.warning);+ assert!(+ session.model.state().sketch(id).unwrap().sketch.links.iter().all(|link| !link.lost),+ "projected boundary must resolve current geometry"+ );+ }+ let state = session.model.state();+ assert!(state.body("Case").is_some());+ assert!((state.sketch(side).unwrap().plane.origin.x - 50.).abs() < 1e-6);+ assert!((state.sketch(floor).unwrap().plane.origin.z - 3.).abs() < 1e-6);+ assert!(state.sketch(floor).unwrap().plane.normal().dot(Vec3::Z) > 0.999);+ let mesh = state.body("Case").unwrap().body.tessellate_with(1e-4, true).unwrap();+ let case = &state.body("Case").unwrap().body;+ let corners: Vec<_> = (0..case.face_count()).filter(|i| matches!(solvecraft_kernel::face_surface(case, *i), Some(solvecraft_kernel::FaceSurface::Cylinder { radius, .. }) if (radius - 6.).abs() < 1e-6)).collect();+ assert_eq!(corners.len(), 4, "later port/boss features must not subdivide untouched outer corners");+ for index in corners {+ let points: Vec<_> = mesh+ .edge_faces+ .iter()+ .enumerate()+ .filter(|(_, faces)| faces.contains(&(index as u32)))+ .flat_map(|(edge, _)| &mesh.edges[edge])+ .collect();+ assert!(points.iter().any(|p| p.z.abs() < 1e-8));+ assert!(points.iter().any(|p| (p.z - 30.).abs() < 1e-8));+ }++ assert!(!mesh.contains(Vec3::new(49., 0., 12.)), "USB must remain open after resize/reopen");+ assert!(mesh.contains(Vec3::new(49., 15., 12.)), "adjacent right wall remains solid");+ assert!(mesh.contains(Vec3::new(-49., 0., 12.)), "opposite wall must stay solid");+ let seed = state.sketch(floor).unwrap().plane.to_world(solvecraft_geom::Vec2::new(40., 20.)) + Vec3::Z * 6.;+ assert!(mesh.contains(seed), "seed boss starts on current floor");+ for shift in [Vec3::ZERO, Vec3::new(-80., 0., 0.), Vec3::new(0., -40., 0.), Vec3::new(-80., -40., 0.)] {+ assert!(mesh.contains(seed + shift), "each patterned boss must survive resize/reopen at {:?}", seed + shift);+ }+ assert!(!mesh.contains(Vec3::new(0., 0., 6.)), "the cavity remains hollow");+ let area = |w: f64, d: f64, r: f64| w * d - (4. - std::f64::consts::PI) * r * r;+ let expected = area(100., 60., 6.) * 30. - area(94., 54., 3.) * 27. - 12. * 7. * 3. + 4. * std::f64::consts::PI * 3.5 * 3.5 * 12.;+ assert!((mesh.measure().volume - expected).abs() < 0.1, "actual {}, analytic {expected}", mesh.measure().volume);+ }+ run(&mut s, "timeline.suppress", json!({"feature":"Hollow","suppressed":true}));+ assert!(s.model.result(side).unwrap().error.is_some());+ assert!(s.model.result(floor).unwrap().error.is_some());+}++#[test]+fn offset_rectangle_pocket_has_one_logical_outer_wall_and_closed_face_projection() {+ let mut s = Session::default();+ let base = run(&mut s, "sketch.create", json!({"plane":"XY"}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.rectangle.center", json!({"center":[0,0],"corner":[30,27]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch":base,"distance":10,"operation":"new","body_name":"Stock"}));+ let control_sketch = run(&mut s, "sketch.create", json!({"plane":"XY"}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.rectangle.two_point", json!({"p0":[100,100],"p1":[104,104]}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch":control_sketch,"distance":10,"operation":"new","body_name":"Control"}));+ let untouched = s.model.state().body("Control").unwrap().body.clone();+ let before_control = solvecraft_kernel::step_export(&[&untouched], "control snapshot").unwrap();+ let pick = top_pick(&s, "Stock");+ let pocket = run(&mut s, "sketch.create", json!({"plane":pick}))["sketch"].as_u64().unwrap();+ let side = {+ let state = s.model.state();+ let sk = &state.sketch(pocket).unwrap().sketch;+ let curve = sk.curves.iter().find(|c| c.id == "l1").unwrap();+ let solvecraft_sketch::CurveKind::Line { a, b } = curve.kind else { panic!() };+ sk.point(a).unwrap() + sk.point(b).unwrap()+ };+ let outer = run(&mut s, "sketch.offset", json!({"curves":["l1"],"distance":0.3425231845240546,"side":[side.x,side.y]}))["curves"].clone();+ let inner = run(&mut s, "sketch.offset", json!({"curves":[outer[0]],"distance":5.609348914858092,"side":[0,0]}))["curves"].clone();+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch":pocket,"profiles":[{"curves":inner}],"distance":-9,"operation":"cut"}));+ let control = s.model.state().body("Control").unwrap().body.clone();+ assert!(control.same(&untouched), "a separate body crossing the cutter end plane remains the exact same solid");+ assert_eq!(solvecraft_kernel::step_export(&[&control], "control snapshot").unwrap(), before_control);+ let state = s.model.state();+ let body = state.body("Stock").unwrap();+ let display = body.body.display_mesh(0.01).unwrap();+ let face = body+ .body+ .faces(0.01)+ .unwrap()+ .into_iter()+ .find(|face| face.plane_normal.is_some_and(|n| n.dot(Vec3::X) > 0.999) && (face.centroid.x - 30.).abs() < 1e-6)+ .unwrap();+ assert_eq!(body.body.faces(0.01).unwrap().len(), 11, "actual pocket topology has no outer floor-height strips");+ assert_eq!(display.surface_patch(face.index).len(), 1);+ let attached = run(&mut s, "sketch.create", json!({"plane":{"body":"Stock","index":face.index,"face":[30,0,0.5]}}))["sketch"].as_u64().unwrap();+ run(&mut s, "sketch.finish", json!({}));+ let reopened = Session::new(solvecraft_doc::Document::from_json(&s.doc.to_json()).unwrap());+ for session in [&s, &reopened] {+ let result = session.model.result(attached).unwrap();+ assert!(result.error.is_none(), "{:?}", result.error);+ assert!(result.warning.is_none(), "{:?}", result.warning);+ let state = session.model.state();+ let sketch = &state.sketch(attached).unwrap().sketch;+ assert!(sketch.links.iter().all(|link| !link.lost));+ assert_eq!(sketch.curves.len(), 4, "whole outer-wall rectangle has no floor-height stations");+ let mesh = state.body("Stock").unwrap().body.display_mesh(0.01).unwrap();+ assert!(mesh.contains(Vec3::new(0., 0., 0.5)));+ assert!(!mesh.contains(Vec3::new(0., 0., 5.)));+ assert!(mesh.contains(Vec3::new(28., 0., 5.)));+ let control = &state.body("Control").unwrap().body;+ assert_eq!(control.faces(0.01).unwrap().len(), 6);+ assert_eq!(control.edges(0.01).unwrap().len(), 12);+ let control_mesh = control.tessellate(0.01).unwrap();+ assert!((control_mesh.measure().volume - 160.).abs() < 1e-6);+ assert!(control_mesh.contains(Vec3::new(102., 102., 0.5)));+ assert!(control_mesh.contains(Vec3::new(102., 102., 5.)));+ let expected = 60. * 54. * 10. - 4. * 24.73317426966596 * 21.733174269665962 * 9.;+ assert!((mesh.measure().volume - expected).abs() < 1e-6, "actual {}, expected {expected}", mesh.measure().volume);+ }+}diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex 36f72e460a..9043a531ff 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -23,28 +23,53 @@ fn rel(a: f64, b: f64) -> f64 {#[test]fn join_extrude_from_a_chamfered_top_face() {let mut s = Session::default();+ run(&mut s, "parameters.add", json!({"name":"height","expression":"20 mm"}));+ run(&mut s, "parameters.add", json!({"name":"bevel","expression":"2 mm"}));run(&mut s, "sketch.create", json!({"plane": "XY"}));run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 10}));- run(&mut s, "solid.extrude", json!({"distance": 20}));- run(&mut s, "solid.chamfer", json!({"edges": [[10, 0, 20]], "distance": 2}));+ let source = run(&mut s, "solid.extrude", json!({"distance": "height","name":"Stem"}))["feature"].as_u64().unwrap();+ run(&mut s, "solid.chamfer", json!({"edges": [[10, 0, 20]], "distance": "bevel"}));let base = volume(&mut s);- let before = s.doc.to_json();- let active = s.active_sketch;- assert!(s.execute("sketch.create", &json!({"plane":{"face":[0,0,20]}})).is_err(), "modified faces require an explicit fixed plane");- assert_eq!(s.doc.to_json(), before);- assert_eq!(s.active_sketch, active);- assert!(rel(volume(&mut s), base) < 1e-12);- let id = run(&mut s, "sketch.create", json!({"plane": {"face": [0, 0, 20],"fixed":true}}))["sketch"].as_u64().unwrap();- let solvecraft_doc::FeatureKind::Sketch { plane: solvecraft_doc::PlaneRef::Custom { plane }, sketch } = &s.doc.feature(id).unwrap().kind else {- panic!("explicit fixed face must become a custom plane");+ let id = run(&mut s, "sketch.create", json!({"plane": {"face": [0, 0, 20]}}))["sketch"].as_u64().unwrap();+ let solvecraft_doc::FeatureKind::Sketch { plane: solvecraft_doc::PlaneRef::Face { anchor: Some(anchor), .. }, sketch } =+ &s.doc.feature(id).unwrap().kind+ else {+ panic!("the chamfered cap retains its exact original construction support");};- assert!((plane.origin.z - 20.).abs() < 1e-9);- assert!(sketch.links.is_empty(), "fresh fixed plane does not create live auto-projections");- run(&mut s, "sketch.circle.center", json!({"center":[0,0],"radius":8}));+ assert_eq!(anchor.target.origin_feature, source);+ assert!(matches!(anchor.target.certificate, Some(solvecraft_doc::config::FaceCertificate::ExtrudeCap { high: true, .. })));+ assert!(!sketch.links.is_empty());+ assert!(sketch.links.iter().all(|link| link.auto_face && !link.lost));+ // The default linked cap outline is radius8; no explicit fixed plane or+ // duplicate manually drawn circle is required to join a pad to that face.run(&mut s, "sketch.finish", json!({}));run(&mut s, "solid.extrude", json!({"distance": 5, "operation": "join"}));assert_eq!(s.model.state().bodies.len(), 1);assert!(rel(volume(&mut s), base + PI * 64.0 * 5.0) < 5e-4);+ for (height, bevel) in [(20., 2.), (25., 3.)] {+ run(&mut s, "parameters.change", json!({"name":"height","expression":format!("{height} mm")}));+ run(&mut s, "parameters.change", json!({"name":"bevel","expression":format!("{bevel} mm")}));+ let expected = PI * (100. * height - (10. * bevel * bevel - bevel * bevel * bevel / 3.) + (10. - bevel) * (10. - bevel) * 5.);+ let loaded = solvecraft_doc::Document::from_json(&s.doc.to_json()).unwrap();+ let mut cold = Session::new(loaded);+ let warm_volume = volume(&mut s);+ let cold_volume = volume(&mut cold);+ assert!(rel(warm_volume, expected) < 5e-4, "{warm_volume} vs {expected}");+ assert!((warm_volume - cold_volume).abs() < 1e-8);+ for current in [&s, &cold] {+ assert!(current.model.results.iter().all(|result| result.error.is_none() && result.warning.is_none()), "{:?}", current.model.results);+ let state = current.model.state();+ assert_eq!(state.bodies.len(), 1);+ let solved = state.sketch(id).unwrap();+ assert!((solved.plane.origin.z - height).abs() < 1e-8);+ assert!(solved.sketch.links.iter().all(|link| link.auto_face && !link.lost));+ let body = &state.bodies[0];+ assert!(body.body.contains(solvecraft_geom::Vec3::new(0., 0., height + 4.)));+ assert!(!body.body.contains(solvecraft_geom::Vec3::new(0., 0., height + 6.)));+ assert!(body.body.contains(solvecraft_geom::Vec3::new(10. - bevel - 0.5, 0., height + 4.)));+ assert!(!body.body.contains(solvecraft_geom::Vec3::new(10. - bevel + 0.5, 0., height + 4.)));+ }+ }}/// A join that bridges two bodies makes them one body, not an overlap of the first and the second.diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex f0a089bf82..3506cc713f 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -5,6 +5,10 @@ use truck_modeling as mt;use crate::{KernelError, Result, guard};+#[path = "planar_regularize.rs"]+mod planar_regularize;+#[path = "planar_sources.rs"]+mod planar_sources;#[path = "shell_groups.rs"]mod shell_groups;@@ -33,11 +37,12 @@ pub struct Body {#[derive(Clone, Debug, PartialEq)]pub enum FaceSource {- ExtrudeSide { segment: solvecraft_geom::Seg2, plane: Option<solvecraft_geom::Plane> },+ ExtrudeSide { segment: solvecraft_geom::Seg2, plane: Option<solvecraft_geom::Plane>, coalesced: bool },CertifiedExtrudeSide { producer: u64, sketch: u64, curve: String, plane: Option<solvecraft_geom::Plane> },ExtrudeCap { high: bool, region: solvecraft_geom::Region2, plane: solvecraft_geom::Plane },CertifiedExtrudeCap { producer: u64, sketch: u64, high: bool, outer: Vec<String>, holes: Vec<Vec<String>>, plane: solvecraft_geom::Plane },Box { producer: Option<u64>, axis: u8, high: bool, plane: solvecraft_geom::Plane },+ ShellPlanar { producer: Option<u64>, source: Box<FaceSource>, inner: bool, plane: solvecraft_geom::Plane },Imported { item: u64, face: u64, payload_sha256: Option<String>, producer: Option<u64> },}@@ -48,7 +53,9 @@ impl FaceSource {fn plane_mut(&mut self) -> Option<&mut solvecraft_geom::Plane> {match self {Self::ExtrudeSide { plane, .. } | Self::CertifiedExtrudeSide { plane, .. } => plane.as_mut(),- Self::ExtrudeCap { plane, .. } | Self::CertifiedExtrudeCap { plane, .. } | Self::Box { plane, .. } => Some(plane),+ Self::ExtrudeCap { plane, .. } | Self::CertifiedExtrudeCap { plane, .. } | Self::Box { plane, .. } | Self::ShellPlanar { plane, .. } => {+ Some(plane)+ }Self::Imported { .. } => None,}}@@ -358,6 +365,12 @@ impl Body {self.face_sources.as_deref().map(Vec::as_slice)}+ /// A current wall reconstructed from an exact contiguous section run.+ /// This transient witness grants no durable source/producer identity.+ pub fn face_was_coalesced(&self, index: usize) -> bool {+ matches!(self.face_sources().and_then(|s| s.get(index)), Some(Some(FaceSource::ExtrudeSide { coalesced: true, .. })))+ }+/// An exact construction/import plane; never inferred from tessellation.pub fn face_plane(&self, index: usize) -> Option<solvecraft_geom::Plane> {if index >= 50_000 {@@ -366,7 +379,10 @@ impl Body {let source = self.face_sources()?.get(index)?.as_ref()?;match source {FaceSource::ExtrudeSide { plane, .. } | FaceSource::CertifiedExtrudeSide { plane, .. } => *plane,- FaceSource::ExtrudeCap { plane, .. } | FaceSource::CertifiedExtrudeCap { plane, .. } | FaceSource::Box { plane, .. } => Some(*plane),+ FaceSource::ExtrudeCap { plane, .. }+ | FaceSource::CertifiedExtrudeCap { plane, .. }+ | FaceSource::Box { plane, .. }+ | FaceSource::ShellPlanar { plane, .. } => Some(*plane),FaceSource::Imported { .. } => self.planar_face(index),}}diff --git a/crates/kernel/src/build.rs b/crates/kernel/src/build.rsindex dde984499a..7834358a1f 100644--- a/crates/kernel/src/build.rs+++ b/crates/kernel/src/build.rs@@ -179,7 +179,7 @@ pub fn extrude(plane: &Plane, regions: &[Region2], start: f64, end: f64) -> Resu}_ => None,};- Some(crate::FaceSource::ExtrudeSide { segment: **segment, plane: basis })+ Some(crate::FaceSource::ExtrudeSide { segment: **segment, plane: basis, coalesced: false })} else {None};diff --git a/crates/kernel/src/face_source_tests.rs b/crates/kernel/src/face_source_tests.rsindex 927750b60e..1851b35b63 100644--- a/crates/kernel/src/face_source_tests.rs+++ b/crates/kernel/src/face_source_tests.rs@@ -116,18 +116,32 @@ fn construction_planes_follow_reflected_and_sheared_affine_images() {}#[test]-fn material_changes_discard_producer_certificates() {+fn material_changes_preserve_only_unchanged_planar_support_certificates() {let base = crate::box_solid(Vec3::ZERO, Vec3::new(10., 10., 10.)).unwrap().with_box_certificate(42).unwrap();let tool = crate::box_solid(Vec3::new(5., -1., -1.), Vec3::new(11., 11., 11.)).unwrap();let cut = crate::boolean(&base, &tool, crate::BoolOp::Cut).unwrap().unwrap();assert!((cut.tessellate(1e-4).unwrap().measure().volume - 500.).abs() < 1e-8);- assert!(cut.face_sources().into_iter().flatten().flatten().all(|source| matches!(- source,- FaceSource::ExtrudeSide { .. }- | FaceSource::ExtrudeCap { .. }- | FaceSource::Box { producer: None, .. }- | FaceSource::Imported { producer: None, .. }- )));+ // Unchanged uniquely certified supports retain their role; a newly cut+ // support must never inherit the removed opposite wall's source identity.+ let mut retained = 0;+ let mut new_wall = 0;+ for index in 0..cut.face_count() {+ let actual = cut.planar_face(index).unwrap();+ let source = cut.face_sources().and_then(|s| s.get(index)).and_then(Option::as_ref);+ if let Some(FaceSource::Box { producer: Some(42), axis, high, .. }) = source {+ assert!(!(*axis == 0 && *high));+ let canonical = cut.face_plane(index).unwrap();+ assert!(actual.normal().dot(canonical.normal()) > 1. - 1e-10);+ assert!(actual.height(canonical.origin).abs() < 1e-10);+ retained += 1;+ }+ if actual.normal().x > 0.9 {+ assert!((actual.origin.x - 5.).abs() < 1e-10);+ assert!(!matches!(source, Some(FaceSource::Box { producer: Some(_), .. })));+ new_wall += 1;+ }+ }+ assert_eq!((retained, new_wall), (5, 1));}#[test]diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rsindex df4c48049a..8b62dc9018 100644--- a/crates/kernel/src/ops.rs+++ b/crates/kernel/src/ops.rs@@ -221,6 +221,9 @@ pub fn boolean(a: &Body, b: &Body, op: BoolOp) -> Result<Option<Body>> {)),};}+ if matches!(op, BoolOp::Cut | BoolOp::Union) {+ r = r.and_then(|result| result.map(|body| body.with_preserved_boolean_planar_sources(a, b, op == BoolOp::Cut)).transpose());+ }r}diff --git a/crates/kernel/src/planar_regularize.rs b/crates/kernel/src/planar_regularize.rsnew file mode 100644index 0000000000..593284c8f9--- /dev/null+++ b/crates/kernel/src/planar_regularize.rs@@ -0,0 +1,284 @@+//! Exact topological removal of construction-induced planar subdivisions.+//! Shared edge identity and complete construction lineage select the groups.+use super::{Body, from_p3};+use crate::{Result, guard};+use solvecraft_geom::Plane;+use std::collections::{BTreeMap, HashMap, HashSet};+use std::sync::Arc;+use truck_modeling as mt;++fn root(parent: &mut [usize], mut i: usize) -> usize {+ while parent[i] != i {+ parent[i] = parent[parent[i]];+ i = parent[i];+ }+ i+}++fn merged_face(faces: &[&mt::Face], members: &[usize], plane: Plane, eligible: &HashSet<mt::EdgeID>) -> Option<mt::Face> {+ let mut counts = HashMap::<mt::EdgeID, (usize, bool)>::new();+ for i in members {+ for edge in faces.get(*i)?.boundary_iters().into_iter().flatten() {+ // Whole linear supports, not a sampled plane fit.+ let mt::Curve::Line(line) = edge.curve() else { return None };+ let (a, b) = (from_p3(line.0), from_p3(line.1));+ if !a.is_finite() || !b.is_finite() || a.len().max(b.len()) > 1e9 {+ return None;+ }+ let front = from_p3(edge.absolute_front().point());+ let back = from_p3(edge.absolute_back().point());+ if !front.is_finite() || !back.is_finite() {+ return None;+ }+ let error = 4096. * f64::EPSILON * (1. + a.len() + b.len() + plane.origin.len());+ if plane.height(a).abs() > error || plane.height(b).abs() > error || a.dist(front) > error || b.dist(back) > error {+ return None;+ }+ let count = counts.entry(edge.id()).or_insert((0, edge.orientation()));+ if count.0 == 1 && (!eligible.contains(&edge.id()) || count.1 == edge.orientation()) {+ return None;+ }+ count.0 += 1;+ if count.0 > 2 {+ return None;+ }+ }+ }+ let mut boundary = Vec::new();+ for i in members {+ for edge in faces.get(*i)?.boundary_iters().into_iter().flatten() {+ if counts.get(&edge.id()).is_some_and(|(n, _)| *n == 1) {+ boundary.push(edge);+ }+ }+ }+ let mut next = HashMap::new();+ let mut incoming = HashMap::new();+ for (i, edge) in boundary.iter().enumerate() {+ if next.insert(edge.front().id(), i).is_some() || incoming.insert(edge.back().id(), i).is_some() {+ return None;+ }+ }+ if next.len() != incoming.len() || next.keys().any(|id| !incoming.contains_key(id)) {+ return None;+ }+ let mut used = vec![false; boundary.len()];+ let mut outer = None;+ let mut holes = Vec::new();+ for first in 0..boundary.len() {+ if used[first] {+ continue;+ }+ let start = boundary.get(first)?.front().id();+ let origin = from_p3(boundary.get(first)?.front().point());+ let mut index = first;+ let mut edges = Vec::new();+ let (mut area, mut magnitude, mut arithmetic_error) = (0., 0., 0.);+ loop {+ if *used.get(index)? {+ return None;+ }+ used[index] = true;+ let edge = boundary.get(index)?.clone();+ let da = from_p3(edge.front().point()) - origin;+ let db = from_p3(edge.back().point()) - origin;+ let a = solvecraft_geom::Vec2::new(da.dot(plane.x), da.dot(plane.y));+ let b = solvecraft_geom::Vec2::new(db.dot(plane.x), db.dot(plane.y));+ let term = a.cross(b);+ area += term;+ magnitude += term.abs();+ let coordinate_error =+ 128. * f64::EPSILON * (1. + origin.len() + from_p3(edge.front().point()).len() + from_p3(edge.back().point()).len());+ arithmetic_error += coordinate_error * (da.len() + db.len() + coordinate_error) * 16.;+ let back = edge.back().id();+ edges.push(edge);+ if back == start {+ break;+ }+ index = *next.get(&back)?;+ }+ if edges.len() < 3 || !area.is_finite() || area.abs() <= arithmetic_error + 64. * f64::EPSILON * (edges.len() as f64 + 1.) * magnitude.max(1.)+ {+ return None;+ }+ let wire = mt::Wire::from(edges);+ if area > 0. {+ if outer.replace(wire).is_some() {+ return None;+ }+ } else {+ holes.push(wire);+ }+ }+ let mut wires = vec![outer?];+ wires.extend(holes);+ mt::Face::try_new(wires, faces.get(*members.first()?)?.oriented_surface()).ok()+}++impl Body {+ pub(crate) fn regularize_certified_planar_faces(self) -> Result<Self> {+ let Some(sources) = self.face_sources() else { return Ok(self) };+ if sources.len() > 16_384 || self.paint().is_some_and(|p| !p.faces.is_empty()) {+ return Ok(self);+ }+ let split_points = self.split_keep().iter().try_fold(0usize, |sum, line| sum.checked_add(line.len()));+ let Some(split_points) = split_points.filter(|n| *n <= 65_536) else { return Ok(self) };+ let result = guard("certified planar topology regularization", || {+ let mut faces = Vec::new();+ let mut shell_owner = Vec::new();+ let mut use_budget = 65_536usize;+ for (shell_index, shell) in self.solid.boundaries().iter().enumerate() {+ for face in shell.face_iter() {+ if faces.len() >= sources.len() {+ return Ok(None);+ }+ for _ in face.edge_iter() {+ let Some(left) = use_budget.checked_sub(1) else { return Ok(None) };+ use_budget = left;+ }+ faces.push(face);+ shell_owner.push(shell_index);+ }+ }+ if faces.len() != sources.len() {+ return Ok(None);+ }+ let valid: Vec<_> = faces+ .iter()+ .zip(sources)+ .map(|(f, s)| {+ s.as_ref()+ .and_then(super::planar_sources::certified_plane)+ .filter(|p| super::planar_sources::actual_plane(f).is_some_and(|actual| super::planar_sources::same_support(p, &actual)))+ })+ .collect();+ let mut adjacency = HashMap::<mt::EdgeID, Vec<(usize, mt::Edge)>>::new();+ for (i, face) in faces.iter().enumerate() {+ for edge in face.boundary_iters().into_iter().flatten() {+ adjacency.entry(edge.id()).or_default().push((i, edge));+ }+ }+ let mut eligible = HashSet::new();+ let mut parent: Vec<_> = (0..faces.len()).collect();+ let mut identity = 16_000_000usize;+ let mut work = 2_000_000usize;+ for uses in adjacency.values() {+ let [(a, ea), (b, eb)] = uses.as_slice() else { continue };+ if a == b || shell_owner[*a] != shell_owner[*b] || ea.orientation() == eb.orientation() {+ continue;+ }+ let (Some(pa), Some(pb)) = (valid[*a], valid[*b]) else { continue };+ if pa != pb {+ continue;+ }+ let (Some(sa), Some(sb)) = (sources[*a].as_ref(), sources[*b].as_ref()) else { continue };+ let Some(cost) = super::planar_sources::descriptor_cost(sa)+ .and_then(|a| super::planar_sources::descriptor_cost(sb).and_then(|b| a.checked_add(b)))+ else {+ continue;+ };+ let Some(left) = identity.checked_sub(cost) else { return Ok(None) };+ identity = left;+ if sa != sb {+ continue;+ }+ let Some(cost) = split_points.checked_mul(6).and_then(|n| n.checked_add(1)) else { return Ok(None) };+ let Some(left) = work.checked_sub(cost) else { return Ok(None) };+ work = left;+ if crate::heal::on_split_line(&crate::heal::edge_points(ea), self.split_keep()) {+ continue;+ }+ eligible.insert(ea.id());+ let (ra, rb) = (root(&mut parent, *a), root(&mut parent, *b));+ parent[ra.max(rb)] = ra.min(rb);+ }+ let mut groups = BTreeMap::<usize, Vec<usize>>::new();+ for i in 0..faces.len() {+ groups.entry(root(&mut parent, i)).or_default().push(i);+ }+ let mut replacements = HashMap::new();+ let mut changed = false;+ let mut metadata = 2_000_000usize;+ for (leader, members) in &groups {+ if members.len() < 2 {+ continue;+ }+ let Some(face) = valid[*leader].and_then(|p| merged_face(&faces, members, p, &eligible)) else { continue };+ replacements.insert(*leader, face);+ changed = true;+ }+ if !changed {+ return Ok(None);+ }+ let mut shells = Vec::new();+ let mut output_sources = Vec::new();+ let mut output_ids = Vec::new();+ let mut offset = 0;+ for shell in self.solid.boundaries() {+ let mut output = Vec::new();+ for face in shell.face_iter() {+ let leader = root(&mut parent, offset);+ if let Some(merged) = replacements.get(&leader) {+ if offset == leader {+ output.push(merged.clone());+ } else {+ offset += 1;+ continue;+ }+ } else {+ output.push(face.clone());+ }+ output_ids.push(output.last().ok_or_else(|| crate::KernelError::Failed("missing regularized face".into()))?.id());+ let source = sources[offset].as_ref();+ if let Some(source) = source {+ let Some(cost) = super::planar_sources::descriptor_cost(source) else { return Ok(None) };+ let Some(left) = metadata.checked_sub(cost) else { return Ok(None) };+ metadata = left;+ }+ output_sources.push(source.cloned());+ offset += 1;+ }+ shells.push(mt::Shell::from(output));+ }+ let solid = mt::Solid::try_new(shells).map_err(|e| crate::KernelError::Failed(format!("planar regularization does not close: {e}")))?;+ let body = Body::new(solid)?.with_color(self.color()).with_paint(self.paint().cloned()).with_split_lines(self.split_lines().cloned());+ if !body.solid.face_iter().map(|f| f.id()).eq(output_ids) {+ return Ok(None);+ }+ Ok(Some(body.with_face_sources(Some(Arc::new(output_sources)))))+ })?;+ Ok(result.unwrap_or(self))+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ #[test]+ fn alternate_adjacency_path_cannot_remove_protected_internal_edge() {+ let vertices: Vec<_> =+ (0..9).map(|i| mt::builder::vertex(super::super::p3(solvecraft_geom::Vec3::new((i % 3) as f64, (i / 3) as f64, 0.)))).collect();+ let mut edges = HashMap::<(usize, usize), mt::Edge>::new();+ let mut faces = Vec::new();+ for (x, y) in [(0, 0), (1, 0), (0, 1), (1, 1)] {+ let ids = [y * 3 + x, y * 3 + x + 1, (y + 1) * 3 + x + 1, (y + 1) * 3 + x];+ let wire: mt::Wire = (0..4)+ .map(|i| {+ let (a, b) = (ids[i], ids[(i + 1) % 4]);+ let key = (a.min(b), a.max(b));+ let edge = edges.entry(key).or_insert_with(|| mt::builder::line(&vertices[key.0], &vertices[key.1]));+ if a == key.0 { edge.clone() } else { edge.inverse() }+ })+ .collect();+ faces.push(mt::builder::try_attach_plane(&[wire]).unwrap());+ }+ let refs: Vec<_> = faces.iter().collect();+ let mut eligible: HashSet<_> = edges.values().map(|e| e.id()).collect();+ assert!(merged_face(&refs, &[0, 1, 2, 3], Plane::XY, &eligible).is_some());+ eligible.remove(&edges[&(1, 4)].id());+ assert!(+ merged_face(&refs, &[0, 1, 2, 3], Plane::XY, &eligible).is_none(),+ "remaining three internal joins cannot bypass authored split protection"+ );+ }+}diff --git a/crates/kernel/src/planar_sources.rs b/crates/kernel/src/planar_sources.rsnew file mode 100644index 0000000000..2fb19bed96--- /dev/null+++ b/crates/kernel/src/planar_sources.rs@@ -0,0 +1,516 @@+//! Exact oriented planar support lineage through a trim and an inside shell.+//! No tessellated face names, centroids, or nearest-plane choices are used.+use super::{Body, FaceSource, from_p3};+use crate::{KernelError, Result, guard};+use solvecraft_geom::{Plane, Vec3};+use std::sync::Arc;+use truck_modeling as mt;++pub(super) fn actual_plane(face: &mt::Face) -> Option<Plane> {+ let mt::Surface::Plane(p) = face.oriented_surface() else { return None };+ let u = p.u_axis();+ let v = p.v_axis();+ let u = Vec3::new(u.x, u.y, u.z);+ let v = Vec3::new(v.x, v.y, v.z);+ if !u.is_finite() || !v.is_finite() || u.cross(v).len() <= u.len() * v.len() * 1e-8 {+ return None;+ }+ Plane::new(from_p3(p.origin()), u, v)+}++pub(super) fn same_support(a: &Plane, b: &Plane) -> bool {+ let error = 4096. * f64::EPSILON * (1. + a.origin.len() + b.origin.len());+ a.normal().cross(b.normal()).len() <= 4096. * f64::EPSILON+ && a.normal().dot(b.normal()) > 0.+ && (a.origin - b.origin).dot(a.normal()).abs() <= error+}++fn base_plane(source: &FaceSource, actual: &Plane) -> Option<Plane> {+ match source {+ FaceSource::CertifiedExtrudeSide { plane: Some(p), .. }+ | FaceSource::CertifiedExtrudeCap { plane: p, .. }+ | FaceSource::Box { producer: Some(_), plane: p, .. }+ | FaceSource::ShellPlanar { producer: Some(_), plane: p, .. } => Some(*p),+ FaceSource::Imported { producer: Some(_), payload_sha256: Some(_), .. } => Some(*actual),+ _ => None,+ }+}++pub(super) fn certified_plane(source: &FaceSource) -> Option<Plane> {+ match source {+ FaceSource::CertifiedExtrudeSide { plane: Some(p), .. }+ | FaceSource::CertifiedExtrudeCap { plane: p, .. }+ | FaceSource::Box { producer: Some(_), plane: p, .. }+ | FaceSource::ShellPlanar { producer: Some(_), plane: p, .. } => Some(*p),+ _ => None,+ }+}++fn boolean_source(source: &FaceSource, constructed: bool) -> bool {+ matches!(source, FaceSource::ShellPlanar { producer: Some(_), .. }) || (constructed && certified_plane(source).is_some())+}++pub(super) fn descriptor_cost(source: &FaceSource) -> Option<usize> {+ let mut cost = 256usize;+ match source {+ FaceSource::CertifiedExtrudeCap { outer, holes, .. } => {+ if holes.len() > 4096 {+ return None;+ }+ cost = cost.checked_add(holes.len().checked_mul(64)?)?;+ let mut entries = 4096usize;+ for id in outer.iter().chain(holes.iter().flatten()) {+ entries = entries.checked_sub(1)?;+ if id.len() > 128 {+ return None;+ }+ cost = cost.checked_add(id.len().checked_add(64)?)?;+ }+ }+ FaceSource::CertifiedExtrudeSide { curve, .. } => {+ if curve.len() > 128 {+ return None;+ }+ cost = cost.checked_add(curve.len())?;+ }+ FaceSource::Imported { payload_sha256: Some(digest), .. } => {+ if digest.len() > 64 {+ return None;+ }+ cost = cost.checked_add(digest.len())?;+ }+ FaceSource::ShellPlanar { source, .. } if !matches!(source.as_ref(), FaceSource::ShellPlanar { .. }) => {+ cost = cost.checked_add(descriptor_cost(source)?)?;+ }+ FaceSource::ExtrudeCap { region, .. } => {+ if region.holes.len() > 8192 {+ return None;+ }+ cost = cost.checked_add(region.holes.len().checked_mul(64)?)?;+ let count = region.holes.iter().try_fold(region.outer.segs.len(), |sum, h| sum.checked_add(h.segs.len()))?;+ if count > 8192 {+ return None;+ }+ cost = cost.checked_add(count.checked_mul(128)?)?;+ }+ FaceSource::ExtrudeSide { .. } | FaceSource::Imported { .. } | FaceSource::Box { .. } => {}+ _ => return None,+ }+ Some(cost)+}++impl Body {+ /// Preserve uniquely certified unchanged planar construction supports.+ pub fn with_preserved_planar_sources(self, input: &Body) -> Result<Self> {+ self.map_planar_sources(input, None, None, &[], false)+ }++ /// Generate distinct outer/inner roles from the exact original supports of+ /// an inside shell. Generated rims and curved walls are intentionally absent.+ pub(crate) fn with_shell_planar_sources(self, input: &Body, thickness: f64, open: &[Vec3]) -> Result<Self> {+ self.map_planar_sources(input, Some(thickness), None, open, false)+ }++ /// Retain exact shell roles, and construction roles for Cut, only on unchanged+ /// supports without a competing coplanar tool. No imported or fitted role is inferred.+ pub(crate) fn with_preserved_boolean_planar_sources(self, input: &Body, tool: &Body, constructed: bool) -> Result<Self> {+ if !input.face_sources().is_some_and(|sources| sources.iter().flatten().any(|s| boolean_source(s, constructed))) {+ return Ok(self);+ }+ self.map_planar_sources(input, None, Some(tool), &[], constructed)+ }++ fn map_planar_sources(mut self, input: &Body, shell: Option<f64>, blocker: Option<&Body>, open: &[Vec3], constructed: bool) -> Result<Self> {+ let Some(sources) = input.face_sources() else { return Ok(self) };+ if input.solid.face_iter().count() > 16_384+ || self.solid.face_iter().count() > 16_384+ || blocker.is_some_and(|b| b.solid.face_iter().count() > 16_384)+ {+ return Err(KernelError::Invalid("planar source face budget exceeded".into()));+ }+ if sources.len() != input.solid.face_iter().count() {+ return Err(KernelError::Invalid("planar source alignment mismatch".into()));+ }+ if shell.is_some_and(|t| !t.is_finite() || t <= 0.) {+ return Err(KernelError::Invalid("invalid shell source thickness".into()));+ }+ if open.len() > 256 {+ return Ok(self);+ }+ let opening_tolerance = if shell.is_some() { input.size() * 1e-4 + 1e-6 } else { 0. };+ let mapped = guard("exact planar support lineage", || {+ let competing: Vec<_> = blocker.into_iter().flat_map(|b| b.solid.face_iter()).filter_map(actual_plane).collect();+ let mut candidates = Vec::new();+ let mut unknown_supports = Vec::new();+ for (face, source) in input.solid.face_iter().zip(sources) {+ let Some(actual) = actual_plane(face) else { continue };+ let Some(source) = source.as_ref() else {+ unknown_supports.push(actual);+ continue;+ };+ if (blocker.is_some() && !boolean_source(source, constructed))+ || (shell.is_some() && matches!(source, FaceSource::ShellPlanar { .. }))+ {+ unknown_supports.push(actual);+ continue;+ }+ let Some(plane) = base_plane(source, &actual) else {+ unknown_supports.push(actual);+ continue;+ };+ if !same_support(&plane, &actual) || (shell.is_some() && open.iter().any(|p| actual.height(*p).abs() <= opening_tolerance)) {+ unknown_supports.push(actual);+ continue;+ }+ let Some(cost) = descriptor_cost(source) else {+ unknown_supports.push(actual);+ continue;+ };+ candidates.push((plane, source, false, cost));+ if let Some(t) = shell {+ let inner = Plane::new(plane.origin - plane.normal() * t, plane.x, -plane.y)+ .ok_or_else(|| KernelError::Invalid("invalid shell inner source plane".into()))?;+ candidates.push((inner, source, true, cost));+ }+ }+ let mut work = 2_000_000usize;+ let mut metadata = 2_000_000usize;+ let mut identity_bytes = 16_000_000usize;+ let mut result = Vec::new();+ for (index, face) in self.solid.face_iter().enumerate() {+ let mut found = None;+ if let Some(actual) = actual_plane(face) {+ let mut blocked = false;+ for plane in &unknown_supports {+ work = work.checked_sub(1).ok_or_else(|| KernelError::Invalid("unknown planar source comparison budget exceeded".into()))?;+ if same_support(plane, &actual) {+ blocked = true;+ break;+ }+ }+ for plane in &competing {+ work = work.checked_sub(1).ok_or_else(|| KernelError::Invalid("planar tool comparison budget exceeded".into()))?;+ if same_support(plane, &actual)+ || same_support(+ &Plane::new(plane.origin, plane.x, -plane.y).ok_or_else(|| KernelError::Invalid("invalid opposing plane".into()))?,+ &actual,+ )+ {+ blocked = true;+ break;+ }+ }+ if blocked {+ let existing = self+ .face_sources()+ .and_then(|sources| sources.get(index))+ .and_then(|s| s.as_ref())+ .filter(|s| (blocker.is_some() || self.face_was_coalesced(index)) && !boolean_source(s, constructed));+ let keep = existing.and_then(|s| {+ descriptor_cost(s).and_then(|cost| {+ metadata.checked_sub(cost).map(|remaining| {+ metadata = remaining;+ s.clone()+ })+ })+ });+ result.push(keep);+ continue;+ }+ let mut chosen: Option<(Plane, &FaceSource, bool, usize)> = None;+ for (plane, source, inner, cost) in &candidates {+ work = work.checked_sub(1).ok_or_else(|| KernelError::Invalid("planar source comparison budget exceeded".into()))?;+ if same_support(plane, &actual) {+ if let Some((previous_plane, previous_source, previous_inner, _)) = chosen {+ let Some(remaining) = identity_bytes.checked_sub(*cost) else {+ chosen = None;+ break;+ };+ identity_bytes = remaining;+ // Several current pieces of one exact source are one+ // logical face; distinct source identities remain ambiguous.+ if previous_plane != *plane || previous_source != *source || previous_inner != *inner {+ chosen = None;+ break;+ }+ } else {+ chosen = Some((*plane, *source, *inner, *cost));+ }+ }+ }+ if let Some((plane, source, inner, cost)) = chosen+ && let Some(remaining) = metadata.checked_sub(cost)+ {+ metadata = remaining;+ found = Some(if shell.is_some() {+ FaceSource::ShellPlanar { producer: None, source: Box::new(source.clone()), inner, plane }+ } else {+ source.clone()+ });+ }+ }+ if found.is_none() && (blocker.is_some() || self.face_was_coalesced(index)) {+ found = self+ .face_sources()+ .and_then(|sources| sources.get(index))+ .and_then(|s| s.as_ref())+ .filter(|s| !boolean_source(s, constructed))+ .and_then(|s| {+ descriptor_cost(s).and_then(|cost| {+ metadata.checked_sub(cost).map(|remaining| {+ metadata = remaining;+ s.clone()+ })+ })+ });+ }+ result.push(found);+ }+ Ok(result)+ })?;+ self.face_sources = Some(Arc::new(mapped));+ self.regularize_certified_planar_faces()+ }++ pub fn with_shell_certificate(mut self, producer: u64) -> Result<Self> {+ if producer == 0 {+ return Err(KernelError::Invalid("invalid shell source producer".into()));+ }+ if let Some(sources) = &self.face_sources {+ let mut sources = sources.as_ref().clone();+ for source in sources.iter_mut().flatten() {+ if let FaceSource::ShellPlanar { producer: id, .. } = source {+ *id = Some(producer);+ }+ }+ self.face_sources = Some(Arc::new(sources));+ }+ self.regularize_certified_planar_faces()+ }+}+#[cfg(test)]+mod tests {+ use super::*;+ use crate::{box_solid, fillet, shell, transform_matrix};++ #[test]+ fn rounded_shell_planar_roles_are_exact_distinct_and_transformable() {+ for (width, thickness) in [(80., 2.), (100., 3.)] {+ let box_body = box_solid(Vec3::new(-width / 2., -30., 0.), Vec3::new(width / 2., 30., 30.)).unwrap().with_box_certificate(7).unwrap();+ let rounded = fillet(+ &box_body,+ &[+ Vec3::new(width / 2., 30., 15.),+ Vec3::new(-width / 2., 30., 15.),+ Vec3::new(-width / 2., -30., 15.),+ Vec3::new(width / 2., -30., 15.),+ ],+ 6.,+ )+ .unwrap()+ .with_preserved_planar_sources(&box_body)+ .unwrap();+ assert_eq!(rounded.face_sources().unwrap().iter().flatten().count(), 6);+ let cup = shell(&rounded, &[Vec3::new(0., 0., 30.)], thickness).unwrap().with_shell_certificate(9).unwrap();+ let sources = cup.face_sources().unwrap();+ assert!(+ !sources+ .iter()+ .flatten()+ .any(|s| matches!(s,FaceSource::ShellPlanar {source, ..} if matches!(source.as_ref(),FaceSource::Box {axis:2,high:true,..})))+ );+ let right = sources.iter().position(|s| matches!(s, Some(FaceSource::ShellPlanar { inner:false, source, .. }) if matches!(source.as_ref(),FaceSource::Box {axis:0,high:true,..}))).unwrap();+ let floor = sources.iter().position(|s| matches!(s, Some(FaceSource::ShellPlanar { inner:true, source, .. }) if matches!(source.as_ref(),FaceSource::Box {axis:2,high:false,..}))).unwrap();+ assert!((cup.face_plane(right).unwrap().origin.x - width / 2.).abs() < 1e-9);+ let floor_plane = cup.face_plane(floor).unwrap();+ assert!((floor_plane.origin.z - thickness).abs() < 1e-9);+ assert!(floor_plane.normal().dot(Vec3::Z) > 0.999999);+ for (i, s) in sources.iter().enumerate() {+ if matches!(s, Some(FaceSource::ExtrudeSide { coalesced: true, plane: None, .. })) {+ assert!(cup.face_plane(i).is_none(), "loss witness is not source authority");+ } else if s.is_some() {+ assert!(same_support(&cup.face_plane(i).unwrap(), &cup.planar_face(i).unwrap()));+ }+ }+ let moved = transform_matrix(&cup, [[0., 1., 0., 0.], [-1., 0., 0., 0.], [0., 0., 1., 0.], [100., 200., 300., 1.]]).unwrap();+ assert!((moved.face_plane(floor).unwrap().origin.z - (300. + thickness)).abs() < 1e-9);+ assert!(matches!(moved.face_sources().unwrap().get(right), Some(Some(FaceSource::ShellPlanar { producer: Some(9), inner: false, .. }))));+ assert!(moved.face_plane(right).unwrap().normal().dot(Vec3::Y) > 0.999999);+ let raw = cup.tessellate(0.01).unwrap();+ let display = cup.display_mesh(0.01).unwrap();+ let cylindrical: Vec<_> = cup+ .solid+ .face_iter()+ .enumerate()+ .filter_map(|(i, f)| {+ let crate::FaceSurface::Cylinder { radius, .. } = crate::face_surface(&cup, i)? else { return None };+ let lo = f.vertex_iter().map(|v| v.point().z).fold(f64::INFINITY, f64::min);+ let hi = f.vertex_iter().map(|v| v.point().z).fold(f64::NEG_INFINITY, f64::max);+ Some((i, radius, lo, hi))+ })+ .collect();+ eprintln!("roundedShell width{width} thickness{thickness} raw{} cylindrical roles{cylindrical:?}", cup.solid.face_iter().count());+ let mut corner_joins = 0;+ for (edge, adjacent) in raw.edge_faces.iter().enumerate() {+ let [a, b] = adjacent.as_slice() else { continue };+ if raw.edges[edge].iter().all(|p| (p.z - thickness).abs() < 1e-8)+ && cylindrical.iter().any(|(i, r, _, _)| *i == *a as usize && (*r - 6.).abs() < 1e-6)+ && cylindrical.iter().any(|(i, r, _, _)| *i == *b as usize && (*r - 6.).abs() < 1e-6)+ {+ corner_joins += 1;+ assert!(display.seams[edge], "existing cylindrical corner joins must not draw a floor-height arc");+ }+ }+ assert_eq!(corner_joins, 0, "no physical lower corner strip remains");+ assert_eq!(cup.face_count(), 19);+ let outer: Vec<_> = cylindrical.iter().filter(|(_, r, _, _)| (*r - 6.).abs() < 1e-6).collect();+ assert_eq!(outer.len(), 4);+ assert!(outer.iter().all(|(i, _, _, _)| cup.face_was_coalesced(*i) && moved.face_was_coalesced(*i)));+ assert!(outer.iter().all(|(_, _, lo, hi)| lo.abs() < 1e-9 && (*hi - 30.).abs() < 1e-9));++ for axis in 0..2 {+ for high in [false, true] {+ let matching: Vec<_> = sources.iter().enumerate().filter_map(|(i,s)| matches!(s,Some(FaceSource::ShellPlanar {inner:false,source,..}) if matches!(source.as_ref(),FaceSource::Box {axis:a,high:h,..} if *a==axis && *h==high)).then_some(i)).collect();+ assert_eq!(matching.len(), 1, "each straight exterior wall is one actual face");+ let face = cup.solid.face_iter().nth(matching[0]).unwrap();+ let z: Vec<_> = face.vertex_iter().map(|v| v.point().z).collect();+ assert!(z.iter().any(|z| z.abs() < 1e-9));+ assert!(z.iter().any(|z| (*z - 30.).abs() < 1e-9));+ }+ }+ assert!(display.contains(Vec3::new(width / 2. - thickness / 2., 0., thickness / 2.)));+ assert!(display.contains(Vec3::new(width / 2. - thickness / 2., 0., 15.)));+ assert!(!display.contains(Vec3::new(0., 0., 15.)));+ assert_eq!(raw.measure().volume, display.measure().volume);+ let expected = (width * 60. - (4. - std::f64::consts::PI) * 36.) * 30.+ - ((width - 2. * thickness) * (60. - 2. * thickness) - (4. - std::f64::consts::PI) * (6. - thickness).powi(2)) * (30. - thickness);+ assert!((cup.tessellate(1e-4).unwrap().measure().volume - expected).abs() < 0.2);+ let imported = crate::step_import(&crate::step_export(&[&cup], "regularized rounded shell").unwrap()).unwrap();+ assert!(imported.warnings.is_empty());+ let copy = &imported.bodies[0].body;+ assert_eq!(copy.face_count(), 19);+ // STEP may additionally coalesce cylindrical corner patches. The+ // certified planar wall topology itself must survive unchanged.+ for (axis, coordinate) in [(Vec3::X, width / 2.), (-Vec3::X, width / 2.), (Vec3::Y, 30.), (-Vec3::Y, 30.)] {+ let walls: Vec<_> = copy+ .solid+ .face_iter()+ .filter(|f| actual_plane(f).is_some_and(|p| p.normal().dot(axis) > 0.999 && (p.origin.dot(axis) - coordinate).abs() < 1e-8))+ .collect();+ assert_eq!(walls.len(), 1);+ let z: Vec<_> = walls[0].vertex_iter().map(|v| v.point().z).collect();+ assert!(z.iter().any(|z| z.abs() < 1e-8));+ assert!(z.iter().any(|z| (*z - 30.).abs() < 1e-8));+ }+ let copy_mesh = copy.tessellate(1e-4).unwrap();+ assert!((copy_mesh.measure().volume - expected).abs() < 0.2);+ assert!(copy_mesh.contains(Vec3::new(width / 2. - thickness / 2., 0., 15.)));+ assert!(!copy_mesh.contains(Vec3::new(0., 0., 15.)));+ }+ }+ #[test]+ fn simple_shell_has_one_full_height_face_per_outer_wall_and_exports_that_topology() {+ let source = box_solid(Vec3::ZERO, Vec3::new(40., 30., 20.)).unwrap().with_box_certificate(1).unwrap();+ let pending = shell(&source, &[Vec3::new(20., 15., 20.)], 2.).unwrap();+ let cup = pending.clone().with_shell_certificate(2).unwrap();+ assert_eq!(cup.solid.face_iter().count(), 11);+ let mesh = cup.tessellate(0.01).unwrap();+ assert!((mesh.measure().volume - (40. * 30. * 20. - 36. * 26. * 18.)).abs() < 1e-6);+ assert!(mesh.contains(Vec3::new(20., 1., 1.)));+ assert!(mesh.contains(Vec3::new(20., 1., 10.)));+ assert!(!mesh.contains(Vec3::new(20., 15., 10.)));+ let imported = crate::step_import(&crate::step_export(&[&cup], "regularized shell").unwrap()).unwrap();+ assert!(imported.warnings.is_empty());+ let copy = &imported.bodies[0].body;+ assert_eq!(copy.solid.face_iter().count(), 11);+ assert!((copy.tessellate(0.01).unwrap().measure().volume - mesh.measure().volume).abs() < 1e-6);+ }+ #[test]+ fn coincident_competing_source_planes_and_tool_planes_stay_unknown() {+ let a = box_solid(Vec3::ZERO, Vec3::new(10., 10., 10.)).unwrap().with_box_certificate(1).unwrap();+ let b = box_solid(Vec3::new(20., 0., 0.), Vec3::new(30., 10., 10.)).unwrap().with_box_certificate(2).unwrap();+ let mut shells = a.solid.boundaries().to_vec();+ shells.extend(b.solid.boundaries().iter().cloned());+ let mut combined = Body::new(mt::Solid::try_new(shells).unwrap()).unwrap();+ combined.face_sources = Some(Arc::new(a.face_sources().unwrap().iter().chain(b.face_sources().unwrap()).cloned().collect()));+ let result = a.clone().with_preserved_planar_sources(&combined).unwrap();+ for (i, face) in result.solid.face_iter().enumerate() {+ if actual_plane(face).unwrap().normal().dot(Vec3::Z).abs() > 0.999 {+ assert!(result.face_sources().unwrap()[i].is_none());+ }+ }+ let mut mixed = combined.clone();+ mixed.face_sources =+ Some(Arc::new(a.face_sources().unwrap().iter().cloned().chain(std::iter::repeat_n(None, b.solid.face_iter().count())).collect()));+ let guarded = a.clone().with_preserved_planar_sources(&mixed).unwrap();+ for (i, face) in guarded.solid.face_iter().enumerate() {+ if actual_plane(face).unwrap().normal().dot(Vec3::Z).abs() > 0.999 {+ assert!(guarded.face_sources().unwrap()[i].is_none(), "uncertified competing support must not gain identity");+ }+ }+ let cup = shell(&a, &[Vec3::new(5., 5., 10.)], 1.).unwrap().with_shell_certificate(3).unwrap();+ let tool = box_solid(Vec3::new(2., 2., 1.), Vec3::new(4., 4., 3.)).unwrap();+ let preserved = cup.clone().with_preserved_boolean_planar_sources(&cup, &tool, false).unwrap();+ for (i, face) in preserved.solid.face_iter().enumerate() {+ let Some(p) = actual_plane(face) else { continue };+ if p.normal().dot(Vec3::Z) > 0.999 && (p.origin.z - 1.).abs() < 1e-9 {+ assert!(preserved.face_sources().unwrap()[i].is_none());+ }+ }+ }++ #[test]+ fn pocket_cut_removes_internal_wall_faces_in_actual_topology() {+ use solvecraft_geom::{Loop2, Region2, Vec2};+ let region = Region2 {+ outer: Loop2::polygon(&[Vec2::new(-30., -27.), Vec2::new(30., -27.), Vec2::new(30., 27.), Vec2::new(-30., 27.)]),+ holes: vec![],+ };+ let original = crate::extrude(&Plane::XY, std::slice::from_ref(®ion), 0., 10.).unwrap().pop().unwrap();+ let curves: Vec<_> = original+ .face_sources()+ .unwrap()+ .iter()+ .enumerate()+ .map(|(i, source)| matches!(source, Some(FaceSource::ExtrudeSide { .. })).then(|| format!("l{i}")))+ .collect();+ let original = original.with_extrude_certificates(2, 1, &curves).unwrap();+ let (x, y) = (24.73317426966596, 21.733174269665962);+ let cutter = box_solid(Vec3::new(-x, -y, 1.), Vec3::new(x, y, 10.)).unwrap();+ let pocket = crate::boolean(&original, &cutter, crate::BoolOp::Cut).unwrap().unwrap();+ let raw = pocket.tessellate(0.01).unwrap();+ let display = pocket.display_mesh(0.01).unwrap();+ let sources = pocket.face_sources().unwrap();+ assert_eq!(pocket.solid.face_iter().count(), 11, "four outer walls, four inner walls, rim, floor, bottom");+ let sides: Vec<_> =+ sources.iter().enumerate().filter_map(|(i, s)| matches!(s, Some(FaceSource::CertifiedExtrudeSide { .. })).then_some(i)).collect();+ assert_eq!(sides.len(), 4);+ for i in sides {+ let face = pocket.solid.face_iter().nth(i).unwrap();+ let z: Vec<_> = face.vertex_iter().map(|v| v.point().z).collect();+ assert!(z.iter().any(|z| z.abs() < 1e-9));+ assert!(z.iter().any(|z| (*z - 10.).abs() < 1e-9));+ assert!(!face.edge_iter().any(|e| (e.front().point().z - 1.).abs() < 1e-9 && (e.back().point().z - 1.).abs() < 1e-9));+ }+ assert!(display.contains(Vec3::new(0., 0., 0.5)));+ assert!(!display.contains(Vec3::new(0., 0., 5.)));+ assert!(display.contains(Vec3::new(28., 0., 5.)));+ assert!((display.measure().volume - (60. * 54. * 10. - 4. * x * y * 9.)).abs() < 1e-7);+ assert_eq!(raw.measure().volume, display.measure().volume);+ let imported = crate::step_import(&crate::step_export(&[&pocket], "regularized pocket").unwrap()).unwrap();+ assert!(imported.warnings.is_empty());+ let copy = &imported.bodies[0].body;+ assert_eq!(copy.solid.face_iter().count(), 11);+ let copy_mesh = copy.tessellate(0.01).unwrap();+ assert!((copy_mesh.measure().volume - raw.measure().volume).abs() < 1e-6);+ assert!(copy_mesh.contains(Vec3::new(0., 0., 0.5)));+ assert!(!copy_mesh.contains(Vec3::new(0., 0., 5.)));+ let competing = box_solid(Vec3::new(30., -1., 0.), Vec3::new(31., 1., 2.)).unwrap();+ let guarded = pocket.clone().with_preserved_boolean_planar_sources(&pocket, &competing, true).unwrap();+ for (index, source) in guarded.face_sources().unwrap().iter().enumerate() {+ if pocket.face_plane(index).is_some_and(|p| p.normal().dot(Vec3::X) > 0.999 && (p.origin.x - 30.).abs() < 1e-9) {+ assert!(source.is_none(), "competing tool plane cannot retain source identity");+ }+ }+ }+}diff --git a/crates/kernel/src/polyhedron.rs b/crates/kernel/src/polyhedron.rsindex e35f97dae5..4c772f0f2e 100644--- a/crates/kernel/src/polyhedron.rs+++ b/crates/kernel/src/polyhedron.rs@@ -130,6 +130,10 @@ pub fn planar_convex(b: &Body) -> Result<Vec<(HalfSpace, Vec3)>> {/// Hollow a convex planar body: walls of `thickness` inside, faces near `open` removed.pub fn shell(b: &Body, open: &[Vec3], thickness: f64) -> Result<Body> {+ shell_impl(b, open, thickness)?.with_shell_planar_sources(b, thickness, open)+}++fn shell_impl(b: &Body, open: &[Vec3], thickness: f64) -> Result<Body> {b.require_brep("shell")?;if !(thickness.is_finite() && thickness > 1e-6) {return Err(KernelError::Invalid("shell thickness must be positive".into()));diff --git a/crates/kernel/src/prism.rs b/crates/kernel/src/prism.rsindex cbab7a5925..6c06877c9b 100644--- a/crates/kernel/src/prism.rs+++ b/crates/kernel/src/prism.rs@@ -683,12 +683,17 @@ fn sew_stack(plane: &Plane, d: Vec3, pa: &Prism, pb: &Prism, tol: f64) -> Option};slabs.push(oriented(&s));}- sew_sections(plane, d, &levels, &slabs, tol)+ sew_sections(plane, d, &levels, &slabs, tol, false)}/// Sew the exact sections between successive levels, including empty gaps.-fn sew_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<Region2>], tol: f64) -> Option<Result<Body>> {- if levels.len() != slabs.len() + 1 || slabs.len() > 128 || plane.normal().dot(d) < 1. - 1e-12 {+fn sew_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<Region2>], tol: f64, coalesce: bool) -> Option<Result<Body>> {+ if levels.len() != slabs.len() + 1+ || slabs.len() > 128+ || plane.normal().dot(d) < 1. - 1e-12+ || levels.iter().any(|z| !z.is_finite())+ || levels.windows(2).any(|z| z[0] >= z[1])+ {return None;}let mut blocks = Vec::new();@@ -732,7 +737,7 @@ fn sew_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<Region2>],pieces.push(piece);}} else {- let piece = sew_connected_sections(plane, d, &levels[first..=end], &slabs[first..end], tol)+ let piece = sew_connected_sections(plane, d, &levels[first..=end], &slabs[first..end], tol, coalesce).ok_or_else(|| KernelError::Failed("stepped prism construction failed".into()))??;remaining_faces =remaining_faces.checked_sub(piece.face_count()).ok_or_else(|| KernelError::Failed("prism output face budget".into()))?;@@ -765,8 +770,18 @@ fn sew_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<Region2>],})())}+/// Stable exact identity for the bounded analytic segment subset.+fn wall_key(s: &Seg2) -> Option<[u64; 6]> {+ let bits = |v: f64| v.is_finite().then(|| if v == 0. { 0 } else { v.to_bits() });+ match s {+ Seg2::Line { a, b } => Some([0, bits(a.x)?, bits(a.y)?, bits(b.x)?, bits(b.y)?, 0]),+ Seg2::Arc { center, radius, start, sweep } => Some([1, bits(center.x)?, bits(center.y)?, bits(*radius)?, bits(*start)?, bits(*sweep)?]),+ _ => None,+ }+}+/// A genuinely stepped connected axial block has no single extrusion footprint.-fn sew_connected_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<Region2>], tol: f64) -> Option<Result<Body>> {+fn sew_connected_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<Region2>], tol: f64, coalesce: bool) -> Option<Result<Body>> {use crate::sew::{EdgeSpec, FaceSpec, SurfSpec};// Faces at each level: up where the slab below sticks out, down where the one above does.let diff = |x: &[Region2], y: &[Region2]| -> Option<Vec<Region2>> {@@ -800,30 +815,61 @@ fn sew_connected_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<R_ => EdgeSpec::Line { a: at(sg.start(), z), b: at(sg.end(), z) },}};- let mut faces: Vec<FaceSpec> = Vec::new();- for (i, s) in slabs.iter().enumerate() {- let (z0, z1) = (*levels.get(i)?, *levels.get(i + 1)?);- for lp in loops_of(s) {+ // Exact oriented generated segments alone define a run. No support fitting,+ // proximity matching, or old face lineage is used here.+ let mut runs: Vec<(usize, usize, Seg2)> = Vec::new();+ let mut last = std::collections::BTreeMap::new();+ let mut remaining = MAX_PLANAR_SEGMENTS * 2;+ for (i, slab) in slabs.iter().enumerate() {+ for lp in loops_of(slab) {for sg0 in &lp.segs {for sg in split_seg(sg0, &pts, tol)? {- let (a, b) = (sg.start(), sg.end());- let lp3 = vec![- edge(&sg, z0),- EdgeSpec::Line { a: at(b, z0), b: at(b, z1) },- edge(&sg.reversed(), z1),- EdgeSpec::Line { a: at(a, z1), b: at(a, z0) },- ];- let tangent = plane.dir_to_world(sg.derivative(0.5));- let outward = tangent.cross(d).normalized()?;- let surface = match sg {- Seg2::Arc { .. } => SurfSpec::Extruded { a: at(a, z0), b: at(b, z0), mid: at(sg.point_at(0.5), z0), dir: d * (z1 - z0) },- _ => SurfSpec::Plane,- };- faces.push(FaceSpec { loops: vec![lp3], surface, probe: Some((at(sg.point_at(0.5), (z0 + z1) / 2.0), outward)) });+ remaining = remaining.checked_sub(1)?;+ let key = wall_key(&sg)?;+ if coalesce {+ if let Some(&index) = last.get(&key) {+ let run: &mut (usize, usize, Seg2) = runs.get_mut(index)?;+ if run.1 == i {+ run.1 = i + 1;+ continue;+ }+ // Duplicate oriented boundaries in one slab are not+ // a valid reason to reconstruct a larger wall.+ if run.1 == i + 1 {+ return None;+ }+ }+ last.insert(key, runs.len());+ }+ runs.push((i, i + 1, sg));}}}}+ let mut faces: Vec<FaceSpec> = Vec::new();+ let mut sources = Vec::new();+ for (first, end, sg) in runs {+ let (z0, z1) = (levels[first], levels[end]);+ let (a, b) = (sg.start(), sg.end());+ let mut lp3 = Vec::with_capacity(2 + 2 * (end - first));+ lp3.push(edge(&sg, z0));+ // Keep station vertices at both ends: neighboring stepped walls/caps+ // must share complete edges rather than create T-junctions.+ for k in first..end {+ lp3.push(EdgeSpec::Line { a: at(b, levels[k]), b: at(b, levels[k + 1]) });+ }+ lp3.push(edge(&sg.reversed(), z1));+ for k in (first..end).rev() {+ lp3.push(EdgeSpec::Line { a: at(a, levels[k + 1]), b: at(a, levels[k]) });+ }+ let outward = plane.dir_to_world(sg.derivative(0.5)).cross(d).normalized()?;+ let surface = match sg {+ Seg2::Arc { .. } => SurfSpec::Extruded { a: at(a, z0), b: at(b, z0), mid: at(sg.point_at(0.5), z0), dir: d * (z1 - z0) },+ _ => SurfSpec::Plane,+ };+ faces.push(FaceSpec { loops: vec![lp3], surface, probe: Some((at(sg.point_at(0.5), (z0 + z1) / 2.0), outward)) });+ sources.push((end > first + 1).then_some(crate::FaceSource::ExtrudeSide { segment: sg, plane: None, coalesced: true }));+ }for (z, up, rs) in &caps {for r in rs {let mut loops = Vec::new();@@ -836,9 +882,10 @@ fn sew_connected_sections(plane: &Plane, d: Vec3, levels: &[f64], slabs: &[Vec<Rloops.push(segs.iter().map(|sg| edge(sg, *z)).collect::<Vec<_>>());}faces.push(FaceSpec { loops, surface: SurfSpec::Plane, probe: None });+ sources.push(None);}}- Some(crate::sew::sew_touching(&faces))+ Some(crate::sew::sew_touching_with_sources(&faces, &sources))}fn simple_prism_boolean(a: &Body, b: &Body, op: BoolOp) -> Option<Result<Option<Body>>> {@@ -1055,7 +1102,19 @@ fn stack_boolean(a: &Body, b: &Body, op: BoolOp) -> Option<Result<Option<Body>>>if slabs.iter().all(Vec::is_empty) {return Some(Ok(None));}- sew_sections(&plane, d, &levels, &slabs, tol).map(|r| r.map(Some))+ sew_sections(+ &plane,+ d,+ &levels,+ &slabs,+ tol,+ op == BoolOp::Cut+ && a.split_keep().is_empty()+ && b.split_keep().is_empty()+ && a.paint().is_none_or(|p| p.faces.is_empty())+ && b.paint().is_none_or(|p| p.faces.is_empty()),+ )+ .map(|r| r.map(Some))}pub(crate) fn prism_boolean(a: &Body, b: &Body, op: BoolOp) -> Option<Result<Option<Body>>> {@@ -1144,7 +1203,12 @@ mod planar_tests {assert!(mesh.contains(Vec3::new(21., 21., 3.)));assert!(!mesh.contains(Vec3::new(25., 25., 3.)));assert!(mesh.contains(Vec3::new(25., 25., 22.)));- assert!(lump.face_sources().is_none_or(|s| s.iter().all(Option::is_none)), "genuinely stepped geometry remains uncertified");+ assert!(+ lump.face_sources().is_none_or(|s| s+ .iter()+ .all(|s| s.is_none() || matches!(s, Some(crate::FaceSource::ExtrudeSide { coalesced: true, plane: None, .. })))),+ "genuinely stepped geometry has no durable certificate"+ );assert!((mesh.measure().volume - (18. * (100. - 4. * std::f64::consts::PI) + 500.)).abs() < 0.02);}}@@ -1152,6 +1216,72 @@ mod planar_tests {assert_eq!(crate::step_export(&[&tool], "tool").unwrap(), before_tool);assert_eq!(crate::step_export(&[&roof], "roof").unwrap(), before_roof);}+ #[test]+ fn contiguous_analytic_walls_remove_faces_but_retain_vertical_stations() {+ for curved in [false, true] {+ let outer = if curved {+ Region2 { outer: Loop2::circle(Vec2::ZERO, 10.), holes: vec![] }+ } else {+ rectangle(Vec2::new(-10., -10.), Vec2::new(10., 10.))+ };+ let mut upper = outer.clone();+ upper.holes.push(if curved {+ Loop2::circle(Vec2::ZERO, 5.).reversed()+ } else {+ rectangle(Vec2::new(-5., -5.), Vec2::new(5., 5.)).outer.reversed()+ });+ let slabs = vec![vec![outer], vec![upper]];+ let old = sew_sections(&Plane::XY, Vec3::Z, &[0., 2., 20.], &slabs, 1e-7, false).unwrap().unwrap();+ let merged = sew_sections(&Plane::XY, Vec3::Z, &[0., 2., 20.], &slabs, 1e-7, true).unwrap().unwrap();+ let count = if curved { 2 } else { 4 };+ assert_eq!(old.face_count() - merged.face_count(), count);+ let marked: Vec<_> = merged.solid.face_iter().enumerate().filter(|(i, _)| merged.face_was_coalesced(*i)).collect();+ assert_eq!(marked.len(), count);+ for (_, face) in marked {+ assert_eq!(face.boundaries()[0].len(), 6, "all axial station vertices are retained");+ let heights: Vec<_> = face.vertex_iter().map(|v| v.point().z).collect();+ for z in [0., 2., 20.] {+ assert!(heights.contains(&z));+ }+ }+ assert!(old.face_sources().is_none_or(|s| s.iter().all(Option::is_none)));+ let expected = if curved { std::f64::consts::PI * (100. * 20. - 25. * 18.) } else { 400. * 20. - 100. * 18. };+ let mesh = merged.tessellate(1e-5).unwrap();+ assert!((mesh.measure().volume - expected).abs() < 0.03);+ assert!(mesh.contains(Vec3::new(0., 0., 1.)));+ assert!(!mesh.contains(Vec3::new(0., 0., 10.)));+ assert!(merged.validity().is_empty());+ assert_ne!(wall_key(&slabs[0][0].outer.segs[0]), wall_key(&slabs[0][0].outer.segs[0].reversed()));+ }+ }++ #[test]+ fn cut_run_coalescing_respects_authored_splits_and_face_paint() {+ let region = Region2 { outer: Loop2::circle(Vec2::ZERO, 10.), holes: vec![] };+ let tool_region = Region2 { outer: Loop2::circle(Vec2::ZERO, 5.), holes: vec![] };+ let stock = crate::extrude(&Plane::XY, &[region], 0., 20.).unwrap().pop().unwrap();+ let cutter = crate::extrude(&Plane::XY, &[tool_region], 2., 22.).unwrap().pop().unwrap();+ let merged = stack_boolean(&stock, &cutter, BoolOp::Cut).unwrap().unwrap().unwrap();+ let protected = [+ stock.clone().with_split_lines(Some(std::sync::Arc::new(vec![vec![Vec3::new(10., 0., 0.), Vec3::new(10., 0., 20.)]]))),+ stock.with_paint(Some(crate::Paint { opacity: 1., faces: vec![crate::FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }] })),+ ];+ for input in protected {+ let output = stack_boolean(&input, &cutter, BoolOp::Cut).unwrap().unwrap().unwrap();+ assert_eq!(output.face_count(), merged.face_count() + 2);+ assert!((0..output.face_count()).all(|i| !output.face_was_coalesced(i)));+ // Independent circular chord-volume bound: 2*pi*(10*20+5*18)*1e-5 < .019.+ let expected = std::f64::consts::PI * (100. * 20. - 25. * 18.);+ for body in [&output, &merged] {+ let mesh = body.tessellate(1e-5).unwrap();+ assert!((mesh.measure().volume - expected).abs() < 0.03);+ assert!(mesh.contains(Vec3::new(0., 0., 1.)));+ assert!(!mesh.contains(Vec3::new(0., 0., 10.)));+ assert!(mesh.contains(Vec3::new(7., 0., 10.)));+ }+ }+ }+#[test]fn annular_inward_tool_recovers_exact_stacks_before_cap_policy() {let plane = Plane::XY;diff --git a/crates/kernel/src/sew.rs b/crates/kernel/src/sew.rsindex 25c7a9387c..0d00d8c266 100644--- a/crates/kernel/src/sew.rs+++ b/crates/kernel/src/sew.rs@@ -97,13 +97,16 @@ impl Cache {/// Sew the faces into a closed solid.pub fn sew(faces: &[FaceSpec]) -> Result<Body> {- sew_impl(faces, false)+ sew_impl(faces, false, None)}/// Separate boundary sheets at a shared geometric edge without moving it.-/// The face adjacency must still describe one connected solid boundary.-pub(crate) fn sew_touching(faces: &[FaceSpec]) -> Result<Body> {- sew_impl(faces, true)+/// Optional transient sources follow only unchanged produced face identities.+pub(crate) fn sew_touching_with_sources(faces: &[FaceSpec], sources: &[Option<crate::FaceSource>]) -> Result<Body> {+ if sources.len() != faces.len() {+ return Err(KernelError::Invalid("sew source alignment".into()));+ }+ sew_impl(faces, true, Some(sources))}type EdgeUse = (usize, usize, usize);@@ -347,7 +350,7 @@ fn split_vertex_fans(faces: Vec<mt::Face>) -> Result<Vec<mt::Face>> {.collect()}-fn sew_impl(faces: &[FaceSpec], touching: bool) -> Result<Body> {+fn sew_impl(faces: &[FaceSpec], touching: bool, sources: Option<&[Option<crate::FaceSource>]>) -> Result<Body> {if faces.len() < 4 || faces.len() > 200_000 {return Err(KernelError::Invalid("a solid needs 4…200000 faces".into()));}@@ -396,6 +399,11 @@ fn sew_impl(faces: &[FaceSpec], touching: bool) -> Result<Body> {};out.push(face);}+ let source_ids: HashMap<_, _> = out+ .iter()+ .enumerate()+ .filter_map(|(i, f)| sources.and_then(|s| s.get(i)).and_then(Option::as_ref).map(|s| (f.id(), (f.orientation(), s))))+ .collect();if !sheets.is_empty() && !faces_connected(&out) {return Err(KernelError::Invalid("sew: bodies touch only along an edge".into()));}@@ -404,7 +412,10 @@ fn sew_impl(faces: &[FaceSpec], touching: bool) -> Result<Body> {}let shells = closed_components(out)?;let solid = Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("sew: the faces do not close: {e}")))?;- Body::new(solid)+ let body = Body::new(solid)?;+ let mapped =+ body.solid.face_iter().map(|f| source_ids.get(&f.id()).filter(|(o, _)| *o == f.orientation()).map(|(_, s)| (*s).clone())).collect();+ Ok(body.with_face_sources(sources.map(|_| std::sync::Arc::new(mapped))))})}diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rsindex 0cee7341ac..a83be2680e 100644--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@ -1273,7 +1273,8 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {update_fill_cells(app, &mut d);let t = Tokens::get();let vp = app.viewport.rect.unwrap_or_else(|| ctx.content_rect());- let anchor = egui::pos2(vp.right(), vp.top() + crate::viewport::AXIS_VIEW_CLEARANCE);+ let top = (vp.top() + crate::viewport::AXIS_VIEW_CLEARANCE).min((vp.bottom() - 360.0).max(vp.top()));+ let anchor = egui::pos2(vp.right(), top);let mut keep = true;let mut ok = false;let mut applied = false;@@ -1303,7 +1304,6 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {width,).frame(frame)- .scroll([false, true]).open(&mut keep).show(ctx, |ui| {ui.spacing_mut().text_edit_width = FIELD_W;@@ -1332,596 +1332,604 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {return;}ui.add_space(2.0);- // Configuration tables own their column widths and scrolling; the two-column form- // grid would squeeze their row names and action buttons into a label-sized cell.- if let Kind::Motion(k @ crate::dialogs_motion::Mo::Configurations { .. }) = &mut d.kind {- enter |= crate::dialogs_motion::rows(app, ui, k, &mut d.inputs);- }- egui::Grid::new("sc_dialog_grid").num_columns(2).spacing(vec2(10.0, 8.0)).show(ui, |ui| {- if matches!(&d.kind, Kind::Motion(crate::dialogs_motion::Mo::Configurations { .. })) {- return;- }- placement_row(&mut d, ui);- input_rows(&mut d, ui);- match &mut d.kind {- Kind::Sketch => {- if d.error.is_some()- && let Some(selection @ Sel::Face { .. }) = d.inputs.first().and_then(|i| i.items.first())- {- row_label(ui, "Attachment");- ui.label("This face cannot provide a durable attachment. Choose another face or explicitly use a fixed plane.");- ui.end_row();- row_label(ui, "");- if ui.button("Use fixed plane").clicked()- && let Some(mut plane) = crate::sketch_attachment_ui::face_plane(app, selection)+ // A sizing pass initially offers almost no height to an auto-sized window.+ // Give only the fields a viewport-derived scroll budget; header and actions+ // stay visible, while short forms still shrink to their natural height.+ let vertical_frame = frame.inner_margin.topf() + frame.inner_margin.bottomf() + 2.0 * frame.stroke.width;+ let footer_height = ui.spacing().interact_size.y.max(24.0) + 6.0 + ui.spacing().item_spacing.y;+ let fields_height = (vp.bottom() - anchor.y - 8.0 - vertical_frame - ui.min_rect().height() - footer_height).max(1.0);+ egui::ScrollArea::vertical().id_salt("feature_fields").min_scrolled_height(fields_height).max_height(fields_height).show(ui, |ui| {+ // Configuration tables own their column widths and scrolling; the two-column form+ // grid would squeeze their row names and action buttons into a label-sized cell.+ if let Kind::Motion(k @ crate::dialogs_motion::Mo::Configurations { .. }) = &mut d.kind {+ enter |= crate::dialogs_motion::rows(app, ui, k, &mut d.inputs);+ }+ egui::Grid::new("sc_dialog_grid").num_columns(2).spacing(vec2(10.0, 8.0)).show(ui, |ui| {+ if matches!(&d.kind, Kind::Motion(crate::dialogs_motion::Mo::Configurations { .. })) {+ return;+ }+ placement_row(&mut d, ui);+ input_rows(&mut d, ui);+ match &mut d.kind {+ Kind::Sketch => {+ if d.error.is_some()+ && let Some(selection @ Sel::Face { .. }) = d.inputs.first().and_then(|i| i.items.first()){- plane["fixed"] = json!(true);- match app.run("sketch.create", json!({"plane":plane})) {- Ok(_) => {- app.pre_sketch_cam = Some(app.cam);- look_at_sketch(app);- cancel = true;+ row_label(ui, "Attachment");+ ui.label("This face cannot provide a durable attachment. Choose another face or explicitly use a fixed plane.");+ ui.end_row();+ row_label(ui, "");+ if ui.button("Use fixed plane").clicked()+ && let Some(mut plane) = crate::sketch_attachment_ui::face_plane(app, selection)+ {+ plane["fixed"] = json!(true);+ match app.run("sketch.create", json!({"plane":plane})) {+ Ok(_) => {+ app.pre_sketch_cam = Some(app.cam);+ look_at_sketch(app);+ cancel = true;+ }+ Err(error) => d.error = Some(error),}- Err(error) => d.error = Some(error),}+ ui.end_row();}- ui.end_row();}- }- Kind::Extrude { distance, direction, operation, auto_op, distance2, taper, taper_present, to_offset, start, all } => {- row_label(ui, "Start");- let old = if object_on(&d.inputs, FROM_OBJECT) { 2 } else { usize::from(!start.is_empty()) };- let mut st = old;- combo(ui, "ex_start", &["Profile Plane", "Offset", "From Object"], &mut st);- if st != old {- set_object(&mut d.inputs, &mut d.active, FROM_OBJECT, st == 2);- if st == 1 && start.is_empty() {- *start = "5 mm".into();- }- if st == 0 {- start.clear();+ Kind::Extrude { distance, direction, operation, auto_op, distance2, taper, taper_present, to_offset, start, all } => {+ row_label(ui, "Start");+ let old = if object_on(&d.inputs, FROM_OBJECT) { 2 } else { usize::from(!start.is_empty()) };+ let mut st = old;+ combo(ui, "ex_start", &["Profile Plane", "Offset", "From Object"], &mut st);+ if st != old {+ set_object(&mut d.inputs, &mut d.active, FROM_OBJECT, st == 2);+ if st == 1 && start.is_empty() {+ *start = "5 mm".into();+ }+ if st == 0 {+ start.clear();+ }}- }- ui.end_row();- if st != 0 {- row_label(ui, "Offset");- enter |= field(ui, start);ui.end_row();- }- row_label(ui, "Direction");- // One Side, Two Sides, Symmetric (a flip is a negative distance).- let order = [0usize, TWO_SIDES, 2];- let mut pos = order.iter().position(|o| o == direction).unwrap_or(0);- combo(ui, "ex_dir", &["One Side", "Two Sides", "Symmetric"], &mut pos);- if pos != order.iter().position(|o| o == direction).unwrap_or(0) {- *direction = order.get(pos).copied().unwrap_or(0);- }- ui.end_row();- if *direction < 2 {- row_label(ui, "Reverse");- let mut reverse = *direction == 1;- if ui.checkbox(&mut reverse, "Reverse Direction").changed() {- *direction = usize::from(reverse);+ if st != 0 {+ row_label(ui, "Offset");+ enter |= field(ui, start);+ ui.end_row();+ }+ row_label(ui, "Direction");+ // One Side, Two Sides, Symmetric (a flip is a negative distance).+ let order = [0usize, TWO_SIDES, 2];+ let mut pos = order.iter().position(|o| o == direction).unwrap_or(0);+ combo(ui, "ex_dir", &["One Side", "Two Sides", "Symmetric"], &mut pos);+ if pos != order.iter().position(|o| o == direction).unwrap_or(0) {+ *direction = order.get(pos).copied().unwrap_or(0);}ui.end_row();- }- row_label(ui, "Extent Type");- let cur = if to_object_on(&d.inputs) { 1 } else { usize::from(*all) * 2 };- let mut ext = cur;- combo(ui, "ex_ext", &["Distance", "To Object", "All"], &mut ext);- *all = ext == 2;- set_to_object(&mut d.inputs, &mut d.active, ext == 1);- ui.end_row();- if ext == 0 {- row_label(ui, "Distance");- enter |= field(ui, distance);- ui.end_row();- if *direction == TWO_SIDES {- row_label(ui, "Distance 2");- enter |= field(ui, distance2);+ if *direction < 2 {+ row_label(ui, "Reverse");+ let mut reverse = *direction == 1;+ if ui.checkbox(&mut reverse, "Reverse Direction").changed() {+ *direction = usize::from(reverse);+ }ui.end_row();}- }- if ext == 1 {- row_label(ui, "To Offset");- enter |= field(ui, to_offset);+ row_label(ui, "Extent Type");+ let cur = if to_object_on(&d.inputs) { 1 } else { usize::from(*all) * 2 };+ let mut ext = cur;+ combo(ui, "ex_ext", &["Distance", "To Object", "All"], &mut ext);+ *all = ext == 2;+ set_to_object(&mut d.inputs, &mut d.active, ext == 1);ui.end_row();- }- if *direction < 2 {- row_label(ui, "Taper Angle");- let before = taper.clone();- enter |= field(ui, taper);- if *taper != before {- *taper_present = !taper.trim().is_empty();+ if ext == 0 {+ row_label(ui, "Distance");+ enter |= field(ui, distance);+ ui.end_row();+ if *direction == TWO_SIDES {+ row_label(ui, "Distance 2");+ enter |= field(ui, distance2);+ ui.end_row();+ }+ }+ if ext == 1 {+ row_label(ui, "To Offset");+ enter |= field(ui, to_offset);+ ui.end_row();+ }+ if *direction < 2 {+ row_label(ui, "Taper Angle");+ let before = taper.clone();+ enter |= field(ui, taper);+ if *taper != before {+ *taper_present = !taper.trim().is_empty();+ }+ ui.end_row();+ }+ row_label(ui, "Operation");+ let before = *operation;+ combo(ui, "ex_op", &OP_LABELS, operation);+ // A choice made by hand sticks.+ if *operation != before {+ *auto_op = false;}ui.end_row();}- row_label(ui, "Operation");- let before = *operation;- combo(ui, "ex_op", &OP_LABELS, operation);- // A choice made by hand sticks.- if *operation != before {- *auto_op = false;- }- ui.end_row();- }- Kind::Revolve { angle, operation, .. } => {- row_label(ui, "Type");- let cur = usize::from(to_object_on(&d.inputs));- let mut ty = cur;- combo(ui, "rv_type", &["Angle", "To Object"], &mut ty);- set_to_object(&mut d.inputs, &mut d.active, ty == 1);- ui.end_row();- if ty == 0 {- // One Side, Two Sides (a second angle), Symmetric (the angle split).- row_label(ui, "Direction");- let cur = if d.extra.contains_key("angle2") {- 1- } else if d.extra.get("direction").is_some() {- 2- } else {- 0- };- let mut dir = cur;- combo(ui, "rv_dir", &["One Side", "Two Sides", "Symmetric"], &mut dir);- if dir != cur {- d.extra.remove("angle2");- d.extra.remove("direction");- match dir {- 1 => {- d.extra.insert("angle2".into(), json!("90 deg"));- }- 2 => {- d.extra.insert("direction".into(), json!("symmetric"));+ Kind::Revolve { angle, operation, .. } => {+ row_label(ui, "Type");+ let cur = usize::from(to_object_on(&d.inputs));+ let mut ty = cur;+ combo(ui, "rv_type", &["Angle", "To Object"], &mut ty);+ set_to_object(&mut d.inputs, &mut d.active, ty == 1);+ ui.end_row();+ if ty == 0 {+ // One Side, Two Sides (a second angle), Symmetric (the angle split).+ row_label(ui, "Direction");+ let cur = if d.extra.contains_key("angle2") {+ 1+ } else if d.extra.get("direction").is_some() {+ 2+ } else {+ 0+ };+ let mut dir = cur;+ combo(ui, "rv_dir", &["One Side", "Two Sides", "Symmetric"], &mut dir);+ if dir != cur {+ d.extra.remove("angle2");+ d.extra.remove("direction");+ match dir {+ 1 => {+ d.extra.insert("angle2".into(), json!("90 deg"));+ }+ 2 => {+ d.extra.insert("direction".into(), json!("symmetric"));+ }+ _ => {}}- _ => {}+ }+ ui.end_row();+ row_label(ui, "Angle");+ enter |= field(ui, angle);+ ui.end_row();+ if dir == 1 {+ row_label(ui, "Angle 2");+ enter |= extra_field(ui, &mut d.extra, "angle2", "90 deg");+ ui.end_row();}}+ row_label(ui, "Operation");+ combo(ui, "rv_op", &OP_LABELS, operation);ui.end_row();- row_label(ui, "Angle");- enter |= field(ui, angle);+ }+ Kind::Fillet { radius, chamfer, chain, ctype, distance2, angle, flip } => {+ if *chamfer {+ row_label(ui, "Chamfer Type");+ combo(ui, "ch_type", &CHAMFER_TYPES, ctype);+ ui.end_row();+ }+ let mut rtype = 0;+ if !*chamfer {+ row_label(ui, "Radius Type");+ rtype = extra_choice(+ ui,+ &mut d.extra,+ "fi_type",+ "type",+ &[("Constant", "constant"), ("Chord Length", "chord"), ("Variable", "variable")],+ );+ ui.end_row();+ }+ row_label(+ ui,+ if !*chamfer {+ match rtype {+ 1 => "Chord Length",+ 2 => "Start Radius",+ _ => "Radius",+ }+ } else if *ctype == 0 {+ "Distance"+ } else {+ "Distance 1"+ },+ );+ enter |= field(ui, radius);ui.end_row();- if dir == 1 {- row_label(ui, "Angle 2");- enter |= extra_field(ui, &mut d.extra, "angle2", "90 deg");+ if *chamfer && *ctype == 1 {+ row_label(ui, "Distance 2");+ enter |= field(ui, distance2);ui.end_row();}- }- row_label(ui, "Operation");- combo(ui, "rv_op", &OP_LABELS, operation);- ui.end_row();- }- Kind::Fillet { radius, chamfer, chain, ctype, distance2, angle, flip } => {- if *chamfer {- row_label(ui, "Chamfer Type");- combo(ui, "ch_type", &CHAMFER_TYPES, ctype);+ if *chamfer && *ctype == 2 {+ row_label(ui, "Angle");+ enter |= field(ui, angle);+ ui.end_row();+ }+ if *chamfer && *ctype > 0 {+ row_label(ui, "Flip");+ ui.checkbox(flip, "");+ ui.end_row();+ }+ if !*chamfer && rtype == 2 {+ row_label(ui, "End Radius");+ enter |= extra_field(ui, &mut d.extra, "radius2", "1 mm");+ ui.end_row();+ // Which end of the first edge takes the start radius.+ row_label(ui, "Swap Ends");+ extra_check(ui, &mut d.extra, "swap_ends");+ ui.end_row();+ // Radii between the ends: position along the edge (from the start end)+ // and radius.+ let mut mids = mid_points(&d.extra);+ let mut remove = None;+ for (k, (t, r)) in mids.iter_mut().enumerate() {+ row_label(ui, "Mid Radius");+ ui.horizontal(|ui| {+ ui.add(egui::DragValue::new(t).speed(0.01).range(0.01..=0.99).fixed_decimals(2))+ .on_hover_text("Position along the edge, 0 at the start end, 1 at the other");+ enter |= field(ui, r);+ if ui.small_button("×").on_hover_text("Remove this point").clicked() {+ remove = Some(k);+ }+ });+ ui.end_row();+ }+ if let Some(k) = remove {+ mids.remove(k);+ }+ row_label(ui, "");+ if ui.button("Add Mid Radius").clicked() && mids.len() < 20 {+ let t = if mids.is_empty() { 0.5 } else { (mids.iter().map(|m| m.0).fold(0.0, f64::max) + 1.0) * 0.5 };+ mids.push((t.min(0.99), radius.clone()));+ }+ ui.end_row();+ d.extra.insert("mid".into(), json!(mids.iter().map(|(t, r)| json!([t, r])).collect::<Vec<_>>()));+ if !mids.is_empty() {+ row_label(ui, "Smooth");+ extra_check(ui, &mut d.extra, "smooth");+ ui.end_row();+ }+ }+ row_label(ui, "Tangent Chain");+ ui.checkbox(chain, "");ui.end_row();}- let mut rtype = 0;- if !*chamfer {- row_label(ui, "Radius Type");- rtype = extra_choice(+ Kind::Shell { thickness } => {+ row_label(ui, "Tangent Chain");+ extra_check(ui, &mut d.extra, "tangent_chain");+ ui.end_row();+ let dir = d.extra.get("direction").and_then(Value::as_str).unwrap_or("inside").to_string();+ row_label(ui,- &mut d.extra,- "fi_type",- "type",- &[("Constant", "constant"), ("Chord Length", "chord"), ("Variable", "variable")],+ match dir.as_str() {+ "outside" => "Outside Thickness",+ "both" => "Thickness",+ _ => "Inside Thickness",+ },);+ enter |= field(ui, thickness);+ ui.end_row();+ row_label(ui, "Direction");+ extra_choice(ui, &mut d.extra, "sh_dir", "direction", &[("Inside", "inside"), ("Outside", "outside"), ("Both", "both")]);ui.end_row();}- row_label(- ui,- if !*chamfer {- match rtype {- 1 => "Chord Length",- 2 => "Start Radius",- _ => "Radius",- }- } else if *ctype == 0 {- "Distance"- } else {- "Distance 1"- },- );- enter |= field(ui, radius);- ui.end_row();- if *chamfer && *ctype == 1 {- row_label(ui, "Distance 2");- enter |= field(ui, distance2);+ Kind::Draft { angle } => {+ row_label(ui, "Angle");+ enter |= field(ui, angle);+ ui.end_row();+ }+ Kind::Mirror => {+ row_label(ui, "Operation");+ let mut op = usize::from(d.extra.get("combine").and_then(Value::as_bool).unwrap_or(false));+ combo(ui, "mi_op", &["New Body", "Join"], &mut op);+ d.extra.insert("combine".into(), json!(op == 1));ui.end_row();}- if *chamfer && *ctype == 2 {+ Kind::Measure { result, .. } => measure_rows(ui, result.as_ref()),+ Kind::OffsetPlane { offset } => {+ row_label(ui, "Distance");+ enter |= field(ui, offset);+ ui.end_row();+ }+ Kind::AnglePlane { angle } => {row_label(ui, "Angle");enter |= field(ui, angle);ui.end_row();}- if *chamfer && *ctype > 0 {+ Kind::Split | Kind::ReplaceFace | Kind::Remove => {}+ Kind::Rib { thickness, depth, flip, .. } => {+ row_label(ui, "Thickness");+ enter |= field(ui, thickness);+ ui.end_row();+ row_label(ui, "Depth");+ let r = ui.add(egui::TextEdit::singleline(depth).hint_text("to the next face"));+ crate::params_dialog::complete(ui, &r, depth);+ enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));+ ui.end_row();row_label(ui, "Flip");ui.checkbox(flip, "");ui.end_row();}- if !*chamfer && rtype == 2 {- row_label(ui, "End Radius");- enter |= extra_field(ui, &mut d.extra, "radius2", "1 mm");+ Kind::Emboss { depth, deboss } => {+ row_label(ui, "Depth");+ enter |= field(ui, depth);ui.end_row();- // Which end of the first edge takes the start radius.- row_label(ui, "Swap Ends");- extra_check(ui, &mut d.extra, "swap_ends");+ row_label(ui, "Type");+ let mut i = usize::from(*deboss);+ combo(ui, "emb_mode", &["Emboss", "Deboss"], &mut i);+ *deboss = i == 1;ui.end_row();- // Radii between the ends: position along the edge (from the start end)- // and radius.- let mut mids = mid_points(&d.extra);- let mut remove = None;- for (k, (t, r)) in mids.iter_mut().enumerate() {- row_label(ui, "Mid Radius");- ui.horizontal(|ui| {- ui.add(egui::DragValue::new(t).speed(0.01).range(0.01..=0.99).fixed_decimals(2))- .on_hover_text("Position along the edge, 0 at the start end, 1 at the other");- enter |= field(ui, r);- if ui.small_button("×").on_hover_text("Remove this point").clicked() {- remove = Some(k);- }- });+ ui.label("");+ ui.add(+ egui::Label::new(+ "Orthogonal line profiles tangent to one supported cylinder wrap automatically. Pick a wall to choose a target.",+ )+ .wrap(),+ );+ ui.end_row();+ }+ Kind::Align { flip } => {+ // Where on the picked face or edge to snap: as picked (a face turns to meet+ // the other, an edge at its middle), its centre, or a round one's centre.+ for (label, key) in [("From Snap", "from_snap"), ("To Snap", "to_snap")] {+ row_label(ui, label);+ extra_choice(ui, &mut d.extra, key, key, &[("As Picked", "picked"), ("Centre", "center"), ("Circle Centre", "circle")]);ui.end_row();}- if let Some(k) = remove {- mids.remove(k);- }- row_label(ui, "");- if ui.button("Add Mid Radius").clicked() && mids.len() < 20 {- let t = if mids.is_empty() { 0.5 } else { (mids.iter().map(|m| m.0).fold(0.0, f64::max) + 1.0) * 0.5 };- mids.push((t.min(0.99), radius.clone()));+ row_label(ui, "Flip");+ ui.checkbox(flip, "");+ ui.end_row();+ }+ Kind::BoundaryFill { operation, cells, .. } => {+ row_label(ui, "Cells");+ if cells.is_empty() {+ ui.label(RichText::new("Pick the tool bodies").color(Tokens::get().text_dim));}ui.end_row();- d.extra.insert("mid".into(), json!(mids.iter().map(|(t, r)| json!([t, r])).collect::<Vec<_>>()));- if !mids.is_empty() {- row_label(ui, "Smooth");- extra_check(ui, &mut d.extra, "smooth");+ for (i, (_, label, on)) in cells.iter_mut().enumerate() {+ row_label(ui, &format!("Cell {}", i + 1));+ ui.checkbox(on, label.as_str());ui.end_row();}- }- row_label(ui, "Tangent Chain");- ui.checkbox(chain, "");- ui.end_row();- }- Kind::Shell { thickness } => {- row_label(ui, "Tangent Chain");- extra_check(ui, &mut d.extra, "tangent_chain");- ui.end_row();- let dir = d.extra.get("direction").and_then(Value::as_str).unwrap_or("inside").to_string();- row_label(- ui,- match dir.as_str() {- "outside" => "Outside Thickness",- "both" => "Thickness",- _ => "Inside Thickness",- },- );- enter |= field(ui, thickness);- ui.end_row();- row_label(ui, "Direction");- extra_choice(ui, &mut d.extra, "sh_dir", "direction", &[("Inside", "inside"), ("Outside", "outside"), ("Both", "both")]);- ui.end_row();- }- Kind::Draft { angle } => {- row_label(ui, "Angle");- enter |= field(ui, angle);- ui.end_row();- }- Kind::Mirror => {- row_label(ui, "Operation");- let mut op = usize::from(d.extra.get("combine").and_then(Value::as_bool).unwrap_or(false));- combo(ui, "mi_op", &["New Body", "Join"], &mut op);- d.extra.insert("combine".into(), json!(op == 1));- ui.end_row();- }- Kind::Measure { result, .. } => measure_rows(ui, result.as_ref()),- Kind::OffsetPlane { offset } => {- row_label(ui, "Distance");- enter |= field(ui, offset);- ui.end_row();- }- Kind::AnglePlane { angle } => {- row_label(ui, "Angle");- enter |= field(ui, angle);- ui.end_row();- }- Kind::Split | Kind::ReplaceFace | Kind::Remove => {}- Kind::Rib { thickness, depth, flip, .. } => {- row_label(ui, "Thickness");- enter |= field(ui, thickness);- ui.end_row();- row_label(ui, "Depth");- let r = ui.add(egui::TextEdit::singleline(depth).hint_text("to the next face"));- crate::params_dialog::complete(ui, &r, depth);- enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));- ui.end_row();- row_label(ui, "Flip");- ui.checkbox(flip, "");- ui.end_row();- }- Kind::Emboss { depth, deboss } => {- row_label(ui, "Depth");- enter |= field(ui, depth);- ui.end_row();- row_label(ui, "Type");- let mut i = usize::from(*deboss);- combo(ui, "emb_mode", &["Emboss", "Deboss"], &mut i);- *deboss = i == 1;- ui.end_row();- ui.label("");- ui.add(- egui::Label::new(- "Orthogonal line profiles tangent to one supported cylinder wrap automatically. Pick a wall to choose a target.",- )- .wrap(),- );- ui.end_row();- }- Kind::Align { flip } => {- // Where on the picked face or edge to snap: as picked (a face turns to meet- // the other, an edge at its middle), its centre, or a round one's centre.- for (label, key) in [("From Snap", "from_snap"), ("To Snap", "to_snap")] {- row_label(ui, label);- extra_choice(ui, &mut d.extra, key, key, &[("As Picked", "picked"), ("Centre", "center"), ("Circle Centre", "circle")]);+ row_label(ui, "Operation");+ combo(ui, "bf_op", &OP_LABELS, operation);+ ui.end_row();+ row_label(ui, "Remove Tools");+ extra_check(ui, &mut d.extra, "remove_tools");ui.end_row();}- row_label(ui, "Flip");- ui.checkbox(flip, "");- ui.end_row();- }- Kind::BoundaryFill { operation, cells, .. } => {- row_label(ui, "Cells");- if cells.is_empty() {- ui.label(RichText::new("Pick the tool bodies").color(Tokens::get().text_dim));+ Kind::PathPattern { count, spacing } => {+ for (l, v) in [("Quantity", count), ("Spacing", spacing)] {+ row_label(ui, l);+ enter |= field(ui, v);+ ui.end_row();+ }}- ui.end_row();- for (i, (_, label, on)) in cells.iter_mut().enumerate() {- row_label(ui, &format!("Cell {}", i + 1));- ui.checkbox(on, label.as_str());+ Kind::Pipe { diameter, wall } => {+ row_label(ui, "Diameter");+ enter |= field(ui, diameter);ui.end_row();- }- row_label(ui, "Operation");- combo(ui, "bf_op", &OP_LABELS, operation);- ui.end_row();- row_label(ui, "Remove Tools");- extra_check(ui, &mut d.extra, "remove_tools");- ui.end_row();- }- Kind::PathPattern { count, spacing } => {- for (l, v) in [("Quantity", count), ("Spacing", spacing)] {- row_label(ui, l);- enter |= field(ui, v);+ row_label(ui, "Wall");+ let r = ui.add(egui::TextEdit::singleline(wall).hint_text("solid"));+ crate::params_dialog::complete(ui, &r, wall);+ enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));ui.end_row();}- }- Kind::Pipe { diameter, wall } => {- row_label(ui, "Diameter");- enter |= field(ui, diameter);- ui.end_row();- row_label(ui, "Wall");- let r = ui.add(egui::TextEdit::singleline(wall).hint_text("solid"));- crate::params_dialog::complete(ui, &r, wall);- enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));- ui.end_row();- }- Kind::Stock { margin } => {- row_label(ui, "Margin");- enter |= field(ui, margin);- ui.end_row();- }- Kind::Scale { factor } => {- row_label(ui, "Scale factor");- enter |= field(ui, factor);- ui.end_row();- }- Kind::OffsetFaces { distance } => {- row_label(ui, "Distance");- enter |= field(ui, distance);- ui.end_row();- }- Kind::Thread { designation, length } => {- // Fusion's order: Modeled, Full Length, then the size; a length only when not- // full.- row_label(ui, "Modeled");- extra_check(ui, &mut d.extra, "modeled");- ui.end_row();- row_label(ui, "Full Length");- let mut full = length.trim().is_empty();- if ui.checkbox(&mut full, "").changed() {- *length = if full { String::new() } else { "10 mm".into() };- }- ui.end_row();- row_label(ui, "Size");- let r = ui.add(egui::TextEdit::singleline(designation).hint_text("fits the face, e.g. M8"));- enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));- ui.end_row();- if !full {- row_label(ui, "Length");- enter |= field(ui, length);+ Kind::Stock { margin } => {+ row_label(ui, "Margin");+ enter |= field(ui, margin);ui.end_row();}- }- Kind::Material { index } => {- let names: Vec<&str> = solvecraft_engine::doc::MATERIALS.iter().map(|(n, _)| *n).collect();- row_label(ui, "Material");- combo(ui, "mat", &names, index);- ui.end_row();- }- Kind::Section { offset, flip } => {- row_label(ui, "Distance");- enter |= field(ui, offset);- ui.end_row();- row_label(ui, "Flip");- ui.checkbox(flip, "");- ui.end_row();- }- Kind::PatternRect { count, spacing, count2, spacing2 } => {- for (l, v) in [("Quantity", count), ("Spacing", spacing), ("Quantity 2", count2), ("Spacing 2", spacing2)] {- row_label(ui, l);- enter |= field(ui, v);+ Kind::Scale { factor } => {+ row_label(ui, "Scale factor");+ enter |= field(ui, factor);ui.end_row();}- }- Kind::PatternCirc { count, angle } => {- for (l, v) in [("Quantity", count), ("Total angle", angle)] {- row_label(ui, l);- enter |= field(ui, v);+ Kind::OffsetFaces { distance } => {+ row_label(ui, "Distance");+ enter |= field(ui, distance);ui.end_row();}- }- Kind::Loft { operation } => {- row_label(ui, "Operation");- combo(ui, "lf_op", &OP_LABELS, operation);- ui.end_row();- }- Kind::Sweep { operation } => {- row_label(ui, "Operation");- combo(ui, "sw_op", &OP_LABELS, operation);- ui.end_row();- }- k @ Kind::Move { .. } => enter |= crate::dialogs_move::rows(ui, k),- Kind::Hole { diameter, depth, kind, cb_diameter, cb_depth, cs_diameter, cs_angle, opts } => {- row_label(ui, "Extents");- let cur = if to_object_on(&d.inputs) { 1 } else { usize::from(opts.all) * 2 };- let mut ext = cur;- combo(ui, "hole_ext", &["Distance", "To Object", "All"], &mut ext);- opts.all = ext == 2;- set_to_object(&mut d.inputs, &mut d.active, ext == 1);- ui.end_row();- if opts.multiple {- // Every point of the picked points' sketches (standalone points and- // circle centres), not just the picked ones.- row_label(ui, "All Sketch Points");- extra_check(ui, &mut d.extra, "all_points");+ Kind::Thread { designation, length } => {+ // Fusion's order: Modeled, Full Length, then the size; a length only when not+ // full.+ row_label(ui, "Modeled");+ extra_check(ui, &mut d.extra, "modeled");+ ui.end_row();+ row_label(ui, "Full Length");+ let mut full = length.trim().is_empty();+ if ui.checkbox(&mut full, "").changed() {+ *length = if full { String::new() } else { "10 mm".into() };+ }ui.end_row();- }- row_label(ui, "Hole Type");- combo(ui, "hole_kind", &HOLE_LABELS, kind);- ui.end_row();- row_label(ui, "Hole Tap Type");- let mut tap = usize::from(opts.tapped);- combo(ui, "hole_tap", &["Simple", "Tapped"], &mut tap);- opts.tapped = tap == 1;- ui.end_row();- if opts.tapped {row_label(ui, "Size");- let r = ui.add(egui::TextEdit::singleline(&mut opts.thread).hint_text("M5"));+ let r = ui.add(egui::TextEdit::singleline(designation).hint_text("fits the face, e.g. M8"));enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));ui.end_row();+ if !full {+ row_label(ui, "Length");+ enter |= field(ui, length);+ ui.end_row();+ }}- if *kind == 0 {- row_label(ui, "Drill Point");- let mut tip = usize::from(opts.angled);- combo(ui, "hole_tip", &["Flat", "Angle"], &mut tip);- opts.angled = tip == 1;+ Kind::Material { index } => {+ let names: Vec<&str> = solvecraft_engine::doc::MATERIALS.iter().map(|(n, _)| *n).collect();+ row_label(ui, "Material");+ combo(ui, "mat", &names, index);ui.end_row();}- if !opts.all {- row_label(ui, "Depth");- enter |= field(ui, depth);+ Kind::Section { offset, flip } => {+ row_label(ui, "Distance");+ enter |= field(ui, offset);ui.end_row();- }- if *kind == 0 && opts.angled {- row_label(ui, "Tip Angle");- enter |= field(ui, &mut opts.tip_angle);+ row_label(ui, "Flip");+ ui.checkbox(flip, "");ui.end_row();}- row_label(ui, "Diameter");- enter |= field(ui, diameter);- ui.end_row();- if *kind == 1 {- row_label(ui, "Counterbore Ø");- enter |= field(ui, cb_diameter);+ Kind::PatternRect { count, spacing, count2, spacing2 } => {+ for (l, v) in [("Quantity", count), ("Spacing", spacing), ("Quantity 2", count2), ("Spacing 2", spacing2)] {+ row_label(ui, l);+ enter |= field(ui, v);+ ui.end_row();+ }+ }+ Kind::PatternCirc { count, angle } => {+ for (l, v) in [("Quantity", count), ("Total angle", angle)] {+ row_label(ui, l);+ enter |= field(ui, v);+ ui.end_row();+ }+ }+ Kind::Loft { operation } => {+ row_label(ui, "Operation");+ combo(ui, "lf_op", &OP_LABELS, operation);ui.end_row();- row_label(ui, "Counterbore depth");- enter |= field(ui, cb_depth);+ }+ Kind::Sweep { operation } => {+ row_label(ui, "Operation");+ combo(ui, "sw_op", &OP_LABELS, operation);ui.end_row();}- if *kind == 2 {- row_label(ui, "Countersink Ø");- enter |= field(ui, cs_diameter);+ k @ Kind::Move { .. } => enter |= crate::dialogs_move::rows(ui, k),+ Kind::Hole { diameter, depth, kind, cb_diameter, cb_depth, cs_diameter, cs_angle, opts } => {+ row_label(ui, "Extents");+ let cur = if to_object_on(&d.inputs) { 1 } else { usize::from(opts.all) * 2 };+ let mut ext = cur;+ combo(ui, "hole_ext", &["Distance", "To Object", "All"], &mut ext);+ opts.all = ext == 2;+ set_to_object(&mut d.inputs, &mut d.active, ext == 1);ui.end_row();- row_label(ui, "Countersink angle");- enter |= field(ui, cs_angle);+ if opts.multiple {+ // Every point of the picked points' sketches (standalone points and+ // circle centres), not just the picked ones.+ row_label(ui, "All Sketch Points");+ extra_check(ui, &mut d.extra, "all_points");+ ui.end_row();+ }+ row_label(ui, "Hole Type");+ combo(ui, "hole_kind", &HOLE_LABELS, kind);ui.end_row();- }- }- Kind::Primitive { fields, operation, .. } => {- for (k, v) in fields.iter_mut() {- row_label(ui, k);- enter |= field(ui, v);+ row_label(ui, "Hole Tap Type");+ let mut tap = usize::from(opts.tapped);+ combo(ui, "hole_tap", &["Simple", "Tapped"], &mut tap);+ opts.tapped = tap == 1;+ ui.end_row();+ if opts.tapped {+ row_label(ui, "Size");+ let r = ui.add(egui::TextEdit::singleline(&mut opts.thread).hint_text("M5"));+ enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));+ ui.end_row();+ }+ if *kind == 0 {+ row_label(ui, "Drill Point");+ let mut tip = usize::from(opts.angled);+ combo(ui, "hole_tip", &["Flat", "Angle"], &mut tip);+ opts.angled = tip == 1;+ ui.end_row();+ }+ if !opts.all {+ row_label(ui, "Depth");+ enter |= field(ui, depth);+ ui.end_row();+ }+ if *kind == 0 && opts.angled {+ row_label(ui, "Tip Angle");+ enter |= field(ui, &mut opts.tip_angle);+ ui.end_row();+ }+ row_label(ui, "Diameter");+ enter |= field(ui, diameter);ui.end_row();+ if *kind == 1 {+ row_label(ui, "Counterbore Ø");+ enter |= field(ui, cb_diameter);+ ui.end_row();+ row_label(ui, "Counterbore depth");+ enter |= field(ui, cb_depth);+ ui.end_row();+ }+ if *kind == 2 {+ row_label(ui, "Countersink Ø");+ enter |= field(ui, cs_diameter);+ ui.end_row();+ row_label(ui, "Countersink angle");+ enter |= field(ui, cs_angle);+ ui.end_row();+ }}- row_label(ui, "Operation");- combo(ui, "pr_op", &OP_LABELS, operation);- ui.end_row();- }- Kind::Combine { operation, keep_tools } => {- row_label(ui, "Operation");- let mut op = operation.saturating_sub(1);- combo(ui, "cb_op", &OP_LABELS[1..], &mut op);- *operation = op + 1;- ui.end_row();- row_label(ui, "New Component");- extra_check(ui, &mut d.extra, "new_component");- ui.end_row();- row_label(ui, "Keep Tools");- ui.checkbox(keep_tools, "");- ui.end_row();- }- Kind::Params { new_name, new_expr } => params_table(app, ui, new_name, new_expr),- Kind::EditParam { name, expr } => {- ui.label(name.as_str());- let r = ui.text_edit_singleline(expr);- crate::params_dialog::complete(ui, &r, expr);- if r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {- ok = true;+ Kind::Primitive { fields, operation, .. } => {+ for (k, v) in fields.iter_mut() {+ row_label(ui, k);+ enter |= field(ui, v);+ ui.end_row();+ }+ row_label(ui, "Operation");+ combo(ui, "pr_op", &OP_LABELS, operation);+ ui.end_row();}- r.request_focus();- ui.end_row();- }- Kind::Rename { name, .. } => {- row_label(ui, "Name");- let r = ui.text_edit_singleline(name);- if r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {- ok = true;+ Kind::Combine { operation, keep_tools } => {+ row_label(ui, "Operation");+ let mut op = operation.saturating_sub(1);+ combo(ui, "cb_op", &OP_LABELS[1..], &mut op);+ *operation = op + 1;+ ui.end_row();+ row_label(ui, "New Component");+ extra_check(ui, &mut d.extra, "new_component");+ ui.end_row();+ row_label(ui, "Keep Tools");+ ui.checkbox(keep_tools, "");+ ui.end_row();}- r.request_focus();- ui.end_row();- }- Kind::Assembly(k) => enter |= crate::dialogs_assembly::rows(app, ui, k, &mut d.inputs, &mut d.active),- Kind::Sheet(k) => enter |= crate::dialogs_sheet::rows(app, ui, k, &mut d.inputs),- Kind::Surface(k) => enter |= crate::dialogs_surface::rows(ui, k),- Kind::Plastic(k) => enter |= crate::dialogs_plastic::rows(app, ui, k, &d.inputs),- Kind::Appearance(k) => enter |= crate::dialogs_appearance::rows(app, ui, k, &mut d.inputs),- Kind::Motion(k) => enter |= crate::dialogs_motion::rows(app, ui, k, &mut d.inputs),- Kind::Part(k) => enter |= crate::dialogs_parts::rows(app, ui, k, &d.inputs),- Kind::ConfirmDelete { with, fail, .. } => {- if !with.is_empty() {- row_label(ui, "Also deletes");- ui.label(with.join(", "));+ Kind::Params { new_name, new_expr } => params_table(app, ui, new_name, new_expr),+ Kind::EditParam { name, expr } => {+ ui.label(name.as_str());+ let r = ui.text_edit_singleline(expr);+ crate::params_dialog::complete(ui, &r, expr);+ if r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {+ ok = true;+ }+ r.request_focus();ui.end_row();}- if !fail.is_empty() {- row_label(ui, "Will fail");- ui.label(RichText::new(fail.join(", ")).color(t.warning));+ Kind::Rename { name, .. } => {+ row_label(ui, "Name");+ let r = ui.text_edit_singleline(name);+ if r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {+ ok = true;+ }+ r.request_focus();ui.end_row();}- }- }- if let Some(e) = d.error.as_ref().or(app.preview.error.as_ref()).cloned() {- row_label(ui, "");- ui.vertical(|ui| {- ui.add(egui::Label::new(RichText::new(e.as_str()).color(t.error)).wrap());- let response = ui.button("Create Issue…");- crate::scenario::publish_handle("dialog:create_issue", response.rect.center());- if response.clicked() {- crate::issue_report::begin(app, ctx, Some(&d), Some(&e));+ Kind::Assembly(k) => enter |= crate::dialogs_assembly::rows(app, ui, k, &mut d.inputs, &mut d.active),+ Kind::Sheet(k) => enter |= crate::dialogs_sheet::rows(app, ui, k, &mut d.inputs),+ Kind::Surface(k) => enter |= crate::dialogs_surface::rows(ui, k),+ Kind::Plastic(k) => enter |= crate::dialogs_plastic::rows(app, ui, k, &d.inputs),+ Kind::Appearance(k) => enter |= crate::dialogs_appearance::rows(app, ui, k, &mut d.inputs),+ Kind::Motion(k) => enter |= crate::dialogs_motion::rows(app, ui, k, &mut d.inputs),+ Kind::Part(k) => enter |= crate::dialogs_parts::rows(app, ui, k, &d.inputs),+ Kind::ConfirmDelete { with, fail, .. } => {+ if !with.is_empty() {+ row_label(ui, "Also deletes");+ ui.label(with.join(", "));+ ui.end_row();+ }+ if !fail.is_empty() {+ row_label(ui, "Will fail");+ ui.label(RichText::new(fail.join(", ")).color(t.warning));+ ui.end_row();+ }}- });- ui.end_row();- }+ }+ if let Some(e) = d.error.as_ref().or(app.preview.error.as_ref()).cloned() {+ row_label(ui, "");+ ui.vertical(|ui| {+ ui.add(egui::Label::new(RichText::new(e.as_str()).color(t.error)).wrap());+ let response = ui.button("Create Issue…");+ crate::scenario::publish_handle("dialog:create_issue", response.rect.center());+ if response.clicked() {+ crate::issue_report::begin(app, ctx, Some(&d), Some(&e));+ }+ });+ ui.end_row();+ }+ });});ui.add_space(6.0);// Footer: an info glyph at the left, OK and Cancel at the right.diff --git a/crates/ui-egui/src/dialogs_motion.rs b/crates/ui-egui/src/dialogs_motion.rsindex f4b6db8b24..f4483b3d96 100644--- a/crates/ui-egui/src/dialogs_motion.rs+++ b/crates/ui-egui/src/dialogs_motion.rs@@ -1023,6 +1023,29 @@ mod tests {assert_eq!(cell_value("param:width", "90 mm"), json!("90 mm"));}+ fn click_rule_button(h: &mut crate::scenario::Harness, name: &str) {+ // The table header also contains this name. Its TextRun may be emitted+ // after the popup, so select the actual choice rather than matching text.+ let bounds = h+ .output+ .accesskit_update+ .as_ref()+ .unwrap()+ .nodes+ .iter()+ .rev()+ .find_map(|(_, n)| {+ (n.role() == egui::accesskit::Role::Button && !n.is_disabled() && n.label() == Some(name)).then(|| n.bounds()).flatten()+ })+ .expect("rule button");+ h.step(&json!({"click": [(bounds.x0 + bounds.x1) / 2.0, (bounds.y0 + bounds.y1) / 2.0]})).unwrap();+ }++ fn select_rule_parameter(h: &mut crate::scenario::Harness, name: &str) {+ click_rule_button(h, name);+ assert!(h.widget("Choose…").is_none(), "parameter choice should close and update the dropdown");+ }+#[test]fn configuration_compound_condition_and_rule_order_are_editable_in_dialog() {let mut h = crate::scenario::Harness::new();@@ -1032,9 +1055,11 @@ mod tests {{"call":"engine.execute","params":{"command":"config.configure","params":{"params":["length"]}}},{"start":"config.table"},{"widget":"Add or edit rule"},{"widget":"Always"},{"widget":"All"},{"widget":"Always"},{"widget":"Parameter"},- {"widget":"Choose…"},{"widget":"length"},{"widget":"Save Rule"}+ {"widget":"Choose…"}])).unwrap();+ select_rule_parameter(&mut h, "length");+ h.step(&json!({"widget":"Save Rule"})).unwrap();assert!(matches!(&h.app.session.doc.configs.rules[0].condition,solvecraft_engine::doc::config::RuleCondition::All{conditions} if matches!(&conditions[0],solvecraft_engine::doc::config::RuleCondition::Parameter{..})));@@ -1044,7 +1069,8 @@ mod tests {])).unwrap();assert!(h.widget("length = 20 mm").is_some());assert_eq!(h.app.session.doc.param("length").unwrap().expr, "40 mm");- h.run(&json!([{"widget":"↑"},{"widget":"Preview Row"}])).unwrap();+ click_rule_button(&mut h, "↑");+ h.step(&json!({"widget":"Preview Row"})).unwrap();assert_eq!(h.app.session.doc.configs.rules[0].id, "last");assert!(h.widget("length = 10 mm").is_some());assert_eq!(h.app.session.doc.param("length").unwrap().expr, "40 mm");@@ -1060,8 +1086,11 @@ mod tests {{"call":"engine.execute","params":{"command":"config.configure","params":{"params":["length"]}}},{"start":"config.table"},{"widget":"Add or edit rule"},- {"widget":"Choose…"},- {"widget":"length"},+ {"widget":"Choose…"}+ ]))+ .unwrap();+ select_rule_parameter(&mut h, "length");+ h.run(&json!([{"widget":"Save Rule"}])).unwrap();diff --git a/crates/ui-egui/src/frame.rs b/crates/ui-egui/src/frame.rsindex 57db782861..98e202e5ed 100644--- a/crates/ui-egui/src/frame.rs+++ b/crates/ui-egui/src/frame.rs@@ -89,6 +89,51 @@ pub fn right_aligned<R>(ui: &mut Ui, total: f32, width: f32, add: impl FnOnce(&m#[cfg(test)]mod tests {+ #[test]+ fn feature_forms_use_available_height_and_keep_actions_visible() {+ use crate::scenario::Harness;+ use serde_json::json;+ for (width, height, scale) in [(1400.0, 900.0, 1.0), (1400.0, 900.0, 2.0)] {+ let mut h = Harness::new();+ h.app.preferences.ui_scale = scale;+ h.call("ui.resize", json!({"width":width / scale,"height":height / scale}));+ h.app.run("sketch.create", json!({"plane":"XY","name":"Base"})).unwrap();+ h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[10,10]})).unwrap();+ h.app.run("sketch.finish", json!({})).unwrap();+ h.step(&json!({"start":"solid.extrude"})).unwrap();+ h.frames(10);+ let dialog = h.app.viewport.dialog_rect.unwrap();+ let viewport = h.app.viewport.rect.unwrap();+ assert!(dialog.height() > 230.0, "scale={scale}: {dialog:?}");+ assert!(viewport.expand(1.0).contains_rect(dialog), "scale={scale}: {dialog:?} outside {viewport:?}");+ assert!(h.widget("Distance").is_some(), "distance must be visible without scrolling");+ if scale == 1.0 {+ assert!(h.widget("Operation").is_some(), "operation must be visible without scrolling");+ }+ assert!(dialog.contains(crate::scenario::handle_at("dialog:OK").unwrap()));+ assert!(h.widget("Cancel").is_some(), "cancel must be visible without scrolling");+ h.step(&json!({"widget":"Cancel"})).unwrap();+ assert!(h.app.dialog.is_none());+ h.step(&json!({"start":"solid.shell"})).unwrap();+ h.frames(8);+ let short = h.app.viewport.dialog_rect.unwrap();+ assert!(short.height() < dialog.height(), "short forms should shrink: {short:?}, {dialog:?}");+ assert!(h.widget("Cancel").is_some());+ h.step(&json!({"widget":"Cancel"})).unwrap();+ h.step(&json!({"start":"solid.hole"})).unwrap();+ if let Some(crate::dialogs::Dialog { kind: crate::dialogs::Kind::Hole { kind, opts, .. }, .. }) = h.app.dialog.as_mut() {+ *kind = 1;+ opts.tapped = true;+ }+ h.frames(8);+ let long = h.app.viewport.dialog_rect.unwrap();+ assert!(viewport.expand(1.0).contains_rect(long), "long form clipped: {long:?}");+ assert!(h.widget("Cancel").is_some(), "long-form actions must stay visible");+ assert!(long.contains(crate::scenario::handle_at("dialog:OK").unwrap()));+ h.step(&json!({"widget":"Cancel"})).unwrap();+ assert!(h.app.dialog.is_none());+ }+ }/// Windows are made in this file only, so none can skip the width limits.#[test]fn windows_come_from_the_frame_helper() {diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 4e726eb8f9..7e04ee8e59 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -78,6 +78,8 @@ mod revolve_edit_tests;mod revolve_manipulator_tests;pub mod scenario;pub mod selection;+#[cfg(test)]+mod shell_face_sketch_ui_tests;pub mod shortcut_box;pub mod sketch3d;#[cfg(test)]diff --git a/crates/ui-egui/src/shell_face_sketch_ui_tests.rs b/crates/ui-egui/src/shell_face_sketch_ui_tests.rsnew file mode 100644index 0000000000..5d90be8c94--- /dev/null+++ b/crates/ui-egui/src/shell_face_sketch_ui_tests.rs@@ -0,0 +1,103 @@+use crate::scenario::Harness;+use serde_json::json;+use solvecraft_engine::{+ Sel,+ doc::{FaceAttachmentStatus, FeatureKind, PlaneRef},+};++fn shell() -> Harness {+ let mut h = Harness::new();+ h.app.ui.show_origin = false;+ h.app.run("solid.box", json!({"length":40,"width":30,"height":20,"body_name":"Case"})).unwrap();+ h.app.run("solid.shell", json!({"faces":[[20,15,20]],"thickness":2})).unwrap();+ h.call("ui.view", json!({"view":"front"}));+ h.call("ui.view", json!({"view":"fit"}));+ h.settle();+ h+}++fn assert_attached(h: &Harness) {+ let id = h.app.session.active_sketch.expect("a combined certified wall remains a sketch target");+ let FeatureKind::Sketch { plane: PlaneRef::Face { anchor: Some(anchor), .. }, .. } = &h.app.session.doc.feature(id).unwrap().kind else {+ panic!("wall sketch must have a durable attachment");+ };+ assert_eq!(anchor.target.body, "Case");+ assert_eq!(serde_json::to_value(&anchor.target.certificate).unwrap()["kind"], "shell_planar");+ assert!(matches!(h.app.session.doc.sketch_face_attachment(id, &h.app.session.model), FaceAttachmentStatus::Healthy { .. }));+ let world = h.app.session.world_state();+ let solved = world.sketch(id).unwrap();+ assert!(solved.plane.origin.y.abs() < 1e-8);+ assert!(solved.plane.normal().y.abs() > 0.999);+ assert!(h.app.session.model.result(id).unwrap().error.is_none());+}++fn selected_wall(h: &Harness) -> usize {+ assert_eq!(h.app.session.selection.len(), 1, "the exterior wall is one physical face, not a grouped lower strip");+ let Sel::Face { body, index, .. } = &h.app.session.selection[0] else {+ panic!("actual wall click must select a face");+ };+ assert_eq!(body, "Case");+ *index+}++fn assert_one_physical_wall(h: &mut Harness) -> usize {+ h.step(&json!({"click":{"world":[20,0,1]}})).unwrap();+ let lower = selected_wall(h);+ h.call("ui.click", json!({"x":300,"y":200}));+ assert!(h.app.session.selection.is_empty());+ h.step(&json!({"click":{"world":[20,0,10]}})).unwrap();+ assert_eq!(selected_wall(h), lower, "below and above the floor height must hit the same BRep face index");+ lower+}++#[test]+fn selected_shell_wall_patch_still_creates_a_certified_sketch() {+ let mut h = shell();+ assert_one_physical_wall(&mut h);+ let undo = h.app.session.undo.len();+ h.step(&json!({"start":"sketch.create"})).unwrap();+ h.settle();+ assert_attached(&h);+ assert_eq!(h.app.session.undo.len(), undo + 1);+}++#[test]+fn pending_create_sketch_accepts_an_actual_shell_wall_patch_click() {+ let mut h = shell();+ assert_one_physical_wall(&mut h);+ h.call("ui.click", json!({"x":300,"y":200}));+ assert!(h.app.session.selection.is_empty());+ let undo = h.app.session.undo.len();+ h.step(&json!({"start":"sketch.create"})).unwrap();+ assert!(h.app.session.active_sketch.is_none());+ h.step(&json!({"click":{"world":[20,0,1]}})).unwrap();+ h.settle();+ assert_attached(&h);+ assert_eq!(h.app.session.undo.len(), undo + 1);+}++#[test]+fn rounded_shell_corner_is_one_physical_face_above_and_below_the_floor() {+ let mut h = Harness::new();+ h.app.ui.show_origin = false;+ h.app.run("solid.box", json!({"length":80,"width":60,"height":30,"corner":[-40,-30,0],"body_name":"Case"})).unwrap();+ h.app.run("solid.fillet", json!({"edges":[[40,30,15],[-40,30,15],[-40,-30,15],[40,-30,15]],"radius":6})).unwrap();+ h.app.run("solid.shell", json!({"faces":[[0,0,30]],"thickness":2})).unwrap();+ h.call("ui.view", json!({"view":"iso"}));+ h.call("ui.view", json!({"view":"fit"}));+ h.settle();+ let state = h.app.session.world_state();+ assert_eq!(state.body("Case").unwrap().body.face_count(), 19, "no artificial lower corner faces remain in the BRep");+ let document = h.app.session.doc.to_json();+ let undo = h.app.session.undo.len();+ let redo = h.app.session.redo.len();+ h.step(&json!({"click":{"world":[38.242640687,-28.242640687,1]}})).unwrap();+ let lower = selected_wall(&h);+ h.call("ui.click", json!({"x":300,"y":200}));+ assert!(h.app.session.selection.is_empty());+ h.step(&json!({"click":{"world":[38.242640687,-28.242640687,15]}})).unwrap();+ assert_eq!(selected_wall(&h), lower, "lower and upper corner clicks hit the same actual face, not two grouped pieces");+ assert_eq!(h.app.session.doc.to_json(), document);+ assert_eq!(h.app.session.undo.len(), undo);+ assert_eq!(h.app.session.redo.len(), redo);+}diff --git a/crates/ui-egui/src/sketch_attachment_ui_tests.rs b/crates/ui-egui/src/sketch_attachment_ui_tests.rsindex 88cbe93679..c13a7b9206 100644--- a/crates/ui-egui/src/sketch_attachment_ui_tests.rs+++ b/crates/ui-egui/src/sketch_attachment_ui_tests.rs@@ -142,14 +142,16 @@ fn unsupported_modified_face_offers_explicit_fixed_plane_without_live_links() {let mut h = Harness::new();h.app.ui.show_origin = false;h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"body_name":"Modified"})).unwrap();- h.app.run("solid.fillet", json!({"edges":[[0,0,5]],"radius":1})).unwrap();+ // An intentional split gives the +z source two distinct planar pieces. A+ // strict attachment cannot claim the original whole-face certificate.+ h.app.run("solid.split_face", json!({"body":"Modified","faces":[[5,5,10]],"plane":{"origin":[5,0,0],"normal":[1,0,0]}})).unwrap();let before = h.app.session.doc.to_json();let undo = h.app.session.undo.len();h.call("ui.view", json!({"view":"top"}));h.call("ui.view", json!({"view":"fit"}));h.settle();h.step(&json!({"start":"sketch.create"})).unwrap();- h.step(&json!({"click":{"world":[5,5,10]}})).unwrap();+ h.step(&json!({"click":{"world":[2.5,5,10]}})).unwrap();assert!(h.app.session.active_sketch.is_none());assert!(h.app.dialog.as_ref().unwrap().error.is_some());assert_eq!(h.app.session.doc.to_json(), before);diff --git a/crates/ui-egui/src/viewport_layout.rs b/crates/ui-egui/src/viewport_layout.rsindex 69c16a9c84..973ad1e0ec 100644--- a/crates/ui-egui/src/viewport_layout.rs+++ b/crates/ui-egui/src/viewport_layout.rs@@ -42,16 +42,14 @@ impl Layout {pub fn new(viewport: Rect, docks: &[Rect], scale: f32) -> Self {let scale = if scale.is_finite() && scale > 0.0 { scale } else { 1.0 };let mut obstacles: Vec<_> = docks.iter().take(6).copied().filter(|r| r.is_finite()).map(|r| r.expand(4.0)).collect();- let available = free_rect(viewport, &obstacles);- let axis_view = if available.width() >= 116.0 && available.height() >= 116.0 {+ // Navigation is anchored to the viewport, never to transient dialog space.+ let available = viewport;+ let mut axis_view = if available.width() >= 116.0 && available.height() >= 116.0 {Rect::from_min_size(pos2(available.right() - 116.0, available.top()), vec2(116.0, 116.0))} else {Rect::NOTHING};- if axis_view.is_positive() {- obstacles.push(axis_view);- }- let nav_space = free_rect(viewport, &obstacles);+ let nav_space = viewport;let columns = ((nav_space.width() - 10.0) / 30.0).floor().clamp(1.0, 10.0);let nav_height = (10.0 / columns).ceil() * 30.0;let navigation = if nav_space.width() >= columns * 30.0 + 10.0 && nav_space.height() >= nav_height + 7.0 {@@ -59,6 +57,14 @@ impl Layout {} else {Rect::NOTHING};+ // On tiny viewports keep the bottom controls usable rather than overlapping them.+ // This decision depends only on viewport size, never on an overlay.+ if axis_view.intersect(navigation).is_positive() {+ axis_view = Rect::NOTHING;+ }+ if axis_view.is_positive() {+ obstacles.push(axis_view);+ }if navigation.is_positive() {obstacles.push(navigation);}diff --git a/crates/ui-egui/src/viewport_layout_tests.rs b/crates/ui-egui/src/viewport_layout_tests.rsindex c80c3c02d7..2b0457656a 100644--- a/crates/ui-egui/src/viewport_layout_tests.rs+++ b/crates/ui-egui/src/viewport_layout_tests.rs@@ -142,7 +142,19 @@ fn measured_axis_view_targets_home_and_drag_work_beside_the_palette_at_hidpi() {assert_eq!(outer, layout.axis_view);assert!(outer.contains_rect(home));assert!(layout.viewport.contains_rect(outer));- assert!(!outer.intersect(palette).is_positive());+ assert_eq!(outer.right_top(), layout.viewport.right_top());+ if outer.intersect(palette).is_positive() {+ // Short palettes may cover the fixed anchor; covered controls never steal input.+ let covered = outer.intersect(palette).center();+ let camera = h.app.cam;+ h.call("ui.click", json!({"x":covered.x,"y":covered.y}));+ assert_eq!(h.app.cam, camera);+ assert!(h.app.viewport.axis_drag.is_none());+ assert_eq!(crate::scenario::rect_of("axis_view:outer").unwrap(), outer);+ assert_eq!(h.app.session.doc.to_json(), baseline);+ assert_eq!(h.app.session.undo.len(), undo);+ continue;+ }assert!(!layout.navigation.intersect(outer).is_positive());for name in ["x", "-x", "y", "-y", "z", "-z"] {let p = crate::scenario::handle_at(&format!("axis_view:{name}")).unwrap();@@ -194,3 +206,79 @@ fn immediate_standard_view_cancels_fit_before_the_measured_frame() {assert_eq!(h.app.session.doc.to_json(), baseline);assert_eq!(h.app.session.undo.len(), undo);}++#[test]+fn navigation_anchors_ignore_positioned_resized_and_covering_dialogs() {+ for (width, height, scale) in [(1400.0, 900.0, 1.0), (700.0, 450.0, 2.0), (700.0, 360.0, 2.0)] {+ let vp = Rect::from_min_max(pos2(250.0, 126.0), pos2(width, height - 30.0));+ let baseline = Layout::new(vp, &[], scale);+ assert!(baseline.axis_view.is_positive() && baseline.navigation.is_positive());+ assert_eq!(baseline.axis_view.right_top(), vp.right_top());+ assert_eq!(baseline.navigation.center().x, vp.center().x);+ assert_eq!(baseline.navigation.bottom(), vp.bottom() - 7.0);+ let cases = [+ vec![Rect::from_min_max(pos2(width - 220.0, vp.top() + 120.0), vp.max)],+ vec![Rect::from_min_size(vp.min, vec2(210.0, 170.0))],+ vec![Rect::from_center_size(vp.center(), vec2(250.0, 180.0)), Rect::from_min_size(vp.min, vec2(70.0, 120.0))],+ vec![vp],+ ];+ for docks in cases {+ let measured = Layout::new(vp, &docks, scale);+ assert_eq!(measured.axis_view, baseline.axis_view, "{docks:?}");+ assert_eq!(measured.navigation, baseline.navigation, "{docks:?}");+ assert!(vp.contains_rect(measured.axis_view));+ assert!(vp.contains_rect(measured.navigation));+ }+ }+}++#[test]+fn opening_different_command_dialogs_keeps_published_navigation_positions() {+ let mut h = Harness::new();+ h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();+ h.settle();+ let axis = crate::scenario::rect_of("axis_view:outer").unwrap();+ let nav = crate::scenario::rect_of("nav:outer").unwrap();+ let camera = h.app.cam;+ let baseline = h.app.session.doc.to_json();+ let undo = h.app.session.undo.len();+ for command in ["solid.extrude", "solid.fillet", "inspect.measure"] {+ h.app.start(command);+ h.settle();+ assert!(h.app.dialog.is_some(), "{command}");+ assert!(h.app.viewport.dialog_rect.is_some(), "dialog must be measured");+ assert_eq!(crate::scenario::rect_of("axis_view:outer").unwrap(), axis, "{command}");+ assert_eq!(crate::scenario::rect_of("nav:outer").unwrap(), nav, "{command}");+ assert_eq!(h.app.cam, camera);+ let pan = pos2(nav.left() + 5.0 + 2.0 * 30.0 + 13.0, nav.top() + 15.0);+ assert!(!h.app.viewport.dialog_rect.unwrap().contains(pan));+ h.app.viewport.nav = None;+ h.call("ui.click", json!({"x":pan.x,"y":pan.y}));+ assert_eq!(h.app.viewport.nav, Some(crate::viewport::NavMode::Pan), "fixed navigation stays usable beside {command}");+ h.app.dialog = None;+ h.settle();+ assert_eq!(crate::scenario::rect_of("axis_view:outer").unwrap(), axis);+ assert_eq!(crate::scenario::rect_of("nav:outer").unwrap(), nav);+ }+ assert_eq!(h.app.session.doc.to_json(), baseline);+ assert_eq!(h.app.session.undo.len(), undo);+}++#[test]+fn tiny_viewports_never_overlap_navigation_and_axis_view() {+ for width in [39.0, 40.0, 90.0, 120.0, 160.0, 310.0] {+ for height in [30.0, 80.0, 130.0, 160.0, 240.0] {+ let vp = Rect::from_min_size(pos2(20.0, 30.0), vec2(width, height));+ let clear = Layout::new(vp, &[], 1.0);+ let covered = Layout::new(vp, &[vp], 1.0);+ assert_eq!(clear.axis_view, covered.axis_view);+ assert_eq!(clear.navigation, covered.navigation);+ assert!(!clear.axis_view.intersect(clear.navigation).is_positive());+ for control in [clear.axis_view, clear.navigation] {+ if control.is_positive() {+ assert!(vp.contains_rect(control), "{clear:?}");+ }+ }+ }+ }+}diff --git a/crates/ui-egui/tests/scenarios/face_wins_over_origin_plane.json b/crates/ui-egui/tests/scenarios/face_wins_over_origin_plane.jsonindex 6d8df41178..21cd76d2ea 100644--- a/crates/ui-egui/tests/scenarios/face_wins_over_origin_plane.json+++ b/crates/ui-egui/tests/scenarios/face_wins_over_origin_plane.json@@ -61,20 +61,13 @@}},{- "note": "The shelled floor is picked rather than the origin plane. Its uncertified mesh face requires an explicit fixed-plane choice."+ "note": "The certified Shell floor is picked rather than the origin plane and starts a healthy attached sketch directly."},{"expect": {- "sketching": false,- "dialog": "this face has no exact planar source"- }- },- {- "widget": "Use fixed plane"- },- {- "expect": {- "sketching": true+ "sketching": true,+ "dialog": null,+ "errors": 0}},{