brepjs-verify 0.2.1

package/dist/disposeShape.d.ts

@@ -0,0 +1 @@
+export declare function disposeShape(shape: unknown): void;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { runPart, type RunPartOptions, type RunPartResult } from './verify/runPart.js';
+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 { typecheckPart, TYPECHECK_CODE, type TypecheckResult } from './verify/typecheck.js';
+export { evaluateExpected, isExpectedDims, pctDelta, DEFAULT_TOLERANCE_PCT, type ExpectedDims, type ExpectedBounds, } from './verify/expected.js';

package/dist/loader/brepjsResolve.mjs

@@ -0,0 +1,57 @@
+import { pathToFileURL } from 'node:url';
+
+// Prefer-local resolution hook for the bundled `brepjs-verify` CLI.
+//
+// The tool bundles its own `brepjs` + `occt-wasm` so it runs standalone, but a part
+// authored inside a real project should bind to THAT project's installed `brepjs`
+// (matching the kernel/types the author develops against). So for every `brepjs` /
+// `occt-wasm` specifier we FIRST try default resolution (which walks the importing
+// module's node_modules and finds a local copy if present); only when that fails do we
+// fall back to the tool's own bundled copy.
+//
+// Critical single-instance property: the bundled fallback always resolves against the
+// SAME tool directory regardless of who imports, so the CLI's own `brepjs` and the
+// part's `import 'brepjs'` collapse to one module URL — one initialized kernel realm.
+
+let toolBaseUrl;
+
+export async function initialize(data) {
+  // `data.toolDir` is the brepjs-verify package root; resolve bundled deps relative to a
+  // file inside it so Node's resolver walks the tool's node_modules.
+  const dir = data && typeof data.toolDir === 'string' ? data.toolDir : undefined;
+  if (dir) {
+    toolBaseUrl = pathToFileURL(
+      dir.endsWith('/') ? dir + 'package.json' : dir + '/package.json'
+    ).href;
+  }
+}
+
+function isManagedSpecifier(specifier) {
+  return (
+    specifier === 'brepjs' ||
+    specifier.startsWith('brepjs/') ||
+    specifier === 'occt-wasm' ||
+    specifier.startsWith('occt-wasm/')
+  );
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  if (!isManagedSpecifier(specifier)) {
+    return nextResolve(specifier, context);
+  }
+  try {
+    // Default resolution: finds a LOCAL brepjs/occt-wasm in the consumer's project.
+    return await nextResolve(specifier, context);
+  } catch (err) {
+    if (!toolBaseUrl) throw err;
+    // Re-run the DEFAULT resolver, but as if the import came from inside the tool's package
+    // (parentURL = the tool's package.json) so it walks the tool's node_modules and honors
+    // package "exports" for subpaths. `import.meta.resolve` is unavailable in the hooks
+    // thread, so this nextResolve-with-rebased-parent is the resolver we have.
+    try {
+      return await nextResolve(specifier, { ...context, parentURL: toolBaseUrl });
+    } catch {
+      throw err;
+    }
+  }
+}

package/dist/snapshot/registry.cjs

