partforge 0.1.0 → 0.3.3

package/src/framework/geometry/errors.js

@@ -0,0 +1,10 @@
+// Thrown by a backend that can't perform a requested op (e.g. Manifold has no
+// fillet/chamfer). The framework catches `.code === "NEEDS_OCCT"` and reroutes
+// the part to the OCCT backend.
+export class KernelCapabilityError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KernelCapabilityError";
+    this.code = "NEEDS_OCCT";
+  }
+}

package/src/framework/geometry/face-selector.js

@@ -0,0 +1,19 @@
+// Map partforge's declarative face selector onto a replicad FaceFinder filter.
+//   undefined / null   → undefined (all faces)
+//   (f) => f...         → passed through (raw replicad finder escape hatch)
+//   { dir, inPlane, at, near } → a filter applying the given criteria (AND)
+// dir picks faces whose normal runs along that axis (i.e. parallel to the
+// perpendicular plane): X→YZ, Y→XZ, Z→XY.
+const PERP_PLANE = { X: "YZ", Y: "XZ", Z: "XY" };
+
+export function toFaceFinder(selector) {
+  if (selector == null) return undefined;
+  if (typeof selector === "function") return selector;
+  return (f) => {
+    let r = f;
+    if (selector.dir != null) r = r.parallelTo(PERP_PLANE[selector.dir]);
+    if (selector.inPlane != null) r = r.inPlane(selector.inPlane, selector.at);
+    if (selector.near != null) r = r.containsPoint(selector.near);
+    return r;
+  };
+}

package/src/framework/geometry/kernel.js

@@ -6,6 +6,9 @@
  * @property {(tool: Solid) => Solid} cut
  * @property {(tools: Solid[]) => Solid} cutAll      batch subtract (backend-optimized)
  * @property {(other: Solid) => Solid} intersect     boolean intersection (Manifold)
+ * @property {() => Solid} clone   independent copy (replicad consumes solids on transform)
+ * @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
  * @property {(plane: "XY"|"XZ"|"YZ") => Solid} mirror
@@ -16,8 +19,10 @@
  *
  * @typedef {Object} GeometryKernel
  * @property {(rBottom:number, rTop:number, h:number, opts?:{center?:boolean}) => Solid} cylinder
+ * @property {(r:number) => Solid} sphere   sphere centred at the origin
  * @property {(min:number[], max:number[]) => Solid} box
  * @property {(points2D:number[][], h:number) => Solid} prism   extrude polygon from z=0
+ * @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

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

@@ -1,4 +1,5 @@
 import { helixTube } from "./helix-tube.js";
+import { KernelCapabilityError } from "./errors.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
@@ -52,7 +53,19 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     cut: (t) => wrap(T(m.subtract(t._m))),
     cutAll: (tools) => wrap(T(m.subtract(unionRaw(tools.map((t) => t._m))))),
     intersect: (t) => wrap(T(m.intersect(t._m))),
+    clone: () => wrap(m),
+    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]],
+      };
+    },
     volume: () => m.volume(),
