brepjs-cad 0.175.0 → 0.177.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.177.0](https://github.com/andymai/brepjs/compare/brepjs-cad-v0.176.0...brepjs-cad-v0.177.0) (2026-08-26)
+
+
+### Features
+
+* **brepjs-cad:** brep export --3dm — element-aware Rhino export ([#2236](https://github.com/andymai/brepjs/issues/2236)) ([91b0235](https://github.com/andymai/brepjs/commit/91b02355d9ba005f69dd4c72002a946600179398))
+
+
+### Bug Fixes
+
+* **brepjs-cad:** quality pass over the preview/loader/3dm/scaffold delta ([#2243](https://github.com/andymai/brepjs/issues/2243)) ([b6ae66e](https://github.com/andymai/brepjs/commit/b6ae66e6a1c4175bfd13846b382972e1d7356adc))
+
+## [0.176.0](https://github.com/andymai/brepjs/compare/brepjs-cad-v0.175.0...brepjs-cad-v0.176.0) (2026-08-26)
+
+
+### Features
+
+* **brepjs-cad:** brep preview — element-aware model viewer with live watch ([#2231](https://github.com/andymai/brepjs/issues/2231)) ([002a20f](https://github.com/andymai/brepjs/commit/002a20f9ad8d38cb812f00a875583bdb850a004d))
+
 ## [0.175.0](https://github.com/andymai/brepjs/compare/brepjs-cad-v0.174.0...brepjs-cad-v0.175.0) (2026-08-26)
 
 

package/README.md

@@ -66,7 +66,8 @@ The `brep` bin is a multi-command CLI. `verify` is the default command, so `brep
 | `brep verify <files...>` | Default command. Loads the part, runs deterministic checks, prints the JSON report. Flags: `--check`, `--json <out\|->`, `--step <out>`, `--glb <out>`, `--snapshot <dir>`, `--serve`, `--no-open`, `--expect-code <CODE>` / `--expect-invalid` (assert a known-bad part fails the right way — for fixtures/eval). Multiple files or a quoted glob → a validity-only JSON array. Exits non-zero when not `ok` (unless `--serve`). |
 | `brep init <name>`       | Scaffolds a parameterized `<name>.brep.ts` + `tsconfig.json` + `README.md` into `./<name>` (or `--out <dir>`). Never overwrites existing files.                                                                                                                                                                                                                                                                                   |
 | `brep watch <file>`      | Re-verifies on every save until Ctrl-C (debounced; watches the parent dir to survive editor rename-on-save).                                                                                                                                                                                                                                                                                                                      |
-| `brep export <file>`     | Batch artifacts behind a validity gate: `--step`, `--glb`, `--stl`, or `--all`; `--out <dir>` (default `.`). Exits non-zero on failure.                                                                                                                                                                                                                                                                                           |
+| `brep preview <file>`    | Element-aware live viewer for a model module (families element tree, resolved tree, or plain shape): key-path picking, failed elements listed, real edges. `--watch` re-evaluates on save and pushes to the open tab; `--write-only` (CI), `--glb <out>`, `--json <out>`, `--port <n>`, `--no-open`.                                                                                                                              |
+| `brep export <file>`     | Batch artifacts behind a validity gate: `--step`, `--glb`, `--stl`, or `--all`; `--3dm` writes an element-aware Rhino file (one named object per element, layered; needs the optional `rhino3dm` install; not combinable with the other formats); `--out <dir>` (default `.`). Exits non-zero on failure.                                                                                                                         |
 | `brep measure <a> [b]`   | Measurements for one part; with a second module, the distance between the two parts.                                                                                                                                                                                                                                                                                                                                              |
 | `brep diff <a> <b>`      | Compares the measurements of a baseline and a comparison module.                                                                                                                                                                                                                                                                                                                                                                  |
 | `brep snapshot <file>`   | Standalone multi-view PNG capture (no report assertions): `--out <dir>`, `--label <tag>` (subfolder, for pre/post A/B pairing). Renders on a private ephemeral server so parallel snapshots don't contend. Requires the optional `puppeteer`/Chrome dependency; degrades with a clear message when absent. (Also available inline via `verify --snapshot <dir>`.)                                                                 |

package/dist/brepjs-cad.cjs

@@ -1,14 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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;
-exports.evaluateExpected = require_diff.evaluateExpected;
-exports.isExpectedDims = require_diff.isExpectedDims;
-exports.pctDelta = require_diff.pctDelta;
-exports.runChecks = require_diff.runChecks;
+const require_usingCtx = require("./usingCtx-LY0tPCbQ.cjs");
+const require_diff = require("./diff-CBp5KDNZ.cjs");
+exports.DEFAULT_TOLERANCE_PCT = require_usingCtx.DEFAULT_TOLERANCE_PCT;
+exports.TYPECHECK_CODE = require_usingCtx.TYPECHECK_CODE;
+exports.emptyReport = require_usingCtx.emptyReport;
+exports.evaluateExpected = require_usingCtx.evaluateExpected;
+exports.isExpectedDims = require_usingCtx.isExpectedDims;
+exports.pctDelta = require_usingCtx.pctDelta;
+exports.runChecks = require_usingCtx.runChecks;
 exports.runDiff = require_diff.runDiff;
 exports.runMeasure = require_diff.runMeasure;
-exports.runPart = require_diff.runPart;
-exports.serializeReport = require_diff.serializeReport;
-exports.typecheckPart = require_diff.typecheckPart;
+exports.runPart = require_usingCtx.runPart;
+exports.serializeReport = require_usingCtx.serializeReport;
+exports.typecheckPart = require_usingCtx.typecheckPart;

package/dist/brepjs-cad.js

@@ -1,2 +1,3 @@
-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";
+import { c as DEFAULT_TOLERANCE_PCT, d as pctDelta, f as runChecks, g as serializeReport, i as TYPECHECK_CODE, l as evaluateExpected, p as emptyReport, r as runPart, s as typecheckPart, u as isExpectedDims } from "./usingCtx-BDYtpr4t.js";
+import { n as runMeasure, t as runDiff } from "./diff-DmFtXXiX.js";
 export { DEFAULT_TOLERANCE_PCT, TYPECHECK_CODE, emptyReport, evaluateExpected, isExpectedDims, pctDelta, runChecks, runDiff, runMeasure, runPart, serializeReport, typecheckPart };

package/dist/cli/exportPart.d.ts

@@ -10,4 +10,5 @@ export interface ExportResult {
     written: string[];
     errors: string[];
 }
+export declare function stem(file: string): string;
 export declare function exportPart(modulePath: string, formats: ExportFormats, outDir: string): Promise<ExportResult>;

package/dist/cli/main.cjs

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_diff = require("../diff-DX9zgrss.cjs");
+const require_usingCtx = require("../usingCtx-LY0tPCbQ.cjs");
+const require_diff = require("../diff-CBp5KDNZ.cjs");
+const require_openBrowser = require("../openBrowser-Bip99cQv.cjs");
+const require_disposeShape = require("../disposeShape-Bui9k40G.cjs");
 let node_url = require("node:url");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let commander = require("commander");
 let node_os = require("node:os");
-let node_child_process = require("node:child_process");
 //#region src/cli/scaffold.ts
 function partTemplate(name) {
 	return `import { box, cut, unwrap } from 'brepjs';
@@ -97,114 +99,20 @@ function scaffoldPart(name, dir) {
 		files
 	};
 }
-function debounce(fn, delayMs = 150) {
-	let timer;
-	const cancel = () => {
-		if (timer) {
-			clearTimeout(timer);
-			timer = void 0;
-		}
-	};
-	const trigger = () => {
-		cancel();
-		timer = setTimeout(() => {
-			timer = void 0;
-			fn();
-		}, delayMs);
-	};
-	return {
-		trigger,
-		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) {
-	const disposer = shape?.[Symbol.dispose];
-	if (typeof disposer === "function") disposer.call(shape);
-}
 //#endregion
 //#region src/cli/exportPart.ts
 function stem(file) {
-	return (0, node_path.basename)(file).replace(/\.brep\.ts$/, "").replace(/\.ts$/, "");
+	return (0, node_path.basename)(file).replace(/\.brep\.ts$/, "").replace(/\.(?:m?ts|tsx)$/, "");
 }
 async function exportPart(modulePath, formats, outDir) {
-	const { shape, report, step, glb } = await require_diff.runPart(modulePath, {
+	const { shape, report, step, glb } = await require_usingCtx.runPart(modulePath, {
 		step: Boolean(formats.step),
 		glb: Boolean(formats.glb)
 	});
 	const errors = [];
 	const written = [];
-	if (!(require_diff.reportOk(report) && shape !== null)) {
-		disposeShape(shape);
+	if (!(require_usingCtx.reportOk(report) && shape !== null)) {
+		require_disposeShape.disposeShape(shape);
 		const failures = report.errorInfos.map((e) => e.message);
 		return {
 			ok: false,
@@ -231,7 +139,7 @@ async function exportPart(modulePath, formats, outDir) {
 			} else errors.push("GLB export produced no data");
 		}
 		if (formats.stl) {
-			const { exportSTL, isOk } = await require_diff.loadBrep();
+			const { exportSTL, isOk } = await require_usingCtx.loadBrep();
 			const r = exportSTL(shape);
 			if (isOk(r)) {
 				const p = (0, node_path.join)(outDir, `${base}.stl`);
@@ -240,7 +148,7 @@ async function exportPart(modulePath, formats, outDir) {
 			} else errors.push(`STL export: ${r.error.message}`);
 		}
 	} finally {
-		disposeShape(shape);
+		require_disposeShape.disposeShape(shape);
 	}
 	return {
 		ok: errors.length === 0,
@@ -250,43 +158,6 @@ async function exportPart(modulePath, formats, outDir) {
 	};
 }
 //#endregion
-//#region src/cli/openBrowser.ts
-/**
-* Whether `--serve` should auto-open the browser for the current environment.
-*
-* Opens only for an interactive session — suppressed under CI, when stderr is
-* not a TTY (agent/piped runs), or on Linux without a display server — so
-* automation never spawns a browser unexpectedly. An explicit `--no-open` is a
-* separate, always-on override handled by the caller.
-*/
-function shouldAutoOpen({ env = process.env, platform = process.platform, isTTY = Boolean(process.stderr.isTTY) } = {}) {
-	if (env["CI"]) return false;
-	if (!isTTY) return false;
-	if (platform === "linux" && !env["DISPLAY"] && !env["WAYLAND_DISPLAY"]) return false;
-	return true;
-}
-/** The platform-specific command that opens `url` in the default browser. */
-function browserCommand(url, platform) {
-	if (platform === "darwin") return ["open", [url]];
-	if (platform === "win32") return ["rundll32", ["url.dll,FileProtocolHandler", url]];
-	return ["xdg-open", [url]];
-}
-/**
-* Best-effort open of `url` in the default browser. Never throws and never
-* blocks — a missing opener just leaves the printed URL as the fallback.
-*/
-function openBrowser(url, platform = process.platform) {
-	try {
-		const [cmd, args] = browserCommand(url, platform);
-		const child = (0, node_child_process.spawn)(cmd, args, {
-			stdio: "ignore",
-			detached: true
-		});
-		child.on("error", () => {});
-		child.unref();
-	} catch {}
-}
-//#endregion
 //#region src/snapshot/aiming.ts
 /**
 * Kernel-anchored marks for the judge: `B<index>` at each body's bbox centroid (only for multi-body
@@ -372,14 +243,14 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 		if (opts.step || opts.serve || opts.snapshot || opts.glb || opts.expectCode || opts.expectInvalid) process.stderr.write("batch mode: --step/--glb/--serve/--snapshot/--expect-code/--expect-invalid ignored (single-file only)\n");
 		const results = [];
 		for (const f of targets) {
-			const { report, shape } = await require_diff.runPart(f, {
+			const { report, shape } = await require_usingCtx.runPart(f, {
 				check: Boolean(opts.check),
 				metrics: Boolean(opts.metrics)
 			});
-			disposeShape(shape);
+			require_disposeShape.disposeShape(shape);
 			results.push({
 				file: f,
-				ok: require_diff.reportOk(report),
+				ok: require_usingCtx.reportOk(report),
 				report
 			});
 		}
@@ -391,7 +262,7 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 	}
 	const file = targets[0] ?? files[0] ?? "";
 	const wantStep = Boolean(opts.step) || Boolean(opts.snapshot) || Boolean(opts.serve);
-	const { report, step, glb, shape } = await require_diff.runPart((0, node_path.resolve)(file), {
+	const { report, step, glb, shape } = await require_usingCtx.runPart((0, node_path.resolve)(file), {
 		step: wantStep,
 		glb: Boolean(opts.glb),
 		check: Boolean(opts.check),
@@ -419,27 +290,27 @@ program.command("verify", { isDefault: true }).argument("<files...>", "path(s) o
 			}
 		} else if (opts.snapshot) process.stderr.write("snapshot skipped: STEP export produced no artifact\n");
 	} catch (e) {
-		require_diff.pushError(report, { message: `artifact write failed: ${e.message}` });
+		require_usingCtx.pushError(report, { message: `artifact write failed: ${e.message}` });
 	} finally {
-		disposeShape(shape);
+		require_disposeShape.disposeShape(shape);
 	}
-	const json = require_diff.serializeReport(report);
+	const json = require_usingCtx.serializeReport(report);
 	if (opts.json && opts.json !== "-") (0, node_fs.writeFileSync)(opts.json, json);
 	process.stdout.write(json + "\n");
-	if (!require_diff.reportOk(report)) process.exitCode = 1;
+	if (!require_usingCtx.reportOk(report)) process.exitCode = 1;
 	if (opts.expectInvalid || opts.expectCode) {
 		const codes = [...new Set(report.errorInfos.map((e) => e.code).filter((c) => Boolean(c)))];
-		const valid = require_diff.reportOk(report);
+		const valid = require_usingCtx.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;
 	}
-	if (Boolean(opts.serve) && stepPath !== void 0 && require_diff.reportOk(report) && stepPath) {
+	if (Boolean(opts.serve) && stepPath !== void 0 && require_usingCtx.reportOk(report) && stepPath) {
 		const { serve } = await Promise.resolve().then(() => require("../snapshot/serve.cjs"));
 		const { url, reused } = await serve({ file: stepPath });
 		process.stderr.write(`viewer: ${url}\n`);
-		if (!reused && opts.open && shouldAutoOpen()) openBrowser(url);
+		if (!reused && opts.open && require_openBrowser.shouldAutoOpen()) require_openBrowser.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, b) => {
@@ -462,14 +333,14 @@ program.command("snapshot").argument("<file>", "path to a .brep.ts module; rende
 	const resolved = (0, node_path.resolve)(file);
 	const base = opts.out ? (0, node_path.resolve)(opts.out) : `${resolved}-shots`;
 	const outDir = opts.label ? (0, node_path.join)(base, opts.label) : base;
-	const { report, step, shape } = await require_diff.runPart(resolved, {
+	const { report, step, shape } = await require_usingCtx.runPart(resolved, {
 		step: true,
 		metrics: true
 	});
 	try {
 		if (!step) {
 			process.stderr.write("snapshot: part produced no STEP — nothing to render\n");
-			process.stdout.write(require_diff.serializeReport(report) + "\n");
+			process.stdout.write(require_usingCtx.serializeReport(report) + "\n");
 			process.exitCode = 1;
 			return;
 		}
@@ -477,7 +348,7 @@ program.command("snapshot").argument("<file>", "path to a .brep.ts module; rende
 		(0, node_fs.writeFileSync)(stepPath, Buffer.from(step));
 		const shoot = await loadSnapshotShoot();
 		if (!shoot) {
-			process.stdout.write(require_diff.serializeReport(report) + "\n");
+			process.stdout.write(require_usingCtx.serializeReport(report) + "\n");
 			return;
 		}
 		const section = aimedSection(report.manufacturability?.bores ?? [], report.measurements.bounds);
@@ -491,7 +362,7 @@ program.command("snapshot").argument("<file>", "path to a .brep.ts module; rende
 		});
 		for (const p of pngs) process.stdout.write(`${p}\n`);
 	} finally {
-		disposeShape(shape);
+		require_disposeShape.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, opts) => {
@@ -506,40 +377,22 @@ program.command("watch").argument("<file>", "path to a .brep.ts module; re-verif
 	const path = (0, node_path.resolve)(file);
 	const run = async (fresh) => {
 		try {
-			const { report, shape } = await require_diff.runPart(path, { freshImport: fresh });
+			const { report, shape } = await require_usingCtx.runPart(path, { freshImport: fresh });
 			try {
-				process.stdout.write(require_diff.serializeReport(report) + "\n");
+				process.stdout.write(require_usingCtx.serializeReport(report) + "\n");
 			} finally {
-				disposeShape(shape);
+				require_disposeShape.disposeShape(shape);
 			}
 		} catch (e) {
 			process.stderr.write(`watch run failed: ${e.message}\n`);
 		}
 	};
-	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;
-		}
-		start(true);
-	};
-	const { trigger } = debounce(schedule, 150);
+	const runner = require_openBrowser.createSerialRunner(run);
+	const { trigger } = require_openBrowser.debounce(runner.trigger, 150);
 	process.stderr.write(`watching ${path} (Ctrl-C to stop)\n`);
-	start(false);
-	const stopWatching = watchTree(watchRootFor(path), (filename) => {
-		if (isWatchRelevant(filename)) trigger();
+	runner.start(false);
+	const stopWatching = require_openBrowser.watchTree(require_openBrowser.watchRootFor(path), (filename) => {
+		if (require_openBrowser.isWatchRelevant(filename)) trigger();
 	});
 	const stop = () => {
 		stopWatching();
@@ -548,7 +401,48 @@ program.command("watch").argument("<file>", "path to a .brep.ts module; re-verif
 	process.on("SIGINT", stop);
 	process.on("SIGTERM", stop);
 });
-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, opts) => {
+program.command("preview").argument("<file>", "path to a model module (.ts/.tsx); a families element tree renders per element").option("--watch", "re-evaluate on save and push updates to the open viewer tab").option("--write-only", "write artifacts without starting the viewer server (exits unless --watch)").option("--glb <out>", "write a merged GLB of the whole model").option("--json <out>", "write the JSON summary to this path").option("--port <n>", "viewer server port (default: OS-assigned)", (v) => parseInt(v, 10)).option("--no-open", "do not auto-open the browser").action(async (file, opts) => {
+	const { runPreview } = await Promise.resolve().then(() => require("../preview/preview.cjs"));
+	try {
+		await runPreview((0, node_path.resolve)(file), opts);
+	} catch (e) {
+		process.stderr.write(`preview failed: ${e.message}\n`);
+		process.exitCode = 1;
+	}
+});
+program.command("export").argument("<file>", "path to a part (.brep.ts) module; --3dm also accepts a model (.ts/.tsx) default-exporting a families element tree").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("--3dm", "write a Rhino .3dm (element-aware: one named object per element, layered)").option("--out <dir>", "output directory", ".").action(async (file, opts) => {
+	const path = (0, node_path.resolve)(file);
+	if (opts["3dm"] && (opts.step || opts.glb || opts.stl || opts.all)) {
+		process.stderr.write("--3dm cannot be combined with --step/--glb/--stl/--all\n");
+		process.exitCode = 1;
+		return;
+	}
+	if (opts["3dm"]) {
+		let run;
+		try {
+			({export3dm: run} = await Promise.resolve().then(() => require("../export3dm/export3dm.cjs")));
+		} catch {
+			process.stderr.write(".3dm export needs rhino3dm — run: npm i rhino3dm\n");
+			process.exitCode = 1;
+			return;
+		}
+		const outPath = (0, node_path.join)((0, node_path.resolve)(opts.out), stem(path) + ".3dm");
+		try {
+			const r = await run(path, outPath);
+			process.stderr.write(`wrote: ${outPath}\n`);
+			process.stdout.write(JSON.stringify({
+				ok: r.failed.length === 0,
+				written: [outPath],
+				elements: r.elements,
+				failed: r.failed
+			}, null, 2) + "\n");
+			if (r.failed.length > 0) process.exitCode = 1;
+		} catch (e) {
+			process.stderr.write(`3dm export failed: ${e.message}\n`);
+			process.exitCode = 1;
+		}
+		return;
+	}
 	const formats = opts.all ? {
 		step: true,
 		glb: true,
@@ -559,11 +453,11 @@ program.command("export").argument("<file>", "path to a .brep.ts module").option
 		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.stderr.write("no formats requested — pass --step/--glb/--stl/--3dm or --all\n");
 		process.exitCode = 1;
 		return;
 	}
-	const result = await exportPart((0, node_path.resolve)(file), formats, (0, node_path.resolve)(opts.out));
+	const result = await exportPart(path, formats, (0, node_path.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({