partforge 0.6.0 → 0.7.0

package/src/framework/app.css

@@ -8,14 +8,15 @@
   --bg: #15181d; --surface: #1f242c; --surface-2: #20262e; --border: #2c333d;
   --text: #d6dbe2; --text-strong: #e7ebf1; --text-2: #cdd4dd;
   --muted: #7d8794; --muted-2: #aab2bd; --status: #8b94a0; --hint: #6b7480;
-  --accent: #3b82f6; --on-accent: #fff; --input-bg: #161a20; --err: #f8746c;
+  --accent: #3f7bf0; --accent-soft: #26314a; --on-accent: #fff; --input-bg: #161a20; --err: #f8746c;
+  --mono: ui-monospace, "SF Mono", SFMono-Regular, "JetBrains Mono", "Cascadia Code", Menlo, Consolas, monospace;
 }
 :root[data-theme="light"] {
   color-scheme: light;
   --bg: #eef1f5; --surface: #ffffff; --surface-2: #f4f6f9; --border: #d4dae2;
   --text: #2b333d; --text-strong: #1a2129; --text-2: #3a434e;
   --muted: #6b7480; --muted-2: #59636f; --status: #6b7480; --hint: #8a93a0;
-  --accent: #3b82f6; --on-accent: #fff; --input-bg: #ffffff; --err: #d8453d;
+  --accent: #1f5bd6; --accent-soft: #e6edfc; --on-accent: #fff; --input-bg: #ffffff; --err: #d8453d;
 }
 * { box-sizing: border-box; }
 html, body { margin: 0; height: 100%; overflow: hidden;
@@ -24,59 +25,86 @@ html, body { margin: 0; height: 100%; overflow: hidden;
 canvas { display: block; }
 
 #panel {
-  position: fixed; top: 12px; left: 12px; width: 252px;
+  position: fixed; top: 12px; left: 12px; width: 256px;
   max-height: calc(100vh - 24px); overflow-y: auto; z-index: 10;
   background: var(--surface); border: 1px solid var(--border); border-radius: 10px;
   padding: 14px; color: var(--text); box-shadow: 0 6px 24px rgba(0,0,0,.35);
 }
-#panel h1 { font-size: 14px; margin: 0 0 2px; }
-#panel .sub { color: var(--muted); font-size: 11px; margin: 0 0 12px; }
+#panel h1 { font-size: 14px; margin: 0 0 2px; color: var(--text-strong); letter-spacing: -0.01em; }
+#panel .sub {
+  font-family: var(--mono); color: var(--muted); font-size: 10px;
+  letter-spacing: 0.04em; text-transform: uppercase;
+  margin: 0 0 12px; padding-bottom: 12px; border-bottom: 1px solid var(--border);
+}
 
 .seg { display: flex; gap: 4px; margin-bottom: 12px; }
 .seg button {
   flex: 1; padding: 7px 0; border: 1px solid var(--border); border-radius: 7px;
-  background: var(--surface-2); color: var(--muted-2); cursor: pointer; font-size: 12px;
+  background: var(--surface-2); color: var(--muted-2); cursor: pointer;
+  font-family: var(--mono); font-size: 11px; letter-spacing: 0.02em;
 }
 .seg button.on { background: var(--accent); color: var(--on-accent); border-color: var(--accent); }
 
 .section {
-  border: 1px solid var(--border); border-radius: 8px; padding: 9px 10px;
+  border: 1px solid var(--border); border-radius: 8px; padding: 10px;
   margin-bottom: 8px; background: var(--surface-2);
 }
-.sec-title { font-weight: 600; color: var(--text-strong); margin-bottom: 7px; }
+.sec-title {
+  font-family: var(--mono); font-size: 10px; font-weight: 600;
+  letter-spacing: 0.14em; text-transform: uppercase; color: var(--muted-2); margin-bottom: 9px;
+}
 select.preset {
   width: 100%; background: var(--input-bg); color: var(--text-2);
-  border: 1px solid var(--border); border-radius: 6px; padding: 5px 7px; font-size: 11px;
+  border: 1px solid var(--border); border-radius: 6px; padding: 6px 8px;
+  font-family: var(--mono); font-size: 11px;
 }
 .feat { display: flex; align-items: center; gap: 8px; margin: 6px 0;
   color: var(--text-2); cursor: pointer; }
