Surface Extrude: sheets from open curves and profile walls (#815)

surface.extrude sweeps open curve chains and profile boundaries along the sketch normal into a surface body (walls only, no caps). Saved under format 17.

Refs #757

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/doc/src/eval_surface.rs

@@ -1,6 +1,8 @@
-//! Evaluation of the surface features: Patch, Stitch, Thicken and Trim (kernel `surfaces`).
+//! Evaluation of the surface features: Patch, Stitch, Thicken, Trim, Extend and Surface Extrude
+//! (kernel `surfaces`).
 
 use super::*;
+use solidcraft_geom::Seg2;
 
 pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st: &mut ModelState) -> Result<()> {
     match &f.kind {
@@ -84,6 +86,83 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
             }
             Ok(())
         }
+        FeatureKind::SurfaceExtrude { sketch, profiles, curves, extent } => {
+            let ss = sketch_in_feature_frame(
+                doc,
+                st.sketch(*sketch).ok_or_else(|| DocError::Unknown(format!("sketch {sketch} (it must come earlier in the timeline)")))?,
+                f.component,
+            )?;
+            if extent.through_all || extent.taper.is_some() || extent.to.is_some() || extent.from.is_some() {
+                return Err(DocError::Invalid("not supported yet: a surface extrude through all, to or from an object, or with a taper".into()));
+            }
+            let d = val(vals, &extent.distance, Kind::Length)?;
+            let off = extent.start_offset.as_deref().map(|e| val(vals, e, Kind::Length)).transpose()?.unwrap_or(0.0);
+            let (a, b) = extent_sides(vals, extent, d, extent.direction)?;
+            let mut chains: Vec<Vec<Seg2>> = Vec::new();
+            if let Some(sel) = profiles {
+                for r in solidcraft_sketch::merge_regions(&select_profiles(&ss, sel)?) {
+                    chains.extend(std::iter::once(r.outer).chain(r.holes).map(|lp| lp.segs));
+                }
+            }
+            chains.extend(curve_chains(&ss, curves)?);
+            if chains.is_empty() {
+                return Err(DocError::Invalid("pick the profiles or curves to extrude".into()));
+            }
+            let body = kernel::extrude_sheet(&ss.plane, &chains, a + off, b + off)?;
+            let name = new_name(st, f, 0);
+            st.bodies.push(ModelBody::new(name, body, f.id));
+            Ok(())
+        }
         _ => Err(DocError::Invalid("not a surface feature".into())),
     }
 }
+
+/// Most sketch curves one feature chains.
+const MAX_CHAIN_CURVES: usize = 1000;
+
+/// The sketch curves `ids` (free-form ones exactly where they can be) grouped into chains of segments that meet end to end, each oriented
+/// to run one way. Curves are joined greedily at their free ends: where three meet, one of them
+/// starts a chain of its own.
+fn curve_chains(ss: &SolvedSketch, ids: &[String]) -> Result<Vec<Vec<Seg2>>> {
+    if ids.len() > MAX_CHAIN_CURVES {
+        return Err(DocError::Invalid(format!("at most {MAX_CHAIN_CURVES} curves")));
+    }
+    let mut pieces: std::collections::VecDeque<Vec<Seg2>> = ids
+        .iter()
+        .map(|id| {
+            let ci = ss.sketch.curve_index(id).ok_or_else(|| DocError::Unknown(format!("curve `{id}`")))?;
+            Ok(ss.sketch.exact_segs(ci).unwrap_or_else(|| ss.sketch.segs(ci)))
+        })
+        .collect::<Result<Vec<_>>>()?
+        .into_iter()
+        .filter(|p| !p.is_empty())
+        .collect();
+    let reversed = |p: Vec<Seg2>| -> Vec<Seg2> { p.iter().rev().map(Seg2::reversed).collect() };
+    let near = |p: Vec2, q: Vec2| p.dist(q) <= 1e-6;
+    let mut chains = Vec::new();
+    while let Some(mut chain) = pieces.pop_front() {
+        while let (Some(head), Some(tail)) = (chain.first().map(Seg2::start), chain.last().map(Seg2::end)) {
+            if near(head, tail) {
+                break;
+            }
+            let ends = |p: &Vec<Seg2>| p.first().map(Seg2::start).zip(p.last().map(Seg2::end));
+            let Some(i) = pieces.iter().position(|p| ends(p).is_some_and(|(s, e)| near(s, tail) || near(e, tail) || near(s, head) || near(e, head)))
+            else {
+                break;
+            };
+            let Some(p) = pieces.remove(i) else { break };
+            let Some((s, e)) = ends(&p) else { continue };
+            if near(s, tail) {
+                chain.extend(p);
+            } else if near(e, tail) {
+                chain.extend(reversed(p));
+            } else if near(e, head) {
+                chain = p.into_iter().chain(chain).collect();
+            } else {
+                chain = reversed(p).into_iter().chain(chain).collect();
+            }
+        }
+        chains.push(chain);
+    }
+    Ok(chains)
+}