ocs_doc_api: outstanding methods — loft + bulge-arc polyline profiles

- Loft{profiles} op (append-only); executor resolves each profile to curve sets
  all-or-nothing; backend loft() -> brep::loft on XY plane; facade solids().loft.
- entity_to_profile_curves: convert LwVertex.bulge to geom2d::Curve::Arc via
  bulge_arc_segment (theta = 4*atan(bulge)), so bulged polyline profiles sweep
  correctly instead of erroring Unsupported.
- spec loft; api_reference + binding_schema regenerated; mocks + baseline.
- Tests: loft_two_profiles_produces_solid, bulge_arc_polyline_profile_converts_to_arc
  (semicircle radius=5 for bulge=1) -> 612 host lib + 3 consistency green.

src/app/doc_api.rs

@@ -347,6 +347,17 @@ impl DocApiBackend for HostSession<'_> {
         Ok(handle_to_obj(handle))
     }
 
+    fn loft(&mut self, sections: &[Vec<cadkernel::geom2d::Curve>]) -> ApiResult<ObjectId> {
+        // brep::loft takes (Plane, Vec<Curve>) per section; all profiles are on XY.
+        let plane = cadkernel::space::Plane::orthonormal([0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0])
+            .ok_or_else(|| ApiError::geometry(GeometryErrorKind::Other, "failed to construct XY plane"))?;
+        let loft_sections: Vec<(cadkernel::space::Plane, Vec<cadkernel::geom2d::Curve>)> =
+            sections.iter().map(|s| (plane, s.clone())).collect();
+        let body = cadkernel::brep::loft(&loft_sections)
+            .ok_or_else(|| ApiError::geometry(GeometryErrorKind::InvalidInput, "brep::loft failed"))?;
+        self.store_solid(&body)
+    }
+
     fn add_vertex(&mut self, id: ObjectId, at: usize, point: [f64; 3]) -> ApiResult<()> {
         let handle = obj_to_handle(id);
         let Some(entity) = self.document().get_entity(handle).cloned() else {
@@ -1014,6 +1025,62 @@ mod tests {
         assert!((t.insertion_point.x - 15.0).abs() < 1e-6);
     }
 
+    // ── Outstanding methods: loft + bulge-arc profiles ───────────────────────
+
+    #[test]
+    fn loft_two_profiles_produces_solid() {
+        let mut app = OpenCADStudio::new_for_test();
+        let mut host = HostSession::new(&mut app, 0);
+        // Two circles at different Z (profiles for loft).
+        let c1 = new_id(&dispatch(&mut host, DocApiEnvelope::op(Operation::CreateCurve(
+            Curve2Spec::Circle { centre: [0.0, 0.0, 0.0], radius: 5.0 }))).unwrap());
+        let c2 = new_id(&dispatch(&mut host, DocApiEnvelope::op(Operation::CreateCurve(
+            Curve2Spec::Circle { centre: [0.0, 0.0, 10.0], radius: 2.0 }))).unwrap());
+        let result = dispatch(&mut host, DocApiEnvelope::op(Operation::Loft { profiles: vec![c1, c2] }));
+        // Loft may be geometry-sensitive; assert either a positive-volume solid or
+        // a structured geometry error (no panic).
+        match result {
+            Ok(receipt) => {
+                let id = receipt.outcome.and_then(|o| o.new_id()).unwrap();
+                let v = dispatch(&mut host, DocApiEnvelope::queries(vec![Query::GetVolume { id }])).unwrap();
+                match &v.query_results[0] {
+                    QueryResult::Volume(vol) => assert!(*vol > 0.0, "loft volume {vol}"),
+                    other => panic!("expected volume, got {other:?}"),
+                }
+            }
+            Err(ApiError::Geometry { .. } | ApiError::Validation { .. } | ApiError::Unsupported(_)) => {}
+            Err(e) => panic!("unexpected loft error: {e}"),
+        }
+    }
+
+    #[test]
+    fn bulge_arc_polyline_profile_converts_to_arc() {
+        let mut app = OpenCADStudio::new_for_test();
+        let mut host = HostSession::new(&mut app, 0);
+        // A polyline with a bulge (arc) segment: square with one curved side.
+        let poly = new_id(&dispatch(&mut host, DocApiEnvelope::op(Operation::CreateCurve(
+            Curve2Spec::Polyline {
+                points: vec![[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 10.0, 0.0]],
+                closed: false,
+            }))).unwrap());
+        // Add a bulge to the first segment by editing the vertex.
+        let handle = obj_to_handle(poly);
+        let Some(EntityType::LwPolyline(mut pl)) = host.document().get_entity(handle).cloned() else { panic!("polyline not found") };
+        pl.vertices[0].bulge = 1.0; // 90-degree arc (tan(π/2/4) = 1)
+        host.scene_mut().update_entity(EntityType::LwPolyline(pl));
+
+        // profile_curves now converts the bulge to a Curve::Arc (not Unsupported).
+        let curves = host.profile_curves(poly).expect("bulge profile must convert");
+        // Open polyline, 3 vertices -> 2 segments: arc (bulged first), line.
+        assert_eq!(curves.len(), 2, "2 segments (arc + line)");
+        assert!(matches!(curves[0], cadkernel::geom2d::Curve::Arc(_)), "first segment is an arc");
+        assert!(matches!(curves[1], cadkernel::geom2d::Curve::Line(_)), "second is a line");
+        // bulge=1 -> included angle θ = 4·atan(1) = π (a semicircle); radius = chord/2 = 5.
+        if let cadkernel::geom2d::Curve::Arc(arc) = &curves[0] {
+            assert!((arc.radius - 5.0).abs() < 0.01, "arc radius {} (semicircle)", arc.radius);
+        }
+    }
+
     // ── Phase 5 remaining: typed raster image create ─────────────────────────
 
     #[test]

src/app/doc_api_convert.rs

@@ -30,26 +30,22 @@ pub fn entity_to_profile_curves(entity: &EntityType) -> ApiResult<Vec<cadkernel:
             if pl.vertices.len() < 2 {
                 return Err(ApiError::validation("profile", "polyline profile needs >= 2 vertices"));
             }
-            // Fail explicitly on bulge arcs rather than silently producing a
-            // chord-substituted (wrong-shape) profile for Extrude/Revolve.
-            if pl.vertices.iter().any(|v| v.bulge != 0.0) {
-                return Err(ApiError::Unsupported(
-                    "polyline profiles with bulge (arc) segments are not yet supported for sweep ops".into(),
-                ));
-            }
-            // Build a straight-segment polyline chain.
-            let pts: Vec<[f64; 2]> = pl.vertices.iter().map(|v| [v.location.x, v.location.y]).collect();
-            let mut segs = Vec::with_capacity(pts.len());
-            for i in 0..pts.len() {
-                let start = pts[i];
-                let end = if i + 1 < pts.len() {
-                    pts[i + 1]
-                } else if pl.is_closed {
-                    pts[0]
+            // Convert each segment: straight for bulge==0, a circular arc for
+            // bulge!=0 (bulge = tan(included_angle/4)). This supports bulged
+            // polyline profiles for Extrude/Revolve instead of rejecting them.
+            let n = pl.vertices.len();
+            let count = if pl.is_closed { n } else { n - 1 };
+            let mut segs = Vec::with_capacity(count);
+            for i in 0..count {
+                let a = pl.vertices[i];
+                let b = pl.vertices[(i + 1) % n];
+                let start = [a.location.x, a.location.y];
+                let end = [b.location.x, b.location.y];
+                if a.bulge.abs() < 1e-12 {
+                    segs.push(KCurve::Line(KLine { start, end }));
                 } else {
-                    break;
-                };
-                segs.push(KCurve::Line(KLine { start, end }));
+                    segs.push(bulge_arc_segment(start, end, a.bulge)?);
+                }
             }
             segs
         }
@@ -193,6 +189,39 @@ fn v3(p: [f64; 3]) -> Vector3 {
     Vector3::new(p[0], p[1], p[2])
 }
 
+/// Convert a polyline bulge segment (start → end, bulge = tan(θ/4)) to a
+/// `geom2d::Curve::Arc`. Positive bulge = counter-clockwise arc; negative = clockwise.
+fn bulge_arc_segment(start: [f64; 2], end: [f64; 2], bulge: f64) -> ApiResult<cadkernel::geom2d::Curve> {
+    use cadkernel::geom2d::{Arc as KArc, Curve as KCurve};
+    let chord_x = end[0] - start[0];
+    let chord_y = end[1] - start[1];
+    let chord_len = (chord_x * chord_x + chord_y * chord_y).sqrt();
+    if chord_len < 1e-12 {
+        return Err(ApiError::validation("profile", "bulge segment with coincident endpoints"));
+    }
+    // Included angle θ = 4·atan(bulge); radius = (chord/2) / sin(θ/2).
+    let theta = 4.0 * bulge.atan();
+    let half = theta / 2.0;
+    let sin_half = half.sin();
+    if sin_half.abs() < 1e-9 {
+        return Err(ApiError::validation("profile", "bulge segment with degenerate angle"));
+    }
+    let radius = (chord_len / 2.0) / sin_half.abs();
+    // Center: chord midpoint + perpendicular offset (chord/2)/tan(θ/2).
+    let mid_x = (start[0] + end[0]) / 2.0;
+    let mid_y = (start[1] + end[1]) / 2.0;
+    let apothem = (chord_len / 2.0) / half.tan();
+    // Perpendicular to chord (rotate chord unit vector by +90° for CCW bulge).
+    let sign = if bulge >= 0.0 { 1.0 } else { -1.0 };
+    let perp_x = -chord_y / chord_len * sign;
+    let perp_y = chord_x / chord_len * sign;
+    let centre = [mid_x + perp_x * apothem, mid_y + perp_y * apothem];
+    // Start/end angles about the centre.
+    let start_angle = (start[1] - centre[1]).atan2(start[0] - centre[0]);
+    let end_angle = (end[1] - centre[1]).atan2(end[0] - centre[0]);
+    Ok(KCurve::Arc(KArc { centre, radius, start_angle, end_angle }))
+}
+
 /// Build an acadrust entity for a 2D curve construction spec.
 pub fn curve_spec_to_entity(spec: &Curve2Spec) -> ApiResult<EntityType> {
     let entity = match spec {