brepjs 18.17.0 → 18.19.0

package/dist/brepjs.cjs

@@ -1,36 +1,36 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_textBlueprints = require("./textBlueprints-Dy4xulfR.cjs");
-const require_shapeTypes = require("./shapeTypes-xj3nxBTM.cjs");
+const require_textBlueprints = require("./textBlueprints-CHh9SChA.cjs");
+const require_shapeTypes = require("./shapeTypes-BpKhed-9.cjs");
 const require_vec3 = require("./vec3-S4Oh59IX.cjs");
 const require_occtWasmAdapter = require("./occtWasmAdapter-C2VW-uYg.cjs");
-const require_errors = require("./errors-Dv6pfNct.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-D0v-c2Xk.cjs");
+const require_errors = require("./errors-BiY8-q1s.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-CHsPXNbI.cjs");
 const require_constants = require("./constants-DTorLmes.cjs");
 const require_types = require("./types-CDkxah-M.cjs");
 const require_vecOps = require("./vecOps-D7xplSx8.cjs");
-const require_planeOps = require("./planeOps-CH4ruLuj.cjs");
-const require_faceFns = require("./faceFns-CbpUuSSF.cjs");
-const require_shapeFns = require("./shapeFns-D1gHNJJY.cjs");
-const require_curveFns = require("./curveFns-Ds0e7i2y.cjs");
-const require_meshFns = require("./meshFns-Dr3EAM7B.cjs");
+const require_planeOps = require("./planeOps-2EyPq0tU.cjs");
+const require_faceFns = require("./faceFns-BbESdudy.cjs");
+const require_shapeFns = require("./shapeFns-CHTLdb_n.cjs");
+const require_curveFns = require("./curveFns-CcheHkr4.cjs");
+const require_meshFns = require("./meshFns-CFMr9FBb.cjs");
 const require_arrayAccess = require("./arrayAccess-7pTWqkJu.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-BkgewbNs.cjs");
-const require_booleanFns = require("./booleanFns-COUVhZlF.cjs");
-const require_primitiveFns = require("./primitiveFns-CvE88XaR.cjs");
-const require_historyFns = require("./historyFns-CdhKQcbS.cjs");
-const require_blueprintSketcher = require("./blueprintSketcher-D2awQyoi.cjs");
-const require_helpers = require("./helpers-CrH0p3GU.cjs");
-const require_drawFns = require("./drawFns-BvqZW_fK.cjs");
-const require_solidBuilders = require("./solidBuilders-lBO5Fk9Z.cjs");
-const require_measureFns = require("./measureFns-DuXAfU3o.cjs");
-const require_cornerFinder = require("./cornerFinder-Cm58LsyX.cjs");
-const require_boolean2D = require("./boolean2D-BlazC0Yu.cjs");
-const require_blueprintFns = require("./blueprintFns-j2YskNJl.cjs");
-const require_importFns = require("./importFns-FvsXxxRS.cjs");
-const require_extrudeFns = require("./extrudeFns-BZAIPeYY.cjs");
-const require_cameraFns = require("./cameraFns-leKP1O1t.cjs");
-const require_textMetrics = require("./textMetrics-DcIcFPtV.cjs");
-const require_shapeRefFns = require("./shapeRefFns-BkVipOTE.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-frj7YRrD.cjs");
+const require_booleanFns = require("./booleanFns-CD25YZGm.cjs");
+const require_primitiveFns = require("./primitiveFns-YpYBx4Pd.cjs");
+const require_historyFns = require("./historyFns-DHOoBh6G.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-Cr9A-R8I.cjs");
+const require_helpers = require("./helpers-BU3ANziG.cjs");
+const require_drawFns = require("./drawFns-CuzUHFyD.cjs");
+const require_solidBuilders = require("./solidBuilders-BlBaFSCS.cjs");
+const require_measureFns = require("./measureFns-BkoPw5JT.cjs");
+const require_cornerFinder = require("./cornerFinder-CXN1IxPg.cjs");
+const require_boolean2D = require("./boolean2D-BZ1UjpjX.cjs");
+const require_blueprintFns = require("./blueprintFns-Dkccxo6d.cjs");
+const require_importFns = require("./importFns-CsRJ9lbm.cjs");
+const require_extrudeFns = require("./extrudeFns-BwU4ng1V.cjs");
+const require_cameraFns = require("./cameraFns-CR2inEBU.cjs");
+const require_textMetrics = require("./textMetrics-CKNdQX02.cjs");
+const require_shapeRefFns = require("./shapeRefFns-CDRLEUik.cjs");
 const require_workerHandler = require("./workerHandler-C7seK7H-.cjs");
 //#region src/topology/shapeBooleans.ts
 var BOPAlgo_GlueShift = 1;
