partforge 0.7.0 → 0.9.0

package/src/framework/geometry/loft.js

@@ -0,0 +1,79 @@
+// Backend-shared loft support. resolveRings() validates the declarative ring specs and
+// applies each ring's in-plane transform ONCE, so both backends build the identical set
+// of placed cross-sections (Manifold hand-meshes them; OCCT turns each into a wire and
+// calls native loft). loftMesh() is the Manifold path — the helix-tube ring recipe
+// generalized to arbitrary polygon rings via the mesh-build.js helpers.
+import { regularPolygon } from "./polygon.js";
+import { isArcContour } from "./profile.js";
+import { sideQuads, fanCap, manifoldFromMesh, reverseWinding } from "./mesh-build.js";
+
+// A ring: { polygon:[[x,y],…] | (sides,radius), z, rotate?:deg, scale?:number|[sx,sy] }.
+// Returns [{ pts2d:[[x,y],…], z }] with scale-then-rotate(Z) baked into pts2d. Throws
+// on malformed input and on rings whose vertex counts differ (straight quad stitching
+// needs a shared N — no re-sampling), so an LLM gets a loud, specific error.
+export function resolveRings(rings) {
+  if (!Array.isArray(rings) || rings.length < 2)
+    throw new Error("loft: rings must be an array of at least 2 rings");
+  const out = rings.map((r, i) => {
+    if (!r || typeof r !== "object") throw new Error(`loft: ring ${i} must be an object { polygon|sides+radius, z }`);
+    if (!Number.isFinite(r.z)) throw new Error(`loft: ring ${i} needs a finite z`);
+    let pts = r.polygon;
+    if (isArcContour(pts)) // arc profiles (roundedProfile) are extrude/prism-only in v1
+      throw new Error(`loft: ring ${i} is an arc profile — loft rings must be a point array (arc rings are not supported yet; use prism/extrude for true STEP arcs)`);
+    if (!pts && Number.isFinite(r.sides) && Number.isFinite(r.radius)) pts = regularPolygon(r.sides, r.radius);
+    if (!Array.isArray(pts) || pts.length < 3)
+      throw new Error(`loft: ring ${i} needs polygon:[[x,y],…] (≥3 points) or sides+radius shorthand`);
+    const s = r.scale ?? 1;
+    const [sx, sy] = Array.isArray(s) ? s : [s, s];
+    const rot = ((r.rotate ?? 0) * Math.PI) / 180, cos = Math.cos(rot), sin = Math.sin(rot);
+    const pts2d = pts.map(([x, y]) => {
+      const X = x * sx, Y = y * sy;                 // scale in-plane, then rotate about Z
+      return [X * cos - Y * sin, X * sin + Y * cos];
+    });
+    return { pts2d, z: r.z };
+  });
+  const N = out[0].pts2d.length;
+  for (const r of out) if (r.pts2d.length !== N)
+    throw new Error("loft: every ring must have the same number of points (straight quad stitching, no re-sampling)");
+  return out;
+}
+
+const centroid = (pts2d, z) => {
+  let cx = 0, cy = 0;
+  for (const [x, y] of pts2d) { cx += x; cy += y; }
+  return [cx / pts2d.length, cy / pts2d.length, z];
+};
+
+// Manifold path: stack the resolved rings, stitch side quads, and (unless closed) fan a
+// cap over each end from its centroid. Caps assume star-convex-from-centroid rings, which
+// covers regular n-gons and every polygon.js helper. Returns a raw Manifold (caller T()s).
+//
+// NOTE on `ruled`: the OCCT backend's native loft honours `ruled:false` (a smooth C2 blend
+// between rings); this hand-mesh always emits faceted straight walls between consecutive
+// rings and ignores `ruled`. So `ruled:false` previews faceted here and only exports the
+// true smooth surface via the OCCT (STEP) path — documented on the loft doc row.
+export function loftMesh(wasm, rings, { closed = false } = {}) {
+  const resolved = resolveRings(rings);
+  const N = resolved[0].pts2d.length;
+  const V = [];
+  for (const { pts2d, z } of resolved) for (const [x, y] of pts2d) V.push(x, y, z);
+  const Tr = [];
+  sideQuads(Tr, resolved.length, N, closed);
+  if (!closed) {
+    const first = resolved[0], lastR = resolved[resolved.length - 1];
+    fanCap(V, Tr, 0, N, centroid(first.pts2d, first.z), true);                    // bottom faces −Z
+    fanCap(V, Tr, (resolved.length - 1) * N, N, centroid(lastR.pts2d, lastR.z), false); // top faces +Z
+  }
+  let out = manifoldFromMesh(wasm, V, Tr);
+  // The mesh helpers wind for CCW rings ordered along +Z. CW-wound rings or descending-z
+  // rings invert every face, yielding a negative-volume solid that ofMesh imports without
+  // complaint but that behaves BACKWARDS under booleans (cut adds material). Detect the
+  // inversion and rebuild with reversed winding so loft is winding/z-order agnostic — this
+  // matches OCCT, whose native loft always returns a positively-oriented solid.
+  if (out.volume() < 0) {
+    out.delete?.();
+    reverseWinding(Tr);
+    out = manifoldFromMesh(wasm, V, Tr);
+  }
+  return out;
+}

package/src/framework/geometry/manifold-backend.js

