partforge 0.6.0 → 0.7.0

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

@@ -4,116 +4,68 @@
 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";
 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;
 
-  // 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
-  };
+  // 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);
 
-  // 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,9 +83,8 @@ export function createOcctKernel(replicad) {
     return wrap(loft([w1, w2]));
   };
 
-  // extrude a 2-D polygon from z=0
+  // 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");
@@ -146,7 +97,6 @@ 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");
@@ -162,13 +112,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])),
+  return finishKernel({
+    cylinder, // boredCylinder: the kernel front's default composition is exactly right here
     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))),
+    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/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/solid-sugar.js

@@ -1,9 +1,16 @@
 // src/framework/geometry/solid-sugar.js
-// Self-describing build-step vocabulary, defined ONCE over both geometry backends.
-// Every Solid a backend's wrap() returns is passed through addSugar(), which attaches
-// readable transform/placement methods composed purely from the solid's existing
-// rotate()/translate() primitives — so the sugar is geometry-identical to the
-// hand-written primitive calls, on Manifold and OCCT alike.
+// The backend-shared Solid front, defined ONCE over both geometry backends. Every
+// Solid a backend's wrap() returns is passed through addSugar(), which:
+//   - attaches the readable transform/placement vocabulary (rotateX/along/at/…),
+//     composed purely from the solid's own rotate()/translate() primitives, so the
+//     sugar is geometry-identical on Manifold and OCCT alike;
+//   - validates arguments the backends would otherwise each check (scale factor);
+//   - derives boundingBox center/size from the backend's raw {min,max};
+//   - stubs any OCCT-only op the backend lacks with a KernelCapabilityError, so
+//     the needs-occt reroute works without hand-written per-backend stubs.
+import { KernelCapabilityError } from "./errors.js";
+import { OCCT_ONLY_OPS } from "./kernel.js";
+
 const ORIGIN = [0, 0, 0];
 const AXIS = { X: [1, 0, 0], Y: [0, 1, 0], Z: [0, 0, 1] };
 
@@ -31,5 +38,25 @@ const SUGAR = {
 };
 
 export function addSugar(s) {
+  const rawScale = s.scale;
+  s.scale = (factor, center = ORIGIN) => {
+    if (!(factor > 0)) throw new Error("scale: factor must be > 0");
+    return rawScale(factor, center);
+  };
+
+  const rawBoundingBox = s.boundingBox;
+  s.boundingBox = () => {
+    const { min, max } = rawBoundingBox();
+    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]],
+    };
+  };
+
+  for (const op of OCCT_ONLY_OPS) {
+    s[op] ??= () => { throw new KernelCapabilityError(`${op} requires the OCCT backend`); };
+  }
+
   return Object.assign(s, SUGAR);
 }

package/src/framework/geometry-service.js

@@ -9,10 +9,8 @@ export function createGeometryService({ createWorker, onMessage }) {
   const workers = { manifold: createWorker("manifold"), occt: createWorker("occt") };
   workers.manifold.onmessage = onMessage;
   workers.occt.onmessage = onMessage;
-  return {
-    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
-  };
+  // Post a job to the chosen backend's worker. The message's own `type` says what to
+  // do (generate / export-stl / export-3mf / export-step); `backend` picks the worker
+  // — manifold for preview/STL/3MF, occt for STEP (the caller passes "occt" for that).
+  return { send: (msg, backend = "manifold") => workers[backend].postMessage(msg) };
 }

package/src/framework/jobs.js

