partforge 0.6.1 → 0.8.0

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

@@ -4,116 +4,71 @@
 import { toEdgeFinder } from "./edge-selector.js";
 import { toFaceFinder } from "./face-selector.js";
 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;
 
-  // Is a shape a closed solid? A broken chamfer (one that over-ran and consumed a face)
-  // meshes to an OPEN surface; a valid one is closed. OCCT meshes each face separately,
-  // so weld vertices by position, then a closed solid has every edge shared by exactly
-  // two triangles. (A coarse mesh is enough — this is a topology check.)
-  const isClosedSolid = (shape) => {
-    const m = shape.mesh({ tolerance: 0.3, angularTolerance: 1.0 });
-    const P = m.vertices, T = m.triangles;
-    const id = new Map();
-    const vid = (i) => {
-      const key = Math.round(P[i * 3] * 32) + "," + Math.round(P[i * 3 + 1] * 32) + "," + Math.round(P[i * 3 + 2] * 32);
-      let d = id.get(key); if (d === undefined) { d = id.size; id.set(key, d); } return d;
-    };
-    const edges = new Map();
-    for (let t = 0; t < T.length / 3; t++) {
-      const a = vid(T[t * 3]), b = vid(T[t * 3 + 1]), c = vid(T[t * 3 + 2]);
-      for (const [x, y] of [[a, b], [b, c], [c, a]]) { const e = x < y ? x * 1e7 + y : y * 1e7 + x; edges.set(e, (edges.get(e) || 0) + 1); }
-    }
-    for (const n of edges.values()) if (n !== 2) return false;
-    return true;
-  };
+  // Fillet/chamfer/shell failure recovery (skip-on-failure, chamfer binary search) —
+  // see occt-repair.js for the policies and why they differ per op.
+  const { validChamfer, safeOp } = createOcctRepair(measureVolume);
 
-  // The true maximum chamfer for an edge depends on local angles and adjacent features,
-  // which is hard to predict analytically (and OCCT exposes no max-radius query). So
-  // VALIDATE the result instead of guessing: try the requested distance, and if it makes
-  // a closed solid, use it (valid large chamfers — e.g. on a pill — go through). If not,
-  // binary-search the largest distance that does. Discarded attempts are freed so OCCT's
-  // WASM heap doesn't grow across regenerates.
-  const validChamfer = (shape, finderFn, distance) => {
-    if (!(distance > 0)) return shape.clone();
-    const tryAt = (d) => {
-      const probe = shape.clone();
-      let res;
-      try { res = probe.chamfer(d, finderFn); } catch { return null; } // probe consumed by the op
-      if (measureVolume(res) > 0 && isClosedSolid(res)) return res;
-      res.delete?.();
-      return null;
-    };
-    let best = tryAt(distance);
-    if (best) return best;                                   // requested distance is valid
-    let lo = 0, hi = distance, bestD = 0;
-    for (let i = 0; i < 6; i++) {
-      const mid = (lo + hi) / 2;
-      const res = tryAt(mid);
-      if (res) { best?.delete?.(); best = res; bestD = mid; lo = mid; } else hi = mid;
-    }
-    if (best) { console.info(`partforge: chamfer ${distance} reduced to ${bestD.toFixed(2)} (largest valid for this geometry)`); return best; }
-    return shape.clone();                                    // nothing valid — skip the chamfer
-  };
-
-  // Native fillet/chamfer can throw or yield an empty solid for out-of-range radii
-  // or awkward edge interactions — and OCCT's failures aren't monotonic in the
-  // radius (e.g. a radius that equals an adjacent fillet's can fail while larger
-  // ones succeed). Rather than letting the whole part vanish, attempt the op on a
-  // clone and fall back to the original shape (feature skipped) on a throw or empty
-  // result, with a console warning so it's discoverable.
-  const safeOp = (shape, op, label) => {
-    const backup = shape.clone();
-    try {
-      const result = op(shape);
-      if (measureVolume(result) > 0) { backup.delete?.(); return result; }
-      result.delete?.();
-      console.warn(`partforge: ${label} produced an empty solid — feature skipped (radius out of range?)`);
-    } catch (e) {
-      console.warn(`partforge: ${label} failed (${e?.message || e}) — feature skipped`);
-    }
-    return backup;
-  };
+  // Feature labels: each entry snapshots the labeled solid's geometry at the moment
+  // the label applies; transforms move the snapshots along, booleans merge the two
+  // sides' lists. At toMesh() time result faces are classified against the snapshots.
+  const cloneLabels = (ls) => ls.map((l) => ({ label: l.label, snapshot: l.snapshot.clone() }));
+  const mapLabels = (ls, f) => ls.map((l) => ({ label: l.label, snapshot: f(l.snapshot.clone()) }));
 
