partforge 0.5.1 → 0.6.0

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.1",
+  "version": "0.6.0",
   "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/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)),

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/framework/viewer.js

@@ -36,8 +36,10 @@ export function createViewer(container, part) {
   const key = new THREE.DirectionalLight(0xffffff, 1.4);
   key.position.set(8, 14, 10);
   scene.add(key);
-  // 1 cm grid (mm units): 200 mm wide, 20 divisions -> 10 mm squares.
-  let grid = new THREE.GridHelper(200, 20, THEME.dark.grid[0], THEME.dark.grid[1]);
+  // 1 cm grid (mm units): 300 mm wide, 30 divisions -> 10 mm (1 cm) squares.
+  const GRID_SIZE = 300, GRID_DIVS = 30;
+  let floorY = 0; // world Y of the grid plane; set to the part's bbox bottom in frameTo
+  let grid = new THREE.GridHelper(GRID_SIZE, GRID_DIVS, THEME.dark.grid[0], THEME.dark.grid[1]);
   scene.add(grid);
 
   // --- material + part groups -----------------------------------------------
@@ -146,6 +148,10 @@ export function createViewer(container, part) {
     const center = _box.getCenter(new THREE.Vector3());
     partsGroup.position.copy(center).multiplyScalar(-1); // centre assembly on the pivot
     const size = _box.getSize(new THREE.Vector3());
+    // Drop the grid to the bottom of the bounding box (model Z -> world Y), so it reads
+    // as a floor the part sits on rather than a plane through its middle.
+    floorY = -size.z / 2;
+    grid.position.y = floorY;
     const r = Math.max(size.x, size.y, size.z) || 12;
     camera.position.setLength(r * 2.6 + 6);
     controls.target.set(0, 0, 0);
@@ -179,7 +185,8 @@ export function createViewer(container, part) {
     const t = THEME[mode] ?? THEME.dark;
     scene.background = new THREE.Color(t.bg);
     scene.remove(grid);
-    grid = new THREE.GridHelper(200, 20, t.grid[0], t.grid[1]);
+    grid = new THREE.GridHelper(GRID_SIZE, GRID_DIVS, t.grid[0], t.grid[1]);
+    grid.position.y = floorY; // keep the floor at the bbox bottom across theme swaps
     scene.add(grid);
     lineMaterial.color.set(t.line);
   }

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/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";