-.feat input { cursor: pointer; }
-.feat-group { margin: 2px 0 8px; padding-left: 9px; border-left: 2px solid var(--border); }
+.feat input { cursor: pointer; accent-color: var(--accent); }
+.feat-group { margin: 2px 0 8px; padding-left: 10px; border-left: 2px solid var(--border); }
 .feat-group.hidden { display: none; }
 .adv-toggle {
-  margin-top: 8px; padding: 3px 0; width: 100%; border: 0; border-radius: 5px;
-  background: transparent; color: var(--muted); cursor: pointer; font-size: 11px;
-  text-align: left;
+  margin-top: 8px; padding: 4px 0; width: 100%; border: 0; border-radius: 5px;
+  background: transparent; color: var(--muted); cursor: pointer;
+  font-family: var(--mono); font-size: 10px; letter-spacing: 0.08em; text-transform: uppercase; text-align: left;
 }
 .adv-toggle:hover { color: var(--muted-2); }
 .adv.hidden { display: none; }
 .adv { margin-top: 4px; }
 
-.slider { margin: 7px 0; }
+.slider { margin: 9px 0; }
 .row { display: flex; justify-content: space-between; align-items: center;
-  margin: 0 0 3px; gap: 8px; }
-.row label { color: var(--muted-2); }
+  margin: 0 0 4px; gap: 8px; }
+.row label { font-family: var(--mono); font-size: 11px; color: var(--muted-2); letter-spacing: 0.01em; }
 .row .val { display: flex; align-items: baseline; gap: 4px; flex: none; }
 .row .num {
-  width: 52px; text-align: right; font: inherit; font-variant-numeric: tabular-nums;
+  width: 54px; text-align: right; font-family: var(--mono); font-size: 12px; font-variant-numeric: tabular-nums;
   background: var(--input-bg); color: var(--text-strong);
-  border: 1px solid var(--border); border-radius: 5px; padding: 2px 5px;
+  border: 1px solid var(--border); border-radius: 5px; padding: 3px 6px;
 }
-.row .num:focus { outline: none; border-color: var(--accent); }
+.row .num:focus { outline: none; border-color: var(--accent); box-shadow: 0 0 0 3px var(--accent-soft); }
 .row .num::-webkit-outer-spin-button, .row .num::-webkit-inner-spin-button { -webkit-appearance: none; margin: 0; }
 .row .num { -moz-appearance: textfield; }