-  const wrap = (shape) => addSugar({
+  const wrap = (shape, labels = []) => addSugar({
     _s: shape,
-    cut: (t) => wrap(shape.cut(t._s)),
-    cutAll: (tools) => wrap(shape.cut(makeCompound(tools.map((t) => t._s)))),
-    clone: () => wrap(shape.clone()),
+    _labels: labels,
+    label: (name) => wrap(shape, [...labels, { label: name, snapshot: shape.clone() }]),
+    cut: (t) => wrap(shape.cut(t._s), [...cloneLabels(labels), ...cloneLabels(t._labels ?? [])]),
+    cutAll: (tools) => wrap(
+      shape.cut(makeCompound(tools.map((t) => t._s))),
+      [...cloneLabels(labels), ...tools.flatMap((t) => cloneLabels(t._labels ?? []))]
+    ),
+    intersect: (t) => wrap(shape.intersect(t._s), [...cloneLabels(labels), ...cloneLabels(t._labels ?? [])]),
+    clone: () => wrap(shape.clone(), cloneLabels(labels)),
     boundingBox: () => {
-      const bb = shape.boundingBox;        // replicad BoundingBox: .bounds [[min],[max]], .center
-      const [min, max] = bb.bounds;
-      return {
-        min: [...min], max: [...max], center: [...bb.center],
-        size: [max[0] - min[0], max[1] - min[1], max[2] - min[2]],
-      };
-    },
-    translate: (v) => wrap(shape.translate(v)),
-    rotate: (deg, center, axis) => wrap(shape.rotate(deg, center, axis)),
-    mirror: (plane) => wrap(shape.mirror(plane)),
-    scale: (factor, center = [0, 0, 0]) => {
-      if (!(factor > 0)) throw new Error("scale: factor must be > 0");
-      return wrap(shape.scale(factor, center));
+      const [min, max] = shape.boundingBox.bounds; // addSugar derives center/size
+      return { min: [...min], max: [...max] };
     },
+    translate: (v) => wrap(shape.translate(v), mapLabels(labels, (s) => s.translate(v))),
+    rotate: (deg, center, axis) => wrap(shape.rotate(deg, center, axis), mapLabels(labels, (s) => s.rotate(deg, center, axis))),
+    mirror: (plane) => wrap(shape.mirror(plane), mapLabels(labels, (s) => s.mirror(plane))),
+    scale: (factor, center) => wrap(shape.scale(factor, center), mapLabels(labels, (s) => s.scale(factor, center))), // validated/defaulted by addSugar
     toMesh: ({ quality = "preview" } = {}) => {
       const m = shape.mesh(MESH[quality]);
-      return {
+      const out = {
         positions: Float32Array.from(m.vertices),
         normals: new Float32Array(0), // let the main thread crease (matches prior look)
         indices: Uint32Array.from(m.triangles),
         triangles: m.triangles.length / 3,
       };
+      if (labels.length) {
+        const soups = labels.map((l) => {
+          const lm = l.snapshot.clone().mesh(MESH.preview); // clone: mesh() must not disturb the kept snapshot
+          return { label: l.label, vertices: lm.vertices, triangles: lm.triangles };
+        });
+        Object.assign(out, classifyFaceGroups(m, soups));
+      }
+      return out;
     },
     toSTL: ({ quality = "print" } = {}) => shape.blobSTL(MESH[quality]).arrayBuffer(),
-    fillet: (radius, selector) => wrap(safeOp(shape, (sh) => sh.fillet(radius, toEdgeFinder(selector)), `fillet(${radius})`)),
-    chamfer: (distance, selector) => wrap(validChamfer(shape, toEdgeFinder(selector), distance)),
+    fillet: (radius, selector) => wrap(safeOp(shape, (sh) => sh.fillet(radius, toEdgeFinder(selector)), `fillet(${radius})`), cloneLabels(labels)),
+    chamfer: (distance, selector) => wrap(validChamfer(shape, toEdgeFinder(selector), distance), cloneLabels(labels)),
     shell: (thickness, openFaces) => {
       if (openFaces == null) throw new Error("shell: openFaces is required (a fully closed hollow is not supported)");
       // replicad shells inward with a positive thickness in this version, keeping outer dimensions.
-      return wrap(safeOp(shape, (sh) => sh.shell(thickness, toFaceFinder(openFaces)), `shell(${thickness})`));
+      return wrap(safeOp(shape, (sh) => sh.shell(thickness, toFaceFinder(openFaces)), `shell(${thickness})`), cloneLabels(labels));
     },
     volume: () => measureVolume(shape),
     toIndexedMesh: () => {
@@ -131,12 +86,25 @@ export function createOcctKernel(replicad) {
     return wrap(loft([w1, w2]));
   };
 
-  // extrude a 2-D polygon from z=0
+  // 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 } = {}) => {
-    if (scaleTop < 0) throw new Error("prism: scaleTop must be ≥ 0");
-    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;
@@ -145,12 +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 } = {}) => {
-    for (const [r] of pts) if (r < 0) throw new Error("revolve: profile radius must be ≥ 0");
-    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)
@@ -162,13 +172,14 @@ export function createOcctKernel(replicad) {
     return wrap(genericSweep(profile, spine, { frenet: true }));
   };
 
-  return {
-    cylinder,
-    boredCylinder: ({ od, h, bore }) =>
-      cylinder(od / 2, od / 2, h).cut(cylinder(bore / 2, bore / 2, h + 4).translate([0, 0, -2])),
-    box: (min, max) => wrap(makeBox(min, max)), prism, revolve, helixSweptTube,
+  return finishKernel({
+    cylinder, // boredCylinder: the kernel front's default composition is exactly right here
+    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))),
+    union: (solids) => wrap(
+      solids.map((s) => s._s).reduce((a, b) => a.fuse(b)),
+      solids.flatMap((s) => cloneLabels(s._labels ?? []))
+    ),
     toSTEP: (named) => exportSTEP(named.map(({ name, solid }) => ({ name, shape: solid._s }))).arrayBuffer(),
-  };
+  });
 }

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

