partforge 0.6.1 → 0.8.0

package/src/framework/geometry/feature-attribution.js

@@ -0,0 +1,102 @@
+// Pure classification math for OCCT feature labels. The OCCT backend meshes each
+// labeled solid snapshot into a triangle soup; a face of the RESULT mesh belongs to
+// a label when its sampled triangle centroids all lie on that soup's surface (a cut
+// face lies exactly on its tool's surface, up to the two meshes' tolerances).
+// No OCCT, no three.js — unit-testable with hand-built soups.
+
+// Result mesh (preview) tolerance 0.1 + snapshot mesh tolerance 0.1 + slack.
+const DEFAULT_TOL = 0.35; // mm — surfaces closer than this to another labeled surface can misattribute
+const SAMPLES_PER_FACE = 4;
+
+// Distance from point p to triangle (a,b,c) — the classic region-based projection.
+export function pointTriDist(p, a, b, c) {
+  const sub = (u, v) => [u[0] - v[0], u[1] - v[1], u[2] - v[2]];
+  const dot = (u, v) => u[0] * v[0] + u[1] * v[1] + u[2] * v[2];
+  const ab = sub(b, a), ac = sub(c, a), ap = sub(p, a);
+  const d1 = dot(ab, ap), d2 = dot(ac, ap);
+  if (d1 <= 0 && d2 <= 0) return Math.hypot(...ap);                 // vertex a
+  const bp = sub(p, b);
+  const d3 = dot(ab, bp), d4 = dot(ac, bp);
+  if (d3 >= 0 && d4 <= d3) return Math.hypot(...bp);                // vertex b
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0) {                              // edge ab
+    const t = d1 / (d1 - d3);
+    return Math.hypot(...sub(p, [a[0] + ab[0] * t, a[1] + ab[1] * t, a[2] + ab[2] * t]));
+  }
+  const cp = sub(p, c);
+  const d5 = dot(ab, cp), d6 = dot(ac, cp);
+  if (d6 >= 0 && d5 <= d6) return Math.hypot(...cp);                // vertex c
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0) {                              // edge ac
+    const t = d2 / (d2 - d6);
+    return Math.hypot(...sub(p, [a[0] + ac[0] * t, a[1] + ac[1] * t, a[2] + ac[2] * t]));
+  }
+  const va = d3 * d6 - d5 * d4;
+  if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {                    // edge bc
+    const t = (d4 - d3) / (d4 - d3 + (d5 - d6));
+    const bc = sub(c, b);
+    return Math.hypot(...sub(p, [b[0] + bc[0] * t, b[1] + bc[1] * t, b[2] + bc[2] * t]));
+  }
+  const denom = 1 / (va + vb + vc);                                  // interior
+  const v = vb * denom, w = vc * denom;
+  return Math.hypot(...sub(p, [a[0] + ab[0] * v + ac[0] * w, a[1] + ab[1] * v + ac[1] * w, a[2] + ab[2] * v + ac[2] * w]));
+}
+
+const centroid = (V, T, t) => {
+  const i = T[t * 3] * 3, j = T[t * 3 + 1] * 3, k = T[t * 3 + 2] * 3;
+  return [(V[i] + V[j] + V[k]) / 3, (V[i + 1] + V[j + 1] + V[k + 1]) / 3, (V[i + 2] + V[j + 2] + V[k + 2]) / 3];
+};
+
+function distToSoup(p, soup) {
+  const V = soup.vertices, T = soup.triangles;
+  let best = Infinity;
+  for (let t = 0; t < T.length / 3; t++) {
+    const a = [V[T[t * 3] * 3], V[T[t * 3] * 3 + 1], V[T[t * 3] * 3 + 2]];
+    const b = [V[T[t * 3 + 1] * 3], V[T[t * 3 + 1] * 3 + 1], V[T[t * 3 + 1] * 3 + 2]];
+    const c = [V[T[t * 3 + 2] * 3], V[T[t * 3 + 2] * 3 + 1], V[T[t * 3 + 2] * 3 + 2]];
+    const d = pointTriDist(p, a, b, c);
+    if (d < best) best = d;
+  }
+  return best;
+}
+
+// resultMesh: replicad ShapeMesh {vertices, triangles, faceGroups}; soups: labeled
+// snapshots meshed by the caller. Returns {} when attribution isn't possible.
+export function classifyFaceGroups(resultMesh, soups, tol = DEFAULT_TOL) {
+  const groups = resultMesh.faceGroups;
+  const nTri = resultMesh.triangles.length / 3;
+  if (!groups?.length || !soups.length) return {};
+
+  // faceGroups start/count units differ across replicad versions: triangle counts
+  // sum to nTri, index counts to nTri*3. Detect which this is.
+  const total = groups.reduce((s, g) => s + g.count, 0);
+  const div = total === nTri * 3 ? 3 : 1;
+
+  const indexOf = new Map(); // label -> 1-based feature index (same-label merge)
+  const features = [];
+  const featureIds = new Uint16Array(nTri);
+
+  for (const g of groups) {
+    const start = g.start / div, count = g.count / div;
+    if (count <= 0) continue; // degenerate group: no triangles, nothing to attribute
+    // sample a few spread triangles of the face
+    const picks = [];
+    const denom = Math.max(1, Math.min(SAMPLES_PER_FACE, count) - 1);
+    for (let s = 0; s < Math.min(SAMPLES_PER_FACE, count); s++) {
+      picks.push(start + Math.floor((s * (count - 1)) / denom));
+    }
+    // last matching soup wins (most recently applied label)
+    let winner = null;
+    for (const soup of soups) {
+      const onSurface = picks.every(
+        (t) => distToSoup(centroid(resultMesh.vertices, resultMesh.triangles, t), soup) <= tol
+      );
+      if (onSurface) winner = soup.label;
+    }
+    if (winner == null) continue;
+    let fi = indexOf.get(winner);
+    if (fi === undefined) { features.push(winner); fi = features.length; indexOf.set(winner, fi); }
+    for (let t = start; t < start + count; t++) featureIds[t] = fi;
+  }
+  return features.length ? { featureIds, features } : {};
+}

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

