brepjs-cad 0.174.0 → 0.175.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.175.0](https://github.com/andymai/brepjs/compare/brepjs-cad-v0.174.0...brepjs-cad-v0.175.0) (2026-08-26)
+
+
+### Features
+
+* **brepjs-cad:** transpiling loader for multi-file TS/TSX projects + working watch ([#2228](https://github.com/andymai/brepjs/issues/2228)) ([980ead6](https://github.com/andymai/brepjs/commit/980ead6508867c31fcec1fd06a683f03bacb1e6f))
+
 ## [0.174.0](https://github.com/andymai/brepjs/compare/brepjs-cad-v0.173.0...brepjs-cad-v0.174.0) (2026-08-22)
 
 

package/dist/brepjs-cad.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_diff = require("./diff-DDu3OLyd.cjs");
+const require_diff = require("./diff-DX9zgrss.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-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-CRu6Pqyr.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-B1sSWjLa.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-DDu3OLyd.cjs");
+const require_diff = require("../diff-DX9zgrss.cjs");
 let node_url = require("node:url");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
@@ -117,6 +117,74 @@ function debounce(fn, delayMs = 150) {
 		cancel
 	};
 }
+var SOURCE_FILE_RE = /\.(?:m?[jt]s|[jt]sx)$/;
+function isWatchRelevant(filename) {
+	if (filename === void 0 || filename === null) return true;
+	const name = filename.toString();
+	if (/(?:^|[\\/])tsconfig(?:\..+)?\.json$/.test(name)) return true;
+	return SOURCE_FILE_RE.test(name);
+}
+/**
+* Root the watcher at the project, not the entry's own directory: with the common
+* `src/main.ts` layout, tsconfig.json (whose JSX options change how sources transpile)
+* and `../` imports live one level up. Nearest package.json or tsconfig.json walking up
+* wins; entries with no project marker fall back to their own directory.
+*/
+function watchRootFor(entryPath) {
+	const start = (0, node_path.dirname)(entryPath);
+	let dir = start;
+	for (;;) {
+		if ((0, node_fs.existsSync)((0, node_path.join)(dir, "package.json")) || (0, node_fs.existsSync)((0, node_path.join)(dir, "tsconfig.json"))) return dir;
+		const parent = (0, node_path.dirname)(dir);
+		if (parent === dir) return start;
+		dir = parent;
+	}
+}
+var IGNORED_DIR_NAMES = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	".git"
+]);
+/**
+* Watch a directory tree with one non-recursive `fs.watch` per directory, skipping
+* node_modules/dist/.git and never following symlinks. `fs.watch({recursive})` has no
+* exclusion API, so on a real project it would descend into node_modules — tens of
+* thousands of inotify watches. Whenever an event fires in a directory it is re-scanned,
+* which picks up newly created subdirectories. Returns a stop function.
+*/
+function watchTree(root, onEvent) {
+	const watchers = /* @__PURE__ */ new Map();
+	const add = (dir) => {
+		if (watchers.has(dir)) return;
+		try {
+			watchers.set(dir, (0, node_fs.watch)(dir, (_event, filename) => {
+				scan(dir);
+				onEvent(filename);
+			}));
+		} catch {}
+	};
+	const scan = (dir) => {
+		let entries;
+		try {
+			entries = (0, node_fs.readdirSync)(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || IGNORED_DIR_NAMES.has(entry.name)) continue;
+			const child = (0, node_path.join)(dir, entry.name);
+			if (watchers.has(child)) continue;
+			add(child);
+			scan(child);
+		}
+	};
+	add(root);
+	scan(root);
+	return () => {
+		for (const watcher of watchers.values()) watcher.close();
+		watchers.clear();
+	};
+}
 //#endregion
 //#region src/disposeShape.ts
 function disposeShape(shape) {
@@ -436,9 +504,9 @@ program.command("init").argument("<name>", "part name; scaffolds <name>.brep.ts
 });
 program.command("watch").argument("<file>", "path to a .brep.ts module; re-verifies on each save until Ctrl-C").action((file) => {
 	const path = (0, node_path.resolve)(file);
-	const run = async () => {
+	const run = async (fresh) => {
 		try {
-			const { report, shape } = await require_diff.runPart(path);
+			const { report, shape } = await require_diff.runPart(path, { freshImport: fresh });
 			try {
 				process.stdout.write(require_diff.serializeReport(report) + "\n");
 			} finally {
@@ -448,18 +516,33 @@ program.command("watch").argument("<file>", "path to a .brep.ts module; re-verif
 			process.stderr.write(`watch run failed: ${e.message}\n`);
 		}
 	};
-	const { trigger } = debounce(run, 150);
-	process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
-	run();
-	const watcher = (0, node_fs.watch)((0, node_path.dirname)(path), (_event, filename) => {
-		if (filename === void 0 || filename === null) {
-			trigger();
+	let inFlight = false;
+	let rerunQueued = false;
+	const start = (fresh) => {
+		inFlight = true;
+		run(fresh).finally(() => {
+			inFlight = false;
+			if (rerunQueued) {
+				rerunQueued = false;
+				start(true);
+			}
+		});
+	};
+	const schedule = () => {
+		if (inFlight) {
+			rerunQueued = true;
 			return;
 		}
-		if ((0, node_path.basename)(path) === filename.toString()) trigger();
+		start(true);
+	};
+	const { trigger } = debounce(schedule, 150);
+	process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
+	start(false);
+	const stopWatching = watchTree(watchRootFor(path), (filename) => {
+		if (isWatchRelevant(filename)) trigger();
 	});
 	const stop = () => {
-		watcher.close();
+		stopWatching();
 		process.exit(0);
 	};
 	process.on("SIGINT", stop);

package/dist/cli/main.js

@@ -1,7 +1,7 @@
 #!/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-CRu6Pqyr.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-B1sSWjLa.js";
 import { fileURLToPath } from "node:url";
-import { existsSync, globSync, mkdirSync, realpathSync, watch, writeFileSync } from "node:fs";
+import { existsSync, globSync, mkdirSync, readdirSync, realpathSync, watch, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { Command } from "commander";
 import { tmpdir } from "node:os";
@@ -116,6 +116,74 @@ function debounce(fn, delayMs = 150) {
 		cancel
 	};
 }
+var SOURCE_FILE_RE = /\.(?:m?[jt]s|[jt]sx)$/;
+function isWatchRelevant(filename) {
+	if (filename === void 0 || filename === null) return true;
+	const name = filename.toString();
+	if (/(?:^|[\\/])tsconfig(?:\..+)?\.json$/.test(name)) return true;
+	return SOURCE_FILE_RE.test(name);
+}
+/**
+* Root the watcher at the project, not the entry's own directory: with the common
+* `src/main.ts` layout, tsconfig.json (whose JSX options change how sources transpile)
+* and `../` imports live one level up. Nearest package.json or tsconfig.json walking up
+* wins; entries with no project marker fall back to their own directory.
+*/
+function watchRootFor(entryPath) {
+	const start = dirname(entryPath);
+	let dir = start;
+	for (;;) {
+		if (existsSync(join(dir, "package.json")) || existsSync(join(dir, "tsconfig.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return start;
+		dir = parent;
+	}
+}
+var IGNORED_DIR_NAMES = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	".git"
+]);
+/**
+* Watch a directory tree with one non-recursive `fs.watch` per directory, skipping
+* node_modules/dist/.git and never following symlinks. `fs.watch({recursive})` has no
+* exclusion API, so on a real project it would descend into node_modules — tens of
+* thousands of inotify watches. Whenever an event fires in a directory it is re-scanned,
+* which picks up newly created subdirectories. Returns a stop function.
+*/
+function watchTree(root, onEvent) {
+	const watchers = /* @__PURE__ */ new Map();
+	const add = (dir) => {
+		if (watchers.has(dir)) return;
+		try {
+			watchers.set(dir, watch(dir, (_event, filename) => {
+				scan(dir);
+				onEvent(filename);
+			}));
+		} catch {}
+	};
+	const scan = (dir) => {
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || IGNORED_DIR_NAMES.has(entry.name)) continue;
+			const child = join(dir, entry.name);
+			if (watchers.has(child)) continue;
+			add(child);
+			scan(child);
+		}
+	};
+	add(root);
+	scan(root);
+	return () => {
+		for (const watcher of watchers.values()) watcher.close();
+		watchers.clear();
+	};
+}
 //#endregion
 //#region src/disposeShape.ts
 function disposeShape(shape) {
@@ -435,9 +503,9 @@ program.command("init").argument("<name>", "part name; scaffolds <name>.brep.ts
 });
 program.command("watch").argument("<file>", "path to a .brep.ts module; re-verifies on each save until Ctrl-C").action((file) => {
 	const path = resolve(file);
-	const run = async () => {
+	const run = async (fresh) => {
 		try {
-			const { report, shape } = await runPart(path);
+			const { report, shape } = await runPart(path, { freshImport: fresh });
 			try {
 				process.stdout.write(serializeReport(report) + "\n");
 			} finally {
@@ -447,18 +515,33 @@ program.command("watch").argument("<file>", "path to a .brep.ts module; re-verif
 			process.stderr.write(`watch run failed: ${e.message}\n`);
 		}
 	};
-	const { trigger } = debounce(run, 150);
-	process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
-	run();
-	const watcher = watch(dirname(path), (_event, filename) => {
-		if (filename === void 0 || filename === null) {
-			trigger();
+	let inFlight = false;
+	let rerunQueued = false;
+	const start = (fresh) => {
+		inFlight = true;
+		run(fresh).finally(() => {
+			inFlight = false;
+			if (rerunQueued) {
+				rerunQueued = false;
+				start(true);
+			}
+		});
+	};
+	const schedule = () => {
+		if (inFlight) {
+			rerunQueued = true;
 			return;
 		}
-		if (basename(path) === filename.toString()) trigger();
+		start(true);
+	};
+	const { trigger } = debounce(schedule, 150);
+	process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
+	start(false);
+	const stopWatching = watchTree(watchRootFor(path), (filename) => {
+		if (isWatchRelevant(filename)) trigger();
 	});
 	const stop = () => {
-		watcher.close();
+		stopWatching();
 		process.exit(0);
 	};
 	process.on("SIGINT", stop);

package/dist/cli/watch.d.ts

@@ -3,3 +3,19 @@ export declare function debounce(fn: () => void | Promise<void>, delayMs?: numbe
     trigger: () => void;
     cancel: () => void;
 };
+export declare function isWatchRelevant(filename: string | Buffer | null | undefined): boolean;
+/**
+ * Root the watcher at the project, not the entry's own directory: with the common
+ * `src/main.ts` layout, tsconfig.json (whose JSX options change how sources transpile)
+ * and `../` imports live one level up. Nearest package.json or tsconfig.json walking up
+ * wins; entries with no project marker fall back to their own directory.
+ */
+export declare function watchRootFor(entryPath: string): string;
+/**
+ * Watch a directory tree with one non-recursive `fs.watch` per directory, skipping
+ * node_modules/dist/.git and never following symlinks. `fs.watch({recursive})` has no
+ * exclusion API, so on a real project it would descend into node_modules — tens of
+ * thousands of inotify watches. Whenever an event fires in a directory it is re-scanned,
+ * which picks up newly created subdirectories. Returns a stop function.
+ */
+export declare function watchTree(root: string, onEvent: (filename: string | Buffer | null | undefined) => void): () => void;

package/dist/{diff-CRu6Pqyr.js → diff-B1sSWjLa.js}

@@ -19,8 +19,9 @@ function toolDir() {
 	}
 }
 function loaderUrl(dir) {
-	const built = resolve(dir, "dist", "loader", "brepjsResolve.mjs");
 	const source = resolve(dir, "src", "loader", "brepjsResolve.mjs");
+	const built = resolve(dir, "dist", "loader", "brepjsResolve.mjs");
+	if (import.meta.url.startsWith(pathToFileURL(resolve(dir, "src") + "/").href)) return pathToFileURL(source).href;
 	return pathToFileURL(existsSync(built) ? built : source).href;
 }
 function registerHook() {
@@ -696,6 +697,33 @@ function packageRootOf(startDir, name) {
 		dir = dirname(dir);
 	}
 }
+/**
+* JSX options for a part come from the nearest tsconfig.json — the same source the
+* runtime load hook reads — so `--check` and execution agree on the dialect
+* (families projects set `jsx: react-jsx` + `jsxImportSource: brepjs-families`).
+* A `.tsx` part with nothing configured defaults to the automatic runtime.
+*/
+function jsxCompilerOptions(partPath) {
+	const out = {};
+	const configPath = ts.findConfigFile(dirname(partPath), (f) => ts.sys.fileExists(f));
+	if (configPath) {
+		const host = {
+			...ts.sys,
+			onUnRecoverableConfigFileDiagnostic: () => {}
+		};
+		const parsed = ts.getParsedCommandLineOfConfigFile(configPath, void 0, host);
+		if (parsed) {
+			for (const key of [
+				"jsx",
+				"jsxImportSource",
+				"jsxFactory",
+				"jsxFragmentFactory"
+			]) if (parsed.options[key] !== void 0) out[key] = parsed.options[key];
+		}
+	}
+	if (partPath.endsWith(".tsx") && out.jsx === void 0) out.jsx = ts.JsxEmit.ReactJSX;
+	return out;
+}
 var COMPILER_OPTIONS = {
 	target: ts.ScriptTarget.ES2022,
 	module: ts.ModuleKind.ESNext,
@@ -747,7 +775,10 @@ function diagnosticToErrorInfo(d) {
 */
 function typecheckPart(partPath, toolDir) {
 	const dts = resolveBrepjsTypes(partPath, toolDir);
-	const options = { ...COMPILER_OPTIONS };
+	const options = {
+		...COMPILER_OPTIONS,
+		...jsxCompilerOptions(partPath)
+	};
 	if (dts) options.paths = { brepjs: [dts] };
 	const typesRoot = nodeTypesRoot(partPath, toolDir);
 	if (typesRoot) {
@@ -800,12 +831,15 @@ function buildMaterialMap(m, spec) {
 	}
 	return map.size > 0 ? { map } : {};
 }
-async function loadPart(modulePath) {
+var importGeneration = 0;
+async function loadPart(modulePath, fresh = false) {
+	const url = new URL(pathToFileURL(modulePath).href);
+	if (fresh) url.searchParams.set("v", String(++importGeneration));
 	try {
-		return await import(pathToFileURL(modulePath).href);
+		return await import(url.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 });
+		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). (${msg})`, { cause: e });
 		throw e;
 	}
 }
@@ -865,7 +899,7 @@ async function runPart(modulePath, opts = {}) {
 	const { isOk, mesh, exportGlb, exportSTEP } = brep;
 	let mod;
 	try {
-		mod = await loadPart(modulePath);
+		mod = await loadPart(modulePath, opts.freshImport);
 	} catch (e) {
 		pushError(report, toErrorInfo("import failed", e));
 		return finalize({

package/dist/{diff-DDu3OLyd.cjs → diff-DX9zgrss.cjs}

@@ -21,8 +21,9 @@ function toolDir() {
 	}
 }
 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");
+	const built = (0, node_path.resolve)(dir, "dist", "loader", "brepjsResolve.mjs");
+	if ({}.url.startsWith((0, node_url.pathToFileURL)((0, node_path.resolve)(dir, "src") + "/").href)) return (0, node_url.pathToFileURL)(source).href;
 	return (0, node_url.pathToFileURL)((0, node_fs.existsSync)(built) ? built : source).href;
 }
 function registerHook() {
@@ -698,6 +699,33 @@ function packageRootOf(startDir, name) {
 		dir = (0, node_path.dirname)(dir);
 	}
 }
+/**
+* JSX options for a part come from the nearest tsconfig.json — the same source the
+* runtime load hook reads — so `--check` and execution agree on the dialect
+* (families projects set `jsx: react-jsx` + `jsxImportSource: brepjs-families`).
+* A `.tsx` part with nothing configured defaults to the automatic runtime.
+*/
+function jsxCompilerOptions(partPath) {
+	const out = {};
+	const configPath = typescript.default.findConfigFile((0, node_path.dirname)(partPath), (f) => typescript.default.sys.fileExists(f));
+	if (configPath) {
+		const host = {
+			...typescript.default.sys,
+			onUnRecoverableConfigFileDiagnostic: () => {}
+		};
+		const parsed = typescript.default.getParsedCommandLineOfConfigFile(configPath, void 0, host);
+		if (parsed) {
+			for (const key of [
+				"jsx",
+				"jsxImportSource",
+				"jsxFactory",
+				"jsxFragmentFactory"
+			]) if (parsed.options[key] !== void 0) out[key] = parsed.options[key];
+		}
+	}
+	if (partPath.endsWith(".tsx") && out.jsx === void 0) out.jsx = typescript.default.JsxEmit.ReactJSX;
+	return out;
+}
 var COMPILER_OPTIONS = {
 	target: typescript.default.ScriptTarget.ES2022,
 	module: typescript.default.ModuleKind.ESNext,
@@ -749,7 +777,10 @@ function diagnosticToErrorInfo(d) {
 */
 function typecheckPart(partPath, toolDir) {
 	const dts = resolveBrepjsTypes(partPath, toolDir);
-	const options = { ...COMPILER_OPTIONS };
+	const options = {
+		...COMPILER_OPTIONS,
+		...jsxCompilerOptions(partPath)
+	};
 	if (dts) options.paths = { brepjs: [dts] };
 	const typesRoot = nodeTypesRoot(partPath, toolDir);
 	if (typesRoot) {
@@ -802,12 +833,15 @@ function buildMaterialMap(m, spec) {
 	}
 	return map.size > 0 ? { map } : {};
 }
-async function loadPart(modulePath) {
+var importGeneration = 0;
+async function loadPart(modulePath, fresh = false) {
+	const url = new URL((0, node_url.pathToFileURL)(modulePath).href);
+	if (fresh) url.searchParams.set("v", String(++importGeneration));
 	try {
-		return await import((0, node_url.pathToFileURL)(modulePath).href);
+		return await import(url.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 });
+		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). (${msg})`, { cause: e });
 		throw e;
 	}
 }
@@ -867,7 +901,7 @@ async function runPart(modulePath, opts = {}) {
 	const { isOk, mesh, exportGlb, exportSTEP } = brep;
 	let mod;
 	try {
-		mod = await loadPart(modulePath);
+		mod = await loadPart(modulePath, opts.freshImport);
 	} catch (e) {
 		pushError(report, toErrorInfo("import failed", e));
 		return finalize({

package/dist/loader/brepjsResolve.mjs

@@ -1,4 +1,6 @@
-import { pathToFileURL } from 'node:url';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 
 // Prefer-local resolution hook for the bundled `brep` CLI.
 //
@@ -12,6 +14,13 @@ import { pathToFileURL } from 'node:url';
 // 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.
+//
+// The same hook also carries a `load` hook that transpiles `.ts`/`.mts`/`.tsx` sources
+// (Node's native type-stripping cannot load `.tsx` at all), and a relative-specifier
+// fallback that maps `./dep.js` onto an on-disk `dep.ts`/`dep.tsx` (house style writes
+// `.js` specifiers over TS sources; Node does not do this mapping). Keeping all of this
+// in the ONE registered hook — instead of reaching for tsx — is what preserves the
+// single-realm property above.
 
 let toolBaseUrl;
 
@@ -35,23 +44,149 @@ function isManagedSpecifier(specifier) {
   );
 }
 
-export async function resolve(specifier, context, nextResolve) {
-  if (!isManagedSpecifier(specifier)) {
-    return nextResolve(specifier, context);
+// Watch/preview cache-busting: the ESM module cache is keyed by full URL, so a rerun
+// that re-imports the same file URL re-executes the FIRST version forever. The watch
+// loop imports the entry with `?v=N`; propagating that query to every user-space file
+// the entry (transitively) imports makes each rerun a fresh module graph. Bare and
+// managed specifiers are never versioned, so `brepjs`/`occt-wasm` keep their stable
+// URLs and the initialized kernel realm survives across reruns.
+function versionParam(parentURL) {
+  if (!parentURL || !parentURL.startsWith('file:')) return undefined;
+  try {
+    return new URL(parentURL).searchParams.get('v') ?? undefined;
+  } catch {
+    return undefined;
   }
+}
+
+function withInheritedVersion(resolution, version) {
+  const url = resolution && resolution.url;
+  if (!version || !url || !url.startsWith('file:') || url.includes('/node_modules/')) {
+    return resolution;
+  }
+  const u = new URL(url);
+  u.searchParams.set('v', version);
+  return { ...resolution, url: u.href };
+}
+
+async function resolveWithTsFallback(specifier, context, nextResolve) {
   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.
+    if (specifier.endsWith('.js')) {
+      const stem = specifier.slice(0, -'.js'.length);
+      for (const ext of ['.ts', '.tsx']) {
+        try {
+          return await nextResolve(stem + ext, context);
+        } catch {
+          // keep trying
+        }
+      }
+    }
+    throw err;
+  }
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  if (isManagedSpecifier(specifier)) {
     try {
-      return await nextResolve(specifier, { ...context, parentURL: toolBaseUrl });
-    } catch {
-      throw err;
+      // 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;
+      }
+    }
+  }
+  if (!specifier.startsWith('./') && !specifier.startsWith('../')) {
+    return nextResolve(specifier, context);
+  }
+  const version = versionParam(context.parentURL);
+  return withInheritedVersion(
+    await resolveWithTsFallback(specifier, context, nextResolve),
+    version
+  );
+}
+
+// --- TypeScript loading ---------------------------------------------------------------
+
+// `typescript` is already a runtime dependency (the `--check` path imports it on the main
+// thread); here it loads lazily in the hooks thread only when a TS source is actually
+// imported, so pure-JS projects never pay for it.
+let tsPromise;
+
+function loadTypescript() {
+  tsPromise ??= import('typescript').then((mod) => mod.default ?? mod);
+  return tsPromise;
+}
+
+// JSX cannot be transpiled without knowing the project's dialect (families projects set
+// `jsx: react-jsx` + `jsxImportSource: brepjs-families`), so read it from the nearest
+// tsconfig.json — the same file the author's editor uses. Cached per directory; config
+// parsing honors `extends`.
+const jsxOptionsCache = new Map();
+
+// Each watch rerun imports with a fresh `?v=N`; treat a new generation as a config
+// epoch so tsconfig edits made between reruns are picked up instead of served stale.
+let jsxOptionsGeneration;
+
+function bumpJsxOptionsGeneration(version) {
+  if (version !== null && version !== jsxOptionsGeneration) {
+    jsxOptionsGeneration = version;
+    jsxOptionsCache.clear();
+  }
+}
+
+function jsxOptionsFor(ts, filePath) {
+  const dir = dirname(filePath);
+  const cached = jsxOptionsCache.get(dir);
+  if (cached) return cached;
+  const options = {};
+  const configPath = ts.findConfigFile(dir, ts.sys.fileExists);
+  if (configPath) {
+    const host = { ...ts.sys, onUnRecoverableConfigFileDiagnostic: () => {} };
+    const parsed = ts.getParsedCommandLineOfConfigFile(configPath, undefined, host);
+    if (parsed) {
+      for (const key of ['jsx', 'jsxImportSource', 'jsxFactory', 'jsxFragmentFactory']) {
+        if (parsed.options[key] !== undefined) options[key] = parsed.options[key];
+      }
     }
   }
+  jsxOptionsCache.set(dir, options);
+  return options;
+}
+
+const TS_SOURCE_RE = /\.(?:ts|mts|tsx)$/;
+const DECLARATION_RE = /\.d\.(?:ts|mts)$/;
+
+export async function load(url, context, nextLoad) {
+  if (!url.startsWith('file:')) return nextLoad(url, context);
+  const parsed = new URL(url);
+  if (!TS_SOURCE_RE.test(parsed.pathname) || DECLARATION_RE.test(parsed.pathname)) {
+    return nextLoad(url, context);
+  }
+  const filePath = fileURLToPath(parsed);
+  const source = readFileSync(filePath, 'utf8');
+  const ts = await loadTypescript();
+  bumpJsxOptionsGeneration(parsed.searchParams.get('v'));
+  const { outputText } = ts.transpileModule(source, {
+    fileName: filePath,
+    compilerOptions: {
+      module: ts.ModuleKind.ESNext,
+      target: ts.ScriptTarget.ES2022,
+      // A .tsx with no configured dialect still needs SOME emit mode; the automatic
+      // runtime is TS's modern default recommendation and what the scaffold ships.
+      ...(parsed.pathname.endsWith('.tsx') ? { jsx: ts.JsxEmit.ReactJSX } : {}),
+      ...jsxOptionsFor(ts, filePath),
+      inlineSourceMap: true,
+    },
+  });
+  return { format: 'module', source: outputText, shortCircuit: true };
 }

package/dist/mcp/server.cjs

@@ -43,9 +43,9 @@ function positiveOrDefault(value, fallback) {
 	return value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
 }
 function defaultCliEntry() {
-	const builtJs = (0, node_url.fileURLToPath)(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, watch as fsWatch, realpathSync, globSync } from 'node:fs';
import { resolve, join, basename, dirname } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport, type VerifyReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import { debounce, DEFAULT_DEBOUNCE_MS } from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';
import { aimedSection, featureMarks } from '../snapshot/aiming.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const 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'
  )
  .option(
    '--metrics',
    'compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default'
  )
  .action(
    async (
      files: string[],
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        expectCode?: string;
        expectInvalid?: boolean;
        metrics?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // A quoted glob ("parts/*.brep.ts") arrives as one literal arg, a shell-expanded one as many;
      // globSync handles both (a literal filename matches itself), falling back to the raw arg so a
      // missing path still runs and reports its own error.
      const targets = [
        ...new Set(
          files.flatMap((f) => {
            const m = globSync(f);
            return m.length ? m : [f];
          })
        ),
      ].map((p) => resolve(p));

      if (targets.length > 1) {
        // Batch: validity-only JSON array. The single-file artifact flags don't apply.
        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: { file: string; ok: boolean; report: VerifyReport }[] = [];
        for (const f of targets) {
          const { report, shape } = await runPart(f, {
            check: Boolean(opts.check),
            metrics: Boolean(opts.metrics),
          });
          disposeShape(shape);
          results.push({ file: f, ok: reportOk(report), report });
        }
        const json = JSON.stringify(results, null, 2);
        if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
        process.stdout.write(json + '\n');
        if (results.some((r) => !r.ok)) process.exitCode = 1;
        return;
      }

      const file = targets[0] ?? files[0] ?? '';
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
        // A snapshot feeds the design judge, so compute metrics too (bores → an aimed section shot).
        metrics: Boolean(opts.metrics) || Boolean(opts.snapshot),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brep-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          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,
              ...(section ? { section } : {}),
              ...(marks.length > 0 ? { marks } : {}),
            });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      // `--json -` is satisfied by the stdout write below; only a real path writes a file.
      if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      // Fixture assertions (Phase: verify-heal precision/recall) override the normal exit code:
      // a known-bad part must fail the *right* way. Codes come from the kernel/authoring errors,
      // not the hint table, so this measures the verifier, not its prose.
      if (opts.expectInvalid || opts.expectCode) {
        // hints are derived from errorInfos, so the codes live there; dedupe to keep the line clean.
        const codes = [
          ...new Set(report.errorInfos.map((e) => e.code).filter((c): c is string => Boolean(c))),
        ];
        const valid = reportOk(report);
        const pass =
          (!opts.expectInvalid || !valid) && (!opts.expectCode || codes.includes(opts.expectCode));
        process.exitCode = pass ? 0 : 1;
        process.stderr.write(
          `expect: ${pass ? 'PASS' : 'FAIL'}` +
            (opts.expectCode ? ` code=${opts.expectCode}` : '') +
            (opts.expectInvalid ? ' invalid' : '') +
            ` (ok=${valid}, codes=${codes.join(',') || 'none'})\n`
        );
        return;
      }
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('snapshot')
  .argument(
    '<file>',
    'path to a .brep.ts module; renders iso/front/top/right PNGs (no report assertions)'
  )
  .option('--out <dir>', 'output directory for the PNGs (default <file>-shots)')
  .option('--label <tag>', 'subfolder for this render set (e.g. pre, post) for A/B pairing')
  .action(async (file: string, opts: { out?: string; label?: string }) => {
    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, metrics: true });
    try {
      if (!step) {
        process.stderr.write('snapshot: part produced no STEP — nothing to render\n');
        process.stdout.write(serializeReport(report) + '\n');
        process.exitCode = 1;
        return;
      }
      const stepPath = join(tmpdir(), `brep-snap-${basename(file)}.step`);
      writeFileSync(stepPath, Buffer.from(step));
      const shoot = await loadSnapshotShoot();
      if (!shoot) {
        // puppeteer absent: loadSnapshotShoot set exitCode + stderr; still emit the report so a
        // caller parsing stdout gets the validity info rather than an empty buffer.
        process.stdout.write(serializeReport(report) + '\n');
        return;
      }
      // fresh: a private ephemeral render server so parallel snapshots don't contend on :7373.
      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,
        ...(section ? { section } : {}),
        ...(marks.length > 0 ? { marks } : {}),
      });
      for (const p of pngs) process.stdout.write(`${p}\n`);
    } finally {
      disposeShape(shape);
    }
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    const run = async () => {
      try {
        const { report, shape } = await runPart(path);
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    const { trigger } = debounce(run, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    void run(); // initial verify
    // Watch the parent dir: editors often replace the file (rename) on save,
    // which drops a watcher bound to the file inode itself.
    const watcher = fsWatch(dirname(path), (_event, filename) => {
      if (filename === undefined || filename === null) {
        trigger();
        return;
      }
      if (basename(path) === filename.toString()) trigger();
    });
    const stop = () => {
      watcher.close();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + {}.url));
+	const builtJs = (0, node_url.fileURLToPath)(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, realpathSync, globSync } from 'node:fs';
import { resolve, join, basename } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport, type VerifyReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import {
  debounce,
  DEFAULT_DEBOUNCE_MS,
  isWatchRelevant,
  watchRootFor,
  watchTree,
} from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';
import { aimedSection, featureMarks } from '../snapshot/aiming.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const 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'
  )
  .option(
    '--metrics',
    'compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default'
  )
  .action(
    async (
      files: string[],
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        expectCode?: string;
        expectInvalid?: boolean;
        metrics?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // A quoted glob ("parts/*.brep.ts") arrives as one literal arg, a shell-expanded one as many;
      // globSync handles both (a literal filename matches itself), falling back to the raw arg so a
      // missing path still runs and reports its own error.
      const targets = [
        ...new Set(
          files.flatMap((f) => {
            const m = globSync(f);
            return m.length ? m : [f];
          })
        ),
      ].map((p) => resolve(p));

      if (targets.length > 1) {
        // Batch: validity-only JSON array. The single-file artifact flags don't apply.
        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: { file: string; ok: boolean; report: VerifyReport }[] = [];
        for (const f of targets) {
          const { report, shape } = await runPart(f, {
            check: Boolean(opts.check),
            metrics: Boolean(opts.metrics),
          });
          disposeShape(shape);
          results.push({ file: f, ok: reportOk(report), report });
        }
        const json = JSON.stringify(results, null, 2);
        if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
        process.stdout.write(json + '\n');
        if (results.some((r) => !r.ok)) process.exitCode = 1;
        return;
      }

      const file = targets[0] ?? files[0] ?? '';
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
        // A snapshot feeds the design judge, so compute metrics too (bores → an aimed section shot).
        metrics: Boolean(opts.metrics) || Boolean(opts.snapshot),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brep-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          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,
              ...(section ? { section } : {}),
              ...(marks.length > 0 ? { marks } : {}),
            });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      // `--json -` is satisfied by the stdout write below; only a real path writes a file.
      if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      // Fixture assertions (Phase: verify-heal precision/recall) override the normal exit code:
      // a known-bad part must fail the *right* way. Codes come from the kernel/authoring errors,
      // not the hint table, so this measures the verifier, not its prose.
      if (opts.expectInvalid || opts.expectCode) {
        // hints are derived from errorInfos, so the codes live there; dedupe to keep the line clean.
        const codes = [
          ...new Set(report.errorInfos.map((e) => e.code).filter((c): c is string => Boolean(c))),
        ];
        const valid = reportOk(report);
        const pass =
          (!opts.expectInvalid || !valid) && (!opts.expectCode || codes.includes(opts.expectCode));
        process.exitCode = pass ? 0 : 1;
        process.stderr.write(
          `expect: ${pass ? 'PASS' : 'FAIL'}` +
            (opts.expectCode ? ` code=${opts.expectCode}` : '') +
            (opts.expectInvalid ? ' invalid' : '') +
            ` (ok=${valid}, codes=${codes.join(',') || 'none'})\n`
        );
        return;
      }
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('snapshot')
  .argument(
    '<file>',
    'path to a .brep.ts module; renders iso/front/top/right PNGs (no report assertions)'
  )
  .option('--out <dir>', 'output directory for the PNGs (default <file>-shots)')
  .option('--label <tag>', 'subfolder for this render set (e.g. pre, post) for A/B pairing')
  .action(async (file: string, opts: { out?: string; label?: string }) => {
    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, metrics: true });
    try {
      if (!step) {
        process.stderr.write('snapshot: part produced no STEP — nothing to render\n');
        process.stdout.write(serializeReport(report) + '\n');
        process.exitCode = 1;
        return;
      }
      const stepPath = join(tmpdir(), `brep-snap-${basename(file)}.step`);
      writeFileSync(stepPath, Buffer.from(step));
      const shoot = await loadSnapshotShoot();
      if (!shoot) {
        // puppeteer absent: loadSnapshotShoot set exitCode + stderr; still emit the report so a
        // caller parsing stdout gets the validity info rather than an empty buffer.
        process.stdout.write(serializeReport(report) + '\n');
        return;
      }
      // fresh: a private ephemeral render server so parallel snapshots don't contend on :7373.
      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,
        ...(section ? { section } : {}),
        ...(marks.length > 0 ? { marks } : {}),
      });
      for (const p of pngs) process.stdout.write(`${p}\n`);
    } finally {
      disposeShape(shape);
    }
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    // Reruns import with a fresh cache-busting query — the ESM cache is keyed by URL, so
    // without it every rerun would re-execute the first version of the part forever.
    const run = async (fresh: boolean) => {
      try {
        const { report, shape } = await runPart(path, { freshImport: fresh });
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    // Serialize runs: a save landing mid-verify must not start a second runPart on the
    // shared kernel (reports would interleave out of order). Edits during a run coalesce
    // into exactly one trailing rerun.
    let inFlight = false;
    let rerunQueued = false;
    const start = (fresh: boolean): void => {
      inFlight = true;
      void run(fresh).finally(() => {
        inFlight = false;
        if (rerunQueued) {
          rerunQueued = false;
          start(true);
        }
      });
    };
    const schedule = (): void => {
      if (inFlight) {
        rerunQueued = true;
        return;
      }
      start(true);
    };
    const { trigger } = debounce(schedule, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    start(false); // initial verify
    // Watch the whole project tree (nearest package.json/tsconfig.json above the entry):
    // editors often replace a file (rename) on save, which drops a watcher bound to the
    // inode itself — and a multi-file project must re-verify when any source OR the root
    // tsconfig changes, not just files beside the entry.
    const stopWatching = watchTree(watchRootFor(path), (filename) => {
      if (isWatchRelevant(filename)) trigger();
    });
    const stop = () => {
      stopWatching();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + {}.url));
 	if ((0, node_fs.existsSync)(builtJs)) return builtJs;
-	return (0, node_url.fileURLToPath)(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, watch as fsWatch, realpathSync, globSync } from 'node:fs';
import { resolve, join, basename, dirname } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport, type VerifyReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import { debounce, DEFAULT_DEBOUNCE_MS } from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';
import { aimedSection, featureMarks } from '../snapshot/aiming.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const 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'
  )
  .option(
    '--metrics',
    'compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default'
  )
  .action(
    async (
      files: string[],
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        expectCode?: string;
        expectInvalid?: boolean;
        metrics?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // A quoted glob ("parts/*.brep.ts") arrives as one literal arg, a shell-expanded one as many;
      // globSync handles both (a literal filename matches itself), falling back to the raw arg so a
      // missing path still runs and reports its own error.
      const targets = [
        ...new Set(
          files.flatMap((f) => {
            const m = globSync(f);
            return m.length ? m : [f];
          })
        ),
      ].map((p) => resolve(p));

      if (targets.length > 1) {
        // Batch: validity-only JSON array. The single-file artifact flags don't apply.
        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: { file: string; ok: boolean; report: VerifyReport }[] = [];
        for (const f of targets) {
          const { report, shape } = await runPart(f, {
            check: Boolean(opts.check),
            metrics: Boolean(opts.metrics),
          });
          disposeShape(shape);
          results.push({ file: f, ok: reportOk(report), report });
        }
        const json = JSON.stringify(results, null, 2);
        if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
        process.stdout.write(json + '\n');
        if (results.some((r) => !r.ok)) process.exitCode = 1;
        return;
      }

      const file = targets[0] ?? files[0] ?? '';
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
        // A snapshot feeds the design judge, so compute metrics too (bores → an aimed section shot).
        metrics: Boolean(opts.metrics) || Boolean(opts.snapshot),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brep-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          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,
              ...(section ? { section } : {}),
              ...(marks.length > 0 ? { marks } : {}),
            });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      // `--json -` is satisfied by the stdout write below; only a real path writes a file.
      if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      // Fixture assertions (Phase: verify-heal precision/recall) override the normal exit code:
      // a known-bad part must fail the *right* way. Codes come from the kernel/authoring errors,
      // not the hint table, so this measures the verifier, not its prose.
      if (opts.expectInvalid || opts.expectCode) {
        // hints are derived from errorInfos, so the codes live there; dedupe to keep the line clean.
        const codes = [
          ...new Set(report.errorInfos.map((e) => e.code).filter((c): c is string => Boolean(c))),
        ];
        const valid = reportOk(report);
        const pass =
          (!opts.expectInvalid || !valid) && (!opts.expectCode || codes.includes(opts.expectCode));
        process.exitCode = pass ? 0 : 1;
        process.stderr.write(
          `expect: ${pass ? 'PASS' : 'FAIL'}` +
            (opts.expectCode ? ` code=${opts.expectCode}` : '') +
            (opts.expectInvalid ? ' invalid' : '') +
            ` (ok=${valid}, codes=${codes.join(',') || 'none'})\n`
        );
        return;
      }
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('snapshot')
  .argument(
    '<file>',
    'path to a .brep.ts module; renders iso/front/top/right PNGs (no report assertions)'
  )
  .option('--out <dir>', 'output directory for the PNGs (default <file>-shots)')
  .option('--label <tag>', 'subfolder for this render set (e.g. pre, post) for A/B pairing')
  .action(async (file: string, opts: { out?: string; label?: string }) => {
    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, metrics: true });
    try {
      if (!step) {
        process.stderr.write('snapshot: part produced no STEP — nothing to render\n');
        process.stdout.write(serializeReport(report) + '\n');
        process.exitCode = 1;
        return;
      }
      const stepPath = join(tmpdir(), `brep-snap-${basename(file)}.step`);
      writeFileSync(stepPath, Buffer.from(step));
      const shoot = await loadSnapshotShoot();
      if (!shoot) {
        // puppeteer absent: loadSnapshotShoot set exitCode + stderr; still emit the report so a
        // caller parsing stdout gets the validity info rather than an empty buffer.
        process.stdout.write(serializeReport(report) + '\n');
        return;
      }
      // fresh: a private ephemeral render server so parallel snapshots don't contend on :7373.
      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,
        ...(section ? { section } : {}),
        ...(marks.length > 0 ? { marks } : {}),
      });
      for (const p of pngs) process.stdout.write(`${p}\n`);
    } finally {
      disposeShape(shape);
    }
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    const run = async () => {
      try {
        const { report, shape } = await runPart(path);
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    const { trigger } = debounce(run, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    void run(); // initial verify
    // Watch the parent dir: editors often replace the file (rename) on save,
    // which drops a watcher bound to the file inode itself.
    const watcher = fsWatch(dirname(path), (_event, filename) => {
      if (filename === undefined || filename === null) {
        trigger();
        return;
      }
      if (basename(path) === filename.toString()) trigger();
    });
    const stop = () => {
      watcher.close();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + {}.url));
+	return (0, node_url.fileURLToPath)(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, realpathSync, globSync } from 'node:fs';
import { resolve, join, basename } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport, type VerifyReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import {
  debounce,
  DEFAULT_DEBOUNCE_MS,
  isWatchRelevant,
  watchRootFor,
  watchTree,
} from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';
import { aimedSection, featureMarks } from '../snapshot/aiming.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const 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'
  )
  .option(
    '--metrics',
    'compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default'
  )
  .action(
    async (
      files: string[],
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        expectCode?: string;
        expectInvalid?: boolean;
        metrics?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // A quoted glob ("parts/*.brep.ts") arrives as one literal arg, a shell-expanded one as many;
      // globSync handles both (a literal filename matches itself), falling back to the raw arg so a
      // missing path still runs and reports its own error.
      const targets = [
        ...new Set(
          files.flatMap((f) => {
            const m = globSync(f);
            return m.length ? m : [f];
          })
        ),
      ].map((p) => resolve(p));

      if (targets.length > 1) {
        // Batch: validity-only JSON array. The single-file artifact flags don't apply.
        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: { file: string; ok: boolean; report: VerifyReport }[] = [];
        for (const f of targets) {
          const { report, shape } = await runPart(f, {
            check: Boolean(opts.check),
            metrics: Boolean(opts.metrics),
          });
          disposeShape(shape);
          results.push({ file: f, ok: reportOk(report), report });
        }
        const json = JSON.stringify(results, null, 2);
        if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
        process.stdout.write(json + '\n');
        if (results.some((r) => !r.ok)) process.exitCode = 1;
        return;
      }

      const file = targets[0] ?? files[0] ?? '';
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
        // A snapshot feeds the design judge, so compute metrics too (bores → an aimed section shot).
        metrics: Boolean(opts.metrics) || Boolean(opts.snapshot),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brep-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          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,
              ...(section ? { section } : {}),
              ...(marks.length > 0 ? { marks } : {}),
            });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      // `--json -` is satisfied by the stdout write below; only a real path writes a file.
      if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      // Fixture assertions (Phase: verify-heal precision/recall) override the normal exit code:
      // a known-bad part must fail the *right* way. Codes come from the kernel/authoring errors,
      // not the hint table, so this measures the verifier, not its prose.
      if (opts.expectInvalid || opts.expectCode) {
        // hints are derived from errorInfos, so the codes live there; dedupe to keep the line clean.
        const codes = [
          ...new Set(report.errorInfos.map((e) => e.code).filter((c): c is string => Boolean(c))),
        ];
        const valid = reportOk(report);
        const pass =
          (!opts.expectInvalid || !valid) && (!opts.expectCode || codes.includes(opts.expectCode));
        process.exitCode = pass ? 0 : 1;
        process.stderr.write(
          `expect: ${pass ? 'PASS' : 'FAIL'}` +
            (opts.expectCode ? ` code=${opts.expectCode}` : '') +
            (opts.expectInvalid ? ' invalid' : '') +
            ` (ok=${valid}, codes=${codes.join(',') || 'none'})\n`
        );
        return;
      }
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('snapshot')
  .argument(
    '<file>',
    'path to a .brep.ts module; renders iso/front/top/right PNGs (no report assertions)'
  )
  .option('--out <dir>', 'output directory for the PNGs (default <file>-shots)')
  .option('--label <tag>', 'subfolder for this render set (e.g. pre, post) for A/B pairing')
  .action(async (file: string, opts: { out?: string; label?: string }) => {
    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, metrics: true });
    try {
      if (!step) {
        process.stderr.write('snapshot: part produced no STEP — nothing to render\n');
        process.stdout.write(serializeReport(report) + '\n');
        process.exitCode = 1;
        return;
      }
      const stepPath = join(tmpdir(), `brep-snap-${basename(file)}.step`);
      writeFileSync(stepPath, Buffer.from(step));
      const shoot = await loadSnapshotShoot();
      if (!shoot) {
        // puppeteer absent: loadSnapshotShoot set exitCode + stderr; still emit the report so a
        // caller parsing stdout gets the validity info rather than an empty buffer.
        process.stdout.write(serializeReport(report) + '\n');
        return;
      }
      // fresh: a private ephemeral render server so parallel snapshots don't contend on :7373.
      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,
        ...(section ? { section } : {}),
        ...(marks.length > 0 ? { marks } : {}),
      });
      for (const p of pngs) process.stdout.write(`${p}\n`);
    } finally {
      disposeShape(shape);
    }
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    // Reruns import with a fresh cache-busting query — the ESM cache is keyed by URL, so
    // without it every rerun would re-execute the first version of the part forever.
    const run = async (fresh: boolean) => {
      try {
        const { report, shape } = await runPart(path, { freshImport: fresh });
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    // Serialize runs: a save landing mid-verify must not start a second runPart on the
    // shared kernel (reports would interleave out of order). Edits during a run coalesce
    // into exactly one trailing rerun.
    let inFlight = false;
    let rerunQueued = false;
    const start = (fresh: boolean): void => {
      inFlight = true;
      void run(fresh).finally(() => {
        inFlight = false;
        if (rerunQueued) {
          rerunQueued = false;
          start(true);
        }
      });
    };
    const schedule = (): void => {
      if (inFlight) {
        rerunQueued = true;
        return;
      }
      start(true);
    };
    const { trigger } = debounce(schedule, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    start(false); // initial verify
    // Watch the whole project tree (nearest package.json/tsconfig.json above the entry):
    // editors often replace a file (rename) on save, which drops a watcher bound to the
    // inode itself — and a multi-file project must re-verify when any source OR the root
    // tsconfig changes, not just files beside the entry.
    const stopWatching = watchTree(watchRootFor(path), (filename) => {
      if (isWatchRelevant(filename)) trigger();
    });
    const stop = () => {
      stopWatching();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + {}.url));
 }
 /**
 * Write `code` to a temp ESM directory, run the verify CLI with `makeArgs(partPath)` in a

package/dist/mcp/server.js

@@ -43,9 +43,9 @@ function positiveOrDefault(value, fallback) {
 	return value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
 }
 function defaultCliEntry() {
-	const builtJs = fileURLToPath(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, watch as fsWatch, realpathSync, globSync } from 'node:fs';
import { resolve, join, basename, dirname } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport, type VerifyReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import { debounce, DEFAULT_DEBOUNCE_MS } from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';
import { aimedSection, featureMarks } from '../snapshot/aiming.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const 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'
  )
  .option(
    '--metrics',
    'compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default'
  )
  .action(
    async (
      files: string[],
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        expectCode?: string;
        expectInvalid?: boolean;
        metrics?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // A quoted glob ("parts/*.brep.ts") arrives as one literal arg, a shell-expanded one as many;
      // globSync handles both (a literal filename matches itself), falling back to the raw arg so a
      // missing path still runs and reports its own error.
      const targets = [
        ...new Set(
          files.flatMap((f) => {
            const m = globSync(f);
            return m.length ? m : [f];
          })
        ),
      ].map((p) => resolve(p));

      if (targets.length > 1) {
        // Batch: validity-only JSON array. The single-file artifact flags don't apply.
        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: { file: string; ok: boolean; report: VerifyReport }[] = [];
        for (const f of targets) {
          const { report, shape } = await runPart(f, {
            check: Boolean(opts.check),
            metrics: Boolean(opts.metrics),
          });
          disposeShape(shape);
          results.push({ file: f, ok: reportOk(report), report });
        }
        const json = JSON.stringify(results, null, 2);
        if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
        process.stdout.write(json + '\n');
        if (results.some((r) => !r.ok)) process.exitCode = 1;
        return;
      }

      const file = targets[0] ?? files[0] ?? '';
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
        // A snapshot feeds the design judge, so compute metrics too (bores → an aimed section shot).
        metrics: Boolean(opts.metrics) || Boolean(opts.snapshot),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brep-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          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,
              ...(section ? { section } : {}),
              ...(marks.length > 0 ? { marks } : {}),
            });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      // `--json -` is satisfied by the stdout write below; only a real path writes a file.
      if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      // Fixture assertions (Phase: verify-heal precision/recall) override the normal exit code:
      // a known-bad part must fail the *right* way. Codes come from the kernel/authoring errors,
      // not the hint table, so this measures the verifier, not its prose.
      if (opts.expectInvalid || opts.expectCode) {
        // hints are derived from errorInfos, so the codes live there; dedupe to keep the line clean.
        const codes = [
          ...new Set(report.errorInfos.map((e) => e.code).filter((c): c is string => Boolean(c))),
        ];
        const valid = reportOk(report);
        const pass =
          (!opts.expectInvalid || !valid) && (!opts.expectCode || codes.includes(opts.expectCode));
        process.exitCode = pass ? 0 : 1;
        process.stderr.write(
          `expect: ${pass ? 'PASS' : 'FAIL'}` +
            (opts.expectCode ? ` code=${opts.expectCode}` : '') +
            (opts.expectInvalid ? ' invalid' : '') +
            ` (ok=${valid}, codes=${codes.join(',') || 'none'})\n`
        );
        return;
      }
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('snapshot')
  .argument(
    '<file>',
    'path to a .brep.ts module; renders iso/front/top/right PNGs (no report assertions)'
  )
  .option('--out <dir>', 'output directory for the PNGs (default <file>-shots)')
  .option('--label <tag>', 'subfolder for this render set (e.g. pre, post) for A/B pairing')
  .action(async (file: string, opts: { out?: string; label?: string }) => {
    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, metrics: true });
    try {
      if (!step) {
        process.stderr.write('snapshot: part produced no STEP — nothing to render\n');
        process.stdout.write(serializeReport(report) + '\n');
        process.exitCode = 1;
        return;
      }
      const stepPath = join(tmpdir(), `brep-snap-${basename(file)}.step`);
      writeFileSync(stepPath, Buffer.from(step));
      const shoot = await loadSnapshotShoot();
      if (!shoot) {
        // puppeteer absent: loadSnapshotShoot set exitCode + stderr; still emit the report so a
        // caller parsing stdout gets the validity info rather than an empty buffer.
        process.stdout.write(serializeReport(report) + '\n');
        return;
      }
      // fresh: a private ephemeral render server so parallel snapshots don't contend on :7373.
      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,
        ...(section ? { section } : {}),
        ...(marks.length > 0 ? { marks } : {}),
      });
      for (const p of pngs) process.stdout.write(`${p}\n`);
    } finally {
      disposeShape(shape);
    }
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    const run = async () => {
      try {
        const { report, shape } = await runPart(path);
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    const { trigger } = debounce(run, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    void run(); // initial verify
    // Watch the parent dir: editors often replace the file (rename) on save,
    // which drops a watcher bound to the file inode itself.
    const watcher = fsWatch(dirname(path), (_event, filename) => {
      if (filename === undefined || filename === null) {
        trigger();
        return;
      }
      if (basename(path) === filename.toString()) trigger();
    });
    const stop = () => {
      watcher.close();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + import.meta.url));
+	const builtJs = fileURLToPath(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, realpathSync, globSync } from 'node:fs';
import { resolve, join, basename } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport, type VerifyReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import {
  debounce,
  DEFAULT_DEBOUNCE_MS,
  isWatchRelevant,
  watchRootFor,
  watchTree,
} from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';
import { aimedSection, featureMarks } from '../snapshot/aiming.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const 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'
  )
  .option(
    '--metrics',
    'compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default'
  )
  .action(
    async (
      files: string[],
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        expectCode?: string;
        expectInvalid?: boolean;
        metrics?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // A quoted glob ("parts/*.brep.ts") arrives as one literal arg, a shell-expanded one as many;
      // globSync handles both (a literal filename matches itself), falling back to the raw arg so a
      // missing path still runs and reports its own error.
      const targets = [
        ...new Set(
          files.flatMap((f) => {
            const m = globSync(f);
            return m.length ? m : [f];
          })
        ),
      ].map((p) => resolve(p));

      if (targets.length > 1) {
        // Batch: validity-only JSON array. The single-file artifact flags don't apply.
        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: { file: string; ok: boolean; report: VerifyReport }[] = [];
        for (const f of targets) {
          const { report, shape } = await runPart(f, {
            check: Boolean(opts.check),
            metrics: Boolean(opts.metrics),
          });
          disposeShape(shape);
          results.push({ file: f, ok: reportOk(report), report });
        }
        const json = JSON.stringify(results, null, 2);
        if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
        process.stdout.write(json + '\n');
        if (results.some((r) => !r.ok)) process.exitCode = 1;
        return;
      }

      const file = targets[0] ?? files[0] ?? '';
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
        // A snapshot feeds the design judge, so compute metrics too (bores → an aimed section shot).
        metrics: Boolean(opts.metrics) || Boolean(opts.snapshot),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brep-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          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,
              ...(section ? { section } : {}),
              ...(marks.length > 0 ? { marks } : {}),
            });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      // `--json -` is satisfied by the stdout write below; only a real path writes a file.
      if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      // Fixture assertions (Phase: verify-heal precision/recall) override the normal exit code:
      // a known-bad part must fail the *right* way. Codes come from the kernel/authoring errors,
      // not the hint table, so this measures the verifier, not its prose.
      if (opts.expectInvalid || opts.expectCode) {
        // hints are derived from errorInfos, so the codes live there; dedupe to keep the line clean.
        const codes = [
          ...new Set(report.errorInfos.map((e) => e.code).filter((c): c is string => Boolean(c))),
        ];
        const valid = reportOk(report);
        const pass =
          (!opts.expectInvalid || !valid) && (!opts.expectCode || codes.includes(opts.expectCode));
        process.exitCode = pass ? 0 : 1;
        process.stderr.write(
          `expect: ${pass ? 'PASS' : 'FAIL'}` +
            (opts.expectCode ? ` code=${opts.expectCode}` : '') +
            (opts.expectInvalid ? ' invalid' : '') +
            ` (ok=${valid}, codes=${codes.join(',') || 'none'})\n`
        );
        return;
      }
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('snapshot')
  .argument(
    '<file>',
    'path to a .brep.ts module; renders iso/front/top/right PNGs (no report assertions)'
  )
  .option('--out <dir>', 'output directory for the PNGs (default <file>-shots)')
  .option('--label <tag>', 'subfolder for this render set (e.g. pre, post) for A/B pairing')
  .action(async (file: string, opts: { out?: string; label?: string }) => {
    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, metrics: true });
    try {
      if (!step) {
        process.stderr.write('snapshot: part produced no STEP — nothing to render\n');
        process.stdout.write(serializeReport(report) + '\n');
        process.exitCode = 1;
        return;
      }
      const stepPath = join(tmpdir(), `brep-snap-${basename(file)}.step`);
      writeFileSync(stepPath, Buffer.from(step));
      const shoot = await loadSnapshotShoot();
      if (!shoot) {
        // puppeteer absent: loadSnapshotShoot set exitCode + stderr; still emit the report so a
        // caller parsing stdout gets the validity info rather than an empty buffer.
        process.stdout.write(serializeReport(report) + '\n');
        return;
      }
      // fresh: a private ephemeral render server so parallel snapshots don't contend on :7373.
      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,
        ...(section ? { section } : {}),
        ...(marks.length > 0 ? { marks } : {}),
      });
      for (const p of pngs) process.stdout.write(`${p}\n`);
    } finally {
      disposeShape(shape);
    }
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    // Reruns import with a fresh cache-busting query — the ESM cache is keyed by URL, so
    // without it every rerun would re-execute the first version of the part forever.
    const run = async (fresh: boolean) => {
      try {
        const { report, shape } = await runPart(path, { freshImport: fresh });
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    // Serialize runs: a save landing mid-verify must not start a second runPart on the
    // shared kernel (reports would interleave out of order). Edits during a run coalesce
    // into exactly one trailing rerun.
    let inFlight = false;
    let rerunQueued = false;
    const start = (fresh: boolean): void => {
      inFlight = true;
      void run(fresh).finally(() => {
        inFlight = false;
        if (rerunQueued) {
          rerunQueued = false;
          start(true);
        }
      });
    };
    const schedule = (): void => {
      if (inFlight) {
        rerunQueued = true;
        return;
      }
      start(true);
    };
    const { trigger } = debounce(schedule, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    start(false); // initial verify
    // Watch the whole project tree (nearest package.json/tsconfig.json above the entry):
    // editors often replace a file (rename) on save, which drops a watcher bound to the
    // inode itself — and a multi-file project must re-verify when any source OR the root
    // tsconfig changes, not just files beside the entry.
    const stopWatching = watchTree(watchRootFor(path), (filename) => {
      if (isWatchRelevant(filename)) trigger();
    });
    const stop = () => {
      stopWatching();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + import.meta.url));
 	if (existsSync(builtJs)) return builtJs;
-	return fileURLToPath(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, watch as fsWatch, realpathSync, globSync } from 'node:fs';
import { resolve, join, basename, dirname } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport, type VerifyReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import { debounce, DEFAULT_DEBOUNCE_MS } from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';
import { aimedSection, featureMarks } from '../snapshot/aiming.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const 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'
  )
  .option(
    '--metrics',
    'compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default'
  )
  .action(
    async (
      files: string[],
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        expectCode?: string;
        expectInvalid?: boolean;
        metrics?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // A quoted glob ("parts/*.brep.ts") arrives as one literal arg, a shell-expanded one as many;
      // globSync handles both (a literal filename matches itself), falling back to the raw arg so a
      // missing path still runs and reports its own error.
      const targets = [
        ...new Set(
          files.flatMap((f) => {
            const m = globSync(f);
            return m.length ? m : [f];
          })
        ),
      ].map((p) => resolve(p));

      if (targets.length > 1) {
        // Batch: validity-only JSON array. The single-file artifact flags don't apply.
        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: { file: string; ok: boolean; report: VerifyReport }[] = [];
        for (const f of targets) {
          const { report, shape } = await runPart(f, {
            check: Boolean(opts.check),
            metrics: Boolean(opts.metrics),
          });
          disposeShape(shape);
          results.push({ file: f, ok: reportOk(report), report });
        }
        const json = JSON.stringify(results, null, 2);
        if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
        process.stdout.write(json + '\n');
        if (results.some((r) => !r.ok)) process.exitCode = 1;
        return;
      }

      const file = targets[0] ?? files[0] ?? '';
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
        // A snapshot feeds the design judge, so compute metrics too (bores → an aimed section shot).
        metrics: Boolean(opts.metrics) || Boolean(opts.snapshot),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brep-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          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,
              ...(section ? { section } : {}),
              ...(marks.length > 0 ? { marks } : {}),
            });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      // `--json -` is satisfied by the stdout write below; only a real path writes a file.
      if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      // Fixture assertions (Phase: verify-heal precision/recall) override the normal exit code:
      // a known-bad part must fail the *right* way. Codes come from the kernel/authoring errors,
      // not the hint table, so this measures the verifier, not its prose.
      if (opts.expectInvalid || opts.expectCode) {
        // hints are derived from errorInfos, so the codes live there; dedupe to keep the line clean.
        const codes = [
          ...new Set(report.errorInfos.map((e) => e.code).filter((c): c is string => Boolean(c))),
        ];
        const valid = reportOk(report);
        const pass =
          (!opts.expectInvalid || !valid) && (!opts.expectCode || codes.includes(opts.expectCode));
        process.exitCode = pass ? 0 : 1;
        process.stderr.write(
          `expect: ${pass ? 'PASS' : 'FAIL'}` +
            (opts.expectCode ? ` code=${opts.expectCode}` : '') +
            (opts.expectInvalid ? ' invalid' : '') +
            ` (ok=${valid}, codes=${codes.join(',') || 'none'})\n`
        );
        return;
      }
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('snapshot')
  .argument(
    '<file>',
    'path to a .brep.ts module; renders iso/front/top/right PNGs (no report assertions)'
  )
  .option('--out <dir>', 'output directory for the PNGs (default <file>-shots)')
  .option('--label <tag>', 'subfolder for this render set (e.g. pre, post) for A/B pairing')
  .action(async (file: string, opts: { out?: string; label?: string }) => {
    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, metrics: true });
    try {
      if (!step) {
        process.stderr.write('snapshot: part produced no STEP — nothing to render\n');
        process.stdout.write(serializeReport(report) + '\n');
        process.exitCode = 1;
        return;
      }
      const stepPath = join(tmpdir(), `brep-snap-${basename(file)}.step`);
      writeFileSync(stepPath, Buffer.from(step));
      const shoot = await loadSnapshotShoot();
      if (!shoot) {
        // puppeteer absent: loadSnapshotShoot set exitCode + stderr; still emit the report so a
        // caller parsing stdout gets the validity info rather than an empty buffer.
        process.stdout.write(serializeReport(report) + '\n');
        return;
      }
      // fresh: a private ephemeral render server so parallel snapshots don't contend on :7373.
      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,
        ...(section ? { section } : {}),
        ...(marks.length > 0 ? { marks } : {}),
      });
      for (const p of pngs) process.stdout.write(`${p}\n`);
    } finally {
      disposeShape(shape);
    }
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    const run = async () => {
      try {
        const { report, shape } = await runPart(path);
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    const { trigger } = debounce(run, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    void run(); // initial verify
    // Watch the parent dir: editors often replace the file (rename) on save,
    // which drops a watcher bound to the file inode itself.
    const watcher = fsWatch(dirname(path), (_event, filename) => {
      if (filename === undefined || filename === null) {
        trigger();
        return;
      }
      if (basename(path) === filename.toString()) trigger();
    });
    const stop = () => {
      watcher.close();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + import.meta.url));
+	return fileURLToPath(new URL("data:video/mp2t;base64,#!/usr/bin/env node
import { Command } from 'commander';
import { writeFileSync, realpathSync, globSync } from 'node:fs';
import { resolve, join, basename } from 'node:path';
import { tmpdir } from 'node:os';
import { fileURLToPath } from 'node:url';
import { runPart } from '../verify/runPart.js';
import { pushError, reportOk, serializeReport, type VerifyReport } from '../verify/report.js';
import { runMeasure } from '../verify/measure.js';
import { runDiff } from '../verify/diff.js';
import { scaffoldPart } from './scaffold.js';
import {
  debounce,
  DEFAULT_DEBOUNCE_MS,
  isWatchRelevant,
  watchRootFor,
  watchTree,
} from './watch.js';
import { exportPart } from './exportPart.js';
import { openBrowser, shouldAutoOpen } from './openBrowser.js';
import { disposeShape } from '../disposeShape.js';
import type { shoot as ShootFn } from '../snapshot/shoot.js';
import { aimedSection, featureMarks } from '../snapshot/aiming.js';

// OCCT's WASM STEP writer emits a "Statistics on Transfer" banner via console.log
// (Emscripten's default stdout sink). The CLI owns stdout for machine-readable JSON,
// so divert that kernel chatter to stderr to keep stdout a single clean JSON document.
// eslint-disable-next-line no-console -- reroute kernel stdout chatter off the JSON channel
console.log = (...args: unknown[]) => {
  process.stderr.write(args.map(String).join(' ') + '\n');
};

export async function loadSnapshotShoot(): Promise<typeof ShootFn | undefined> {
  try {
    const mod = await import('../snapshot/shoot.js');
    return mod.shoot;
  } catch {
    process.stderr.write('snapshots need puppeteer/Chrome — run: npm i puppeteer\n');
    process.exitCode = 1;
    return undefined;
  }
}

const 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'
  )
  .option(
    '--metrics',
    'compute deterministic manufacturability metrics (per-body breakdown + interference matrix) for the design judge — slower; off by default'
  )
  .action(
    async (
      files: string[],
      opts: {
        step?: string;
        glb?: string;
        json?: string;
        check?: boolean;
        snapshot?: string;
        serve?: boolean;
        expectCode?: string;
        expectInvalid?: boolean;
        metrics?: boolean;
        // Commander materializes a negated flag as a concrete boolean: true by
        // default, false when --no-open is passed.
        open: boolean;
      }
    ) => {
      // A quoted glob ("parts/*.brep.ts") arrives as one literal arg, a shell-expanded one as many;
      // globSync handles both (a literal filename matches itself), falling back to the raw arg so a
      // missing path still runs and reports its own error.
      const targets = [
        ...new Set(
          files.flatMap((f) => {
            const m = globSync(f);
            return m.length ? m : [f];
          })
        ),
      ].map((p) => resolve(p));

      if (targets.length > 1) {
        // Batch: validity-only JSON array. The single-file artifact flags don't apply.
        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: { file: string; ok: boolean; report: VerifyReport }[] = [];
        for (const f of targets) {
          const { report, shape } = await runPart(f, {
            check: Boolean(opts.check),
            metrics: Boolean(opts.metrics),
          });
          disposeShape(shape);
          results.push({ file: f, ok: reportOk(report), report });
        }
        const json = JSON.stringify(results, null, 2);
        if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
        process.stdout.write(json + '\n');
        if (results.some((r) => !r.ok)) process.exitCode = 1;
        return;
      }

      const file = targets[0] ?? files[0] ?? '';
      // The WASM viewer loads a CAD file (it can't run a .brep.ts), so --snapshot/--serve
      // stage the primary STEP and point the viewer at it via ?dir=&file=. --glb is its own artifact.
      const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
      const { report, step, glb, shape } = await runPart(resolve(file), {
        step: wantStep,
        glb: Boolean(opts.glb),
        check: Boolean(opts.check),
        // A snapshot feeds the design judge, so compute metrics too (bores → an aimed section shot).
        metrics: Boolean(opts.metrics) || Boolean(opts.snapshot),
      });
      let stepPath: string | undefined = opts.step;
      try {
        if (opts.glb && glb) writeFileSync(opts.glb, Buffer.from(glb));

        if (wantStep && step) {
          stepPath = opts.step ?? join(tmpdir(), `brep-${basename(file)}.step`);
          writeFileSync(stepPath, Buffer.from(step));
        }
        if (opts.snapshot && stepPath) {
          const shoot = await loadSnapshotShoot(); // lazy: keeps puppeteer off the default path
          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,
              ...(section ? { section } : {}),
              ...(marks.length > 0 ? { marks } : {}),
            });
            // Diagnostic paths go to stderr — stdout stays a single clean JSON document.
            for (const p of pngs) process.stderr.write(`snapshot: ${p}\n`);
          }
        } else if (opts.snapshot) {
          process.stderr.write('snapshot skipped: STEP export produced no artifact\n');
        }
      } catch (e) {
        pushError(report, { message: `artifact write failed: ${(e as Error).message}` });
      } finally {
        // The shape is a live WASM handle; release it before the server takes over (the
        // --serve path stays running, so leaking here would persist for the server's lifetime).
        disposeShape(shape);
      }
      // Serialize once after all artifact writes so the --json file and stdout
      // reflect the same report (incl. any "artifact write failed" error).
      const json = serializeReport(report);
      // `--json -` is satisfied by the stdout write below; only a real path writes a file.
      if (opts.json && opts.json !== '-') writeFileSync(opts.json, json);
      process.stdout.write(json + '\n');
      if (!reportOk(report)) process.exitCode = 1;
      // Fixture assertions (Phase: verify-heal precision/recall) override the normal exit code:
      // a known-bad part must fail the *right* way. Codes come from the kernel/authoring errors,
      // not the hint table, so this measures the verifier, not its prose.
      if (opts.expectInvalid || opts.expectCode) {
        // hints are derived from errorInfos, so the codes live there; dedupe to keep the line clean.
        const codes = [
          ...new Set(report.errorInfos.map((e) => e.code).filter((c): c is string => Boolean(c))),
        ];
        const valid = reportOk(report);
        const pass =
          (!opts.expectInvalid || !valid) && (!opts.expectCode || codes.includes(opts.expectCode));
        process.exitCode = pass ? 0 : 1;
        process.stderr.write(
          `expect: ${pass ? 'PASS' : 'FAIL'}` +
            (opts.expectCode ? ` code=${opts.expectCode}` : '') +
            (opts.expectInvalid ? ' invalid' : '') +
            ` (ok=${valid}, codes=${codes.join(',') || 'none'})\n`
        );
        return;
      }
      const willServe = Boolean(opts.serve) && stepPath !== undefined && reportOk(report);
      if (willServe && stepPath) {
        const { serve } = await import('../snapshot/serve.js'); // lazy: no server deps on the default path
        const { url, reused } = await serve({ file: stepPath }); // builds a ?dir=&file= URL; server runs until Ctrl-C
        process.stderr.write(`viewer: ${url}\n`);
        // Auto-open only for a freshly started server (a reused one already has
        // a tab) in an interactive session; `--no-open` (opts.open === false)
        // always suppresses it.
        if (!reused && opts.open && shouldAutoOpen()) {
          openBrowser(url);
        }
      }
    }
  );

program
  .command('measure')
  .argument('<a>', 'path to a .brep.ts module')
  .argument('[b]', 'optional second module; if given, measures distance between the two parts')
  .action(async (a: string, b?: string) => {
    const result = await runMeasure(resolve(a), b === undefined ? undefined : resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('diff')
  .argument('<a>', 'path to the baseline .brep.ts module')
  .argument('<b>', 'path to the comparison .brep.ts module')
  .action(async (a: string, b: string) => {
    const result = await runDiff(resolve(a), resolve(b));
    process.stdout.write(
      JSON.stringify({ ok: result.errors.length === 0, ...result }, null, 2) + '\n'
    );
    if (result.errors.length > 0) process.exitCode = 1;
  });

program
  .command('snapshot')
  .argument(
    '<file>',
    'path to a .brep.ts module; renders iso/front/top/right PNGs (no report assertions)'
  )
  .option('--out <dir>', 'output directory for the PNGs (default <file>-shots)')
  .option('--label <tag>', 'subfolder for this render set (e.g. pre, post) for A/B pairing')
  .action(async (file: string, opts: { out?: string; label?: string }) => {
    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, metrics: true });
    try {
      if (!step) {
        process.stderr.write('snapshot: part produced no STEP — nothing to render\n');
        process.stdout.write(serializeReport(report) + '\n');
        process.exitCode = 1;
        return;
      }
      const stepPath = join(tmpdir(), `brep-snap-${basename(file)}.step`);
      writeFileSync(stepPath, Buffer.from(step));
      const shoot = await loadSnapshotShoot();
      if (!shoot) {
        // puppeteer absent: loadSnapshotShoot set exitCode + stderr; still emit the report so a
        // caller parsing stdout gets the validity info rather than an empty buffer.
        process.stdout.write(serializeReport(report) + '\n');
        return;
      }
      // fresh: a private ephemeral render server so parallel snapshots don't contend on :7373.
      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,
        ...(section ? { section } : {}),
        ...(marks.length > 0 ? { marks } : {}),
      });
      for (const p of pngs) process.stdout.write(`${p}\n`);
    } finally {
      disposeShape(shape);
    }
  });

program
  .command('init')
  .argument('<name>', 'part name; scaffolds <name>.brep.ts + tsconfig.json + README.md')
  .option('--out <dir>', 'target directory (defaults to ./<name>)')
  .action((name: string, opts: { out?: string }) => {
    const dir = resolve(opts.out ?? name);
    const result = scaffoldPart(name, dir);
    for (const f of result.files) {
      const tag = f.created ? 'created' : 'exists (kept)';
      process.stderr.write(`${tag}: ${f.path}\n`);
    }
    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
  });

program
  .command('watch')
  .argument('<file>', 'path to a .brep.ts module; re-verifies on each save until Ctrl-C')
  .action((file: string) => {
    const path = resolve(file);
    // Reruns import with a fresh cache-busting query — the ESM cache is keyed by URL, so
    // without it every rerun would re-execute the first version of the part forever.
    const run = async (fresh: boolean) => {
      try {
        const { report, shape } = await runPart(path, { freshImport: fresh });
        try {
          process.stdout.write(serializeReport(report) + '\n');
        } finally {
          disposeShape(shape); // live WASM handle; the loop runs indefinitely
        }
      } catch (e) {
        process.stderr.write(`watch run failed: ${(e as Error).message}\n`);
      }
    };
    // Serialize runs: a save landing mid-verify must not start a second runPart on the
    // shared kernel (reports would interleave out of order). Edits during a run coalesce
    // into exactly one trailing rerun.
    let inFlight = false;
    let rerunQueued = false;
    const start = (fresh: boolean): void => {
      inFlight = true;
      void run(fresh).finally(() => {
        inFlight = false;
        if (rerunQueued) {
          rerunQueued = false;
          start(true);
        }
      });
    };
    const schedule = (): void => {
      if (inFlight) {
        rerunQueued = true;
        return;
      }
      start(true);
    };
    const { trigger } = debounce(schedule, DEFAULT_DEBOUNCE_MS);
    process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
    start(false); // initial verify
    // Watch the whole project tree (nearest package.json/tsconfig.json above the entry):
    // editors often replace a file (rename) on save, which drops a watcher bound to the
    // inode itself — and a multi-file project must re-verify when any source OR the root
    // tsconfig changes, not just files beside the entry.
    const stopWatching = watchTree(watchRootFor(path), (filename) => {
      if (isWatchRelevant(filename)) trigger();
    });
    const stop = () => {
      stopWatching();
      process.exit(0);
    };
    process.on('SIGINT', stop);
    process.on('SIGTERM', stop); // supervisors (docker stop, systemctl) send SIGTERM
  });

program
  .command('export')
  .argument('<file>', 'path to a .brep.ts module')
  .option('--step', 'write a STEP artifact')
  .option('--glb', 'write a GLB artifact')
  .option('--stl', 'write an STL artifact')
  .option('--all', 'write STEP + GLB + STL')
  .option('--out <dir>', 'output directory', '.')
  .action(
    async (
      file: string,
      opts: { step?: boolean; glb?: boolean; stl?: boolean; all?: boolean; out: string }
    ) => {
      const formats = opts.all
        ? { step: true, glb: true, stl: true }
        : { step: Boolean(opts.step), glb: Boolean(opts.glb), stl: Boolean(opts.stl) };
      if (!formats.step && !formats.glb && !formats.stl) {
        process.stderr.write('no formats requested — pass --step/--glb/--stl or --all\n');
        process.exitCode = 1;
        return;
      }
      const result = await exportPart(resolve(file), formats, resolve(opts.out));
      for (const p of result.written) process.stderr.write(`wrote: ${p}\n`);
      for (const e of result.errors) process.stderr.write(`error: ${e}\n`);
      process.stdout.write(
        JSON.stringify({ ok: result.ok, written: result.written, errors: result.errors }, null, 2) +
          '\n'
      );
      if (!result.ok) process.exitCode = 1;
    }
  );

// Only drive the CLI when run as the entry script, so tests can import the
// guarded loaders without commander parsing the test runner's argv.
// Resolve symlinks on both sides: the npm-installed bin (node_modules/.bin/brepjs)
// is a symlink, so process.argv[1] would otherwise never equal the real module path.
export function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean {
  if (!argv1) return false;
  try {
    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
  } catch {
    return false;
  }
}

if (isEntrypoint(process.argv[1], import.meta.url)) {
  void program.parseAsync();
}
", "" + import.meta.url));
 }
 /**
 * Write `code` to a temp ESM directory, run the verify CLI with `makeArgs(partPath)` in a

package/dist/verify/runPart.d.ts

@@ -15,6 +15,11 @@ export interface RunPartOptions {
      * judge/snapshot path opts in; the author `--check` loop stays fast.
      */
     metrics?: boolean;
+    /**
+     * Bust the ESM module cache for the part and its own imports (watch reruns pick up
+     * edits). The kernel realm (`brepjs`/`occt-wasm`) keeps its stable URLs either way.
+     */
+    freshImport?: boolean;
 }
 export interface RunPartResult {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs-cad",
-  "version": "0.174.0",
+  "version": "0.175.0",
   "description": "Brainstorm → design → author → verify → polish pipeline for parametric brepjs CAD, with the brep CLI",
   "license": "Apache-2.0",
   "type": "module",
@@ -66,7 +66,7 @@
     "puppeteer": "^25.0.4"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.116.0",
+    "@anthropic-ai/sdk": "0.117.1",
     "@langfuse/client": "5.10.0",
     "@langfuse/otel": "5.10.0",
     "@langfuse/tracing": "5.10.0",
@@ -84,7 +84,7 @@
     "react": "19.2.8",
     "react-dom": "19.2.8",
     "three": "0.185.1",
-    "tsx": "4.23.11",
+    "tsx": "4.23.12",
     "vite": "^8.0.0",
     "vite-plugin-dts": "^5.0.1",
     "vitest": "^4.0.0",