@@ -2879,12 +2879,12 @@ function makeInternalGearProfileWire(params) {
 }
 function makeProfileWire(params, isInternal) {
 	try {
-		var _usingCtx$2 = require_shapeTypes._usingCtx();
+		var _usingCtx$3 = require_shapeTypes._usingCtx();
 		const { teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, samples = adaptiveSampleCount(moduleSize) } = params;
 		if (teeth < 4) return require_errors.err(require_errors.validationError("GEAR_TEETH_TOO_FEW", `gear needs ≥ 4 teeth, got ${teeth}`));
 		if (moduleSize <= 0) return require_errors.err(require_errors.validationError("GEAR_MODULE_NONPOSITIVE", `module must be > 0, got ${moduleSize}`));
 		const tm = gearGeometry(teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, isInternal);
-		const scope = _usingCtx$2.u(new require_shapeTypes.DisposalScope());
+		const scope = _usingCtx$3.u(new require_shapeTypes.DisposalScope());
 		const allEdges = [];
 		for (let i = 0; i < teeth; i++) {
 			const periodEdges = buildToothPeriodEdges(tm, i, teeth, samples, scope);
@@ -2895,9 +2895,9 @@ function makeProfileWire(params, isInternal) {
 		if (require_errors.isErr(wireResult)) return wireResult;
 		return require_errors.ok(wireResult.value);
 	} catch (_) {
-		_usingCtx$2.e = _;
+		_usingCtx$3.e = _;
 	} finally {
-		_usingCtx$2.d();
+		_usingCtx$3.d();
 	}
 }
 //#endregion
@@ -3078,8 +3078,8 @@ function resolvePlanetaryParams(params) {
 }
 function makeOuterCircleWire(radius) {
 	try {
-		var _usingCtx$1 = require_shapeTypes._usingCtx();
-		const wireResult = require_surfaceBuilders.assembleWire([_usingCtx$1.u(new require_shapeTypes.DisposalScope()).register(require_surfaceBuilders.makeCircle(radius, [
+		var _usingCtx$2 = require_shapeTypes._usingCtx();
+		const wireResult = require_surfaceBuilders.assembleWire([_usingCtx$2.u(new require_shapeTypes.DisposalScope()).register(require_surfaceBuilders.makeCircle(radius, [
 			0,
 			0,
 			0
@@ -3091,9 +3091,9 @@ function makeOuterCircleWire(radius) {
 		if (require_errors.isErr(wireResult)) return wireResult;
 		return require_errors.ok(wireResult.value);
 	} catch (_) {
-		_usingCtx$1.e = _;
+		_usingCtx$2.e = _;
 	} finally {
-		_usingCtx$1.d();
+		_usingCtx$2.d();
 	}
 }
 function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
@@ -3412,6 +3412,1687 @@ var patterns_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
 	linearPattern: () => require_historyFns.linearPattern
 });
 //#endregion
+//#region src/csg/hash.ts
+var FNV_OFFSET = 14695981039346656037n;
+var FNV_PRIME = 1099511628211n;
+var MASK_64 = 18446744073709551615n;
+function fnvInit() {
+	return FNV_OFFSET;
+}
+function fnvMixByte(h, byte) {
+	return (h ^ BigInt(byte & 255)) * FNV_PRIME & MASK_64;
+}
+function fnvMixBytes(h, bytes) {
+	let r = h;
+	for (let i = 0; i < bytes.length; i++) r = fnvMixByte(r, bytes[i] ?? 0);
+	return r;
+}
+var ENCODER = new TextEncoder();
+function fnvMixString(h, s) {
+	return fnvMixBytes(h, ENCODER.encode(s));
+}
+var SCRATCH = /* @__PURE__ */ new ArrayBuffer(8);
+var SCRATCH_VIEW = new DataView(SCRATCH);
+var SCRATCH_BYTES = new Uint8Array(SCRATCH);
+function fnvMixNumber(h, n) {
+	SCRATCH_VIEW.setFloat64(0, Object.is(n, -0) ? 0 : n);
+	return fnvMixBytes(h, SCRATCH_BYTES);
+}
+function fnvMixHash(h, child) {
+	let r = h;
+	let v = child & MASK_64;
+	for (let i = 0; i < 8; i++) {
+		r = fnvMixByte(r, Number(v & 255n));
+		v >>= 8n;
+	}
+	return r;
+}
+function fnvMixInt32(h, n) {
+	let r = h;
+	let v = n | 0;
+	for (let i = 0; i < 4; i++) {
+		r = fnvMixByte(r, v & 255);
+		v >>>= 8;
+	}
+	return r;
+}
+function fnvMixBool(h, b) {
+	return fnvMixByte(h, b ? 1 : 0);
+}
+function toHex(h) {
+	return (h & MASK_64).toString(16).padStart(16, "0");
+}
+//#endregion
+//#region src/csg/expressions.ts
+var EMPTY_DEPS$1 = /* @__PURE__ */ new Set();
+function startHash$1(tag) {
+	return fnvMixString(fnvInit(), tag);
+}
+function numLit(value) {
+	return {
+		kind: "NumLit",
+		value,
+		structuralHash: fnvMixNumber(startHash$1("NumLit"), value),
+		freeParams: EMPTY_DEPS$1
+	};
+}
+function vec3Lit(value) {
+	let h = startHash$1("Vec3Lit");
+	for (const n of value) h = fnvMixNumber(h, n);
+	return {
+		kind: "Vec3Lit",
+		value,
+		structuralHash: h,
+		freeParams: EMPTY_DEPS$1
+	};
+}
+function vec2Lit(value) {
+	let h = startHash$1("Vec2Lit");
+	for (const n of value) h = fnvMixNumber(h, n);
+	return {
+		kind: "Vec2Lit",
+		value,
+		structuralHash: h,
+		freeParams: EMPTY_DEPS$1
+	};
+}
+function param(name) {
+	return {
+		kind: "Param",
+		name,
+		structuralHash: fnvMixString(startHash$1("Param"), name),
+		freeParams: new Set([name])
+	};
+}
+function binOp(op, a, b) {
+	let h = fnvMixString(startHash$1("BinOp"), op);
+	h = fnvMixHash(h, a.structuralHash);
+	h = fnvMixHash(h, b.structuralHash);
+	return {
+		kind: "BinOp",
+		op,
+		a,
+		b,
+		structuralHash: h,
+		freeParams: unionParams(a.freeParams, b.freeParams)
+	};
+}
+function unaryOp(op, arg) {
+	let h = fnvMixString(startHash$1("UnaryOp"), op);
+	h = fnvMixHash(h, arg.structuralHash);
+	return {
+		kind: "UnaryOp",
+		op,
+		arg,
+		structuralHash: h,
+		freeParams: arg.freeParams
+	};
+}
+function component(vec, index) {
+	let h = fnvMixInt32(startHash$1("Component"), index);
+	h = fnvMixHash(h, vec.structuralHash);
+	return {
+		kind: "Component",
+		vec,
+		index,
+		structuralHash: h,
+		freeParams: vec.freeParams
+	};
+}
+function buildVec(dim, components) {
+	let h = fnvMixInt32(startHash$1("BuildVec"), dim);
+	const deps = /* @__PURE__ */ new Set();
+	for (const c of components) {
+		h = fnvMixHash(h, c.structuralHash);
+		for (const p of c.freeParams) deps.add(p);
+	}
+	return {
+		kind: "BuildVec",
+		dim,
+		components,
+		structuralHash: h,
+		freeParams: deps
+	};
+}
+var add = (a, b) => binOp("+", a, b);
+var mul = (a, b) => binOp("*", a, b);
+function asScalarExpr(input) {
+	return typeof input === "number" ? numLit(input) : input;
+}
+function asVecExpr(input, dim) {
+	if (!Array.isArray(input)) return input;
+	const arr = input;
+	if (arr.every((v) => typeof v === "number")) return dim === 3 ? vec3Lit([
+		arr[0],
+		arr[1],
+		arr[2]
+	]) : vec2Lit([arr[0], arr[1]]);
+	return buildVec(dim, arr.map(asScalarExpr));
+}
+function asVec3Expr(input) {
+	return asVecExpr(input, 3);
+}
+function asVec2Expr(input) {
+	return asVecExpr(input, 2);
+}
+function unionParams(a, b) {
+	if (a.size === 0) return b;
+	if (b.size === 0) return a;
+	const out = new Set(a);
+	for (const x of b) out.add(x);
+	return out;
+}
+function isNumber$2(v) {
+	return typeof v === "number";
+}
+function expectNumber(v, where) {
+	if (isNumber$2(v)) return require_errors.ok(v);
+	return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${where}: expected number, got ${Array.isArray(v) ? `vector(${v.length})` : typeof v}`));
+}
+function expectVecLen(v, len, where) {
+	if (Array.isArray(v) && v.length === len) return require_errors.ok(v);
+	return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${where}: expected Vec${len}, got ${isNumber$2(v) ? "number" : `vector(${v.length})`}`));
+}
+function evalExpr(expr, env) {
+	switch (expr.kind) {
+		case "NumLit": return require_errors.ok(expr.value);
+		case "Vec3Lit": return require_errors.ok(expr.value);
+		case "Vec2Lit": return require_errors.ok(expr.value);
+		case "Param": {
+			const v = env[expr.name];
+			if (v === void 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `unbound param: ${expr.name}`));
+			return require_errors.ok(v);
+		}
+		case "BinOp": return evalBinOp(expr, env);
+		case "UnaryOp": return evalUnaryOp(expr, env);
+		case "Component": return evalComponent(expr, env);
+		case "BuildVec": return evalBuildVec(expr, env);
+	}
+}
+function evalBinOp(expr, env) {
+	const ar = evalExpr(expr.a, env);
+	if (!ar.ok) return ar;
+	const br = evalExpr(expr.b, env);
+	if (!br.ok) return br;
+	const an = expectNumber(ar.value, `BinOp(${expr.op}).a`);
+	if (!an.ok) return an;
+	const bn = expectNumber(br.value, `BinOp(${expr.op}).b`);
+	if (!bn.ok) return bn;
+	switch (expr.op) {
+		case "+": return require_errors.ok(an.value + bn.value);
+		case "-": return require_errors.ok(an.value - bn.value);
+		case "*": return require_errors.ok(an.value * bn.value);
+		case "/":
+			if (bn.value === 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `BinOp(/): division by zero`));
+			return require_errors.ok(an.value / bn.value);
+	}
+}
+function evalUnaryOp(expr, env) {
+	const ar = evalExpr(expr.arg, env);
+	if (!ar.ok) return ar;
+	const an = expectNumber(ar.value, `UnaryOp(${expr.op})`);
+	if (!an.ok) return an;
+	const n = an.value;
+	switch (expr.op) {
+		case "neg": return require_errors.ok(-n);
+		case "sin": return require_errors.ok(Math.sin(n));
+		case "cos": return require_errors.ok(Math.cos(n));
+		case "sqrt": return require_errors.ok(Math.sqrt(n));
+		case "abs": return require_errors.ok(Math.abs(n));
+	}
+}
+function evalComponent(expr, env) {
+	const vr = evalExpr(expr.vec, env);
+	if (!vr.ok) return vr;
+	if (isNumber$2(vr.value)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `Component: cannot index a scalar`));
+	const v = vr.value;
+	const c = v[expr.index];
+	if (c === void 0) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `Component: index ${expr.index} out of range for Vec${v.length}`));
+	return require_errors.ok(c);
+}
+function evalBuildVec(expr, env) {
+	if (expr.components.length !== expr.dim) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `BuildVec(${expr.dim}): expected ${expr.dim} components, got ${expr.components.length}`));
+	const out = [];
+	for (const c of expr.components) {
+		const r = evalExpr(c, env);
+		if (!r.ok) return r;
+		const n = expectNumber(r.value, "BuildVec.component");
+		if (!n.ok) return n;
+		out.push(n.value);
+	}
+	return require_errors.ok(expr.dim === 2 ? [out[0], out[1]] : [
+		out[0],
+		out[1],
+		out[2]
+	]);
+}
+function evalScalar(expr, env, where) {
+	const r = evalExpr(expr, env);
+	if (!r.ok) return r;
+	return expectNumber(r.value, where);
+}
+function evalVec3(expr, env, where) {
+	const r = evalExpr(expr, env);
+	if (!r.ok) return r;
+	const v = expectVecLen(r.value, 3, where);
+	if (!v.ok) return v;
+	const [a, b, c] = v.value;
+	return require_errors.ok([
+		a,
+		b,
+		c
+	]);
+}
+function projectEnv(env, deps) {
+	if (deps.size === 0) return Object.freeze({});
+	const out = {};
+	for (const k of deps) {
+		const v = env[k];
+		if (v !== void 0) out[k] = v;
+	}
+	return Object.freeze(out);
+}
+//#endregion
+//#region src/csg/builders.ts
+var EMPTY_DEPS = /* @__PURE__ */ new Set();
+function startHash(tag) {
+	return fnvMixString(fnvInit(), tag);
+}
+function mix(h, x) {
+	return fnvMixHash(h, x.structuralHash);
+}
+function mixOptExpr(h, e) {
+	if (e === void 0) return fnvMixBool(h, false);
+	return mix(fnvMixBool(h, true), e);
+}
+function mixOptNumber(h, n) {
+	if (n === void 0) return fnvMixBool(h, false);
+	return fnvMixNumber(fnvMixBool(h, true), n);
+}
+function depsOf(...sources) {
+	const acc = /* @__PURE__ */ new Set();
+	for (const s of sources) {
+		if (!s) continue;
+		for (const p of s.freeParams) acc.add(p);
+	}
+	return acc.size === 0 ? EMPTY_DEPS : acc;
+}
+function box$1(x, y, z) {
+	const xe = asScalarExpr(x);
+	const ye = asScalarExpr(y);
+	const ze = asScalarExpr(z);
+	let h = startHash("Box");
+	h = mix(mix(mix(h, xe), ye), ze);
+	return {
+		kind: "Box",
+		x: xe,
+		y: ye,
+		z: ze,
+		structuralHash: h,
+		freeParams: depsOf(xe, ye, ze)
+	};
+}
+function sphere$1(radius) {
+	const re = asScalarExpr(radius);
+	return {
+		kind: "Sphere",
+		radius: re,
+		structuralHash: mix(startHash("Sphere"), re),
+		freeParams: re.freeParams
+	};
+}
+function cylinder$1(radius, height) {
+	const re = asScalarExpr(radius);
+	const he = asScalarExpr(height);
+	return {
+		kind: "Cylinder",
+		radius: re,
+		height: he,
+		structuralHash: mix(mix(startHash("Cylinder"), re), he),
+		freeParams: depsOf(re, he)
+	};
+}
+function cone$1(radius1, radius2, height) {
+	const r1 = asScalarExpr(radius1);
+	const r2 = asScalarExpr(radius2);
+	const he = asScalarExpr(height);
+	let h = startHash("Cone");
+	h = mix(mix(mix(h, r1), r2), he);
+	return {
+		kind: "Cone",
+		radius1: r1,
+		radius2: r2,
+		height: he,
+		structuralHash: h,
+		freeParams: depsOf(r1, r2, he)
+	};
+}
+function torus$1(majorRadius, minorRadius) {
+	const ma = asScalarExpr(majorRadius);
+	const mi = asScalarExpr(minorRadius);
+	return {
+		kind: "Torus",
+		majorRadius: ma,
+		minorRadius: mi,
+		structuralHash: mix(mix(startHash("Torus"), ma), mi),
+		freeParams: depsOf(ma, mi)
+	};
+}
+function polygon$1(points) {
+	const pts = points.map(asVec3Expr);
+	let h = fnvMixInt32(startHash("Polygon"), pts.length);
+	for (const p of pts) h = mix(h, p);
+	return {
+		kind: "Polygon",
+		points: pts,
+		structuralHash: h,
+		freeParams: depsOf(...pts)
+	};
+}
+function circle$1(radius) {
+	const re = asScalarExpr(radius);
+	return {
+		kind: "Circle",
+		radius: re,
+		structuralHash: mix(startHash("Circle"), re),
+		freeParams: re.freeParams
+	};
+}
+function line$1(from, to) {
+	const fe = asVec3Expr(from);
+	const te = asVec3Expr(to);
+	return {
+		kind: "Line",
+		from: fe,
+		to: te,
+		structuralHash: mix(mix(startHash("Line"), fe), te),
+		freeParams: depsOf(fe, te)
+	};
+}
+function vertex$1(point) {
+	const pe = asVec3Expr(point);
+	return {
+		kind: "Vertex",
+		point: pe,
+		structuralHash: mix(startHash("Vertex"), pe),
+		freeParams: pe.freeParams
+	};
+}
+function emptyOf(output) {
+	return {
+		kind: "Empty",
+		output,
+		structuralHash: fnvMixString(startHash("Empty"), output),
+		freeParams: EMPTY_DEPS
+	};
+}
+function emptySolid() {
+	return emptyOf("Solid");
+}
+function emptyFace() {
+	return emptyOf("Face");
+}
+function emptyWire() {
+	return emptyOf("Wire");
+}
+function binaryBoolHash(tag, a, b, tol) {
+	return mixOptNumber(mix(mix(startHash(tag), a), b), tol);
+}
+function fuse$1(a, b, tolerance) {
+	return {
+		kind: "Fuse",
+		a,
+		b,
+		tolerance,
+		structuralHash: binaryBoolHash("Fuse", a, b, tolerance),
+		freeParams: depsOf(a, b)
+	};
+}
+function cut$1(a, b, tolerance) {
+	return {
+		kind: "Cut",
+		a,
+		b,
+		tolerance,
+		structuralHash: binaryBoolHash("Cut", a, b, tolerance),
+		freeParams: depsOf(a, b)
+	};
+}
+function intersect$1(a, b, tolerance) {
+	return {
+		kind: "Intersect",
+		a,
+		b,
+		tolerance,
+		structuralHash: binaryBoolHash("Intersect", a, b, tolerance),
+		freeParams: depsOf(a, b)
+	};
+}
+function fuseAll$1(shapes, tolerance) {
+	let h = fnvMixInt32(startHash("FuseAll"), shapes.length);
+	for (const s of shapes) h = mix(h, s);
+	h = mixOptNumber(h, tolerance);
+	return {
+		kind: "FuseAll",
+		shapes,
+		tolerance,
+		structuralHash: h,
+		freeParams: depsOf(...shapes)
+	};
+}
+function cutAll$1(base, tools, tolerance) {
+	let h = mix(startHash("CutAll"), base);
+	h = fnvMixInt32(h, tools.length);
+	for (const t of tools) h = mix(h, t);
+	h = mixOptNumber(h, tolerance);
+	return {
+		kind: "CutAll",
+		base,
+		tools,
+		tolerance,
+		structuralHash: h,
+		freeParams: depsOf(base, ...tools)
+	};
+}
+function optVec3$1(v) {
+	return v !== void 0 ? asVec3Expr(v) : void 0;
+}
+function translate$1(target, vector) {
+	const ve = asVec3Expr(vector);
+	return {
+		kind: "Translate",
+		target,
+		vector: ve,
+		structuralHash: mix(mix(startHash("Translate"), target), ve),
+		freeParams: depsOf(target, ve)
+	};
+}
+function rotate$1(target, angle, options) {
+	const ae = asScalarExpr(angle);
+	const axisE = optVec3$1(options?.axis);
+	const atE = optVec3$1(options?.at);
+	let h = mix(mix(startHash("Rotate"), target), ae);
+	h = mixOptExpr(h, axisE);
+	h = mixOptExpr(h, atE);
+	return {
+		kind: "Rotate",
+		target,
+		angle: ae,
+		axis: axisE,
+		at: atE,
+		structuralHash: h,
+		freeParams: depsOf(target, ae, axisE, atE)
+	};
+}
+function scale$1(target, factor, options) {
+	const fe = asScalarExpr(factor);
+	const cE = optVec3$1(options?.center);
+	let h = mix(mix(startHash("Scale"), target), fe);
+	h = mixOptExpr(h, cE);
+	return {
+		kind: "Scale",
+		target,
+		factor: fe,
+		center: cE,
+		structuralHash: h,
+		freeParams: depsOf(target, fe, cE)
+	};
+}
+function mirror$1(target, options) {
+	const nE = optVec3$1(options?.normal);
+	const atE = optVec3$1(options?.at);
+	let h = mix(startHash("Mirror"), target);
+	h = mixOptExpr(h, nE);
+	h = mixOptExpr(h, atE);
+	return {
+		kind: "Mirror",
+		target,
+		normal: nE,
+		at: atE,
+		structuralHash: h,
+		freeParams: depsOf(target, nE, atE)
+	};
+}
+function compound$1(children) {
+	let h = fnvMixInt32(startHash("Compound"), children.length);
+	for (const c of children) h = mix(h, c);
+	return {
+		kind: "Compound",
+		children,
+		structuralHash: h,
+		freeParams: depsOf(...children)
+	};
+}
+//#endregion
+//#region src/csg/types.ts
+function outputKindOf(node) {
+	switch (node.kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus": return "Solid";
+		case "Polygon": return "Face";
+		case "Circle":
+		case "Line": return "Edge";
+		case "Vertex": return "Vertex";
+		case "Empty": return node.output;
+		case "Fuse":
+		case "Cut":
+		case "Intersect": return outputKindOf(node.a);
+		case "FuseAll": return node.shapes[0] ? outputKindOf(node.shapes[0]) : "Solid";
+		case "CutAll": return outputKindOf(node.base);
+		case "Translate":
+		case "Rotate":
+		case "Scale":
+		case "Mirror": return outputKindOf(node.target);
+		case "Compound": return "Compound";
+	}
+}
+//#endregion
+//#region src/csg/evaluators/primitives.ts
+function evalBox(node, ctx) {
+	const x = evalScalar(node.x, ctx.env, "Box.x");
+	if (!x.ok) return x;
+	const y = evalScalar(node.y, ctx.env, "Box.y");
+	if (!y.ok) return y;
+	const z = evalScalar(node.z, ctx.env, "Box.z");
+	if (!z.ok) return z;
+	return require_errors.ok(require_primitiveFns.box(x.value, y.value, z.value));
+}
+function evalSphere(node, ctx) {
+	const r = evalScalar(node.radius, ctx.env, "Sphere.radius");
+	if (!r.ok) return r;
+	return require_errors.ok(require_primitiveFns.sphere(r.value));
+}
+function evalCylinder(node, ctx) {
+	const r = evalScalar(node.radius, ctx.env, "Cylinder.radius");
+	if (!r.ok) return r;
+	const h = evalScalar(node.height, ctx.env, "Cylinder.height");
+	if (!h.ok) return h;
+	return require_errors.ok(require_primitiveFns.cylinder(r.value, h.value));
+}
+function evalCone(node, ctx) {
+	const r1 = evalScalar(node.radius1, ctx.env, "Cone.radius1");
+	if (!r1.ok) return r1;
+	const r2 = evalScalar(node.radius2, ctx.env, "Cone.radius2");
+	if (!r2.ok) return r2;
+	const h = evalScalar(node.height, ctx.env, "Cone.height");
+	if (!h.ok) return h;
+	return require_errors.ok(require_primitiveFns.cone(r1.value, r2.value, h.value));
+}
+function evalTorus(node, ctx) {
+	const ma = evalScalar(node.majorRadius, ctx.env, "Torus.majorRadius");
+	if (!ma.ok) return ma;
+	const mi = evalScalar(node.minorRadius, ctx.env, "Torus.minorRadius");
+	if (!mi.ok) return mi;
+	return require_errors.ok(require_primitiveFns.torus(ma.value, mi.value));
+}
+function evalPolygon(node, ctx) {
+	const pts = [];
+	for (const p of node.points) {
+		const r = evalVec3(p, ctx.env, "Polygon.point");
+		if (!r.ok) return r;
+		pts.push(r.value);
+	}
+	return require_primitiveFns.polygon(pts);
+}
+function evalCircle(node, ctx) {
+	const r = evalScalar(node.radius, ctx.env, "Circle.radius");
+	if (!r.ok) return r;
+	return require_errors.ok(require_primitiveFns.circle(r.value));
+}
+function evalLine(node, ctx) {
+	const f = evalVec3(node.from, ctx.env, "Line.from");
+	if (!f.ok) return f;
+	const t = evalVec3(node.to, ctx.env, "Line.to");
+	if (!t.ok) return t;
+	return require_errors.ok(require_primitiveFns.line(f.value, t.value));
+}
+function evalVertex(node, ctx) {
+	const p = evalVec3(node.point, ctx.env, "Vertex.point");
+	if (!p.ok) return p;
+	return require_errors.ok(require_primitiveFns.vertex(p.value));
+}
+//#endregion
+//#region src/csg/evaluators/booleans.ts
+/**
+* Evaluators for CSG boolean nodes.
+*
+* Identity short-circuits are correctness invariants, not optimisations:
+*   Fuse with an Empty operand: short-circuits to the other operand
+*   Cut with an Empty tool:     short-circuits to the base
+*   Intersect with any Empty:   errors (no empty-solid representation)
+*
+* The optimizer pass handles broader rewrites; these inline checks just
+* keep the evaluator from feeding null operands to the kernel.
+*/
+function emptyResult$1(kind) {
+	return require_errors.err(require_errors.computationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${kind}: empty result has no kernel representation`));
+}
+function resolveOperand(ctx, node, where) {
+	const r = ctx.evalNode(node);
+	if (!r.ok) return r;
+	if (!require_shapeTypes.isShape3D(r.value)) return require_errors.err(require_errors.typeCastError(require_errors.BrepErrorCode.CSG_NOT_3D, `${where}: operand did not produce a 3D shape`));
+	return require_errors.ok(r.value);
+}
+function boolOptions(node, ctx) {
+	return {
+		unsafe: true,
+		fuzzyValue: node.tolerance ?? ctx.tolerance
+	};
+}
+function evalFuse(node, ctx) {
+	if (node.a.kind === "Empty") return ctx.evalNode(node.b);
+	if (node.b.kind === "Empty") return ctx.evalNode(node.a);
+	const a = resolveOperand(ctx, node.a, "Fuse.a");
+	if (!a.ok) return a;
+	const b = resolveOperand(ctx, node.b, "Fuse.b");
+	if (!b.ok) return b;
+	return require_booleanFns.fuse(a.value, b.value, boolOptions(node, ctx));
+}
+function evalCut(node, ctx) {
+	if (node.a.kind === "Empty") return emptyResult$1("Cut");
+	if (node.b.kind === "Empty") return ctx.evalNode(node.a);
+	const a = resolveOperand(ctx, node.a, "Cut.a");
+	if (!a.ok) return a;
+	const b = resolveOperand(ctx, node.b, "Cut.b");
+	if (!b.ok) return b;
+	return require_booleanFns.cut(a.value, b.value, boolOptions(node, ctx));
+}
+function evalIntersect(node, ctx) {
+	if (node.a.kind === "Empty" || node.b.kind === "Empty") return emptyResult$1("Intersect");
+	const a = resolveOperand(ctx, node.a, "Intersect.a");
+	if (!a.ok) return a;
+	const b = resolveOperand(ctx, node.b, "Intersect.b");
+	if (!b.ok) return b;
+	return require_booleanFns.intersect(a.value, b.value, boolOptions(node, ctx));
+}
+function resolveAll(ctx, nodes, where) {
+	const out = [];
+	for (const n of nodes) {
+		const r = resolveOperand(ctx, n, where);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return require_errors.ok(out);
+}
+function evalFuseAll(node, ctx) {
+	const non = node.shapes.filter((s) => s.kind !== "Empty");
+	if (non.length === 0) return emptyResult$1("FuseAll");
+	if (non.length === 1 && non[0]) return ctx.evalNode(non[0]);
+	const resolved = resolveAll(ctx, non, "FuseAll.operand");
+	if (!resolved.ok) return resolved;
+	return require_booleanFns.fuseAll(resolved.value, boolOptions(node, ctx));
+}
+function evalCutAll(node, ctx) {
+	if (node.base.kind === "Empty") return emptyResult$1("CutAll");
+	const tools = node.tools.filter((s) => s.kind !== "Empty");
+	if (tools.length === 0) return ctx.evalNode(node.base);
+	const base = resolveOperand(ctx, node.base, "CutAll.base");
+	if (!base.ok) return base;
+	const resolved = resolveAll(ctx, tools, "CutAll.tool");
+	if (!resolved.ok) return resolved;
+	return require_booleanFns.cutAll(base.value, resolved.value, boolOptions(node, ctx));
+}
+//#endregion
+//#region src/csg/evaluators/transforms.ts
+function emptyResult(kind) {
+	return require_errors.err(require_errors.computationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `${kind}: cannot transform an Empty node`));
+}
+function optVec3(expr, env, where, fallback) {
+	return expr ? evalVec3(expr, env, where) : require_errors.ok(fallback);
+}
+function evalTranslate(node, ctx) {
+	if (node.target.kind === "Empty") return emptyResult("Translate");
+	const v = evalVec3(node.vector, ctx.env, "Translate.vector");
+	if (!v.ok) return v;
+	const r = ctx.evalNode(node.target);
+	if (!r.ok) return r;
+	return require_errors.ok(require_shapeFns.translate(r.value, v.value));
+}
+function evalRotate(node, ctx) {
+	if (node.target.kind === "Empty") return emptyResult("Rotate");
+	const a = evalScalar(node.angle, ctx.env, "Rotate.angle");
+	if (!a.ok) return a;
+	const axis = optVec3(node.axis, ctx.env, "Rotate.axis", [
+		0,
+		0,
+		1
+	]);
+	if (!axis.ok) return axis;
+	const at = optVec3(node.at, ctx.env, "Rotate.at", [
+		0,
+		0,
+		0
+	]);
+	if (!at.ok) return at;
+	const r = ctx.evalNode(node.target);
+	if (!r.ok) return r;
+	return require_errors.ok(require_shapeFns.rotate(r.value, a.value, at.value, axis.value));
+}
+function evalScale(node, ctx) {
+	if (node.target.kind === "Empty") return emptyResult("Scale");
+	const f = evalScalar(node.factor, ctx.env, "Scale.factor");
+	if (!f.ok) return f;
+	const center = optVec3(node.center, ctx.env, "Scale.center", [
+		0,
+		0,
+		0
+	]);
+	if (!center.ok) return center;
+	const r = ctx.evalNode(node.target);
+	if (!r.ok) return r;
+	return require_errors.ok(require_shapeFns.scale(r.value, f.value, center.value));
+}
+function evalMirror(node, ctx) {
+	if (node.target.kind === "Empty") return emptyResult("Mirror");
+	const normal = optVec3(node.normal, ctx.env, "Mirror.normal", [
+		1,
+		0,
+		0
+	]);
+	if (!normal.ok) return normal;
+	const at = optVec3(node.at, ctx.env, "Mirror.at", [
+		0,
+		0,
+		0
+	]);
+	if (!at.ok) return at;
+	const r = ctx.evalNode(node.target);
+	if (!r.ok) return r;
+	return require_errors.ok(require_shapeFns.mirror(r.value, normal.value, at.value));
+}
+//#endregion
+//#region src/csg/evaluators/compound.ts
+function evalCompound(node, ctx) {
+	const non = node.children.filter((c) => c.kind !== "Empty");
+	if (non.length === 0) return require_errors.err(require_errors.computationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, "Compound: cannot materialize a compound with zero non-empty children"));
+	const shapes = [];
+	for (const c of non) {
+		const r = ctx.evalNode(c);
+		if (!r.ok) return r;
+		shapes.push(r.value);
+	}
+	return require_errors.ok(require_primitiveFns.compound(shapes));
+}
+function evalEmpty() {
+	return require_errors.err(require_errors.computationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, "Empty: cannot materialize an Empty node directly — only valid as boolean/transform operand"));
+}
+//#endregion
+//#region src/csg/evaluate.ts
+function dispatch(node, ctx) {
+	switch (node.kind) {
+		case "Box": return evalBox(node, ctx);
+		case "Sphere": return evalSphere(node, ctx);
+		case "Cylinder": return evalCylinder(node, ctx);
+		case "Cone": return evalCone(node, ctx);
+		case "Torus": return evalTorus(node, ctx);
+		case "Polygon": return evalPolygon(node, ctx);
+		case "Circle": return evalCircle(node, ctx);
+		case "Line": return evalLine(node, ctx);
+		case "Vertex": return evalVertex(node, ctx);
+		case "Empty": return evalEmpty();
+		case "Fuse": return evalFuse(node, ctx);
+		case "Cut": return evalCut(node, ctx);
+		case "Intersect": return evalIntersect(node, ctx);
+		case "FuseAll": return evalFuseAll(node, ctx);
+		case "CutAll": return evalCutAll(node, ctx);
+		case "Translate": return evalTranslate(node, ctx);
+		case "Rotate": return evalRotate(node, ctx);
+		case "Scale": return evalScale(node, ctx);
+		case "Mirror": return evalMirror(node, ctx);
+		case "Compound": return evalCompound(node, ctx);
+	}
+}
+function hashExprValue(h, v) {
+	if (typeof v === "number") return fnvMixNumber(fnvMixBool(h, false), v);
+	let r = fnvMixBool(h, true);
+	r = fnvMixInt32(r, v.length);
+	for (const n of v) r = fnvMixNumber(r, n);
+	return r;
+}
+function projectedEnvHash(env, deps) {
+	if (deps.size === 0) return fnvInit();
+	const projected = projectEnv(env, deps);
+	const keys = Object.keys(projected).sort();
+	let h = fnvInit();
+	for (const k of keys) {
+		h = fnvMixString(h, k);
+		const v = projected[k];
+		if (v !== void 0) h = hashExprValue(h, v);
+	}
+	return h;
+}
+function cacheKey(node, env, kernelId, tolerance) {
+	const projHash = projectedEnvHash(env, node.freeParams);
+	const tolHash = tolerance === void 0 ? "d" : fnvMixNumber(fnvInit(), tolerance).toString(16);
+	return `${toHex(node.structuralHash)}:${kernelId}:${toHex(projHash)}:${tolHash}`;
+}
+var Evaluator = class {
+	scope = new require_shapeTypes.DisposalScope();
+	cache = /* @__PURE__ */ new Map();
+	registered = /* @__PURE__ */ new WeakSet();
+	kernelId;
+	defaultTolerance;
+	onStep;
+	hits = 0;
+	misses = 0;
+	constructor(options = {}) {
+		this.kernelId = options.kernel ?? require_shapeTypes.getActiveKernelId() ?? "unregistered";
+		this.defaultTolerance = options.tolerance;
+		if (options.onStep) this.onStep = options.onStep;
+	}
+	/**
+	* Materialize a CSG IR tree against the given parameter environment.
+	* The returned shape is borrowed — valid for as long as this Evaluator is
+	* not disposed. Callers must NOT call `.delete()` / `[Symbol.dispose]()`
+	* on the returned shape; that would invalidate the cache entry for every
+	* future call returning the same handle.
+	*/
+	evaluate(node, env = {}) {
+		return require_shapeTypes.withKernel(this.kernelId, () => this.evaluateInner(node, env));
+	}
+	evaluateInner(node, env) {
+		const key = cacheKey(node, env, this.kernelId, this.defaultTolerance);
+		const cached = this.cache.get(key);
+		if (cached !== void 0) {
+			this.hits++;
+			this.onStep?.({
+				node,
+				cacheKey: key,
+				cacheHit: true
+			});
+			return require_errors.ok(cached);
+		}
+		this.misses++;
+		const result = dispatch(node, {
+			env,
+			tolerance: this.defaultTolerance,
+			evalNode: (child) => this.evaluateInner(child, env)
+		});
+		if (!result.ok) return result;
+		if (!this.registered.has(result.value)) {
+			this.scope.register(result.value);
+			this.registered.add(result.value);
+		}
+		this.cache.set(key, result.value);
+		this.onStep?.({
+			node,
+			cacheKey: key,
+			cacheHit: false
+		});
+		return result;
+	}
+	cacheStats() {
+		return {
+			hits: this.hits,
+			misses: this.misses,
+			entries: this.cache.size
+		};
+	}
+	resetStats() {
+		this.hits = 0;
+		this.misses = 0;
+	}
+	[Symbol.dispose]() {
+		this.scope[Symbol.dispose]();
+		this.cache.clear();
+	}
+};
+/**
+* Run a callback with a fresh Evaluator that is disposed when the callback
+* returns. Sync-only: an async callback would resolve after disposal,
+* leaving borrowed shapes pointing at freed WASM memory. Mirrors the
+* Promise-guard pattern in `withKernel`.
+*/
+function withEvaluator(options, fn) {
+	try {
+		var _usingCtx$1 = require_shapeTypes._usingCtx();
+		const result = fn(_usingCtx$1.u(new Evaluator(options)));
+		if (result instanceof Promise) throw new Error("withEvaluator() callback returned a Promise. Async code must construct an Evaluator directly and dispose it manually — borrowed shapes would otherwise be freed before the Promise resolves.");
+		return result;
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+function toJSON(node) {
+	return {
+		csgVersion: 1,
+		root: nodeToJson(node)
+	};
+}
+function exprToJson(e) {
+	switch (e.kind) {
+		case "NumLit": return {
+			kind: "NumLit",
+			value: e.value
+		};
+		case "Vec3Lit": return {
+			kind: "Vec3Lit",
+			value: [
+				e.value[0],
+				e.value[1],
+				e.value[2]
+			]
+		};
+		case "Vec2Lit": return {
+			kind: "Vec2Lit",
+			value: [e.value[0], e.value[1]]
+		};
+		case "Param": return {
+			kind: "Param",
+			name: e.name
+		};
+		case "BinOp": return {
+			kind: "BinOp",
+			op: e.op,
+			a: exprToJson(e.a),
+			b: exprToJson(e.b)
+		};
+		case "UnaryOp": return {
+			kind: "UnaryOp",
+			op: e.op,
+			arg: exprToJson(e.arg)
+		};
+		case "Component": return {
+			kind: "Component",
+			vec: exprToJson(e.vec),
+			index: e.index
+		};
+		case "BuildVec": return {
+			kind: "BuildVec",
+			dim: e.dim,
+			components: e.components.map(exprToJson)
+		};
+	}
+}
+function primitiveToJson(n) {
+	switch (n.kind) {
+		case "Box": return {
+			kind: "Box",
+			x: exprToJson(n.x),
+			y: exprToJson(n.y),
+			z: exprToJson(n.z)
+		};
+		case "Sphere": return {
+			kind: "Sphere",
+			radius: exprToJson(n.radius)
+		};
+		case "Cylinder": return {
+			kind: "Cylinder",
+			radius: exprToJson(n.radius),
+			height: exprToJson(n.height)
+		};
+		case "Cone": return {
+			kind: "Cone",
+			radius1: exprToJson(n.radius1),
+			radius2: exprToJson(n.radius2),
+			height: exprToJson(n.height)
+		};
+		case "Torus": return {
+			kind: "Torus",
+			majorRadius: exprToJson(n.majorRadius),
+			minorRadius: exprToJson(n.minorRadius)
+		};
+		case "Polygon": return {
+			kind: "Polygon",
+			points: n.points.map(exprToJson)
+		};
+		case "Circle": return {
+			kind: "Circle",
+			radius: exprToJson(n.radius)
+		};
+		case "Line": return {
+			kind: "Line",
+			from: exprToJson(n.from),
+			to: exprToJson(n.to)
+		};
+		case "Vertex": return {
+			kind: "Vertex",
+			point: exprToJson(n.point)
+		};
+		case "Empty": return {
+			kind: "Empty",
+			output: n.output
+		};
+		default: return;
+	}
+}
+function booleanToJson(n) {
+	switch (n.kind) {
+		case "Fuse":
+		case "Cut":
+		case "Intersect": return {
+			kind: n.kind,
+			a: nodeToJson(n.a),
+			b: nodeToJson(n.b),
+			tolerance: n.tolerance
+		};
+		case "FuseAll": return {
+			kind: "FuseAll",
+			shapes: n.shapes.map(nodeToJson),
+			tolerance: n.tolerance
+		};
+		case "CutAll": return {
+			kind: "CutAll",
+			base: nodeToJson(n.base),
+			tools: n.tools.map(nodeToJson),
+			tolerance: n.tolerance
+		};
+		default: return;
+	}
+}
+function optExprToJson(e) {
+	return e ? exprToJson(e) : void 0;
+}
+function transformToJson(n) {
+	switch (n.kind) {
+		case "Translate": return {
+			kind: "Translate",
+			target: nodeToJson(n.target),
+			vector: exprToJson(n.vector)
+		};
+		case "Rotate": return {
+			kind: "Rotate",
+			target: nodeToJson(n.target),
+			angle: exprToJson(n.angle),
+			axis: optExprToJson(n.axis),
+			at: optExprToJson(n.at)
+		};
+		case "Scale": return {
+			kind: "Scale",
+			target: nodeToJson(n.target),
+			factor: exprToJson(n.factor),
+			center: optExprToJson(n.center)
+		};
+		case "Mirror": return {
+			kind: "Mirror",
+			target: nodeToJson(n.target),
+			normal: optExprToJson(n.normal),
+			at: optExprToJson(n.at)
+		};
+		default: return;
+	}
+}
+function nodeToJson(n) {
+	if (n.kind === "Compound") return {
+		kind: "Compound",
+		children: n.children.map(nodeToJson)
+	};
+	return primitiveToJson(n) ?? booleanToJson(n) ?? transformToJson(n);
+}
+function bad(msg) {
+	return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `csg.fromJSON: ${msg}`));
+}
+function isObj(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isNumber$1(v) {
+	return typeof v === "number" && Number.isFinite(v);
+}
+function isString(v) {
+	return typeof v === "string";
+}
+function readVec3(v, where) {
+	if (!Array.isArray(v) || v.length !== 3) return bad(`${where}: expected Vec3 array`);
+	const [a, b, c] = v;
+	if (!isNumber$1(a) || !isNumber$1(b) || !isNumber$1(c)) return bad(`${where}: Vec3 contains non-number`);
+	return require_errors.ok([
+		a,
+		b,
+		c
+	]);
+}
+function readVec2(v, where) {
+	if (!Array.isArray(v) || v.length !== 2) return bad(`${where}: expected Vec2 array`);
+	const [a, b] = v;
+	if (!isNumber$1(a) || !isNumber$1(b)) return bad(`${where}: Vec2 contains non-number`);
+	return require_errors.ok([a, b]);
+}
+function fromJSON(envelope) {
+	if (!isObj(envelope)) return bad("input is not an object");
+	const v = envelope["csgVersion"];
+	if (v !== 1) return bad(`unsupported csgVersion ${String(v)} (expected 1)`);
+	const root = envelope["root"];
+	return readNode(root);
+}
+function readExpr(j) {
+	if (!isObj(j)) return bad("expression: not an object");
+	const kind = j["kind"];
+	switch (kind) {
+		case "NumLit": return isNumber$1(j["value"]) ? require_errors.ok(numLit(j["value"])) : bad("NumLit.value");
+		case "Vec3Lit": {
+			const v = readVec3(j["value"], "Vec3Lit.value");
+			return v.ok ? require_errors.ok(vec3Lit(v.value)) : v;
+		}
+		case "Vec2Lit": {
+			const v = readVec2(j["value"], "Vec2Lit.value");
+			return v.ok ? require_errors.ok(vec2Lit(v.value)) : v;
+		}
+		case "Param": return isString(j["name"]) ? require_errors.ok(param(j["name"])) : bad("Param.name");
+		case "BinOp": return readBinOp(j);
+		case "UnaryOp": return readUnaryOp(j);
+		case "Component": return readComponent(j);
+		case "BuildVec": return readBuildVec(j);
+		default: return bad(`unknown expression kind: ${String(kind)}`);
+	}
+}
+function readBinOp(j) {
+	const op = j["op"];
+	if (op !== "+" && op !== "-" && op !== "*" && op !== "/") return bad(`BinOp.op: ${String(op)}`);
+	const a = readExpr(j["a"]);
+	if (!a.ok) return a;
+	const b = readExpr(j["b"]);
+	if (!b.ok) return b;
+	return require_errors.ok(binOp(op, a.value, b.value));
+}
+function readUnaryOp(j) {
+	const op = j["op"];
+	if (!isString(op) || ![
+		"neg",
+		"sin",
+		"cos",
+		"sqrt",
+		"abs"
+	].includes(op)) return bad(`UnaryOp.op: ${String(op)}`);
+	const arg = readExpr(j["arg"]);
+	if (!arg.ok) return arg;
+	return require_errors.ok(unaryOp(op, arg.value));
+}
+function readComponent(j) {
+	const index = j["index"];
+	if (index !== 0 && index !== 1 && index !== 2) return bad(`Component.index: ${String(index)}`);
+	const vec = readExpr(j["vec"]);
+	if (!vec.ok) return vec;
+	return require_errors.ok(component(vec.value, index));
+}
+function readBuildVec(j) {
+	const dim = j["dim"];
+	if (dim !== 2 && dim !== 3) return bad(`BuildVec.dim: ${String(dim)}`);
+	const comps = j["components"];
+	if (!Array.isArray(comps)) return bad("BuildVec.components: not array");
+	if (comps.length !== dim) return bad(`BuildVec.components: expected ${dim} components, got ${comps.length}`);
+	const out = [];
+	for (const c of comps) {
+		const r = readExpr(c);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return require_errors.ok(buildVec(dim, out));
+}
+function readNodeArray(j, where) {
+	if (!Array.isArray(j)) return bad(`${where}: not array`);
+	const out = [];
+	for (const c of j) {
+		const r = readNode(c);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return require_errors.ok(out);
+}
+function readOptTolerance(j) {
+	const t = j["tolerance"];
+	if (t === void 0 || t === null) return require_errors.ok(void 0);
+	return isNumber$1(t) ? require_errors.ok(t) : bad("tolerance: not a finite number");
+}
+function readNode(j) {
+	if (!isObj(j)) return bad("node: not an object");
+	const kind = j["kind"];
+	switch (kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus":
+		case "Polygon":
+		case "Circle":
+		case "Line":
+		case "Vertex":
+		case "Empty": return readPrimitive(kind, j);
+		case "Fuse":
+		case "Cut":
+		case "Intersect": return readBinaryBool(kind, j);
+		case "FuseAll":
+		case "CutAll": return readNaryBool(kind, j);
+		case "Translate":
+		case "Rotate":
+		case "Scale":
+		case "Mirror": return readTransform(kind, j);
+		case "Compound": return readCompound(j);
+		default: return bad(`unknown node kind: ${String(kind)}`);
+	}
+}
+function readSingleExpr(j, key, build) {
+	const r = readExpr(j[key]);
+	return r.ok ? require_errors.ok(build(r.value)) : r;
+}
+function readPrimitive(kind, j) {
+	switch (kind) {
+		case "Box": return readBox(j);
+		case "Sphere": return readSingleExpr(j, "radius", sphere$1);
+		case "Cylinder": return readCylinder(j);
+		case "Cone": return readCone(j);
+		case "Torus": return readTorus(j);
+		case "Polygon": return readPolygon(j);
+		case "Circle": return readSingleExpr(j, "radius", circle$1);
+		case "Line": return readLine(j);
+		case "Vertex": return readSingleExpr(j, "point", vertex$1);
+		case "Empty": return readEmpty(j);
+	}
+	return bad(`unhandled primitive: ${kind}`);
+}
+function readBox(j) {
+	const x = readExpr(j["x"]);
+	if (!x.ok) return x;
+	const y = readExpr(j["y"]);
+	if (!y.ok) return y;
+	const z = readExpr(j["z"]);
+	if (!z.ok) return z;
+	return require_errors.ok(box$1(x.value, y.value, z.value));
+}
+function readCylinder(j) {
+	const r = readExpr(j["radius"]);
+	if (!r.ok) return r;
+	const h = readExpr(j["height"]);
+	if (!h.ok) return h;
+	return require_errors.ok(cylinder$1(r.value, h.value));
+}
+function readCone(j) {
+	const r1 = readExpr(j["radius1"]);
+	if (!r1.ok) return r1;
+	const r2 = readExpr(j["radius2"]);
+	if (!r2.ok) return r2;
+	const h = readExpr(j["height"]);
+	if (!h.ok) return h;
+	return require_errors.ok(cone$1(r1.value, r2.value, h.value));
+}
+function readTorus(j) {
+	const ma = readExpr(j["majorRadius"]);
+	if (!ma.ok) return ma;
+	const mi = readExpr(j["minorRadius"]);
+	if (!mi.ok) return mi;
+	return require_errors.ok(torus$1(ma.value, mi.value));
+}
+function readPolygon(j) {
+	const pts = j["points"];
+	if (!Array.isArray(pts)) return bad("Polygon.points: not array");
+	const out = [];
+	for (const p of pts) {
+		const r = readExpr(p);
+		if (!r.ok) return r;
+		out.push(r.value);
+	}
+	return require_errors.ok(polygon$1(out));
+}
+function readLine(j) {
+	const f = readExpr(j["from"]);
+	if (!f.ok) return f;
+	const t = readExpr(j["to"]);
+	if (!t.ok) return t;
+	return require_errors.ok(line$1(f.value, t.value));
+}
+function readEmpty(j) {
+	const out = j["output"];
+	switch (out) {
+		case "Solid": return require_errors.ok(emptySolid());
+		case "Face": return require_errors.ok(emptyFace());
+		case "Wire": return require_errors.ok(emptyWire());
+		default: return bad(`Empty.output: ${String(out)}`);
+	}
+}
+function readBinaryBool(kind, j) {
+	const a = readNode(j["a"]);
+	if (!a.ok) return a;
+	const b = readNode(j["b"]);
+	if (!b.ok) return b;
+	const t = readOptTolerance(j);
+	if (!t.ok) return t;
+	switch (kind) {
+		case "Fuse": return require_errors.ok(fuse$1(a.value, b.value, t.value));
+		case "Cut": return require_errors.ok(cut$1(a.value, b.value, t.value));
+		case "Intersect": return require_errors.ok(intersect$1(a.value, b.value, t.value));
+	}
+}
+function readNaryBool(kind, j) {
+	const t = readOptTolerance(j);
+	if (!t.ok) return t;
+	if (kind === "FuseAll") {
+		const shapes = readNodeArray(j["shapes"], "FuseAll.shapes");
+		return shapes.ok ? require_errors.ok(fuseAll$1(shapes.value, t.value)) : shapes;
+	}
+	const base = readNode(j["base"]);
+	if (!base.ok) return base;
+	const tools = readNodeArray(j["tools"], "CutAll.tools");
+	return tools.ok ? require_errors.ok(cutAll$1(base.value, tools.value, t.value)) : tools;
+}
+function readTransform(kind, j) {
+	const tgt = readNode(j["target"]);
+	if (!tgt.ok) return tgt;
+	switch (kind) {
+		case "Translate": return readTranslate(j, tgt.value);
+		case "Rotate": return readRotate(j, tgt.value);
+		case "Scale": return readScale(j, tgt.value);
+		case "Mirror": return readMirror(j, tgt.value);
+	}
+}
+function readTranslate(j, target) {
+	const v = readExpr(j["vector"]);
+	return v.ok ? require_errors.ok(translate$1(target, v.value)) : v;
+}
+function readOptExpr(j, key) {
+	if (j[key] === void 0) return require_errors.ok(void 0);
+	const r = readExpr(j[key]);
+	return r.ok ? require_errors.ok(r.value) : r;
+}
+function readRotate(j, target) {
+	const ang = readExpr(j["angle"]);
+	if (!ang.ok) return ang;
+	const axis = readOptExpr(j, "axis");
+	if (!axis.ok) return axis;
+	const at = readOptExpr(j, "at");
+	if (!at.ok) return at;
+	return require_errors.ok(rotate$1(target, ang.value, {
+		axis: axis.value,
+		at: at.value
+	}));
+}
+function readScale(j, target) {
+	const f = readExpr(j["factor"]);
+	if (!f.ok) return f;
+	const center = readOptExpr(j, "center");
+	if (!center.ok) return center;
+	return require_errors.ok(scale$1(target, f.value, { center: center.value }));
+}
+function readMirror(j, target) {
+	const normal = readOptExpr(j, "normal");
+	if (!normal.ok) return normal;
+	const at = readOptExpr(j, "at");
+	if (!at.ok) return at;
+	return require_errors.ok(mirror$1(target, {
+		normal: normal.value,
+		at: at.value
+	}));
+}
+function readCompound(j) {
+	const children = readNodeArray(j["children"], "Compound.children");
+	return children.ok ? require_errors.ok(compound$1(children.value)) : children;
+}
+//#endregion
+//#region src/csg/optimize.ts
+function optimize(node) {
+	return optimizeNode(node);
+}
+function foldExpr(e) {
+	switch (e.kind) {
+		case "NumLit":
+		case "Vec3Lit":
+		case "Vec2Lit":
+		case "Param": return e;
+		case "BinOp": {
+			const a = foldExpr(e.a);
+			const b = foldExpr(e.b);
+			if (a.kind === "NumLit" && b.kind === "NumLit") switch (e.op) {
+				case "+": return numLit(a.value + b.value);
+				case "-": return numLit(a.value - b.value);
+				case "*": return numLit(a.value * b.value);
+				case "/": return numLit(a.value / b.value);
+			}
+			if (a !== e.a || b !== e.b) return binOp(e.op, a, b);
+			return e;
+		}
+		case "UnaryOp": {
+			const arg = foldExpr(e.arg);
+			if (arg.kind === "NumLit") {
+				const n = arg.value;
+				switch (e.op) {
+					case "neg": return numLit(-n);
+					case "sin": return numLit(Math.sin(n));
+					case "cos": return numLit(Math.cos(n));
+					case "sqrt": return numLit(Math.sqrt(n));
+					case "abs": return numLit(Math.abs(n));
+				}
+			}
+			if (arg !== e.arg) return unaryOp(e.op, arg);
+			return e;
+		}
+		case "Component": {
+			const v = foldExpr(e.vec);
+			if (v.kind === "Vec3Lit") return numLit(v.value[e.index]);
+			if (v.kind === "Vec2Lit" && (e.index === 0 || e.index === 1)) return numLit(v.value[e.index]);
+			if (v !== e.vec) return component(v, e.index);
+			return e;
+		}
+		case "BuildVec": {
+			const folded = e.components.map(foldExpr);
+			const collapsed = foldBuildVec(e.dim, folded);
+			if (collapsed) return collapsed;
+			if (folded.some((c, i) => c !== e.components[i])) return buildVec(e.dim, folded);
+			return e;
+		}
+	}
+}
+function foldBuildVec(dim, comps) {
+	if (comps.length !== dim) return void 0;
+	const nums = [];
+	for (const c of comps) {
+		if (c.kind !== "NumLit") return void 0;
+		nums.push(c.value);
+	}
+	if (dim === 2) return vec2Lit([nums[0], nums[1]]);
+	return vec3Lit([
+		nums[0],
+		nums[1],
+		nums[2]
+	]);
+}
+function optimizeNode(n) {
+	switch (n.kind) {
+		case "Box": return box$1(foldExpr(n.x), foldExpr(n.y), foldExpr(n.z));
+		case "Sphere": return sphere$1(foldExpr(n.radius));
+		case "Cylinder": return cylinder$1(foldExpr(n.radius), foldExpr(n.height));
+		case "Cone": return cone$1(foldExpr(n.radius1), foldExpr(n.radius2), foldExpr(n.height));
+		case "Torus": return torus$1(foldExpr(n.majorRadius), foldExpr(n.minorRadius));
+		case "Polygon": return polygon$1(n.points.map(foldExpr));
+		case "Circle": return circle$1(foldExpr(n.radius));
+		case "Line": return line$1(foldExpr(n.from), foldExpr(n.to));
+		case "Vertex": return vertex$1(foldExpr(n.point));
+		case "Empty": return n;
+		case "Fuse": return optimizeFuse(n.a, n.b, n.tolerance);
+		case "Cut": return optimizeCut(n.a, n.b, n.tolerance);
+		case "Intersect": return optimizeIntersect(n.a, n.b, n.tolerance);
+		case "FuseAll": return optimizeFuseAll(n.shapes, n.tolerance);
+		case "CutAll": return optimizeCutAll(n.base, n.tools, n.tolerance);
+		case "Translate": return optimizeTranslate(n.target, n.vector);
+		case "Rotate": return rotate$1(optimizeNode(n.target), foldExpr(n.angle), {
+			axis: n.axis ? foldExpr(n.axis) : void 0,
+			at: n.at ? foldExpr(n.at) : void 0
+		});
+		case "Scale": return scale$1(optimizeNode(n.target), foldExpr(n.factor), { center: n.center ? foldExpr(n.center) : void 0 });
+		case "Mirror": return mirror$1(optimizeNode(n.target), {
+			normal: n.normal ? foldExpr(n.normal) : void 0,
+			at: n.at ? foldExpr(n.at) : void 0
+		});
+		case "Compound": return compound$1(n.children.map(optimizeNode).filter((c) => c.kind !== "Empty"));
+	}
+}
+function optimizeFuse(a, b, tol) {
+	const oa = optimizeNode(a);
+	const ob = optimizeNode(b);
+	if (oa.kind === "Empty") return ob;
+	if (ob.kind === "Empty") return oa;
+	return fuse$1(oa, ob, tol);
+}
+function optimizeCut(a, b, tol) {
+	const oa = optimizeNode(a);
+	const ob = optimizeNode(b);
+	if (ob.kind === "Empty") return oa;
+	if (oa.kind === "Empty") return oa;
+	return cut$1(oa, ob, tol);
+}
+function optimizeIntersect(a, b, tol) {
+	const oa = optimizeNode(a);
+	const ob = optimizeNode(b);
+	if (oa.kind === "Empty") return oa;
+	if (ob.kind === "Empty") return ob;
+	return intersect$1(oa, ob, tol);
+}
+function optimizeFuseAll(shapes, tol) {
+	const opt = shapes.map(optimizeNode).filter((s) => s.kind !== "Empty");
+	if (opt.length === 0) return emptySolid();
+	if (opt.length === 1) return opt[0];
+	return fuseAll$1(opt, tol);
+}
+function optimizeCutAll(base, tools, tol) {
+	const ob = optimizeNode(base);
+	if (ob.kind === "Empty") return ob;
+	const ot = tools.map(optimizeNode).filter((s) => s.kind !== "Empty");
+	if (ot.length === 0) return ob;
+	return cutAll$1(ob, ot, tol);
+}
+function optimizeTranslate(target, vector) {
+	const ot = optimizeNode(target);
+	const ov = foldExpr(vector);
+	if (ov.kind !== "Vec3Lit") return translate$1(ot, ov);
+	const [x, y, z] = ov.value;
+	if (x === 0 && y === 0 && z === 0) return ot;
+	if (ot.kind === "Translate") {
+		const inner = foldExpr(ot.vector);
+		if (inner.kind === "Vec3Lit") return translate$1(ot.target, [
+			inner.value[0] + x,
+			inner.value[1] + y,
+			inner.value[2] + z
+		]);
+	}
+	return translate$1(ot, ov);
+}
+//#endregion
+//#region src/csg/edit.ts
+function replaceNode(root, pred, replacement) {
+	return walk(root, pred, replacement);
+}
+function walk(node, pred, repl) {
+	if (pred(node)) return repl;
+	return rebuildChildren(node, pred, repl);
+}
+function rebuildChildren(n, pred, repl) {
+	switch (n.kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus":
+		case "Polygon":
+		case "Circle":
+		case "Line":
+		case "Vertex":
+		case "Empty": return n;
+		case "Fuse": return fuse$1(walk(n.a, pred, repl), walk(n.b, pred, repl), n.tolerance);
+		case "Cut": return cut$1(walk(n.a, pred, repl), walk(n.b, pred, repl), n.tolerance);
+		case "Intersect": return intersect$1(walk(n.a, pred, repl), walk(n.b, pred, repl), n.tolerance);
+		case "FuseAll": return fuseAll$1(n.shapes.map((c) => walk(c, pred, repl)), n.tolerance);
+		case "CutAll": return cutAll$1(walk(n.base, pred, repl), n.tools.map((c) => walk(c, pred, repl)), n.tolerance);
+		case "Translate": return translate$1(walk(n.target, pred, repl), n.vector);
+		case "Rotate": return rotate$1(walk(n.target, pred, repl), n.angle, {
+			axis: n.axis,
+			at: n.at
+		});
+		case "Scale": return scale$1(walk(n.target, pred, repl), n.factor, { center: n.center });
+		case "Mirror": return mirror$1(walk(n.target, pred, repl), {
+			normal: n.normal,
+			at: n.at
+		});
+		case "Compound": return compound$1(n.children.map((c) => walk(c, pred, repl)));
+	}
+}
+function forEachNode(root, fn) {
+	fn(root);
+	for (const child of childrenOf(root)) forEachNode(child, fn);
+}
+function childrenOf(n) {
+	switch (n.kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus":
+		case "Polygon":
+		case "Circle":
+		case "Line":
+		case "Vertex":
+		case "Empty": return [];
+		case "Fuse":
+		case "Cut":
+		case "Intersect": return [n.a, n.b];
+		case "FuseAll": return n.shapes;
+		case "CutAll": return [n.base, ...n.tools];
+		case "Translate":
+		case "Rotate":
+		case "Scale":
+		case "Mirror": return [n.target];
+		case "Compound": return n.children;
+	}
+}
+function nodeCount(root) {
+	let n = 0;
+	forEachNode(root, () => {
+		n++;
+	});
+	return n;
+}
+//#endregion
+//#region src/ns/csg.ts
+var csg_exports = /* @__PURE__ */ require_textBlueprints.__exportAll({
+	CSG_VERSION: () => 1,
+	Evaluator: () => Evaluator,
+	add: () => add,
+	asScalarExpr: () => asScalarExpr,
+	asVec2Expr: () => asVec2Expr,
+	asVec3Expr: () => asVec3Expr,
+	binOp: () => binOp,
+	box: () => box$1,
+	buildVec: () => buildVec,
+	circle: () => circle$1,
+	component: () => component,
+	compound: () => compound$1,
+	cone: () => cone$1,
+	cut: () => cut$1,
+	cutAll: () => cutAll$1,
+	cylinder: () => cylinder$1,
+	emptyFace: () => emptyFace,
+	emptySolid: () => emptySolid,
+	emptyWire: () => emptyWire,
+	foldExpr: () => foldExpr,
+	forEachNode: () => forEachNode,
+	fromJSON: () => fromJSON,
+	fuse: () => fuse$1,
+	fuseAll: () => fuseAll$1,
+	intersect: () => intersect$1,
+	line: () => line$1,
+	mirror: () => mirror$1,
+	mul: () => mul,
+	nodeCount: () => nodeCount,
+	numLit: () => numLit,
+	optimize: () => optimize,
+	outputKindOf: () => outputKindOf,
+	param: () => param,
+	polygon: () => polygon$1,
+	replaceNode: () => replaceNode,
+	rotate: () => rotate$1,
+	scale: () => scale$1,
+	sphere: () => sphere$1,
+	toJSON: () => toJSON,
+	torus: () => torus$1,
+	translate: () => translate$1,
+	unaryOp: () => unaryOp,
+	vec2Lit: () => vec2Lit,
+	vec3Lit: () => vec3Lit,
+	vertex: () => vertex$1,
+	withEvaluator: () => withEvaluator
+});
+//#endregion
 exports.BaseSketcher2d = require_blueprintSketcher.BaseSketcher2d;
 exports.BlueprintSketcher = require_blueprintSketcher.BlueprintSketcher;
 exports.BrepBugError = require_errors.BrepBugError;
@@ -3523,6 +5204,12 @@ exports.createVertex = require_shapeTypes.createVertex;
 exports.createWire = require_shapeTypes.createWire;
 exports.createWorkerClient = require_workerHandler.createWorkerClient;
 exports.createWorkerHandler = require_workerHandler.createWorkerHandler;
+Object.defineProperty(exports, "csg", {
+	enumerable: true,
+	get: function() {
+		return csg_exports;
+	}
+});
 exports.curve2dBoundingBox = require_blueprintFns.curve2dBoundingBox;
 exports.curve2dDistanceFrom = require_blueprintFns.curve2dDistanceFrom;
 exports.curve2dFirstPoint = require_blueprintFns.curve2dFirstPoint;