@@ -0,0 +1,37 @@
+// The backend-shared kernel front. Each backend builds its primitive mapping and
+// returns finishKernel(kernel), which layers on everything that is NOT
+// backend-specific:
+//   - argument validation (previously copy-pasted into both backends);
+//   - default compound-op compositions — a backend only overrides one when it has
+//     a reason to (Manifold's boredCylinder hashes atomically for its solid cache);
+//   - a KernelCapabilityError stub for toSTEP when the backend can't write B-rep.
+// The per-Solid twin of this layer is addSugar() in solid-sugar.js.
+import { KernelCapabilityError } from "./errors.js";
+
+export function finishKernel(k) {
+  const rawPrism = k.prism;
+  k.prism = (pts, h, opts) => {
+    if ((opts?.scaleTop ?? 1) < 0) throw new Error("prism: scaleTop must be ≥ 0");
+    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");
+    return rawRevolve(pts, opts);
+  };
+
+  // Compound: bored-through cylinder (tool overshoots 2 mm each end for a clean cut).
+  k.boredCylinder ??= ({ od, h, bore }) =>
+    k.cylinder(od / 2, od / 2, h).cut(k.cylinder(bore / 2, bore / 2, h + 4).translate([0, 0, -2]));
+
+  k.toSTEP ??= () => { throw new KernelCapabilityError("toSTEP requires the OCCT backend"); };
+
+  return k;
+}

package/src/framework/geometry/kernel.js

