partforge 0.5.2 → 0.6.1

package/README.md

@@ -47,8 +47,11 @@ boots with no errors. Needs Playwright: `npm i -D playwright && npx playwright i
 contract, the geometry kernel API, the parameter schema, app wiring, testing, and
 gotchas. See **Designing the control panel** in that guide for how to write descriptions,
 hide internal params, and keep the interface simple while staying deeply adjustable.
-`src/parts/demo.js` is a minimal worked example; run `npm run dev` and open
-`/demo.html` to see it live.
+`src/parts/demo.js` is a minimal worked example.
+
+**Live showcase:** https://scottsykora.github.io/partforge/ — the landing gallery links
+three live example apps (Faceted Planter, Spacer, Filleted Box), auto-deployed from `main`.
+Locally, `npm run dev` then open `/demo.html`, `/planter.html`, or `/filleted-box.html`.
 
 - **Agent clarification (`request-a-pick`):** an external tool can ask the user to click
   geometry and get the `Selection` back — serve with `?pickserver`, drive with

package/bin/cli.js

@@ -7,6 +7,7 @@ import { createManifoldKernel } from "../src/framework/geometry/manifold-backend
 import { detectBackend } from "../src/framework/geometry/probe.js";
 import { bootOcctKernel } from "../src/testing/occt.js";
 import { measure } from "../src/testing/measure.js";
+import { verify } from "../src/testing/verify.js";
 import { renderViews } from "../src/testing/render.js";
 import { createPickServer, requestPicks, formatPickResult } from "../src/framework/pick-request/server.js";
 
@@ -64,11 +65,19 @@ if (["measure", "render"].includes(cmd)) {
     if (cmd === "measure") {
       const report = measure(kernel, part, view);
       printMeasure(report);
+      let vok = true;
+      const processFlag = typeof flags.process === "string" ? flags.process : undefined;
+      if ((part.verify || processFlag) && !flags["no-verify"]) {
+        const v = verify(kernel, part, { process: processFlag, view });
+        printVerify(v);
+        report.verify = v;
+        vok = v.ok;
+      }
       const file = `measure-${slug(report.part)}-${report.view}.json`;
       writeFileSync(file, JSON.stringify(report, null, 2));
       console.log(`\nwrote ${file}`);
       if (flags.json) console.log(JSON.stringify(report, null, 2));
-      process.exit(report.ok ? 0 : 1);
+      process.exit(report.ok && vok ? 0 : 1);
     } else {
       const views = typeof flags.views === "string" ? flags.views.split(",") : undefined;
       const files = await renderViews(kernel, part, view, { views, out: flags.out || "render" });
@@ -93,3 +102,16 @@ function printMeasure(r) {
   console.log(`  ── view  bbox ${a.bbox.map((n) => n.toFixed(1)).join("×")}  vol ${(a.volume / 1000).toFixed(2)}cm³  tris ${a.triangleCount}`);
   console.log(`  overlaps: ${r.overlaps.length ? r.overlaps.map((o) => `${o.a}×${o.b} (${o.volume.toFixed(1)}mm³)`).join(", ") : "none"}`);
 }
+
+function printVerify(v) {
+  console.log(`\nverify:`);
+  for (const c of v.cases) {
+    console.log(`  ${c.name}`);
+    for (const ch of c.checks) {
+      const icon = ch.status === "pass" ? "✓" : ch.status === "fail" ? "✗" : ch.status === "warn" ? "⚠" : "·";
+      console.log(`    ${icon} ${ch.subpart ?? "_view"} ${ch.metric} ${ch.expr}  (${ch.message})`);
+    }
+  }
+  const f = v.failures.length, w = v.warnings.length;
+  console.log(`  result: ${f ? `${f} gate failure(s)` : "all gates passed"}${w ? `, ${w} warning(s)` : ""}`);
+}

package/docs/AUTHORING-PARTS.md

@@ -106,7 +106,11 @@ entry pulls in the DOM viewer/controls, and your build functions run in a Web Wo
 | `s.cut(tool)` / `s.cutAll(tools[])` | boolean subtract (one / batch) |
 | `s.intersect(other)` | boolean intersection (Manifold; used by collision tests) |
 | `s.translate([x,y,z])` | move |
-| `s.rotate(deg, center, axis)` | rotate `deg` about `axis` through `center` |
+| `s.rotate(deg, center, axis)` | **internal primitive** — prefer `rotateX/Y/Z` / `rotateAbout` |
+| `s.rotateX(deg)` / `s.rotateY(deg)` / `s.rotateZ(deg)` | rotate about a world axis through the origin |
+| `s.rotateAbout({ axis, deg, through? })` | general rotation: `axis` = `"X"｜"Y"｜"Z"` or `[x,y,z]`; `through` = centre (default origin) |
+| `s.along(dir)` | orient the canonical **+Z** build axis to point along `dir` (`"+X"｜"-X"｜"+Y"｜"-Y"｜"+Z"｜"-Z"`) |
+| `s.at([x,y,z])` | place an origin-built solid at a point (readable alias of `translate`) |
 | `s.mirror("XY"\|"XZ"\|"YZ")` | mirror across a plane |
 | `s.scale(factor, center?)` | uniform scale (single factor) about `center` (default origin) — scaling an off-origin part about the origin also moves it; pass a center (e.g. `s.boundingBox().center`) to resize in place |
 | `s.clone()` | independent copy (replicad consumes solids on transform) |
@@ -118,6 +122,41 @@ entry pulls in the DOM viewer/controls, and your build functions run in a Web Wo
 You normally only call the *make/combine/transform* ops; the framework handles
 `toMesh`/`toSTL`/`toIndexedMesh`/`toSTEP`. Units are millimetres.
 
+### Build-step style: orient → place, and batch features
+
+Write build steps so intent is legible — an LLM (and a human) should not have to decode
+magic vectors. Three habits:
+
+- **Orient then place.** Build a primitive along its canonical **+Z** axis, point it with
+  `along(dir)`, then position it with `at([x,y,z])`:
+
+  ```js
+  // ✗ cryptic: which axis? what centre?
+  k.cylinder(r, r, L).rotate(-90, [0, 0, 0], [1, 0, 0]).translate([rp, y1, sz])
+  // ✓ legible
+  k.cylinder(r, r, L).along("+Y").at([rp, y1, sz])
+  ```
+
+- **Rotate about a point with `rotateAbout`** when the axis isn't through the origin
+  (use `rotateX/Y/Z` for the common origin cases):
+
+  ```js
+  // ✗  .rotate(angle, [rp, 0, 0], [0, 0, 1])
+  // ✓
+  tool.rotateAbout({ axis: "Z", deg: angle, through: [rp, 0, 0] })
+  ```
+
+- **Batch features** instead of reassigning through a cut-chain:
+
+  ```js
+  // ✗  body = body.cut(a); body = body.cut(b); body = body.cut(c);
+  // ✓
+  body.cutAll([a, b, c])          // and k.union([base, f1, f2]) for additive batches
+  ```
+
+The bare `rotate(deg, center, axis)` remains available as the low-level primitive for
+anything `rotateX/Y/Z`/`rotateAbout` can't express, but prefer the vocabulary above.
+
 ### Caching & determinism
 
 The preview kernel memoizes geometry by content hash, so editing a parameter only
@@ -409,6 +448,64 @@ The `measure` function is also exported for vitest (boot a Manifold kernel as in
 
 ---
 
+## Self-verification (the `verify` block)
+
+A part can declare how it should be checked, co-located with its schema, so
+`partforge measure` (and vitest) can prove it is both **printable** and **correct**.
+Add an optional top-level `verify` block:
+
+```js
+verify: {
+  process: "fdm-pla",            // a DFM profile: fdm-pla | fdm-petg | resin, or an
+                                  // inline { bed:[x,y,z], minWall, clearance } object
+  cases: ["defaults", "M3"],     // optional; default = defaults + every preset
+  expect: {                      // design intent, by sub-part name (+ "_view")
+    spacer: { holes: 1, bbox: "<=[60,60,60]", volume: "0.4..0.6cm3" },
+    _view:  { overlaps: 0 },
+  },
+}
+```
+
+**What the profile gives you:** a hard **bed-fit** gate (the view bbox must fit `bed`)
+and a **min-wall** warning. **What `expect` gives you:** per-sub-part assertions on the
+facts `measure` already reports — `holes` (through-bores / genus), `volume`,
+`surfaceArea`, `triangleCount`, `bbox`, `watertight`, `minWall`; and `_view` assertions
+`bbox`, `volume`, `overlaps`.
+
+**Assertion DSL:** a bare number means equality (`holes: 1`); `">=n"`, `"<=n"`, `">n"`,
+`"<n"`, or a range `"a..b"`; an optional unit suffix `mm`/`cm`/`mm3`/`cm3`; and for
+`bbox`, a componentwise vector `"<=[x,y,z]"` / `">=[x,y,z]"` where `*` skips an axis.
+The parser is strict — a malformed assertion fails loudly.
+
+**Gates vs. warnings:** exact facts are **gates** (a failure sets a non-zero exit code);
+`minWall` is computed (a ray/shot wall-thickness measurement) and reported as a
+**warning** — it flags walls below the profile's minimum but never fails the build.
+`holes`/`watertight` are Manifold-only, so those assertions **skip** on OCCT parts
+rather than fail.
+
+**Running it:**
+
+```bash
+npx partforge measure src/parts/<part>.js          # auto-runs verify if a block exists
+npx partforge measure src/parts/<part>.js --process resin   # force/override a profile
+npx partforge measure src/parts/<part>.js --no-verify       # facts only
+```
+
+…and in vitest:
+
+```js
+import { verify } from "partforge/testing";
+test("part is printable and correct", () => {
+  expect(verify(kernel, part).ok).toBe(true);
+});
+```
+
+Checks run across the **default config plus every preset** (or your `cases` list); a
+preset that changes only parameters no on-screen sub-part reads is deduplicated, so
+coverage is cheap.
+
+---
+
 ## Fillet & chamfer (automatic OCCT backend)
 
 Two backends build your part: **Manifold** (fast meshes — preview, STL, 3MF) and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/app-planter.js

@@ -0,0 +1,10 @@
+import planterPart from "./parts/planter.js";
+import { mount } from "./framework/index.js";
+
+// Dev-only example app for the faceted planter part. Identical wiring to app-demo.js —
+// only the imported definition and the worker entry differ per part. `npm run dev`,
+// then open /planter.html.
+mount(planterPart, {
+  createWorker: (name) =>
+    new Worker(new URL("./planter-worker.js", import.meta.url), { type: "module", name }),
+});

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; }
@@ -198,4 +237,4 @@ 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); }
-}
+}

package/src/framework/geometry/kernel.js

@@ -11,7 +11,13 @@
  * @property {() => {min:number[],max:number[],center:number[],size:number[]}} boundingBox   axis-aligned bounds (query)
  * @property {(thickness:number, openFaces:object) => Solid} shell   hollow inward (OCCT only); openFaces selector required
  * @property {(v: number[]) => Solid} translate
- * @property {(deg: number, center: number[], axis: number[]) => Solid} rotate
+ * @property {(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
+ * @property {(deg: number) => Solid} rotateY   rotate about world Y through the origin
+ * @property {(deg: number) => Solid} rotateZ   rotate about world Z through the origin
+ * @property {(o:{axis:"X"|"Y"|"Z"|number[], deg:number, through?:number[]}) => Solid} rotateAbout   general rotation (legible)
+ * @property {(dir:"+X"|"-X"|"+Y"|"-Y"|"+Z"|"-Z") => Solid} along   orient the canonical +Z build axis along dir
+ * @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)

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

@@ -2,6 +2,7 @@ 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";
 
 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
@@ -12,6 +13,18 @@ const SHARP_ANGLE = 35; // deg — same-surface edges sharper than this shade ha
 const COPLANAR_COS = Math.cos((5 * Math.PI) / 180); // edge lines: skip cut seams that bend less than 5° (coplanar)
 const MIN_EDGE2 = 0.01 * 0.01; // edge lines: drop sub-0.01mm segments (degenerate boolean slivers, not real features)
 
+// true axis-angle rotation as a column-major 4x4 (manifold Mat4), translation 0
+function axisAngleMat4(axis, deg) {
+  const len = Math.hypot(axis[0], axis[1], axis[2]) || 1;
+  const x = axis[0] / len, y = axis[1] / len, z = axis[2] / len;
+  const t = (deg * Math.PI) / 180, c = Math.cos(t), s = Math.sin(t), C = 1 - c;
+  const R00 = c + x*x*C,   R01 = x*y*C - z*s, R02 = x*z*C + y*s;
+  const R10 = y*x*C + z*s, R11 = c + y*y*C,   R12 = y*z*C - x*s;
+  const R20 = z*x*C - y*s, R21 = z*y*C + x*s, R22 = c + z*z*C;
+  // column-major: columns are images of the basis vectors; 4th column = translation (0)
+  return [R00, R10, R20, 0,  R01, R11, R21, 0,  R02, R12, R22, 0,  0, 0, 0, 1];
+}
+
 export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   const { Manifold, CrossSection } = wasm;
   const segs = SEGS[quality], tube = TUBE[quality];
@@ -58,7 +71,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     return { positions, indices };
   }
 
-  const wrap = (m, hash) => ({
+  const wrap = (m, hash) => addSugar({
     _m: m,
     _hash: hash,
     cut: (t) => cached(h("cut", hash, t._hash), () => T(m.subtract(t._m))),
@@ -80,9 +93,11 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     isEmpty: () => m.isEmpty(),
     translate: (v) => wrap(T(m.translate(v)), h("translate", hash, v)),
     rotate: (deg, center, axis) => {
-      const euler = [axis[0] * deg, axis[1] * deg, axis[2] * deg];
+      const nz = (axis[0] !== 0) + (axis[1] !== 0) + (axis[2] !== 0);
       const a = T(m.translate([-center[0], -center[1], -center[2]]));
-      const b = T(a.rotate(euler));
+      const b = nz <= 1
+        ? T(a.rotate([axis[0] * deg, axis[1] * deg, axis[2] * deg]))   // basis axis — euler is exact; unchanged
+        : T(a.transform(axisAngleMat4(axis, deg)));                    // general axis-angle
       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)),
@@ -123,7 +138,9 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
         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 } = {}) =>

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

@@ -3,6 +3,7 @@
 // (makeCylinder, makeHelix+genericSweep, draw/extrude, cut/fuse) now live.
 import { toEdgeFinder } from "./edge-selector.js";
 import { toFaceFinder } from "./face-selector.js";
+import { addSugar } from "./solid-sugar.js";
 const MESH = { preview: { tolerance: 0.1, angularTolerance: 0.5 }, print: { tolerance: 0.01, angularTolerance: 0.1 } };
 
 export function createOcctKernel(replicad) {
@@ -77,7 +78,7 @@ export function createOcctKernel(replicad) {
     return backup;
   };
 
-  const wrap = (shape) => ({
+  const wrap = (shape) => addSugar({
     _s: shape,
     cut: (t) => wrap(shape.cut(t._s)),
     cutAll: (tools) => wrap(shape.cut(makeCompound(tools.map((t) => t._s)))),

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

@@ -0,0 +1,35 @@
+// 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.
+const ORIGIN = [0, 0, 0];
+const AXIS = { X: [1, 0, 0], Y: [0, 1, 0], Z: [0, 0, 1] };
+
+const SUGAR = {
+  rotateX(deg) { return this.rotate(deg, ORIGIN, [1, 0, 0]); },
+  rotateY(deg) { return this.rotate(deg, ORIGIN, [0, 1, 0]); },
+  rotateZ(deg) { return this.rotate(deg, ORIGIN, [0, 0, 1]); },
+  rotateAbout({ axis, deg, through = ORIGIN }) {
+    const ax = Array.isArray(axis) ? axis : AXIS[axis];
+    if (!ax) throw new Error(`rotateAbout: unknown axis ${JSON.stringify(axis)} (use "X"|"Y"|"Z" or a [x,y,z] vector)`);
+    return this.rotate(deg, through, ax);
+  },
+  along(dir) {
+    switch (dir) {
+      case "+Z": return this.translate(ORIGIN);   // fresh handle, identity geometry — consistent with the other directions
+      case "-Z": return this.rotate(180, ORIGIN, [1, 0, 0]);
+      case "+Y": return this.rotate(-90, ORIGIN, [1, 0, 0]);
+      case "-Y": return this.rotate(90, ORIGIN, [1, 0, 0]);
+      case "+X": return this.rotate(90, ORIGIN, [0, 1, 0]);
+      case "-X": return this.rotate(-90, ORIGIN, [0, 1, 0]);
+      default: throw new Error(`along: unknown direction ${JSON.stringify(dir)} (use "+X"|"-X"|"+Y"|"-Y"|"+Z"|"-Z")`);
+    }
+  },
+  at(v) { return this.translate(v); },
+};
+
+export function addSugar(s) {
+  return Object.assign(s, SUGAR);
+}

package/src/parts/demo.js

@@ -50,9 +50,19 @@ export default {
       build: (k, p, d) => {
         let s = k.cylinder(p.od / 2, p.od / 2, p.h);
         if (p.flange_d > 0) s = k.union([s, k.cylinder(p.flange_d / 2, p.flange_d / 2, p.flange_h)]);
-        return s.cut(k.cylinder(d.boreR, d.boreR, d.cutH).translate([0, 0, -2]));
+        return s.cut(k.cylinder(d.boreR, d.boreR, d.cutH).at([0, 0, -2]));
       },
     },
   },
   views: { spacer: { label: "Spacer" } },
+  // Self-verification (see docs/AUTHORING-PARTS.md "Self-verification"): opt into the
+  // FDM-PLA process profile (bed-fit gate + min-wall warning) and pin the design intent
+  // — one through-bore, fits comfortably on the bed, no interpenetration.
+  verify: {
+    process: "fdm-pla",
+    expect: {
+      spacer: { holes: 1, bbox: "<=[60,60,60]" },
+      _view: { overlaps: 0 },
+    },
+  },
 };

package/src/parts/filleted-box.js

@@ -37,7 +37,7 @@ export default {
         // the shortest edge it touches (here the fillets' bottom arcs), so it stops at
         // its valid maximum instead of mangling the bottom face.
         if (p.chamfer > 0) s = s.chamfer(p.chamfer, { inPlane: "XY", at: 0 });    // base edges
-        if (p.bore > 0) s = s.cut(k.cylinder(p.bore / 2, p.bore / 2, p.h + 2).translate([p.w / 2, p.d / 2, -1]));
+        if (p.bore > 0) s = s.cut(k.cylinder(p.bore / 2, p.bore / 2, p.h + 2).at([p.w / 2, p.d / 2, -1]));
         return s;
       },
     },

package/src/parts/planter.js

@@ -0,0 +1,119 @@
+// Example PartDefinition — a faceted planter / cup / vase. A second worked example
+// alongside parts/demo.js (the Spacer): it shows a prism-based body (Manifold backend,
+// so it stays fast — no OCCT), per-control descriptions, presets, an optional feature
+// (drainage), a hidden internal constant (floor), and a derive() that turns raw inputs
+// into the n-gon point lists and dependent dimensions the build consumes.
+//
+// Why it's a good demo: every control has an obvious reason to touch it before
+// printing. Facets/twist are pure fun, height/diameter/taper fit it to your plant or
+// pens, the drainage hole is a real functional choice (planter vs. cup), and dropping
+// Wall below the fdm-pla 1.2 mm minimum trips partforge's min-wall warning.
+
+// A regular n-gon of circumradius R, in the XY plane, as [[x,y],…] for k.prism.
+// A small rotation seats a flat edge toward the viewer so even-sided shapes read right.
+const ngon = (R, n) => {
+  const pts = [];
+  const offset = Math.PI / n - Math.PI / 2; // flat side facing -Y
+  for (let i = 0; i < n; i++) {
+    const a = (2 * Math.PI * i) / n + offset;
+    pts.push([R * Math.cos(a), R * Math.sin(a)]);
+  }
+  return pts;
+};
+
+export default {
+  meta: { title: "Faceted Planter", units: "mm", background: 0x15181d },
+  parameters: [
+    {
+      id: "body",
+      title: "Body",
+      description:
+        "The faceted vessel. Pick a preset to start, or open **Advanced** for exact dimensions. " +
+        "**Facets** and **Twist** are pure styling; **Wall** is the one that decides whether it prints cleanly.",
+      presets: {
+        "Pen cup": { facets: 6, dia: 80, height: 100, taper: 1.0, twist: 0, drain: 0 },
+        Planter: { facets: 8, dia: 90, height: 80, taper: 0.9, twist: 0, drain: 8 },
+        Vase: { facets: 5, dia: 70, height: 150, taper: 1.12, twist: 40, drain: 0 },
+      },
+      advanced: [
+        { key: "facets", label: "Facets", min: 3, max: 12, step: 1,
+          description: "Number of flat sides around the body. Low counts read as crystalline; high counts approach a smooth cylinder." },
+        { key: "dia", label: "Diameter", unit: "mm", min: 30, max: 150, step: 1,
+          description: "Across-corners diameter at the base. Size it to the plant, pens, or shelf it has to fit." },
+        { key: "height", label: "Height", unit: "mm", min: 20, max: 200, step: 1,
+          description: "Overall height along the axis." },
+        { key: "taper", label: "Top taper", min: 0.6, max: 1.4, step: 0.02,
+          description: "Rim size relative to the base: below 1 tapers inward (planter), 1 is straight (cup), above 1 flares out (vase)." },
+        { key: "wall", label: "Wall thickness", unit: "mm", min: 0.8, max: 4, step: 0.1,
+          description: "Side-wall thickness. The fdm-pla profile wants **≥ 1.2 mm** — go thinner and partforge flags a min-wall warning." },
+        { key: "twist", label: "Twist", unit: "°", min: 0, max: 180, step: 5,
+          description: "Rotates the facets from base to rim for a spiral look. 0 keeps the facets vertical." },
+        { key: "floor", label: "Floor thickness", unit: "mm", min: 1, max: 6, step: 0.5, hidden: true,
+          description: "Internal: solid base thickness, fixed by the design. Hidden from the end user but still drives the geometry." },
+      ],
+    },
+    {
+      id: "drainage",
+      title: "Drainage",
+      description: "Optional drainage hole through the base — turn it on for a planter, off to hold water like a cup or vase.",
+      features: [
+        { label: "Drainage hole", key: "drain", on: 8,
+          description: "Drills a centered hole of this diameter through the floor.",
+          sliders: [{ key: "drain", label: "Hole diameter", unit: "mm", min: 3, max: 30, step: 1,
+            description: "Diameter of the centered drainage hole." }] },
+      ],
+    },
+  ],
+  defaults: { facets: 6, dia: 70, height: 90, taper: 1.2, wall: 1.6, twist: 30, drain: 8, floor: 3 },
+  // derive(): turn raw inputs into the n-gon point lists and dependent dimensions the
+  // build needs, sized so the wall stays even (see build()).
+  derive: (p) => {
+    const Rout = p.dia / 2;
+    // Offset the inner polygon inward by `wall` along the FACE normals, not the radius:
+    // for a regular n-gon an edge offset of `wall` shrinks the circumradius by
+    // wall / cos(π/n). This keeps the perpendicular wall = `wall` on every flat.
+    // clamp only matters if wall is set past the slider bounds via the API
+    const Rin = Math.max(Rout - p.wall / Math.cos(Math.PI / p.facets), 1);
+    return {
+      outerPts: ngon(Rout, p.facets),
+      innerPts: ngon(Rin, p.facets),
+      // Inner taper that holds the wall constant top-to-bottom even as the body flares:
+      // pick it so inner_radius(top) = outer_radius(top) − wall.
+      innerTaper: 1 + (Rout * (p.taper - 1)) / Rin,
+      drainR: (p.drain + 0.2) / 2, // nominal hole + 0.2 mm print clearance, as a radius
+    };
+  },
+  parts: {
+    planter: {
+      label: "Planter",
+      views: ["planter"],
+      export: { name: "planter" },
+      build: (k, p, d) => {
+        const body = k.prism(d.outerPts, p.height, { scaleTop: p.taper, twist: p.twist });
+        // Hollow it. The cavity is built from z=0 sharing the body's exact twist RATE and
+        // taper slope (f rescales the ~4 mm overshoot so the rates still match), so the
+        // inner and outer facets stay radially aligned at every height — the wall can't
+        // pinch when twisted. Then clip the cavity to z ≥ floor so the base stays solid.
+        const f = (p.height + 4) / p.height;
+        const cavity = k
+          .prism(d.innerPts, p.height + 4, { scaleTop: 1 + (d.innerTaper - 1) * f, twist: p.twist * f })
+          .intersect(k.box([-1e4, -1e4, p.floor], [1e4, 1e4, p.height + 10]));
+        let s = body.cut(cavity);
+        // Optional drainage hole straight through the base.
+        if (p.drain > 0) s = s.cut(k.cylinder(d.drainR, d.drainR, p.floor + 4).at([0, 0, -2]));
+        return s;
+      },
+    },
+  },
+  views: { planter: { label: "Planter" } },
+  // Self-verification (see docs/AUTHORING-PARTS.md "Self-verification"): opt into the
+  // FDM-PLA process profile (bed-fit gate + min-wall warning) and pin the design intent
+  // — one drainage hole through the base, fits the bed, no interpenetration.
+  verify: {
+    process: "fdm-pla",
+    expect: {
+      planter: { holes: 1 /* drain=8 at defaults → 1 hole; adjust if running verify with a non-default drain */, bbox: "<=[220,220,250]" },
+      _view: { overlaps: 0 } /* _view = whole-model composite (not a named part) */,
+    },
+  },
+};

package/src/planter-worker.js

@@ -0,0 +1,3 @@
+import part from "./parts/planter.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);

package/src/testing/assert-dsl.js

@@ -0,0 +1,79 @@
+// Assertion mini-DSL: parse a declared expectation into a normalized predicate.
+// Numeric values are normalized to base units (mm for length, mm³ for volume) at
+// parse time so the evaluator compares plain numbers. Strict: any unrecognized form
+// throws an Error naming the offending string.
+
+const UNIT = { mm: 1, cm: 10, mm3: 1, cm3: 1000 };
+
+function toBase(numStr, unit) {
+  const n = Number(numStr);
+  if (!Number.isFinite(n)) throw new Error(`assertion: not a number: "${numStr}"`);
+  if (unit === undefined) return n;
+  if (!(unit in UNIT)) throw new Error(`assertion: unknown unit: "${unit}"`);
+  return n * UNIT[unit];
+}
+
+const NUM = "[-+]?[0-9]*\\.?[0-9]+";
+const U = "(mm3|cm3|mm|cm)?";
+const reScalar = new RegExp(`^(>=|<=|>|<)?\\s*(${NUM})\\s*${U}$`);
+const reRange = new RegExp(`^(${NUM})\\s*\\.\\.\\s*(${NUM})\\s*${U}$`);
+const reVec = /^(>=|<=)\s*\[\s*(.+?)\s*\]$/;
+
+export function parseAssertion(expr) {
+  if (typeof expr === "number" || typeof expr === "boolean") return { op: "eq", value: expr };
+  if (typeof expr !== "string") throw new Error(`assertion: unsupported value ${JSON.stringify(expr)}`);
+  const s = expr.trim();
+
+  const vec = s.match(reVec);
+  if (vec) {
+    const parts = vec[2].split(",").map((t) => t.trim());
+    if (parts.length !== 3) throw new Error(`assertion: vector needs 3 components: "${expr}"`);
+    return { op: vec[1] === "<=" ? "vle" : "vge", vec: parts.map((t) => (t === "*" ? null : toBase(t, undefined))) };
+  }
+  const range = s.match(reRange);
+  if (range) return { op: "range", min: toBase(range[1], range[3] || undefined), max: toBase(range[2], range[3] || undefined) };
+
+  const sc = s.match(reScalar);
+  if (sc) {
+    const op = sc[1] ? { ">=": "gte", "<=": "lte", ">": "gt", "<": "lt" }[sc[1]] : "eq";
+    return { op, value: toBase(sc[2], sc[3] || undefined) };
+  }
+  throw new Error(`assertion: unrecognized form: "${expr}"`);
+}
+
+const EPS = 1e-6;
+const approxEq = (a, b) => Math.abs(a - b) <= EPS + EPS * Math.abs(b);
+const fmtVec = (v) => "[" + v.map((x) => (x === null ? "*" : x)).join(",") + "]";
+
+export function evaluateAssertion(parsed, actual) {
+  switch (parsed.op) {
+    case "eq": {
+      const pass = typeof parsed.value === "boolean" ? actual === parsed.value : approxEq(actual, parsed.value);
+      return { pass, message: `${actual} ${pass ? "==" : "!="} ${parsed.value}` };
+    }
+    case "gte": return mk(actual >= parsed.value - EPS, actual, ">=", parsed.value);
+    case "lte": return mk(actual <= parsed.value + EPS, actual, "<=", parsed.value);
+    case "gt": return mk(actual > parsed.value, actual, ">", parsed.value);
+    case "lt": return mk(actual < parsed.value, actual, "<", parsed.value);
+    case "range": {
+      const pass = actual >= parsed.min - EPS && actual <= parsed.max + EPS;
+      return { pass, message: `${actual} ${pass ? "in" : "out of"} ${parsed.min}..${parsed.max}` };
+    }
+    case "vle":
+    case "vge": {
+      const ge = parsed.op === "vge";
+      let pass = true;
+      for (let i = 0; i < 3; i++) {
+        const lim = parsed.vec[i];
+        if (lim === null) continue;
+        if (ge ? actual[i] < lim - EPS : actual[i] > lim + EPS) pass = false;
+      }
+      return { pass, message: `${fmtVec(actual)} ${ge ? ">=" : "<="} ${fmtVec(parsed.vec)}` };
+    }
+    default: throw new Error(`assertion: unknown op "${parsed.op}"`);
+  }
+}
+
+function mk(pass, actual, opStr, value) {
+  return { pass, message: `${actual} ${pass ? opStr : "not " + opStr} ${value}` };
+}

package/src/testing/bvh.js

@@ -0,0 +1,166 @@
+// src/testing/bvh.js
+// Triangle BVH over a mesh in either Manifold non-indexed soup form (9 floats per
+// triangle, no `indices`) or OCCT indexed form (`positions` = 3 floats/vertex +
+// `indices` = 3 vertex-indices/triangle). A reusable spatial index: nearest ray hit
+// (raycast) and nearest surface point (closestPoint, added alongside). AABB tree,
+// median split on the widest centroid axis, slab ray–box test with pruning.
+
+const LEAF = 4; // max triangles per leaf
+
+// Triangles as [v0,v1,v2] coord triples, from either a Manifold non-indexed soup
+// (positions = 9 floats/triangle, no indices) or an OCCT indexed mesh (positions =
+// 3 floats/vertex + indices = 3 vertex-indices/triangle).
+export function meshTriangles(mesh) {
+  const { positions, indices } = mesh;
+  if (indices) {
+    const n = indices.length / 3, out = new Array(n);
+    for (let t = 0; t < n; t++) {
+      const a = indices[3 * t] * 3, b = indices[3 * t + 1] * 3, c = indices[3 * t + 2] * 3;
+      out[t] = [[positions[a], positions[a + 1], positions[a + 2]],
+                [positions[b], positions[b + 1], positions[b + 2]],
+                [positions[c], positions[c + 1], positions[c + 2]]];
+    }
+    return out;
+  }
+  const n = positions.length / 9, out = new Array(n);
+  for (let t = 0; t < n; t++) {
+    const o = t * 9;
+    out[t] = [[positions[o], positions[o + 1], positions[o + 2]],
+              [positions[o + 3], positions[o + 4], positions[o + 5]],
+              [positions[o + 6], positions[o + 7], positions[o + 8]]];
+  }
+  return out;
+}
+
+function readTris(mesh) {
+  const triangles = meshTriangles(mesh);
+  return triangles.map(([v0, v1, v2], i) => {
+    const min = [Math.min(v0[0], v1[0], v2[0]), Math.min(v0[1], v1[1], v2[1]), Math.min(v0[2], v1[2], v2[2])];
+    const max = [Math.max(v0[0], v1[0], v2[0]), Math.max(v0[1], v1[1], v2[1]), Math.max(v0[2], v1[2], v2[2])];
+    return { i, v0, v1, v2, min, max, c: [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2] };
+  });
+}
+
+function aabbOf(items) {
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+  for (const it of items) for (let a = 0; a < 3; a++) { if (it.min[a] < min[a]) min[a] = it.min[a]; if (it.max[a] > max[a]) max[a] = it.max[a]; }
+  return { min, max };
+}
+
+function build(items) {
+  const box = aabbOf(items);
+  if (items.length <= LEAF) return { ...box, tris: items };
+  const ext = [box.max[0] - box.min[0], box.max[1] - box.min[1], box.max[2] - box.min[2]];
+  const axis = ext[0] >= ext[1] && ext[0] >= ext[2] ? 0 : ext[1] >= ext[2] ? 1 : 2;
+  const sorted = items.slice().sort((p, q) => p.c[axis] - q.c[axis]);
+  const mid = sorted.length >> 1;
+  const left = sorted.slice(0, mid), right = sorted.slice(mid);
+  if (left.length === 0 || right.length === 0) return { ...box, tris: items }; // degenerate split
+  return { ...box, left: build(left), right: build(right) };
+}
+
+// slab test: returns the entry distance if the ray meets [min,max] within (tMin,best], else Infinity
+function rayBox(o, invD, min, max, tMin, best) {
+  let t0 = tMin, t1 = best;
+  for (let a = 0; a < 3; a++) {
+    let lo = (min[a] - o[a]) * invD[a], hi = (max[a] - o[a]) * invD[a];
+    if (lo > hi) { const tmp = lo; lo = hi; hi = tmp; }
+    if (lo > t0) t0 = lo; if (hi < t1) t1 = hi;
+    if (t0 > t1) return Infinity;
+  }
+  return t0;
+}
+
+// nearest point on triangle to P (Ericson), returns { point, d2 }
+function closestOnTri(P, tri) {
+  const A = tri.v0, B = tri.v1, C = tri.v2;
+  const sub = (p, q) => [p[0]-q[0], p[1]-q[1], p[2]-q[2]];
+  const dot = (p, q) => p[0]*q[0] + p[1]*q[1] + p[2]*q[2];
+  const add = (p, q) => [p[0]+q[0], p[1]+q[1], p[2]+q[2]];
+  const mul = (p, s) => [p[0]*s, p[1]*s, p[2]*s];
+  const ab = sub(B,A), ac = sub(C,A), ap = sub(P,A);
+  const d1 = dot(ab,ap), d2 = dot(ac,ap);
+  let Q;
+  if (d1<=0&&d2<=0) Q = A;
+  else { const bp = sub(P,B), d3 = dot(ab,bp), d4 = dot(ac,bp);
+    if (d3>=0&&d4<=d3) Q = B;
+    else { const vc = d1*d4 - d3*d2;
+      if (vc<=0&&d1>=0&&d3<=0) Q = add(A, mul(ab, d1/(d1-d3)));
+      else { const cp = sub(P,C), d5 = dot(ab,cp), d6 = dot(ac,cp);
+        if (d6>=0&&d5<=d6) Q = C;
+        else { const vb = d5*d2 - d1*d6;
+          if (vb<=0&&d2>=0&&d6<=0) Q = add(A, mul(ac, d2/(d2-d6)));
+          else { const va = d3*d6 - d5*d4;
+            if (va<=0&&(d4-d3)>=0&&(d5-d6)>=0) Q = add(B, mul(sub(C,B), (d4-d3)/((d4-d3)+(d5-d6))));
+            else { const denom = 1/(va+vb+vc); Q = add(add(A, mul(ab, vb*denom)), mul(ac, vc*denom)); } } } } } }
+  const pq = sub(P, Q);
+  return { point: Q, d2: dot(pq, pq) };
+}
+
+// squared distance from point to an AABB (0 inside)
+function distSqBox(p, min, max) {
+  let s = 0;
+  for (let a = 0; a < 3; a++) { const v = p[a] < min[a] ? min[a] - p[a] : p[a] > max[a] ? p[a] - max[a] : 0; s += v * v; }
+  return s;
+}
+
+// Möller–Trumbore; returns t>tMin or Infinity
+function rayTri(o, d, tri, tMin) {
+  const e1 = [tri.v1[0] - tri.v0[0], tri.v1[1] - tri.v0[1], tri.v1[2] - tri.v0[2]];
+  const e2 = [tri.v2[0] - tri.v0[0], tri.v2[1] - tri.v0[1], tri.v2[2] - tri.v0[2]];
+  const p = [d[1] * e2[2] - d[2] * e2[1], d[2] * e2[0] - d[0] * e2[2], d[0] * e2[1] - d[1] * e2[0]];
+  const det = e1[0] * p[0] + e1[1] * p[1] + e1[2] * p[2];
+  if (det > -1e-12 && det < 1e-12) return Infinity;
+  const inv = 1 / det;
+  const tv = [o[0] - tri.v0[0], o[1] - tri.v0[1], o[2] - tri.v0[2]];
+  const u = (tv[0] * p[0] + tv[1] * p[1] + tv[2] * p[2]) * inv;
+  if (u < 0 || u > 1) return Infinity;
+  const q = [tv[1] * e1[2] - tv[2] * e1[1], tv[2] * e1[0] - tv[0] * e1[2], tv[0] * e1[1] - tv[1] * e1[0]];
+  const v = (d[0] * q[0] + d[1] * q[1] + d[2] * q[2]) * inv;
+  if (v < 0 || u + v > 1) return Infinity;
+  const t = (e2[0] * q[0] + e2[1] * q[1] + e2[2] * q[2]) * inv;
+  return t > tMin ? t : Infinity;
+}
+
+export function buildBVH(mesh) {
+  const tris = readTris(mesh);
+  const root = build(tris);
+
+  function raycast(origin, dir, { tMin = 1e-6, tMax = Infinity, skipTri = -1 } = {}) {
+    const invD = [1 / dir[0], 1 / dir[1], 1 / dir[2]];
+    let best = tMax, bestTri = -1;
+    const stack = [root];
+    while (stack.length) {
+      const node = stack.pop();
+      if (rayBox(origin, invD, node.min, node.max, tMin, best) === Infinity) continue;
+      if (node.tris) {
+        for (const tri of node.tris) {
+          if (tri.i === skipTri) continue;
+          const t = rayTri(origin, dir, tri, tMin);
+          if (t < best) { best = t; bestTri = tri.i; }
+        }
+      } else { stack.push(node.left, node.right); }
+    }
+    return bestTri === -1 ? null : { t: best, tri: bestTri };
+  }
+
+  // No production consumer yet — pre-built + tested as the reusable primitive for the deferred clearance/min-feature gate.
+  function closestPoint(p) {
+    let best2 = Infinity, bestPt = null, bestTri = -1;
+    const stack = [root];
+    while (stack.length) {
+      const node = stack.pop();
+      if (distSqBox(p, node.min, node.max) > best2) continue;
+      if (node.tris) {
+        for (const tri of node.tris) { const r = closestOnTri(p, tri); if (r.d2 < best2) { best2 = r.d2; bestPt = r.point; bestTri = tri.i; } }
+      } else {
+        // visit the nearer child first for better pruning
+        const dl = distSqBox(p, node.left.min, node.left.max), dr = distSqBox(p, node.right.min, node.right.max);
+        if (dl < dr) { stack.push(node.right, node.left); } else { stack.push(node.left, node.right); }
+      }
+    }
+    return { point: bestPt, dist: Math.sqrt(best2), tri: bestTri };
+  }
+
+  return { raycast, closestPoint };
+}

package/src/testing/cases.js

@@ -0,0 +1,25 @@
+// Enumerate the parameter configurations verify() checks: the default config plus
+// every declared preset (or an explicit part.verify.cases list).
+
+function presetMap(part) {
+  const map = {};
+  for (const section of part.parameters ?? []) {
+    if (!section.presets) continue;
+    for (const [name, overrides] of Object.entries(section.presets)) {
+      if (name in map) throw new Error(`duplicate preset name across sections: "${name}"`);
+      map[name] = overrides;
+    }
+  }
+  return map;
+}
+
+export function expandCases(part) {
+  const presets = presetMap(part);
+  const make = (name) => {
+    if (name === "defaults") return { name, params: { ...part.defaults } };
+    if (!(name in presets)) throw new Error(`unknown verify case "${name}" (not "defaults" or a preset)`);
+    return { name, params: { ...part.defaults, ...presets[name] } };
+  };
+  const names = part.verify?.cases ?? ["defaults", ...Object.keys(presets)];
+  return names.map(make);
+}

package/src/testing/dfm-profiles.js

@@ -0,0 +1,23 @@
+// Reusable design-for-manufacturing process profiles. `bed` is the build volume
+// [x,y,z] in mm (a hard bbox-fit gate); `minWall` mm (a warn); `clearance` mm is
+// carried for a future gap check (not enforced yet).
+export const PROFILES = {
+  "fdm-pla": { bed: [220, 220, 250], minWall: 1.2, clearance: 0.2 },
+  "fdm-petg": { bed: [220, 220, 250], minWall: 1.5, clearance: 0.3 },
+  "resin": { bed: [120, 68, 160], minWall: 0.6, clearance: 0.1 },
+};
+
+export function resolveProfile(spec) {
+  if (typeof spec === "string") {
+    if (!(spec in PROFILES)) {
+      throw new Error(`unknown process profile: "${spec}" (known: ${Object.keys(PROFILES).join(", ")})`);
+    }
+    return { ...PROFILES[spec] };
+  }
+  if (spec && typeof spec === "object") {
+    const base = spec.base ? resolveProfile(spec.base) : {};
+    const { base: _drop, ...overrides } = spec;
+    return { ...base, ...overrides };
+  }
+  throw new Error(`invalid process profile: ${JSON.stringify(spec)}`);
+}

package/src/testing/measure.js

@@ -1,6 +1,7 @@
 import { buildView } from "./build.js";
 import { assemblyOverlaps } from "../framework/assembly.js";
 import { bounds, meshArea } from "./mesh.js";
+import { minWall } from "./min-wall.js";
 
 const size = ({ min, max }) => [max[0] - min[0], max[1] - min[1], max[2] - min[2]];
 const unionBounds = (list) => list.reduce(
@@ -13,7 +14,7 @@ const unionBounds = (list) => list.reduce(
 // the assembly overlap check. All solid facts are read BEFORE assemblyOverlaps,
 // which frees the shared kernel's objects at its end.
 //   → { part, view, subparts[], aggregate, overlaps[], ok }
-export function measure(kernel, part, view = Object.keys(part.views)[0], params = {}) {
+export function measure(kernel, part, view = Object.keys(part.views)[0], params = {}, opts = {}) {
   const built = buildView(kernel, part, view, params);
   const subBounds = [];
   const subparts = built.map(({ name, solid, mesh }) => {
@@ -27,6 +28,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       triangleCount: mesh.triangles,
       watertight: typeof solid.isEmpty === "function" ? !solid.isEmpty() : null,
       holes: typeof solid.genus === "function" ? solid.genus() : null,
+      minWall: opts.minWall ? (minWall(mesh)?.value ?? null) : null,
     };
   });
 

package/src/testing/min-wall.js

@@ -0,0 +1,38 @@
+// src/testing/min-wall.js
+// Min wall thickness by ray/shot on a triangle BVH (see the spec's spike: this beat the
+// voxel/SDF approach on both accuracy and speed). For each surface triangle, cast a ray
+// inward (reverse of its outward normal) from the centroid; the nearest hit is the local
+// material thickness. The minimum across samples is the reported min wall.
+// Works with both Manifold non-indexed meshes and OCCT indexed meshes (via meshTriangles).
+import { buildBVH, meshTriangles } from "./bvh.js";
+
+export function minWall(mesh, { maxThickness } = {}) {
+  const pos = mesh.positions;
+  const tris = meshTriangles(mesh);
+  if (tris.length === 0) return null;
+
+  // bbox diagonal as the default cap (a ray exiting into open air gets no hit anyway).
+  if (maxThickness == null) {
+    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < pos.length; i += 3) for (let a = 0; a < 3; a++) { if (pos[i + a] < min[a]) min[a] = pos[i + a]; if (pos[i + a] > max[a]) max[a] = pos[i + a]; }
+    maxThickness = Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) + 1;
+  }
+
+  const bvh = buildBVH(mesh);
+  let best = Infinity, loc = null;
+  for (let t = 0; t < tris.length; t++) {
+    const [v0, v1, v2] = tris[t];
+    const e1 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
+    const e2 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]];
+    let nx = e1[1] * e2[2] - e1[2] * e2[1], ny = e1[2] * e2[0] - e1[0] * e2[2], nz = e1[0] * e2[1] - e1[1] * e2[0];
+    const len = Math.hypot(nx, ny, nz);
+    if (len < 1e-9) continue;                       // degenerate triangle
+    nx /= len; ny /= len; nz /= len;                // outward normal (manifold winding)
+    const c = [(v0[0] + v1[0] + v2[0]) / 3, (v0[1] + v1[1] + v2[1]) / 3, (v0[2] + v1[2] + v2[2]) / 3];
+    const dir = [-nx, -ny, -nz];                    // inward
+    const origin = [c[0] + dir[0] * 1e-4, c[1] + dir[1] * 1e-4, c[2] + dir[2] * 1e-4];
+    const hit = bvh.raycast(origin, dir, { tMax: maxThickness, skipTri: t });
+    if (hit && hit.t < best) { best = hit.t; loc = c; }
+  }
+  return best === Infinity ? null : { value: best, location: loc };
+}

package/src/testing/verify.js

@@ -0,0 +1,89 @@
+import { parseAssertion, evaluateAssertion } from "./assert-dsl.js";
+import { measure as defaultMeasure } from "./measure.js";
+import { resolveProfile } from "./dfm-profiles.js";
+import { expandCases } from "./cases.js";
+import { subPartReadKeys, relevanceHash, RELEVANT_ALL } from "../framework/param-deps.js";
+
+// Metric registry: name → how to pull the value out of facts, and whether a failure
+// is a hard gate or a warning. `manifoldOnly` facts are null on OCCT parts.
+const SUBPART_METRICS = {
+  holes: { kind: "gate", manifoldOnly: true, extract: (s) => s.holes },
+  watertight: { kind: "gate", manifoldOnly: true, extract: (s) => s.watertight },
+  volume: { kind: "gate", extract: (s) => s.volume },
+  surfaceArea: { kind: "gate", extract: (s) => s.surfaceArea },
+  triangleCount: { kind: "gate", extract: (s) => s.triangleCount },
+  bbox: { kind: "gate", extract: (s) => s.bbox },
+  minWall: { kind: "warn", extract: (s) => s.minWall },
+};
+const VIEW_METRICS = {
+  bbox: { kind: "gate", extract: (r) => r.aggregate.bbox },
+  volume: { kind: "gate", extract: (r) => r.aggregate.volume },
+  overlaps: { kind: "gate", extract: (r) => r.overlaps.length },
+};
+
+function check(scope, subpart, metric, expr, registry, factsObj) {
+  const reg = registry[metric];
+  if (!reg) throw new Error(`unknown ${scope} metric "${metric}"${subpart ? ` on sub-part "${subpart}"` : ""}`);
+  const actual = reg.extract(factsObj);
+  const base = { scope, subpart, metric, kind: reg.kind, expr: String(expr) };
+  if (actual === null || actual === undefined) {
+    if (reg.manifoldOnly) return { ...base, actual, status: "skip", pass: null, message: "n/a (OCCT backend)" };
+    if (metric === "minWall") return { ...base, actual, status: "warn", pass: null, message: "min wall unavailable" };
+    return { ...base, actual, status: "skip", pass: null, message: "unavailable" };
+  }
+  const { pass, message } = evaluateAssertion(parseAssertion(expr), actual);
+  const status = pass ? "pass" : reg.kind === "warn" ? "warn" : "fail";
+  return { ...base, actual, status, pass, message };
+}
+
+// Pure policy: profile rules + per-part expect → checks for one case's facts.
+export function evaluateCase(facts, { profile, expect }) {
+  const checks = [];
+  const viewExp = {
+    ...(profile?.bed ? { bbox: `<=[${profile.bed.join(",")}]` } : {}),
+    ...(expect?._view ?? {}),
+  };
+  for (const [metric, expr] of Object.entries(viewExp)) checks.push(check("view", null, metric, expr, VIEW_METRICS, facts));
+
+  for (const s of facts.subparts) {
+    const merged = {
+      ...(profile?.minWall != null ? { minWall: `>=${profile.minWall}` } : {}),
+      ...(expect?.[s.name] ?? {}),
+    };
+    for (const [metric, expr] of Object.entries(merged)) checks.push(check("subpart", s.name, metric, expr, SUBPART_METRICS, s));
+  }
+  return checks;
+}
+
+export function verify(kernel, part, { process, view, measureFn = defaultMeasure } = {}) {
+  view = view ?? Object.keys(part.views)[0];
+  const profileSpec = process ?? part.verify?.process;
+  const profile = profileSpec ? resolveProfile(profileSpec) : null;
+  const expect = part.verify?.expect ?? {};
+  const expectMentionsMinWall = Object.values(expect).some((o) => o && typeof o === "object" && "minWall" in o);
+  const needMinWall = profile?.minWall != null || expectMentionsMinWall;
+
+  const cases = expandCases(part);
+  const readKeys = subPartReadKeys(part, view, part.defaults);
+  const signature = (params) =>
+    readKeys === RELEVANT_ALL
+      ? JSON.stringify(params)
+      : [...readKeys.entries()].map(([name, keys]) => `${name}:${relevanceHash([...keys], params)}`).join("|");
+
+  const memo = new Map();
+  const measureCase = (params) => {
+    const key = signature(params);
+    if (!memo.has(key)) memo.set(key, measureFn(kernel, part, view, params, { minWall: needMinWall }));
+    return memo.get(key);
+  };
+
+  const caseResults = cases.map(({ name, params }) => ({ name, params, checks: evaluateCase(measureCase(params), { profile, expect }) }));
+  const all = caseResults.flatMap((c) => c.checks.map((ch) => ({ case: c.name, ...ch })));
+  return {
+    ok: !all.some((c) => c.status === "fail"),
+    view,
+    cases: caseResults,
+    failures: all.filter((c) => c.status === "fail"),
+    warnings: all.filter((c) => c.status === "warn"),
+  };
+}

package/src/testing.js

@@ -9,3 +9,6 @@ export { meshVolume, bboxSize } from "./testing/mesh.js";
 export { buildView } from "./testing/build.js";
 export { measure } from "./testing/measure.js";
 export { renderViews } from "./testing/render.js";
+export { verify } from "./testing/verify.js";
+export { buildBVH } from "./testing/bvh.js";
+export { minWall } from "./testing/min-wall.js";