brepjs-verify 0.3.0 → 0.8.0

package/dist/{diff-mxAOOl_m.cjs → diff-DDEu6YJM.cjs}

@@ -164,6 +164,14 @@ var HINT_TABLE = {
 		fix: "The boolean subtraction failed — often a tool that does not actually intersect the base, or tolerance issues.",
 		nextStep: "Confirm the tool overlaps the base, optionally heal the inputs, then re-cut."
 	},
+	FILLET_FAILED: {
+		fix: "The fillet could not be built — usually the radius is too large for an edge it touched (it cannot exceed the adjacent face/wall), or you filleted EVERY edge (the no-edge-list form) including ones too thin to round.",
+		nextStep: "Select only the edges you mean to round — e.g. edgeFinder().inDirection(\"Z\").findAll(solid) — and/or reduce the radius below the thinnest adjacent wall, then re-verify."
+	},
+	CHAMFER_FAILED: {
+		fix: "The chamfer could not be built — usually the distance is too large for an edge it touched, or you chamfered EVERY edge (the no-edge-list form) including ones too thin.",
+		nextStep: "Select only the target edges with an edge finder and/or reduce the distance below the shortest adjacent edge, then re-verify."
+	},
 	BOOLEAN_HAS_ERRORS: {
 		fix: "The boolean ran but the kernel reported errors (often coincident faces or near-tangent contact).",
 		nextStep: "Perturb one operand slightly so contact is a clean overlap, or heal the inputs, then retry."
@@ -199,6 +207,10 @@ var HINT_TABLE = {
 	TYPECHECK: {
 		fix: "Fix the TypeScript type error before running the part — the API call or value does not match brepjs’s types.",
 		nextStep: "Correct the flagged type (e.g. argument/return type or import), then re-verify."
+	},
+	EXPECTED_UNKNOWN_KEY: {
+		fix: "Your `expected` block has keys the CLI does not assert (so the intended check never ran). Bounds must be `{ xMin, xMax, yMin, yMax, zMin, zMax }` — not `{ min, max }` or `{ x, y, z }`.",
+		nextStep: "Rewrite `expected` using only volume, area, tolerancePct, and bounds.{xMin..zMax}, then re-verify."
 	}
 };
 /** Synthetic code attached to validity-check failures (validSolid returns a plain string error). */
@@ -249,7 +261,7 @@ function shapeTypeOf(brep, s) {
 	return "Unknown";
 }
 function runChecks(brep, shape) {
-	const { isSolid, isShape3D, isFace, measureVolume, measureArea, getBounds, validSolid, isOk } = brep;
+	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);
 	if (isSolid(shape)) {
@@ -266,19 +278,41 @@ 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}`);
+			});
+			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);
+		}
 	}
 	if (isShape3D(shape)) {
-		const vol = measureVolume(shape);
-		if (isOk(vol)) {
-			r.measurements.volume = vol.value;
+		const volProps = measureVolumeProps(shape);
+		if (isOk(volProps)) {
+			r.measurements.volume = volProps.value.volume;
+			r.measurements.centerOfMass = volProps.value.centerOfMass;
 			r.checks.push({
 				name: "positiveVolume",
-				passed: vol.value > 0
+				passed: volProps.value.volume > 0
 			});
 		} else pushError(r, {
-			message: `measureVolume: ${vol.error.message}`,
-			code: vol.error.code,
-			suggestion: vol.error.suggestion
+			message: `measureVolume: ${volProps.error.message}`,
+			code: volProps.error.code,
+			suggestion: volProps.error.suggestion
 		});
 	}
 	if (isFace(shape) || isShape3D(shape)) {
@@ -290,6 +324,18 @@ function runChecks(brep, shape) {
 	} catch (e) {
 		pushError(r, { message: `getBounds: ${e.message}` });
 	}
+	try {
+		r.topology = {
+			faceCount: getFaces(shape).length,
+			edgeCount: getEdges(shape).length,
+			wireCount: getWires(shape).length,
+			vertexCount: getVertices(shape).length
+		};
+	} catch {}
+	if (r.topology) try {
+		const shells = getShells(shape);
+		if (shells.length > 0) r.topology.manifold = shells.every((s) => isManifoldShell(s));
+	} catch {}
 	r.hints = buildHints(r);
 	return r;
 }
@@ -302,8 +348,38 @@ function pctDelta(actual, expected) {
 	return Math.abs(actual - expected) / Math.abs(expected) * 100;
 }
 function withinTolerance(actual, expected, tolerancePct) {
+	if (Math.abs(actual - expected) <= 1e-6) return true;
 	return pctDelta(actual, expected) <= tolerancePct;
 }
+var TOP_LEVEL_KEYS = new Set([
+	"volume",
+	"area",
+	"bounds",
+	"tolerancePct"
+]);
+var BOUND_KEYS = new Set([
+	"xMin",
+	"xMax",
+	"yMin",
+	"yMax",
+	"zMin",
+	"zMax"
+]);
+/**
+* Keys in an `expected` block that the CLI does not understand and would silently ignore — a
+* `{ min: [...], max: [...] }` or `{ x: [...] }` bounds shape, or a misspelled top-level field.
+* Surfaced as an error (not dropped) so a wrong `expected` shape fails loud instead of passing
+* vacuously with the intended assertion never run.
+*/
+function unknownExpectedKeys(expected) {
+	const bad = [];
+	for (const k of Object.keys(expected)) if (!TOP_LEVEL_KEYS.has(k)) bad.push(k);
+	const bounds = expected.bounds;
+	if (bounds && typeof bounds === "object") {
+		for (const k of Object.keys(bounds)) if (!BOUND_KEYS.has(k)) bad.push(`bounds.${k}`);
+	}
+	return bad;
+}
 function isExpectedDims(v) {
 	if (typeof v !== "object" || v === null) return false;
 	const r = v;
@@ -427,6 +503,25 @@ var COMPILER_OPTIONS = {
 	skipLibCheck: true,
 	allowImportingTsExtensions: true
 };
+/**
+* Locate the `@types/node` declarations so a part may import Node built-ins (`node:fs` to load a
+* font, `node:fs/promises` to read a STEP file, etc.) without `--check` failing on the import.
+* Returns the `@types` directory to use as a `typeRoots` entry. Probes the tool's own install
+* first (where `@types/node` ships as a dependency), then the part's directory.
+*/
+function nodeTypesRoot(partPath, toolDir) {
+	const froms = [
+		{}.url,
+		toolDir ? (0, node_url.pathToFileURL)((0, node_path.resolve)(toolDir, "package.json")).href : void 0,
+		(0, node_url.pathToFileURL)(partPath).href
+	];
+	for (const from of froms) {
+		if (!from) continue;
+		try {
+			return (0, node_path.dirname)((0, node_path.dirname)((0, node_module.createRequire)(from).resolve("@types/node/package.json")));
+		} catch {}
+	}
+}
 function diagnosticToErrorInfo(d) {
 	const text = typescript.default.flattenDiagnosticMessageText(d.messageText, "\n");
 	let where = "";
@@ -451,6 +546,11 @@ function typecheckPart(partPath, toolDir) {
 	const dts = resolveBrepjsTypes(partPath, toolDir);
 	const options = { ...COMPILER_OPTIONS };
 	if (dts) options.paths = { brepjs: [dts] };
+	const typesRoot = nodeTypesRoot(partPath, toolDir);
+	if (typesRoot) {
+		options.typeRoots = [typesRoot];
+		options.types = ["node"];
+	}
 	const program = typescript.default.createProgram([partPath], options);
 	const errors = [
 		...program.getSemanticDiagnostics(),
@@ -464,6 +564,39 @@ function typecheckPart(partPath, toolDir) {
 }
 //#endregion
 //#region src/verify/runPart.ts
+/** Centroid of a face group's vertices, in part (Z-up, mm) coordinates. */
+function faceCentroid(m, start, count) {
+	let x = 0;
+	let y = 0;
+	let z = 0;
+	for (let i = start; i < start + count; i++) {
+		const vi = (m.triangles[i] ?? 0) * 3;
+		x += m.vertices[vi] ?? 0;
+		y += m.vertices[vi + 1] ?? 0;
+		z += m.vertices[vi + 2] ?? 0;
+	}
+	const n = count || 1;
+	return [
+		x / n,
+		y / n,
+		z / n
+	];
+}
+function buildMaterialMap(m, spec) {
+	if (spec === void 0 || spec === null) return {};
+	if (typeof spec !== "function" && (typeof spec !== "object" || Array.isArray(spec))) return { warning: "export const materials must be a function or a material object — ignored" };
+	const sel = spec;
+	const select = typeof sel === "function" ? sel : () => sel;
+	const map = /* @__PURE__ */ new Map();
+	for (const fg of m.faceGroups) {
+		const mat = select({
+			faceId: fg.faceId,
+			center: faceCentroid(m, fg.start, fg.count)
+		});
+		if (mat) map.set(fg.faceId, mat);
+	}
+	return map.size > 0 ? { map } : {};
+}
 async function loadPart(modulePath) {
 	try {
 		return await import((0, node_url.pathToFileURL)(modulePath).href);
@@ -487,7 +620,13 @@ function toErrorInfo(prefix, e) {
 		code: e.code,
 		suggestion: e.suggestion
 	};
-	if (e instanceof Error) return { message: `${prefix}: ${e.message}` };
+	if (e instanceof Error) {
+		const code = e.message.match(/\[[A-Z][A-Z0-9_]*\]\s+([A-Z][A-Z0-9_]+):/)?.[1];
+		return code ? {
+			message: `${prefix}: ${e.message}`,
+			code
+		} : { message: `${prefix}: ${e.message}` };
+	}
 	return { message: `${prefix}: ${String(e)}` };
 }
 function finalize(result) {
@@ -567,11 +706,22 @@ async function runPart(modulePath, opts = {}) {
 	if (isExpectedDims(mod.expected)) {
 		const expected = mod.expected;
 		result.assertions = evaluateExpected(expected, result.measurements);
+		const unknown = unknownExpectedKeys(expected);
+		if (unknown.length > 0) pushError(result, {
+			message: `expected has unrecognized keys (ignored): ${unknown.join(", ")}. Valid keys: volume, area, tolerancePct, bounds.{xMin,xMax,yMin,yMax,zMin,zMax}.`,
+			code: "EXPECTED_UNKNOWN_KEY"
+		});
 	}
 	let glb;
 	let step;
 	if (opts.glb) try {
-		glb = exportGlb(mesh(shape));
+		const shapeMesh = mesh(shape);
+		const { map, warning } = buildMaterialMap(shapeMesh, mod.materials);
+		if (warning) pushError(result, {
+			message: `materials: ${warning}`,
+			code: "MATERIALS_IGNORED"
+		});
+		glb = map ? exportGlb(shapeMesh, { materials: map }) : exportGlb(shapeMesh);
 	} catch (e) {
 		pushError(result, toErrorInfo("exportGlb", e));
 	}

package/dist/index.d.ts

@@ -2,6 +2,6 @@ export { runPart, type RunPartOptions, type RunPartResult } from './verify/runPa
 export { runChecks } from './verify/checks.js';
 export { runMeasure, type MeasureReport } from './verify/measure.js';
 export { runDiff } from './verify/diff.js';
-export { serializeReport, emptyReport, type VerifyReport, type VerifyCheck, type VerifyMeasurements, type VerifyAssertion, type DiffReport, type BoundsDelta, } from './verify/report.js';
+export { serializeReport, emptyReport, type VerifyReport, type VerifyCheck, type VerifyMeasurements, type VerifyTopology, type VerifyAssertion, type DiffReport, type BoundsDelta, } from './verify/report.js';
 export { typecheckPart, TYPECHECK_CODE, type TypecheckResult } from './verify/typecheck.js';
 export { evaluateExpected, isExpectedDims, pctDelta, DEFAULT_TOLERANCE_PCT, type ExpectedDims, type ExpectedBounds, } from './verify/expected.js';