@@ -1,15 +1,48 @@
-// The GeometryKernel contract (documentation). Backends implement the @typedef
-// below. (2-D polygon helpers live in ./polygon.js.)
+// The GeometryKernel contract. The op lists below are DATA, not just docs: the
+// parity tests (test/kernel-contract.test.js and the OCCT twin in
+// test/occt-backend.test.js) assert each backend exposes exactly these ops, so the
+// contract can't silently drift from the implementations — the drift class that
+// once broke the probe kernel (see probe.js). The @typedefs document signatures.
+// (2-D polygon helpers live in ./polygon.js.)
+
+// Ops every backend kernel must implement.
+export const KERNEL_OPS = [
+  "cylinder", "boredCylinder", "sphere", "box", "prism", "extrude", "revolve",
+  "loft", "sweep", "helixSweptTube", "union", "toSTEP",
+];
+
+// Backend-optional kernel ops: the Manifold cache brackets + WASM lifetime hooks.
+// jobs.js calls all of these via `?.`, so a backend may simply omit them.
+export const KERNEL_OPTIONAL_OPS = [
+  "beginSubPart", "endSubPart", "cacheStats", "resetCacheStats", "cleanup",
+];
+
+// Ops every Solid must implement (including the sugar addSugar() attaches).
+export const SOLID_OPS = [
+  "cut", "cutAll", "intersect", "clone", "label", "boundingBox", "volume",
+  "translate", "rotate", "rotateX", "rotateY", "rotateZ", "rotateAbout", "along", "at",
+  "mirror", "scale", "toMesh", "toSTL", "toIndexedMesh",
+  "fillet", "chamfer", "shell",
+];
+
+// Backend-optional Solid queries: Manifold mesh-topology numbers (measure.js
+// guards with `typeof`); OCCT has no cheap equivalent.
+export const SOLID_OPTIONAL_OPS = ["genus", "isEmpty"];
+
+// Solid ops only OCCT implements natively. Single source of truth: probe.js routes
+// a part to OCCT when its build uses one of these, and the Manifold backend
+// generates its KernelCapabilityError stubs from the same list — adding an op here
+// wires up both automatically.
+export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
 
 /**
- * @typedef {Object} Solid  An opaque handle to a backend solid.
- * @property {string} _hash   content hash (Manifold backend only; drives the worker solid cache)
+ * @typedef {Object} Solid  An opaque handle to a backend solid. `_`-prefixed keys are backend internals.
  * @property {(tool: Solid) => Solid} cut
  * @property {(tools: Solid[]) => Solid} cutAll      batch subtract (backend-optimized)
- * @property {(other: Solid) => Solid} intersect     boolean intersection (Manifold)
+ * @property {(other: Solid) => Solid} intersect     boolean intersection (both backends)
  * @property {() => Solid} clone   independent copy (replicad consumes solids on transform)
+ * @property {(name: string) => Solid} label   name this solid's surface for hover/pick feature attribution (survives transforms + booleans; same name on several solids merges into one feature)
  * @property {() => {min:number[],max:number[],center:number[],size:number[]}} boundingBox   axis-aligned bounds (query)
- * @property {(thickness:number, openFaces:object) => Solid} shell   hollow inward (OCCT only); openFaces selector required
  * @property {(v: number[]) => Solid} translate
  * @property {(deg: number, center: number[], axis: number[]) => Solid} rotate   internal primitive — prefer rotateX/Y/Z / rotateAbout
  * @property {(deg: number) => Solid} rotateX   rotate about world X through the origin
@@ -20,10 +53,16 @@
  * @property {(v:number[]) => Solid} at   place an origin-built solid at point v (alias of translate)
  * @property {(plane: "XY"|"XZ"|"YZ") => Solid} mirror
  * @property {(factor:number, center?:number[]) => Solid} scale   uniform scale about center (default origin)
- * @property {() => number} volume                   solid volume in mm³ (Manifold; used by collision tests)
- * @property {(opts?: {quality?: "preview"|"print"}) => {positions:Float32Array, normals:Float32Array, indices:Uint32Array, triangles:number}} toMesh
+ * @property {() => number} volume                   solid volume in mm³ (both backends; used by collision/overlap tests)
+ * @property {(opts?: {quality?: "preview"|"print"}) => {positions:Float32Array, normals:Float32Array, indices?:Uint32Array, triangles:number, edges?:Float32Array}} toMesh
+ *           `edges` = feature-edge line segments (Manifold); quality is advisory — the Manifold kernel bakes it at creation
  * @property {(opts?: {quality?: "preview"|"print"}) => Promise<ArrayBuffer>} toSTL
- * @property {() => {positions:Float32Array, indices:Uint32Array}} toIndexedMesh   indexed mesh, for 3MF (Manifold)
+ * @property {() => {positions:Float32Array, indices:Uint32Array}} toIndexedMesh   indexed mesh, for 3MF
+ * @property {(radius:number, selector?:object) => Solid} fillet    round edges (OCCT only; Manifold throws KernelCapabilityError)
+ * @property {(distance:number, selector?:object) => Solid} chamfer  bevel edges (OCCT only; Manifold throws KernelCapabilityError)
+ * @property {(thickness:number, openFaces:object) => Solid} shell   hollow inward (OCCT only); openFaces selector required
+ * @property {() => number} [genus]     through-hole count (Manifold only)
+ * @property {() => boolean} [isEmpty]  no geometry at all (Manifold only)
  *
  * @typedef {Object} GeometryKernel
  * @property {(rBottom:number, rTop:number, h:number, opts?:{center?:boolean}) => Solid} cylinder
@@ -31,9 +70,16 @@
  * @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
- * @property {(named:{name:string,solid:Solid}[]) => Promise<ArrayBuffer>} toSTEP   OCCT only
+ * @property {(named:{name:string,solid:Solid}[]) => Promise<ArrayBuffer>} toSTEP   OCCT only (Manifold throws KernelCapabilityError)
+ * @property {(name:string) => void} [beginSubPart]   open a per-sub-part solid-cache round (Manifold only)
+ * @property {() => void} [endSubPart]                close the cache round (always pair with beginSubPart)
+ * @property {() => {hits:number,misses:number}} [cacheStats]
+ * @property {() => void} [resetCacheStats]
  * @property {() => void} [cleanup]   free per-job WASM objects (Manifold backend); call after each job
  */

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,8 +1,11 @@
 import { helixTube } from "./helix-tube.js";
