brepjs-cad 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [0.30.0](https://github.com/andymai/brepjs/compare/brepjs-cad-v0.29.0...brepjs-cad-v0.30.0) (2026-06-22)
+
+
+### Features
+
+* **brepjs-cad:** add airfoils.md feature recipe (swept fans/props/impellers) ([#1566](https://github.com/andymai/brepjs/issues/1566)) ([8c786db](https://github.com/andymai/brepjs/commit/8c786db69ead59edcdc9d0f8525e43324552e4db))
+* **brepjs-cad:** aimed section cut for the design judge (Phase 3) ([#1543](https://github.com/andymai/brepjs/issues/1543)) ([40e5acd](https://github.com/andymai/brepjs/commit/40e5acd54318d768dc5a620403d17d43e358e698))
+* **brepjs-cad:** decomposed, cross-checked design-judge rubric (Phase 1.5) ([#1539](https://github.com/andymai/brepjs/issues/1539)) ([8059b6d](https://github.com/andymai/brepjs/commit/8059b6d701ae5980e6bb11f51695aa102fe2bb43))
+* **brepjs-cad:** deterministic body/interference metrics for the design judge (Phase 1) ([#1531](https://github.com/andymai/brepjs/issues/1531)) ([d296b54](https://github.com/andymai/brepjs/commit/d296b545f2d7084b861683d61b626ace4747a371))
+* **brepjs-cad:** kernel-anchored Set-of-Marks for the design judge ([#1545](https://github.com/andymai/brepjs/issues/1545)) ([2b6f5b4](https://github.com/andymai/brepjs/commit/2b6f5b436f2a73c96747cc71f83afc8715765cd0))
+* **brepjs-cad:** reliable internal-bore detection for the design judge (keystone) ([#1542](https://github.com/andymai/brepjs/issues/1542)) ([0d780c3](https://github.com/andymai/brepjs/commit/0d780c3b73c2551dab2f04a6ff31bf9ec8cae2ab))
+* **brepjs-cad:** surface fragmentation in verify --check (the [#1](https://github.com/andymai/brepjs/issues/1) design defect) ([#1560](https://github.com/andymai/brepjs/issues/1560)) ([45a4f6e](https://github.com/andymai/brepjs/commit/45a4f6e268331b7816cd9957fbdab4c0893b2000))
+* **brepjs-cad:** xray internal-reveal shot for the design judge (Phase 2a) ([#1540](https://github.com/andymai/brepjs/issues/1540)) ([eca5bc9](https://github.com/andymai/brepjs/commit/eca5bc9ad20fc7947132d647952245cfe466a7f4))
+
+
+### Bug Fixes
+
+* **brepjs-cad:** add a triangular-gusset recipe to the implement skill (bracket/enclosure eval) ([#1571](https://github.com/andymai/brepjs/issues/1571)) ([346d042](https://github.com/andymai/brepjs/commit/346d0423fefa3bd163f4075f69bf96d478543bf5))
+* **brepjs-cad:** add the "realize the designed object" bar to the implement skill ([#1563](https://github.com/andymai/brepjs/issues/1563)) ([e150357](https://github.com/andymai/brepjs/commit/e1503570aaf271ebef1e39d48be9c70a5ffe8f03))
+* **brepjs-cad:** close gear-teeth edge cases found by /eval-skill (ring, worm tip relief, GT2) ([#1548](https://github.com/andymai/brepjs/issues/1548)) ([4bd0494](https://github.com/andymai/brepjs/commit/4bd049401f3affcc3f38e3a31bb9520653a3e89c))
+* **brepjs-cad:** code + hint the degenerate-edge (duplicate-vertex) verify failure ([#1550](https://github.com/andymai/brepjs/issues/1550)) ([502dffc](https://github.com/andymai/brepjs/commit/502dffc4a2ae495ae5c98b0c7966721abe0d5f48))
+* **brepjs-cad:** correct spur-gear example flanks + add root fillet ([#1528](https://github.com/andymai/brepjs/issues/1528)) ([6971c6b](https://github.com/andymai/brepjs/commit/6971c6befa1fea36a8c2f3ee89c4aa20946020c7))
+* **brepjs-cad:** exploded-joint legibility + disjoint-compound caveat (basics eval) ([#1565](https://github.com/andymai/brepjs/issues/1565)) ([9d06121](https://github.com/andymai/brepjs/commit/9d0612111a595e57fcfca6fd191ed9169fc2c062))
+* **brepjs-cad:** handle brepjs/playground refs + summarize body relations in the digest ([#1547](https://github.com/andymai/brepjs/issues/1547)) ([b0acef0](https://github.com/andymai/brepjs/commit/b0acef0ad80cdd61f0d2683f1e6d0ece0cae028e))
+* **brepjs-cad:** heal 6 implement-skill findings from the full-flywheel re-run ([#1568](https://github.com/andymai/brepjs/issues/1568)) ([f63bf3d](https://github.com/andymai/brepjs/commit/f63bf3d5a0aa638d06e11dd7e2c27e84dbf74746))
+* **brepjs-cad:** heal implement + polish skills from clean-room eval ([#1526](https://github.com/andymai/brepjs/issues/1526)) ([0645e16](https://github.com/andymai/brepjs/commit/0645e163e1d8759c95406d0f9526d0aa3b5dd480))
+* **brepjs-cad:** heal implement skill — deep-stack bounds extremes aren't datums ([#1529](https://github.com/andymai/brepjs/issues/1529)) ([5ed366f](https://github.com/andymai/brepjs/commit/5ed366f266b3e6e50ae4b54d5779aa05453e894a))
+* **brepjs-cad:** heal implement skill from the eval flywheel (3 findings) ([#1552](https://github.com/andymai/brepjs/issues/1552)) ([51def82](https://github.com/andymai/brepjs/commit/51def82db4e0600e85f45e4dd828cc9caee58d15))
+* **brepjs-cad:** heal implement skill from the full-corpus eval flywheel (4 findings) ([#1554](https://github.com/andymai/brepjs/issues/1554)) ([3cfc28e](https://github.com/andymai/brepjs/commit/3cfc28ed8b82c46330f1d75f1e98c13fd4d65a06))
+* **brepjs-cad:** make blind-judge reference adaptation render multi-body parts at scale ([#1530](https://github.com/andymai/brepjs/issues/1530)) ([18d4523](https://github.com/andymai/brepjs/commit/18d4523c85e1b22496bb5c0b8fb382a1146429c6))
+* **brepjs-cad:** polish skill — bosses on shells must fuse, or they float (eval finding) ([#1553](https://github.com/andymai/brepjs/issues/1553)) ([07cbf93](https://github.com/andymai/brepjs/commit/07cbf93e47fbf880df53bc2a1cee05bf0d17e2d5))
+* **brepjs-cad:** teach worm-wheel and rack tooth recipes; fix gear-build contradiction ([#1544](https://github.com/andymai/brepjs/issues/1544)) ([b0da85f](https://github.com/andymai/brepjs/commit/b0da85f218d463e0f1ef0ca8760cec54b4814b02))
+
 ## [0.29.0](https://github.com/andymai/brepjs/compare/brepjs-cad-v0.28.0...brepjs-cad-v0.29.0) (2026-06-20)
 
 

package/dist/{brepjs-verify.cjs → brepjs-cad.cjs}

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_diff = require("./diff-kQJXMzLR.cjs");
+const require_diff = require("./diff-DhOTZnG_.cjs");
 exports.DEFAULT_TOLERANCE_PCT = require_diff.DEFAULT_TOLERANCE_PCT;
 exports.TYPECHECK_CODE = require_diff.TYPECHECK_CODE;
 exports.emptyReport = require_diff.emptyReport;

package/dist/{brepjs-verify.js → brepjs-cad.js}

@@ -1,2 +1,2 @@
-import { a as typecheckPart, c as isExpectedDims, d as emptyReport, i as TYPECHECK_CODE, l as pctDelta, m as serializeReport, n as runMeasure, o as DEFAULT_TOLERANCE_PCT, r as runPart, s as evaluateExpected, t as runDiff, u as runChecks } from "./diff-DcKUadBa.js";
+import { a as typecheckPart, c as isExpectedDims, d as emptyReport, i as TYPECHECK_CODE, l as pctDelta, m as serializeReport, n as runMeasure, o as DEFAULT_TOLERANCE_PCT, r as runPart, s as evaluateExpected, t as runDiff, u as runChecks } from "./diff-MBAc87Xi.js";
 export { DEFAULT_TOLERANCE_PCT, TYPECHECK_CODE, emptyReport, evaluateExpected, isExpectedDims, pctDelta, runChecks, runDiff, runMeasure, runPart, serializeReport, typecheckPart };

package/dist/cli/main.cjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_diff = require("../diff-kQJXMzLR.cjs");
+const require_diff = require("../diff-DhOTZnG_.cjs");
 let node_url = require("node:url");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
@@ -215,6 +215,67 @@ function openBrowser(url, platform = process.platform) {
 	} catch {}
 }
 //#endregion
+//#region src/snapshot/aiming.ts
+/**
+* Kernel-anchored marks for the judge: `B<index>` at each body's bbox centroid (only for multi-body
+* parts — a single body needs no label) and `H1..` at each bore's axis. The same id lands on the same
+* feature across every view (it's a 3D anchor projected per-view), giving the judge view-invariant,
+* part-space addressing without per-body mesh color.
+*
+* Body labels use the body's INDEX (0-based), matching how the measured-facts digest refers to bodies
+* ("bodies 0&1: interfering"), so the judge can cross-reference a mark with the facts. A body that
+* can't be located (no bounds) simply gets no mark — there is no resequenced gap.
+*/
+function featureMarks(bodies, bores) {
+	const marks = [];
+	if (bodies.length > 1) for (const b of bodies) {
+		if (!b.bounds) continue;
+		marks.push({
+			label: `B${b.index}`,
+			pos: [
+				(b.bounds.xMin + b.bounds.xMax) / 2,
+				(b.bounds.yMin + b.bounds.yMax) / 2,
+				(b.bounds.zMin + b.bounds.zMax) / 2
+			]
+		});
+	}
+	bores.forEach((bore, i) => {
+		marks.push({
+			label: `H${i + 1}`,
+			pos: bore.axisOrigin
+		});
+	});
+	return marks;
+}
+/**
+* Aim a section cut through the dominant (largest-radius) bore: cut on the basis axis MOST
+* perpendicular to the bore axis, positioned to pass THROUGH the bore origin — so the bore opens as
+* a clean cross-section (reads wall thickness, where the xray is cluttered). Returns null when there
+* are no bores or no bounds. Plain structural inputs keep this decoupled from the verify report.
+*/
+function aimedSection(bores, bounds) {
+	if (bores.length === 0 || !bounds) return null;
+	const bore = bores.reduce((a, b) => b.radius > a.radius ? b : a);
+	const d = bore.axisDir;
+	const perp = {
+		x: Math.abs(d[0]),
+		y: Math.abs(d[1]),
+		z: Math.abs(d[2])
+	};
+	const axis = [
+		"x",
+		"y",
+		"z"
+	].reduce((a, b) => perp[b] < perp[a] ? b : a);
+	const i = axis === "x" ? 0 : axis === "y" ? 1 : 2;
+	const min = axis === "x" ? bounds.xMin : axis === "y" ? bounds.yMin : bounds.zMin;
+	const span = (axis === "x" ? bounds.xMax : axis === "y" ? bounds.yMax : bounds.zMax) - min || 1;
+	return {
+		axis,
+		frac: Math.min(1, Math.max(0, (bore.axisOrigin[i] - min) / span))
+	};
+}
+//#endregion
 //#region src/cli/main.ts
 console.log = (...args) => {
 	process.stderr.write(args.map(String).join(" ") + "\n");
@@ -230,7 +291,7 @@ async function loadSnapshotShoot() {
 }
 var program = new commander.Command();
 program.name("brep");
-program.command("verify", { isDefault: true }).argument("<files...>", "path(s) or glob(s) to .brep.ts modules; multiple files → a batch validity JSON array").option("--step <out>", "write the primary STEP artifact to this path").option("--glb <out>", "write a derived GLB preview to this path").option("--json <out>", "write the JSON report to this path").option("--check", "type-check the part (against brepjs types) before running; skip execution on type errors").option("--snapshot <dir>", "render iso/front/top/right PNGs to this dir (requires built viewer)").option("--serve", "after verifying, start a preview server and print a ?dir=&file= deep link (stays running)").option("--no-open", "with --serve, do not auto-open the browser (just print the viewer URL)").option("--expect-code <code>", "exit 0 only if the report emits this error code (for fixtures/eval recall)").option("--expect-invalid", "exit 0 only if the part is invalid (ok:false) — for known-bad fixtures").action(async (files, opts) => {
+program.command("verify", { isDefault: true }).argument("<files...>", "path(s) or glob(s) to .brep.ts modules; multiple files → a batch validity JSON array").option("--step <out>", "write the primary STEP artifact to this path").option("--glb <out>", "write a derived GLB preview to this path").option("--json <out>", "write the JSON report to this path").option("--check", "type-check the part (against brepjs types) before running; skip execution on type errors").option("--snapshot <dir>", "render iso/front/top/right PNGs to this dir (requires built viewer)").option("--serve", "after verifying, start a preview server and print a ?dir=&file= deep link (stays running)").option("--no-open", "with --serve, do not auto-open the browser (just print the viewer URL)").option("--expect-code <code>", "exit 0 only if the report emits this error code (for fixtures/eval recall)").option("--expect-invalid", "exit 0 only if the part is invalid (ok:false) — for known-bad fixtures").option("--metrics", "compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default").action(async (files, opts) => {
 	const targets = [...new Set(files.flatMap((f) => {
 		const m = (0, node_fs.globSync)(f);
 		return m.length ? m : [f];
@@ -239,7 +300,10 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 		if (opts.step || opts.serve || opts.snapshot || opts.glb || opts.expectCode || opts.expectInvalid) process.stderr.write("batch mode: --step/--glb/--serve/--snapshot/--expect-code/--expect-invalid ignored (single-file only)\n");
 		const results = [];
 		for (const f of targets) {
-			const { report, shape } = await require_diff.runPart(f, { check: Boolean(opts.check) });
+			const { report, shape } = await require_diff.runPart(f, {
+				check: Boolean(opts.check),
+				metrics: Boolean(opts.metrics)
+			});
 			disposeShape(shape);
 			results.push({
 				file: f,
@@ -258,7 +322,8 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 	const { report, step, glb, shape } = await require_diff.runPart((0, node_path.resolve)(file), {
 		step: wantStep,
 		glb: Boolean(opts.glb),
-		check: Boolean(opts.check)
+		check: Boolean(opts.check),
+		metrics: Boolean(opts.metrics) || Boolean(opts.snapshot)
 	});
 	let stepPath = opts.step;
 	try {
@@ -270,9 +335,13 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 		if (opts.snapshot && stepPath) {
 			const shoot = await loadSnapshotShoot();
 			if (shoot) {
+				const section = aimedSection(report.manufacturability?.bores ?? [], report.measurements.bounds);
+				const marks = featureMarks(report.bodies ?? [], report.manufacturability?.bores ?? []);
 				const { pngs } = await shoot({
 					file: stepPath,
-					outDir: opts.snapshot
+					outDir: opts.snapshot,
+					...section ? { section } : {},
+					...marks.length > 0 ? { marks } : {}
 				});
 				for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
 			}
@@ -321,7 +390,10 @@ program.command("snapshot").argument("<file>", "path to a .brep.ts module; rende
 	const resolved = (0, node_path.resolve)(file);
 	const base = opts.out ? (0, node_path.resolve)(opts.out) : `${resolved}-shots`;
 	const outDir = opts.label ? (0, node_path.join)(base, opts.label) : base;
-	const { report, step, shape } = await require_diff.runPart(resolved, { step: true });
+	const { report, step, shape } = await require_diff.runPart(resolved, {
+		step: true,
+		metrics: true
+	});
 	try {
 		if (!step) {
 			process.stderr.write("snapshot: part produced no STEP — nothing to render\n");
@@ -336,10 +408,14 @@ program.command("snapshot").argument("<file>", "path to a .brep.ts module; rende
 			process.stdout.write(require_diff.serializeReport(report) + "\n");
 			return;
 		}
+		const section = aimedSection(report.manufacturability?.bores ?? [], report.measurements.bounds);
+		const marks = featureMarks(report.bodies ?? [], report.manufacturability?.bores ?? []);
 		const { pngs } = await shoot({
 			file: stepPath,
 			outDir,
-			fresh: true
+			fresh: true,
+			...section ? { section } : {},
+			...marks.length > 0 ? { marks } : {}
 		});
 		for (const p of pngs) process.stdout.write(`${p}\n`);
 	} finally {

package/dist/cli/main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { f as pushError, h as loadBrep, m as serializeReport, n as runMeasure, p as reportOk, r as runPart, t as runDiff } from "../diff-DcKUadBa.js";
+import { f as pushError, h as loadBrep, m as serializeReport, n as runMeasure, p as reportOk, r as runPart, t as runDiff } from "../diff-MBAc87Xi.js";
 import { fileURLToPath } from "node:url";
 import { existsSync, globSync, mkdirSync, realpathSync, watch, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
@@ -214,6 +214,67 @@ function openBrowser(url, platform = process.platform) {
 	} catch {}
 }
 //#endregion
+//#region src/snapshot/aiming.ts
+/**
+* Kernel-anchored marks for the judge: `B<index>` at each body's bbox centroid (only for multi-body
+* parts — a single body needs no label) and `H1..` at each bore's axis. The same id lands on the same
+* feature across every view (it's a 3D anchor projected per-view), giving the judge view-invariant,
+* part-space addressing without per-body mesh color.
+*
+* Body labels use the body's INDEX (0-based), matching how the measured-facts digest refers to bodies
+* ("bodies 0&1: interfering"), so the judge can cross-reference a mark with the facts. A body that
+* can't be located (no bounds) simply gets no mark — there is no resequenced gap.
+*/
+function featureMarks(bodies, bores) {
+	const marks = [];
+	if (bodies.length > 1) for (const b of bodies) {
+		if (!b.bounds) continue;
+		marks.push({
+			label: `B${b.index}`,
+			pos: [
+				(b.bounds.xMin + b.bounds.xMax) / 2,
+				(b.bounds.yMin + b.bounds.yMax) / 2,
+				(b.bounds.zMin + b.bounds.zMax) / 2
+			]
+		});
+	}
+	bores.forEach((bore, i) => {
+		marks.push({
+			label: `H${i + 1}`,
+			pos: bore.axisOrigin
+		});
+	});
+	return marks;
+}
+/**
+* Aim a section cut through the dominant (largest-radius) bore: cut on the basis axis MOST
+* perpendicular to the bore axis, positioned to pass THROUGH the bore origin — so the bore opens as
+* a clean cross-section (reads wall thickness, where the xray is cluttered). Returns null when there
+* are no bores or no bounds. Plain structural inputs keep this decoupled from the verify report.
+*/
+function aimedSection(bores, bounds) {
+	if (bores.length === 0 || !bounds) return null;
+	const bore = bores.reduce((a, b) => b.radius > a.radius ? b : a);
+	const d = bore.axisDir;
+	const perp = {
+		x: Math.abs(d[0]),
+		y: Math.abs(d[1]),
+		z: Math.abs(d[2])
+	};
+	const axis = [
+		"x",
+		"y",
+		"z"
+	].reduce((a, b) => perp[b] < perp[a] ? b : a);
+	const i = axis === "x" ? 0 : axis === "y" ? 1 : 2;
+	const min = axis === "x" ? bounds.xMin : axis === "y" ? bounds.yMin : bounds.zMin;
+	const span = (axis === "x" ? bounds.xMax : axis === "y" ? bounds.yMax : bounds.zMax) - min || 1;
+	return {
+		axis,
+		frac: Math.min(1, Math.max(0, (bore.axisOrigin[i] - min) / span))
+	};
+}
+//#endregion
 //#region src/cli/main.ts
 console.log = (...args) => {
 	process.stderr.write(args.map(String).join(" ") + "\n");
@@ -229,7 +290,7 @@ async function loadSnapshotShoot() {
 }
 var program = new Command();
 program.name("brep");
-program.command("verify", { isDefault: true }).argument("<files...>", "path(s) or glob(s) to .brep.ts modules; multiple files → a batch validity JSON array").option("--step <out>", "write the primary STEP artifact to this path").option("--glb <out>", "write a derived GLB preview to this path").option("--json <out>", "write the JSON report to this path").option("--check", "type-check the part (against brepjs types) before running; skip execution on type errors").option("--snapshot <dir>", "render iso/front/top/right PNGs to this dir (requires built viewer)").option("--serve", "after verifying, start a preview server and print a ?dir=&file= deep link (stays running)").option("--no-open", "with --serve, do not auto-open the browser (just print the viewer URL)").option("--expect-code <code>", "exit 0 only if the report emits this error code (for fixtures/eval recall)").option("--expect-invalid", "exit 0 only if the part is invalid (ok:false) — for known-bad fixtures").action(async (files, opts) => {
+program.command("verify", { isDefault: true }).argument("<files...>", "path(s) or glob(s) to .brep.ts modules; multiple files → a batch validity JSON array").option("--step <out>", "write the primary STEP artifact to this path").option("--glb <out>", "write a derived GLB preview to this path").option("--json <out>", "write the JSON report to this path").option("--check", "type-check the part (against brepjs types) before running; skip execution on type errors").option("--snapshot <dir>", "render iso/front/top/right PNGs to this dir (requires built viewer)").option("--serve", "after verifying, start a preview server and print a ?dir=&file= deep link (stays running)").option("--no-open", "with --serve, do not auto-open the browser (just print the viewer URL)").option("--expect-code <code>", "exit 0 only if the report emits this error code (for fixtures/eval recall)").option("--expect-invalid", "exit 0 only if the part is invalid (ok:false) — for known-bad fixtures").option("--metrics", "compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default").action(async (files, opts) => {
 	const targets = [...new Set(files.flatMap((f) => {
 		const m = globSync(f);
 		return m.length ? m : [f];
@@ -238,7 +299,10 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 		if (opts.step || opts.serve || opts.snapshot || opts.glb || opts.expectCode || opts.expectInvalid) process.stderr.write("batch mode: --step/--glb/--serve/--snapshot/--expect-code/--expect-invalid ignored (single-file only)\n");
 		const results = [];
 		for (const f of targets) {
-			const { report, shape } = await runPart(f, { check: Boolean(opts.check) });
+			const { report, shape } = await runPart(f, {
+				check: Boolean(opts.check),
+				metrics: Boolean(opts.metrics)
+			});
 			disposeShape(shape);
 			results.push({
 				file: f,
@@ -257,7 +321,8 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 	const { report, step, glb, shape } = await runPart(resolve(file), {
 		step: wantStep,
 		glb: Boolean(opts.glb),
-		check: Boolean(opts.check)
+		check: Boolean(opts.check),
+		metrics: Boolean(opts.metrics) || Boolean(opts.snapshot)
 	});
 	let stepPath = opts.step;
 	try {
@@ -269,9 +334,13 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 		if (opts.snapshot && stepPath) {
 			const shoot = await loadSnapshotShoot();
 			if (shoot) {
+				const section = aimedSection(report.manufacturability?.bores ?? [], report.measurements.bounds);
+				const marks = featureMarks(report.bodies ?? [], report.manufacturability?.bores ?? []);
 				const { pngs } = await shoot({
 					file: stepPath,
-					outDir: opts.snapshot
+					outDir: opts.snapshot,
+					...section ? { section } : {},
+					...marks.length > 0 ? { marks } : {}
 				});
 				for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
 			}
@@ -320,7 +389,10 @@ program.command("snapshot").argument("<file>", "path to a .brep.ts module; rende
 	const resolved = resolve(file);
 	const base = opts.out ? resolve(opts.out) : `${resolved}-shots`;
 	const outDir = opts.label ? join(base, opts.label) : base;
-	const { report, step, shape } = await runPart(resolved, { step: true });
+	const { report, step, shape } = await runPart(resolved, {
+		step: true,
+		metrics: true
+	});
 	try {
 		if (!step) {
 			process.stderr.write("snapshot: part produced no STEP — nothing to render\n");
@@ -335,10 +407,14 @@ program.command("snapshot").argument("<file>", "path to a .brep.ts module; rende
 			process.stdout.write(serializeReport(report) + "\n");
 			return;
 		}
+		const section = aimedSection(report.manufacturability?.bores ?? [], report.measurements.bounds);
+		const marks = featureMarks(report.bodies ?? [], report.manufacturability?.bores ?? []);
 		const { pngs } = await shoot({
 			file: stepPath,
 			outDir,
-			fresh: true
+			fresh: true,
+			...section ? { section } : {},
+			...marks.length > 0 ? { marks } : {}
 		});
 		for (const p of pngs) process.stdout.write(`${p}\n`);
 	} finally {

package/dist/{diff-kQJXMzLR.cjs → diff-DhOTZnG_.cjs}

@@ -50,6 +50,199 @@ function initOcctWasm(brep) {
 	return kernelReady;
 }
 //#endregion
+//#region src/verify/manufacturability.ts
+var RELATION_BUDGET_MS = 15e3;
+var MAX_BODIES = 24;
+var VOL_EPS = 1e-9;
+var SUBSTANTIAL_USPAN = 2.5;
+var BORE_DOT = .5;
+var v3sub = (a, b) => [
+	a[0] - b[0],
+	a[1] - b[1],
+	a[2] - b[2]
+];
+var v3dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var v3scale = (a, s) => [
+	a[0] * s,
+	a[1] * s,
+	a[2] * s
+];
+var v3unit = (a) => {
+	const n = Math.hypot(a[0], a[1], a[2]) || 1;
+	return [
+		a[0] / n,
+		a[1] / n,
+		a[2] / n
+	];
+};
+function diagonalOf(boundsList) {
+	if (boundsList.length === 0) return 1;
+	const u = {
+		xMin: Math.min(...boundsList.map((b) => b.xMin)),
+		yMin: Math.min(...boundsList.map((b) => b.yMin)),
+		zMin: Math.min(...boundsList.map((b) => b.zMin)),
+		xMax: Math.max(...boundsList.map((b) => b.xMax)),
+		yMax: Math.max(...boundsList.map((b) => b.yMax)),
+		zMax: Math.max(...boundsList.map((b) => b.zMax))
+	};
+	return Math.hypot(u.xMax - u.xMin, u.yMax - u.yMin, u.zMax - u.zMin) || 1;
+}
+function aabbDisjoint(a, b, eps) {
+	return a.xMax + eps < b.xMin || b.xMax + eps < a.xMin || a.yMax + eps < b.yMin || b.yMax + eps < a.yMin || a.zMax + eps < b.zMin || b.zMax + eps < a.zMin;
+}
+/** Per-body volume/bounds/validity. Used both for the report and to drive the relation matrix. */
+function computeBodies(brep, solids) {
+	const { measureVolume, getBounds, validSolid, isOk } = brep;
+	return solids.map((s, index) => {
+		const v = measureVolume(s);
+		const volume = isOk(v) ? v.value : 0;
+		let bounds;
+		try {
+			bounds = getBounds(s);
+		} catch {}
+		return {
+			index,
+			volume,
+			...bounds ? { bounds } : {},
+			valid: isOk(validSolid(s))
+		};
+	});
+}
+/**
+* Pairwise body relationships. `separate` when the bodies are apart (AABB-disjoint, or measured
+* clearance above eps); `interfering` when they touch or overlap (clearance within eps). `touching`/
+* `nested` (which need a boolean-volume tier) are reserved for a later phase. eps scales to the
+* assembly diagonal so it is meaningful from millimetre parts to metre-scale BIM.
+*/
+function computeBodyRelations(brep, solids, bodies) {
+	const { checkInterference, isOk } = brep;
+	const relations = [];
+	const eps = Math.max(1e-6, 1e-4 * diagonalOf(bodies.flatMap((b) => b.bounds ? [b.bounds] : [])));
+	const start = Date.now();
+	for (let i = 0; i < solids.length; i++) for (let j = i + 1; j < solids.length; j++) {
+		if (Date.now() - start > RELATION_BUDGET_MS) return {
+			relations,
+			truncated: true
+		};
+		const bi = bodies[i]?.bounds;
+		const bj = bodies[j]?.bounds;
+		if (bi && bj && aabbDisjoint(bi, bj, eps)) {
+			relations.push({
+				a: i,
+				b: j,
+				relation: "separate"
+			});
+			continue;
+		}
+		const si = solids[i];
+		const sj = solids[j];
+		if (!si || !sj) continue;
+		const res = checkInterference(si, sj, eps);
+		if (!isOk(res)) continue;
+		relations.push({
+			a: i,
+			b: j,
+			relation: res.value.hasInterference ? "interfering" : "separate",
+			clearance: res.value.minDistance
+		});
+	}
+	return {
+		relations,
+		truncated: false
+	};
+}
+/**
+* Cylindrical features: the smallest substantial cylinder radius (bore/shaft; fillet strips excluded
+* by angular extent) and the internal bores (concave, detected by an outward-normal-vs-radial test).
+* The bore axis lets a later phase aim a section cut or anchor a feature mark.
+*/
+function computeCylinderFeatures(brep, shape) {
+	const { getFaces, faceGeomType, faceCenter, normalAt, faceOrientation, faceAxis, measureCurvatureAtMid, uvBounds, isOk } = brep;
+	const bores = [];
+	let minRadius;
+	let faces;
+	try {
+		faces = getFaces(shape);
+	} catch {
+		return { bores };
+	}
+	for (const f of faces) {
+		if ((() => {
+			try {
+				return faceGeomType(f);
+			} catch {
+				return null;
+			}
+		})() !== "CYLINDRE") continue;
+		const ax = faceAxis(f);
+		if (!ax) continue;
+		const curv = measureCurvatureAtMid(f);
+		if (!isOk(curv)) continue;
+		const k = Math.max(Math.abs(curv.value.maxCurvature), Math.abs(curv.value.minCurvature));
+		if (k <= 0) continue;
+		const radius = 1 / k;
+		try {
+			const uv = uvBounds(f);
+			if (uv.uMax - uv.uMin <= SUBSTANTIAL_USPAN) continue;
+		} catch {
+			continue;
+		}
+		minRadius = minRadius === void 0 ? radius : Math.min(minRadius, radius);
+		try {
+			const p = faceCenter(f);
+			const o = ax.origin;
+			const d = v3unit(ax.direction);
+			const rel = v3sub(p, o);
+			const radial = v3unit(v3sub(rel, v3scale(d, v3dot(rel, d))));
+			const n = normalAt(f);
+			if (v3dot(v3unit(faceOrientation(f) === "forward" ? n : v3scale(n, -1)), radial) > BORE_DOT) bores.push({
+				radius,
+				axisOrigin: [
+					o[0],
+					o[1],
+					o[2]
+				],
+				axisDir: [
+					d[0],
+					d[1],
+					d[2]
+				]
+			});
+		} catch {}
+	}
+	return {
+		...minRadius !== void 0 ? { minRadius } : {},
+		bores
+	};
+}
+/** Orchestrate the deterministic metrics for a verified shape. Never throws (caller wraps too). */
+function computeMetrics(brep, shape, solids) {
+	const bodies = computeBodies(brep, solids);
+	const violations = [];
+	bodies.forEach((b) => {
+		if (b.volume <= VOL_EPS) violations.push(`body ${b.index} has ~zero volume (degenerate)`);
+	});
+	const manufacturability = { violations };
+	const feat = computeCylinderFeatures(brep, shape);
+	if (feat.minRadius !== void 0) manufacturability.minRadius = feat.minRadius;
+	if (feat.bores.length > 0) manufacturability.bores = feat.bores;
+	if (bodies.length <= 1) return { manufacturability };
+	if (bodies.length > MAX_BODIES) {
+		manufacturability.relationsTruncated = true;
+		return {
+			bodies,
+			manufacturability
+		};
+	}
+	const { relations, truncated } = computeBodyRelations(brep, solids, bodies);
+	if (truncated) manufacturability.relationsTruncated = true;
+	return {
+		bodies,
+		bodyRelations: relations,
+		manufacturability
+	};
+}
+//#endregion
 //#region src/verify/report.ts
 function emptyReport() {
 	return {
@@ -104,6 +297,10 @@ var HINT_TABLE = {
 		fix: "Pass a non-zero thickness to `.extrude(h)` — a height of 0 is a zero-length vector, no solid.",
 		nextStep: "Set a positive extrusion height (units: mm) and re-verify."
 	},
+	DEGENERATE_EDGE: {
+		fix: "A polygon/wire has coincident consecutive points (a zero-length edge). Dedupe the point list before building — common in computed tooth/gear loops where a land and a groove point land on the same coordinate.",
+		nextStep: "Remove duplicate consecutive points from the profile (a tooth’s trailing point is the next tooth’s leading point), then re-verify."
+	},
 	ZERO_OFFSET: {
 		fix: "Offset by a non-zero amount — an offset of 0 is a no-op the kernel rejects.",
 		nextStep: "Use a small non-zero offset (positive grows, negative shrinks) and re-verify."
@@ -264,10 +461,11 @@ function shapeTypeOf(brep, s) {
 	if (isVertex(s)) return "Vertex";
 	return "Unknown";
 }
-function runChecks(brep, shape) {
+function runChecks(brep, shape, opts = {}) {
 	const { isSolid, isShape3D, isFace, measureVolumeProps, measureArea, getBounds, getFaces, getEdges, getWires, getVertices, getSolids, getShells, isManifoldShell, validSolid, isOk } = brep;
 	const r = emptyReport();
 	r.shapeType = shapeTypeOf(brep, shape);
+	const solids = isSolid(shape) ? [shape] : getSolids(shape);
 	if (isSolid(shape)) {
 		const valid = validSolid(shape);
 		const validCheck = {
@@ -282,28 +480,26 @@ function runChecks(brep, shape) {
 			});
 		}
 		r.checks.push(validCheck);
-	} else {
-		const solids = getSolids(shape);
-		if (solids.length > 0) {
-			const failures = [];
-			solids.forEach((s, i) => {
-				const v = validSolid(s);
-				if (!isOk(v)) failures.push(`body ${i}: ${v.error}`);
+	} else if (solids.length > 0) {
+		const failures = [];
+		solids.forEach((s, i) => {
+			const v = validSolid(s);
+			if (!isOk(v)) failures.push(`body ${i}: ${v.error}`);
+		});
+		const bodiesCheck = {
+			name: "allBodiesValid",
+			passed: failures.length === 0
+		};
+		if (failures.length > 0) {
+			bodiesCheck.detail = `${failures.length}/${solids.length} bodies invalid — ${failures.join("; ")}`;
+			r.errorInfos.push({
+				message: `allBodiesValid: ${bodiesCheck.detail}`,
+				code: VALIDITY_FAILURE_CODE
 			});
-			const bodiesCheck = {
-				name: "allBodiesValid",
-				passed: failures.length === 0
-			};
-			if (failures.length > 0) {
-				bodiesCheck.detail = `${failures.length}/${solids.length} bodies invalid — ${failures.join("; ")}`;
-				r.errorInfos.push({
-					message: `allBodiesValid: ${bodiesCheck.detail}`,
-					code: VALIDITY_FAILURE_CODE
-				});
-			}
-			r.checks.push(bodiesCheck);
 		}
+		r.checks.push(bodiesCheck);
 	}
+	if (!isSolid(shape) && solids.length > 1) (r.notes ??= []).push(`shapeType is ${r.shapeType} with ${solids.length} solids. If this is meant to be ONE part, the bodies are NOT welded — give the operands a real overlap and fuseAll(shapes, { unsafe: true }). If it is a deliberate assembly, this is expected. Run --metrics to see whether the bodies touch (a failed weld) or sit apart (an assembly).`);
 	if (isShape3D(shape)) {
 		const volProps = measureVolumeProps(shape);
 		if (isOk(volProps)) {
@@ -340,6 +536,12 @@ function runChecks(brep, shape) {
 		const shells = getShells(shape);
 		if (shells.length > 0) r.topology.manifold = shells.every((s) => isManifoldShell(s));
 	} catch {}
+	if (opts.metrics) try {
+		const m = computeMetrics(brep, shape, solids);
+		if (m.bodies) r.bodies = m.bodies;
+		if (m.bodyRelations) r.bodyRelations = m.bodyRelations;
+		r.manufacturability = m.manufacturability;
+	} catch {}
 	r.hints = buildHints(r);
 	return r;
 }
@@ -625,7 +827,7 @@ function toErrorInfo(prefix, e) {
 		suggestion: e.suggestion
 	};
 	if (e instanceof Error) {
-		const code = e.message.match(/\[[A-Z][A-Z0-9_]*\]\s+([A-Z][A-Z0-9_]+):/)?.[1];
+		const code = e.message.match(/\[[A-Z][A-Z0-9_]*\]\s+([A-Z][A-Z0-9_]+):/)?.[1] ?? classifyKernelMessage(e.message);
 		return code ? {
 			message: `${prefix}: ${e.message}`,
 			code
@@ -633,6 +835,9 @@ function toErrorInfo(prefix, e) {
 	}
 	return { message: `${prefix}: ${String(e)}` };
 }
+function classifyKernelMessage(message) {
+	if (/makeLineEdge: construction failed/i.test(message)) return "DEGENERATE_EDGE";
+}
 function finalize(result) {
 	result.report.hints = buildHints(result.report);
 	return result;
@@ -706,7 +911,7 @@ async function runPart(modulePath, opts = {}) {
 			report
 		});
 	}
-	const result = runChecks(brep, shape);
+	const result = runChecks(brep, shape, { metrics: Boolean(opts.metrics) });
 	if (isExpectedDims(mod.expected)) {
 		const expected = mod.expected;
 		result.assertions = evaluateExpected(expected, result.measurements);