+    genus: () => m.genus(),
+    isEmpty: () => m.isEmpty(),
     translate: (v) => wrap(T(m.translate(v))),
     rotate: (deg, center, axis) => {
       const euler = [axis[0] * deg, axis[1] * deg, axis[2] * deg];
@@ -64,10 +77,14 @@ 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 {
     cylinder: (rb, rt, h, { center = false } = {}) => wrap(T(Manifold.cylinder(h, rb, rt, segs, center))),
+    sphere: (r) => wrap(T(Manifold.sphere(r, segs))),
     box: (min, max) => {
       const cube = T(Manifold.cube([max[0] - min[0], max[1] - min[1], max[2] - min[2]]));
       return wrap(T(cube.translate(min)));
@@ -77,6 +94,10 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       return wrap(T(cs.extrude(h)));
     },
     helixSweptTube: (o) => wrap(T(helixTube(wasm, { ...o, ...tube }))),
+    revolve: (pts, { degrees = 360 } = {}) => {
+      for (const [r] of pts) if (r < 0) throw new Error("revolve: profile radius must be ≥ 0");
+      return wrap(T(Manifold.revolve([pts], segs, degrees)));
+    },
     union: (solids) => wrap(unionRaw(solids.map((s) => s._m))), // unionRaw already tracks its result
     toSTEP: () => { throw new Error("STEP export not supported by the Manifold backend"); },
     // Free every WASM object created since the last cleanup. Call after each job

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

@@ -1,16 +1,95 @@
 // OCCT backend via replicad. Same GeometryKernel shape as the Manifold backend,
 // and the only backend with toSTEP(). This is where today's drum.js kernel calls
 // (makeCylinder, makeHelix+genericSweep, draw/extrude, cut/fuse) now live.
+import { toEdgeFinder } from "./edge-selector.js";
+import { toFaceFinder } from "./face-selector.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 } = replicad;
+          makeCompound, loft, draw, exportSTEP, measureVolume, makeSphere } = 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;
+  };
+
+  // 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;
+  };
 
   const wrap = (shape) => ({
     _s: shape,
     cut: (t) => wrap(shape.cut(t._s)),
     cutAll: (tools) => wrap(shape.cut(makeCompound(tools.map((t) => t._s)))),
+    clone: () => wrap(shape.clone()),
+    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)),
@@ -24,6 +103,18 @@ export function createOcctKernel(replicad) {
       };
     },
     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)),