-import { KernelCapabilityError } from "./errors.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";
+import { finishKernel } from "./kernel-front.js";
 
 const PLANE_NORMAL = { XY: [0, 0, 1], XZ: [0, 1, 0], YZ: [1, 0, 0] };
 // 'preview' = interactive view (fast); 'print' = STL export (high-res, used only
@@ -38,6 +41,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   const unionRaw = (ms) => ms.reduce((a, b) => T(a.add(b))); // track each reduce step
 
   const cache = createSolidCache();
+  const featureLabels = new Map(); // originalID -> label string (grows per label(); tiny)
   // Boundary ops route through cache.lookup; on a miss `make` runs the WASM op,
   // tracks the result, and returns the triple the cache needs to pin/dispose it.
   const cached = (hash, computeM) => cache.lookup(hash, () => {
@@ -49,7 +53,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   // transient mesh handle.
   function meshOut(m, asStl) {
     const g = m.getMesh();
-    const r = asStl ? stlFromMesh(g) : creasedNormals(g, Math.cos((SHARP_ANGLE * Math.PI) / 180));
+    const r = asStl ? stlFromMesh(g) : creasedNormals(g, Math.cos((SHARP_ANGLE * Math.PI) / 180), featureLabels);
     g.delete?.();
     return r;
   }
@@ -79,14 +83,23 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       () => T(m.subtract(unionRaw(tools.map((t) => t._m))))),
     intersect: (t) => cached(h("intersect", hash, t._hash), () => T(m.intersect(t._m))),
     clone: () => wrap(m, hash),
+    // Name this solid's surface for hover/pick feature attribution. asOriginal()
+    // stamps a fresh originalID that survives transforms and booleans, so every
+    // surviving triangle of this surface can be traced back to the label. The
+    // registry entry lives exactly as long as the cache pins the solid — eviction
+    // disposes both, so the registry can't grow unboundedly across regenerates.
+    label: (name) => {
+      const lh = h("label", hash, name);
+      return cache.lookup(lh, () => {
+        const o = T(m.asOriginal());
+        const id = o.originalID();
+        featureLabels.set(id, name);
+        return { value: wrap(o, lh), pin: o, dispose: () => { featureLabels.delete(id); o.delete?.(); } };
+      });
+    },
     boundingBox: () => {
-      const b = m.boundingBox();           // { min: Vec3, max: Vec3 }
-      const min = [...b.min], max = [...b.max];
-      return {
-        min, max,
-        center: [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2],
-        size: [max[0] - min[0], max[1] - min[1], max[2] - min[2]],
-      };
+      const b = m.boundingBox();           // { min: Vec3, max: Vec3 } — addSugar derives center/size
+      return { min: [...b.min], max: [...b.max] };
     },
     volume: () => m.volume(),
     genus: () => m.genus(),
@@ -101,8 +114,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       return wrap(T(b.translate(center)), h("rotate", hash, deg, center, axis));
     },
     mirror: (plane) => wrap(T(m.mirror(PLANE_NORMAL[plane])), h("mirror", hash, plane)),
