partforge 0.7.0 → 0.8.0

package/docs/AUTHORING-PARTS.md

@@ -90,13 +90,55 @@ handles. The same code runs on **Manifold** (fast meshes — preview + STL + 3MF
 |---|---|
 | `k.cylinder(rBottom, rTop, h, { center? })` | cylinder/cone along +Z (frustum if radii differ) |
 | `k.box(min, max)` | axis-aligned box from `[x,y,z]` min/max |
-| `k.prism(points2D, h, { twist?, scaleTop? })` | extrude a 2-D polygon from z=0; optional `twist` (degrees over the height) and `scaleTop` (uniform top taper: 1 straight, <1 taper in, 0 → point/cone) |
+| `k.prism(points2D, h, { twist?, scaleTop? })` | extrude a 2-D polygon (or an **arc profile** from `roundedProfile`) from z=0; optional `twist` (degrees over the height) and `scaleTop` (uniform top taper: 1 straight, <1 taper in, 0 → point/cone) |
+| `k.extrude(profile, h, { twist?, scaleTop? })` | extrude a **polygon-with-holes** region from z=0 in one op — `profile` is `{ outer, holes? }` where each contour is a points array **or an arc profile** (`roundedProfile`, for true STEP fillets), or a bare points array / arc profile for outer-only; same `twist`/`scaleTop` as `prism` (both backends) |
+| `k.loft(rings, { ruled?, closed? })` | stack polygon cross-sections into a solid — ruled walls between consecutive rings, capped ends (both backends; `closed:true` capless loops are Manifold-only). `ruled:false` (smooth C2 blend) is honoured only by OCCT/STEP export; the Manifold preview always shows faceted straight walls |
+| `k.sweep(profile2D, path3D, { cornerRadius?, closed?, ruled?, smooth? })` | sweep a fixed 2-D profile along a 3-D polyline path — sharp mitered corners (or `cornerRadius` fillets), capped ends (both backends). `closed:true` capless loops and `smooth:true` (OCCT-native swept B-rep, STEP-exact / preview-faceted) are backend-specific, like loft's `closed`/`ruled:false`. `closed:true` loops must be **planar** — RMF frame-transport holonomy can seam-twist a non-planar closed loop where the last station rejoins the first, so only planar closed loops are supported/tested |
 | `k.sphere(r)` | sphere centred at the origin |
 | `k.revolve(points2D, { degrees })` | revolve a lathe profile `[[r,z],…]` (r ≥ 0) around the Z axis (full or partial) |
 | `k.helixSweptTube({ pathR, profileR, pitch, turns, z0, lefthand })` | circle swept along a helix (e.g. a rope groove) |
 | `k.union(solids[])` | boolean union |
 
-2-D polygon helpers for `prism`: `import { piePolygon, hexPolygon } from "partforge/geometry"`.
+**`loft` rings** — each ring is `{ polygon:[[x,y],…] | sides+radius, z, rotate?, scale? }`
+(all rings must share the same vertex count; `rotate` is degrees about Z, `scale` is a
+number or `[sx,sy]`). Author rings CCW and ordered by ascending `z` (the `regularPolygon`
+/ `polygon.js` helpers are already CCW); loft self-corrects a fully-inverted result so
+CW-wound or descending-z rings still export a valid outward solid. (Arc profiles from
+`roundedProfile` are **not** accepted as loft rings yet — a ring must be a point array;
+use `prism`/`extrude` for true-arc STEP export.) **`sweep`** takes the same CCW
+`polygon.js` outline as its `profile2D` and a plain `[[x,y,z],…]` point list as its
+`path3D`; the profile stays perpendicular to the path (a rotation-minimizing frame), with
+sharp mitered corners by default or `cornerRadius` fillets. Worked snippets:
+
+```js
+// a square tube (extrude a region with a hole) — one op, no boolean cut
+k.extrude({ outer: roundedRectPolygon(40, 30, 4), holes: [circleProfile(6)] }, 10);
+
+// a tapered, twisting faceted vase wall (see src/parts/faceted-vase.js)
+const rings = [];
+for (let i = 0; i <= 24; i++) { const t = i / 24;
+  rings.push({ sides: 6, radius: 30 - 8 * t, z: 120 * t, rotate: 90 * t }); }
+k.loft(rings);                          // ruled walls, capped ends
+
+// a cable/hose: sweep a circle along a 3-D polyline, with rounded bends
+k.sweep(circleProfile(3), [[0, 0, 0], [0, 0, 20], [15, 0, 20]], { cornerRadius: 5 });
+
+// round every corner of any CCW outline, then extrude/loft/prism it
+k.prism(filletPolygon(bracketOutline, 3), 4);       // tessellated corners (faceted in STEP)
+k.prism(roundedProfile(bracketOutline, 3), 4);      // true CIRCLE corners in STEP export
+```
+
+2-D polygon helpers for `prism`/`extrude`/`loft`: `import { piePolygon, hexPolygon,
+regularPolygon, roundedRectPolygon, starPolygon, circleProfile, filletPolygon,
+roundedProfile } from "partforge/geometry"`. `filletPolygon(points, r, { segs? })` rounds
+every corner of a CCW polygon (per-corner radius clamped so neighbouring arcs never overlap)
+and returns points usable by `prism`/`extrude`/`loft` on both backends — but it **bakes each
+corner into line facets**, so STEP corners are faceted. `roundedProfile(points, r | r[])`
+rounds corners the same way but keeps them **mathematically true** — it carries the arc
+symbolically so STEP export gets real circular edges. Use it for `prism`/`extrude` (not yet
+`loft` — arc rings are rejected there in v1). A scalar `r` rounds every corner; a per-corner
+`r[]` (length = points) rounds selectively (a `0`, a zero-length edge, or a straight/180°
+corner stays sharp).
 **Import geometry helpers from `partforge/geometry`, never from `partforge`** — the main
 entry pulls in the DOM viewer/controls, and your build functions run in a Web Worker
 (importing the main entry there throws `document is not defined`).
@@ -195,7 +237,12 @@ module-level mutable state. An impure build will silently return stale geometry.
 Cache granularity follows the operations you call. Booleans and heavy primitives are
 cached; cheap transforms are recomputed. To make a multi-step shape into a single
 cache node, use (or add) a **compound op** like `k.boredCylinder({ od, h, bore })` —
-it hashes from its own arguments and never exposes its internals to the cache.
+it hashes from its own arguments and never exposes its internals to the cache. The heavy
+primitives `loft`, `sweep`, `extrude`, `prism`, and `revolve` are cached this way too:
+their hash folds every shape-affecting argument (each `loft` ring's points/`z`/`rotate`/`scale`,
+`sweep`'s profile points/path points/`cornerRadius`/`closed`, `extrude`'s holes, an arc
+profile's segment specs from `roundedProfile`, and the tessellation from `twist`), so
+changing any of them is a fresh cache node while an identical rebuild is a hit.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/app-faceted-vase.js

@@ -0,0 +1,10 @@
+import vasePart from "./parts/faceted-vase.js";
+import { mount } from "./framework/index.js";
+
+// Dev-only example app for the faceted vase part. Identical wiring to app-planter.js —
+// only the imported definition and the worker entry differ per part. `npm run dev`,
+// then open /faceted-vase.html.
+mount(vasePart, {
+  createWorker: (name) =>
+    new Worker(new URL("./faceted-vase-worker.js", import.meta.url), { type: "module", name }),
+});

package/src/faceted-vase-worker.js

@@ -0,0 +1,3 @@
+import part from "./parts/faceted-vase.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);

package/src/framework/geometry/helix-tube.js

@@ -1,8 +1,10 @@
 // Builds a watertight triangle mesh of a circular profile swept along a helix in
 // its frenet frame, then imports it as a Manifold solid. The profile stays
 // perpendicular to the helix tangent (unlike twist-extrude), so it matches an
-// exact frenet sweep. Winding is consistent-outward; getting it wrong makes
-// Manifold.ofMesh throw or import an inverted solid.
+// exact frenet sweep. Winding is consistent-outward; the ring stitching + caps +
+// ofMesh import are the shared ring-mesh helpers in mesh-build.js (also used by loft).
+import { sideQuads, fanCap, manifoldFromMesh } from "./mesh-build.js";
+
 const norm = (v) => { const m = Math.hypot(...v); return [v[0] / m, v[1] / m, v[2] / m]; };
 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]];
 
