Rename SolveCraft to SolidCraft everywhere, with compatibility shims (#389)

* WIP deep rename (not for push)

* WIP2

* WIP3

* WIP4 wxs fix

* rustfmt

* Rename the remaining identifiers in merged crash-report code

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01RjGw4gA5ZvKrU8MQP6sBgT

---------

Co-authored-by: Claude Opus 5.5 <[email protected]>

crates/doc/src/anchor_frame.rs

@@ -7,7 +7,7 @@ pub fn state_in_face_anchor_frame<'a>(doc: &Document, state: &'a ModelState, anc
     let raw = state.body(&anchor.target.body).ok_or_else(|| DocError::Unknown(format!("anchored body `{}`", anchor.target.body)))?;
     let relative = anchor.source_to_author(doc, author, raw)?;
     let mut output = crate::state_in_frame_at(doc, state, author, frame).into_owned();
-    let shape = if crate::is_identity(&relative) { raw.body.clone() } else { solvecraft_kernel::transform_matrix(&raw.body, relative)? };
+    let shape = if crate::is_identity(&relative) { raw.body.clone() } else { solidcraft_kernel::transform_matrix(&raw.body, relative)? };
     let mut body = ModelBody::new(raw.name.clone(), shape, raw.feature);
     body.component = raw.component;
     body.transferred = raw.transferred;

crates/doc/src/appearance.rs

@@ -6,7 +6,7 @@
 use std::collections::BTreeMap;
 
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;
 
 use crate::Document;
 

crates/doc/src/assembly.rs

@@ -9,7 +9,7 @@
 //! and the engine maps a new feature's geometry into the active component's frame.
 
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Plane, Vec3};
+use solidcraft_geom::{Plane, Vec3};
 
 use crate::{AxisRef, DocError, Document, FeatureKind, PatternKind, PlaneRef, Result};
 

crates/doc/src/body_transfer.rs