@@ -19,25 +19,44 @@ 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`.
+// Resolve a part's effective params + derived values for a build: the user's params
+// layered over the part defaults, and derive() run once over the result.
+export function resolveParams(part, params) {
+  const p = { ...part.defaults, ...params };
+  const d = part.derive ? part.derive(p) : {};
+  return { p, d };
+}
+
+// Build one sub-part and apply its optional place() for the given purpose/view.
+// `p`/`d` come from resolveParams(). This is the SINGLE definition of "a posed
+// sub-part solid" — the worker, the collision check, and the test harness all call
+// it, so display/export poses can never drift between the app and its tests.
+export function buildPosed(kernel, part, name, { purpose, view, p, d, onProgress } = {}) {
+  const sp = part.parts[name];
+  const solid = sp.build(kernel, p, d, onProgress);
+  return sp.place ? sp.place(solid, { view, purpose, p, d }) : solid;
+}
+
+// Handle one geometry job, posting results/progress via `post(msg, transfer?)`.
+// Backend-agnostic and part-agnostic: every part specific comes through `part`.
 //   { type:"generate", subparts, view, params } → { type:"meshes", meshes, ms }
 //   { type:"export-stl", view, params }         → { type:"download-parts", ext, mime, parts }
 //   { type:"export-step", view, params }        → { type:"download", data, filename, mime }
+// Each result branch declares its own transferables (the big binary buffers,
+// zero-copy across the worker boundary) right where the buffers are created —
+// so a new job type can't silently regress to structured-cloning its payload.
 // Progress is posted as { type:"progress", phase }. Export builds thread the
 // progress callback into build() so a part's own per-feature progress surfaces;
 // preview generates stay quiet (no callback) to avoid flicker during slider drags.
+const bufferOf = (data) => (ArrayBuffer.isView(data) ? data.buffer : data);
+
 export async function handle(kernel, part, msg, post) {
   const onProgress = (phase) => post({ type: "progress", phase });
-  const p = { ...part.defaults, ...msg.params };
-  const d = part.derive ? part.derive(p) : {};
+  const { p, d } = resolveParams(part, msg.params);
   const label = (name) => part.parts[name].label ?? name;
   const exportName = (name) => part.parts[name].export?.name ?? name;
-  const buildPosed = (name, purpose, view, prog) => {
-    const sp = part.parts[name];
-    const solid = sp.build(kernel, p, d, prog);
-    return sp.place ? sp.place(solid, { view, purpose, p, d }) : solid;
-  };
+  // Local shorthand over the shared helper: kernel/part/view/p/d are fixed per job.
+  const posed = (name, purpose, prog) => buildPosed(kernel, part, name, { purpose, view: msg.view, p, d, onProgress: prog });
 
   try {
     if (msg.type === "generate") {
@@ -48,37 +67,40 @@ export async function handle(kernel, part, msg, post) {
       for (const name of msg.subparts) {
         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 });
+          const m = posed(name, "display").toMesh({ quality: "preview" });
+          meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges, featureIds: m.featureIds, features: m.features });
         } 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, cache: kernel.cacheStats?.() });
+      const transfer = meshes.flatMap((m) =>
+        [m.positions.buffer, m.normals?.buffer, m.indices?.buffer, m.edges?.buffer, m.featureIds?.buffer].filter(Boolean));
+      post({ type: "meshes", meshes, ms: Date.now() - t0, cache: kernel.cacheStats?.() }, transfer);
     } else if (msg.type === "export-stl") {
       const out = [];
       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" }) });
+        out.push({ name: exportName(name), data: await posed(name, "export", onProgress).toSTL({ quality: "print" }) });
       }
-      post({ type: "download-parts", ext: "stl", mime: "model/stl", parts: out });
+      post({ type: "download-parts", ext: "stl", mime: "model/stl", parts: out }, out.map((p) => bufferOf(p.data)));
     } else if (msg.type === "export-step") {
       const solids = exportSubParts(part, msg.view, p).map((name) => {
         onProgress(`building ${label(name)}`);
-        return { name: exportName(name), solid: buildPosed(name, "export", msg.view, onProgress) };
+        return { name: exportName(name), solid: posed(name, "export", onProgress) };
       });
       onProgress("writing STEP file");
       const data = await kernel.toSTEP(solids);
-      post({ type: "download", data, filename: `${msg.view}.step`, mime: "application/step" });
+      post({ type: "download", data, filename: `${msg.view}.step`, mime: "application/step" }, [bufferOf(data)]);
     } else if (msg.type === "export-3mf") {
       const meshes = exportSubParts(part, msg.view, p).map((name) => {
         onProgress(`building ${label(name)}`);
-        const { positions, indices } = buildPosed(name, "export", msg.view, onProgress).toIndexedMesh();
+        const { positions, indices } = posed(name, "export", onProgress).toIndexedMesh();
         return { name: exportName(name), positions, indices };
       });
       onProgress("writing 3MF file");
-      post({ type: "download", data: meshTo3MF(meshes), filename: `${msg.view}.3mf`, mime: "model/3mf" });
+      const data = meshTo3MF(meshes);
+      post({ type: "download", data, filename: `${msg.view}.3mf`, mime: "model/3mf" }, [bufferOf(data)]);
     }
   } catch (err) {
     if (err?.code === "NEEDS_OCCT") post({ type: "needs-occt" });

package/src/framework/mesh-cache.js

@@ -0,0 +1,41 @@
+import { subPartReadKeys, relevanceHash, RELEVANT_ALL } from "./param-deps.js";
+
+// Tracks whether each sub-part's cached display mesh is still valid for the current
+// params ("Layer 1" of the cache — skipping regeneration of sub-parts whose inputs
+// didn't change). A sub-part's mesh is stamped with a relevance hash over just the
+// params that sub-part reads; it's current while that hash is unchanged and the mesh
+// is still in the viewer.
+//
+// The view/paramsVersion/caching state lives in mount and changes over time, so it's
+// passed as getters. `params` is a stable object mutated in place, so it's passed by
+// reference.
+export function createMeshCache(part, viewer, { params, getView, getParamsVersion, isCaching }) {
+  const cacheHash = {}; // name -> relevance hash the cached mesh was built at
+
+  // Memoize the per-sub-part read-key map per (paramsVersion, view): subPartReadKeys
+  // runs probe builds, so we compute it once per change, not per sub-part.
+  let readsKey = null, readsMap = null;
+  const readsFor = () => {
+    const key = `${getParamsVersion()}|${getView()}`;
+    if (readsKey !== key) { readsKey = key; readsMap = subPartReadKeys(part, getView(), params); }
+    return readsMap;
+  };
+
+  // The relevance hash for one sub-part at the current params (RELEVANT_ALL → hash
+  // over ALL params, so any edit invalidates it — the safe fallback).
+  const hashFor = (name) => {
+    if (!isCaching()) return `v${getParamsVersion()}`; // caching off: any edit invalidates every sub-part
+    const reads = readsFor();
+    const keys = reads === RELEVANT_ALL ? Object.keys(params) : [...(reads.get(name) ?? Object.keys(params))];
+    return relevanceHash(keys, params);
+  };
+
+  return {
+    // A cached sub-part is current only if its relevance hash is unchanged.
+    isCurrent: (name) => viewer.hasSubMesh(name) && cacheHash[name] === hashFor(name),
+    // Stamp a freshly built mesh with the hash it was built at.
+    record: (name) => { cacheHash[name] = hashFor(name); },
+    // Drop a sub-part's stamp so it rebuilds next generate.
+    forget: (name) => { delete cacheHash[name]; },
+  };
+}