partforge 0.1.0 → 0.4.0

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

@@ -1,19 +1,102 @@
 // 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)),
+    scale: (factor, center = [0, 0, 0]) => {
+      if (!(factor > 0)) throw new Error("scale: factor must be > 0");
+      return wrap(shape.scale(factor, center));
+    },
     toMesh: ({ quality = "preview" } = {}) => {
       const m = shape.mesh(MESH[quality]);
       return {
@@ -24,6 +107,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
@@ -36,10 +131,25 @@ export function createOcctKernel(replicad) {
   };
 
   // extrude a 2-D polygon from z=0
-  const prism = (pts, h) => {
+  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");
+    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));
+  };
+
+  // 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]);
-    return wrap(pen.close().sketchOnPlane("XY").extrude(h));
+    const sketch = pen.close().sketchOnPlane("XZ");
+    return wrap(sketch.revolve([0, 0, 1], { angle: degrees }));
   };
 
   // circle profile swept along a helix (frenet)
@@ -52,7 +162,11 @@ export function createOcctKernel(replicad) {
   };
 
   return {
-    cylinder, box: (min, max) => wrap(makeBox(min, max)), prism, helixSweptTube,
+    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,
+    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,120 @@ 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;
+}
+
+// CCW circle of radius r centered at [cx, cy]. A shared 2-D profile primitive:
+// compose with the kernel's profile ops — e.g. revolve(circleProfile(minorR,
+// [majorR, 0])) is a torus, prism(circleProfile(r), h) a cylinder.
+export function circleProfile(r, center = [0, 0], segs = 48) {
+  if (!(r > 0)) throw new Error("circleProfile: r must be > 0");
+  const [cx, cy] = center;
+  const pts = [];
+  for (let i = 0; i < segs; i++) {
+    const a = (2 * Math.PI * i) / segs;
+    pts.push([cx + r * Math.cos(a), cy + r * Math.sin(a)]);
+  }
+  return pts;
+}

package/src/framework/geometry/probe.js

@@ -0,0 +1,52 @@
+// 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; },
+    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) }; },
+  };
+  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() {},
+  };
+  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/solid-cache.js

@@ -0,0 +1,39 @@
+// Worker-side cache of boundary-op solids, partitioned per sub-part. Retention is
+// bounded to the CURRENT build's graph: each begin()/end() bracket rebuilds a
+// sub-part's retained set from scratch, disposing any entry not re-used this round.
+// WASM-agnostic — it stores opaque {value, pin, dispose} triples supplied by the
+// caller (the Manifold backend), so it is unit-testable with plain objects.
+export function createSolidCache() {
+  const caches = new Map(); // name -> Map(hash -> { value, pin, dispose })
+  const pinned = new Set();  // every live `pin` across all sub-parts
+  let name = null, active = null, prev = null;
+  let hits = 0, misses = 0;
+
+  return {
+    begin(n) { name = n; prev = caches.get(n) ?? new Map(); active = new Map(); },
+
+    end() {
+      if (name == null) return;
+      for (const [hash, entry] of prev) {
+        if (!active.has(hash)) { pinned.delete(entry.pin); entry.dispose(); } // evict
+      }
+      caches.set(name, active);
+      name = null; active = prev = null;
+    },
+
+    lookup(hash, make) {
+      if (name == null) return make().value; // not bracketed → no caching
+      if (active.has(hash)) { hits++; return active.get(hash).value; }
+      if (prev.has(hash)) { hits++; const e = prev.get(hash); active.set(hash, e); return e.value; }
+      misses++;
+      const entry = make();
+      active.set(hash, entry);
+      pinned.add(entry.pin);
+      return entry.value;
+    },
+
+    isPinned: (pin) => pinned.has(pin),
+    stats: () => ({ hits, misses }),
+    resetStats: () => { hits = 0; misses = 0; },
+  };
+}

package/src/framework/geometry/solid-hash.js

@@ -0,0 +1,21 @@
+// Stable content hash for cached solids. Serializes scalar args canonically and
+// folds via FNV-1a → base36. Solid operands are passed as their own (already
+// computed) short `_hash` string, so composing two solids stays O(1) and the
+// resulting key length stays bounded no matter how deep the build graph is.
+export function h(...parts) {
+  return fnv(parts.map(canon).join("|"));
+}
+
+function canon(x) {
+  if (Array.isArray(x)) return "[" + x.map(canon).join(",") + "]";
+  if (x && typeof x === "object") return "{" + Object.keys(x).sort().map((k) => k + ":" + canon(x[k])).join(",") + "}";
+  return String(x);
+}
+
+// FNV-1a folded to 32-bit space (collision risk acceptable: retained only for one
+// sub-part's build graph ~3–15 nodes, rebuilt each round, no accumulation).
+function fnv(s) {
+  let hsh = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) { hsh ^= s.charCodeAt(i); hsh = Math.imul(hsh, 0x01000193); }
+  return (hsh >>> 0).toString(36);
+}

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 }
@@ -34,22 +42,29 @@ export async function handle(kernel, part, msg, post) {
   try {
     if (msg.type === "generate") {
       const t0 = Date.now();
+      const useCache = msg.cache !== false; // ?debug toggle can disable caching (cache:false)
       const meshes = [];
+      kernel.resetCacheStats?.(); // count hits/misses for just this job
       for (const name of msg.subparts) {
-        const m = buildPosed(name, "display", msg.view).toMesh({ quality: "preview" });
-        meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges });
-        kernel.cleanup?.();
+        if (useCache) kernel.beginSubPart?.(name); // open the per-sub-part cache round
+        try {
+          const m = buildPosed(name, "display", msg.view).toMesh({ quality: "preview" });
+          meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges });
+        } finally {
+          if (useCache) kernel.endSubPart?.(); // always close the bracket — a throw mid-build must not strand pinned solids
+          kernel.cleanup?.();                  // free this round's transients (cached/pinned solids survive)
+        }
       }
-      post({ type: "meshes", meshes, ms: Date.now() - t0 });
+      post({ type: "meshes", meshes, ms: Date.now() - t0, cache: kernel.cacheStats?.() });
     } 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 +72,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 +81,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);
+}