+    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})`));
+    },
+    volume: () => measureVolume(shape),
+    toIndexedMesh: () => {
+      const m = shape.mesh(MESH.preview);
+      return { positions: Float32Array.from(m.vertices), indices: Uint32Array.from(m.triangles) };
+    },
   });
 
   // cylinder OR frustum (loft of two circles) when rb !== rt
@@ -42,6 +133,15 @@ export function createOcctKernel(replicad) {
     return wrap(pen.close().sketchOnPlane("XY").extrude(h));
   };
 
+  // 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 }));
+  };
+
   // circle profile swept along a helix (frenet)
   const helixSweptTube = ({ pathR, profileR, pitch, turns, z0, lefthand }) => {
     const spine = makeHelix(pitch, pitch * turns, pathR, [0, 0, z0], [0, 0, 1], lefthand);
@@ -52,7 +152,8 @@ export function createOcctKernel(replicad) {
   };
 
   return {
-    cylinder, box: (min, max) => wrap(makeBox(min, max)), prism, helixSweptTube,
+    cylinder, box: (min, max) => wrap(makeBox(min, max)), prism, revolve, helixSweptTube,
+    sphere: (r) => wrap(makeSphere(r)),
     union: (solids) => wrap(solids.map((s) => s._s).reduce((a, b) => a.fuse(b))),
     toSTEP: (named) => exportSTEP(named.map(({ name, solid }) => ({ name, shape: solid._s }))).arrayBuffer(),
   };

package/src/framework/geometry/polygon.js

@@ -21,3 +21,106 @@ export function hexPolygon(r) {
   }
   return pts;
 }
+
+// Rectangle w×h centred at the origin with radius-r corners (r clamped to min(w,h)/2).
+export function roundedRectPolygon(w, h, r, segs = 8) {
+  r = Math.min(r, Math.min(w, h) / 2);
+  const hw = w / 2, hh = h / 2;
+  if (r <= 0) return [[hw, -hh], [hw, hh], [-hw, hh], [-hw, -hh]];
+  const corners = [
+    [hw - r, hh - r, 0],                 // top-right
+    [-(hw - r), hh - r, Math.PI / 2],    // top-left
+    [-(hw - r), -(hh - r), Math.PI],     // bottom-left
+    [hw - r, -(hh - r), (3 * Math.PI) / 2], // bottom-right
+  ];
+  const pts = [];
+  for (const [cx, cy, a0] of corners)
+    for (let i = 0; i <= segs; i++) {
+      const a = a0 + (Math.PI / 2) * (i / segs);
+      pts.push([cx + r * Math.cos(a), cy + r * Math.sin(a)]);
+    }
+  return pts;
+}
+
+// Regular n-gon, circumradius r. Vertex up by default; flat:true puts a flat edge up.
+export function regularPolygon(n, r, { flat = false } = {}) {
+  const base = Math.PI / 2 + (flat ? Math.PI / n : 0);
+  const pts = [];
+  for (let i = 0; i < n; i++) {
+    const a = base + (2 * Math.PI * i) / n;
+    pts.push([r * Math.cos(a), r * Math.sin(a)]);
+  }
+  return pts;
+}
+
+// Ellipse with semi-axes rx, ry.
+export function ellipsePolygon(rx, ry, segs = 48) {
+  const pts = [];
+  for (let i = 0; i < segs; i++) {
+    const a = (2 * Math.PI * i) / segs;
+    pts.push([rx * Math.cos(a), ry * Math.sin(a)]);
+  }
+  return pts;
+}
+
+// Stadium/obround slot: two r-radius semicircles whose centres are `length` apart
+// (overall length = length + 2r), centred at the origin, long axis along X.
+export function slotPolygon(length, r, segs = 16) {
+  const hl = length / 2;
+  const pts = [];
+  for (let i = 0; i <= segs; i++) { const a = -Math.PI / 2 + Math.PI * (i / segs); pts.push([hl + r * Math.cos(a), r * Math.sin(a)]); }
+  for (let i = 0; i <= segs; i++) { const a = Math.PI / 2 + Math.PI * (i / segs); pts.push([-hl + r * Math.cos(a), r * Math.sin(a)]); }
+  return pts;
+}
+
+// Star with `points` tips, alternating outer/inner radius. First tip points up.
+export function starPolygon(points, outerR, innerR) {
+  const pts = [];
+  for (let i = 0; i < points * 2; i++) {
+    const a = Math.PI / 2 + (Math.PI * i) / points;
+    const rr = i % 2 === 0 ? outerR : innerR;
+    pts.push([rr * Math.cos(a), rr * Math.sin(a)]);
+  }
+  return pts;
+}
+
+// Annular sector as a single closed contour (outer arc, then inner arc back).
+// arcDeg must be < 360 — a full annulus is a contour-with-hole; cut an inner
+// cylinder from an outer one for a full ring.
+export function ringSectorPolygon(innerR, outerR, arcDeg, segs = 32) {
+  if (arcDeg >= 360) throw new Error("ringSectorPolygon: arcDeg must be < 360 (use a cut for a full ring)");
+  const a = (arcDeg * Math.PI) / 180;
+  const steps = Math.max(2, Math.ceil((segs * arcDeg) / 360));
+  const pts = [];
+  for (let i = 0; i <= steps; i++) { const t = (a * i) / steps; pts.push([outerR * Math.cos(t), outerR * Math.sin(t)]); }
+  for (let i = steps; i >= 0; i--) { const t = (a * i) / steps; pts.push([innerR * Math.cos(t), innerR * Math.sin(t)]); }
+  return pts;
+}
+
+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.
+// Returns a Solid[] — feed to k.union(...) (features) or s.cutAll(...) (holes).
+export function linearPattern(solid, count, step) {
+  const out = [];
+  for (let i = 0; i < count; i++)
+    out.push(solid.clone().translate([step[0] * i, step[1] * i, step[2] * i]));
+  return out;
+}
+
+// `count` copies spaced angle/count degrees apart around `axis` through `center`.
+// rotateCopies:true re-orients each copy to face along the circle; false places it
+// at the orbital position with its original orientation (for radially symmetric tools).
+export function circularPattern(solid, count, { center = [0, 0, 0], axis = "Z", angle = 360, rotateCopies = true } = {}) {
+  const ax = Array.isArray(axis) ? axis : PATTERN_AXIS[axis];
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const deg = (angle / count) * i;
+    const placed = solid.clone().rotate(deg, center, ax);
+    if (rotateCopies) { out.push(placed); continue; }
+    // cancel the orientation change by counter-rotating about the copy's own centre
+    const c = placed.boundingBox().center;
+    out.push(placed.rotate(-deg, c, ax));
+  }
+  return out;
+}

package/src/framework/geometry/probe.js

@@ -0,0 +1,50 @@
+// 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"]);
+
+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; },
+    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) }; },
+  };
+  const kernel = {
+    cylinder() { note("cylinder"); 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() {},
+  };
+  return { kernel, used };
+}
+
+export function detectBackend(part, params = {}) {
+  if (part.meta?.backend) return part.meta.backend;
+  const p = { ...part.defaults, ...params };
+  const d = part.derive ? part.derive(p) : {};
+  const { kernel, used } = createProbeKernel();
+  for (const name of Object.keys(part.parts)) {
+    try { part.parts[name].build(kernel, p, d); } catch { /* probe miss → capability backstop covers it */ }
+  }
+  for (const op of used) if (OCCT_ONLY.has(op)) return "occt";
+  return "manifold";
+}

package/src/framework/geometry-service.js

@@ -5,16 +5,14 @@
 // `new Worker(new URL("./part-worker.js", import.meta.url), { type:"module", name })`
 // pattern INLINE — Vite only bundles a worker (and its backend chunks) when it sees
 // that literal call, so the framework can't construct it from a passed-in URL.
-export function createGeometryService({ createWorker, onMessage, occtPreview = false }) {
-  const preview = createWorker("manifold"); // preview meshes + STL
-  const exporter = createWorker("occt");    // STEP (and preview when occtPreview)
-  preview.onmessage = onMessage;
-  exporter.onmessage = onMessage;
-  const genWorker = occtPreview ? exporter : preview;
+export function createGeometryService({ createWorker, onMessage }) {
+  const workers = { manifold: createWorker("manifold"), occt: createWorker("occt") };
+  workers.manifold.onmessage = onMessage;
+  workers.occt.onmessage = onMessage;
   return {
-    generate: (msg) => genWorker.postMessage(msg),
-    exportStl: (msg) => preview.postMessage(msg),
-    export3mf: (msg) => preview.postMessage(msg), // mesh export → Manifold worker
-    exportStep: (msg) => exporter.postMessage(msg),
+    generate: (msg, backend = "manifold") => workers[backend].postMessage(msg),
+    exportStl: (msg, backend = "manifold") => workers[backend].postMessage(msg),
+    export3mf: (msg, backend = "manifold") => workers[backend].postMessage(msg),
+    exportStep: (msg) => workers.occt.postMessage(msg), // STEP is always OCCT
   };
 }

package/src/framework/jobs.js

@@ -11,6 +11,14 @@ export function viewSubParts(part, view, params) {
   });
 }
 
+// Sub-parts to include in an EXPORT of this view: the visible sub-parts, minus any
+// flagged `exportable: false` (reference/preview-only parts — motor ghosts, bearing
+// placeholders, etc.). They still show in the viewer; they're just never written to
+// an STL/STEP/3MF file, so the user never has to toggle them off before exporting.
+export function exportSubParts(part, view, params) {
+  return viewSubParts(part, view, params).filter((name) => part.parts[name].exportable !== false);
+}
+
 // Handle one geometry job, posting results/progress via `post`. Backend-agnostic
 // and part-agnostic: every part specific comes through `part`.
 //   { type:"generate", subparts, view, params } → { type:"meshes", meshes, ms }
@@ -43,13 +51,13 @@ export async function handle(kernel, part, msg, post) {
       post({ type: "meshes", meshes, ms: Date.now() - t0 });
     } else if (msg.type === "export-stl") {
       const out = [];
-      for (const name of viewSubParts(part, msg.view, p)) {
+      for (const name of exportSubParts(part, msg.view, p)) {
         onProgress(`building ${label(name)}`);
         out.push({ name: exportName(name), data: await buildPosed(name, "export", msg.view, onProgress).toSTL({ quality: "print" }) });
       }
       post({ type: "download-parts", ext: "stl", mime: "model/stl", parts: out });
     } else if (msg.type === "export-step") {
-      const solids = viewSubParts(part, msg.view, p).map((name) => {
+      const solids = exportSubParts(part, msg.view, p).map((name) => {
         onProgress(`building ${label(name)}`);
         return { name: exportName(name), solid: buildPosed(name, "export", msg.view, onProgress) };
       });
@@ -57,7 +65,7 @@ export async function handle(kernel, part, msg, post) {
       const data = await kernel.toSTEP(solids);
       post({ type: "download", data, filename: `${msg.view}.step`, mime: "application/step" });
     } else if (msg.type === "export-3mf") {
-      const meshes = viewSubParts(part, msg.view, p).map((name) => {
+      const meshes = exportSubParts(part, msg.view, p).map((name) => {
         onProgress(`building ${label(name)}`);
         const { positions, indices } = buildPosed(name, "export", msg.view, onProgress).toIndexedMesh();
         return { name: exportName(name), positions, indices };
@@ -66,7 +74,8 @@ export async function handle(kernel, part, msg, post) {
       post({ type: "download", data: meshTo3MF(meshes), filename: `${msg.view}.3mf`, mime: "model/3mf" });
     }
   } catch (err) {
-    post({ type: "error", message: String(err?.message || err) });
+    if (err?.code === "NEEDS_OCCT") post({ type: "needs-occt" });
+    else post({ type: "error", message: String(err?.message || err) });
   } finally {
     kernel.cleanup?.();
   }

package/src/framework/markdown.js

@@ -0,0 +1,41 @@
+// Render a (trusted, author-authored) Markdown description to sanitized HTML for
+// display in a control/section info popover. Main-thread only — it imports a DOM
+// sanitizer, so it must NOT be imported from the geometry worker.
+import { marked } from "marked";
+import createDOMPurify from "dompurify";
+
+const CONFIG = {
+  ALLOWED_TAGS: ["a", "img", "p", "br", "strong", "em", "code", "pre", "blockquote",
+    "ul", "ol", "li", "h1", "h2", "h3", "h4", "table", "thead", "tbody", "tr", "th", "td", "hr", "del"],
+  ALLOWED_ATTR: ["href", "src", "alt", "title", "target", "rel"],
+  // links: http(s)/mailto; images: https or data:image/. (Union applied to all URI attrs.)
+  ALLOWED_URI_REGEXP: /^(?:https?:|mailto:|data:image\/)/i,
+  FORBID_ATTR: ["style"],
+};
+
+// DOMPurify is initialized lazily so that window is available at call time.
+// Eager module-level init runs before happy-dom has finished setting up its
+// global window, causing DOMPurify.isSupported to be false.
+let _purify = null;
+function getPurify() {
+  if (_purify) return _purify;
+  // Pass window explicitly: works in a real browser and in the happy-dom
+  // per-file test environment (where window is global but may not be set yet
+  // at module-evaluation time).
+  _purify = createDOMPurify(window);
+  // Links open in a new tab and cannot reach window.opener.
+  _purify.addHook("afterSanitizeAttributes", (node) => {
+    if (node.tagName === "A" && node.getAttribute("href")) {
+      node.setAttribute("target", "_blank");
+      node.setAttribute("rel", "noopener noreferrer");
+    }
+  });
+  return _purify;
+}
+
+// src: a CommonMark string. Returns sanitized HTML. Empty/blank/non-string → "".
+export function renderMarkdown(src) {
+  if (typeof src !== "string" || !src.trim()) return "";
+  const raw = marked.parse(src, { async: false });
+  return getPurify().sanitize(raw, CONFIG);
+}