@@ -1,6 +1,6 @@
 //! Recorded ownership changes are evaluated at their timeline position.
 use crate::{DocError, Document, Mat, ModelBody, ModelState, Result};
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;
 use std::collections::BTreeSet;
 
 pub fn valid_transfer_matrix(m: &Mat) -> bool {
@@ -39,7 +39,7 @@ pub(crate) fn evaluate(doc: &Document, st: &mut ModelState, bodies: &[String], f
         if doc.model_body_component(old) != from {
             return Err(DocError::Invalid(format!("body `{name}` no longer belongs to transfer source component {from}")));
         }
-        let shape = if crate::is_identity(&transform) { old.body.clone() } else { solvecraft_kernel::transform_matrix(&old.body, transform)? };
+        let shape = if crate::is_identity(&transform) { old.body.clone() } else { solidcraft_kernel::transform_matrix(&old.body, transform)? };
         let mut body = ModelBody::new(old.name.clone(), shape, old.feature);
         body.component = to;
         body.transferred = true;

crates/doc/src/body_transfer_sheet.rs

@@ -1,5 +1,5 @@
 //! World-frame metadata at a timeline body ownership boundary.
-use solvecraft_geom::Plane;
+use solidcraft_geom::Plane;
 
 use crate::{DocError, Mat, ModelState, Result, apply_point, apply_vector};
 

crates/doc/src/canvas.rs

@@ -2,7 +2,7 @@
 //! The image bytes travel inside the design file (base64), so it reopens without the original.
 
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Plane, Vec2, Vec3};
+use solidcraft_geom::{Plane, Vec2, Vec3};
 
 use crate::PlaneRef;
 

crates/doc/src/clipboard.rs

@@ -202,13 +202,13 @@ fn remap_plane(
 }
 
 fn remap_link(
-    source: &mut solvecraft_sketch::LinkSource,
+    source: &mut solidcraft_sketch::LinkSource,
     ids: &BTreeMap<u64, u64>,
     names: &BTreeMap<String, String>,
     bodies: &BTreeMap<String, String>,
     depth: usize,
 ) {
-    use solvecraft_sketch::LinkSource;
+    use solidcraft_sketch::LinkSource;
     if depth > 64 {
         return;
     }
@@ -441,11 +441,11 @@ fn checked_plane(p: &PlaneRef, depth: usize) -> crate::Result<()> {
     }
     Ok(())
 }
-fn checked_link(source: &solvecraft_sketch::LinkSource, depth: usize) -> crate::Result<()> {
+fn checked_link(source: &solidcraft_sketch::LinkSource, depth: usize) -> crate::Result<()> {
     if depth > 64 {
         return Err(crate::DocError::Invalid("copy link nesting exceeds 64".into()));
     }
-    if let solvecraft_sketch::LinkSource::Intersection { a, b } = source {
+    if let solidcraft_sketch::LinkSource::Intersection { a, b } = source {
         checked_link(a, depth + 1)?;
         checked_link(b, depth + 1)?;
     }

crates/doc/src/config_certificates.rs

@@ -1,7 +1,7 @@
 //! Certificates are producer identities, never a nearest-surface selection.
 use crate::{DocError, Document, FeatureKind, ModelBody, Result, SolvedSketch};
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::Seg2;
+use solidcraft_geom::Seg2;
 
 fn valid_signature(outer: &[String], holes: &[Vec<String>]) -> bool {
     let valid = |ids: &[String]| {
@@ -68,11 +68,11 @@ pub(crate) fn cap_key(outer: &[String], holes: &[Vec<String>]) -> String {
     }
     format!("{:x}", hash.finalize())
 }
-fn exact_region_signature(curves: &ExactSketchCurves, region: &solvecraft_geom::Region2) -> Option<solvecraft_kernel::CapSignature> {
+fn exact_region_signature(curves: &ExactSketchCurves, region: &solidcraft_geom::Region2) -> Option<solidcraft_kernel::CapSignature> {
     if region.outer.segs.len() + region.holes.iter().map(|hole| hole.segs.len()).sum::<usize>() > 4096 || region.holes.len() > 128 {
         return None;
     }
-    let signature = |outline: &solvecraft_geom::Loop2| {
+    let signature = |outline: &solidcraft_geom::Loop2| {
         let mut ids = outline.segs.iter().map(|segment| curves.find(segment)).collect::<Option<Vec<_>>>()?;
         ids.sort();
         ids.dedup();
@@ -85,9 +85,9 @@ fn exact_region_signature(curves: &ExactSketchCurves, region: &solvecraft_geom::
 }
 
 /// Charge all source-curve comparisons before matching; over-budget tools stay usable but uncertified.
-type CapBindings = Vec<Vec<Option<solvecraft_kernel::CapSignature>>>;
-pub(crate) fn extrude_cap_bindings(sketch: &SolvedSketch, bodies: &[solvecraft_kernel::Body], budget: usize) -> Option<CapBindings> {
-    use solvecraft_kernel::FaceSource;
+type CapBindings = Vec<Vec<Option<solidcraft_kernel::CapSignature>>>;
+pub(crate) fn extrude_cap_bindings(sketch: &SolvedSketch, bodies: &[solidcraft_kernel::Body], budget: usize) -> Option<CapBindings> {
+    use solidcraft_kernel::FaceSource;
     if sketch.sketch.curves.len() > 2000 {
         return None;
     }
@@ -116,7 +116,7 @@ pub(crate) fn extrude_cap_bindings(sketch: &SolvedSketch, bodies: &[solvecraft_k
     let mut counts = std::collections::BTreeMap::new();
     let mut bindings = Vec::with_capacity(bodies.len());
     for body in bodies {
-        let mut cached: Option<(&solvecraft_geom::Region2, Option<solvecraft_kernel::CapSignature>)> = None;
+        let mut cached: Option<(&solidcraft_geom::Region2, Option<solidcraft_kernel::CapSignature>)> = None;
         let mut values = Vec::new();
         for source in body.face_sources().into_iter().flatten() {
             let signature = if let Some(FaceSource::ExtrudeCap { region, high, .. }) = source {
@@ -260,8 +260,8 @@ pub(crate) fn shell_certificate_role(source: &FaceCertificate, inner: bool) -> R
     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;
+pub(crate) fn flat_source_certificate(source: &solidcraft_kernel::FaceSource) -> Option<(u64, FaceCertificate)> {
+    use solidcraft_kernel::FaceSource;
     match source {
         FaceSource::Box { producer: Some(producer), axis, high, .. } => Some((*producer, FaceCertificate::Box { axis: *axis, high: *high })),
         FaceSource::CertifiedExtrudeSide { producer, sketch, curve, .. } => {
@@ -277,8 +277,8 @@ pub(crate) fn flat_source_certificate(source: &solvecraft_kernel::FaceSource) ->
     }
 }
 
-pub(crate) fn flat_source_matches(certificate: &FaceCertificate, source: &solvecraft_kernel::FaceSource, producer: u64) -> bool {
-    use solvecraft_kernel::FaceSource;
+pub(crate) fn flat_source_matches(certificate: &FaceCertificate, source: &solidcraft_kernel::FaceSource, producer: u64) -> bool {
+    use solidcraft_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
@@ -324,14 +324,14 @@ impl<'a> ExactSketchCurves<'a> {
             if curve.construction
                 || !matches!(
                     curve.kind,
-                    solvecraft_sketch::CurveKind::Line { .. }
-                        | solvecraft_sketch::CurveKind::Arc { .. }
-                        | solvecraft_sketch::CurveKind::Circle { .. }
+                    solidcraft_sketch::CurveKind::Line { .. }
+                        | solidcraft_sketch::CurveKind::Arc { .. }
+                        | solidcraft_sketch::CurveKind::Circle { .. }
                 )
             {
                 continue;
             }
-            let originals = if let solvecraft_sketch::CurveKind::Circle { c, r } = curve.kind {
+            let originals = if let solidcraft_sketch::CurveKind::Circle { c, r } = curve.kind {
                 sketch
                     .sketch
                     .point(c)
@@ -364,7 +364,7 @@ fn exact_segment_contains(original: &Seg2, generated: &Seg2) -> bool {
         (Seg2::Line { a, b }, Seg2::Line { a: c, b: d }) => {
             let direction = *b - *a;
             let scale = direction.len().max((*d - *c).len()).max(1.);
-            let interval = |point: solvecraft_geom::Vec2| {
+            let interval = |point: solidcraft_geom::Vec2| {
                 let t = (point - *a).dot(direction) / direction.len2();
                 (-1e-10..=1. + 1e-10).contains(&t)
             };
@@ -400,18 +400,18 @@ fn exact_segment_contains(original: &Seg2, generated: &Seg2) -> bool {
 }
 
 impl Document {
-    pub fn configuration_face_target(&self, body: &ModelBody, index: usize, point: solvecraft_geom::Vec3) -> Result<crate::config::ConfigFaceTarget> {
+    pub fn configuration_face_target(&self, body: &ModelBody, index: usize, point: solidcraft_geom::Vec3) -> Result<crate::config::ConfigFaceTarget> {
         let names = crate::naming::face_names(body);
         let mut name = names
             .get(index)
             .map(|name| crate::naming::strip_piece(name).to_string())
             .ok_or_else(|| DocError::Unknown("face source name missing".into()))?;
         let origin = match body.body.face_sources().and_then(|sources| sources.get(index)).and_then(Option::as_ref) {
-            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,
+            Some(solidcraft_kernel::FaceSource::Imported { producer: Some(producer), .. })
+            | Some(solidcraft_kernel::FaceSource::CertifiedExtrudeSide { producer, .. })
+            | Some(solidcraft_kernel::FaceSource::CertifiedExtrudeCap { producer, .. })
+            | Some(solidcraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), .. })
+            | Some(solidcraft_kernel::FaceSource::Box { producer: Some(producer), .. }) => *producer,
             _ => name
                 .strip_prefix('F')
                 .and_then(|name| name.split_once(':'))
@@ -439,7 +439,7 @@ 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 let solidcraft_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()));
             }
@@ -452,7 +452,7 @@ impl Document {
             certificate.validate()?;
             return Ok(Some(certificate));
         }
-        if let solvecraft_kernel::FaceSource::Imported { item, face, payload_sha256: Some(digest), producer: Some(producer) } = source {
+        if let solidcraft_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()));
             }
@@ -461,7 +461,7 @@ impl Document {
             return Ok(Some(certificate));
         }
         let certificate = match source {
-            solvecraft_kernel::FaceSource::CertifiedExtrudeSide { producer, sketch, curve, .. } => {
+            solidcraft_kernel::FaceSource::CertifiedExtrudeSide { producer, sketch, curve, .. } => {
                 if !self.feature(*producer).is_some_and(|feature| matches!(feature.kind, FeatureKind::Extrude { .. })) {
                     return Err(DocError::Invalid("side source producer missing".into()));
                 }
@@ -472,16 +472,16 @@ impl Document {
         certificate.validate()?;
         Ok(Some(certificate))
     }
-    pub fn strong_face_target(&self, body: &ModelBody, index: usize, point: solvecraft_geom::Vec3) -> Result<crate::config::ConfigFaceTarget> {
+    pub fn strong_face_target(&self, body: &ModelBody, index: usize, point: solidcraft_geom::Vec3) -> Result<crate::config::ConfigFaceTarget> {
         let mut target = self.configuration_face_target(body, index, point)?;
         match body.body.face_sources().and_then(|sources| sources.get(index)).and_then(Option::as_ref) {
-            Some(solvecraft_kernel::FaceSource::Box { producer: Some(producer), axis, high, .. }) => {
+            Some(solidcraft_kernel::FaceSource::Box { producer: Some(producer), axis, high, .. }) => {
                 target.origin_feature = *producer;
                 let axis_name = ["x", "y", "z"].get(*axis as usize).ok_or_else(|| DocError::Invalid("invalid box face axis".into()))?;
                 target.name = format!("F{producer}:{}{axis_name}", if *high { "+" } else { "-" });
                 target.certificate = Some(FaceCertificate::Box { axis: *axis, high: *high });
             }
-            Some(solvecraft_kernel::FaceSource::CertifiedExtrudeCap { producer, sketch, high, outer, holes, .. }) => {
+            Some(solidcraft_kernel::FaceSource::CertifiedExtrudeCap { producer, sketch, high, outer, holes, .. }) => {
                 target.origin_feature = *producer;
                 target.name = format!("F{producer}:cap:{}:{}", if *high { "high" } else { "low" }, cap_key(outer, holes));
                 target.certificate = Some(FaceCertificate::ExtrudeCap { sketch: *sketch, high: *high, outer: outer.clone(), holes: holes.clone() });
@@ -507,15 +507,15 @@ mod tests {
     use super::*;
     use serde_json::json;
 
-    fn solved(mut sketch: solvecraft_sketch::Sketch) -> SolvedSketch {
-        let report = solvecraft_sketch::solve(&mut sketch);
-        SolvedSketch { feature: 1, name: "sources".into(), plane: solvecraft_geom::Plane::XY, sketch, report, profiles: Vec::new() }
+    fn solved(mut sketch: solidcraft_sketch::Sketch) -> SolvedSketch {
+        let report = solidcraft_sketch::solve(&mut sketch);
+        SolvedSketch { feature: 1, name: "sources".into(), plane: solidcraft_geom::Plane::XY, sketch, report, profiles: Vec::new() }
     }
 
     #[test]
     fn prepared_sources_keep_exact_identity_and_reject_ambiguity() {
-        use solvecraft_geom::Vec2;
-        let mut sketch = solvecraft_sketch::Sketch::new();
+        use solidcraft_geom::Vec2;
+        let mut sketch = solidcraft_sketch::Sketch::new();
         sketch.add_line(Vec2::ZERO, Vec2::new(10., 0.), None, None, Some("line")).unwrap();
         sketch.add_circle(Vec2::new(20., 0.), 2., None, Some("circle")).unwrap();
         let construction = sketch.add_line(Vec2::ZERO, Vec2::new(10., 0.), None, None, Some("construction")).unwrap();
@@ -532,7 +532,7 @@ mod tests {
         // A prepared pass borrows one immutable evaluated sketch, so an upstream edit
         // necessarily prepares fresh sources rather than retaining stale coordinates.
         let mut moved = sketch.clone();
-        moved.sketch = solvecraft_sketch::Sketch::new();
+        moved.sketch = solidcraft_sketch::Sketch::new();
         moved.sketch.add_line(Vec2::new(0., 1.), Vec2::new(10., 1.), None, None, Some("line")).unwrap();
         assert_eq!(ExactSketchCurves::new(&moved).find(&partial), None);
     }
@@ -540,8 +540,8 @@ mod tests {
     #[test]
     #[ignore = "manual optimized certification microbenchmark; no timing assertion"]
     fn benchmark_prepared_extrude_sources() {
-        use solvecraft_geom::Vec2;
-        let mut sketch = solvecraft_sketch::Sketch::new();
+        use solidcraft_geom::Vec2;
+        let mut sketch = solidcraft_sketch::Sketch::new();
         for i in 0..1000 {
             let y = i as f64;
             sketch.add_line(Vec2::new(0., y), Vec2::new(10., y), None, None, None).unwrap();
@@ -593,7 +593,7 @@ mod tests {
     #[test]
     fn analytic_arc_interval_refuses_unsampled_gaps_and_accepts_wrap_reversal() {
         let radians = |degrees: f64| degrees.to_radians();
-        let arc = |start, sweep| Seg2::Arc { center: solvecraft_geom::Vec2::default(), radius: 10., start: radians(start), sweep: radians(sweep) };
+        let arc = |start, sweep| Seg2::Arc { center: solidcraft_geom::Vec2::default(), radius: 10., start: radians(start), sweep: radians(sweep) };
         assert!(!exact_segment_contains(&arc(10., 350.), &arc(20., 360.)), "five point probes missed the missing ten-degree gap");
         assert!(!exact_segment_contains(&arc(10., 350.), &arc(20., -360.)));
         assert!(exact_segment_contains(&arc(350., 40.), &arc(355., 20.)));

crates/doc/src/config_clone.rs

@@ -142,7 +142,7 @@ mod tests {
                     body: "Old".into(),
                     origin_feature: 3,
                     name: "F3:+z".into(),
-                    point: solvecraft_geom::Vec3::new(1., 1., 2.),
+                    point: solidcraft_geom::Vec3::new(1., 1., 2.),
                     certificate: None,
                 }),
             ],
@@ -199,7 +199,7 @@ mod tests {
                     body: "Foreign".into(),
                     origin_feature: 3,
                     name: "F3:+z".into(),
-                    point: solvecraft_geom::Vec3::ZERO,
+                    point: solidcraft_geom::Vec3::ZERO,
                     certificate: None,
                 }),
             ],

crates/doc/src/config_shell_tests.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::{FeatureKind, Model, PlaneRef};
 use serde_json::json;
-use solvecraft_geom::{Vec2, Vec3};
+use solidcraft_geom::{Vec2, Vec3};
 
 fn shell_document() -> (Document, u64, u64) {
     let mut doc = Document::new("certified shell");
@@ -35,23 +35,23 @@ fn face_index(body: &ModelBody, inner: bool) -> usize {
         .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,.. }))
+            matches!(source, Some(solidcraft_kernel::FaceSource::ShellPlanar { inner: current, source, .. })
+            if *current == inner && matches!(source.as_ref(), solidcraft_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());
+    let plane = solidcraft_geom::Plane::XY;
+    let same = |planes: &[Option<solidcraft_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 },
+        solidcraft_geom::Plane { origin: Vec3::X, ..plane },
+        solidcraft_geom::Plane { x: -plane.x, y: -plane.y, ..plane },
+        solidcraft_geom::Plane { y: -plane.y, ..plane },
     ] {
         assert!(!same(&[Some(plane), Some(different)]));
     }
@@ -82,15 +82,15 @@ fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {
     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)))
+        matches!(source, Some(solidcraft_kernel::FaceSource::ShellPlanar { inner: false, source, .. }) if matches!(source.as_ref(), solidcraft_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();
+    let projected = crate::project::resolve_anchored_face(&doc, &state, &outer_plane, solidcraft_sketch::LinkKind::Project, &outer_anchor).unwrap();
+    let mut linked = solidcraft_sketch::Sketch::new();
+    let link = linked.add_link(solidcraft_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();
@@ -100,7 +100,7 @@ fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {
     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 mut sketch = solidcraft_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 {
@@ -136,11 +136,11 @@ fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {
     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!((solidcraft_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();
+        crate::project::resolve_anchored_face(&doc, &changed, &changed_outer_plane, solidcraft_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:?}");
@@ -173,11 +173,11 @@ fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {
 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");
+    legacy["format"] = json!("solidcraft/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"], crate::format::format_string(crate::format::FORMAT));
-    current["format"] = json!("solvecraft/12");
+    current["format"] = json!("solidcraft/12");
     crate::format::pieces_in_shell_order(&mut legacy["features"]);
     assert_eq!(legacy, current, "the migration preserves every prior field");
     legacy["format"] = json!(crate::format::format_string(crate::format::FORMAT + 1));
@@ -199,7 +199,7 @@ fn regularized_shell_keeps_legacy_and_explicit_single_face_projections_closed()
             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");
+            assert_eq!(body.body.face_sources().unwrap().iter().filter(|source|matches!(source,Some(solidcraft_kernel::FaceSource::ShellPlanar {inner:false,source,..}) if matches!(source.as_ref(),solidcraft_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
@@ -208,14 +208,14 @@ fn regularized_shell_keeps_legacy_and_explicit_single_face_projections_closed()
                 .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 source = solidcraft_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();
+            let legacy = crate::project::resolve(&doc, &values, &state, &plane, solidcraft_sketch::LinkKind::Project, &source).unwrap();
+            let explicit = crate::project::resolve_face_indices(&state, &plane, solidcraft_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();
+            let mut sketch = solidcraft_sketch::Sketch::new();
+            let link = sketch.add_link(solidcraft_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:?}");
@@ -242,11 +242,11 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
     // 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 {
+    let raw_source = solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(20., 12., 10.)).unwrap().with_paint(Some(solidcraft_kernel::Paint {
         opacity: 1.,
-        faces: vec![solvecraft_kernel::FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }],
+        faces: vec![solidcraft_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 raw = solidcraft_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(),
@@ -258,13 +258,13 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
     assert_eq!(crate::naming::parent_piece(&captured), Some(stem.as_str()), "actual strip capture records a piece name");
     // What the builds before format 14 saved for that piece: its number by centroid order.
     let former = format!("{stem}#1");
-    let mut sketch = solvecraft_sketch::Sketch::new();
+    let mut sketch = solidcraft_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();
+    let geometry: Vec<_> = (0..4).map(|i| solidcraft_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.) },
+            solidcraft_sketch::LinkKind::Project,
+            solidcraft_sketch::LinkSource::Face { body: "Case".into(), at: Vec3::new(20., 6., 1.) },
             &geometry,
         )
         .unwrap();
@@ -289,7 +289,7 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
         )
         .unwrap();
     let mut legacy: serde_json::Value = serde_json::from_str(&doc.to_json()).unwrap();
-    legacy["format"] = json!("solvecraft/12");
+    legacy["format"] = json!("solidcraft/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();
@@ -308,7 +308,7 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
             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,
+                (solidcraft_kernel::measure(&material.body).unwrap().volume - 24.).abs() < 1e-8,
                 "old24mm3 profile must not silently become120mm3 wall profile"
             );
             let bounds = material.mesh().bounds();
@@ -320,8 +320,8 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
 
 #[test]
 fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
-    use solvecraft_kernel::{FacePaint, Paint};
-    use solvecraft_sketch::{LinkKind, LinkSource, Sketch};
+    use solidcraft_kernel::{FacePaint, Paint};
+    use solidcraft_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();
@@ -362,14 +362,14 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
         .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(
+    let cavity_box = solidcraft_kernel::box_solid(Vec3::new(-38., -28., 2.), Vec3::new(38., 28., 35.)).unwrap();
+    let cavity = solidcraft_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 raw = solidcraft_kernel::boolean(&old_source, &cavity, solidcraft_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(),
@@ -403,18 +403,18 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
             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 = solidcraft_geom::Plane::YZ.to_local(*points.first().unwrap());
+        let b = solidcraft_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 = solidcraft_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));
+        geometry.push(solidcraft_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();
@@ -422,7 +422,7 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
     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"))
+        .add_feature(FeatureKind::Sketch { plane: PlaneRef::Custom { plane: solidcraft_geom::Plane::YZ }, sketch }, Some("Saved corner strip"))
         .unwrap();
     let boss = doc
         .add_feature(
@@ -454,7 +454,7 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
             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,
+                (solidcraft_kernel::measure(&material.body).unwrap().volume - 12.).abs() < 1e-7,
                 "two-mm strip cannot expand to a full thirty-mm wall"
             );
         }
@@ -463,8 +463,8 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
 
 #[test]
 fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() {
-    use solvecraft_kernel::{BoolOp, FacePaint, Paint};
-    use solvecraft_sketch::{LinkKind, LinkSource, Sketch};
+    use solidcraft_kernel::{BoolOp, FacePaint, Paint};
+    use solidcraft_sketch::{LinkKind, LinkSource, Sketch};
     let mut doc = Document::new("public stepped tab case");
     doc.set_param("length", "40", Some("mm"), None).unwrap();
     doc.set_param("wall", "2", Some("mm"), None).unwrap();
@@ -508,7 +508,7 @@ fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() {
         .body
         .clone()
         .with_paint(Some(Paint { opacity: 1., faces: vec![FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }] }));
-    let old_cut = solvecraft_kernel::boolean(&old_stock, &before.body("Pocket tool").unwrap().body, BoolOp::Cut).unwrap().unwrap();
+    let old_cut = solidcraft_kernel::boolean(&old_stock, &before.body("Pocket tool").unwrap().body, BoolOp::Cut).unwrap().unwrap();
     let mut old_body = ModelBody::new("Case".into(), old_cut, cut);
     old_body.names = crate::naming::NameCell::new(Some(std::sync::Arc::new(crate::naming::NamingOrigin {
         feature: doc.feature(cut).unwrap().clone(),
@@ -522,7 +522,7 @@ fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() {
     let index = crate::naming::face_on_body(&old_body, &former, at).unwrap().0;
     let mut old_state = crate::ModelState::default();
     old_state.bodies.push(old_body);
-    let plane = solvecraft_geom::Plane::YZ;
+    let plane = solidcraft_geom::Plane::YZ;
     let resolved = crate::project::resolve_face_indices(&old_state, &plane, LinkKind::Project, "Case", &[index]).unwrap();
     let current_state = model.state();
     let current = current_state.body("Case").unwrap();
@@ -569,15 +569,15 @@ fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() {
             assert_eq!(saved.sketch.curves, original.curves);
             let stock = state.bodies.iter().find(|b| b.feature == material).unwrap();
             assert!(
-                (solvecraft_kernel::measure(&stock.body).unwrap().volume - 200.).abs() < 1e-7,
+                (solidcraft_kernel::measure(&stock.body).unwrap().volume - 200.).abs() < 1e-7,
                 "saved10x20 patch must not become30x20 wall; actualvolume={}, bounds={:?}, originalpoints={:?}",
-                solvecraft_kernel::measure(&stock.body).unwrap().volume,
+                solidcraft_kernel::measure(&stock.body).unwrap().volume,
                 stock.mesh().bounds(),
                 original.points
             );
             let case = state.body("Case").unwrap();
             let expected = length * 30. * 20. + 8. * 10. * 8. - (length - 2. * wall) * (30. - 2. * wall) * (20. - wall);
-            assert!((solvecraft_kernel::measure(&case.body).unwrap().volume - expected).abs() < 1e-6);
+            assert!((solidcraft_kernel::measure(&case.body).unwrap().volume - expected).abs() < 1e-6);
         }
     }
 }

crates/doc/src/config_styles.rs

@@ -3,9 +3,9 @@ use super::Column;
 use crate::{DocError, Document, FeatureKind, ModelState, Result};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;
 
-pub(crate) fn shell_plane_family(planes: impl IntoIterator<Item = Option<solvecraft_geom::Plane>>) -> bool {
+pub(crate) fn shell_plane_family(planes: impl IntoIterator<Item = Option<solidcraft_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))
@@ -112,7 +112,7 @@ impl Document {
             (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 { .. }))))
+                    && 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, solidcraft_sketch::CurveKind::Line { .. } | solidcraft_sketch::CurveKind::Circle { .. } | solidcraft_sketch::CurveKind::Arc { .. }))))
             }
             (FaceCertificate::Imported { .. }, FeatureKind::Import { .. }) => true,
             _ => false,
@@ -138,7 +138,7 @@ impl Document {
                 }
                 (super::FaceCertificate::ExtrudeSide { sketch, curve }, FeatureKind::Extrude { sketch: producer_sketch, extent, operation: crate::Operation::NewBody, .. }) => {
                     sketch == producer_sketch && extent.taper.is_none() && role == format!("side:{curve}")
-                        && 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 { .. }))))
+                        && 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, solidcraft_sketch::CurveKind::Line { .. } | solidcraft_sketch::CurveKind::Circle { .. } | solidcraft_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 { .. }) => {
@@ -183,7 +183,7 @@ impl Document {
         }
         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)
+                matches!(current, Some(solidcraft_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.
@@ -203,11 +203,11 @@ impl Document {
                     let matched = match (&target.certificate, source) {
                         (
                             Some(super::FaceCertificate::Box { axis, high }),
-                            Some(solvecraft_kernel::FaceSource::Box { producer: Some(producer), axis: current_axis, high: current_high, .. }),
+                            Some(solidcraft_kernel::FaceSource::Box { producer: Some(producer), axis: current_axis, high: current_high, .. }),
                         ) => *producer == target.origin_feature && axis == current_axis && high == current_high,
                         (
                             Some(super::FaceCertificate::ExtrudeCap { sketch, high, outer, holes }),
-                            Some(solvecraft_kernel::FaceSource::CertifiedExtrudeCap {
+                            Some(solidcraft_kernel::FaceSource::CertifiedExtrudeCap {
                                 producer,
                                 sketch: current_sketch,
                                 high: current_high,
@@ -234,7 +234,7 @@ impl Document {
         }
         if let Some(super::FaceCertificate::ExtrudeSide { sketch, curve }) = &target.certificate {
             let indices: Vec<_> = body.body.face_sources().into_iter().flatten().enumerate().filter_map(|(index, source)| {
-                matches!(source, Some(solvecraft_kernel::FaceSource::CertifiedExtrudeSide { producer, sketch: current_sketch, curve: current_curve, .. }) if *producer == target.origin_feature && current_sketch == sketch && current_curve == curve).then_some(index)
+                matches!(source, Some(solidcraft_kernel::FaceSource::CertifiedExtrudeSide { producer, sketch: current_sketch, curve: current_curve, .. }) if *producer == target.origin_feature && current_sketch == sketch && current_curve == curve).then_some(index)
             }).collect();
             if indices.is_empty() {
                 return Err(DocError::Unknown("constructed side certificate no longer exists".into()));
@@ -243,7 +243,7 @@ impl Document {
         }
         if let Some(super::FaceCertificate::Imported { payload_sha256, item, face }) = &target.certificate {
             let indices: Vec<_> = body.body.face_sources().into_iter().flatten().enumerate().filter_map(|(index, source)| {
-                matches!(source, Some(solvecraft_kernel::FaceSource::Imported { item: current_item, face: current_face, payload_sha256: Some(digest), producer: Some(producer) }) if current_item == item && current_face == face && digest == payload_sha256 && *producer == target.origin_feature).then_some(index)
+                matches!(source, Some(solidcraft_kernel::FaceSource::Imported { item: current_item, face: current_face, payload_sha256: Some(digest), producer: Some(producer) }) if current_item == item && current_face == face && digest == payload_sha256 && *producer == target.origin_feature).then_some(index)
             }).collect();
             if indices.is_empty() {
                 return Err(DocError::Unknown("immutable import face certificate no longer exists".into()));

crates/doc/src/construct.rs

@@ -8,8 +8,8 @@
 use std::collections::BTreeMap;
 
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Plane, Vec2, Vec3};
-use solvecraft_kernel::{self as kernel, FaceSurface};
+use solidcraft_geom::{Plane, Vec2, Vec3};
+use solidcraft_kernel::{self as kernel, FaceSurface};
 
 use crate::eval::{ModelBody, ModelState};
 use crate::expr::{Kind, Value};

crates/doc/src/document.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Plane, Vec2, Vec3};
-use solvecraft_sketch::Sketch;
+use solidcraft_geom::{Plane, Vec2, Vec3};
+use solidcraft_sketch::Sketch;
 
 use crate::construct::{AxisDef, GeoRef, PointDef};
 use crate::expr::{self, Kind};
@@ -884,7 +884,7 @@ pub enum FeatureKind {
         step: String,
         /// The file's product/assembly tree, kept for components.
         #[serde(default, skip_serializing_if = "Vec::is_empty")]
-        components: Vec<solvecraft_kernel::StepNode>,
+        components: Vec<solidcraft_kernel::StepNode>,
     },
     /// Rebuild an upstream constant-section mesh with analytic planar/cylindrical faces.
     MeshConvert {
@@ -1697,7 +1697,7 @@ pub struct Document {
 pub struct NamedView {
     #[serde(default)]
     pub name: String,
-    pub target: solvecraft_geom::Vec3,
+    pub target: solidcraft_geom::Vec3,
     pub yaw: f64,
     pub pitch: f64,
     pub distance: f64,
@@ -1774,13 +1774,13 @@ impl Document {
         let mut st = state.clone();
         for b in &mut st.bodies {
             let c = self.body_color(b);
-            let faces: Vec<solvecraft_kernel::FacePaint> = self
+            let faces: Vec<solidcraft_kernel::FacePaint> = self
                 .face_colors(b)
                 .into_iter()
-                .map(|(face, l)| solvecraft_kernel::FacePaint { face, color: l.rgb(), opacity: l.opacity as f32 })
+                .map(|(face, l)| solidcraft_kernel::FacePaint { face, color: l.rgb(), opacity: l.opacity as f32 })
                 .collect();
             let opacity = self.model_body_opacity(b) as f32;
-            let paint = solvecraft_kernel::Paint { opacity, faces };
+            let paint = solidcraft_kernel::Paint { opacity, faces };
             if c != b.body.color() || b.body.paint() != Some(&paint) {
                 b.body = b.body.clone().with_color(c).with_paint(Some(paint));
             }
@@ -2214,14 +2214,14 @@ impl Document {
         &self,
         vals: &std::collections::BTreeMap<String, expr::Value>,
         sk: &mut Sketch,
-        stored: &solvecraft_sketch::DrivingValues,
-    ) -> Result<solvecraft_sketch::SolveReport> {
+        stored: &solidcraft_sketch::DrivingValues,
+    ) -> Result<solidcraft_sketch::SolveReport> {
         self.apply_dimension_values(vals, sk)?;
-        let mut report = solvecraft_sketch::solve_after_value_edit(sk, stored);
+        let mut report = solidcraft_sketch::solve_after_value_edit(sk, stored);
         if !sk.offsets.is_empty() || !sk.freeform_offsets.is_empty() {
             // Source dimensions may have moved curves during the solve.
             sk.refresh_offsets()?;
-            report = if report.ok() { solvecraft_sketch::solve(sk) } else { solvecraft_sketch::solve_after_value_edit(sk, stored) };
+            report = if report.ok() { solidcraft_sketch::solve(sk) } else { solidcraft_sketch::solve_after_value_edit(sk, stored) };
         }
         Ok(report)
     }

crates/doc/src/eval.rs

@@ -5,9 +5,9 @@ use std::hash::{Hash, Hasher};
 use std::sync::{Arc, OnceLock};
 
 use serde::Serialize;
-use solvecraft_geom::{Mesh, Plane, Region2, Vec2, Vec3};
-use solvecraft_kernel::{self as kernel, Body, BoolOp};
-use solvecraft_sketch::{CurveKind, Profile, SolveReport, find_profiles};
+use solidcraft_geom::{Mesh, Plane, Region2, Vec2, Vec3};
+use solidcraft_kernel::{self as kernel, Body, BoolOp};
+use solidcraft_sketch::{CurveKind, Profile, SolveReport, find_profiles};
 
 use crate::expr::{self, Kind, Value};
 use crate::lineage::Traced;
@@ -79,7 +79,7 @@ pub struct SolvedSketch {
     pub feature: u64,
     pub name: String,
     pub plane: Plane,
-    pub sketch: solvecraft_sketch::Sketch,
+    pub sketch: solidcraft_sketch::Sketch,
     pub report: SolveReport,
     pub profiles: Vec<Profile>,
 }
@@ -217,7 +217,7 @@ fn thread_on(st: &ModelState, feature: u64, p: Vec3, designation: Option<&str>,
 /// profile, 60° flanks): cut from the shaft (external) or the hole wall (internal), running from
 /// `start` to `end` along the axis. `radius` is the face's own radius; `open` says which ends
 /// of the threaded length are free ends of the face.
-fn thread_groove(t: &ThreadInfo, radius: f64, open: (bool, bool)) -> Result<solvecraft_geom::Mesh> {
+fn thread_groove(t: &ThreadInfo, radius: f64, open: (bool, bool)) -> Result<solidcraft_geom::Mesh> {
     let (p, d) = (t.pitch, t.major_diameter);
     let h = p * 3f64.sqrt() / 2.0;
     let slope = (std::f64::consts::PI / 6.0).tan();
@@ -538,7 +538,7 @@ const QUANTUM: f64 = 1e-6;
 
 /// Put what a solve writes into a sketch on the [`QUANTUM`] grid: positions, radii and the
 /// measured values of driven dimensions.
-fn quantize(sk: &mut solvecraft_sketch::Sketch) {
+fn quantize(sk: &mut solidcraft_sketch::Sketch) {
     let q = |v: f64| (v / QUANTUM).round() * QUANTUM;
     for p in &mut sk.points {
         p.pos = Vec2::new(q(p.pos.x), q(p.pos.y));
@@ -572,7 +572,7 @@ fn feature_json(f: &Feature) -> String {
 /// constraints' values. Nothing else: what evaluation derives for its own copy (an offset's
 /// upgraded topology, refreshed links) stays out of the stored sketch. A `solved` that does not
 /// match `stored` entity for entity is not adopted.
-fn adopt_solution(stored: &mut solvecraft_sketch::Sketch, solved: &solvecraft_sketch::Sketch) {
+fn adopt_solution(stored: &mut solidcraft_sketch::Sketch, solved: &solidcraft_sketch::Sketch) {
     if stored.points.len() != solved.points.len()
         || stored.curves.len() != solved.curves.len()
         || stored.constraints.len() != solved.constraints.len()
@@ -771,7 +771,7 @@ impl Model {
     /// recomputed; the next [`Model::evaluate`] recomputes from the sketch on. Returns `false`,
     /// changing nothing, when the sketch has no evaluated result or a feature before it is
     /// already stale (only a full evaluation brings that up to date).
-    pub fn show_live_sketch(&mut self, feature: u64, sketch: solvecraft_sketch::Sketch, report: SolveReport) -> bool {
+    pub fn show_live_sketch(&mut self, feature: u64, sketch: solidcraft_sketch::Sketch, report: SolveReport) -> bool {
         let Some(i) = self.results.iter().position(|r| r.id == feature) else { return false };
         if self.results.iter().take(i).any(|r| r.stale) {
             return false;
@@ -1042,7 +1042,7 @@ pub fn select_profiles(ss: &SolvedSketch, sel: &ProfileSel) -> Result<Vec<Region
         // "All" means what was drawn: projected reference geometry (a face's auto-projected
         // edges) only counts when the drawn curves alone make no profile.
         ProfileSel::All => {
-            let drawn = solvecraft_sketch::find_drawn_profiles(&ss.sketch);
+            let drawn = solidcraft_sketch::find_drawn_profiles(&ss.sketch);
             if drawn.is_empty() { ps.iter().map(|p| p.region.clone()).collect() } else { drawn.into_iter().map(|p| p.region).collect() }
         }
         ProfileSel::Indices { indices } => {
@@ -1066,7 +1066,7 @@ pub fn select_profiles(ss: &SolvedSketch, sel: &ProfileSel) -> Result<Vec<Region
             let mut v = Vec::new();
             for p in points {
                 // Innermost profile containing the point.
-                let found = solvecraft_sketch::profile_at_point(ps, *p).and_then(|i| ps.get(i));
+                let found = solidcraft_sketch::profile_at_point(ps, *p).and_then(|i| ps.get(i));
                 v.push(found.ok_or_else(|| DocError::Unknown(format!("profile at {:?} in {}", [p.x, p.y], ss.name)))?.region.clone());
             }
             v
@@ -1079,12 +1079,12 @@ pub fn select_profiles(ss: &SolvedSketch, sel: &ProfileSel) -> Result<Vec<Region
 }
 
 /// The error for a profile picked by curves that no longer names exactly one profile.
-pub fn curve_pick_error(e: solvecraft_sketch::CurvePick, ids: &[String], sketch: &str) -> DocError {
+pub fn curve_pick_error(e: solidcraft_sketch::CurvePick, ids: &[String], sketch: &str) -> DocError {
     match e {
-        solvecraft_sketch::CurvePick::Missing => DocError::Invalid(format!(
+        solidcraft_sketch::CurvePick::Missing => DocError::Invalid(format!(
             "no profile of {sketch} is bounded by exactly the curves {ids:?} (a curve was deleted, or another curve now cuts the region)"
         )),
-        solvecraft_sketch::CurvePick::Ambiguous(n) => DocError::Invalid(format!(
+        solidcraft_sketch::CurvePick::Ambiguous(n) => DocError::Invalid(format!(
             "{n} profiles of {sketch} are bounded by exactly the curves {ids:?}; add a curve that tells them apart, or pick by index or point"
         )),
     }
@@ -1389,7 +1389,7 @@ fn grow_profile_for_coplanar(st: &ModelState, r: &Region2, op: Operation, target
     let delta = (size * 0.005).max(1e-3);
     let lp = r.outer.ccw();
     let lines: Option<Vec<(Vec2, Vec2)>> =
-        lp.segs.iter().map(|s| if let solvecraft_geom::Seg2::Line { a, b } = *s { Some((a, b)) } else { None }).collect();
+        lp.segs.iter().map(|s| if let solidcraft_geom::Seg2::Line { a, b } = *s { Some((a, b)) } else { None }).collect();
     let Some(lines) = lines else { return r.clone() };
     let inside_any = |p: Vec3| meshes.iter().any(|m| m.contains(p));
     let mut grow = vec![0.0; lines.len()];
@@ -1436,7 +1436,7 @@ fn grow_profile_for_coplanar(st: &ModelState, r: &Region2, op: Operation, target
         let t = (p1 - p0).cross(d1) / den;
         pts.push(p0 + d0 * t);
     }
-    Region2 { outer: solvecraft_geom::Loop2::polygon(&pts), holes: r.holes.clone() }
+    Region2 { outer: solidcraft_geom::Loop2::polygon(&pts), holes: r.holes.clone() }
 }
 
 /// Booleans struggle with coincident faces (a cut starting on the face it cuts, a boss
@@ -1771,7 +1771,7 @@ fn hole_tools(
     let seam = std::cell::Cell::new(0.0);
     let disc = |rad: f64| {
         seam.set(seam.get() + 0.613);
-        Region2 { outer: solvecraft_geom::Loop2::circle_from(Vec2::ZERO, rad, seam.get()), holes: vec![] }
+        Region2 { outer: solidcraft_geom::Loop2::circle_from(Vec2::ZERO, rad, seam.get()), holes: vec![] }
     };
     let cyl = |rad: f64, lo: f64, hi: f64| -> Result<Body> {
         kernel::extrude(&plane, &[disc(rad)], lo, hi)?.pop().ok_or_else(|| DocError::Invalid("hole tool".into()))
@@ -1794,7 +1794,7 @@ fn hole_tools(
                 let side = up.any_perp();
                 let rp = Plane::new(*position, side, up).ok_or_else(|| DocError::Invalid("hole axis".into()))?;
                 let pts = [Vec2::new(0.0, top), Vec2::new(r, top), Vec2::new(r, bottom), Vec2::new(0.0, bottom - tip)];
-                let region = Region2 { outer: solvecraft_geom::Loop2::polygon(&pts), holes: vec![] };
+                let region = Region2 { outer: solidcraft_geom::Loop2::polygon(&pts), holes: vec![] };
                 tools.extend(kernel::revolve(&rp, &[region], Vec2::ZERO, Vec2::Y, std::f64::consts::TAU)?);
             } else {
                 tools.push(cyl(r, bottom, top)?);
@@ -1987,7 +1987,7 @@ fn feature_tools_with_constructor(
     match &f.kind {
         FeatureKind::Extrude { sketch, profiles, extent, operation, targets } => {
             let ss = st.sketch(*sketch).ok_or_else(|| DocError::Unknown(format!("sketch {sketch} (it must come earlier in the timeline)")))?.clone();
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
             // From / To Object: where the face or point lies along the normal, measured over the
             // middle of the profiles.
             let n = ss.plane.normal();
@@ -2130,7 +2130,7 @@ fn feature_tools_with_constructor(
         }
         FeatureKind::Revolve { sketch, profiles, axis, angle, angle2, symmetric, convention, to, .. } => {
             let ss = st.sketch(*sketch).ok_or_else(|| DocError::Unknown(format!("sketch {sketch} (it must come earlier in the timeline)")))?.clone();
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
             let (o, d) = revolve_axis(&ss, axis)?;
             let angles = if to.is_some() {
                 (0.0, None)
@@ -2257,7 +2257,7 @@ fn feature_tools_with_constructor(
             let [a, b] = &sections[..] else { return Err(DocError::Invalid("not supported yet: a point section in a loft of more than two".into())) };
             let (prof, pt) = if a.point.is_some() { (b, a) } else { (a, b) };
             let ss = st.sketch(prof.sketch).ok_or_else(|| DocError::Unknown(format!("sketch {}", prof.sketch)))?;
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(ss, &prof.profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(ss, &prof.profiles)?);
             let [r] = &regions[..] else { return Err(DocError::Invalid("each loft section must be one profile".into())) };
             let ps = st.sketch(pt.sketch).ok_or_else(|| DocError::Unknown(format!("sketch {}", pt.sketch)))?;
             let id = pt.point.as_deref().unwrap_or_default();
@@ -2292,10 +2292,10 @@ fn feature_tools_with_constructor(
             let plane = Plane { origin: *base, x, y: k };
             let c = Vec2::new(r, 0.0);
             let outer = match section {
-                crate::CoilSection::Circular => solvecraft_geom::Loop2::circle(c, s / 2.0),
+                crate::CoilSection::Circular => solidcraft_geom::Loop2::circle(c, s / 2.0),
                 crate::CoilSection::Square => {
                     let h = s / 2.0;
-                    solvecraft_geom::Loop2::polygon(&[c + Vec2::new(-h, -h), c + Vec2::new(h, -h), c + Vec2::new(h, h), c + Vec2::new(-h, h)])
+                    solidcraft_geom::Loop2::polygon(&[c + Vec2::new(-h, -h), c + Vec2::new(h, -h), c + Vec2::new(h, h), c + Vec2::new(-h, h)])
                 }
             };
             let region = Region2 { outer, holes: Vec::new() };
@@ -2310,7 +2310,7 @@ fn feature_tools_with_constructor(
                 let ss = st
                     .sketch(sec.sketch)
                     .ok_or_else(|| DocError::Unknown(format!("sketch {} (it must come earlier in the timeline)", sec.sketch)))?;
-                let regions = solvecraft_sketch::merge_regions(&select_profiles(ss, &sec.profiles)?);
+                let regions = solidcraft_sketch::merge_regions(&select_profiles(ss, &sec.profiles)?);
                 let [r] = &regions[..] else { return Err(DocError::Invalid("each loft section must be one profile".into())) };
                 secs.push((ss.plane, r.outer.clone()));
             }
@@ -2332,7 +2332,7 @@ fn feature_tools_with_constructor(
             };
             let mapped = path_in_frame(doc, ps, f.component)?;
             let ps = mapped.as_ref();
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(ss, profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(ss, profiles)?);
             let start = regions.first().map(|r| ss.plane.to_world(r.centroid())).unwrap_or_default();
             let tool = |r: &Region2, body: Body| crate::lineage::ProfileRoles::swept(Some(ss), Some(r)).tool(body, None);
             // A path through 3D sketch curves follows them as points.
@@ -2407,14 +2407,14 @@ fn pipe_region(vals: &BTreeMap<String, Value>, r: f64, wall: &Option<String>) ->
             if !(wt > 0.0 && wt < r) {
                 return Err(DocError::Invalid("the wall must be thinner than the radius".into()));
             }
-            vec![solvecraft_geom::Loop2::circle(Vec2::ZERO, r - wt).reversed()]
+            vec![solidcraft_geom::Loop2::circle(Vec2::ZERO, r - wt).reversed()]
         }
         None => Vec::new(),
     };
-    Ok(Region2 { outer: solvecraft_geom::Loop2::circle(Vec2::ZERO, r), holes })
+    Ok(Region2 { outer: solidcraft_geom::Loop2::circle(Vec2::ZERO, r), holes })
 }
 
-fn map_wire(wire: &mut solvecraft_sketch::Wire, matrix: &Mat) {
+fn map_wire(wire: &mut solidcraft_sketch::Wire, matrix: &Mat) {
     for point in wire.pts.iter_mut().chain(&mut wire.fit) {
         *point = crate::apply_point(matrix, *point);
     }
@@ -2453,7 +2453,7 @@ fn path_in_frame<'a>(doc: &Document, sketch: &'a SolvedSketch, consumer: u64) ->
     )
     .ok_or_else(|| DocError::Invalid("path sketch frame is invalid".into()))?;
     for wire in &mut mapped.sketch.wires {
-        let matrix = if wire.space == solvecraft_sketch::WireSpace::Component { &relative } else { &inverse };
+        let matrix = if wire.space == solidcraft_sketch::WireSpace::Component { &relative } else { &inverse };
         map_wire(wire, matrix);
     }
     Ok(Cow::Owned(mapped))
@@ -2530,7 +2530,7 @@ fn path_segments(ps: &SolvedSketch, ids: &[String], start: Vec3) -> Result<Vec<k
     if let Some(pts) = path_points(ps, ids, start)? {
         return Ok(pts.windows(2).map(|w| kernel::PathSeg::Line { a: w[0], b: w[1] }).collect());
     }
-    let mut segs: Vec<solvecraft_geom::Seg2> = Vec::new();
+    let mut segs: Vec<solidcraft_geom::Seg2> = Vec::new();
     for id in ids {
         let ci = ps.sketch.curve_index(id).ok_or_else(|| DocError::Unknown(format!("path curve `{id}`")))?;
         segs.extend(ps.sketch.segs(ci));
@@ -2564,12 +2564,12 @@ fn path_segments(ps: &SolvedSketch, ids: &[String], start: Vec3) -> Result<Vec<k
     Ok(segs
         .iter()
         .flat_map(|s| match *s {
-            solvecraft_geom::Seg2::Line { a, b } => vec![kernel::PathSeg::Line { a: w(a), b: w(b) }],
-            solvecraft_geom::Seg2::Arc { center, sweep, .. } => {
+            solidcraft_geom::Seg2::Line { a, b } => vec![kernel::PathSeg::Line { a: w(a), b: w(b) }],
+            solidcraft_geom::Seg2::Arc { center, sweep, .. } => {
                 vec![kernel::PathSeg::Arc { a: w(s.start()), center: w(center), axis: n * sweep.signum(), angle: sweep.abs() }]
             }
             // Free-form path curves are followed as polylines.
-            solvecraft_geom::Seg2::Cubic { .. } | solvecraft_geom::Seg2::Conic { .. } | solvecraft_geom::Seg2::Bezier { .. } => {
+            solidcraft_geom::Seg2::Cubic { .. } | solidcraft_geom::Seg2::Conic { .. } | solidcraft_geom::Seg2::Bezier { .. } => {
                 s.polyline(1e-2).windows(2).map(|q| kernel::PathSeg::Line { a: w(q[0]), b: w(q[1]) }).collect()
             }
         })
@@ -3388,7 +3388,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
                 (None, Some(sid)) => {
                     let ss = st.sketch(*sid).ok_or_else(|| DocError::Unknown(format!("sketch {sid}")))?;
                     // Each curve's exact segments (lines and arcs split by their own plane and cylinder).
-                    let curves: Vec<Vec<solvecraft_geom::Seg2>> = (0..ss.sketch.curves.len())
+                    let curves: Vec<Vec<solidcraft_geom::Seg2>> = (0..ss.sketch.curves.len())
                         .filter(|ci| ss.sketch.curves.get(*ci).is_some_and(|c| !c.construction))
                         .map(|ci| ss.sketch.segs(ci))
                         .filter(|segs| !segs.is_empty())
@@ -3681,7 +3681,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
         }
         FeatureKind::BoundingSolid { bodies, margin } => {
             let m = val(vals, margin, Kind::Length)?;
-            let mut bb = solvecraft_geom::Aabb3::EMPTY;
+            let mut bb = solidcraft_geom::Aabb3::EMPTY;
             for b in st.bodies.iter().filter(|b| bodies.is_empty() || bodies.contains(&b.name)) {
                 bb = bb.union(&b.mesh().bounds());
             }
@@ -3812,7 +3812,7 @@ pub fn state_in_frame_at<'a>(doc: &Document, st: &'a ModelState, comp: u64, fram
         .collect();
     let sketch_m: Vec<Mat> = st.sketches.iter().map(|s| rel(comp_of_feature(s.feature), None)).collect();
     let world_wires_need_mapping = !crate::is_identity(&inv)
-        && st.sketches.iter().any(|sketch| sketch.sketch.wires.iter().any(|wire| wire.space == solvecraft_sketch::WireSpace::World));
+        && st.sketches.iter().any(|sketch| sketch.sketch.wires.iter().any(|wire| wire.space == solidcraft_sketch::WireSpace::World));
     if body_m.iter().chain(&sketch_m).all(crate::is_identity) && !world_wires_need_mapping {
         return Cow::Borrowed(st);
     }
@@ -3835,7 +3835,7 @@ pub fn state_in_frame_at<'a>(doc: &Document, st: &'a ModelState, comp: u64, fram
     }
     for (s, m) in out.sketches.iter_mut().zip(&sketch_m) {
         // Only a sketch the frame moves is copied.
-        let maps_wire = |w: &solvecraft_sketch::Wire| !crate::is_identity(if w.space == solvecraft_sketch::WireSpace::Component { m } else { &inv });
+        let maps_wire = |w: &solidcraft_sketch::Wire| !crate::is_identity(if w.space == solidcraft_sketch::WireSpace::Component { m } else { &inv });
         if crate::is_identity(m) && !s.sketch.wires.iter().any(maps_wire) {
             continue;
         }
@@ -3846,7 +3846,7 @@ pub fn state_in_frame_at<'a>(doc: &Document, st: &'a ModelState, comp: u64, fram
             s.plane = np;
         }
         for wire in &mut s.sketch.wires {
-            let matrix = if wire.space == solvecraft_sketch::WireSpace::Component { m } else { &inv };
+            let matrix = if wire.space == solidcraft_sketch::WireSpace::Component { m } else { &inv };
             map_wire(wire, matrix);
         }
     }
@@ -3919,7 +3919,7 @@ pub fn world_state(doc: &Document, st: &ModelState) -> ModelState {
                     }
                 }
                 for wire in &mut s2.sketch.wires {
-                    if wire.space == solvecraft_sketch::WireSpace::Component {
+                    if wire.space == solidcraft_sketch::WireSpace::Component {
                         map_wire(wire, &m);
                     }
                 }

crates/doc/src/eval_more.rs

@@ -5,7 +5,7 @@ use super::*;
 use crate::EmbossFace;
 use crate::apply_point;
 use crate::sheet;
-use solvecraft_geom::{Loop2, Seg2};
+use solidcraft_geom::{Loop2, Seg2};
 
 pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st: &mut ModelState) -> Result<()> {
     match &f.kind {
@@ -357,7 +357,7 @@ pub(super) fn sheet_eval(
     match &f.kind {
         FeatureKind::SheetBase { sketch, profiles, rule, flip } => {
             let ss = st.sketch(*sketch).ok_or_else(|| DocError::Unknown(format!("sketch {sketch}")))?.clone();
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
             let r = doc.sheet_rule(rule.as_deref());
             let rv = doc.rule_values(vals, &r)?;
             for (k, region) in regions.into_iter().enumerate() {
@@ -631,7 +631,7 @@ pub(super) fn sheet_cut(
         return Ok(Vec::new());
     }
     let Some(ss) = st.sketch(*sketch).cloned() else { return Ok(Vec::new()) };
-    let regions = solvecraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
+    let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
     let n = ss.plane.normal();
     let mut work = sheet::FlatWork::new();
     let faces = tools.iter().fold(0usize, |count, body| count.saturating_add(body.face_count()));
@@ -836,7 +836,7 @@ pub(super) fn sheet_cut(
 
 /// Outline loops (in `plane` coordinates) of the mesh triangles lying in the plane at distance
 /// `level` from `at` along `n`: the edges used by one of them only, chained.
-fn face_loops(mesh: &solvecraft_geom::Mesh, plane: &Plane, at: Vec3, n: Vec3, level: f64, tol: f64) -> Vec<Vec<Vec2>> {
+fn face_loops(mesh: &solidcraft_geom::Mesh, plane: &Plane, at: Vec3, n: Vec3, level: f64, tol: f64) -> Vec<Vec<Vec2>> {
     let on: Vec<[u32; 3]> = mesh
         .triangles
         .iter()

crates/doc/src/eval_surface.rs

@@ -8,7 +8,7 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
             let mut made = Vec::new();
             if let Some(sk) = sketch {
                 let ss = st.sketch(*sk).ok_or_else(|| DocError::Unknown(format!("sketch {sk} (it must come earlier in the timeline)")))?;
-                let regions = solvecraft_sketch::merge_regions(&select_profiles(ss, profiles)?);
+                let regions = solidcraft_sketch::merge_regions(&select_profiles(ss, profiles)?);
                 for r in &regions {
                     made.push(kernel::patch_region(&ss.plane, r)?);
                 }

crates/doc/src/face_anchor.rs

@@ -3,7 +3,7 @@ use crate::config::ConfigFaceTarget;
 use crate::{DocError, Document, EmbossFace, FeatureKind, Model, ModelBody, ModelState, PlaneRef, Result};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use solvecraft_geom::Plane;
+use solidcraft_geom::Plane;
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -311,7 +311,7 @@ pub fn validate_face_anchors_json(value: &Value) -> Result<()> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use solvecraft_geom::Vec3;
+    use solidcraft_geom::Vec3;
     fn fixture() -> (Document, ModelBody, usize, Plane) {
         let mut doc = Document::default();
         let kind: FeatureKind =
@@ -319,7 +319,7 @@ mod tests {
         let id = doc.add_feature(kind, Some("Base")).unwrap();
         let body = ModelBody::new(
             "Base".into(),
-            solvecraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 10.)).unwrap().with_box_certificate(id).unwrap(),
+            solidcraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 10.)).unwrap().with_box_certificate(id).unwrap(),
             id,
         );
         let index = body
@@ -327,7 +327,7 @@ mod tests {
             .face_sources()
             .unwrap()
             .iter()
-            .position(|source| matches!(source, Some(solvecraft_kernel::FaceSource::Box { axis: 2, high: true, .. })))
+            .position(|source| matches!(source, Some(solidcraft_kernel::FaceSource::Box { axis: 2, high: true, .. })))
             .unwrap();
         let canonical = body.body.face_plane(index).unwrap();
         let picked = Plane::new(canonical.origin + canonical.x * 2. + canonical.y * 3., canonical.y, -canonical.x).unwrap();
@@ -350,7 +350,7 @@ mod tests {
         assert!((initial.x - picked.x).len() < 1e-9);
         state.bodies[0] = ModelBody::new(
             "Base".into(),
-            solvecraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 20.))
+            solidcraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 20.))
                 .unwrap()
                 .with_box_certificate(anchor.target.origin_feature)
                 .unwrap(),
@@ -361,7 +361,7 @@ mod tests {
         assert!((changed.origin.x - initial.origin.x).abs() < 1e-9);
         state.bodies[0] = ModelBody::new(
             "Control".into(),
-            solvecraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 30.))
+            solidcraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 30.))
                 .unwrap()
                 .with_box_certificate(anchor.target.origin_feature)
                 .unwrap(),
@@ -369,7 +369,7 @@ mod tests {
         );
         assert!(doc.resolve_face_anchor(&anchor, 0, &state).is_err());
         state.bodies[0].name = "Base".into();
-        state.bodies[0].body = solvecraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 30.))
+        state.bodies[0].body = solidcraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 30.))
             .unwrap()
             .with_box_certificate(anchor.target.origin_feature + 1)
             .unwrap();
@@ -400,8 +400,8 @@ mod tests {
     }
     #[test]
     fn extrude_cap_profile_reordering_never_retargets_an_ordinal_body() {
-        use solvecraft_geom::Vec2;
-        let mut sketch = solvecraft_sketch::Sketch::new();
+        use solidcraft_geom::Vec2;
+        let mut sketch = solidcraft_sketch::Sketch::new();
         for offset in [0., 30.] {
             let points: Vec<_> = [(0., 0.), (10., 0.), (10., 10.), (0., 10.)]
                 .iter()
@@ -432,7 +432,7 @@ mod tests {
         assert_eq!(state.bodies.len(), 2);
         let solved = state.sketch(source).unwrap();
         let regions = crate::select_profiles(solved, &crate::ProfileSel::All).unwrap();
-        let raw = solvecraft_kernel::extrude(&solved.plane, &regions, 0., 10.).unwrap();
+        let raw = solidcraft_kernel::extrude(&solved.plane, &regions, 0., 10.).unwrap();
         assert!(
             crate::config::extrude_cap_bindings(solved, &raw, 0).is_none(),
             "exhausted certification work must leave the complete producer uncertified"
@@ -449,7 +449,7 @@ mod tests {
             .face_sources()
             .unwrap()
             .iter()
-            .position(|source| matches!(source, Some(solvecraft_kernel::FaceSource::CertifiedExtrudeCap { high: true, .. })))
+            .position(|source| matches!(source, Some(solidcraft_kernel::FaceSource::CertifiedExtrudeCap { high: true, .. })))
             .unwrap();
         let picked = body.body.face_plane(index).unwrap();
         let anchor = doc.capture_face_anchor(body, index, &picked, &[], 0, &[]).unwrap();
@@ -476,7 +476,7 @@ mod tests {
                         base: Box::new(PlaneRef::Face { plane: picked, at: picked.origin, name: None, anchor: None }),
                         distance: "2".into(),
                     },
-                    sketch: solvecraft_sketch::Sketch::new(),
+                    sketch: solidcraft_sketch::Sketch::new(),
                 },
                 None,
             )
@@ -492,7 +492,7 @@ mod tests {
     }
     #[test]
     fn warm_root_body_offset_edit_matches_cold_attached_sketch_and_downstream_bounds() {
-        use solvecraft_geom::Vec2;
+        use solidcraft_geom::Vec2;
         let (mut doc, _, _, _) = fixture();
         let mut warm = Model::new();
         warm.evaluate(&doc);
@@ -503,12 +503,12 @@ mod tests {
             .face_sources()
             .unwrap()
             .iter()
-            .position(|source| matches!(source, Some(solvecraft_kernel::FaceSource::Box { axis: 2, high: true, .. })))
+            .position(|source| matches!(source, Some(solidcraft_kernel::FaceSource::Box { axis: 2, high: true, .. })))
             .unwrap();
         let picked = body.body.face_plane(index).unwrap();
         let anchor = doc.capture_face_anchor(body, index, &picked, &[], 0, &[]).unwrap();
         let source_name = body.name.clone();
-        let mut sketch = solvecraft_sketch::Sketch::new();
+        let mut sketch = solidcraft_sketch::Sketch::new();
         let points: Vec<_> =
             [(2., 2.), (4., 2.), (4., 4.), (2., 4.)].iter().map(|(x, y)| sketch.add_point(Vec2::new(*x, *y), None).unwrap()).collect();
         for edge in 0..4 {

crates/doc/src/format.rs

@@ -1,6 +1,6 @@
 //! The design file format version and the migrations that bring older files up to date.
 //!
-//! A design file starts with `"format": "solvecraft/N"`. A file of an older format is read and
+//! A design file starts with `"format": "solidcraft/N"`. A file of an older format is read and
 //! upgraded step by step (N → N+1 → … → current): JSON-level steps first, for changes in the
 //! file's shape, then document-level steps. A file of a newer format than this build knows is
 //! refused with a message saying so, never guessed at.
@@ -55,12 +55,16 @@ use crate::{DocError, Document, Result};
 pub const FORMAT: u32 = 14;
 
 pub fn format_string(n: u32) -> String {
-    format!("solvecraft/{n}")
+    format!("solidcraft/{n}")
 }
 
-/// The version in a format string (`solvecraft/N`).
+/// The format tag of designs saved before the rename. Compatibility shim (docs/compatibility.md):
+/// read, never written.
+pub const LEGACY_FORMAT_PREFIX: &str = "solvecraft/";
+
+/// The version in a format string (`solidcraft/N`, or the legacy `solvecraft/N`).
 pub fn version_of(s: &str) -> Option<u32> {
-    s.strip_prefix("solvecraft/")?.parse().ok()
+    s.strip_prefix("solidcraft/").or_else(|| s.strip_prefix(LEGACY_FORMAT_PREFIX))?.parse().ok()
 }
 
 /// JSON-level upgrades: entry `i` turns format `i + 1` into `i + 2`.
@@ -300,7 +304,7 @@ pub fn read(s: &str) -> Result<Document> {
         if let Some(crate::Feature { kind: crate::FeatureKind::Sketch { sketch, .. }, .. }) = d.features.get_mut(feature_index) {
             let mut spaces = std::collections::BTreeMap::new();
             for link in &sketch.links {
-                spaces.entry(link.id.as_str()).or_insert_with(|| solvecraft_sketch::WireSpace::from_legacy_link(link));
+                spaces.entry(link.id.as_str()).or_insert_with(|| solidcraft_sketch::WireSpace::from_legacy_link(link));
             }
             for wire_index in wire_indices {
                 if let Some(wire) = sketch.wires.get_mut(wire_index) {
@@ -358,9 +362,9 @@ fn validate_sketch_sizes(value: &Value) -> Result<()> {
         }
         let Some(sketch) = feature.get("sketch") else { continue };
         let len = |key: &str| sketch.get(key).and_then(Value::as_array).map_or(0, Vec::len);
-        if len("points") > solvecraft_sketch::MAX_POINTS
-            || len("curves") > solvecraft_sketch::MAX_CURVES
-            || len("constraints") > solvecraft_sketch::MAX_CONSTRAINTS
+        if len("points") > solidcraft_sketch::MAX_POINTS
+            || len("curves") > solidcraft_sketch::MAX_CURVES
+            || len("constraints") > solidcraft_sketch::MAX_CONSTRAINTS
         {
             return Err(invalid());
         }
@@ -553,7 +557,7 @@ fn validate_versioned_geometry(value: &Value) -> Result<()> {
             }
             let indices = curve.get("pts").and_then(Value::as_array).ok_or_else(invalid)?;
             work = work.saturating_add(indices.len());
-            if !(4..=solvecraft_sketch::MAX_SPLINE_POINTS).contains(&indices.len())
+            if !(4..=solidcraft_sketch::MAX_SPLINE_POINTS).contains(&indices.len())
                 || work > 1_000_000
                 || curve.get("control").is_some_and(|control| control.as_bool() != Some(false))
                 || curve.get("degree").is_some_and(|degree| degree.as_u64() != Some(3))
@@ -630,7 +634,7 @@ fn validate_freeform_offsets(value: &Value) -> Result<()> {
             if !(1..=256).contains(&divisions)
                 || !divisions.is_power_of_two()
                 || !(1..=256).contains(&pieces)
-                || pieces * divisions >= solvecraft_sketch::MAX_SPLINE_POINTS as u64
+                || pieces * divisions >= solidcraft_sketch::MAX_SPLINE_POINTS as u64
                 || !distance.is_finite()
                 || !(1e-9..=MAX_REAL).contains(&distance.abs())
                 || !tolerance.is_finite()
@@ -727,7 +731,7 @@ mod tests {
     #[test]
     fn version_thirteen_names_keep_their_meaning_under_the_legacy_mark() {
         let file = serde_json::json!({
-            "format": "solvecraft/13",
+            "format": "solidcraft/13",
             "features": [
                 {"type": "fillet", "edge_names": ["F2:side:l2|F2:top#2~1", ""], "face_names": ["F2:top#1", ""]},
                 {"type": "sheet_flange", "edge_names": ["base:l1:top"]},
@@ -774,7 +778,7 @@ mod tests {
     #[test]
     fn version_thirteen_marking_targets_name_fields_not_key_names() {
         let file = serde_json::json!({
-            "format": "solvecraft/13",
+            "format": "solidcraft/13",
             "features": [
                 {"type": "extrude", "options": {"face": "flat", "face_name": "label", "face_names": ["a"]}},
                 {"type": "fillet", "settings": {"edge_names": ["kept"]}},
@@ -794,8 +798,8 @@ mod tests {
 
     #[test]
     fn version_nine_wire_spaces_preserve_saved_points_and_explicit_markers() {
-        use solvecraft_geom::Vec3;
-        use solvecraft_sketch::{LinkKind, LinkSource, Sketch, WireSpace};
+        use solidcraft_geom::Vec3;
+        use solidcraft_sketch::{LinkKind, LinkSource, Sketch, WireSpace};
         let mut sketch = Sketch::new();
         sketch.add_drawn_wire(&[Vec3::new(12.0, 3.0, 4.0)]).unwrap();
         let link = sketch
@@ -810,7 +814,7 @@ mod tests {
         let mut doc = Document::new("legacy wire spaces");
         doc.add_feature(crate::FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch }, None).unwrap();
         let mut json: Value = serde_json::from_str(&doc.to_json()).unwrap();
-        json["format"] = Value::from("solvecraft/9");
+        json["format"] = Value::from("solidcraft/9");
         for wire in json["features"][0]["sketch"]["wires"].as_array_mut().unwrap() {
             wire.as_object_mut().unwrap().remove("space");
         }
@@ -891,7 +895,7 @@ mod tests {
         let mut document = Document::new("legacy named extent");
         document.set_param("offset", "2", Some("mm"), None).unwrap();
         let sketch = document
-            .add_feature(FeatureKind::Sketch { plane: PlaneRef::Origin { name: "XY".into() }, sketch: solvecraft_sketch::Sketch::new() }, None)
+            .add_feature(FeatureKind::Sketch { plane: PlaneRef::Origin { name: "XY".into() }, sketch: solidcraft_sketch::Sketch::new() }, None)
             .unwrap();
         document
             .add_feature(
@@ -905,9 +909,9 @@ mod tests {
                         start_offset: None,
                         through_all: false,
                         taper: Some("0 deg".into()),
-                        to: Some(solvecraft_geom::Vec3::new(0.0, 0.0, 10.0)),
+                        to: Some(solidcraft_geom::Vec3::new(0.0, 0.0, 10.0)),
                         to_offset: Some("offset + 1 mm".into()),
-                        from: Some(solvecraft_geom::Vec3::new(0.0, 0.0, 5.0)),
+                        from: Some(solidcraft_geom::Vec3::new(0.0, 0.0, 5.0)),
                     },
                     operation: Operation::NewBody,
                     targets: vec![],
@@ -928,7 +932,7 @@ mod tests {
             )
             .unwrap();
         let mut legacy: Value = serde_json::from_str(&document.to_json()).unwrap();
-        legacy["format"] = Value::from("solvecraft/8");
+        legacy["format"] = Value::from("solidcraft/8");
         // Version 8 exposed distance and taper, but had no model slot for To Offset.
         legacy["features"][1]["param_names"] = serde_json::json!(["d1", "d2"]);
         legacy["features"][2]["param_names"] = serde_json::json!(["d3", "d4", "d5"]);
@@ -952,8 +956,8 @@ mod tests {
 
     #[test]
     fn saved_offset_cannot_alias_and_overwrite_its_source_geometry() {
-        use solvecraft_geom::Vec2;
-        use solvecraft_sketch::{CurveKind, Sketch};
+        use solidcraft_geom::Vec2;
+        use solidcraft_sketch::{CurveKind, Sketch};
         let mut sketch = Sketch::new();
         let center = sketch.add_point(Vec2::ZERO, None).unwrap();
         let major = sketch.add_point(Vec2::new(10.0, 0.0), None).unwrap();
@@ -976,7 +980,7 @@ mod tests {
         let mut document = Document::new("missing offset geometry");
         document
             .add_feature(
-                crate::FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch: solvecraft_sketch::Sketch::new() },
+                crate::FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch: solidcraft_sketch::Sketch::new() },
                 None,
             )
             .unwrap();
@@ -1052,7 +1056,7 @@ mod tests {
             ("degree", serde_json::json!(2)),
             ("pts", serde_json::json!([0, 1, 2])),
             ("pts", serde_json::json!([0, 1, 2, u64::MAX])),
-            ("pts", serde_json::json!(vec![0; solvecraft_sketch::MAX_SPLINE_POINTS + 1])),
+            ("pts", serde_json::json!(vec![0; solidcraft_sketch::MAX_SPLINE_POINTS + 1])),
         ] {
             let mut damaged = curve.clone();
             damaged[key] = malformed;
@@ -1091,8 +1095,8 @@ mod tests {
 
     #[test]
     fn periodic_file_validation_refuses_damaged_closed_geometry() {
-        use solvecraft_geom::Vec2;
-        use solvecraft_sketch::{CurveKind, Sketch};
+        use solidcraft_geom::Vec2;
+        use solidcraft_sketch::{CurveKind, Sketch};
         let mut sketch = Sketch::new();
         let mut pts = Vec::new();
         for point in [Vec2::ZERO, Vec2::new(10.0, 0.0), Vec2::new(0.0, 10.0), Vec2::ZERO] {
@@ -1199,7 +1203,7 @@ mod tests {
         ];
         d.configs.active = Some("Default".into());
         let mut legacy: Value = serde_json::from_str(&d.to_json()).unwrap();
-        legacy["format"] = Value::from("solvecraft/6");
+        legacy["format"] = Value::from("solidcraft/6");
         let original_table = legacy["configs"].clone();
         let upgraded = read(&legacy.to_string()).unwrap();
         d.features.iter_mut().for_each(|f| f.shell_piece_order = true);
@@ -1224,7 +1228,7 @@ mod tests {
         }];
         d.apply_configuration("Blue steel").unwrap();
         let mut value: Value = serde_json::from_str(&d.to_json()).unwrap();
-        value["format"] = Value::from("solvecraft/7");
+        value["format"] = Value::from("solidcraft/7");
         let original_table = value["configs"].clone();
         let roundtrip = read(&value.to_string()).unwrap();
         assert_eq!(roundtrip, d);
@@ -1241,8 +1245,8 @@ mod tests {
 
     #[test]
     fn version_seven_origin_sketch_keeps_geometry_dimension_ids_and_expressions() {
-        use solvecraft_geom::Vec2;
-        use solvecraft_sketch::{ConstraintKind, Sketch};
+        use solidcraft_geom::Vec2;
+        use solidcraft_sketch::{ConstraintKind, Sketch};
         let mut d = Document::new("legacy origin dimensions");
         d.set_param("reach", "25 mm", Some("mm"), None).unwrap();
         let dim = d.new_model_param("reach", "mm");
@@ -1253,7 +1257,7 @@ mod tests {
         sketch.add_constraint(ConstraintKind::Length { l: line, value: 25.0 }, Some(dim)).unwrap();
         d.add_feature(crate::FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch }, Some("Dimensioned")).unwrap();
         let mut legacy: Value = serde_json::from_str(&d.to_json()).unwrap();
-        legacy["format"] = Value::from("solvecraft/7");
+        legacy["format"] = Value::from("solidcraft/7");
         let mut features = legacy["features"].clone();
         pieces_in_shell_order(&mut features);
         let params = legacy["params"].clone();
@@ -1268,8 +1272,8 @@ mod tests {
 
     #[test]
     fn version_eight_persistent_angle_sweep_and_slot_dimensions_roundtrip() {
-        use solvecraft_geom::Vec2;
-        use solvecraft_sketch::{ConstraintKind, Sketch};
+        use solidcraft_geom::Vec2;
+        use solidcraft_sketch::{ConstraintKind, Sketch};
         let mut d = Document::new("persistent typed dimensions");
         let heading = d.new_model_param("45 deg", "deg");
         let sweep = d.new_model_param("180 deg", "deg");
@@ -1358,8 +1362,11 @@ mod tests {
 
     #[test]
     fn versions() {
-        assert_eq!(version_of("solvecraft/1"), Some(1));
-        assert_eq!(version_of("solvecraft/x"), None);
+        assert_eq!(version_of("solidcraft/1"), Some(1));
+        assert_eq!(version_of("solidcraft/x"), None);
+        // Compatibility shim: files saved before the rename carry the legacy tag.
+        assert_eq!(version_of("solvecraft/13"), Some(13));
+        assert_eq!(version_of("solvecraftx/13"), None);
         let d = Document::new("A");
         assert_eq!(d.format, format_string(FORMAT));
         let back = read(&d.to_json()).unwrap();
@@ -1378,44 +1385,44 @@ mod tests {
             )
             .unwrap();
         let mut json: Value = serde_json::from_str(&doc.to_json()).unwrap();
-        json["format"] = Value::from("solvecraft/5");
+        json["format"] = Value::from("solidcraft/5");
         let migrated = read(&json.to_string()).unwrap();
         let crate::FeatureKind::ConstructionPlane { plane } = &migrated.feature(id).unwrap().kind else { panic!("plane") };
         let (values, errors) = migrated.param_values();
         assert!(errors.is_empty());
         let p = migrated.resolve_plane(&values, plane, 0).unwrap();
-        assert_eq!(p.y, solvecraft_geom::Vec3::Z);
-        assert_eq!(p.normal(), -solvecraft_geom::Vec3::Y);
-        assert_eq!(p.origin, solvecraft_geom::Vec3::new(0.0, -7.0, 0.0));
+        assert_eq!(p.y, solidcraft_geom::Vec3::Z);
+        assert_eq!(p.normal(), -solidcraft_geom::Vec3::Y);
+        assert_eq!(p.origin, solidcraft_geom::Vec3::new(0.0, -7.0, 0.0));
         assert_eq!(read(&migrated.to_json()).unwrap(), migrated);
         let fresh = doc.resolve_plane(&values, &crate::PlaneRef::Origin { name: "XZ".into() }, 0).unwrap();
-        assert_eq!(fresh.normal(), solvecraft_geom::Vec3::Y);
+        assert_eq!(fresh.normal(), solidcraft_geom::Vec3::Y);
     }
 
     #[test]
     fn older_upgraded_newer_refused_others_rejected() {
         let mut v: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap();
-        v["format"] = Value::from("solvecraft/1");
+        v["format"] = Value::from("solidcraft/1");
         assert_eq!(read(&v.to_string()).unwrap().format, format_string(FORMAT));
         v.as_object_mut().unwrap().remove("format");
         assert!(read(&v.to_string()).is_ok(), "a file without a format is format 1");
         v["format"] = Value::from(format_string(FORMAT + 1));
         let e = read(&v.to_string()).unwrap_err().to_string();
         assert!(e.contains("newer SolidCraft"), "{e}");
-        for bad in ["solvecraft/0", "acad/3", "solvecraft/-1", "solvecraft/99999999999999999999"] {
+        for bad in ["solidcraft/0", "acad/3", "solidcraft/-1", "solidcraft/99999999999999999999"] {
             v["format"] = Value::from(bad);
             assert!(read(&v.to_string()).is_err(), "{bad}");
         }
         assert!(read("[]").is_err());
         // Format 2 body colours become body appearances.
         let mut old: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap();
-        old["format"] = Value::from("solvecraft/2");
+        old["format"] = Value::from("solidcraft/2");
         old["appearances"] = serde_json::json!({"Body1": [200, 10, 20]});
         let d = read(&old.to_string()).unwrap();
         let l = d.appearances.bodies.get("Body1").unwrap();
         // Format 3 joints (aligned unless flipped) keep their placement.
         let mut j: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap();
-        j["format"] = Value::from("solvecraft/3");
+        j["format"] = Value::from("solidcraft/3");
         j["assembly"] = serde_json::json!({"joints": [{"id": 1, "name": "J", "kind": "rigid", "a": {"occurrence": 0, "snap": {"type": "point", "point": [0, 0, 0]}}, "b": {"occurrence": 0, "snap": {"type": "point", "point": [0, 0, 0]}}}]});
         let dj = read(&j.to_string()).unwrap();
         assert!(dj.assembly.joints[0].flip, "aligned before = not mated now");
@@ -1431,14 +1438,14 @@ mod tests {
     /// file too, before the arrays are deserialised.
     #[test]
     fn oversized_sketches_are_refused_before_typed_decoding() {
-        use solvecraft_sketch::{MAX_CONSTRAINTS, MAX_CURVES, MAX_POINTS, Sketch};
+        use solidcraft_sketch::{MAX_CONSTRAINTS, MAX_CURVES, MAX_POINTS, Sketch};
 
         // A sketch right at the point cap, chained by coincident constraints.
         let mut sketch = Sketch::new();
         let mut previous = 0;
         while sketch.points.len() < MAX_POINTS {
-            let i = sketch.add_point(solvecraft_geom::Vec2::new(0.001 * sketch.points.len() as f64, 0.0), None).unwrap();
-            sketch.add_constraint(solvecraft_sketch::ConstraintKind::Coincident { p: previous, q: i }, None).unwrap();
+            let i = sketch.add_point(solidcraft_geom::Vec2::new(0.001 * sketch.points.len() as f64, 0.0), None).unwrap();
+            sketch.add_constraint(solidcraft_sketch::ConstraintKind::Coincident { p: previous, q: i }, None).unwrap();
             previous = i;
         }
         let mut doc = Document::new("big sketch");

crates/doc/src/format_offsets.rs

@@ -380,11 +380,11 @@ mod tests {
 
     #[test]
     fn formats_one_through_eleven_keep_legacy_offset_geometry_and_ids() {
-        let mut sketch = solvecraft_sketch::Sketch::new();
-        let center = sketch.add_point(solvecraft_geom::Vec2::new(4., 7.), Some("center")).unwrap();
-        sketch.add_circle(solvecraft_geom::Vec2::new(4., 7.), 10., Some(center), Some("source")).unwrap();
-        sketch.add_circle(solvecraft_geom::Vec2::new(4., 7.), 9., Some(center), Some("offset")).unwrap();
-        sketch.offsets.push(solvecraft_sketch::OffsetChain {
+        let mut sketch = solidcraft_sketch::Sketch::new();
+        let center = sketch.add_point(solidcraft_geom::Vec2::new(4., 7.), Some("center")).unwrap();
+        sketch.add_circle(solidcraft_geom::Vec2::new(4., 7.), 10., Some(center), Some("source")).unwrap();
+        sketch.add_circle(solidcraft_geom::Vec2::new(4., 7.), 9., Some(center), Some("offset")).unwrap();
+        sketch.offsets.push(solidcraft_sketch::OffsetChain {
             sources: vec![("source".into(), true)],
             outputs: vec!["offset".into()],
             distance: 1.,
@@ -409,15 +409,15 @@ mod tests {
             let state = model.state();
             let solved = state.sketch(sketch_id).unwrap();
             let radius = solved.sketch.curves.iter().find(|curve| curve.id == "offset").map(|curve| &curve.kind);
-            assert!(matches!(radius,Some(solvecraft_sketch::CurveKind::Circle {r,..}) if *r ==9.));
+            assert!(matches!(radius,Some(solidcraft_sketch::CurveKind::Circle {r,..}) if *r ==9.));
         }
     }
 
     #[test]
     fn missing_boundary_or_defining_sketch_reopens_as_a_model_error_without_retarget() {
         for missing_sketch in [false, true] {
-            let mut sketch = solvecraft_sketch::Sketch::new();
-            sketch.add_circle(solvecraft_geom::Vec2::new(0., 0.), 10., None, Some("unrelated-circle")).unwrap();
+            let mut sketch = solidcraft_sketch::Sketch::new();
+            sketch.add_circle(solidcraft_geom::Vec2::new(0., 0.), 10., None, Some("unrelated-circle")).unwrap();
             let mut document = Document::new("repairable lost boundary");
             let id = document.add_feature(FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch }, None).unwrap();
             document

crates/doc/src/history_names.rs

@@ -17,7 +17,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 use std::sync::{Arc, OnceLock};
 
-use solvecraft_kernel::history::{FaceOrigin, FaceProv, History};
+use solidcraft_kernel::history::{FaceOrigin, FaceProv, History};
 
 use crate::ModelBody;
 use crate::lineage::{Lineage, Operand};

crates/doc/src/joints.rs

@@ -13,7 +13,7 @@
 use std::collections::{BTreeMap, BTreeSet, VecDeque};
 
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;
 
 use crate::{DocError, Document, IDENTITY, Mat, ModelState, Result, apply_point, apply_vector, mat_inverse, mat_mul};
 
@@ -273,9 +273,9 @@ pub fn resolve_origin(doc: &Document, st: &ModelState, o: &JointOrigin) -> Resul
             let comp = component_of(doc, o.occurrence)?;
             let cyl = component_bodies(doc, st, comp)
                 .into_iter()
-                .filter_map(|b| solvecraft_kernel::cylinder_face_at(&b.body, *pick))
+                .filter_map(|b| solidcraft_kernel::cylinder_face_at(&b.body, *pick))
                 .min_by(|a, b| {
-                    let off = |c: &solvecraft_kernel::CylinderFace| {
+                    let off = |c: &solidcraft_kernel::CylinderFace| {
                         let v = *pick - c.axis_point;
                         ((v - c.axis * v.dot(c.axis)).len() - c.radius).abs()
                     };

crates/doc/src/lib.rs

@@ -1,4 +1,4 @@
-//! The SolveCraft document: user and model parameters, and a parametric timeline of features
+//! The SolidCraft document: user and model parameters, and a parametric timeline of features
 //! (sketches, extrudes, revolves, fillets, primitives, combines…). Evaluating the timeline with
 //! the kernel produces the model (bodies and solved sketches). Evaluation is incremental: a
 //! feature is recomputed only when it, a parameter it uses, or an earlier feature changed.
@@ -47,8 +47,8 @@ pub use eval::{
     state_in_frame_at, through_all_distance, world_state,
 };
 pub use params::{ParamRow, ParamUser, cycles};
-pub use solvecraft_kernel as kernel;
-pub use solvecraft_sketch as sketch;
+pub use solidcraft_kernel as kernel;
+pub use solidcraft_sketch as sketch;
 
 #[derive(Debug, Clone, PartialEq, thiserror::Error)]
 pub enum DocError {
@@ -59,9 +59,9 @@ pub enum DocError {
     #[error("unknown {0}")]
     Unknown(String),
     #[error(transparent)]
-    Sketch(#[from] solvecraft_sketch::SketchError),
+    Sketch(#[from] solidcraft_sketch::SketchError),
     #[error(transparent)]
-    Kernel(#[from] solvecraft_kernel::KernelError),
+    Kernel(#[from] solidcraft_kernel::KernelError),
 }
 
 pub type Result<T> = std::result::Result<T, DocError>;

crates/doc/src/lineage.rs

@@ -11,9 +11,9 @@
 
 use std::sync::{Arc, OnceLock};
 
-use solvecraft_geom::Region2;
-use solvecraft_kernel::Body;
-use solvecraft_kernel::history::{Change, FaceOrigin, FaceProv, History};
+use solidcraft_geom::Region2;
+use solidcraft_kernel::Body;
+use solidcraft_kernel::history::{Change, FaceOrigin, FaceProv, History};
 
 use crate::SolvedSketch;
 
@@ -183,7 +183,7 @@ impl<'a> ProfileRoles<'a> {
         if history.operands != 0 {
             return None;
         }
-        let segments: Vec<&solvecraft_geom::Seg2> =
+        let segments: Vec<&solidcraft_geom::Seg2> =
             self.region.map(|r| std::iter::once(&r.outer).chain(&r.holes).flat_map(|l| &l.segs).collect()).unwrap_or_default();
         let curves = self.sketch.map(crate::config::ExactSketchCurves::new);
         let curve = |segment: usize| -> Option<String> { curves.as_ref()?.find(segments.get(segment)?).map(|id| format!("side:{id}")) };
@@ -235,7 +235,7 @@ pub(crate) fn box_tool(body: Body) -> Traced {
         sources
             .iter()
             .map(|source| match source {
-                Some(solvecraft_kernel::FaceSource::Box { axis, high, .. }) => {
+                Some(solidcraft_kernel::FaceSource::Box { axis, high, .. }) => {
                     ["x", "y", "z"].get(usize::from(*axis)).map(|a| vec![format!("{}{a}", if *high { "+" } else { "-" })]).unwrap_or_default()
                 }
                 _ => Vec::new(),

crates/doc/src/motion.rs

@@ -3,7 +3,7 @@
 //! shown without changing the design).
 
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;
 
 /// Occurrences whose bodies may touch but not pass through each other while joints move.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

crates/doc/src/name_lookup.rs

@@ -8,7 +8,7 @@
 //! was worked out from geometry, found where the reference's point no longer lies, is reported:
 //! only geometry decided.
 
-use solvecraft_geom::{Mesh, Vec3};
+use solidcraft_geom::{Mesh, Vec3};
 
 use crate::history_names::{Match, Names};
 use crate::naming::{self, closest, edge_names, face_names, legacy_edge_names, legacy_face_names, strip_piece};

crates/doc/src/named_projection_tests.rs

@@ -1,11 +1,11 @@
 use crate::{Document, ModelBody, ModelState};
-use solvecraft_geom::{Plane, Vec3};
-use solvecraft_sketch::{LinkKind, LinkSource, Sketch};
+use solidcraft_geom::{Plane, Vec3};
+use solidcraft_sketch::{LinkKind, LinkSource, Sketch};
 use std::collections::BTreeMap;
 use std::sync::Arc;
 
 fn named_box(name: &str, width: f64, height: f64) -> ModelBody {
-    let body = solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(width, width, height)).unwrap();
+    let body = solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(width, width, height)).unwrap();
     let mut names = vec!["unrelated".to_string(); body.faces(0.01).unwrap().len()];
     let top = body.faces(0.01).unwrap().into_iter().find(|face| face.plane_normal.is_some_and(|normal| normal.z > 0.99)).unwrap().index;
     names[top] = "shared:top".into();

crates/doc/src/naming.rs

@@ -17,7 +17,7 @@
 
 use std::sync::{Arc, OnceLock};
 
-use solvecraft_geom::{Mesh, Seg2, Vec2, Vec3};
+use solidcraft_geom::{Mesh, Seg2, Vec2, Vec3};
 
 use crate::history_names::Names;
 use crate::lineage::Lineage;
@@ -737,7 +737,7 @@ mod tests {
 
     #[test]
     fn merged_face_votes_collectively_for_pieces_of_one_source() {
-        let body = ModelBody::new("Input".into(), solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(4., 1., 1.)).unwrap(), 1);
+        let body = ModelBody::new("Input".into(), solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(4., 1., 1.)).unwrap(), 1);
         let mut mesh = Mesh::default();
         let mut points = Vec::new();
         for i in 0..3u32 {

crates/doc/src/profile_refs.rs

@@ -5,7 +5,7 @@ use crate::{DocError, ProfileSel, Result, SolvedSketch, WholeProfileBoundary};
 
 const MAX_SELECTIONS: usize = 128;
 
-fn whole_boundary(profile: &solvecraft_sketch::Profile) -> Option<WholeProfileBoundary> {
+fn whole_boundary(profile: &solidcraft_sketch::Profile) -> Option<WholeProfileBoundary> {
     let (outer, holes) = profile.whole_curve_boundaries()?;
     Some(WholeProfileBoundary { outer, holes })
 }
@@ -117,10 +117,10 @@ pub fn profile_selection_indices(ss: &SolvedSketch, selection: &ProfileSel) -> R
                     if curves.iter().collect::<BTreeSet<_>>().len() != curves.len()
                         && !ss.profiles.iter().any(|profile| same_ids(curves, &profile.outer_curves))
                     {
-                        return Err(crate::curve_pick_error(solvecraft_sketch::CurvePick::Missing, curves, &ss.name));
+                        return Err(crate::curve_pick_error(solidcraft_sketch::CurvePick::Missing, curves, &ss.name));
                     }
                     indices.push(
-                        solvecraft_sketch::profile_by_curves(&ss.profiles, curves)
+                        solidcraft_sketch::profile_by_curves(&ss.profiles, curves)
                             .map_err(|error| crate::curve_pick_error(error, curves, &ss.name))?,
                     );
                 }
@@ -230,8 +230,8 @@ pub fn capture_profile_selection(ss: &SolvedSketch, indices: &[usize]) -> Result
 mod tests {
     #![allow(clippy::unwrap_used, clippy::panic)]
     use super::*;
-    use solvecraft_geom::{Plane, Vec2};
-    use solvecraft_sketch::{Sketch, find_profiles, solve};
+    use solidcraft_geom::{Plane, Vec2};
+    use solidcraft_sketch::{Sketch, find_profiles, solve};
 
     fn rounded_source(sketch: &mut Sketch, radius: f64) -> Vec<(String, bool)> {
         let endpoints = [
@@ -328,13 +328,13 @@ mod tests {
             )
             .unwrap();
         model.evaluate(&document);
-        let volume = solvecraft_kernel::measure(&model.state().bodies[0].body).unwrap().volume;
+        let volume = solidcraft_kernel::measure(&model.state().bodies[0].body).unwrap().volume;
         assert!((volume - 2. * 73.2 * 63.2).abs() < 1e-6, "{volume}");
         let reopened = crate::Document::from_json(&document.to_json()).unwrap();
         assert_eq!(reopened, document);
         let mut cold = crate::Model::new();
         cold.evaluate(&reopened);
-        assert!((solvecraft_kernel::measure(&cold.state().bodies[0].body).unwrap().volume - volume).abs() < 1e-6);
+        assert!((solidcraft_kernel::measure(&cold.state().bodies[0].body).unwrap().volume - volume).abs() < 1e-6);
         let crate::FeatureKind::Sketch { sketch, .. } = &mut document.features[0].kind else { panic!("sketch") };
         set_source_radius(sketch, 2.);
         model.evaluate(&document);
@@ -345,7 +345,7 @@ mod tests {
         assert_eq!(active, original_roles);
         let rounded_area = 75.2 * 65.2 - (4. - std::f64::consts::PI) * 0.6 * 0.6;
         assert!((crate::select_profiles(solved, &selection).unwrap()[0].area() - rounded_area).abs() < 1e-7);
-        let volume = solvecraft_kernel::measure(&model.state().bodies[0].body).unwrap().volume;
+        let volume = solidcraft_kernel::measure(&model.state().bodies[0].body).unwrap().volume;
         // Kernel volume integrates the curved display mesh; the analytic region above
         // checks the exact rounded geometry independently of that tessellation.
         assert!((volume - 2. * rounded_area).abs() < 0.002, "{volume}");
@@ -359,7 +359,7 @@ mod tests {
         );
         let reopened = crate::Document::from_json(&document.to_json()).unwrap();
         cold.evaluate(&reopened);
-        assert!((solvecraft_kernel::measure(&cold.state().bodies[0].body).unwrap().volume - volume).abs() < 1e-5);
+        assert!((solidcraft_kernel::measure(&cold.state().bodies[0].body).unwrap().volume - volume).abs() < 1e-5);
     }
 
     #[test]
@@ -387,7 +387,7 @@ mod tests {
     fn periodic_offset_ring_whole_source_survives_adaptive_spans_and_reopen() {
         let mut sketch = Sketch::new();
         let major = sketch.add_point(Vec2::new(10., 0.), None).unwrap();
-        let ellipse = sketch.add_curve(solvecraft_sketch::CurveKind::Ellipse { c: 0, m: major, r: 5. }, None).unwrap();
+        let ellipse = sketch.add_curve(solidcraft_sketch::CurveKind::Ellipse { c: 0, m: major, r: 5. }, None).unwrap();
         let first = sketch.add_freeform_offset(ellipse, true, -1.).unwrap();
         sketch.add_freeform_offset(first, true, -0.5).unwrap();
         let mut document = crate::Document::new("periodic offset ring multiset");
@@ -453,7 +453,7 @@ mod tests {
             )
             .unwrap();
         model.evaluate(&document);
-        let initial_volume = solvecraft_kernel::measure(&model.state().bodies[0].body).unwrap().volume;
+        let initial_volume = solidcraft_kernel::measure(&model.state().bodies[0].body).unwrap().volume;
         // Kernel measurement integrates the curved mesh. Scale the established
         // periodic-ring tolerance (0.05 mm³ at height3) to this height2 extrusion.
         // Exact profile identity and cold/warm equality below remain strict.
@@ -481,7 +481,7 @@ mod tests {
         assert!(updated_region.contains(ring_point));
         assert!(!updated_region.contains(source_point + normal * 0.5));
         assert!(!updated_region.contains(source_point + normal * 1.75));
-        let updated_volume = solvecraft_kernel::measure(&updated_state.bodies[0].body).unwrap().volume;
+        let updated_volume = solidcraft_kernel::measure(&updated_state.bodies[0].body).unwrap().volume;
         assert!(updated_volume > initial_volume);
         assert!(
             (updated_volume - 2. * updated_region.area()).abs() < volume_tolerance,
@@ -491,7 +491,7 @@ mod tests {
         let reopened_document = crate::Document::from_json(&document.to_json()).unwrap();
         cold.evaluate(&reopened_document);
         assert!(cold.results.iter().all(|result| result.error.is_none()));
-        assert!((solvecraft_kernel::measure(&cold.state().bodies[0].body).unwrap().volume - updated_volume).abs() < 1e-6);
+        assert!((solidcraft_kernel::measure(&cold.state().bodies[0].body).unwrap().volume - updated_volume).abs() < 1e-6);
 
         // A new hole is a semantic boundary change, not the old ring. Whole-source
         // identities include holes and must not silently absorb the new material cutout.

crates/doc/src/project.rs

@@ -8,8 +8,8 @@
 
 use std::collections::BTreeMap;
 
-use solvecraft_geom::{Mesh, Plane, Vec2, Vec3};
-use solvecraft_sketch::{CurveKind, LinkGeom, LinkKind, LinkSource, Sketch};
+use solidcraft_geom::{Mesh, Plane, Vec2, Vec3};
+use solidcraft_sketch::{CurveKind, LinkGeom, LinkKind, LinkSource, Sketch};
 
 use crate::eval::ModelState;
 use crate::expr::Value;
@@ -259,7 +259,7 @@ fn resolve_uncached(
                 _ => vec![LinkGeom::Point(o)],
             }
         }
-        LinkSource::Text { text, at, height, angle } => solvecraft_sketch::text_geometry(text, *at, *height, *angle)?,
+        LinkSource::Text { text, at, height, angle } => solidcraft_sketch::text_geometry(text, *at, *height, *angle)?,
         LinkSource::Plane { name } => {
             let pr =
                 if Plane::named(name).is_some() { PlaneRef::Origin { name: name.clone() } } else { PlaneRef::Construction { name: name.clone() } };
@@ -310,7 +310,7 @@ fn projection_face_edges(body: &crate::ModelBody, mesh: &Mesh, index: u32, plane
         .body
         .face_sources()
         .and_then(|sources| sources.get(index as usize))
-        .is_some_and(|source| matches!(source, Some(solvecraft_kernel::FaceSource::ShellPlanar { .. })));
+        .is_some_and(|source| matches!(source, Some(solidcraft_kernel::FaceSource::ShellPlanar { .. })));
     if shell_plane { order::raw_face_edges(mesh, index, plane) } else { order::face_edges(mesh, index, plane) }
 }
 
@@ -319,10 +319,10 @@ fn certified_planar_construction(body: &crate::ModelBody, index: usize) -> bool
         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 { .. }
+                solidcraft_kernel::FaceSource::ShellPlanar { producer: Some(_), .. }
+                    | solidcraft_kernel::FaceSource::Box { producer: Some(_), .. }
+                    | solidcraft_kernel::FaceSource::CertifiedExtrudeSide { plane: Some(_), .. }
+                    | solidcraft_kernel::FaceSource::CertifiedExtrudeCap { .. }
             )
         )
     })
@@ -785,7 +785,7 @@ fn as_spline(pts: &[Vec2], tol: f64) -> Option<LinkGeom> {
         if fit.len() < 2 {
             return None;
         }
-        let poly = solvecraft_sketch::spline_polyline(&fit, false, 3);
+        let poly = solidcraft_sketch::spline_polyline(&fit, false, 3);
         let ok = pts.iter().all(|q| {
             poly.windows(2)
                 .map(|w| {

crates/doc/src/project3d.rs

@@ -4,8 +4,8 @@
 use std::collections::BTreeMap;
 use std::sync::Arc;
 
-use solvecraft_geom::{Mesh, Plane, Vec2, Vec3};
-use solvecraft_sketch::LinkSource;
+use solidcraft_geom::{Mesh, Plane, Vec2, Vec3};
+use solidcraft_sketch::LinkSource;
 
 use crate::eval::ModelState;
 
@@ -439,8 +439,8 @@ fn tri_dist(p: Vec3, t: &[Vec3; 3]) -> f64 {
 }
 
 /// Sample a fitted planar curve.
-fn link_polyline(g: &solvecraft_sketch::LinkGeom) -> Vec<Vec2> {
-    use solvecraft_sketch::LinkGeom;
+fn link_polyline(g: &solidcraft_sketch::LinkGeom) -> Vec<Vec2> {
+    use solidcraft_sketch::LinkGeom;
     match *g {
         LinkGeom::Line(a, b) => vec![a, b],
         LinkGeom::Circle(c, r) => (0..=96).map(|i| c + Vec2::from_angle(i as f64 / 96.0 * std::f64::consts::TAU) * r).collect(),
@@ -452,11 +452,11 @@ fn link_polyline(g: &solvecraft_sketch::LinkGeom) -> Vec<Vec2> {
             let r = c.dist(a);
             (0..=48).map(|i| c + Vec2::from_angle(s0 + sw * i as f64 / 48.0) * r).collect()
         }
-        LinkGeom::Conic { a, apex, b, rho } => (0..=32).map(|i| solvecraft_sketch::conic_point(a, apex, b, rho, i as f64 / 32.0)).collect(),
+        LinkGeom::Conic { a, apex, b, rho } => (0..=32).map(|i| solidcraft_sketch::conic_point(a, apex, b, rho, i as f64 / 32.0)).collect(),
         LinkGeom::Ellipse { c, major, minor } => {
-            (0..=96).map(|i| solvecraft_sketch::ellipse_point(c, major, minor, i as f64 / 96.0 * std::f64::consts::TAU)).collect()
+            (0..=96).map(|i| solidcraft_sketch::ellipse_point(c, major, minor, i as f64 / 96.0 * std::f64::consts::TAU)).collect()
         }
-        LinkGeom::Spline { ref pts, control, degree, periodic } => solvecraft_sketch::spline_polyline_mode(pts, control, degree, periodic),
+        LinkGeom::Spline { ref pts, control, degree, periodic } => solidcraft_sketch::spline_polyline_mode(pts, control, degree, periodic),
         LinkGeom::Point(_) => Vec::new(),
     }
 }

crates/doc/src/project_order.rs

@@ -3,7 +3,7 @@
 
 use std::collections::BTreeMap;
 
-use solvecraft_geom::{Mesh, Plane, Vec3};
+use solidcraft_geom::{Mesh, Plane, Vec3};
 
 use crate::{DocError, Result};
 
@@ -60,7 +60,7 @@ fn boundary_edges(mesh: &Mesh, mut edges: Vec<usize>, plane: &Plane) -> Result<V
     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()));
     }
-    if edges.len() > solvecraft_sketch::MAX_LINK_ENTITIES {
+    if edges.len() > solidcraft_sketch::MAX_LINK_ENTITIES {
         return Err(DocError::Invalid("face projection exceeds the boundary edge limit".into()));
     }
     let geometry_key = |e: usize| {
@@ -197,17 +197,17 @@ mod tests {
         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 mut sk = solidcraft_sketch::Sketch::new();
         let link = sk
-            .add_link(solvecraft_sketch::LinkKind::Project, solvecraft_sketch::LinkSource::Face { body: "ambiguous".into(), at: Vec3::ZERO }, &geom)
+            .add_link(solidcraft_sketch::LinkKind::Project, solidcraft_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;
+        use solidcraft_geom::Vec2;
+        use solidcraft_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 [
@@ -271,8 +271,8 @@ mod tests {
                 let normalized: Vec<_> = expected
                     .iter()
                     .map(|g| {
-                        let solvecraft_sketch::LinkGeom::Line(a, b) = g[0] else { panic!("line") };
-                        if a.x > b.x || a.y > b.y { vec![solvecraft_sketch::LinkGeom::Line(b, a)] } else { g.clone() }
+                        let solidcraft_sketch::LinkGeom::Line(a, b) = g[0] else { panic!("line") };
+                        if a.x > b.x || a.y > b.y { vec![solidcraft_sketch::LinkGeom::Line(b, a)] } else { g.clone() }
                     })
                     .collect();
                 assert_eq!(actual, normalized);
@@ -288,8 +288,8 @@ mod tests {
 
     #[test]
     fn rounded_boundary_arc_sweeps_survive_individual_edge_reversal() {
-        use solvecraft_geom::{Seg2, Vec2};
-        use solvecraft_sketch::LinkGeom;
+        use solidcraft_geom::{Seg2, Vec2};
+        use solidcraft_sketch::LinkGeom;
         let mut mesh = Mesh::default();
         for (extent, radius) in [(10.0, 3.0), (8.0, 1.0)] {
             for k in 0..4 {

crates/doc/src/sheet.rs

@@ -10,8 +10,8 @@
 //! together; the flat solid is the outline extruded through the thickness.
 
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
-use solvecraft_kernel::{self as kernel, Body, EdgeSpec, FaceSpec, SurfSpec};
+use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
+use solidcraft_kernel::{self as kernel, Body, EdgeSpec, FaceSpec, SurfSpec};
 
 use crate::expr::{self, Kind, Value};
 use crate::{DocError, Document, IDENTITY, Mat, Result, apply_point, apply_vector, mat_inverse, mat_mul};

crates/doc/src/tests.rs

@@ -1,6 +1,6 @@
-use solvecraft_geom::{Vec2, Vec3};
-use solvecraft_kernel::measure;
-use solvecraft_sketch::{ConstraintKind, Sketch};
+use solidcraft_geom::{Vec2, Vec3};
+use solidcraft_kernel::measure;
+use solidcraft_sketch::{ConstraintKind, Sketch};
 
 use crate::*;
 
@@ -379,7 +379,7 @@ fn input_sketches_lists_every_variant_with_a_sketch_field() {
 
 #[test]
 fn timeline_clones_share_meshes_even_when_cloned_before_tessellation() {
-    let body = solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(10., 10., 10.)).unwrap();
+    let body = solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(10., 10., 10.)).unwrap();
     let a = crate::eval::ModelBody::new("box".into(), body, 1);
     let b = a.clone();
     assert!(std::sync::Arc::ptr_eq(&a.mesh(), &b.mesh()));