@@ -1,4 +1,7 @@
 import { helixTube } from "./helix-tube.js";
+import { loftMesh } from "./loft.js";
+import { sweepMesh } from "./sweep.js";
+import { tessellateContour, tessellateProfile } from "./profile.js";
 import { h } from "./solid-hash.js";
 import { createSolidCache } from "./solid-cache.js";
 import { addSugar } from "./solid-sugar.js";
@@ -140,13 +143,31 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     },
     prism: (pts, height, { twist = 0, scaleTop = 1 } = {}) =>
       cached(h("prism", pts, height, twist, scaleTop, segs), () => {
-        const cs = T(CrossSection.ofPolygons([pts]));
+        const cs = T(CrossSection.ofPolygons([tessellateContour(pts, segs)]));
         if (twist === 0 && scaleTop === 1) return T(cs.extrude(height));
         const nDiv = Math.max(1, Math.ceil(Math.abs(twist) / 5));
         // Manifold's extrude scaleTop is a Vec2 — a scalar is NOT broadcast (it scales
         // X and drives Y to 0, squishing the top to a line). Broadcast for a uniform taper.
         return T(cs.extrude(height, nDiv, twist, [scaleTop, scaleTop]));
       }),
+    // Polygon-with-holes extrude in one op: even/odd fill turns the extra contours into
+    // holes regardless of their winding (outer + holes, no per-hole boolean cut).
+    extrude: (profile, height, { twist = 0, scaleTop = 1 } = {}) =>
+      cached(h("extrude", profile, height, twist, scaleTop, segs), () => {
+        const { outer, holes } = tessellateProfile(profile, segs);
+        const cs = T(CrossSection.ofPolygons([outer, ...holes], "EvenOdd"));
+        if (twist === 0 && scaleTop === 1) return T(cs.extrude(height));
+        const nDiv = Math.max(1, Math.ceil(Math.abs(twist) / 5));
+        return T(cs.extrude(height, nDiv, twist, [scaleTop, scaleTop]));
+      }),
+    // Ring loft: hand-meshed via the shared ring-mesh helpers (helix-tube recipe).
+    // Cached atomically; the hash folds every ring's points/z/rotate/scale and the opts.
+    loft: (rings, opts = {}) => cached(h("loft", rings, opts), () => T(loftMesh(wasm, rings, opts))),
+    // Sweep a fixed 2-D profile along a 3-D polyline: hand-meshed from the shared station
+    // list (sweep.js), so it agrees with OCCT's ruled loft of the same stations by
+    // construction. Cached atomically; the hash folds profile pts, path pts, and opts
+    // (closed/cornerRadius) so a shape change is a fresh node and an identical rebuild hits.
+    sweep: (profile, path, opts = {}) => cached(h("sweep", profile, path, opts), () => T(sweepMesh(wasm, profile, path, opts))),
     helixSweptTube: (o) => cached(h("helixSweptTube", o, tube), () => T(helixTube(wasm, { ...o, ...tube }))),
     revolve: (pts, { degrees = 360 } = {}) =>
       cached(h("revolve", pts, degrees, segs), () => T(Manifold.revolve([pts], segs, degrees))),

package/src/framework/geometry/mesh-build.js

@@ -0,0 +1,53 @@
+// Shared triangle-mesh assembly for ring-based Manifold primitives. Both helix-tube
+// (a circular profile swept up a helix) and loft (stacked polygon cross-sections)
+// build the same way: N-vertex rings stacked in order, stitched with side quads and
+// closed with fan caps, then imported via Manifold.ofMesh. The winding convention is
+// CCW = outward (getting it wrong makes ofMesh throw or import an inverted solid), so
+// these helpers own the winding once for every ring-mesh primitive.
+
+// Stitch side walls between consecutive rings. `V` already holds ringCount rings of
+// ringSegs vertices each, ring i occupying indices [i*ringSegs, (i+1)*ringSegs). When
+// `closed` also stitches the last ring back to the first (a tube/loop with no caps).
+// Winding assumes each ring is CCW viewed from +Z and rings are ordered along +Z.
+export function sideQuads(Tr, ringCount, ringSegs, closed = false) {
+  const last = closed ? ringCount : ringCount - 1;
+  for (let i = 0; i < last; i++) {
+    const i0 = i * ringSegs, i1 = ((i + 1) % ringCount) * ringSegs;
+    for (let j = 0; j < ringSegs; j++) {
+      const a = i0 + j, b = i0 + (j + 1) % ringSegs;
+      const cc = i1 + j, dd = i1 + (j + 1) % ringSegs;
+      Tr.push(a, dd, cc, a, b, dd);
+    }
+  }
+}
+
+// Add a triangle fan closing one ring around a center point (pushed as a new vertex).
+// `flip` reverses the winding: use flip=true for a bottom cap (faces −Z) and flip=false
+// for a top cap (faces +Z), so both caps point outward. The center should lie inside the
+// ring's polygon (its centroid), so the fan is valid for convex / star-convex rings.
+export function fanCap(V, Tr, ringStart, ringSegs, center, flip) {
+  const c = V.length / 3;
+  V.push(center[0], center[1], center[2]);
+  for (let j = 0; j < ringSegs; j++) {
+    const a = ringStart + j, b = ringStart + (j + 1) % ringSegs;
+    if (flip) Tr.push(c, b, a); else Tr.push(c, a, b);
+  }
+}
+
+// Reverse the winding of every triangle in `Tr` in place (swap the 2nd and 3rd index of
+// each tri). Flips which way all faces point, i.e. turns an inward-facing (negative-volume)
+// mesh into an outward-facing one. Used to make loft winding/z-order agnostic.
+export function reverseWinding(Tr) {
+  for (let t = 0; t < Tr.length; t += 3) { const tmp = Tr[t + 1]; Tr[t + 1] = Tr[t + 2]; Tr[t + 2] = tmp; }
+}
+
+// Import a flat vertex array + triangle indices as a watertight Manifold. merge() welds
+// coincident vertices so ofMesh sees a closed manifold; ofMesh consumes the mesh handle,
+// so free it here and let the caller track the returned Manifold.
+export function manifoldFromMesh(wasm, V, Tr) {
+  const mesh = new wasm.Mesh({ numProp: 3, vertProperties: Float32Array.from(V), triVerts: Uint32Array.from(Tr) });
+  mesh.merge();
+  const out = wasm.Manifold.ofMesh(mesh);
+  mesh.delete?.(); // input mesh is consumed by ofMesh; free it (caller tracks `out`)
+  return out;
+}