-.row .unit { color: var(--muted); font-size: 11px; }
-input[type="range"] { width: 100%; }
+.row .unit { font-family: var(--mono); color: var(--muted); font-size: 10px; }
+
+/* crafted range slider — hairline track + CAD-blue handle (the panel's signature control) */
+input[type="range"] { -webkit-appearance: none; appearance: none; width: 100%; height: 18px; margin: 0; background: transparent; cursor: pointer; }
+input[type="range"]::-webkit-slider-runnable-track { height: 3px; border-radius: 2px; background: var(--border); }
+input[type="range"]::-moz-range-track { height: 3px; border-radius: 2px; background: var(--border); }
+input[type="range"]::-moz-range-progress { height: 3px; border-radius: 2px; background: var(--accent); }
+input[type="range"]::-webkit-slider-thumb {
+  -webkit-appearance: none; appearance: none; width: 14px; height: 14px; margin-top: -5.5px;
+  border-radius: 50%; background: var(--accent); border: 2px solid var(--surface-2); box-shadow: 0 0 0 1px var(--accent);
+  transition: box-shadow .12s ease;
+}
+input[type="range"]::-moz-range-thumb {
+  width: 14px; height: 14px; border-radius: 50%; background: var(--accent);
+  border: 2px solid var(--surface-2); box-shadow: 0 0 0 1px var(--accent);
+}
+input[type="range"]:hover::-webkit-slider-thumb { box-shadow: 0 0 0 5px var(--accent-soft); }
+input[type="range"]:focus-visible { outline: none; }
+input[type="range"]:focus-visible::-webkit-slider-thumb { box-shadow: 0 0 0 5px var(--accent-soft); }
+input[type="range"]:focus-visible::-moz-range-thumb { box-shadow: 0 0 0 5px var(--accent-soft); }
 
 button.action {
   width: 100%; margin-top: 8px; padding: 9px; border: 0; border-radius: 7px;
@@ -85,19 +113,29 @@ button.action {
 button.ghost { background: var(--border); color: var(--text-2); font-weight: 500; }
 button.action:disabled { opacity: .5; cursor: default; }
 
-.dl { margin-top: 12px; }
-.dl-head { font-weight: 600; color: var(--text-strong); margin-bottom: 6px; }
+.dl { margin-top: 14px; }
+.dl-head {
+  font-family: var(--mono); font-size: 10px; font-weight: 600;
+  letter-spacing: 0.14em; text-transform: uppercase; color: var(--muted-2); margin-bottom: 7px;
+}
 .dl-row { display: flex; gap: 6px; }
 .dl-row button {
   flex: 1; padding: 8px 0; border: 1px solid var(--border); border-radius: 7px;
-  background: var(--surface-2); color: var(--text-2); font-weight: 600;
-  font-size: 12px; cursor: pointer;
+  background: var(--surface-2); color: var(--text-2);
+  font-family: var(--mono); font-weight: 600; font-size: 11px; letter-spacing: 0.06em; cursor: pointer;
 }
 .dl-row button:hover:not(:disabled) { border-color: var(--accent); color: var(--text-strong); }
 .dl-row button:disabled { opacity: .45; cursor: default; }
-#status { margin-top: 10px; min-height: 16px; color: var(--status); font-size: 11px; }
+#status { font-family: var(--mono); margin-top: 12px; min-height: 16px; color: var(--status);
+  font-size: 11px; font-variant-numeric: tabular-nums; }
 #status.err { color: var(--err); }
-.hint { margin-top: 8px; color: var(--hint); font-size: 10px; }
+.hint { font-family: var(--mono); margin-top: 8px; color: var(--hint); font-size: 10px; letter-spacing: 0.02em; }
+
+/* keyboard focus ring shared across the panel's interactive controls */
+.seg button:focus-visible, select.preset:focus-visible, .dl-row button:focus-visible,
+button.action:focus-visible, .adv-toggle:focus-visible, #viewbar button:focus-visible {
+  outline: 2px solid var(--accent); outline-offset: 2px;
+}
 
 /* part tabs, floated top-centre over the viewport */
 #topbar {
@@ -156,6 +194,7 @@ button.action:disabled { opacity: .5; cursor: default; }
 }
 .popover[hidden] { display: none; }
 .popover img { max-width: 100%; height: auto; border-radius: 4px; }
+.popover code { font-family: var(--mono); background: var(--surface-2); padding: 0.05em 0.35em; border-radius: 4px; font-size: 0.9em; }
 .popover a { color: var(--accent); }
 .popover p:first-child { margin-top: 0; }
 .popover p:last-child { margin-bottom: 0; }
@@ -165,6 +204,18 @@ button.action:disabled { opacity: .5; cursor: default; }
 .irrelevant:hover { opacity: 0.7; }
 .section-hidden { display: none; }
 
+/* hover feature-label tooltip (selection/hover.js) */
+#pf-hover-tip {
+  position: fixed; z-index: 30; pointer-events: none; display: none;
+  padding: 4px 9px; border-radius: 6px; max-width: 260px;
+  background: var(--surface); border: 1px solid var(--border);
+  color: var(--text-strong); font-size: 12px; line-height: 1.35;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, .25);
+}
+#pf-hover-tip.show { display: block; }
+#pf-hover-tip .pf-hover-sub { color: var(--muted); font-size: 11px; margin-left: 7px; }
+#pf-hover-tip .pf-hover-sub:empty { display: none; }
+
 /* request-a-pick: agent prompt banner, floated top-centre well below the part tabs,
    laid out like a chat message (avatar + text). Slides/fades in when shown; themed. */
 #pf-pick-banner {