@@ -28,23 +30,11 @@ export function helixTube(wasm, opts) {
              ctr[2] + profileR * (Math.cos(a) * N[2] + Math.sin(a) * B[2]));
     }
   }
-  // side faces (outward winding)
-  for (let i = 0; i < n - 1; i++) for (let j = 0; j < ringSegs; j++) {
-    const a = i*ringSegs + j, b = i*ringSegs + (j+1)%ringSegs;
-    const cc = (i+1)*ringSegs + j, dd = (i+1)*ringSegs + (j+1)%ringSegs;
-    Tr.push(a, dd, cc, a, b, dd);
-  }
-  // end caps
-  const c0 = V.length / 3;
-  V.push(pathR * Math.cos(0), pathR * Math.sin(0), z0);
-  for (let j = 0; j < ringSegs; j++) Tr.push(c0, (j+1)%ringSegs, j);
-  const base = (n - 1) * ringSegs, cz = V.length / 3;
-  V.push(pathR * Math.cos(sign * phiMax), pathR * Math.sin(sign * phiMax), z0 + c * phiMax);
-  for (let j = 0; j < ringSegs; j++) Tr.push(cz, base + j, base + (j+1)%ringSegs);
+  sideQuads(Tr, n, ringSegs, false); // side walls between the n stations
+  // end caps fanned from each end's path-center (outward: bottom flipped, top not)
+  fanCap(V, Tr, 0, ringSegs, [pathR, 0, z0], true);
+  fanCap(V, Tr, (n - 1) * ringSegs, ringSegs,
+         [pathR * Math.cos(sign * phiMax), pathR * Math.sin(sign * phiMax), z0 + c * phiMax], false);
 