-    scale: (factor, center = [0, 0, 0]) => {
-      if (!(factor > 0)) throw new Error("scale: factor must be > 0");
+    scale: (factor, center) => { // factor validated (and center defaulted) by addSugar
       const a = T(m.translate([-center[0], -center[1], -center[2]]));
       const b = T(a.scale([factor, factor, factor]));
       return wrap(T(b.translate(center)), h("scale", hash, factor, center));
@@ -110,12 +122,9 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     toMesh: () => meshOut(m, false),
     toSTL: () => Promise.resolve(meshOut(m, true)),
     toIndexedMesh: () => indexedMeshOut(m),
-    fillet: () => { throw new KernelCapabilityError("fillet requires the OCCT backend"); },
-    chamfer: () => { throw new KernelCapabilityError("chamfer requires the OCCT backend"); },
-    shell: () => { throw new KernelCapabilityError("shell requires the OCCT backend"); },
   });
 
-  return {
+  return finishKernel({
     cylinder: (rb, rt, h2, { center = false } = {}) =>
       wrap(T(Manifold.cylinder(h2, rb, rt, segs, center)), h("cylinder", rb, rt, h2, center, segs)),
     // Compound op: hashed ATOMICALLY from its own args, so it is a single cache
@@ -134,22 +143,35 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     },
     prism: (pts, height, { twist = 0, scaleTop = 1 } = {}) =>
       cached(h("prism", pts, height, twist, scaleTop, segs), () => {
-        if (scaleTop < 0) throw new Error("prism: scaleTop must be ≥ 0");
-        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), () => {
-        for (const [r] of pts) if (r < 0) throw new Error("revolve: profile radius must be ≥ 0");
-        return T(Manifold.revolve([pts], segs, degrees));
-      }),
+      cached(h("revolve", pts, degrees, segs), () => T(Manifold.revolve([pts], segs, degrees))),
     union: (solids) => cached(h("union", solids.map((s) => s._hash)), () => unionRaw(solids.map((s) => s._m))),
-    toSTEP: () => { throw new Error("STEP export not supported by the Manifold backend"); },
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),
     cacheStats: () => cache.stats(),
@@ -157,7 +179,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // Free every WASM object created since the last cleanup EXCEPT solids the cache
     // still pins (they must survive for the next build to resume from them).
     cleanup: () => { for (const o of tracked) if (!cache.isPinned(o)) o.delete?.(); tracked.length = 0; },
-  };
+  });
 }
 
 // Build a non-indexed mesh with normals that are smooth within a single original
@@ -166,7 +188,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
 // only over incident triangles of the SAME original surface that also meet within
 // `sharpCos` — so cut seams stay crisp at any angle (even near-tangent), and a
 // surface's own sharp edges (e.g. a face meeting a side) stay crisp too.
-function creasedNormals(g, sharpCos) {
+function creasedNormals(g, sharpCos, featureLabels) {
   const np = g.numProp, vp = g.vertProperties, tris = g.triVerts;
   const nTri = (tris.length / 3) | 0, nVert = (vp.length / np) | 0;
 
@@ -245,7 +267,27 @@ function creasedNormals(g, sharpCos) {
       }
     }
 
-  return { positions, normals, triangles: nTri, edges: Float32Array.from(edges) }; // mesh non-indexed
+  // Per-triangle feature attribution: map each triangle's original-surface id
+  // through the label registry. Same label string → same feature entry, so a
+  // pattern of solids labeled alike reads as one feature.
+  let featureIds = null, features = null;
+  if (featureLabels?.size) {
+    const indexOf = new Map(); // label string -> 1-based feature index
+    features = [];
+    featureIds = new Uint16Array(nTri);
+    for (let t = 0; t < nTri; t++) {
+      const label = featureLabels.get(triOID[t]);
+      if (label === undefined) continue;
+      let fi = indexOf.get(label);
+      if (fi === undefined) { features.push(label); fi = features.length; indexOf.set(label, fi); }
+      featureIds[t] = fi;
+    }
+    if (features.length === 0) { featureIds = features = null; } // labels exist in the kernel, none in THIS mesh
+  }
+
+  const out = { positions, normals, triangles: nTri, edges: Float32Array.from(edges) }; // mesh non-indexed
+  if (featureIds) { out.featureIds = featureIds; out.features = features; }
+  return out;
 }
 
 function stlFromMesh(g) {

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