brepjs 18.131.0 → 18.133.0

package/dist/brepjs.cjs

@@ -1809,8 +1809,8 @@ function hashEdgeRef(h0, ref) {
 *  serializable node data (the cache key stays purely structural); it
 *  resolves against the materialized target at evaluation, so an upstream
 *  parameter edit re-targets the same edge by its face roles. */
-function fillet$1(target, ref, radius) {
-	const copied = {
+function copyEdgeRef(ref) {
+	return {
 		origin: ref.origin,
 		faceRoles: [ref.faceRoles[0], ref.faceRoles[1]],
 		hint: {
@@ -1819,6 +1819,9 @@ function fillet$1(target, ref, radius) {
 			midpoint: ref.hint.midpoint ? [...ref.hint.midpoint] : void 0
 		}
 	};
+}
+function fillet$1(target, ref, radius) {
+	const copied = copyEdgeRef(ref);
 	const re = asScalarExpr(radius);
 	let h = mix(startHash("Fillet"), target);
 	h = hashEdgeRef(h, copied);
@@ -1832,6 +1835,23 @@ function fillet$1(target, ref, radius) {
 		freeParams: depsOf(target, re)
 	};
 }
+/** Chamfer the edge named by a lineage ref on the evaluated target. Same
+*  contract as `fillet`: the ref is deep-copied, serializable node data. */
+function chamfer$1(target, ref, distance) {
+	const copied = copyEdgeRef(ref);
+	const de = asScalarExpr(distance);
+	let h = mix(startHash("Chamfer"), target);
+	h = hashEdgeRef(h, copied);
+	h = mix(h, de);
+	return {
+		kind: "Chamfer",
+		target,
+		ref: copied,
+		distance: de,
+		structuralHash: h,
+		freeParams: depsOf(target, de)
+	};
+}
 /** Attach a color (hex string or RGB/RGBA tuple, canonicalized to RGBA) to
 *  the evaluated result of `target`. Metadata rides beside the geometry: the
 *  evaluator re-tags the shared target materialization with an independent
@@ -1984,7 +2004,8 @@ function outputKindOf(node) {
 		case "Revolve":
 		case "Loft":
 		case "Sweep":
-		case "Fillet": return "Solid";
+		case "Fillet":
+		case "Chamfer": return "Solid";
 		case "Profile": return "Face";
 		case "Path": return "Wire";
 		case "Compound": return "Compound";
@@ -2634,7 +2655,7 @@ function evalExtrude(node, ctx) {
 function evalRevolve(node, ctx) {
 	const a = evalScalar(node.angle, ctx.env, "Revolve.angle");
 	if (!a.ok) return a;
-	if (a.value <= 0) return require_errors.err(require_errors.validationError("CSG_REVOLVE_ANGLE", `Revolve.angle must be positive (degrees), got ${a.value}`));
+	if (!Number.isFinite(a.value) || a.value <= 0) return require_errors.err(require_errors.validationError("CSG_REVOLVE_ANGLE", `Revolve.angle must be positive (degrees), got ${a.value}`));
 	const deg = Math.min(a.value, 360);
 	const axis = node.axis ? evalVec3(node.axis, ctx.env, "Revolve.axis") : require_errors.ok([
 		0,
@@ -2995,7 +3016,7 @@ function evalColor(node, ctx) {
 function evalFillet(node, ctx) {
 	const radius = evalScalar(node.radius, ctx.env, "Fillet.radius");
 	if (!radius.ok) return radius;
-	if (radius.value <= 0) return require_errors.err(require_errors.validationError("CSG_FILLET_RADIUS", `Fillet.radius must be positive, got ${radius.value}`));
+	if (!Number.isFinite(radius.value) || radius.value <= 0) return require_errors.err(require_errors.validationError("CSG_FILLET_RADIUS", `Fillet.radius must be positive, got ${radius.value}`));
 	const t = ctx.evalNode(node.target);
 	if (!t.ok) return t;
 	if (!require_shapeTypes.isSolid(t.value)) return require_errors.err(require_errors.validationError("CSG_FILLET_TARGET", "Fillet.target did not produce a Solid"));
@@ -3007,6 +3028,22 @@ function evalFillet(node, ctx) {
 	return require_healingFns.fillet(solid.value, [resolved.entity], radius.value);
 }
 //#endregion
+//#region src/csg/evaluators/chamfer.ts
+function evalChamfer(node, ctx) {
+	const distance = evalScalar(node.distance, ctx.env, "Chamfer.distance");
+	if (!distance.ok) return distance;
+	if (!Number.isFinite(distance.value) || distance.value <= 0) return require_errors.err(require_errors.validationError("CSG_CHAMFER_DISTANCE", `Chamfer.distance must be positive, got ${distance.value}`));
+	const t = ctx.evalNode(node.target);
+	if (!t.ok) return t;
+	if (!require_shapeTypes.isSolid(t.value)) return require_errors.err(require_errors.validationError("CSG_CHAMFER_TARGET", "Chamfer.target did not produce a Solid"));
+	const solid = require_validityTypes.validSolid(t.value);
+	if (!solid.ok) return require_errors.err(require_errors.validationError("CSG_CHAMFER_TARGET", solid.error));
+	const resolved = require_refResolveFns.resolveRefIn(node.ref, t.value);
+	if (!resolved.ok) return require_errors.err(require_errors.validationError("CSG_CHAMFER_REF", `Chamfer.ref did not resolve: ${resolved.reason}`));
+	if (!require_shapeTypes.isEdge(resolved.entity)) return require_errors.err(require_errors.validationError("CSG_CHAMFER_REF", "Chamfer.ref resolved to a non-edge"));
+	return require_healingFns.chamfer(solid.value, [resolved.entity], distance.value);
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -3031,6 +3068,19 @@ function dispatch(node, ctx) {
 		case "Mirror": return evalMirror(node, ctx);
 		case "Compound": return evalCompound(node, ctx);
 		case "Instance": return evalInstance(node, ctx);
+		case "Extrude":
+		case "Revolve":
+		case "Loft":
+		case "Path":
+		case "Sweep":
+		case "Profile":
+		case "Color":
+		case "Fillet":
+		case "Chamfer": return dispatchFeature(node, ctx);
+	}
+}
+function dispatchFeature(node, ctx) {
+	switch (node.kind) {
 		case "Extrude": return evalExtrude(node, ctx);
 		case "Revolve": return evalRevolve(node, ctx);
 		case "Loft": return evalLoft(node, ctx);
@@ -3039,6 +3089,7 @@ function dispatch(node, ctx) {
 		case "Profile": return evalProfile(node, ctx);
 		case "Color": return evalColor(node, ctx);
 		case "Fillet": return evalFillet(node, ctx);
+		case "Chamfer": return evalChamfer(node, ctx);
 	}
 }
 function hashExprValue(h, v) {
@@ -3448,7 +3499,7 @@ function withEvaluator(options, fn) {
 var MIN_CSG_VERSION = 1;
 function toJSON(node) {
 	return {
-		csgVersion: 5,
+		csgVersion: 6,
 		root: nodeToJson(node)
 	};
 }
@@ -3604,6 +3655,17 @@ function segmentToJson(s) {
 		};
 	}
 }
+function edgeRefToJson(ref) {
+	return {
+		origin: ref.origin,
+		faceRoles: [...ref.faceRoles],
+		hint: {
+			entityType: "edge",
+			length: ref.hint.length,
+			midpoint: ref.hint.midpoint ? [...ref.hint.midpoint] : void 0
+		}
+	};
+}
 function contourToJson(c) {
 	return {
 		start: exprToJson(c.start),
@@ -3681,17 +3743,15 @@ function nodeToJson(n) {
 	if (n.kind === "Fillet") return {
 		kind: "Fillet",
 		target: nodeToJson(n.target),
-		ref: {
-			origin: n.ref.origin,
-			faceRoles: [...n.ref.faceRoles],
-			hint: {
-				entityType: "edge",
-				length: n.ref.hint.length,
-				midpoint: n.ref.hint.midpoint ? [...n.ref.hint.midpoint] : void 0
-			}
-		},
+		ref: edgeRefToJson(n.ref),
 		radius: exprToJson(n.radius)
 	};
+	if (n.kind === "Chamfer") return {
+		kind: "Chamfer",
+		target: nodeToJson(n.target),
+		ref: edgeRefToJson(n.ref),
+		distance: exprToJson(n.distance)
+	};
 	if (n.kind === "Compound") return {
 		kind: "Compound",
 		children: n.children.map(nodeToJson)
@@ -3735,7 +3795,7 @@ 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 > 5) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..5)`);
+	if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_CSG_VERSION || v > 6) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..6)`);
 	const root = envelope["root"];
 	return readNode(root);
 }
@@ -3851,6 +3911,7 @@ function readNode(j) {
 		case "Profile": return readProfile(j);
 		case "Color": return readColor(j);
 		case "Fillet": return readFillet(j);
+		case "Chamfer": return readChamfer(j);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -4100,28 +4161,23 @@ function readContour(j, where) {
 	}
 	return require_errors.ok(contour(start.value, segments));
 }
-function readFillet(j) {
-	const target = readNode(j["target"]);
-	if (!target.ok) return target;
-	const radius = readExpr(j["radius"]);
-	if (!radius.ok) return radius;
-	const ref = j["ref"];
-	if (!isObj(ref)) return bad("Fillet.ref: not an object");
-	const origin = ref["origin"];
-	if (!isString(origin)) return bad("Fillet.ref.origin: not a string");
-	const roles = ref["faceRoles"];
-	if (!Array.isArray(roles) || roles.length !== 2 || !roles.every(isString)) return bad("Fillet.ref.faceRoles: expected two role strings");
-	const hintRaw = ref["hint"];
-	if (!isObj(hintRaw)) return bad("Fillet.ref.hint: not an object");
+function readEdgeRef(j, where) {
+	if (!isObj(j)) return bad(`${where}: not an object`);
+	const origin = j["origin"];
+	if (!isString(origin)) return bad(`${where}.origin: not a string`);
+	const roles = j["faceRoles"];
+	if (!Array.isArray(roles) || roles.length !== 2 || !roles.every(isString)) return bad(`${where}.faceRoles: expected two role strings`);
+	const hintRaw = j["hint"];
+	if (!isObj(hintRaw)) return bad(`${where}.hint: not an object`);
 	const length = hintRaw["length"];
-	if (length !== void 0 && !isNumber$1(length)) return bad("Fillet.ref.hint.length");
+	if (length !== void 0 && !isNumber$1(length)) return bad(`${where}.hint.length`);
 	let midpoint;
 	if (hintRaw["midpoint"] !== void 0) {
-		const m = readVec3(hintRaw["midpoint"], "Fillet.ref.hint.midpoint");
+		const m = readVec3(hintRaw["midpoint"], `${where}.hint.midpoint`);
 		if (!m.ok) return m;
 		midpoint = m.value;
 	}
-	return require_errors.ok(fillet$1(target.value, {
+	return require_errors.ok({
 		origin,
 		faceRoles: [roles[0], roles[1]],
 		hint: {
@@ -4129,7 +4185,25 @@ function readFillet(j) {
 			length,
 			midpoint
 		}
-	}, radius.value));
+	});
+}
+function readFillet(j) {
+	const target = readNode(j["target"]);
+	if (!target.ok) return target;
+	const radius = readExpr(j["radius"]);
+	if (!radius.ok) return radius;
+	const ref = readEdgeRef(j["ref"], "Fillet.ref");
+	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"]);
+	if (!target.ok) return target;
+	const distance = readExpr(j["distance"]);
+	if (!distance.ok) return distance;
+	const ref = readEdgeRef(j["ref"], "Chamfer.ref");
+	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"]);
@@ -4290,7 +4364,8 @@ function optimizeNode(n) {
 		case "Profile":
 		case "Path":
 		case "Color":
-		case "Fillet": return optimizeFeature(n);
+		case "Fillet":
+		case "Chamfer": return optimizeFeature(n);
 	}
 }
 function optimizeFeature(n) {
@@ -4306,6 +4381,7 @@ function optimizeFeature(n) {
 		case "Path": return path(foldExpr(n.start), n.segments.map((s) => foldSegment(s, foldExpr)));
 		case "Color": return color(optimizeNode(n.target), [...n.color]);
 		case "Fillet": return fillet$1(optimizeNode(n.target), n.ref, foldExpr(n.radius));
+		case "Chamfer": return chamfer$1(optimizeNode(n.target), n.ref, foldExpr(n.distance));
 	}
 }
 function optimizeTransform(n) {
@@ -4416,7 +4492,8 @@ function rebuildChildren(n, pred, repl) {
 		case "Loft":
 		case "Sweep":
 		case "Color":
-		case "Fillet": return rebuildFeature(n, pred, repl);
+		case "Fillet":
+		case "Chamfer": return rebuildFeature(n, pred, repl);
 	}
 }
 function rebuildFeature(n, pred, repl) {
@@ -4430,6 +4507,7 @@ function rebuildFeature(n, pred, repl) {
 		case "Sweep": return sweep$2(walk(n.profile, pred, repl), walk(n.spine, pred, repl), { frenet: n.frenet });
 		case "Color": return color(walk(n.target, pred, repl), [...n.color]);
 		case "Fillet": return fillet$1(walk(n.target, pred, repl), n.ref, n.radius);
+		case "Chamfer": return chamfer$1(walk(n.target, pred, repl), n.ref, n.distance);
 	}
 }
 function forEachNode(root, fn) {
@@ -4460,7 +4538,8 @@ function childrenOf(n) {
 		case "Scale":
 		case "Mirror":
 		case "Color":
-		case "Fillet": return [n.target];
+		case "Fillet":
+		case "Chamfer": return [n.target];
 		case "Compound": return n.children;
 		case "Instance": return [n.source];
 		case "Extrude":
@@ -8471,7 +8550,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: () => 5,
+	CSG_VERSION: () => 6,
 	Evaluator: () => Evaluator,
 	add: () => add$1,
 	arbitraryClosedProfile: () => arbitraryClosedProfile,
@@ -8486,6 +8565,7 @@ var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	box: () => box$2,
 	buildVec: () => buildVec,
 	cShapeProfile: () => cShapeProfile,
+	chamfer: () => chamfer$1,
 	circle: () => circle$1,
 	circleHollowProfile: () => circleHollowProfile,
 	circularProfile: () => circularProfile,

package/dist/brepjs.js

@@ -17,7 +17,7 @@ import { a as curveIsPeriodic, c as curvePointAt, d as flipOrientation, f as get
 import { a as meshEdges$1, c as meshMultiLOD, d as createMeshCache, i as mesh$1, l as buildMeshCacheKey, n as exportSTEP, o as meshLODs, r as exportSTL, s as meshLODsProgressive, t as exportIGES, u as clearMeshCache } from "./meshFns-CpfeEN1b.js";
 import { n as getAtOrThrow, r as lastOrThrow, t as firstOrThrow } from "./arrayAccess-DrUGPADn.js";
 import { _ as makeThreePointArc, d as makeCircle, h as makeLine, l as makeBSplineInterpolation, n as fill, p as makeEllipseArc, r as makeFace, s as assembleWire, u as makeBezierCurve } from "./surfaceBuilders-B7WlmoVr.js";
-import { A as toBufferGeometryData, C as chamfer$1, D as shell$1, E as offset$1, M as toLODGeometryData, N as toLODGeometryLevels, O as thicken$1, P as toLineGeometryData, S as chamferDistAngle, T as fillet$2, _ as checkBoolean, a as healFace, b as getNurbsCurveData, c as isValid$1, d as chamferWithEvolution, f as cutWithEvolution, g as shellWithEvolution, h as intersectWithEvolution, i as heal$1, j as toGroupedBufferGeometryData, k as variableFillet, l as solidFromShell, m as fuseWithEvolution, n as fixSelfIntersection, o as healSolid, p as filletWithEvolution, r as fixShape, s as healWire, t as autoHeal, u as positionOnCurve, v as cutAllBisect, w as draft$1, x as getNurbsSurfaceData, y as fuseAllBisect } from "./healingFns-BrrTpxjI.js";
+import { A as toBufferGeometryData, C as chamfer$2, D as shell$1, E as offset$1, M as toLODGeometryData, N as toLODGeometryLevels, O as thicken$1, P as toLineGeometryData, S as chamferDistAngle, T as fillet$2, _ as checkBoolean, a as healFace, b as getNurbsCurveData, c as isValid$1, d as chamferWithEvolution, f as cutWithEvolution, g as shellWithEvolution, h as intersectWithEvolution, i as heal$1, j as toGroupedBufferGeometryData, k as variableFillet, l as solidFromShell, m as fuseWithEvolution, n as fixSelfIntersection, o as healSolid, p as filletWithEvolution, r as fixShape, s as healWire, t as autoHeal, u as positionOnCurve, v as cutAllBisect, w as draft$1, x as getNurbsSurfaceData, y as fuseAllBisect } from "./healingFns-BrrTpxjI.js";
 import { A as setJointValue, B as walkAssembly, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, F as countNodes, G as quatFromAxisAngle, H as circularPattern, I as createAssemblyNode, J as quatRotate, K as quatFromTo, L as findNode, M as sphericalJoint, N as addChild, O as prismaticJoint, P as collectShapes, R as removeChild, S as addJoint, T as jointTransform, U as gridPattern, V as exportAssemblySTEP, W as linearPattern, Y as createAssembly, _ as exportURDF, a as deserializeHistory, b as inverseKinematics, c as modifyStep, d as replayFrom, f as replayHistory, g as undoLast, h as stepsFrom, i as createRegistry, j as setJointValues, k as revoluteJoint, l as registerOperation, m as stepCount, n as addStep, o as findStep, p as serializeHistory, q as quatMultiply, r as createHistory, s as getShape, t as thread, u as registerShape, v as importURDF, w as forwardKinematics, x as jointTrajectory, y as jointsFromDH, z as updateNode } from "./threadFns-B6-3UeCZ.js";
 import { n as BaseSketcher2d, r as organiseBlueprints, t as BlueprintSketcher } from "./blueprintSketcher-yZiAeqft.js";
 import { a as createTypedFinder, i as wireFinder, n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-BiqV-wPK.js";
@@ -1819,8 +1819,8 @@ function hashEdgeRef(h0, ref) {
 *  serializable node data (the cache key stays purely structural); it
 *  resolves against the materialized target at evaluation, so an upstream
 *  parameter edit re-targets the same edge by its face roles. */
-function fillet$1(target, ref, radius) {
-	const copied = {
+function copyEdgeRef(ref) {
+	return {
 		origin: ref.origin,
 		faceRoles: [ref.faceRoles[0], ref.faceRoles[1]],
 		hint: {
@@ -1829,6 +1829,9 @@ function fillet$1(target, ref, radius) {
 			midpoint: ref.hint.midpoint ? [...ref.hint.midpoint] : void 0
 		}
 	};
+}
+function fillet$1(target, ref, radius) {
+	const copied = copyEdgeRef(ref);
 	const re = asScalarExpr(radius);
 	let h = mix(startHash("Fillet"), target);
 	h = hashEdgeRef(h, copied);
@@ -1842,6 +1845,23 @@ function fillet$1(target, ref, radius) {
 		freeParams: depsOf(target, re)
 	};
 }
+/** Chamfer the edge named by a lineage ref on the evaluated target. Same
+*  contract as `fillet`: the ref is deep-copied, serializable node data. */
+function chamfer$1(target, ref, distance) {
+	const copied = copyEdgeRef(ref);
+	const de = asScalarExpr(distance);
+	let h = mix(startHash("Chamfer"), target);
+	h = hashEdgeRef(h, copied);
+	h = mix(h, de);
+	return {
+		kind: "Chamfer",
+		target,
+		ref: copied,
+		distance: de,
+		structuralHash: h,
+		freeParams: depsOf(target, de)
+	};
+}
 /** Attach a color (hex string or RGB/RGBA tuple, canonicalized to RGBA) to
 *  the evaluated result of `target`. Metadata rides beside the geometry: the
 *  evaluator re-tags the shared target materialization with an independent
@@ -1994,7 +2014,8 @@ function outputKindOf(node) {
 		case "Revolve":
 		case "Loft":
 		case "Sweep":
-		case "Fillet": return "Solid";
+		case "Fillet":
+		case "Chamfer": return "Solid";
 		case "Profile": return "Face";
 		case "Path": return "Wire";
 		case "Compound": return "Compound";
@@ -2644,7 +2665,7 @@ function evalExtrude(node, ctx) {
 function evalRevolve(node, ctx) {
 	const a = evalScalar(node.angle, ctx.env, "Revolve.angle");
 	if (!a.ok) return a;
-	if (a.value <= 0) return err(validationError("CSG_REVOLVE_ANGLE", `Revolve.angle must be positive (degrees), got ${a.value}`));
+	if (!Number.isFinite(a.value) || a.value <= 0) return err(validationError("CSG_REVOLVE_ANGLE", `Revolve.angle must be positive (degrees), got ${a.value}`));
 	const deg = Math.min(a.value, 360);
 	const axis = node.axis ? evalVec3(node.axis, ctx.env, "Revolve.axis") : ok([
 		0,
@@ -3005,7 +3026,7 @@ function evalColor(node, ctx) {
 function evalFillet(node, ctx) {
 	const radius = evalScalar(node.radius, ctx.env, "Fillet.radius");
 	if (!radius.ok) return radius;
-	if (radius.value <= 0) return err(validationError("CSG_FILLET_RADIUS", `Fillet.radius must be positive, got ${radius.value}`));
+	if (!Number.isFinite(radius.value) || radius.value <= 0) return err(validationError("CSG_FILLET_RADIUS", `Fillet.radius must be positive, got ${radius.value}`));
 	const t = ctx.evalNode(node.target);
 	if (!t.ok) return t;
 	if (!isSolid(t.value)) return err(validationError("CSG_FILLET_TARGET", "Fillet.target did not produce a Solid"));
@@ -3017,6 +3038,22 @@ function evalFillet(node, ctx) {
 	return fillet$2(solid.value, [resolved.entity], radius.value);
 }
 //#endregion
+//#region src/csg/evaluators/chamfer.ts
+function evalChamfer(node, ctx) {
+	const distance = evalScalar(node.distance, ctx.env, "Chamfer.distance");
+	if (!distance.ok) return distance;
+	if (!Number.isFinite(distance.value) || distance.value <= 0) return err(validationError("CSG_CHAMFER_DISTANCE", `Chamfer.distance must be positive, got ${distance.value}`));
+	const t = ctx.evalNode(node.target);
+	if (!t.ok) return t;
+	if (!isSolid(t.value)) return err(validationError("CSG_CHAMFER_TARGET", "Chamfer.target did not produce a Solid"));
+	const solid = validSolid(t.value);
+	if (!solid.ok) return err(validationError("CSG_CHAMFER_TARGET", solid.error));
+	const resolved = resolveRefIn(node.ref, t.value);
+	if (!resolved.ok) return err(validationError("CSG_CHAMFER_REF", `Chamfer.ref did not resolve: ${resolved.reason}`));
+	if (!isEdge(resolved.entity)) return err(validationError("CSG_CHAMFER_REF", "Chamfer.ref resolved to a non-edge"));
+	return chamfer$2(solid.value, [resolved.entity], distance.value);
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -3041,6 +3078,19 @@ function dispatch(node, ctx) {
 		case "Mirror": return evalMirror(node, ctx);
 		case "Compound": return evalCompound(node, ctx);
 		case "Instance": return evalInstance(node, ctx);
+		case "Extrude":
+		case "Revolve":
+		case "Loft":
+		case "Path":
+		case "Sweep":
+		case "Profile":
+		case "Color":
+		case "Fillet":
+		case "Chamfer": return dispatchFeature(node, ctx);
+	}
+}
+function dispatchFeature(node, ctx) {
+	switch (node.kind) {
 		case "Extrude": return evalExtrude(node, ctx);
 		case "Revolve": return evalRevolve(node, ctx);
 		case "Loft": return evalLoft(node, ctx);
@@ -3049,6 +3099,7 @@ function dispatch(node, ctx) {
 		case "Profile": return evalProfile(node, ctx);
 		case "Color": return evalColor(node, ctx);
 		case "Fillet": return evalFillet(node, ctx);
+		case "Chamfer": return evalChamfer(node, ctx);
 	}
 }
 function hashExprValue(h, v) {
@@ -3458,7 +3509,7 @@ function withEvaluator(options, fn) {
 var MIN_CSG_VERSION = 1;
 function toJSON(node) {
 	return {
-		csgVersion: 5,
+		csgVersion: 6,
 		root: nodeToJson(node)
 	};
 }
@@ -3614,6 +3665,17 @@ function segmentToJson(s) {
 		};
 	}
 }
+function edgeRefToJson(ref) {
+	return {
+		origin: ref.origin,
+		faceRoles: [...ref.faceRoles],
+		hint: {
+			entityType: "edge",
+			length: ref.hint.length,
+			midpoint: ref.hint.midpoint ? [...ref.hint.midpoint] : void 0
+		}
+	};
+}
 function contourToJson(c) {
 	return {
 		start: exprToJson(c.start),
@@ -3691,17 +3753,15 @@ function nodeToJson(n) {
 	if (n.kind === "Fillet") return {
 		kind: "Fillet",
 		target: nodeToJson(n.target),
-		ref: {
-			origin: n.ref.origin,
-			faceRoles: [...n.ref.faceRoles],
-			hint: {
-				entityType: "edge",
-				length: n.ref.hint.length,
-				midpoint: n.ref.hint.midpoint ? [...n.ref.hint.midpoint] : void 0
-			}
-		},
+		ref: edgeRefToJson(n.ref),
 		radius: exprToJson(n.radius)
 	};
+	if (n.kind === "Chamfer") return {
+		kind: "Chamfer",
+		target: nodeToJson(n.target),
+		ref: edgeRefToJson(n.ref),
+		distance: exprToJson(n.distance)
+	};
 	if (n.kind === "Compound") return {
 		kind: "Compound",
 		children: n.children.map(nodeToJson)
@@ -3745,7 +3805,7 @@ 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 > 5) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..5)`);
+	if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_CSG_VERSION || v > 6) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..6)`);
 	const root = envelope["root"];
 	return readNode(root);
 }
@@ -3861,6 +3921,7 @@ function readNode(j) {
 		case "Profile": return readProfile(j);
 		case "Color": return readColor(j);
 		case "Fillet": return readFillet(j);
+		case "Chamfer": return readChamfer(j);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -4110,28 +4171,23 @@ function readContour(j, where) {
 	}
 	return ok(contour(start.value, segments));
 }
-function readFillet(j) {
-	const target = readNode(j["target"]);
-	if (!target.ok) return target;
-	const radius = readExpr(j["radius"]);
-	if (!radius.ok) return radius;
-	const ref = j["ref"];
-	if (!isObj(ref)) return bad("Fillet.ref: not an object");
-	const origin = ref["origin"];
-	if (!isString(origin)) return bad("Fillet.ref.origin: not a string");
-	const roles = ref["faceRoles"];
-	if (!Array.isArray(roles) || roles.length !== 2 || !roles.every(isString)) return bad("Fillet.ref.faceRoles: expected two role strings");
-	const hintRaw = ref["hint"];
-	if (!isObj(hintRaw)) return bad("Fillet.ref.hint: not an object");
+function readEdgeRef(j, where) {
+	if (!isObj(j)) return bad(`${where}: not an object`);
+	const origin = j["origin"];
+	if (!isString(origin)) return bad(`${where}.origin: not a string`);
+	const roles = j["faceRoles"];
+	if (!Array.isArray(roles) || roles.length !== 2 || !roles.every(isString)) return bad(`${where}.faceRoles: expected two role strings`);
+	const hintRaw = j["hint"];
+	if (!isObj(hintRaw)) return bad(`${where}.hint: not an object`);
 	const length = hintRaw["length"];
-	if (length !== void 0 && !isNumber$1(length)) return bad("Fillet.ref.hint.length");
+	if (length !== void 0 && !isNumber$1(length)) return bad(`${where}.hint.length`);
 	let midpoint;
 	if (hintRaw["midpoint"] !== void 0) {
-		const m = readVec3(hintRaw["midpoint"], "Fillet.ref.hint.midpoint");
+		const m = readVec3(hintRaw["midpoint"], `${where}.hint.midpoint`);
 		if (!m.ok) return m;
 		midpoint = m.value;
 	}
-	return ok(fillet$1(target.value, {
+	return ok({
 		origin,
 		faceRoles: [roles[0], roles[1]],
 		hint: {
@@ -4139,7 +4195,25 @@ function readFillet(j) {
 			length,
 			midpoint
 		}
-	}, radius.value));
+	});
+}
+function readFillet(j) {
+	const target = readNode(j["target"]);
+	if (!target.ok) return target;
+	const radius = readExpr(j["radius"]);
+	if (!radius.ok) return radius;
+	const ref = readEdgeRef(j["ref"], "Fillet.ref");
+	if (!ref.ok) return ref;
+	return ok(fillet$1(target.value, ref.value, radius.value));
+}
+function readChamfer(j) {
+	const target = readNode(j["target"]);
+	if (!target.ok) return target;
+	const distance = readExpr(j["distance"]);
+	if (!distance.ok) return distance;
+	const ref = readEdgeRef(j["ref"], "Chamfer.ref");
+	if (!ref.ok) return ref;
+	return ok(chamfer$1(target.value, ref.value, distance.value));
 }
 function readColor(j) {
 	const target = readNode(j["target"]);
@@ -4300,7 +4374,8 @@ function optimizeNode(n) {
 		case "Profile":
 		case "Path":
 		case "Color":
-		case "Fillet": return optimizeFeature(n);
+		case "Fillet":
+		case "Chamfer": return optimizeFeature(n);
 	}
 }
 function optimizeFeature(n) {
@@ -4316,6 +4391,7 @@ function optimizeFeature(n) {
 		case "Path": return path(foldExpr(n.start), n.segments.map((s) => foldSegment(s, foldExpr)));
 		case "Color": return color(optimizeNode(n.target), [...n.color]);
 		case "Fillet": return fillet$1(optimizeNode(n.target), n.ref, foldExpr(n.radius));
+		case "Chamfer": return chamfer$1(optimizeNode(n.target), n.ref, foldExpr(n.distance));
 	}
 }
 function optimizeTransform(n) {
@@ -4426,7 +4502,8 @@ function rebuildChildren(n, pred, repl) {
 		case "Loft":
 		case "Sweep":
 		case "Color":
-		case "Fillet": return rebuildFeature(n, pred, repl);
+		case "Fillet":
+		case "Chamfer": return rebuildFeature(n, pred, repl);
 	}
 }
 function rebuildFeature(n, pred, repl) {
@@ -4440,6 +4517,7 @@ function rebuildFeature(n, pred, repl) {
 		case "Sweep": return sweep$2(walk(n.profile, pred, repl), walk(n.spine, pred, repl), { frenet: n.frenet });
 		case "Color": return color(walk(n.target, pred, repl), [...n.color]);
 		case "Fillet": return fillet$1(walk(n.target, pred, repl), n.ref, n.radius);
+		case "Chamfer": return chamfer$1(walk(n.target, pred, repl), n.ref, n.distance);
 	}
 }
 function forEachNode(root, fn) {
@@ -4470,7 +4548,8 @@ function childrenOf(n) {
 		case "Scale":
 		case "Mirror":
 		case "Color":
-		case "Fillet": return [n.target];
+		case "Fillet":
+		case "Chamfer": return [n.target];
 		case "Compound": return n.children;
 		case "Instance": return [n.source];
 		case "Extrude":
@@ -7075,7 +7154,7 @@ function chamfer(shape, edgesOrDistance, maybeDistance) {
 		const selectedEdges = edges ?? getEdges(s);
 		return chamferDistAngle(s, [...selectedEdges], normalized.distance, normalized.angle);
 	}
-	return chamfer$1(s, edges, normalized.distance);
+	return chamfer$2(s, edges, normalized.distance);
 }
 /** Create a hollow shell by removing faces and offsetting remaining walls. */
 function shell(shape, faces, thickness, options) {
@@ -8480,7 +8559,7 @@ var patterns_exports = /* @__PURE__ */ __exportAll({
 //#endregion
 //#region src/ns/csg.ts
 var csg_exports = /* @__PURE__ */ __exportAll({
-	CSG_VERSION: () => 5,
+	CSG_VERSION: () => 6,
 	Evaluator: () => Evaluator,
 	add: () => add$1,
 	arbitraryClosedProfile: () => arbitraryClosedProfile,
@@ -8495,6 +8574,7 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	box: () => box$2,
 	buildVec: () => buildVec,
 	cShapeProfile: () => cShapeProfile,
+	chamfer: () => chamfer$1,
 	circle: () => circle$1,
 	circleHollowProfile: () => circleHollowProfile,
 	circularProfile: () => circularProfile,

package/dist/csg/builders.d.ts

@@ -3,7 +3,7 @@ import { Contour, Segment2D } from './segments.js';
 import { Matrix4x4 } from '../core/types.js';
 import { ColorInput } from '../topology/metadata/colorFns.js';
 import { EdgeRef } from '../topology/shapeRef/shapeRefTypes.js';
-import { BoxNode, SphereNode, CylinderNode, ConeNode, TorusNode, PolygonNode, CircleNode, LineNode, VertexLitNode, EmptyNode, FuseNode, CutNode, IntersectNode, FuseAllNode, CutAllNode, TranslateNode, RotateNode, ScaleNode, MirrorNode, ExtrudeNode, RevolveNode, LoftNode, SweepNode, ProfileNode, PathNode, ColorNode, FilletNode, CompoundNode, InstanceNode, IRNode, SolidNode, FaceNode, EdgeNode, VertexNode } from './types.js';
+import { BoxNode, SphereNode, CylinderNode, ConeNode, TorusNode, PolygonNode, CircleNode, LineNode, VertexLitNode, EmptyNode, FuseNode, CutNode, IntersectNode, FuseAllNode, CutAllNode, TranslateNode, RotateNode, ScaleNode, MirrorNode, ExtrudeNode, RevolveNode, LoftNode, SweepNode, ProfileNode, PathNode, ColorNode, FilletNode, ChamferNode, CompoundNode, InstanceNode, IRNode, SolidNode, FaceNode, EdgeNode, VertexNode } from './types.js';
 export declare function box(x: ScalarInput, y: ScalarInput, z: ScalarInput): BoxNode;
 export declare function sphere(radius: ScalarInput): SphereNode;
 export declare function cylinder(radius: ScalarInput, height: ScalarInput): CylinderNode;
@@ -37,11 +37,10 @@ export interface MirrorOptions {
 }
 export declare function mirror(target: IRNode, options?: MirrorOptions): MirrorNode;
 export declare function extrude(profile: FaceNode, vector: Vec3Input): ExtrudeNode;
-/** Fillet the edge named by a lineage ref on the evaluated target. The ref is
- *  serializable node data (the cache key stays purely structural); it
- *  resolves against the materialized target at evaluation, so an upstream
- *  parameter edit re-targets the same edge by its face roles. */
 export declare function fillet(target: IRNode, ref: EdgeRef, radius: ScalarInput): FilletNode;
+/** Chamfer the edge named by a lineage ref on the evaluated target. Same
+ *  contract as `fillet`: the ref is deep-copied, serializable node data. */
+export declare function chamfer(target: IRNode, ref: EdgeRef, distance: ScalarInput): ChamferNode;
 /** Attach a color (hex string or RGB/RGBA tuple, canonicalized to RGBA) to
  *  the evaluated result of `target`. Metadata rides beside the geometry: the
  *  evaluator re-tags the shared target materialization with an independent

package/dist/csg/evaluators/chamfer.d.ts

@@ -0,0 +1,5 @@
+import { Result } from '../../core/result.js';
+import { AnyShape, Dimension } from '../../core/shapeTypes.js';
+import { ChamferNode } from '../types.js';
+import { EvalContext } from './context.js';
+export declare function evalChamfer(node: ChamferNode, ctx: EvalContext): Result<AnyShape<Dimension>>;

package/dist/csg/index.d.ts

@@ -5,9 +5,9 @@
  * parameterize via named expression bindings; evaluate against the active
  * kernel with subtree-level cache reuse for incremental parametric edits.
  */
-export { box, sphere, cylinder, cone, torus, polygon, circle, line, vertex, emptySolid, emptyFace, emptyWire, fuse, cut, intersect, fuseAll, cutAll, translate, rotate, scale, mirror, extrude, revolve, loft, sweep, profile, path, color, fillet, compound, instance, type RevolveOptions, type LoftOptions, type SweepNodeOptions, type RotateOptions, type ScaleOptions, type MirrorOptions, } from './builders.js';
+export { box, sphere, cylinder, cone, torus, polygon, circle, line, vertex, emptySolid, emptyFace, emptyWire, fuse, cut, intersect, fuseAll, cutAll, translate, rotate, scale, mirror, extrude, revolve, loft, sweep, profile, path, color, fillet, chamfer, compound, instance, type RevolveOptions, type LoftOptions, type SweepNodeOptions, type RotateOptions, type ScaleOptions, type MirrorOptions, } from './builders.js';
 export { numLit, vec3Lit, vec2Lit, param, binOp, unaryOp, component, buildVec, add, mul, asScalarExpr, asVec3Expr, asVec2Expr, type Expr, type ExprValue, type Env, type ScalarInput, type Vec3Input, type Vec2Input, type BinaryOp, type UnaryOp, } from './expressions.js';
-export type { IRNode, NodeKind, OutputKind, PrimitiveNode, BooleanNode, TransformIRNode, ExtrudeNode, RevolveNode, LoftNode, SweepNode, ProfileNode, PathNode, ColorNode, FilletNode, InstanceNode, SolidNode, FaceNode, EdgeNode, VertexNode, AnyNode, } from './types.js';
+export type { IRNode, NodeKind, OutputKind, PrimitiveNode, BooleanNode, TransformIRNode, ExtrudeNode, RevolveNode, LoftNode, SweepNode, ProfileNode, PathNode, ColorNode, FilletNode, ChamferNode, InstanceNode, SolidNode, FaceNode, EdgeNode, VertexNode, AnyNode, } from './types.js';
 export { outputKindOf } from './types.js';
 export { lineTo, arcTo, bezierTo, ellipseArcTo, contour, type Contour, type Segment2D, type SegmentOptions, type EllipseArcOptions, } from './segments.js';
 export { rectangularProfile, circularProfile, iBeamProfile, asymmetricIProfile, lShapeProfile, tShapeProfile, uShapeProfile, zShapeProfile, cShapeProfile, ellipseProfile, trapeziumProfile, rectangleHollowProfile, circleHollowProfile, arbitraryClosedProfile, arbitraryProfileWithVoids, type IBeamParams, type AsymmetricIParams, type LShapeParams, type TShapeParams, type UShapeParams, type ZShapeParams, type CShapeParams, type TrapeziumParams, type RectangleHollowParams, type CircleHollowParams, } from './profiles.js';

package/dist/csg/serialize.d.ts

@@ -1,6 +1,6 @@
 import { Result } from '../core/result.js';
 import { IRNode } from './types.js';
-export declare const CSG_VERSION = 5;
+export declare const CSG_VERSION = 6;
 export interface CsgEnvelope {
     readonly csgVersion: number;
     readonly root: unknown;

package/dist/csg/types.d.ts

@@ -134,6 +134,13 @@ export interface FilletNode extends IRNodeBase {
     readonly ref: EdgeRef;
     readonly radius: Expr;
 }
+export interface ChamferNode extends IRNodeBase {
+    readonly kind: 'Chamfer';
+    readonly target: IRNode;
+    /** Serializable lineage ref naming the edge by its two adjacent face roles. */
+    readonly ref: EdgeRef;
+    readonly distance: Expr;
+}
 export interface ColorNode extends IRNodeBase {
     readonly kind: 'Color';
     readonly target: IRNode;
@@ -186,7 +193,7 @@ export interface InstanceNode extends IRNodeBase {
 export type PrimitiveNode = BoxNode | SphereNode | CylinderNode | ConeNode | TorusNode | PolygonNode | CircleNode | LineNode | VertexLitNode | EmptyNode;
 export type BooleanNode = FuseNode | CutNode | IntersectNode | FuseAllNode | CutAllNode;
 export type TransformIRNode = TranslateNode | RotateNode | ScaleNode | MirrorNode;
-export type IRNode = PrimitiveNode | BooleanNode | TransformIRNode | ExtrudeNode | RevolveNode | LoftNode | SweepNode | ProfileNode | PathNode | ColorNode | FilletNode | CompoundNode | InstanceNode;
+export type IRNode = PrimitiveNode | BooleanNode | TransformIRNode | ExtrudeNode | RevolveNode | LoftNode | SweepNode | ProfileNode | PathNode | ColorNode | FilletNode | ChamferNode | CompoundNode | InstanceNode;
 export type NodeKind = IRNode['kind'];
 export type AnyNode = IRNode;
 /** Nodes that produce a 3D solid. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs",
-  "version": "18.131.0",
+  "version": "18.133.0",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",