-  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;
+  return manifoldFromMesh(wasm, V, Tr);
 }

package/src/framework/geometry/kernel-front.js

@@ -15,6 +15,12 @@ export function finishKernel(k) {
     return rawPrism(pts, h, opts);
   };
 
+  const rawExtrude = k.extrude;
+  k.extrude = (profile, h, opts) => {
+    if ((opts?.scaleTop ?? 1) < 0) throw new Error("extrude: scaleTop must be ≥ 0");
+    return rawExtrude(profile, h, opts);
+  };
+
   const rawRevolve = k.revolve;
   k.revolve = (pts, opts) => {
     for (const [r] of pts) if (r < 0) throw new Error("revolve: profile radius must be ≥ 0");

package/src/framework/geometry/kernel.js

@@ -7,8 +7,8 @@
 
 // Ops every backend kernel must implement.
 export const KERNEL_OPS = [
-  "cylinder", "boredCylinder", "sphere", "box", "prism", "revolve",
-  "helixSweptTube", "union", "toSTEP",
+  "cylinder", "boredCylinder", "sphere", "box", "prism", "extrude", "revolve",
+  "loft", "sweep", "helixSweptTube", "union", "toSTEP",
 ];
 
 // Backend-optional kernel ops: the Manifold cache brackets + WASM lifetime hooks.
@@ -70,6 +70,9 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @property {(r:number) => Solid} sphere   sphere centred at the origin
  * @property {(min:number[], max:number[]) => Solid} box
  * @property {(points2D:number[][], h:number, opts?:{twist?:number,scaleTop?:number}) => Solid} prism   extrude polygon from z=0 (optional twist° + uniform top taper)
+ * @property {(profile:number[][]|{outer:number[][],holes?:number[][][]}, h:number, opts?:{twist?:number,scaleTop?:number}) => Solid} extrude   extrude a polygon-with-holes region from z=0 in one op (bare array = outer only)
+ * @property {(rings:{polygon?:number[][],sides?:number,radius?:number,z:number,rotate?:number,scale?:number|number[]}[], opts?:{ruled?:boolean,closed?:boolean}) => Solid} loft   stack polygon cross-sections (per-ring z/rotate/scale), ruled walls, capped ends
+ * @property {(profile2D:number[][], path3D:number[][], opts?:{closed?:boolean,cornerRadius?:number,ruled?:boolean,smooth?:boolean}) => Solid} sweep   sweep a fixed 2-D profile along a 3-D polyline path (sharp mitered corners or cornerRadius fillets; capped ends; closed:true loops and smooth:true native B-rep are backend-specific)
  * @property {(points2D:number[][], opts?:{degrees?:number}) => Solid} revolve   revolve a lathe profile [[r,z],…] around Z
  * @property {(o:{pathR:number,profileR:number,pitch:number,turns:number,z0:number,lefthand:boolean}) => Solid} helixSweptTube
  * @property {(solids:Solid[]) => Solid} union

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;
+}

package/src/parts/faceted-vase.js