package/src/framework/geometry/occt-backend.js

@@ -7,11 +7,14 @@ import { addSugar } from "./solid-sugar.js";
 import { finishKernel } from "./kernel-front.js";
 import { createOcctRepair } from "./occt-repair.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
+import { resolveRings } from "./loft.js";
+import { resolveSweepStations } from "./sweep.js";
+import { normalizeProfile } from "./profile.js";
 const MESH = { preview: { tolerance: 0.1, angularTolerance: 0.5 }, print: { tolerance: 0.01, angularTolerance: 0.1 } };
 
 export function createOcctKernel(replicad) {
   const { makeCylinder, makeBox, makeCircle, makeHelix, assembleWire, genericSweep,
-          makeCompound, loft, draw, exportSTEP, measureVolume, makeSphere } = replicad;
+          makeCompound, loft, draw, exportSTEP, measureVolume, makeSphere, makeLine, Plane } = replicad;
 
   // Fillet/chamfer/shell failure recovery (skip-on-failure, chamfer binary search) —
   // see occt-repair.js for the policies and why they differ per op.
@@ -83,11 +86,25 @@ export function createOcctKernel(replicad) {
     return wrap(loft([w1, w2]));
   };
 
+  // Draw a closed Drawing from a Contour: a legacy 2-D point list (all straight edges,
+  // the former polyDrawing) OR an ArcContour whose { to, via } segments become true
+  // OCCT arc edges via threePointsArcTo — so a rounded corner survives to STEP as a
+  // real CIRCLE B-rep entity, not a fan of LINEs. close() joins the last point back to
+  // the start with a straight edge (mirrors the implied ArcContour closure).
+  const contourDrawing = (contour) => {
+    if (Array.isArray(contour)) {
+      let pen = draw(contour[0]);
+      for (let i = 1; i < contour.length; i++) pen = pen.lineTo(contour[i]);
+      return pen.close();
+    }
+    let pen = draw(contour.start);
+    for (const seg of contour.segments) pen = seg.via ? pen.threePointsArcTo(seg.to, seg.via) : pen.lineTo(seg.to);
+    return pen.close();
+  };
+
   // extrude a 2-D polygon from z=0 (arguments validated by the kernel front)
   const prism = (pts, h, { twist = 0, scaleTop = 1 } = {}) => {
-    let pen = draw(pts[0]);
-    for (let i = 1; i < pts.length; i++) pen = pen.lineTo(pts[i]);
-    const sketch = pen.close().sketchOnPlane("XY");
+    const sketch = contourDrawing(pts).sketchOnPlane("XY");
     if (twist === 0 && scaleTop === 1) return wrap(sketch.extrude(h));
     const cfg = {};
     if (twist !== 0) cfg.twistAngle = twist;
@@ -96,11 +113,54 @@ export function createOcctKernel(replicad) {
   };
 
   // revolve a lathe profile [[r,z],…] around the Z axis (degrees defaults to 360)
-  const revolve = (pts, { degrees = 360 } = {}) => {
-    let pen = draw(pts[0]);
-    for (let i = 1; i < pts.length; i++) pen = pen.lineTo(pts[i]);
-    const sketch = pen.close().sketchOnPlane("XZ");
-    return wrap(sketch.revolve([0, 0, 1], { angle: degrees }));
+  const revolve = (pts, { degrees = 360 } = {}) =>
+    wrap(contourDrawing(pts).sketchOnPlane("XZ").revolve([0, 0, 1], { angle: degrees }));
+
+  // extrude a polygon-with-holes region from z=0: cut each hole Drawing out of the outer
+  // Drawing (winding-agnostic 2-D boolean), sketch it, then extrude (twist/taper via cfg).
+  const extrude = (profile, h, { twist = 0, scaleTop = 1 } = {}) => {
+    const { outer, holes } = normalizeProfile(profile);
+    let region = contourDrawing(outer);
+    for (const hole of holes) region = region.cut(contourDrawing(hole));
+    const sketch = region.sketchOnPlane("XY");
+    if (twist === 0 && scaleTop === 1) return wrap(sketch.extrude(h));
+    const cfg = {};
+    if (twist !== 0) cfg.twistAngle = twist;
+    if (scaleTop !== 1) cfg.extrusionProfile = { profile: "linear", endFactor: scaleTop };
+    return wrap(sketch.extrude(h, cfg));
+  };
+
+  // ring loft: each ring becomes a closed polygon wire placed at its z (native loft closes
+  // the ends for closed wires). closed:true loops are Manifold-only (replicad loft is open).
+  const loftOp = (rings, { ruled = true, closed = false } = {}) => {
+    if (closed) throw new Error("loft: closed:true loops are only supported on the Manifold backend");
+    const wires = resolveRings(rings).map(({ pts2d, z }) => contourDrawing(pts2d).sketchOnPlane("XY", z).wire);
+    return wrap(loft(wires, { ruled }));
+  };
+
+  // Sweep a 2-D profile along a 3-D polyline path. DEFAULT (§3A recipe): loft the SAME
+  // 3-D stations resolveSweepStations() hands the Manifold backend, as ruled polygon wires
+  // — so the two backends produce identical elbow geometry by construction (the loft-parity
+  // mechanism, not a tolerance). smooth:true switches to the OCCT-native genericSweep along
+  // a spline spine for an exact swept B-rep (STEP-exact / preview-faceted, parity waived —
+  // the same contract loft ships for ruled:false). closed:true loops are Manifold-only.
+  const sweepSmooth = (profile2D, path3D, cornerRadius) => {
+    const edges = [];
+    for (let i = 0; i < path3D.length - 1; i++) edges.push(makeLine(path3D[i], path3D[i + 1]));
+    const spine = assembleWire(edges);
+    const t0 = [path3D[1][0] - path3D[0][0], path3D[1][1] - path3D[0][1], path3D[1][2] - path3D[0][2]];
+    const profileWire = contourDrawing(profile2D).sketchOnPlane(new Plane(path3D[0], null, t0)).wire;
+    return wrap(genericSweep(profileWire, spine, {
+      transitionMode: cornerRadius > 0 ? "round" : "right", // sharp miter analogue vs rounded joint
+      forceProfileSpineOthogonality: true,
+    }));
+  };
+  const sweep = (profile2D, path3D, { closed = false, cornerRadius = 0, ruled = true, smooth = false } = {}) => {
+    if (closed) throw new Error("sweep: closed:true loops are only supported on the Manifold backend");
+    if (smooth) return sweepSmooth(profile2D, path3D, cornerRadius);
+    const { stations } = resolveSweepStations(profile2D, path3D, { closed, cornerRadius });
+    const wires = stations.map((ring) => assembleWire(ring.map((p, i) => makeLine(p, ring[(i + 1) % ring.length]))));
+    return wrap(loft(wires, { ruled }));
   };
 
   // circle profile swept along a helix (frenet)
@@ -114,7 +174,7 @@ export function createOcctKernel(replicad) {
 
   return finishKernel({
     cylinder, // boredCylinder: the kernel front's default composition is exactly right here
-    box: (min, max) => wrap(makeBox(min, max)), prism, revolve, helixSweptTube,
+    box: (min, max) => wrap(makeBox(min, max)), prism, extrude, revolve, loft: loftOp, sweep, helixSweptTube,
     sphere: (r) => wrap(makeSphere(r)),
     union: (solids) => wrap(
       solids.map((s) => s._s).reduce((a, b) => a.fuse(b)),

package/src/framework/geometry/polygon.js

@@ -97,6 +97,95 @@ export function ringSectorPolygon(innerR, outerR, arcDeg, segs = 32) {
   return pts;
 }
 
+// Per-corner rounding geometry, shared verbatim by filletPolygon (which tessellates it)
+// and roundedProfile (which emits it as a symbolic arc). Given a corner p0→p1→p2 and a
+// requested radius r, returns the incoming/outgoing tangent points `a`/`b`, the arc centre
+// `c`, the clamped radius `rr`, the short sweep `dA`, and the incoming start angle `a0` —
+// or null for a corner that must stay sharp (zero-length edge or a straight/180° corner).
+// The per-corner clamp (t ≤ min(l0,l2)/2) keeps neighbouring arcs from overlapping.
+// Extracting this means the two consumers can never diverge on clamping/winding.
+export function cornerArc(p0, p1, p2, r) {
+  let v0 = [p0[0] - p1[0], p0[1] - p1[1]], v2 = [p2[0] - p1[0], p2[1] - p1[1]];
+  const l0 = Math.hypot(v0[0], v0[1]), l2 = Math.hypot(v2[0], v2[1]);
+  if (l0 < 1e-9 || l2 < 1e-9) return null;               // zero-length edge → sharp
+  v0 = [v0[0] / l0, v0[1] / l0]; v2 = [v2[0] / l2, v2[1] / l2];
+  const cosA = Math.max(-1, Math.min(1, v0[0] * v2[0] + v0[1] * v2[1]));
+  const half = Math.acos(cosA) / 2;                      // half the corner's interior angle
+  let bis = [v0[0] + v2[0], v0[1] + v2[1]];
+  const bl = Math.hypot(bis[0], bis[1]);
+  if (half < 1e-6 || bl < 1e-9) return null;             // straight (180°) corner → sharp
+  bis = [bis[0] / bl, bis[1] / bl];
+  let rr = r, t = r / Math.tan(half);                    // tangent setback along each edge
+  const tmax = Math.min(l0, l2) / 2;                     // clamp: never past an edge midpoint
+  if (t > tmax) { t = tmax; rr = t * Math.tan(half); }
+  const a = [p1[0] + v0[0] * t, p1[1] + v0[1] * t];      // tangent point on the incoming edge
+  const b = [p1[0] + v2[0] * t, p1[1] + v2[1] * t];      // tangent point on the outgoing edge
+  const c = [p1[0] + bis[0] * (rr / Math.sin(half)), p1[1] + bis[1] * (rr / Math.sin(half))]; // arc center
+  const a0 = Math.atan2(a[1] - c[1], a[0] - c[0]);
+  let dA = Math.atan2(b[1] - c[1], b[0] - c[0]) - a0;     // sweep the SHORT arc from a to b
+  while (dA <= -Math.PI) dA += 2 * Math.PI;
+  while (dA > Math.PI) dA -= 2 * Math.PI;
+  return { a, b, c, rr, dA, a0 };
+}
+
+// Round every corner of a CCW polygon: each vertex is replaced by a tangent circular
+// arc of radius r, tessellated with `segs` segments per corner (default 8, matching
+// roundedRectPolygon). Returns a plain [[x,y],…] point list usable by prism/extrude/loft
+// on BOTH kernels by construction. Corners are CLAMPED per-corner: r is reduced so an
+// arc's tangent points never pass the midpoint of either adjacent edge, so neighbouring
+// rounded corners can never overlap (pass a very large r to fully round every corner).
+// Intended for convex CCW outlines (brackets, gussets, pads, knob/star profiles); a
+// reflex corner is still rounded but its arc is placed on the angle bisector.
+// NOTE: bakes each arc into `segs` straight facets, so STEP export of a filletPolygon
+// part has faceted (LINE) corners; for mathematically-true CIRCLE corners in STEP use
+// roundedProfile, which carries the arc symbolically to both backends.
+export function filletPolygon(points, r, { segs = 8 } = {}) {
+  const n = points.length;
+  if (n < 3) throw new Error("filletPolygon: need at least 3 points");
+  if (!(r > 0)) throw new Error("filletPolygon: r must be > 0");
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const arc = cornerArc(points[(i - 1 + n) % n], points[i], points[(i + 1) % n], r);
+    if (!arc) { out.push([points[i][0], points[i][1]]); continue; } // sharp corner
+    const { c, rr, dA, a0 } = arc;
+    for (let s = 0; s <= segs; s++) {
+      const ang = a0 + dA * (s / segs);
+      out.push([c[0] + rr * Math.cos(ang), c[1] + rr * Math.sin(ang)]);
+    }
+  }
+  return out;
+}
+
+// Arc-aware sibling of filletPolygon: rounds the corners of a CCW polygon with the SAME
+// tangent/centre/sweep math (via cornerArc), but instead of tessellating each arc into
+// line facets it emits a canonical ArcContour { start, segments:[{to}|{to,via}], arc:true }
+// that carries the arc SYMBOLICALLY. Feed it to prism/extrude (not loft yet): OCCT builds a
+// true CIRCLE B-rep edge (exact STEP fillets) while Manifold tessellates the same spec, so
+// both kernels agree by construction. `r` is a scalar (every corner) or a per-corner array
+// r[] (length === points.length; a 0 or a degenerate corner stays sharp — a plain line).
+export function roundedProfile(points, r) {
+  const n = points.length;
+  if (n < 3) throw new Error("roundedProfile: need at least 3 points");
+  const radii = Array.isArray(r) ? r : null;
+  if (radii && radii.length !== n)
+    throw new Error("roundedProfile: r[] length must match points length");
+  if (!radii && !(r >= 0)) throw new Error("roundedProfile: r must be ≥ 0 (or a per-corner r[]); 0 keeps every corner sharp");
+  const segments = [];
+  let start = null;
+  const lineTo = (p) => { if (start === null) start = [p[0], p[1]]; else segments.push({ to: [p[0], p[1]] }); };
+  for (let i = 0; i < n; i++) {
+    const p1 = points[i];
+    const ri = radii ? radii[i] : r;
+    const arc = ri > 0 ? cornerArc(points[(i - 1 + n) % n], p1, points[(i + 1) % n], ri) : null;
+    if (!arc) { lineTo(p1); continue; }                  // sharp / degenerate corner → plain vertex
+    const { a, b, c, rr, dA, a0 } = arc;
+    lineTo(a);                                           // straight run into the incoming tangent point
+    const mid = a0 + dA / 2;                             // arc midpoint (three-point via — sign/winding-free)
+    segments.push({ to: [b[0], b[1]], via: [c[0] + rr * Math.cos(mid), c[1] + rr * Math.sin(mid)] });
+  }
+  return { start, segments, arc: true };
+}
+
 const PATTERN_AXIS = { X: [1, 0, 0], Y: [0, 1, 0], Z: [0, 0, 1] };
 
 // `count` copies of `solid` translated by i*step ([dx,dy,dz]) for i in 0..count-1.

package/src/framework/geometry/profile.js

@@ -0,0 +1,96 @@
+// Backend-shared 2-D region normalization + tessellation for extrude()/prism(). A contour
+// is EITHER a bare points array (legacy, all straight edges) OR a canonical ArcContour
+// { start:[x,y], segments:[{to}|{to,via}], arc:true } carrying true circular arcs (from
+// roundedProfile). normalizeProfile validates the polymorphic { outer, holes } envelope
+// (bare array = outer only), preserving each contour's shape; tessellateProfile turns the
+// arcs into point rings for the Manifold (mesh) path. The OCCT path consumes the same
+// ArcContour directly (contourDrawing → threePointsArcTo) for true CIRCLE B-rep edges.
+// Legacy point-array contours take the exact former path byte-for-byte — no cache-busting.
+
+// An ArcContour is a non-array object carrying arcs symbolically.
+export function isArcContour(c) {
+  return !!c && typeof c === "object" && !Array.isArray(c) && (c.arc === true || Array.isArray(c.segments));
+}
+
+function validateContour(c, role) {
+  if (isArcContour(c)) {
+    if (!Array.isArray(c.start) || c.start.length < 2)
+      throw new Error(`extrude: ${role} arc contour needs a start [x,y]`);
+    if (!Array.isArray(c.segments) || c.segments.length < 1)
+      throw new Error(`extrude: ${role} arc contour needs ≥1 segment`);
+    return;
+  }
+  if (!Array.isArray(c) || c.length < 3) throw new Error(`extrude: ${role} needs ≥3 points`);
+}
+
+export function normalizeProfile(profile) {
+  let outer, holes;
+  if (Array.isArray(profile) || isArcContour(profile)) { outer = profile; holes = []; }
+  else if (profile && typeof profile === "object") { outer = profile.outer; holes = profile.holes ?? []; }
+  else throw new Error("extrude: profile must be [[x,y],…], an arc contour, or { outer, holes? }");
+  // Preserve the historical, test-pinned wording for the legacy point-array path.
+  if (isArcContour(outer)) validateContour(outer, "outer contour");
+  else if (!Array.isArray(outer) || outer.length < 3) throw new Error("extrude: outer contour needs ≥3 points");
+  if (!Array.isArray(holes)) throw new Error("extrude: holes must be an array of contours");
+  for (const hole of holes) {
+    if (isArcContour(hole)) validateContour(hole, "hole arc contour");
+    else if (!Array.isArray(hole) || hole.length < 3) throw new Error("extrude: each hole needs ≥3 points");
+  }
+  return { outer, holes };
+}
+
+// Sample the circular arc through (p0, via, p1) — the three-point form roundedProfile
+// emits — into a point list p1…pN (EXCLUDING the start p0, which the ring already holds;
+// the last point is exactly p1). The circle is recovered from the circumcircle of the
+// three points; the sweep direction is the one whose arc actually passes through `via`
+// (sign-free, winding-free). Facet count scales with the sweep's fraction of the kernel's
+// full-circle resolution `segs`, matching the piePolygon/circleProfile convention, so an
+// arc and a circleProfile of equal radius facet identically. A degenerate (collinear)
+// triple falls back to a single straight segment to p1 — the same "plain line" the OCCT
+// side gets when roundedProfile emits no `via`.
+export function sampleArc(p0, via, p1, segs) {
+  const [ax, ay] = p0, [bx, by] = via, [cx, cy] = p1;
+  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+  if (Math.abs(d) < 1e-12) return [[cx, cy]];            // collinear → straight line
+  const sa = ax * ax + ay * ay, sb = bx * bx + by * by, sc = cx * cx + cy * cy;
+  const ux = (sa * (by - cy) + sb * (cy - ay) + sc * (ay - by)) / d;
+  const uy = (sa * (cx - bx) + sb * (ax - cx) + sc * (bx - ax)) / d;
+  const rr = Math.hypot(ax - ux, ay - uy);
+  const a0 = Math.atan2(ay - uy, ax - ux);
+  const av = Math.atan2(by - uy, bx - ux);
+  const a1 = Math.atan2(cy - uy, cx - ux);
+  const twoPi = 2 * Math.PI;
+  const ccw = (x) => { let v = x % twoPi; if (v < 0) v += twoPi; return v; };
+  const dCCW = ccw(a1 - a0), vCCW = ccw(av - a0);
+  const dA = vCCW <= dCCW ? dCCW : dCCW - twoPi;          // pick the sweep containing `via`
+  const steps = Math.max(2, Math.ceil((segs * Math.abs(dA)) / twoPi));
+  const out = [];
+  for (let s = 1; s <= steps; s++) {
+    const ang = a0 + dA * (s / steps);
+    out.push([ux + rr * Math.cos(ang), uy + rr * Math.sin(ang)]);
+  }
+  out[out.length - 1] = [cx, cy];                        // pin the exact endpoint
+  return out;
+}
+
+// Tessellate a single contour into a CCW point ring. A legacy array is returned unchanged
+// (identical to the former path); an ArcContour is walked start→segment→segment, lines
+// pushing their `to` and arcs pushing their sampled points.
+export function tessellateContour(contour, segs) {
+  if (Array.isArray(contour)) return contour;
+  const ring = [[contour.start[0], contour.start[1]]];
+  let prev = contour.start;
+  for (const seg of contour.segments) {
+    if (seg.via) for (const p of sampleArc(prev, seg.via, seg.to, segs)) ring.push(p);
+    else ring.push([seg.to[0], seg.to[1]]);
+    prev = seg.to;
+  }
+  return ring;
+}
+
+// Normalize + tessellate a whole region to { outer:[[x,y],…], holes:[[[x,y],…],…] } of
+// point rings, ready for CrossSection.ofPolygons on the Manifold path.
+export function tessellateProfile(profile, segs) {
+  const { outer, holes } = normalizeProfile(profile);
+  return { outer: tessellateContour(outer, segs), holes: holes.map((hl) => tessellateContour(hl, segs)) };
+}

package/src/framework/geometry/sweep.js

@@ -0,0 +1,151 @@
+// Backend-shared sweep support. resolveSweepStations() walks a 3-D polyline path with a
+// rotation-minimizing frame (parallel transport, specialised to piecewise-linear paths:
+// the frame only ever rotates ACROSS a vertex, by the minimal rotation carrying the
+// incoming tangent onto the outgoing one) and places the 2-D profile at a fixed, shared
+// set of 3-D cross-section stations. BOTH backends build from that SAME station list —
+// Manifold hand-meshes it (sweepMesh below, the loft/helix-tube recipe via mesh-build.js),
+// OCCT lofts the same rings ruled (occt-backend.js). So the elbow shape agrees BY
+// CONSTRUCTION, not by tolerance — the same parity mechanism loft's resolveRings uses.
+//
+// Corners: cornerRadius==0 → a SHARP MITER (one station per vertex, in the bisecting
+// plane, stretched by 1/cos(turn/2) so straight walls meet flush). cornerRadius>0 →
+// a tangent circular ARC FAN (setback clamped like filletPolygon). Fold conditions
+// (profile too wide for a bend; 180° reversal) throw up front — the volume+bbox oracle
+// would ship a fold silently otherwise.
+import { sideQuads, fanCap, manifoldFromMesh, reverseWinding } from "./mesh-build.js";
+
+const EPS = 1e-9;
+const Z = [0, 0, 1], X = [1, 0, 0];
+// Corner-arc station density, in degrees of turn per station. A shared CONSTANT (not a
+// backend/quality value) so both backends subdivide a cornerRadius arc identically →
+// identical stations → parity by construction.
+const ARC_STEP_DEG = 12;
+
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+const scl = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const vlen = (a) => Math.hypot(a[0], a[1], a[2]);
+const norm = (a) => { const m = vlen(a) || 1; return [a[0] / m, a[1] / m, a[2] / m]; };
+// Rotate vector v about unit axis k by angle ang (Rodrigues) — same math as
+// manifold-backend.js axisAngleMat4, applied to a vector.
+const rodrigues = (v, k, ang) => {
+  const c = Math.cos(ang), s = Math.sin(ang), kd = dot(k, v), kv = cross(k, v);
+  return [
+    v[0] * c + kv[0] * s + k[0] * kd * (1 - c),
+    v[1] * c + kv[1] * s + k[1] * kd * (1 - c),
+    v[2] * c + kv[2] * s + k[2] * kd * (1 - c),
+  ];
+};
+
+// Place the 2-D profile into 3-D at `center` using frame axes (N=profile-x, B=profile-y).
+const placeRing = (profile2D, center, N, B) =>
+  profile2D.map(([x, y]) => add(center, add(scl(N, x), scl(B, y))));
+
+export function resolveSweepStations(profile2D, path3D, { closed = false, cornerRadius = 0 } = {}) {
+  if (!Array.isArray(profile2D) || profile2D.length < 3)
+    throw new Error("sweep: profile2D must be an array of ≥3 [x,y] points");
+  if (!Array.isArray(path3D) || path3D.length < 2)
+    throw new Error("sweep: path3D must be an array of ≥2 [x,y,z] points");
+  for (let i = 0; i < path3D.length; i++) {
+    const p = path3D[i];
+    if (!Array.isArray(p) || p.length < 3 || !Number.isFinite(p[0]) || !Number.isFinite(p[1]) || !Number.isFinite(p[2]))
+      throw new Error(`sweep: path3D[${i}] must be a finite [x,y,z]`);
+  }
+  const P = path3D, m = P.length;
+  const segCount = closed ? m : m - 1;
+  const dir = [], segLen = [];
+  for (let k = 0; k < segCount; k++) {
+    const d = sub(P[(k + 1) % m], P[k]), l = vlen(d);
+    if (l < EPS) throw new Error(`sweep: path segment ${k} has zero length (coincident points ${k} and ${(k + 1) % m})`);
+    dir.push(scl(d, 1 / l)); segLen.push(l);
+  }
+  // profile half-width = the farthest a profile vertex reaches from its own origin
+  let maxReach = 0;
+  for (const [x, y] of profile2D) maxReach = Math.max(maxReach, Math.hypot(x, y));
+
+  // Seed the frame ⟂ the tangent coming INTO the first processed station (reference-vector
+  // method; the ref pick avoids N collapsing when the path starts along Z).
+  const seedT = closed ? dir[segCount - 1] : dir[0];
+  const ref = Math.abs(dot(seedT, Z)) < 0.9 ? Z : X;
+  let N = norm(sub(ref, scl(seedT, dot(ref, seedT))));
+  let B = cross(seedT, N);
+
+  const stations = [];
+
+  // Emit station(s) for an interior vertex and advance (N,B) from ⟂tIn to ⟂tOut.
+  const corner = (center, tIn, tOut, vtx, lenIn, lenOut) => {
+    const axisRaw = cross(tIn, tOut), s = vlen(axisRaw);
+    const cdot = Math.max(-1, Math.min(1, dot(tIn, tOut)));
+    if (cdot < -1 + 1e-6)
+      throw new Error(`sweep: 180° reversal at vertex ${vtx} is ambiguous — insert an intermediate point or use cornerRadius`);
+    if (s < EPS) { stations.push(placeRing(profile2D, center, N, B)); return; } // collinear: no turn, frame unchanged
+    const axis = scl(axisRaw, 1 / s);
+    const theta = Math.atan2(s, cdot);                    // exterior turn angle
+    if (cornerRadius > 0) {
+      if (cornerRadius < maxReach)
+        throw new Error(`sweep: cornerRadius ${cornerRadius} < profile half-width ${maxReach.toFixed(3)} at vertex ${vtx} — the inner wall would fold; increase cornerRadius`);
+      const t = cornerRadius * Math.tan(theta / 2);       // tangent setback along each leg (= r/tan(interiorHalf))
+      const tmax = Math.min(lenIn, lenOut) / 2;
+      if (t > tmax)
+        throw new Error(`sweep: cornerRadius too large for the bend at vertex ${vtx} (setback ${t.toFixed(3)} > half the shorter segment ${tmax.toFixed(3)}) — reduce cornerRadius or lengthen the segment`);
+      const a = sub(center, scl(tIn, t));                 // arc start on the incoming leg
+      const arcCenter = add(center, scl(norm(sub(tOut, tIn)), cornerRadius / Math.cos(theta / 2)));
+      const va = sub(a, arcCenter);
+      const steps = Math.max(2, Math.ceil(((theta * 180) / Math.PI) / ARC_STEP_DEG));
+      for (let i = 0; i <= steps; i++) {                  // smooth arc: rotate frame with the tangent, no miter tilt
+        const ang = (theta * i) / steps;
+        stations.push(placeRing(profile2D, add(arcCenter, rodrigues(va, axis, ang)),
+          rodrigues(N, axis, ang), rodrigues(B, axis, ang)));
+      }
+    } else {                                              // sharp miter: one station in the bisecting plane
+      if (maxReach * Math.tan(theta / 2) > 0.5 * Math.min(lenIn, lenOut))
+        throw new Error(`sweep: profile too wide for the bend at vertex ${vtx} (turn too sharp / segment too short) — increase cornerRadius or lengthen the segment`);
+      const Nh = rodrigues(N, axis, theta / 2), Bh = rodrigues(B, axis, theta / 2);
+      const mDir = rodrigues(tIn, axis, theta / 2);       // ring-plane normal (average travel dir)
+      const u = norm(cross(axis, mDir));                  // in-plane bend direction (stretch axis)
+      const cosh = Math.cos(theta / 2);
+      stations.push(profile2D.map(([x, y]) => {
+        const p = add(scl(Nh, x), scl(Bh, y));            // profile point in the miter plane (spanned by u, axis)
+        return add(center, add(scl(axis, dot(p, axis)), scl(u, dot(p, u) / cosh))); // stretch the u component
+      }));
+    }
+    N = rodrigues(N, axis, theta); B = rodrigues(B, axis, theta); // advance frame to ⟂ tOut
+  };
+
+  if (closed) {
+    for (let k = 0; k < m; k++)
+      corner(P[k], dir[(k - 1 + m) % m], dir[k], k, segLen[(k - 1 + m) % m], segLen[k]);
+  } else {
+    stations.push(placeRing(profile2D, P[0], N, B));      // start cap ring ⟂ dir[0]
+    for (let k = 1; k <= m - 2; k++) corner(P[k], dir[k - 1], dir[k], k, segLen[k - 1], segLen[k]);
+    stations.push(placeRing(profile2D, P[m - 1], N, B));  // end cap ring ⟂ dir[last]
+  }
+  return { stations, closed };
+}
+
+const centroid = (ring) => {
+  let cx = 0, cy = 0, cz = 0;
+  for (const [x, y, z] of ring) { cx += x; cy += y; cz += z; }
+  return [cx / ring.length, cy / ring.length, cz / ring.length];
+};
+
+// Manifold path: stack the resolved stations, stitch side quads, and (unless closed) fan a
+// cap over each end from its 3-D centroid. Winding self-heals via loft's signed-volume
+// check so the sweep is winding/direction-agnostic. Returns a raw Manifold (caller T()s).
+export function sweepMesh(wasm, profile2D, path3D, opts = {}) {
+  const { stations, closed } = resolveSweepStations(profile2D, path3D, opts);
+  const N = profile2D.length;
+  const V = [];
+  for (const ring of stations) for (const [x, y, z] of ring) V.push(x, y, z);
+  const Tr = [];
+  sideQuads(Tr, stations.length, N, closed);
+  if (!closed) {
+    fanCap(V, Tr, 0, N, centroid(stations[0]), true);                          // start cap faces backward
+    fanCap(V, Tr, (stations.length - 1) * N, N, centroid(stations[stations.length - 1]), false); // end faces forward
+  }
+  let out = manifoldFromMesh(wasm, V, Tr);
+  if (out.volume() < 0) { out.delete?.(); reverseWinding(Tr); out = manifoldFromMesh(wasm, V, Tr); }
+  return out;
+}