brepjs 18.154.0 → 18.156.0

package/dist/brepjs.cjs

@@ -16,7 +16,7 @@ const require_solidBuilders = require("./solidBuilders-BKSCyfzL.cjs");
 const require_primitiveFns = require("./primitiveFns-BjwF7CHF.cjs");
 const require_shapeFns = require("./shapeFns-C3AFMiyv.cjs");
 const require_curveFns = require("./curveFns-DTbY4aYG.cjs");
-const require_meshFns = require("./meshFns-cMtop3IN.cjs");
+const require_meshFns = require("./meshFns-BZNqLhDE.cjs");
 const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
 const require_surfaceBuilders = require("./surfaceBuilders-aSFtcDr6.cjs");
 const require_healingFns = require("./healingFns-CnRyuMWf.cjs");
@@ -3355,20 +3355,6 @@ function relocateFaceGroups(faceGroups, innerHashes, placedHashes) {
 		faceId: remap.get(g.faceId) ?? g.faceId
 	}));
 }
-var SCALE_INVARIANT_DIAGONAL = 10;
-function scaleDefaultTolerance(base, shape) {
-	let diagonal;
-	try {
-		const b = require_topologyQueryFns.getBounds(shape);
-		const dx = b.xMax - b.xMin;
-		const dy = b.yMax - b.yMin;
-		const dz = b.zMax - b.zMin;
-		diagonal = Math.sqrt(dx * dx + dy * dy + dz * dz);
-	} catch {
-		return base;
-	}
-	return base * Math.max(1, diagonal / SCALE_INVARIANT_DIAGONAL);
-}
 var Evaluator = class {
 	cache = /* @__PURE__ */ new Map();
 	refCounts = /* @__PURE__ */ new Map();
@@ -3499,7 +3485,7 @@ var Evaluator = class {
 		const { inner } = peelRigid(node, env);
 		const source = this.evaluate(inner, env);
 		if (!source.ok) return base;
-		return scaleDefaultTolerance(base, source.value);
+		return require_meshFns.scaleDefaultTolerance(base, source.value);
 	}
 	evaluateInner(node, env) {
 		const key = cacheKey(node, env, this.kernelId, this.defaultTolerance);
@@ -3606,13 +3592,165 @@ function withEvaluator(options, fn) {
 		_usingCtx$4.d();
 	}
 }
+//#endregion
+//#region src/csg/edit.ts
+function replaceNode(root, pred, replacement) {
+	return walk(root, pred, replacement, /* @__PURE__ */ new Map());
+}
+function walk(node, pred, repl, memo) {
+	const cached = memo.get(node);
+	if (cached !== void 0) return cached;
+	const out = pred(node) ? repl : rebuildChildren(node, pred, repl, memo);
+	memo.set(node, out);
+	return out;
+}
+function rebuildChildren(n, pred, repl, memo) {
+	switch (n.kind) {
+		case "Box":
+		case "Sphere":
+		case "Cylinder":
+		case "Cone":
+		case "Torus":
+		case "Polygon":
+		case "Circle":
+		case "Line":
+		case "Vertex":
+		case "Empty":
+		case "Path":
+		case "Profile": return n;
+		case "Fuse": return fuse$1(walk(n.a, pred, repl, memo), walk(n.b, pred, repl, memo), n.tolerance);
+		case "Cut": return cut$1(walk(n.a, pred, repl, memo), walk(n.b, pred, repl, memo), n.tolerance);
+		case "Intersect": return intersect$1(walk(n.a, pred, repl, memo), walk(n.b, pred, repl, memo), n.tolerance);
+		case "FuseAll": return fuseAll$1(n.shapes.map((c) => walk(c, pred, repl, memo)), n.tolerance);
+		case "CutAll": return cutAll$1(walk(n.base, pred, repl, memo), n.tools.map((c) => walk(c, pred, repl, memo)), n.tolerance);
+		case "Translate": return translate$1(walk(n.target, pred, repl, memo), n.vector);
+		case "Rotate": return rotate$1(walk(n.target, pred, repl, memo), n.angle, {
+			axis: n.axis,
+			at: n.at
+		});
+		case "Scale": return scale$2(walk(n.target, pred, repl, memo), n.factor, { center: n.center });
+		case "Mirror": return mirror$1(walk(n.target, pred, repl, memo), {
+			normal: n.normal,
+			at: n.at
+		});
+		case "Compound": return compound$1(n.children.map((c) => walk(c, pred, repl, memo)));
+		case "Instance": return instance$1(walk(n.source, pred, repl, memo), n.placements, n.fuse);
+		case "Extrude":
+		case "Revolve":
+		case "Loft":
+		case "Sweep":
+		case "Color":
+		case "Fillet":
+		case "Chamfer":
+		case "Shell": return rebuildFeature(n, pred, repl, memo);
+	}
+}
+function rebuildFeature(n, pred, repl, memo) {
+	switch (n.kind) {
+		case "Extrude": return extrude$1(walk(n.profile, pred, repl, memo), n.vector);
+		case "Revolve": return revolve$1(walk(n.profile, pred, repl, memo), n.angle, {
+			axis: n.axis,
+			at: n.at
+		});
+		case "Loft": return loft$1(n.sections.map((s) => walk(s, pred, repl, memo)), { ruled: n.ruled });
+		case "Sweep": return sweep$2(walk(n.profile, pred, repl, memo), walk(n.spine, pred, repl, memo), { frenet: n.frenet });
+		case "Color": return color(walk(n.target, pred, repl, memo), [...n.color]);
+		case "Fillet": return fillet$1(walk(n.target, pred, repl, memo), n.ref, n.radius);
+		case "Chamfer": return chamfer$1(walk(n.target, pred, repl, memo), n.ref, n.distance);
+		case "Shell": return shell$1(walk(n.target, pred, repl, memo), n.refs, n.thickness);
+	}
+}
+/** Visits each DISTINCT node once (identity-deduplicated), so a shared
+*  subtree is reported once and a self-referencing DAG walks in linear time. */
+function forEachNode(root, fn) {
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (seen.has(node)) return;
+		seen.add(node);
+		fn(node);
+		for (const child of childrenOf(node)) visit(child);
+	};
+	visit(root);
+}
+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":
+		case "Path":
+		case "Profile": 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":
+		case "Color":
+		case "Fillet":
+		case "Chamfer":
+		case "Shell": return [n.target];
+		case "Compound": return n.children;
+		case "Instance": return [n.source];
+		case "Extrude":
+		case "Revolve": return [n.profile];
+		case "Loft": return n.sections;
+		case "Sweep": return [n.profile, n.spine];
+	}
+}
+function nodeCount(root) {
+	let n = 0;
+	forEachNode(root, () => {
+		n++;
+	});
+	return n;
+}
 var MIN_CSG_VERSION = 1;
 function toJSON(node) {
-	return {
-		csgVersion: 7,
-		root: nodeToJson(node)
+	const ctx = {
+		counts: countRefs(node),
+		ids: /* @__PURE__ */ new Map(),
+		defs: []
+	};
+	const root = emitNode(node, ctx);
+	return ctx.defs.length > 0 ? {
+		csgVersion: 8,
+		defs: ctx.defs,
+		root
+	} : {
+		csgVersion: 8,
+		root
 	};
 }
+function countRefs(root) {
+	const counts = /* @__PURE__ */ new Map();
+	const visit = (n) => {
+		const seen = counts.get(n) ?? 0;
+		counts.set(n, seen + 1);
+		if (seen === 0) for (const child of childrenOf(n)) visit(child);
+	};
+	visit(root);
+	return counts;
+}
+function emitNode(n, ctx) {
+	if ((ctx.counts.get(n) ?? 0) < 2) return nodeToJson(n, ctx);
+	const existing = ctx.ids.get(n);
+	if (existing !== void 0) return { $ref: existing };
+	const body = nodeToJson(n, ctx);
+	const id = ctx.defs.length;
+	ctx.defs.push(body);
+	ctx.ids.set(n, id);
+	return { $ref: id };
+}
 function exprToJson(e) {
 	switch (e.kind) {
 		case "NumLit": return {
@@ -3710,25 +3848,25 @@ function primitiveToJson(n) {
 		default: return;
 	}
 }
-function booleanToJson(n) {
+function booleanToJson(n, ctx) {
 	switch (n.kind) {
 		case "Fuse":
 		case "Cut":
 		case "Intersect": return {
 			kind: n.kind,
-			a: nodeToJson(n.a),
-			b: nodeToJson(n.b),
+			a: emitNode(n.a, ctx),
+			b: emitNode(n.b, ctx),
 			tolerance: n.tolerance
 		};
 		case "FuseAll": return {
 			kind: "FuseAll",
-			shapes: n.shapes.map(nodeToJson),
+			shapes: n.shapes.map((s) => emitNode(s, ctx)),
 			tolerance: n.tolerance
 		};
 		case "CutAll": return {
 			kind: "CutAll",
-			base: nodeToJson(n.base),
-			tools: n.tools.map(nodeToJson),
+			base: emitNode(n.base, ctx),
+			tools: n.tools.map((t) => emitNode(t, ctx)),
 			tolerance: n.tolerance
 		};
 		default: return;
@@ -3795,103 +3933,108 @@ function contourToJson(c) {
 		segments: c.segments.map(segmentToJson)
 	};
 }
-function transformToJson(n) {
+function transformToJson(n, ctx) {
 	switch (n.kind) {
 		case "Translate": return {
 			kind: "Translate",
-			target: nodeToJson(n.target),
+			target: emitNode(n.target, ctx),
 			vector: exprToJson(n.vector)
 		};
 		case "Rotate": return {
 			kind: "Rotate",
-			target: nodeToJson(n.target),
+			target: emitNode(n.target, ctx),
 			angle: exprToJson(n.angle),
 			axis: optExprToJson(n.axis),
 			at: optExprToJson(n.at)
 		};
 		case "Scale": return {
 			kind: "Scale",
-			target: nodeToJson(n.target),
+			target: emitNode(n.target, ctx),
 			factor: exprToJson(n.factor),
 			center: optExprToJson(n.center)
 		};
 		case "Mirror": return {
 			kind: "Mirror",
-			target: nodeToJson(n.target),
+			target: emitNode(n.target, ctx),
 			normal: optExprToJson(n.normal),
 			at: optExprToJson(n.at)
 		};
 		default: return;
 	}
 }
-function nodeToJson(n) {
-	if (n.kind === "Extrude") return {
-		kind: "Extrude",
-		profile: nodeToJson(n.profile),
-		vector: exprToJson(n.vector)
-	};
-	if (n.kind === "Revolve") return {
-		kind: "Revolve",
-		profile: nodeToJson(n.profile),
-		angle: exprToJson(n.angle),
-		axis: optExprToJson(n.axis),
-		at: optExprToJson(n.at)
-	};
-	if (n.kind === "Loft") return {
-		kind: "Loft",
-		sections: n.sections.map(nodeToJson),
-		ruled: n.ruled
-	};
-	if (n.kind === "Path") return {
-		kind: "Path",
-		start: exprToJson(n.start),
-		segments: n.segments.map(segmentToJson)
-	};
-	if (n.kind === "Sweep") return {
-		kind: "Sweep",
-		profile: nodeToJson(n.profile),
-		spine: nodeToJson(n.spine),
-		frenet: n.frenet
-	};
-	if (n.kind === "Profile") return {
-		kind: "Profile",
-		outline: contourToJson(n.outline),
-		holes: n.holes.map(contourToJson)
-	};
+function featureToJson(n, ctx) {
+	switch (n.kind) {
+		case "Extrude": return {
+			kind: "Extrude",
+			profile: emitNode(n.profile, ctx),
+			vector: exprToJson(n.vector)
+		};
+		case "Revolve": return {
+			kind: "Revolve",
+			profile: emitNode(n.profile, ctx),
+			angle: exprToJson(n.angle),
+			axis: optExprToJson(n.axis),
+			at: optExprToJson(n.at)
+		};
+		case "Loft": return {
+			kind: "Loft",
+			sections: n.sections.map((s) => emitNode(s, ctx)),
+			ruled: n.ruled
+		};
+		case "Path": return {
+			kind: "Path",
+			start: exprToJson(n.start),
+			segments: n.segments.map(segmentToJson)
+		};
+		case "Sweep": return {
+			kind: "Sweep",
+			profile: emitNode(n.profile, ctx),
+			spine: emitNode(n.spine, ctx),
+			frenet: n.frenet
+		};
+		case "Profile": return {
+			kind: "Profile",
+			outline: contourToJson(n.outline),
+			holes: n.holes.map(contourToJson)
+		};
+		default: return;
+	}
+}
+function nodeToJson(n, ctx) {
 	if (n.kind === "Color") return {
 		kind: "Color",
-		target: nodeToJson(n.target),
+		target: emitNode(n.target, ctx),
 		color: [...n.color]
 	};
 	if (n.kind === "Fillet") return {
 		kind: "Fillet",
-		target: nodeToJson(n.target),
+		target: emitNode(n.target, ctx),
 		ref: edgeRefToJson(n.ref),
 		radius: exprToJson(n.radius)
 	};
 	if (n.kind === "Chamfer") return {
 		kind: "Chamfer",
-		target: nodeToJson(n.target),
+		target: emitNode(n.target, ctx),
 		ref: edgeRefToJson(n.ref),
 		distance: exprToJson(n.distance)
 	};
 	if (n.kind === "Shell") return {
 		kind: "Shell",
-		target: nodeToJson(n.target),
+		target: emitNode(n.target, ctx),
 		refs: n.refs.map(shapeRefToJson),
 		thickness: exprToJson(n.thickness)
 	};
 	if (n.kind === "Compound") return {
 		kind: "Compound",
-		children: n.children.map(nodeToJson)
+		children: n.children.map((c) => emitNode(c, ctx))
 	};
 	if (n.kind === "Instance") return {
 		kind: "Instance",
-		source: nodeToJson(n.source),
+		source: emitNode(n.source, ctx),
 		placements: n.placements,
 		fuse: n.fuse
 	};
-	return primitiveToJson(n) ?? booleanToJson(n) ?? transformToJson(n);
+	return featureToJson(n, ctx) ?? primitiveToJson(n) ?? booleanToJson(n, ctx) ?? transformToJson(n, ctx);
 }
 function bad(msg) {
 	return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.NULL_SHAPE_INPUT, `csg.fromJSON: ${msg}`));
@@ -3924,9 +4067,18 @@ function readVec2(v, where) {
 function fromJSON(envelope) {
 	if (!isObj(envelope)) return bad("input is not an object");
 	const v = envelope["csgVersion"];
-	if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_CSG_VERSION || v > 7) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..7)`);
-	const root = envelope["root"];
-	return readNode(root);
+	if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_CSG_VERSION || v > 8) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..8)`);
+	const rawDefs = envelope["defs"];
+	const defs = [];
+	if (rawDefs !== void 0) {
+		if (!Array.isArray(rawDefs)) return bad("defs: not an array");
+		for (const raw of rawDefs) {
+			const r = readNode(raw, defs);
+			if (!r.ok) return r;
+			defs.push(r.value);
+		}
+	}
+	return readNode(envelope["root"], defs);
 }
 function readExpr(j) {
 	if (!isObj(j)) return bad("expression: not an object");
@@ -3992,11 +4144,11 @@ function readBuildVec(j) {
 	}
 	return require_errors.ok(buildVec(dim, out));
 }
-function readNodeArray(j, where) {
+function readNodeArray(j, where, defs) {
 	if (!Array.isArray(j)) return bad(`${where}: not array`);
 	const out = [];
 	for (const c of j) {
-		const r = readNode(c);
+		const r = readNode(c, defs);
 		if (!r.ok) return r;
 		out.push(r.value);
 	}
@@ -4007,8 +4159,15 @@ function readOptTolerance(j) {
 	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) {
+function readNode(j, defs) {
 	if (!isObj(j)) return bad("node: not an object");
+	const ref = j["$ref"];
+	if (ref !== void 0) {
+		if (!isNumber$1(ref) || !Number.isInteger(ref) || ref < 0) return bad("$ref: expected a non-negative integer def index");
+		const node = defs[ref];
+		if (node === void 0) return bad(`$ref: ${ref} is out of range (forward refs are rejected)`);
+		return require_errors.ok(node);
+	}
 	const kind = j["kind"];
 	switch (kind) {
 		case "Box":
@@ -4023,25 +4182,25 @@ function readNode(j) {
 		case "Empty": return readPrimitive(kind, j);
 		case "Fuse":
 		case "Cut":
-		case "Intersect": return readBinaryBool(kind, j);
+		case "Intersect": return readBinaryBool(kind, j, defs);
 		case "FuseAll":
-		case "CutAll": return readNaryBool(kind, j);
+		case "CutAll": return readNaryBool(kind, j, defs);
 		case "Translate":
 		case "Rotate":
 		case "Scale":
-		case "Mirror": return readTransform(kind, j);
-		case "Compound": return readCompound(j);
-		case "Instance": return readInstance(j);
-		case "Extrude": return readExtrude(j);
-		case "Revolve": return readRevolve(j);
-		case "Loft": return readLoft(j);
+		case "Mirror": return readTransform(kind, j, defs);
+		case "Compound": return readCompound(j, defs);
+		case "Instance": return readInstance(j, defs);
+		case "Extrude": return readExtrude(j, defs);
+		case "Revolve": return readRevolve(j, defs);
+		case "Loft": return readLoft(j, defs);
 		case "Path": return readPath(j);
-		case "Sweep": return readSweep(j);
+		case "Sweep": return readSweep(j, defs);
 		case "Profile": return readProfile(j);
-		case "Color": return readColor(j);
-		case "Fillet": return readFillet(j);
-		case "Chamfer": return readChamfer(j);
-		case "Shell": return readShell(j);
+		case "Color": return readColor(j, defs);
+		case "Fillet": return readFillet(j, defs);
+		case "Chamfer": return readChamfer(j, defs);
+		case "Shell": return readShell(j, defs);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -4123,10 +4282,10 @@ function readEmpty(j) {
 		default: return bad(`Empty.output: ${String(out)}`);
 	}
 }
-function readBinaryBool(kind, j) {
-	const a = readNode(j["a"]);
+function readBinaryBool(kind, j, defs) {
+	const a = readNode(j["a"], defs);
 	if (!a.ok) return a;
-	const b = readNode(j["b"]);
+	const b = readNode(j["b"], defs);
 	if (!b.ok) return b;
 	const t = readOptTolerance(j);
 	if (!t.ok) return t;
@@ -4136,20 +4295,20 @@ function readBinaryBool(kind, j) {
 		case "Intersect": return require_errors.ok(intersect$1(a.value, b.value, t.value));
 	}
 }
-function readNaryBool(kind, j) {
+function readNaryBool(kind, j, defs) {
 	const t = readOptTolerance(j);
 	if (!t.ok) return t;
 	if (kind === "FuseAll") {
-		const shapes = readNodeArray(j["shapes"], "FuseAll.shapes");
+		const shapes = readNodeArray(j["shapes"], "FuseAll.shapes", defs);
 		return shapes.ok ? require_errors.ok(fuseAll$1(shapes.value, t.value)) : shapes;
 	}
-	const base = readNode(j["base"]);
+	const base = readNode(j["base"], defs);
 	if (!base.ok) return base;
-	const tools = readNodeArray(j["tools"], "CutAll.tools");
+	const tools = readNodeArray(j["tools"], "CutAll.tools", defs);
 	return tools.ok ? require_errors.ok(cutAll$1(base.value, tools.value, t.value)) : tools;
 }
-function readTransform(kind, j) {
-	const tgt = readNode(j["target"]);
+function readTransform(kind, j, defs) {
+	const tgt = readNode(j["target"], defs);
 	if (!tgt.ok) return tgt;
 	switch (kind) {
 		case "Translate": return readTranslate(j, tgt.value);
@@ -4196,15 +4355,15 @@ function readMirror(j, target) {
 		at: at.value
 	}));
 }
-function readExtrude(j) {
-	const profile = readNode(j["profile"]);
+function readExtrude(j, defs) {
+	const profile = readNode(j["profile"], defs);
 	if (!profile.ok) return profile;
 	const vector = readExpr(j["vector"]);
 	if (!vector.ok) return vector;
 	return require_errors.ok(extrude$1(profile.value, vector.value));
 }
-function readRevolve(j) {
-	const profile = readNode(j["profile"]);
+function readRevolve(j, defs) {
+	const profile = readNode(j["profile"], defs);
 	if (!profile.ok) return profile;
 	const angle = readExpr(j["angle"]);
 	if (!angle.ok) return angle;
@@ -4217,8 +4376,8 @@ function readRevolve(j) {
 		at: at.value
 	}));
 }
-function readLoft(j) {
-	const sections = readNodeArray(j["sections"], "Loft.sections");
+function readLoft(j, defs) {
+	const sections = readNodeArray(j["sections"], "Loft.sections", defs);
 	if (!sections.ok) return sections;
 	const ruled = j["ruled"];
 	if (ruled !== void 0 && typeof ruled !== "boolean") return bad("Loft.ruled: not a boolean");
@@ -4366,8 +4525,8 @@ function readShapeRef(j, where) {
 		}
 	});
 }
-function readShell(j) {
-	const target = readNode(j["target"]);
+function readShell(j, defs) {
+	const target = readNode(j["target"], defs);
 	if (!target.ok) return target;
 	const thickness = readExpr(j["thickness"]);
 	if (!thickness.ok) return thickness;
@@ -4381,8 +4540,8 @@ function readShell(j) {
 	}
 	return require_errors.ok(shell$1(target.value, refs, thickness.value));
 }
-function readFillet(j) {
-	const target = readNode(j["target"]);
+function readFillet(j, defs) {
+	const target = readNode(j["target"], defs);
 	if (!target.ok) return target;
 	const radius = readExpr(j["radius"]);
 	if (!radius.ok) return radius;
@@ -4390,8 +4549,8 @@ function readFillet(j) {
 	if (!ref.ok) return ref;
 	return require_errors.ok(fillet$1(target.value, ref.value, radius.value));
 }
-function readChamfer(j) {
-	const target = readNode(j["target"]);
+function readChamfer(j, defs) {
+	const target = readNode(j["target"], defs);
 	if (!target.ok) return target;
 	const distance = readExpr(j["distance"]);
 	if (!distance.ok) return distance;
@@ -4399,8 +4558,8 @@ function readChamfer(j) {
 	if (!ref.ok) return ref;
 	return require_errors.ok(chamfer$1(target.value, ref.value, distance.value));
 }
-function readColor(j) {
-	const target = readNode(j["target"]);
+function readColor(j, defs) {
+	const target = readNode(j["target"], defs);
 	if (!target.ok) return target;
 	const c = j["color"];
 	if (!Array.isArray(c) || c.length !== 4 || !c.every((v) => isNumber$1(v) && v >= 0 && v <= 1)) return bad("Color.color: expected an RGBA array of 4 numbers in [0, 1]");
@@ -4424,10 +4583,10 @@ function readProfile(j) {
 	}
 	return require_errors.ok(profile(outline.value, holes));
 }
-function readSweep(j) {
-	const profile = readNode(j["profile"]);
+function readSweep(j, defs) {
+	const profile = readNode(j["profile"], defs);
 	if (!profile.ok) return profile;
-	const spine = readNode(j["spine"]);
+	const spine = readNode(j["spine"], defs);
 	if (!spine.ok) return spine;
 	const frenet = readFlag(j, "frenet");
 	if (!frenet.ok) return frenet;
@@ -4446,15 +4605,15 @@ function readPath(j) {
 	}
 	return require_errors.ok(path(start.value, segments));
 }
-function readCompound(j) {
-	const children = readNodeArray(j["children"], "Compound.children");
+function readCompound(j, defs) {
+	const children = readNodeArray(j["children"], "Compound.children", defs);
 	return children.ok ? require_errors.ok(compound$1(children.value)) : children;
 }
 function isMatrix4x4(v) {
 	return Array.isArray(v) && v.length === 4 && v.every((row) => Array.isArray(row) && row.length === 4 && row.every(isNumber$1));
 }
-function readInstance(j) {
-	const source = readNode(j["source"]);
+function readInstance(j, defs) {
+	const source = readNode(j["source"], defs);
 	if (!source.ok) return source;
 	const placements = j["placements"];
 	if (!Array.isArray(placements) || !placements.every(isMatrix4x4)) return bad("Instance.placements must be an array of 4x4 number matrices");
@@ -4652,128 +4811,6 @@ function optimizeTranslate(target, vector) {
 	return translate$1(ot, ov);
 }
 //#endregion
-//#region src/csg/edit.ts
-function replaceNode(root, pred, replacement) {
-	return walk(root, pred, replacement, /* @__PURE__ */ new Map());
-}
-function walk(node, pred, repl, memo) {
-	const cached = memo.get(node);
-	if (cached !== void 0) return cached;
-	const out = pred(node) ? repl : rebuildChildren(node, pred, repl, memo);
-	memo.set(node, out);
-	return out;
-}
-function rebuildChildren(n, pred, repl, memo) {
-	switch (n.kind) {
-		case "Box":
-		case "Sphere":
-		case "Cylinder":
-		case "Cone":
-		case "Torus":
-		case "Polygon":
-		case "Circle":
-		case "Line":
-		case "Vertex":
-		case "Empty":
-		case "Path":
-		case "Profile": return n;
-		case "Fuse": return fuse$1(walk(n.a, pred, repl, memo), walk(n.b, pred, repl, memo), n.tolerance);
-		case "Cut": return cut$1(walk(n.a, pred, repl, memo), walk(n.b, pred, repl, memo), n.tolerance);
-		case "Intersect": return intersect$1(walk(n.a, pred, repl, memo), walk(n.b, pred, repl, memo), n.tolerance);
-		case "FuseAll": return fuseAll$1(n.shapes.map((c) => walk(c, pred, repl, memo)), n.tolerance);
-		case "CutAll": return cutAll$1(walk(n.base, pred, repl, memo), n.tools.map((c) => walk(c, pred, repl, memo)), n.tolerance);
-		case "Translate": return translate$1(walk(n.target, pred, repl, memo), n.vector);
-		case "Rotate": return rotate$1(walk(n.target, pred, repl, memo), n.angle, {
-			axis: n.axis,
-			at: n.at
-		});
-		case "Scale": return scale$2(walk(n.target, pred, repl, memo), n.factor, { center: n.center });
-		case "Mirror": return mirror$1(walk(n.target, pred, repl, memo), {
-			normal: n.normal,
-			at: n.at
-		});
-		case "Compound": return compound$1(n.children.map((c) => walk(c, pred, repl, memo)));
-		case "Instance": return instance$1(walk(n.source, pred, repl, memo), n.placements, n.fuse);
-		case "Extrude":
-		case "Revolve":
-		case "Loft":
-		case "Sweep":
-		case "Color":
-		case "Fillet":
-		case "Chamfer":
-		case "Shell": return rebuildFeature(n, pred, repl, memo);
-	}
-}
-function rebuildFeature(n, pred, repl, memo) {
-	switch (n.kind) {
-		case "Extrude": return extrude$1(walk(n.profile, pred, repl, memo), n.vector);
-		case "Revolve": return revolve$1(walk(n.profile, pred, repl, memo), n.angle, {
-			axis: n.axis,
-			at: n.at
-		});
-		case "Loft": return loft$1(n.sections.map((s) => walk(s, pred, repl, memo)), { ruled: n.ruled });
-		case "Sweep": return sweep$2(walk(n.profile, pred, repl, memo), walk(n.spine, pred, repl, memo), { frenet: n.frenet });
-		case "Color": return color(walk(n.target, pred, repl, memo), [...n.color]);
-		case "Fillet": return fillet$1(walk(n.target, pred, repl, memo), n.ref, n.radius);
-		case "Chamfer": return chamfer$1(walk(n.target, pred, repl, memo), n.ref, n.distance);
-		case "Shell": return shell$1(walk(n.target, pred, repl, memo), n.refs, n.thickness);
-	}
-}
-/** Visits each DISTINCT node once (identity-deduplicated), so a shared
-*  subtree is reported once and a self-referencing DAG walks in linear time. */
-function forEachNode(root, fn) {
-	const seen = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		if (seen.has(node)) return;
-		seen.add(node);
-		fn(node);
-		for (const child of childrenOf(node)) visit(child);
-	};
-	visit(root);
-}
-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":
-		case "Path":
-		case "Profile": 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":
-		case "Color":
-		case "Fillet":
-		case "Chamfer":
-		case "Shell": return [n.target];
-		case "Compound": return n.children;
-		case "Instance": return [n.source];
-		case "Extrude":
-		case "Revolve": return [n.profile];
-		case "Loft": return n.sections;
-		case "Sweep": return [n.profile, n.spine];
-	}
-}
-function nodeCount(root) {
-	let n = 0;
-	forEachNode(root, () => {
-		n++;
-	});
-	return n;
-}
-//#endregion
 //#region src/sketching/blueprintContourFns.ts
 var EPS$1 = 1e-6;
 function p2(p) {
@@ -8732,7 +8769,7 @@ var patterns_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 //#endregion
 //#region src/ns/csg.ts
 var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
-	CSG_VERSION: () => 7,
+	CSG_VERSION: () => 8,
 	Evaluator: () => Evaluator,
 	add: () => add$1,
 	arbitraryClosedProfile: () => arbitraryClosedProfile,