brepjs-verify 0.2.1

package/dist/diff-CZ4mLtrf.cjs

@@ -0,0 +1,869 @@
+const require_chunk = require("./chunk-D6vf50IK.cjs");
+let node_url = require("node:url");
+let node_module = require("node:module");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let typescript = require("typescript");
+typescript = require_chunk.__toESM(typescript, 1);
+//#region src/verify/brepjsRuntime.ts
+var cached;
+var hookRegistered = false;
+function toolDir() {
+	let dir = (0, node_path.dirname)((0, node_url.fileURLToPath)({}.url));
+	const root = (0, node_path.parse)(dir).root;
+	for (;;) {
+		const pkg = (0, node_path.resolve)(dir, "package.json");
+		if ((0, node_fs.existsSync)(pkg)) try {
+			if (JSON.parse((0, node_fs.readFileSync)(pkg, "utf8")).name === "brepjs-verify") return dir;
+		} catch {}
+		if (dir === root) return dir;
+		dir = (0, node_path.dirname)(dir);
+	}
+}
+function loaderUrl(dir) {
+	const built = (0, node_path.resolve)(dir, "dist", "loader", "brepjsResolve.mjs");
+	const source = (0, node_path.resolve)(dir, "src", "loader", "brepjsResolve.mjs");
+	return (0, node_url.pathToFileURL)((0, node_fs.existsSync)(built) ? built : source).href;
+}
+function registerHook() {
+	if (hookRegistered) return;
+	const dir = toolDir();
+	(0, node_module.register)(loaderUrl(dir), {
+		parentURL: {}.url,
+		data: { toolDir: dir }
+	});
+	hookRegistered = true;
+}
+function loadBrep() {
+	if (!cached) {
+		registerHook();
+		cached = import("brepjs");
+	}
+	return cached;
+}
+//#endregion
+//#region src/verify/report.ts
+function emptyReport() {
+	return {
+		shapeType: null,
+		checks: [],
+		measurements: {},
+		errors: [],
+		errorInfos: [],
+		hints: [],
+		assertions: []
+	};
+}
+function pushError(r, info) {
+	r.errors.push(info.message);
+	r.errorInfos.push(info);
+}
+function reportOk(r) {
+	return r.errors.length === 0 && r.checks.every((c) => c.passed) && r.assertions.every((a) => a.passed);
+}
+/**
+* Local, brepjs-cad-owned advice keyed on `BrepErrorCode` values (see `brepjs`'s public
+* `BrepErrorCode`). Intentionally not importing the library's internal `getSuggestionForCode`:
+* this table is the agent loop's own actionable `fix` + `nextStep` guidance, and the library's
+* public `BrepError.suggestion` is still surfaced alongside it on each hint.
+*/
+var HINT_TABLE = {
+	FILLET_NO_EDGES: {
+		fix: "Select real edges before filleting — pass an edge query (e.g. find edges by direction/position) or a non-empty edge list, not the whole solid.",
+		nextStep: "List the solid’s edges, pick the ones to round, then call fillet(solid, radius, edges)."
+	},
+	CHAMFER_NO_EDGES: {
+		fix: "Select real edges before chamfering — pass a non-empty edge query/list rather than relying on a default that matched nothing.",
+		nextStep: "Enumerate the solid’s edges, choose the target edges, then call chamfer(solid, distance, edges)."
+	},
+	INVALID_FILLET_RADIUS: {
+		fix: "Use a fillet radius that is > 0 and small enough to fit the adjacent faces (well under half the thinnest wall).",
+		nextStep: "Reduce the radius (try a fraction of the smallest local feature size) and re-verify."
+	},
+	INVALID_CHAMFER_DISTANCE: {
+		fix: "Use a chamfer distance that is > 0 and smaller than the adjacent edge lengths.",
+		nextStep: "Lower the distance below the shortest adjacent edge and re-verify."
+	},
+	INVALID_THICKNESS: {
+		fix: "Use a shell/wall thickness that is > 0 and less than half the smallest cross-section.",
+		nextStep: "Reduce the thickness and re-verify, or remove the offending face from the removed-faces set."
+	},
+	ZERO_LENGTH_EXTRUSION: {
+		fix: "Extrude by a non-zero distance — a length of 0 produces no solid.",
+		nextStep: "Set a positive extrusion height (units: mm) and 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."
+	},
+	FILLET_NOT_3D: {
+		fix: "fillet needs a 3D solid. Build the solid (extrude/revolve/box) before rounding edges.",
+		nextStep: "Move the fillet after the solid is created, then fillet the solid’s edges."
+	},
+	CHAMFER_NOT_3D: {
+		fix: "chamfer needs a 3D solid. Build the solid first, then chamfer its edges.",
+		nextStep: "Reorder so chamfer runs on the finished solid, not a sketch/wire/face."
+	},
+	FUSE_NOT_3D: {
+		fix: "fuse needs two 3D solids. Ensure both operands are solids before unioning.",
+		nextStep: "Extrude/loft each profile into a solid first, then fuse and unwrap the Result."
+	},
+	CUT_NOT_3D: {
+		fix: "cut needs 3D solids for both the base and the tool. Build both as solids first.",
+		nextStep: "Make the tool a solid (e.g. a box/cylinder), then cut(base, tool) and unwrap the Result."
+	},
+	INTERSECT_NOT_3D: {
+		fix: "intersect needs two 3D solids. Build both operands as solids first.",
+		nextStep: "Ensure both inputs are solids, then intersect(a, b) and unwrap the Result."
+	},
+	SHELL_NOT_3D: {
+		fix: "shell needs a 3D solid. Create the solid before hollowing it.",
+		nextStep: "Build the solid first, then shell it with a thickness and the faces to remove."
+	},
+	OFFSET_NOT_3D: {
+		fix: "This offset needs a 3D solid. Build the solid before offsetting.",
+		nextStep: "Reorder so offset runs on the solid, then re-verify."
+	},
+	SWEEP_NOT_3D: {
+		fix: "sweep needs a 3D result context — check the profile and path produce a solid sweep.",
+		nextStep: "Verify the profile is a closed wire/face and the path is a valid wire, then re-sweep."
+	},
+	LOFT_NOT_3D: {
+		fix: "loft needs 3D-capable sections. Use closed profiles that can form a solid.",
+		nextStep: "Provide at least two closed section wires/faces, then loft and unwrap the Result."
+	},
+	REVOLUTION_NOT_3D: {
+		fix: "revolve needs a 2D profile revolved about an axis. Pass a face/closed wire.",
+		nextStep: "Use a closed profile and a valid axis, then revolve and unwrap the Result."
+	},
+	LOFT_FAILED: {
+		fix: "The loft could not be built — usually mismatched, self-intersecting, or out-of-order sections.",
+		nextStep: "Make the sections consistent (same orientation, non-self-intersecting, ordered along the loft) and retry."
+	},
+	LOFT_EMPTY: {
+		fix: "loft received too few sections. Provide at least two profiles.",
+		nextStep: "Add the missing section wires/faces and loft again."
+	},
+	SWEEP_FAILED: {
+		fix: "The sweep failed — usually a path with sharp corners/self-intersection or a profile too large for the path curvature.",
+		nextStep: "Smooth or simplify the path, shrink the profile, then re-sweep."
+	},
+	FUSE_FAILED: {
+		fix: "The boolean union failed — often touching-but-not-overlapping solids or tolerance issues.",
+		nextStep: "Make the operands overlap slightly (or heal/translate one), then re-fuse."
+	},
+	CUT_FAILED: {
+		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."
+	},
+	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."
+	},
+	STEP_EXPORT_CRASHED: {
+		fix: "STEP export crashed in the kernel — frequently a disjoint/degenerate fuse or an invalid solid reaching the exporter.",
+		nextStep: "Run validity checks first, heal/simplify the shape (or avoid fusing disjoint solids), then re-export."
+	},
+	STEP_EXPORT_FAILED: {
+		fix: "STEP export failed. The shape is likely invalid or non-manifold.",
+		nextStep: "Fix validity errors (heal/sew) until the solid is valid, then re-export."
+	},
+	STL_EXPORT_CRASHED: {
+		fix: "STL export crashed — usually an invalid or non-manifold mesh source.",
+		nextStep: "Verify the solid is valid and watertight, then re-export."
+	},
+	STL_EXPORT_FAILED: {
+		fix: "STL export failed. The shape is likely invalid or empty.",
+		nextStep: "Fix validity errors first, then re-export."
+	},
+	NULL_SHAPE_INPUT: {
+		fix: "An operation received a null/empty shape. Ensure the previous step actually produced a shape.",
+		nextStep: "Check the upstream Result was unwrapped (not an Err) before passing it on."
+	},
+	NULL_SHAPE: {
+		fix: "An operation produced or received a null shape. A prior step likely failed silently.",
+		nextStep: "Verify each intermediate shape is non-null before chaining the next operation."
+	},
+	VALIDATION_FAILED: {
+		fix: "The shape failed validity (BRepCheck). It is non-manifold, self-intersecting, or has bad geometry.",
+		nextStep: "Heal/sew the shape, or revisit the operation that produced it, until validSolid passes."
+	},
+	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."
+	}
+};
+/** Synthetic code attached to validity-check failures (validSolid returns a plain string error). */
+var VALIDITY_FAILURE_CODE = "VALIDATION_FAILED";
+function hintFor(info) {
+	if (!info.code) return null;
+	const entry = HINT_TABLE[info.code];
+	const fix = entry?.fix ?? info.suggestion ?? "No specific fix available; inspect the error and the operation that produced it.";
+	const nextStep = entry?.nextStep ?? "Adjust the failing operation per the message/suggestion, then re-verify.";
+	return {
+		code: info.code,
+		message: info.message,
+		fix,
+		nextStep
+	};
+}
+function buildHints(r) {
+	const hints = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const info of r.errorInfos) {
+		const hint = hintFor(info);
+		if (!hint) continue;
+		const key = `${hint.code}${hint.message}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		hints.push(hint);
+	}
+	return hints;
+}
+function serializeReport(r) {
+	return JSON.stringify({
+		ok: reportOk(r),
+		...r
+	}, null, 2);
+}
+//#endregion
+//#region src/verify/checks.ts
+function shapeTypeOf(brep, s) {
+	const { isSolid, isFace, isShell, isWire, isEdge, isVertex, isCompound, isCompSolid } = brep;
+	if (isSolid(s)) return "Solid";
+	if (isCompSolid(s)) return "CompSolid";
+	if (isCompound(s)) return "Compound";
+	if (isShell(s)) return "Shell";
+	if (isFace(s)) return "Face";
+	if (isWire(s)) return "Wire";
+	if (isEdge(s)) return "Edge";
+	if (isVertex(s)) return "Vertex";
+	return "Unknown";
+}
+function runChecks(brep, shape) {
+	const { isSolid, isShape3D, isFace, measureVolume, measureArea, getBounds, validSolid, isOk } = brep;
+	const r = emptyReport();
+	r.shapeType = shapeTypeOf(brep, shape);
+	if (isSolid(shape)) {
+		const valid = validSolid(shape);
+		const validCheck = {
+			name: "isValidSolid",
+			passed: isOk(valid)
+		};
+		if (!isOk(valid)) {
+			validCheck.detail = valid.error;
+			r.errorInfos.push({
+				message: `isValidSolid: ${valid.error}`,
+				code: VALIDITY_FAILURE_CODE
+			});
+		}
+		r.checks.push(validCheck);
+	}
+	if (isShape3D(shape)) {
+		const vol = measureVolume(shape);
+		if (isOk(vol)) {
+			r.measurements.volume = vol.value;
+			r.checks.push({
+				name: "positiveVolume",
+				passed: vol.value > 0
+			});
+		} else pushError(r, {
+			message: `measureVolume: ${vol.error.message}`,
+			code: vol.error.code,
+			suggestion: vol.error.suggestion
+		});
+	}
+	if (isFace(shape) || isShape3D(shape)) {
+		const area = measureArea(shape);
+		if (isOk(area)) r.measurements.area = area.value;
+	}
+	try {
+		r.measurements.bounds = getBounds(shape);
+	} catch (e) {
+		pushError(r, { message: `getBounds: ${e.message}` });
+	}
+	r.hints = buildHints(r);
+	return r;
+}
+//#endregion
+//#region src/verify/expected.ts
+var DEFAULT_TOLERANCE_PCT = .5;
+/** Percent deviation of `actual` from `expected`; 0 expected matches only 0 actual. */
+function pctDelta(actual, expected) {
+	if (expected === 0) return actual === 0 ? 0 : Infinity;
+	return Math.abs(actual - expected) / Math.abs(expected) * 100;
+}
+function withinTolerance(actual, expected, tolerancePct) {
+	return pctDelta(actual, expected) <= tolerancePct;
+}
+function isExpectedDims(v) {
+	if (typeof v !== "object" || v === null) return false;
+	const r = v;
+	const numOk = (k) => r[k] === void 0 || typeof r[k] === "number";
+	const boundsOk = r["bounds"] === void 0 || typeof r["bounds"] === "object" && r["bounds"] !== null;
+	return numOk("volume") && numOk("area") && numOk("tolerancePct") && boundsOk;
+}
+function pushAssertion(out, name, expected, actual, tolerancePct) {
+	if (actual === void 0) {
+		out.push({
+			name,
+			expected,
+			actual: null,
+			passed: false
+		});
+		return;
+	}
+	out.push({
+		name,
+		expected,
+		actual,
+		passed: withinTolerance(actual, expected, tolerancePct)
+	});
+}
+/**
+* Compare measured dimensions against a part's `expected` export. Each declared field becomes one
+* assertion; a missing measurement for a declared expectation is a failing assertion (`actual:null`).
+*/
+function evaluateExpected(expected, measurements) {
+	const tol = expected.tolerancePct ?? .5;
+	const assertions = [];
+	if (expected.volume !== void 0) pushAssertion(assertions, "volume", expected.volume, measurements.volume, tol);
+	if (expected.area !== void 0) pushAssertion(assertions, "area", expected.area, measurements.area, tol);
+	if (expected.bounds) {
+		const b = measurements.bounds;
+		for (const key of [
+			"xMin",
+			"xMax",
+			"yMin",
+			"yMax",
+			"zMin",
+			"zMax"
+		]) {
+			const want = expected.bounds[key];
+			if (want === void 0) continue;
+			pushAssertion(assertions, `bounds.${key}`, want, b?.[key], tol);
+		}
+	}
+	return assertions;
+}
+//#endregion
+//#region src/verify/typecheck.ts
+/** Code stamped on every type-check diagnostic so the report/hints can key on it. */
+var TYPECHECK_CODE = "TYPECHECK";
+/**
+* Resolve the `brepjs` declaration entry the part should be checked against. Mirrors the
+* runtime resolve hook's prefer-local-then-bundled policy: try to resolve `brepjs` from the
+* part's own directory first (so authors in a real project type-check against THAT install),
+* and fall back to the bundled copy via `toolDir`.
+*/
+function resolveBrepjsTypes(partPath, toolDir) {
+	const fromPart = brepjsTypesFor((0, node_url.pathToFileURL)(partPath).href);
+	if (fromPart) return fromPart;
+	if (toolDir) {
+		const fromTool = brepjsTypesFor((0, node_url.pathToFileURL)((0, node_path.resolve)(toolDir, "package.json")).href);
+		if (fromTool) return fromTool;
+	}
+}
+function brepjsTypesFor(fromUrl) {
+	let jsEntry;
+	try {
+		jsEntry = (0, node_module.createRequire)(fromUrl).resolve("brepjs");
+	} catch {
+		return;
+	}
+	const pkgDir = packageRootOf((0, node_path.dirname)(jsEntry), "brepjs");
+	if (!pkgDir) return void 0;
+	const pkgPath = (0, node_path.resolve)(pkgDir, "package.json");
+	let pkg;
+	try {
+		pkg = JSON.parse((0, node_fs.readFileSync)(pkgPath, "utf8"));
+	} catch {
+		return;
+	}
+	const rel = typesEntryOf(pkg);
+	if (!rel) return void 0;
+	const abs = (0, node_path.resolve)(pkgDir, rel);
+	return (0, node_fs.existsSync)(abs) ? abs : void 0;
+}
+function typesEntryOf(pkg) {
+	const exportsRoot = pkg.exports?.["."];
+	if (exportsRoot && typeof exportsRoot === "object") {
+		const imp = exportsRoot["import"];
+		if (imp && typeof imp === "object") {
+			const t = imp["types"];
+			if (typeof t === "string") return t;
+		}
+		const t = exportsRoot["types"];
+		if (typeof t === "string") return t;
+	}
+	return typeof pkg.types === "string" ? pkg.types : void 0;
+}
+function packageRootOf(startDir, name) {
+	let dir = startDir;
+	const root = (0, node_path.parse)(dir).root;
+	for (;;) {
+		const pkg = (0, node_path.resolve)(dir, "package.json");
+		if ((0, node_fs.existsSync)(pkg)) try {
+			if (JSON.parse((0, node_fs.readFileSync)(pkg, "utf8")).name === name) return dir;
+		} catch {}
+		if (dir === root) return void 0;
+		dir = (0, node_path.dirname)(dir);
+	}
+}
+var COMPILER_OPTIONS = {
+	target: typescript.default.ScriptTarget.ES2022,
+	module: typescript.default.ModuleKind.ESNext,
+	moduleResolution: typescript.default.ModuleResolutionKind.Bundler,
+	strict: true,
+	noEmit: true,
+	skipLibCheck: true,
+	allowImportingTsExtensions: true
+};
+function diagnosticToErrorInfo(d) {
+	const text = typescript.default.flattenDiagnosticMessageText(d.messageText, "\n");
+	let where = "";
+	if (d.file && typeof d.start === "number") {
+		const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
+		where = `${d.file.fileName}:${line + 1}:${character + 1} `;
+	}
+	return {
+		message: `typecheck: ${where}TS${d.code}: ${text}`,
+		code: TYPECHECK_CODE
+	};
+}
+/**
+* Type-check a single `.brep.ts` part against the bundled (or local) `brepjs` declarations.
+*
+* Uses a synthetic in-memory program: a `paths` mapping points the bare `brepjs` specifier at
+* the resolved `.d.ts`, so the part can be checked without a real install or tsconfig. If the
+* `brepjs` types cannot be resolved, the check is skipped (ok:true, no errors) rather than
+* failing — `--check` should never be worse than not passing it.
+*/
+function typecheckPart(partPath, toolDir) {
+	const dts = resolveBrepjsTypes(partPath, toolDir);
+	const options = { ...COMPILER_OPTIONS };
+	if (dts) options.paths = { brepjs: [dts] };
+	const program = typescript.default.createProgram([partPath], options);
+	const errors = [
+		...program.getSemanticDiagnostics(),
+		...program.getSyntacticDiagnostics(),
+		...program.getGlobalDiagnostics()
+	].filter((d) => d.category === typescript.default.DiagnosticCategory.Error).map(diagnosticToErrorInfo);
+	return {
+		ok: errors.length === 0,
+		errors
+	};
+}
+//#endregion
+//#region src/verify/runPart.ts
+async function loadPart(modulePath) {
+	try {
+		return await import((0, node_url.pathToFileURL)(modulePath).href);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		if (/\.[mc]?tsx?$/.test(modulePath) && /import statement|file extension/i.test(msg)) throw new Error(`cannot load TypeScript part "${modulePath}": author parts in an ESM project (set "type": "module" in package.json) or rename the file to .mts. (${msg})`, { cause: e });
+		throw e;
+	}
+}
+function isResult(v) {
+	return typeof v === "object" && v !== null && "ok" in v && typeof v.ok === "boolean";
+}
+function isBrepError(v) {
+	if (typeof v !== "object" || v === null) return false;
+	const rec = v;
+	return typeof rec["code"] === "string" && typeof rec["message"] === "string";
+}
+function toErrorInfo(prefix, e) {
+	if (isBrepError(e)) return {
+		message: `${prefix}: ${e.message}`,
+		code: e.code,
+		suggestion: e.suggestion
+	};
+	if (e instanceof Error) return { message: `${prefix}: ${e.message}` };
+	return { message: `${prefix}: ${String(e)}` };
+}
+function finalize(result) {
+	result.report.hints = buildHints(result.report);
+	return result;
+}
+async function runPart(modulePath, opts = {}) {
+	const report = emptyReport();
+	if (opts.check) {
+		const tc = typecheckPart(modulePath, toolDir());
+		if (!tc.ok) {
+			for (const e of tc.errors) pushError(report, e);
+			return finalize({
+				shape: null,
+				report
+			});
+		}
+	}
+	let brep;
+	try {
+		brep = await loadBrep();
+		await brep.init();
+	} catch (e) {
+		pushError(report, toErrorInfo("kernel init failed", e));
+		return finalize({
+			shape: null,
+			report
+		});
+	}
+	const { isOk, mesh, exportGlb, exportSTEP } = brep;
+	let mod;
+	try {
+		mod = await loadPart(modulePath);
+	} catch (e) {
+		pushError(report, toErrorInfo("import failed", e));
+		return finalize({
+			shape: null,
+			report
+		});
+	}
+	if (typeof mod.default !== "function") {
+		pushError(report, { message: "module has no default-exported part function" });
+		return finalize({
+			shape: null,
+			report
+		});
+	}
+	let out;
+	try {
+		out = await mod.default();
+	} catch (e) {
+		pushError(report, toErrorInfo("part threw", e));
+		return finalize({
+			shape: null,
+			report
+		});
+	}
+	let shape;
+	if (isResult(out)) {
+		if (!isOk(out)) {
+			pushError(report, toErrorInfo("part returned Err", out.error));
+			return finalize({
+				shape: null,
+				report
+			});
+		}
+		shape = out.value;
+	} else shape = out;
+	if (!shape) {
+		pushError(report, { message: "part produced no shape" });
+		return finalize({
+			shape: null,
+			report
+		});
+	}
+	const result = runChecks(brep, shape);
+	if (isExpectedDims(mod.expected)) {
+		const expected = mod.expected;
+		result.assertions = evaluateExpected(expected, result.measurements);
+	}
+	let glb;
+	let step;
+	if (opts.glb) try {
+		glb = exportGlb(mesh(shape));
+	} catch (e) {
+		pushError(result, toErrorInfo("exportGlb", e));
+	}
+	if (opts.step) {
+		const r = exportSTEP(shape);
+		if (isOk(r)) step = await r.value.arrayBuffer();
+		else pushError(result, toErrorInfo("exportSTEP", r.error));
+	}
+	return finalize({
+		shape,
+		report: result,
+		step,
+		glb
+	});
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.132.0/helpers/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/verify/measure.ts
+async function runMeasure(aPath, bPath) {
+	try {
+		var _usingCtx$2 = _usingCtx();
+		const { measureDistance, measureLength, isOk } = await loadBrep();
+		const errors = [];
+		const a = await runPart(aPath);
+		errors.push(...a.report.errors);
+		if (!a.shape) return { errors };
+		const sa = _usingCtx$2.u(a.shape);
+		if (bPath === void 0) {
+			const len = measureLength(sa);
+			if (isOk(len)) return {
+				length: len.value,
+				errors
+			};
+			errors.push(`measureLength: ${len.error.message}`);
+			return { errors };
+		}
+		const b = await runPart(bPath);
+		errors.push(...b.report.errors);
+		if (!b.shape) return { errors };
+		const dist = measureDistance(sa, _usingCtx$2.u(b.shape));
+		if (isOk(dist)) return {
+			distance: dist.value,
+			errors
+		};
+		errors.push(`measureDistance: ${dist.error.message}`);
+		return { errors };
+	} catch (_) {
+		_usingCtx$2.e = _;
+	} finally {
+		_usingCtx$2.d();
+	}
+}
+//#endregion
+//#region src/verify/diff.ts
+function emptyDiff(errors) {
+	return {
+		volumeDelta: 0,
+		areaDelta: 0,
+		bboxDelta: {
+			xMin: 0,
+			xMax: 0,
+			yMin: 0,
+			yMax: 0,
+			zMin: 0,
+			zMax: 0
+		},
+		symmetricDifferenceVolume: 0,
+		errors
+	};
+}
+function volumeOf(brep, shape, errors) {
+	const v = brep.measureVolume(shape);
+	if (brep.isOk(v)) return v.value;
+	errors.push(`measureVolume: ${v.error.message}`);
+	return 0;
+}
+function areaOf(brep, shape, errors) {
+	if (!brep.isShape3D(shape)) return 0;
+	const a = brep.measureArea(shape);
+	if (brep.isOk(a)) return a.value;
+	errors.push(`measureArea: ${a.error.message}`);
+	return 0;
+}
+function boundsDelta(brep, a, b, errors) {
+	try {
+		const ba = brep.getBounds(a);
+		const bb = brep.getBounds(b);
+		return {
+			xMin: bb.xMin - ba.xMin,
+			xMax: bb.xMax - ba.xMax,
+			yMin: bb.yMin - ba.yMin,
+			yMax: bb.yMax - ba.yMax,
+			zMin: bb.zMin - ba.zMin,
+			zMax: bb.zMax - ba.zMax
+		};
+	} catch (e) {
+		errors.push(`getBounds: ${e.message}`);
+		return {
+			xMin: 0,
+			xMax: 0,
+			yMin: 0,
+			yMax: 0,
+			zMin: 0,
+			zMax: 0
+		};
+	}
+}
+function cutVolume(brep, x, y, errors) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		const r = brep.cut(x, y);
+		if (!brep.isOk(r)) {
+			errors.push(`cut: ${r.error.message}`);
+			return 0;
+		}
+		return volumeOf(brep, _usingCtx$1.u(r.value), errors);
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+async function runDiff(aPath, bPath) {
+	try {
+		var _usingCtx3 = _usingCtx();
+		const brep = await loadBrep();
+		const { isShape3D } = brep;
+		const errors = [];
+		const a = await runPart(aPath);
+		errors.push(...a.report.errors);
+		if (!a.shape) return emptyDiff(errors);
+		const sa = _usingCtx3.u(a.shape);
+		const b = await runPart(bPath);
+		errors.push(...b.report.errors);
+		if (!b.shape) return emptyDiff(errors);
+		const sb = _usingCtx3.u(b.shape);
+		const bboxDelta = boundsDelta(brep, sa, sb, errors);
+		const areaDelta = areaOf(brep, sb, errors) - areaOf(brep, sa, errors);
+		let volumeDelta = 0;
+		let symmetricDifferenceVolume = 0;
+		if (isShape3D(sa) && isShape3D(sb)) {
+			volumeDelta = volumeOf(brep, sb, errors) - volumeOf(brep, sa, errors);
+			symmetricDifferenceVolume = cutVolume(brep, sa, sb, errors) + cutVolume(brep, sb, sa, errors);
+		}
+		return {
+			volumeDelta,
+			areaDelta,
+			bboxDelta,
+			symmetricDifferenceVolume,
+			errors
+		};
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+}
+//#endregion
+Object.defineProperty(exports, "DEFAULT_TOLERANCE_PCT", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_TOLERANCE_PCT;
+	}
+});
+Object.defineProperty(exports, "TYPECHECK_CODE", {
+	enumerable: true,
+	get: function() {
+		return TYPECHECK_CODE;
+	}
+});
+Object.defineProperty(exports, "emptyReport", {
+	enumerable: true,
+	get: function() {
+		return emptyReport;
+	}
+});
+Object.defineProperty(exports, "evaluateExpected", {
+	enumerable: true,
+	get: function() {
+		return evaluateExpected;
+	}
+});
+Object.defineProperty(exports, "isExpectedDims", {
+	enumerable: true,
+	get: function() {
+		return isExpectedDims;
+	}
+});
+Object.defineProperty(exports, "loadBrep", {
+	enumerable: true,
+	get: function() {
+		return loadBrep;
+	}
+});
+Object.defineProperty(exports, "pctDelta", {
+	enumerable: true,
+	get: function() {
+		return pctDelta;
+	}
+});
+Object.defineProperty(exports, "pushError", {
+	enumerable: true,
+	get: function() {
+		return pushError;
+	}
+});
+Object.defineProperty(exports, "reportOk", {
+	enumerable: true,
+	get: function() {
+		return reportOk;
+	}
+});
+Object.defineProperty(exports, "runChecks", {
+	enumerable: true,
+	get: function() {
+		return runChecks;
+	}
+});
+Object.defineProperty(exports, "runDiff", {
+	enumerable: true,
+	get: function() {
+		return runDiff;
+	}
+});
+Object.defineProperty(exports, "runMeasure", {
+	enumerable: true,
+	get: function() {
+		return runMeasure;
+	}
+});
+Object.defineProperty(exports, "runPart", {
+	enumerable: true,
+	get: function() {
+		return runPart;
+	}
+});
+Object.defineProperty(exports, "serializeReport", {
+	enumerable: true,
+	get: function() {
+		return serializeReport;
+	}
+});
+Object.defineProperty(exports, "typecheckPart", {
+	enumerable: true,
+	get: function() {
+		return typecheckPart;
+	}
+});