@@ -198,4 +249,18 @@ button.action:disabled { opacity: .5; cursor: default; }
 @keyframes pf-pick-in {
   from { opacity: 0; transform: translateX(-50%) translateY(-10px); }
   to   { opacity: 1; transform: translateX(-50%) translateY(0); }
-}
+}
+
+/* ?pick clipboard mode: a bottom-left toggle button + a transient token toast. */
+#pf-pick {
+  position: fixed; left: 12px; bottom: 12px; z-index: 9999;
+  font: 12px system-ui, sans-serif; padding: 6px 10px; cursor: pointer;
+}
+#pf-pick.on { outline: 2px solid #ffcc33; }
+#pf-pick-toast {
+  position: fixed; left: 12px; bottom: 48px; z-index: 9999; max-width: 60ch;
+  font: 12px ui-monospace, monospace; padding: 6px 10px; border-radius: 4px;
+  background: rgba(20,24,29,0.92); color: #d8e0ea;
+  white-space: pre-wrap; word-break: break-word; display: none;
+}
+#pf-pick-toast.show { display: block; }

package/src/framework/assembly.js

@@ -1,4 +1,4 @@
-import { viewSubParts } from "./jobs.js";
+import { viewSubParts, resolveParams, buildPosed } from "./jobs.js";
 
 // Collision check for an assembled view: build each sub-part in its display
 // (assembly) pose and return the pairs whose solid-intersection volume exceeds
@@ -8,14 +8,11 @@ import { viewSubParts } from "./jobs.js";
 // part tests so an author/LLM editing a part sees collisions fail.
 //   → [{ a, b, volume }] for each offending pair (empty = no collisions)
 export function assemblyOverlaps(kernel, part, view, params = {}, { tolerance = 1 } = {}) {
-  const p = { ...part.defaults, ...params };
-  const d = part.derive ? part.derive(p) : {};
-  const posed = viewSubParts(part, view, p).map((name) => {
-    const sp = part.parts[name];
-    let solid = sp.build(kernel, p, d);
-    if (sp.place) solid = sp.place(solid, { view, purpose: "display", p, d });
-    return { name, solid };
-  });
+  const { p, d } = resolveParams(part, params);
+  const posed = viewSubParts(part, view, p).map((name) => ({
+    name,
+    solid: buildPosed(kernel, part, name, { purpose: "display", view, p, d }),
+  }));
 
   const overlaps = [];
   for (let i = 0; i < posed.length; i++) {

package/src/framework/download.js

@@ -0,0 +1,23 @@
+import { zipSync } from "fflate";
+
+// Browser file-download helpers. Pure DOM/Blob utilities with no app state — the
+// worker produces the bytes; these just hand them to the browser as a download.
+
+// Trigger a download of one binary blob under `filename`.
+export function triggerDownload(data, filename, mime) {
+  const url = URL.createObjectURL(new Blob([data], { type: mime }));
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+// Download a set of built parts: a single part downloads directly; multiple parts
+// are bundled into one flat, store-only (level 0) zip named `zipName`.
+export function downloadParts({ parts, ext, mime }, zipName) {
+  if (parts.length === 1) return triggerDownload(parts[0].data, `${parts[0].name}.${ext}`, mime);
+  const entries = {};
+  for (const p of parts) entries[`${p.name}.${ext}`] = new Uint8Array(p.data);
+  triggerDownload(zipSync(entries, { level: 0 }), zipName, "application/zip");
+}

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/kernel-front.js

@@ -0,0 +1,31 @@
+// 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 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", "revolve",
+  "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
@@ -34,6 +73,10 @@
  * @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/manifold-backend.js

@@ -1,8 +1,8 @@
 import { helixTube } from "./helix-tube.js";
-import { KernelCapabilityError } from "./errors.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 +38,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 +50,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 +80,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 +111,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 +119,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,20 +140,17 @@ 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]));
         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));
+        // 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]));
       }),
     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(),
@@ -155,7 +158,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
@@ -164,7 +167,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;
 
@@ -243,7 +246,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) {