@@ -0,0 +1,83 @@
+// Failure recovery for native OCCT features (fillet/chamfer/shell), extracted from
+// occt-backend.js so the backend reads as a clean contract mapping and the pure
+// mesh-topology logic is unit-testable without booting OCCT.
+//
+// Two deliberately different rescue policies:
+//   - chamfer → validChamfer: try the requested distance, and if it breaks the
+//     solid, binary-search the largest distance that doesn't. An over-large chamfer
+//     fails by over-running its faces, which is (near enough) monotonic in the
+//     distance — so bisection is sound.
+//   - fillet (and shell) → safeOp: attempt once, skip the feature on failure.
+//     OCCT fillet failures are NOT monotonic in the radius (a radius equal to an
+//     adjacent fillet's can fail while larger ones succeed), so a binary search
+//     would converge on garbage; skipping keeps the part alive and warns.
+
+// Is a shape a closed solid? A broken chamfer (one that over-ran and consumed a face)
+// meshes to an OPEN surface; a valid one is closed. OCCT meshes each face separately,
+// so weld vertices by position, then a closed solid has every edge shared by exactly
+// two triangles. (A coarse mesh is enough — this is a topology check.)
+export const isClosedSolid = (shape) => {
+  const m = shape.mesh({ tolerance: 0.3, angularTolerance: 1.0 });
+  const P = m.vertices, T = m.triangles;
+  const id = new Map();
+  const vid = (i) => {
+    const key = Math.round(P[i * 3] * 32) + "," + Math.round(P[i * 3 + 1] * 32) + "," + Math.round(P[i * 3 + 2] * 32);
+    let d = id.get(key); if (d === undefined) { d = id.size; id.set(key, d); } return d;
+  };
+  const edges = new Map();
+  for (let t = 0; t < T.length / 3; t++) {
+    const a = vid(T[t * 3]), b = vid(T[t * 3 + 1]), c = vid(T[t * 3 + 2]);
+    for (const [x, y] of [[a, b], [b, c], [c, a]]) { const e = x < y ? x * 1e7 + y : y * 1e7 + x; edges.set(e, (edges.get(e) || 0) + 1); }
+  }
+  for (const n of edges.values()) if (n !== 2) return false;
+  return true;
+};
+
+export function createOcctRepair(measureVolume) {
+  // The true maximum chamfer for an edge depends on local angles and adjacent features,
+  // which is hard to predict analytically (and OCCT exposes no max-radius query). So
+  // VALIDATE the result instead of guessing: try the requested distance, and if it makes
+  // a closed solid, use it (valid large chamfers — e.g. on a pill — go through). If not,
+  // binary-search the largest distance that does. Discarded attempts are freed so OCCT's
+  // WASM heap doesn't grow across regenerates.
+  const validChamfer = (shape, finderFn, distance) => {
+    if (!(distance > 0)) return shape.clone();
+    const tryAt = (d) => {
+      const probe = shape.clone();
+      let res;
+      try { res = probe.chamfer(d, finderFn); } catch { return null; } // probe consumed by the op
+      if (measureVolume(res) > 0 && isClosedSolid(res)) return res;
+      res.delete?.();
+      return null;
+    };
+    let best = tryAt(distance);
+    if (best) return best;                                   // requested distance is valid
+    let lo = 0, hi = distance, bestD = 0;
+    for (let i = 0; i < 6; i++) {
+      const mid = (lo + hi) / 2;
+      const res = tryAt(mid);
+      if (res) { best?.delete?.(); best = res; bestD = mid; lo = mid; } else hi = mid;
+    }
+    if (best) { console.info(`partforge: chamfer ${distance} reduced to ${bestD.toFixed(2)} (largest valid for this geometry)`); return best; }
+    return shape.clone();                                    // nothing valid — skip the chamfer
+  };
+
+  // Native fillet/shell can throw or yield an empty solid for out-of-range radii
+  // or awkward edge interactions. Rather than letting the whole part vanish, attempt
+  // the op on a clone and fall back to the original shape (feature skipped) on a
+  // throw or empty result, with a console warning so it's discoverable.
+  const safeOp = (shape, op, label) => {
+    const backup = shape.clone();
+    try {
+      const result = op(shape);
+      if (measureVolume(result) > 0) { backup.delete?.(); return result; }
+      result.delete?.();
+      console.warn(`partforge: ${label} produced an empty solid — feature skipped (radius out of range?)`);
+    } catch (e) {
+      console.warn(`partforge: ${label} failed (${e?.message || e}) — feature skipped`);
+    }
+    return backup;
+  };
+
+  return { validChamfer, safeOp };
+}

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/probe.js