@@ -0,0 +1,50 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_snapshot_static = require("./static.cjs");
+//#region src/snapshot/registry.ts
+var DEFAULT_PORT = 7373;
+var PROBE_SPAN = 8;
+var DEFAULT_SHUTDOWN_AFTER_MS = 720 * 60 * 1e3;
+async function probe(port) {
+	const ctrl = new AbortController();
+	const timer = setTimeout(() => ctrl.abort(), 400);
+	try {
+		const res = await fetch(`http://127.0.0.1:${port}/__cad/server`, { signal: ctrl.signal });
+		if (!res.ok) return false;
+		const d = await res.json();
+		return d.app === "brepjs-cad-viewer" && d.dynamicRoot === true && typeof d.serverApiVersion === "number" && d.serverApiVersion >= 1;
+	} catch {
+		return false;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function acquireServer(opts = {}) {
+	const ports = opts.port !== void 0 ? [opts.port] : Array.from({ length: PROBE_SPAN }, (_, i) => DEFAULT_PORT + i);
+	for (const port of ports) if (await probe(port)) return {
+		port,
+		url: `http://127.0.0.1:${port}`,
+		reused: true,
+		close: () => Promise.resolve()
+	};
+	let server;
+	for (const port of ports) try {
+		server = await require_snapshot_static.startStaticServer({ port });
+		break;
+	} catch {}
+	if (!server) throw new Error(`no free port in ${ports[0]}..${ports.at(-1)}`);
+	const timer = setTimeout(() => void server?.close(), opts.shutdownAfterMs ?? 432e5);
+	timer.unref();
+	const started = server;
+	return {
+		port: started.port,
+		url: started.url,
+		reused: false,
+		close: async () => {
+			clearTimeout(timer);
+			await started.close();
+		}
+	};
+}
+//#endregion
+exports.DEFAULT_SHUTDOWN_AFTER_MS = DEFAULT_SHUTDOWN_AFTER_MS;
+exports.acquireServer = acquireServer;

package/dist/snapshot/registry.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_SHUTDOWN_AFTER_MS: number;
+export interface AcquireOptions {
+    port?: number;
+    shutdownAfterMs?: number;
+}
+export interface AcquiredServer {
+    port: number;
+    url: string;
+    reused: boolean;
+    close(): Promise<void>;
+}
+export declare function acquireServer(opts?: AcquireOptions): Promise<AcquiredServer>;

package/dist/snapshot/registry.js

@@ -0,0 +1,48 @@
+import { startStaticServer } from "./static.js";
+//#region src/snapshot/registry.ts
+var DEFAULT_PORT = 7373;
+var PROBE_SPAN = 8;
+var DEFAULT_SHUTDOWN_AFTER_MS = 720 * 60 * 1e3;
+async function probe(port) {
+	const ctrl = new AbortController();
+	const timer = setTimeout(() => ctrl.abort(), 400);
+	try {
+		const res = await fetch(`http://127.0.0.1:${port}/__cad/server`, { signal: ctrl.signal });
+		if (!res.ok) return false;
+		const d = await res.json();
+		return d.app === "brepjs-cad-viewer" && d.dynamicRoot === true && typeof d.serverApiVersion === "number" && d.serverApiVersion >= 1;
+	} catch {
+		return false;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function acquireServer(opts = {}) {
+	const ports = opts.port !== void 0 ? [opts.port] : Array.from({ length: PROBE_SPAN }, (_, i) => DEFAULT_PORT + i);
+	for (const port of ports) if (await probe(port)) return {
+		port,
+		url: `http://127.0.0.1:${port}`,
+		reused: true,
+		close: () => Promise.resolve()
+	};
+	let server;
+	for (const port of ports) try {
+		server = await startStaticServer({ port });
+		break;
+	} catch {}
+	if (!server) throw new Error(`no free port in ${ports[0]}..${ports.at(-1)}`);
+	const timer = setTimeout(() => void server?.close(), opts.shutdownAfterMs ?? 432e5);
+	timer.unref();
+	const started = server;
+	return {
+		port: started.port,
+		url: started.url,
+		reused: false,
+		close: async () => {
+			clearTimeout(timer);
+			await started.close();
+		}
+	};
+}
+//#endregion
+export { DEFAULT_SHUTDOWN_AFTER_MS, acquireServer };

package/dist/snapshot/serve.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_snapshot_registry = require("./registry.cjs");
+let node_path = require("node:path");
+//#region src/snapshot/serve.ts
+function viewerUrl(base, file) {
+	if (!file) return base;
+	const abs = (0, node_path.resolve)(file);
+	return `${base}/?dir=${encodeURIComponent((0, node_path.dirname)(abs))}&file=${encodeURIComponent((0, node_path.basename)(abs))}`;
+}
+/** Acquire (reuse or start) the persistent server and return its viewer URL. */
+async function serve(opts = {}) {
+	const server = await require_snapshot_registry.acquireServer(opts);
+	const url = viewerUrl(server.url, opts.file);
+	if (!server.reused) {
+		const onSig = () => void server.close().then(() => process.exit(0));
+		process.once("SIGINT", onSig);
+		process.once("SIGTERM", onSig);
+	}
+	return {
+		port: server.port,
+		url,
+		reused: server.reused,
+		close: () => server.close()
+	};
+}
+//#endregion
+exports.serve = serve;

package/dist/snapshot/serve.d.ts

@@ -0,0 +1,12 @@
+import { AcquireOptions } from './registry.js';
+export interface ServeOptions extends AcquireOptions {
+    file?: string;
+}
+export interface ServeHandle {
+    port: number;
+    url: string;
+    reused: boolean;
+    close(): Promise<void>;
+}
+/** Acquire (reuse or start) the persistent server and return its viewer URL. */
+export declare function serve(opts?: ServeOptions): Promise<ServeHandle>;

package/dist/snapshot/serve.js

@@ -0,0 +1,26 @@
+import { acquireServer } from "./registry.js";
+import { basename, dirname, resolve } from "node:path";
+//#region src/snapshot/serve.ts
+function viewerUrl(base, file) {
+	if (!file) return base;
+	const abs = resolve(file);
+	return `${base}/?dir=${encodeURIComponent(dirname(abs))}&file=${encodeURIComponent(basename(abs))}`;
+}
+/** Acquire (reuse or start) the persistent server and return its viewer URL. */
+async function serve(opts = {}) {
+	const server = await acquireServer(opts);
+	const url = viewerUrl(server.url, opts.file);
+	if (!server.reused) {
+		const onSig = () => void server.close().then(() => process.exit(0));
+		process.once("SIGINT", onSig);
+		process.once("SIGTERM", onSig);
+	}
+	return {
+		port: server.port,
+		url,
+		reused: server.reused,
+		close: () => server.close()
+	};
+}
+//#endregion
+export { serve };

package/dist/snapshot/shoot.cjs

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("../chunk-D6vf50IK.cjs");
+const require_snapshot_registry = require("./registry.cjs");
+let node_path = require("node:path");
+let node_fs_promises = require("node:fs/promises");
+let puppeteer = require("puppeteer");
+puppeteer = require_chunk.__toESM(puppeteer, 1);
+//#region src/snapshot/shoot.ts
+var VIEWS = [
+	"iso",
+	"front",
+	"top",
+	"right"
+];
+var READY_TIMEOUT_MS = 9e4;
+async function shoot(opts) {
+	const absFile = (0, node_path.resolve)(opts.file);
+	const dir = (0, node_path.dirname)(absFile);
+	const rel = (0, node_path.basename)(absFile);
+	const views = opts.views ?? VIEWS;
+	await (0, node_fs_promises.mkdir)(opts.outDir, { recursive: true });
+	const server = await require_snapshot_registry.acquireServer(opts);
+	const browser = await puppeteer.default.launch({
+		headless: true,
+		args: [
+			"--no-sandbox",
+			"--use-gl=angle",
+			"--use-angle=swiftshader",
+			"--enable-unsafe-swiftshader"
+		]
+	});
+	const pngs = [];
+	try {
+		const page = await browser.newPage();
+		await page.setViewport({
+			width: 1200,
+			height: 900
+		});
+		const target = `${server.url}/?dir=${encodeURIComponent(dir)}&file=${encodeURIComponent(rel)}`;
+		await page.goto(target, {
+			waitUntil: "domcontentloaded",
+			timeout: 3e4
+		});
+		await page.waitForFunction("window.__ready === true", { timeout: READY_TIMEOUT_MS });
+		for (const view of views) {
+			await page.evaluate((v) => {
+				globalThis.__renderView(v);
+			}, view);
+			await new Promise((r) => setTimeout(r, opts.settleMs ?? 400));
+			const path = (0, node_path.resolve)(opts.outDir, `${view}.png`);
+			await page.screenshot({ path });
+			pngs.push(path);
+		}
+	} finally {
+		await browser.close();
+		await server.close();
+	}
+	return {
+		outDir: opts.outDir,
+		pngs
+	};
+}
+//#endregion
+exports.shoot = shoot;

package/dist/snapshot/shoot.d.ts

@@ -0,0 +1,14 @@
+import { AcquireOptions } from './registry.js';
+export type ViewName = 'iso' | 'front' | 'top' | 'right';
+export interface ShootOptions extends AcquireOptions {
+    file: string;
+    outDir: string;
+    views?: readonly ViewName[];
+    /** Wall-clock ms to let the camera settle before each capture (default 400; raise on slow CI). */
+    settleMs?: number;
+}
+export interface ShootResult {
+    outDir: string;
+    pngs: string[];
+}
+export declare function shoot(opts: ShootOptions): Promise<ShootResult>;

package/dist/snapshot/shoot.js

@@ -0,0 +1,61 @@
+import { acquireServer } from "./registry.js";
+import { basename, dirname, resolve } from "node:path";
+import { mkdir } from "node:fs/promises";
+import puppeteer from "puppeteer";
+//#region src/snapshot/shoot.ts
+var VIEWS = [
+	"iso",
+	"front",
+	"top",
+	"right"
+];
+var READY_TIMEOUT_MS = 9e4;
+async function shoot(opts) {
+	const absFile = resolve(opts.file);
+	const dir = dirname(absFile);
+	const rel = basename(absFile);
+	const views = opts.views ?? VIEWS;
+	await mkdir(opts.outDir, { recursive: true });
+	const server = await acquireServer(opts);
+	const browser = await puppeteer.launch({
+		headless: true,
+		args: [
+			"--no-sandbox",
+			"--use-gl=angle",
+			"--use-angle=swiftshader",
+			"--enable-unsafe-swiftshader"
+		]
+	});
+	const pngs = [];
+	try {
+		const page = await browser.newPage();
+		await page.setViewport({
+			width: 1200,
+			height: 900
+		});
+		const target = `${server.url}/?dir=${encodeURIComponent(dir)}&file=${encodeURIComponent(rel)}`;
+		await page.goto(target, {
+			waitUntil: "domcontentloaded",
+			timeout: 3e4
+		});
+		await page.waitForFunction("window.__ready === true", { timeout: READY_TIMEOUT_MS });
+		for (const view of views) {
+			await page.evaluate((v) => {
+				globalThis.__renderView(v);
+			}, view);
+			await new Promise((r) => setTimeout(r, opts.settleMs ?? 400));
+			const path = resolve(opts.outDir, `${view}.png`);
+			await page.screenshot({ path });
+			pngs.push(path);
+		}
+	} finally {
+		await browser.close();
+		await server.close();
+	}
+	return {
+		outDir: opts.outDir,
+		pngs
+	};
+}
+//#endregion
+export { shoot };

package/dist/snapshot/static.cjs

@@ -0,0 +1,100 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_url = require("node:url");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_http = require("node:http");
+let node_fs_promises = require("node:fs/promises");
+//#region src/snapshot/static.ts
+var SERVER_API_VERSION = 1;
+var VIEWER_DIST = (0, node_path.resolve)((0, node_path.dirname)((0, node_url.fileURLToPath)({}.url)), "../../viewer/dist");
+var MIME = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".wasm": "application/wasm",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".glb": "model/gltf-binary",
+	".gltf": "model/gltf+json",
+	".step": "application/step",
+	".stp": "application/step",
+	".stl": "model/stl",
+	".obj": "text/plain; charset=utf-8"
+};
+var mimeFor = (p) => MIME[(0, node_path.extname)(p).toLowerCase()] ?? "application/octet-stream";
+async function sendFile(res, absPath) {
+	const info = await (0, node_fs_promises.stat)(absPath);
+	if (!info.isFile()) {
+		res.writeHead(404).end("not found");
+		return;
+	}
+	res.writeHead(200, {
+		"content-type": mimeFor(absPath),
+		"content-length": info.size
+	});
+	(0, node_fs.createReadStream)(absPath).pipe(res);
+}
+function safeJoin(root, rel) {
+	const abs = (0, node_path.resolve)(root, (0, node_path.normalize)(decodeURIComponent(rel.replace(/^\/+/, ""))));
+	if (abs !== root && !abs.startsWith(root + node_path.sep)) return null;
+	return abs;
+}
+async function handle(req, res, port) {
+	const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+	if (url.pathname === "/__cad/server") {
+		const d = {
+			app: "brepjs-cad-viewer",
+			port,
+			dynamicRoot: true,
+			serverApiVersion: 1
+		};
+		res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+		res.end(JSON.stringify(d));
+		return;
+	}
+	if (url.pathname.startsWith("/__model/")) {
+		const root = url.searchParams.get("dir");
+		if (!root) {
+			res.writeHead(400).end("missing dir");
+			return;
+		}
+		const abs = safeJoin((0, node_path.resolve)(root), url.pathname.slice(8));
+		if (!abs) {
+			res.writeHead(403).end("forbidden");
+			return;
+		}
+		await sendFile(res, abs).catch(() => res.writeHead(404).end("not found"));
+		return;
+	}
+	if (url.searchParams.has("dir") && url.pathname !== "/") {
+		res.writeHead(403).end("forbidden");
+		return;
+	}
+	const abs = safeJoin(VIEWER_DIST, url.pathname === "/" ? "index.html" : url.pathname);
+	if (!abs) {
+		res.writeHead(403).end("forbidden");
+		return;
+	}
+	await sendFile(res, abs).catch(() => sendFile(res, (0, node_path.join)(VIEWER_DIST, "index.html")).catch(() => res.writeHead(404).end("not found")));
+}
+function startStaticServer(opts = {}) {
+	return new Promise((resolvePromise, reject) => {
+		const server = (0, node_http.createServer)((req, res) => {
+			handle(req, res, server.address().port);
+		});
+		server.on("error", reject);
+		server.listen(opts.port ?? 0, "127.0.0.1", () => {
+			const port = server.address().port;
+			resolvePromise({
+				port,
+				url: `http://127.0.0.1:${port}`,
+				close: () => new Promise((done, fail) => server.close((e) => e ? fail(e) : done()))
+			});
+		});
+	});
+}
+//#endregion
+exports.SERVER_API_VERSION = SERVER_API_VERSION;
+exports.startStaticServer = startStaticServer;

package/dist/snapshot/static.d.ts

@@ -0,0 +1,16 @@
+export declare const SERVER_API_VERSION = 1;
+export interface StaticServerOptions {
+    port?: number;
+}
+export interface StaticServer {
+    port: number;
+    url: string;
+    close(): Promise<void>;
+}
+export interface ServerDescriptor {
+    app: 'brepjs-cad-viewer';
+    port: number;
+    dynamicRoot: true;
+    serverApiVersion: number;
+}
+export declare function startStaticServer(opts?: StaticServerOptions): Promise<StaticServer>;

package/dist/snapshot/static.js

@@ -0,0 +1,98 @@
+import { fileURLToPath } from "node:url";
+import { createReadStream } from "node:fs";
+import { dirname, extname, join, normalize, resolve, sep } from "node:path";
+import { createServer } from "node:http";
+import { stat } from "node:fs/promises";
+//#region src/snapshot/static.ts
+var SERVER_API_VERSION = 1;
+var VIEWER_DIST = resolve(dirname(fileURLToPath(import.meta.url)), "../../viewer/dist");
+var MIME = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".wasm": "application/wasm",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".glb": "model/gltf-binary",
+	".gltf": "model/gltf+json",
+	".step": "application/step",
+	".stp": "application/step",
+	".stl": "model/stl",
+	".obj": "text/plain; charset=utf-8"
+};
+var mimeFor = (p) => MIME[extname(p).toLowerCase()] ?? "application/octet-stream";
+async function sendFile(res, absPath) {
+	const info = await stat(absPath);
+	if (!info.isFile()) {
+		res.writeHead(404).end("not found");
+		return;
+	}
+	res.writeHead(200, {
+		"content-type": mimeFor(absPath),
+		"content-length": info.size
+	});
+	createReadStream(absPath).pipe(res);
+}
+function safeJoin(root, rel) {
+	const abs = resolve(root, normalize(decodeURIComponent(rel.replace(/^\/+/, ""))));
+	if (abs !== root && !abs.startsWith(root + sep)) return null;
+	return abs;
+}
+async function handle(req, res, port) {
+	const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+	if (url.pathname === "/__cad/server") {
+		const d = {
+			app: "brepjs-cad-viewer",
+			port,
+			dynamicRoot: true,
+			serverApiVersion: 1
+		};
+		res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+		res.end(JSON.stringify(d));
+		return;
+	}
+	if (url.pathname.startsWith("/__model/")) {
+		const root = url.searchParams.get("dir");
+		if (!root) {
+			res.writeHead(400).end("missing dir");
+			return;
+		}
+		const abs = safeJoin(resolve(root), url.pathname.slice(8));
+		if (!abs) {
+			res.writeHead(403).end("forbidden");
+			return;
+		}
+		await sendFile(res, abs).catch(() => res.writeHead(404).end("not found"));
+		return;
+	}
+	if (url.searchParams.has("dir") && url.pathname !== "/") {
+		res.writeHead(403).end("forbidden");
+		return;
+	}
+	const abs = safeJoin(VIEWER_DIST, url.pathname === "/" ? "index.html" : url.pathname);
+	if (!abs) {
+		res.writeHead(403).end("forbidden");
+		return;
+	}
+	await sendFile(res, abs).catch(() => sendFile(res, join(VIEWER_DIST, "index.html")).catch(() => res.writeHead(404).end("not found")));
+}
+function startStaticServer(opts = {}) {
+	return new Promise((resolvePromise, reject) => {
+		const server = createServer((req, res) => {
+			handle(req, res, server.address().port);
+		});
+		server.on("error", reject);
+		server.listen(opts.port ?? 0, "127.0.0.1", () => {
+			const port = server.address().port;
+			resolvePromise({
+				port,
+				url: `http://127.0.0.1:${port}`,
+				close: () => new Promise((done, fail) => server.close((e) => e ? fail(e) : done()))
+			});
+		});
+	});
+}
+//#endregion
+export { SERVER_API_VERSION, startStaticServer };

package/dist/verify/brepjsRuntime.d.ts

@@ -0,0 +1,4 @@
+import type * as Brep from 'brepjs';
+export type BrepNs = typeof Brep;
+export declare function toolDir(): string;
+export declare function loadBrep(): Promise<BrepNs>;

package/dist/verify/checks.d.ts

@@ -0,0 +1,4 @@
+import { AnyShape } from 'brepjs';
+import { BrepNs } from './brepjsRuntime.js';
+import { VerifyReport } from './report.js';
+export declare function runChecks(brep: BrepNs, shape: AnyShape): VerifyReport;

package/dist/verify/diff.d.ts

@@ -0,0 +1,2 @@
+import { DiffReport } from './report.js';
+export declare function runDiff(aPath: string, bPath: string): Promise<DiffReport>;

package/dist/verify/expected.d.ts

@@ -0,0 +1,26 @@
+import { VerifyAssertion, VerifyMeasurements } from './report.js';
+export interface ExpectedBounds {
+    xMin?: number;
+    xMax?: number;
+    yMin?: number;
+    yMax?: number;
+    zMin?: number;
+    zMax?: number;
+}
+/** Asserted dimensions a part may `export const expected` to gate its own verification. */
+export interface ExpectedDims {
+    volume?: number;
+    area?: number;
+    bounds?: ExpectedBounds;
+    /** Allowed percent deviation for each numeric comparison; defaults to 0.5%. */
+    tolerancePct?: number;
+}
+export declare const DEFAULT_TOLERANCE_PCT = 0.5;
+/** Percent deviation of `actual` from `expected`; 0 expected matches only 0 actual. */
+export declare function pctDelta(actual: number, expected: number): number;
+export declare function isExpectedDims(v: unknown): v is ExpectedDims;
+/**
+ * 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`).
+ */
+export declare function evaluateExpected(expected: ExpectedDims, measurements: VerifyMeasurements): VerifyAssertion[];

package/dist/verify/measure.d.ts

@@ -0,0 +1,6 @@
+export interface MeasureReport {
+    length?: number;
+    distance?: number;
+    errors: string[];
+}
+export declare function runMeasure(aPath: string, bPath?: string): Promise<MeasureReport>;