@@ -0,0 +1,75 @@
+// Example PartDefinition — the motivating showcase for k.loft(). Silhouette rings are
+// stacked up a smooth base→waist→rim curve; each ring is a regular n-gon rotated by a
+// running twist plus an alternating half-facet offset, so the facets zig-zag into a
+// woven look. A second, wall-inset loft is cut from the body to hollow it (Manifold
+// backend, so it stays fast — no OCCT). See docs/AUTHORING-PARTS.md for the conventions.
+import { regularPolygon } from "partforge/geometry";
+
+const RINGS = 28; // silhouette resolution (ring count up the height)
+
+// Body radius at height fraction t (0..1): a quadratic Bézier through base/waist/rim.
+const silhouette = (t, p) => { const a = 1 - t; return a * a * p.baseR + 2 * a * t * p.waistR + t * t * p.rimR; };
+
+// Ring list for a wall at radial `inner` inset (offset along the face normal so the
+// perpendicular wall stays == p.wall on every facet). inner=false → outer surface.
+const vaseRings = (p, inner) => {
+  const inset = inner ? p.wall / Math.cos(Math.PI / p.facets) : 0;
+  const out = [];
+  for (let i = 0; i <= RINGS; i++) {
+    const t = i / RINGS;
+    const radius = Math.max(silhouette(t, p) - inset, 0.5);
+    const rotate = p.twist * t + (i % 2) * (180 / p.facets); // running twist + alternating half-facet
+    out.push({ sides: p.facets, radius, z: p.height * t, rotate });
+  }
+  return out;
+};
+
+export default {
+  meta: { title: "Faceted Vase", units: "mm", background: 0x15181d },
+  parameters: [
+    {
+      id: "body",
+      title: "Body",
+      description: "A faceted, twisting vase built from stacked cross-sections (`k.loft`). " +
+        "Pick a preset, or open **Advanced** for exact dimensions. **Facets** and **Twist** are the styling; **Wall** decides whether it prints cleanly.",
+      presets: {
+        "Tulip vase": { height: 150, baseR: 35, waistR: 26, rimR: 40, facets: 5, twist: 40, wall: 2 },
+        "Barrel pot": { height: 90, baseR: 40, waistR: 44, rimR: 38, facets: 8, twist: 0, wall: 2.4 },
+        "Twist column": { height: 180, baseR: 30, waistR: 30, rimR: 30, facets: 6, twist: 120, wall: 2 },
+      },
+      advanced: [
+        { key: "height", label: "Height", unit: "mm", min: 40, max: 220, step: 1, description: "Overall height along the axis." },
+        { key: "baseR", label: "Base radius", unit: "mm", min: 15, max: 70, step: 1, description: "Across-corners radius at the foot." },
+        { key: "waistR", label: "Waist radius", unit: "mm", min: 12, max: 80, step: 1, description: "Radius at mid-height — set below base+rim to pinch a waist, above to bulge a belly." },
+        { key: "rimR", label: "Rim radius", unit: "mm", min: 12, max: 80, step: 1, description: "Across-corners radius at the mouth." },
+        { key: "facets", label: "Facets", min: 3, max: 12, step: 1, description: "Sides of each cross-section. Low counts read crystalline; high counts approach smooth." },
+        { key: "twist", label: "Twist", unit: "°", min: 0, max: 180, step: 5, description: "Total rotation of the facets from foot to rim, for a spiral." },
+        { key: "wall", label: "Wall thickness", unit: "mm", min: 1, max: 5, step: 0.1, description: "Perpendicular wall thickness. The fdm-pla profile wants **≥ 1.2 mm**." },
+        { key: "floor", label: "Floor thickness", unit: "mm", min: 1, max: 8, step: 0.5, hidden: true, description: "Internal: solid base thickness; hidden but drives the geometry." },
+      ],
+    },
+  ],
+  defaults: { height: 150, baseR: 35, waistR: 26, rimR: 40, facets: 5, twist: 40, wall: 2, floor: 3 },
+  parts: {
+    vase: {
+      label: "Vase", views: ["vase"], export: { name: "vase" },
+      build: (k, p) => {
+        const body = k.loft(vaseRings(p, false)).label("Faceted wall");
+        // Hollow it: an inset loft clipped to z ≥ floor (so the base stays solid), cut from the body.
+        const cavity = k.loft(vaseRings(p, true))
+          .intersect(k.box([-1e4, -1e4, p.floor], [1e4, 1e4, p.height + 10])).label("Cavity");
+        return body.cut(cavity);
+      },
+    },
+  },
+  views: { vase: { label: "Vase" } },
+  // Self-verification: opt into the FDM-PLA profile (bed-fit gate + min-wall warning) and
+  // pin the intent — an open vessel (no through-holes), fits the bed, no interpenetration.
+  verify: {
+    process: "fdm-pla",
+    expect: {
+      vase: { holes: 0, bbox: "<=[220,220,230]" },
+      _view: { overlaps: 0 },
+    },
+  },
+};