@@ -1,41 +1,48 @@
 // Geometry-free backend detection. A probe kernel records every op a part's
 // build() invokes (returning chainable no-op proxies, dummy values for queries);
-// if an OCCT-only op was used, the part needs the OCCT backend.
-export const OCCT_ONLY = new Set(["fillet", "chamfer", "shell"]);
+// if an OCCT-only op was used, the part needs the OCCT backend. The op list lives
+// in kernel.js — the same list generates the Manifold backend's throwing stubs.
+import { OCCT_ONLY_OPS } from "./kernel.js";
+
+const OCCT_ONLY = new Set(OCCT_ONLY_OPS);
 
 export function createProbeKernel() {
   const used = new Set();
   const note = (name) => used.add(name);
-  const proxy = {
-    cut() { note("cut"); return proxy; },
-    cutAll() { note("cutAll"); return proxy; },
-    intersect() { note("intersect"); return proxy; },
-    clone() { note("clone"); return proxy; },
-    boundingBox() { note("boundingBox"); return { min: [0, 0, 0], max: [1, 1, 1], center: [0.5, 0.5, 0.5], size: [1, 1, 1] }; },
-    translate() { note("translate"); return proxy; },
-    rotate() { note("rotate"); return proxy; },
-    mirror() { note("mirror"); return proxy; },
-    scale() { note("scale"); return proxy; },
-    fillet() { note("fillet"); return proxy; },
-    chamfer() { note("chamfer"); return proxy; },
-    shell() { note("shell"); return proxy; },
-    volume() { note("volume"); return 1; },
-    toMesh() { note("toMesh"); return { positions: new Float32Array(9), normals: new Float32Array(9), triangles: 1, edges: new Float32Array(0) }; },
-    toSTL() { note("toSTL"); return new ArrayBuffer(0); },
-    toIndexedMesh() { note("toIndexedMesh"); return { positions: new Float32Array(9), indices: new Uint32Array(3) }; },
+
+  // Catch-all proxies: any method records its name and returns the chainable solid
+  // proxy, EXCEPT the queries below, which return realistic dummy values the build may
+  // read. Using a Proxy (rather than a hand-listed allowlist) means new kernel/solid
+  // methods never have to be mirrored here — the probe can't drift out of sync with the
+  // real backends. (That drift previously broke the panel's relevance dimming/hiding when
+  // the build-step vocabulary was added but not taught to the probe.)
+  const solidQueries = {
+    boundingBox: () => ({ min: [0, 0, 0], max: [1, 1, 1], center: [0.5, 0.5, 0.5], size: [1, 1, 1] }),
+    volume: () => 1,
+    toMesh: () => ({ positions: new Float32Array(9), normals: new Float32Array(9), triangles: 1, edges: new Float32Array(0) }),
+    toSTL: () => new ArrayBuffer(0),
+    toIndexedMesh: () => ({ positions: new Float32Array(9), indices: new Uint32Array(3) }),
   };
-  const kernel = {
-    cylinder() { note("cylinder"); return proxy; },
-    boredCylinder() { note("boredCylinder"); return proxy; },
-    sphere() { note("sphere"); return proxy; },
-    box() { note("box"); return proxy; },
-    prism() { note("prism"); return proxy; },
-    revolve() { note("revolve"); return proxy; },
-    helixSweptTube() { note("helixSweptTube"); return proxy; },
-    union() { note("union"); return proxy; },
-    toSTEP() { note("toSTEP"); return Promise.resolve(new ArrayBuffer(0)); },
-    cleanup() {},
+  const kernelQueries = {
+    toSTEP: () => Promise.resolve(new ArrayBuffer(0)),
+    cleanup: () => {},
   };
+
+  // `ignore` keeps the proxy from masquerading as a thenable/internal handle: symbols,
+  // `then` (so it's never await-unwrapped), and `_`-prefixed internals resolve to
+  // undefined rather than a chainable op.
+  const ignore = (key) => typeof key !== "string" || key === "then" || key[0] === "_";
+
+  const opProxy = (queries) => new Proxy({}, {
+    get(_t, key) {
+      if (ignore(key)) return undefined;
+      if (key in queries) return queries[key];
+      return (..._args) => { note(key); return proxy; };
+    },
+  });
+
+  const proxy = opProxy(solidQueries);   // a solid handle: every op chains back to itself
+  const kernel = opProxy(kernelQueries); // factory ops (cylinder/box/prism/…) return a solid
   return { kernel, used };
 }
 

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