brepjs 18.124.8 → 18.126.0

package/dist/brepjs.js

@@ -16,7 +16,7 @@ import { a as isSameShape, i as isEqualShape, n as getHashCode, o as simplify$1,
 import { a as curveIsPeriodic, c as curvePointAt, d as flipOrientation, f as getCurveType, h as offsetWire2D, i as curveIsClosed, l as curveStartPoint, m as interpolateCurve, n as curveAxis, o as curveLength, p as getOrientation, r as curveEndPoint, s as curvePeriod, t as approximateCurve, u as curveTangentAt } from "./curveFns-Bh_PHl9N.js";
 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, r as makeFace, s as assembleWire } from "./surfaceBuilders-B7WlmoVr.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 shellWithEvolution, D as getNurbsCurveData, E as fuseAllBisect, M as toLODGeometryData, N as toLODGeometryLevels, O as getNurbsSurfaceData, P as toLineGeometryData, S as intersectWithEvolution, T as cutAllBisect, _ as positionOnCurve, a as healFace, b as filletWithEvolution, c as isValid$1, d as draft$1, f as fillet$1, g as variableFillet, h as thicken$1, i as heal$1, j as toGroupedBufferGeometryData, k as chamferDistAngle, l as solidFromShell, m as shell$1, n as fixSelfIntersection, o as healSolid, p as offset$1, r as fixShape, s as healWire, t as autoHeal, u as chamfer$1, v as chamferWithEvolution, w as checkBoolean, x as fuseWithEvolution, y as cutWithEvolution } from "./healingFns-Digw1d6D.js";
 import { A as setJointValue, B as createAssemblyNode, C as cylindricalJoint, D as planarJoint, E as mechanismDOF, F as quatMultiply, G as circularPattern, H as removeChild, I as quatRotate, J as exportAssemblySTEP, K as gridPattern, L as addChild, M as sphericalJoint, N as quatFromAxisAngle, O as prismaticJoint, P as quatFromTo, R as collectShapes, S as addJoint, T as jointTransform, U as updateNode, V as findNode, W as walkAssembly, 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 linearPattern, 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 countNodes } from "./threadFns-BWbibv4L.js";
 import { n as BaseSketcher2d, r as organiseBlueprints, t as BlueprintSketcher } from "./blueprintSketcher-yZiAeqft.js";
@@ -27,8 +27,8 @@ import { t as cornerFinder } from "./cornerFinder-CiHpo7kU.js";
 import { a as fuseBlueprints, c as roundedRectangleBlueprint, i as cutBlueprints, n as fuse2D, o as intersectBlueprints, r as intersect2D, s as polysidesBlueprint, t as cut2D } from "./boolean2D-BuM5xJSa.js";
 import { S as reverseCurve, _ as curve2dIsOnCurve, a as isInside2D, b as curve2dSplitAt, c as scale2D, d as stretch2D, f as toSVGPathD, g as curve2dFirstPoint, h as curve2dDistanceFrom, i as getOrientation2D, l as sketchOnFace2D, m as curve2dBoundingBox, n as createCompoundBlueprint, o as mirror2D, p as translate2D, r as getBounds2D, s as rotate2D, t as createBlueprint, u as sketchOnPlane2D, v as curve2dLastPoint, x as curve2dTangentAt, y as curve2dParameter } from "./blueprintFns-COSD5yZH.js";
 import { a as importSVG, c as blueprintToDXF, d as exportGltf, f as exportOBJ, i as exportSTEPConfigured, l as exportDXF, n as importSTEP, o as importSVGPathD, r as importSTL, s as exportThreeMF, t as importIGES, u as exportGlb } from "./importFns-BId6d2pt.js";
-import { a as multiSectionSweep, c as twistExtrude, i as guidedSweep, n as loftAll, o as supportExtrude, r as complexExtrude, s as sweep$1, t as loft$1 } from "./loftFns-m7LoJWE2.js";
-import { a as Sketch, b as extrudeAll, c as compoundSketchLoft, d as sketchFace, f as sketchLoft, h as sketchWires, i as Sketches, l as compoundSketchRevolve, m as sketchSweep, n as getFont, o as compoundSketchExtrude, p as sketchRevolve, r as loadFont, s as compoundSketchFace, t as textBlueprints, u as sketchExtrude, v as CompoundSketch, x as revolve$1, y as extrude$1 } from "./textBlueprints-C1aMaWLc.js";
+import { a as multiSectionSweep, c as twistExtrude, i as guidedSweep, n as loftAll, o as supportExtrude, r as complexExtrude, s as sweep$1, t as loft$2 } from "./loftFns-m7LoJWE2.js";
+import { a as Sketch, b as extrudeAll, c as compoundSketchLoft, d as sketchFace, f as sketchLoft, h as sketchWires, i as Sketches, l as compoundSketchRevolve, m as sketchSweep, n as getFont, o as compoundSketchExtrude, p as sketchRevolve, r as loadFont, s as compoundSketchFace, t as textBlueprints, u as sketchExtrude, v as CompoundSketch, x as revolve$2, y as extrude$2 } from "./textBlueprints-C1aMaWLc.js";
 import { a as makeProjectedEdges, i as projectEdges, n as cameraLookAt, r as createCamera, s as isProjectionPlane, t as cameraFromPlane } from "./cameraFns-VVI0cWLa.js";
 import { n as textMetrics, r as sketchText, t as fontMetrics } from "./textMetrics-DH3YPwVC.js";
 import { a as facesOfVertex, c as verticesOfFace, i as facesOfEdge, l as wiresOfFace, n as adjacentFaces, o as sharedEdges, r as edgesOfFace, s as verticesOfEdge } from "./adjacencyFns-CwcdjOsT.js";
@@ -264,8 +264,8 @@ function repairMesh(mesh, opts, id) {
 	if (isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$8 = _usingCtx();
-			const repaired = _usingCtx$8.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
+			var _usingCtx$10 = _usingCtx();
+			const repaired = _usingCtx$10.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
 			const vertexCount = repaired.positions.length / 3;
 			return ok({
 				vertices: repaired.positions,
@@ -279,9 +279,9 @@ function repairMesh(mesh, opts, id) {
 				}]
 			});
 		} catch (_) {
-			_usingCtx$8.e = _;
+			_usingCtx$10.e = _;
 		} finally {
-			_usingCtx$8.d();
+			_usingCtx$10.d();
 		}
 	} catch (cause) {
 		return err(computationError("VOXEL_REPAIR_FAILED", cause instanceof Error ? cause.message : "voxel repair failed (grid too large?).", cause));
@@ -360,12 +360,12 @@ function offsetMesh(mesh, distance, opts, id) {
 	if (isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$7 = _usingCtx();
-			return meshFromResult(_usingCtx$7.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
+			var _usingCtx$9 = _usingCtx();
+			return meshFromResult(_usingCtx$9.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
 		} catch (_) {
-			_usingCtx$7.e = _;
+			_usingCtx$9.e = _;
 		} finally {
-			_usingCtx$7.d();
+			_usingCtx$9.d();
 		}
 	} catch (cause) {
 		return err(computationError("VOXEL_OFFSET_FAILED", cause instanceof Error ? cause.message : "voxel offset failed (grid too large?).", cause));
@@ -490,9 +490,9 @@ function resolveGridParams$1(opts) {
 */
 function meshFromField(field) {
 	try {
-		var _usingCtx$6 = _usingCtx();
+		var _usingCtx$8 = _usingCtx();
 		const rawResult = field.contour();
-		const { positions, normals, indices } = _usingCtx$6.u({
+		const { positions, normals, indices } = _usingCtx$8.u({
 			value: rawResult,
 			[Symbol.dispose]() {
 				rawResult.free();
@@ -512,9 +512,9 @@ function meshFromField(field) {
 			}]
 		});
 	} catch (_) {
-		_usingCtx$6.e = _;
+		_usingCtx$8.e = _;
 	} finally {
-		_usingCtx$6.d();
+		_usingCtx$8.d();
 	}
 }
 function fieldDeletable(raw) {
@@ -1082,13 +1082,13 @@ function latticeInfill(mesh, opts, id) {
 	const { tag, period, thickness, resolution, padding } = resolved.value;
 	try {
 		try {
-			var _usingCtx$5 = _usingCtx();
-			const repaired = _usingCtx$5.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness));
+			var _usingCtx$7 = _usingCtx();
+			const repaired = _usingCtx$7.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness));
 			return ok(toMesh(repaired));
 		} catch (_) {
-			_usingCtx$5.e = _;
+			_usingCtx$7.e = _;
 		} finally {
-			_usingCtx$5.d();
+			_usingCtx$7.d();
 		}
 	} catch (cause) {
 		return err(computationError("LATTICE_INFILL_FAILED", cause instanceof Error ? cause.message : "lattice infill failed (grid too large?).", cause));
@@ -1567,7 +1567,7 @@ function polyhedron(points, faces, options = {}) {
 }
 //#endregion
 //#region src/operations/straightSkeleton.ts
-var EPS = 1e-10;
+var EPS$1 = 1e-10;
 function cross2(ax, ay, bx, by) {
 	return ax * by - ay * bx;
 }
@@ -1605,7 +1605,7 @@ function bisector(poly, i) {
 	const e2x = next.x - cur.x;
 	const e2y = next.y - cur.y;
 	const e2l = len2(e2x, e2y);
-	if (e1l < EPS || e2l < EPS) return {
+	if (e1l < EPS$1 || e2l < EPS$1) return {
 		dx: 0,
 		dy: 0
 	};
@@ -1616,14 +1616,14 @@ function bisector(poly, i) {
 	let bx = n1x + n2x;
 	let by = n1y + n2y;
 	const bl = len2(bx, by);
-	if (bl < EPS) return {
+	if (bl < EPS$1) return {
 		dx: n1x,
 		dy: n1y
 	};
 	bx /= bl;
 	by /= bl;
 	const cosHalf = dot2(bx, by, n1x, n1y);
-	const speed = Math.abs(cosHalf) > EPS ? 1 / cosHalf : 1;
+	const speed = Math.abs(cosHalf) > EPS$1 ? 1 / cosHalf : 1;
 	return {
 		dx: bx * speed,
 		dy: by * speed
@@ -1685,14 +1685,14 @@ function bisectorIntersectTime(a, b) {
 	const ddy = a.by - b.by;
 	const dxp = b.x - a.x;
 	const dyp = b.y - a.y;
-	if (Math.abs(ddx) < EPS && Math.abs(ddy) < EPS) return null;
+	if (Math.abs(ddx) < EPS$1 && Math.abs(ddy) < EPS$1) return null;
 	let t;
 	if (Math.abs(ddx) > Math.abs(ddy)) t = dxp / ddx;
 	else t = dyp / ddy;
-	if (t < EPS) return null;
+	if (t < EPS$1) return null;
 	const otherDd = Math.abs(ddx) > Math.abs(ddy) ? ddy : ddx;
 	const otherDp = Math.abs(ddx) > Math.abs(ddy) ? dyp : dxp;
-	if (Math.abs(otherDd) > EPS) {
+	if (Math.abs(otherDd) > EPS$1) {
 		const t2 = otherDp / otherDd;
 		if (Math.abs(t - t2) > 1e-4 * Math.max(1, Math.abs(t))) return null;
 	}
@@ -1703,16 +1703,16 @@ function raySplitTime(node, eA, eB) {
 	const edx = eB.x - eA.x;
 	const edy = eB.y - eA.y;
 	const el = len2(edx, edy);
-	if (el < EPS) return null;
+	if (el < EPS$1) return null;
 	const enx = -edy / el;
 	const eny = edx / el;
 	const d0 = (node.x - eA.x) * enx + (node.y - eA.y) * eny;
 	const relBx = node.bx - (eA.bx + eB.bx) / 2;
 	const relBy = node.by - (eA.by + eB.by) / 2;
 	const dRate = relBx * enx + relBy * eny;
-	if (Math.abs(dRate) < EPS) return null;
+	if (Math.abs(dRate) < EPS$1) return null;
 	const t = -d0 / dRate;
-	if (t < EPS) return null;
+	if (t < EPS$1) return null;
 	const px = node.x + t * node.bx;
 	const py = node.y + t * node.by;
 	const ax = eA.x + t * eA.bx;
@@ -1722,7 +1722,7 @@ function raySplitTime(node, eA, eB) {
 	const segDx = bxx - ax;
 	const segDy = byy - ay;
 	const segL = len2(segDx, segDy);
-	if (segL < EPS) return t;
+	if (segL < EPS$1) return t;
 	const s = dot2(px - ax, py - ay, segDx, segDy) / (segL * segL);
 	if (s < -.01 || s > 1.01) return null;
 	return t;
@@ -1732,7 +1732,7 @@ function computeEvents(lavNodes) {
 	for (const node of lavNodes) {
 		if (!node.active || !node.next) continue;
 		const t = bisectorIntersectTime(node, node.next);
-		if (t !== null && t > EPS) {
+		if (t !== null && t > EPS$1) {
 			const x = node.x + t * node.bx;
 			const y = node.y + t * node.by;
 			events.push({
@@ -1749,7 +1749,7 @@ function computeEvents(lavNodes) {
 			let count = 0;
 			while (cur !== node.prev && cur !== node && count < 1e3) {
 				const st = raySplitTime(node, cur, cur.next);
-				if (st !== null && st > EPS) {
+				if (st !== null && st > EPS$1) {
 					const x = node.x + st * node.bx;
 					const y = node.y + st * node.by;
 					events.push({
@@ -1805,7 +1805,7 @@ function computeStraightSkeletonImpl(polygon) {
 				const b = a.next;
 				const c = b.next;
 				const t = bisectorIntersectTime(a, b);
-				const time = t !== null && t > EPS ? t : 0;
+				const time = t !== null && t > EPS$1 ? t : 0;
 				const mx = (a.x + b.x + c.x) / 3 + time * (a.bx + b.bx + c.bx) / 3;
 				const my = (a.y + b.y + c.y) / 3 + time * (a.by + b.by + c.by) / 3;
 				const nodeIdx = skeletonNodes.length;
@@ -1944,7 +1944,7 @@ function computeStraightSkeletonImpl(polygon) {
 			if (!sn) continue;
 			const lastVert = faceVerts[faceVerts.length - 1];
 			if (!lastVert) continue;
-			if (len2(sn.x - lastVert.x, sn.y - lastVert.y) > EPS) {
+			if (len2(sn.x - lastVert.x, sn.y - lastVert.y) > EPS$1) {
 				faceVerts.push({
 					x: sn.x,
 					y: sn.y
@@ -3737,7 +3737,7 @@ function isEmpty(shape) {
 */
 function extrude(face, height) {
 	const f = resolve(face);
-	return extrude$1(f, typeof height === "number" ? [
+	return extrude$2(f, typeof height === "number" ? [
 		0,
 		0,
 		height
@@ -3752,7 +3752,7 @@ function revolve(face, options) {
 		0,
 		0
 	];
-	return revolve$1(resolve(face), pivotPoint, options?.axis ?? [
+	return revolve$2(resolve(face), pivotPoint, options?.axis ?? [
 		0,
 		0,
 		1
@@ -3763,7 +3763,7 @@ function revolve(face, options) {
 */
 function loft(wires, options) {
 	const resolvedWires = wires.map((w) => resolve(w));
-	return loft$1(resolvedWires, options);
+	return loft$2(resolvedWires, options);
 }
 //#endregion
 //#region src/operations/compoundOpsFns.ts
@@ -3910,7 +3910,7 @@ function drill(shape, options) {
 */
 function pocket(shape, options) {
 	try {
-		var _usingCtx$4 = _usingCtx();
+		var _usingCtx$6 = _usingCtx();
 		const s = resolve(shape);
 		const { profile, depth } = options;
 		if (depth <= 0) return err(validationError("POCKET_INVALID_DEPTH", "Pocket depth must be positive"));
@@ -3919,7 +3919,7 @@ function pocket(shape, options) {
 		const targetFace = targetResult.value;
 		const normal = normalAt(targetFace);
 		const center = faceCenter(targetFace);
-		const scope = _usingCtx$4.u(new DisposalScope());
+		const scope = _usingCtx$6.u(new DisposalScope());
 		const { wire: w, owned } = toWire(profile);
 		if (owned) scope.register(w);
 		const faceResult = makeFace(w);
@@ -3927,14 +3927,14 @@ function pocket(shape, options) {
 		scope.register(faceResult.value);
 		const positioned = scope.register(translate$2(faceResult.value, center));
 		const extDir = vecScale(vecNormalize(normal), -depth);
-		const toolResult = extrude$1(positioned, extDir);
+		const toolResult = extrude$2(positioned, extDir);
 		if (isErr(toolResult)) return toolResult;
 		scope.register(toolResult.value);
 		return cut$2(s, toolResult.value, { unsafe: true });
 	} catch (_) {
-		_usingCtx$4.e = _;
+		_usingCtx$6.e = _;
 	} finally {
-		_usingCtx$4.d();
+		_usingCtx$6.d();
 	}
 }
 /**
@@ -3962,7 +3962,7 @@ function boss(shape, options) {
 		scope.register(faceResult.value);
 		const positioned = scope.register(translate$2(faceResult.value, center));
 		const extDir = vecScale(vecNormalize(normal), height);
-		const toolResult = extrude$1(positioned, extDir);
+		const toolResult = extrude$2(positioned, extDir);
 		if (isErr(toolResult)) return toolResult;
 		scope.register(toolResult.value);
 		return fuse$2(s, toolResult.value, { unsafe: true });
@@ -4524,12 +4524,12 @@ function makeInternalGearProfileWire(params) {
 }
 function makeProfileWire(params, isInternal) {
 	try {
-		var _usingCtx$3 = _usingCtx();
+		var _usingCtx$5 = _usingCtx();
 		const { teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, samples = adaptiveSampleCount(moduleSize) } = params;
 		if (teeth < 4) return err(validationError("GEAR_TEETH_TOO_FEW", `gear needs ≥ 4 teeth, got ${teeth}`));
 		if (moduleSize <= 0) return err(validationError("GEAR_MODULE_NONPOSITIVE", `module must be > 0, got ${moduleSize}`));
 		const tm = gearGeometry(teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, isInternal);
-		const scope = _usingCtx$3.u(new DisposalScope());
+		const scope = _usingCtx$5.u(new DisposalScope());
 		const allEdges = [];
 		for (let i = 0; i < teeth; i++) {
 			const periodEdges = buildToothPeriodEdges(tm, i, teeth, samples, scope);
@@ -4540,9 +4540,9 @@ function makeProfileWire(params, isInternal) {
 		if (isErr(wireResult)) return wireResult;
 		return ok(wireResult.value);
 	} catch (_) {
-		_usingCtx$3.e = _;
+		_usingCtx$5.e = _;
 	} finally {
-		_usingCtx$3.d();
+		_usingCtx$5.d();
 	}
 }
 //#endregion
@@ -4723,8 +4723,8 @@ function resolvePlanetaryParams(params) {
 }
 function makeOuterCircleWire(radius) {
 	try {
-		var _usingCtx$2 = _usingCtx();
-		const circleEdge = _usingCtx$2.u(new DisposalScope()).register(makeCircle(radius, [
+		var _usingCtx$4 = _usingCtx();
+		const circleEdge = _usingCtx$4.u(new DisposalScope()).register(makeCircle(radius, [
 			0,
 			0,
 			0
@@ -4737,9 +4737,9 @@ function makeOuterCircleWire(radius) {
 		if (isErr(wireResult)) return wireResult;
 		return ok(wireResult.value);
 	} catch (_) {
-		_usingCtx$2.e = _;
+		_usingCtx$4.e = _;
 	} finally {
-		_usingCtx$2.d();
+		_usingCtx$4.d();
 	}
 }
 function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
@@ -4750,7 +4750,7 @@ function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
 		const faceResult = makeFace(wire);
 		if (isErr(faceResult)) return faceResult;
 		profileScope.register(faceResult.value);
-		const solidResult = extrude$1(faceResult.value, [
+		const solidResult = extrude$2(faceResult.value, [
 			0,
 			0,
 			thickness
@@ -4762,7 +4762,7 @@ function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
 		const boreFaceResult = makeBoreFace(bore / 2);
 		if (isErr(boreFaceResult)) return boreFaceResult;
 		boreScope.register(boreFaceResult.value);
-		const boreRaw = extrude$1(boreFaceResult.value, [
+		const boreRaw = extrude$2(boreFaceResult.value, [
 			0,
 			0,
 			thickness + 1
@@ -4791,7 +4791,7 @@ function makeBoreFace(radius) {
 function finalizeInternalSolid(outerWire, innerToothedWire, thickness, geom, diagnostics) {
 	const faceResult = makeFace(outerWire, [innerToothedWire]);
 	if (isErr(faceResult)) return faceResult;
-	const solidResult = extrude$1(faceResult.value, [
+	const solidResult = extrude$2(faceResult.value, [
 		0,
 		0,
 		thickness
@@ -5336,6 +5336,14 @@ function evalVec3(expr, env, where) {
 		c
 	]);
 }
+function evalVec2(expr, env, where) {
+	const r = evalExpr(expr, env);
+	if (!r.ok) return r;
+	const v = expectVecLen(r.value, 2, where);
+	if (!v.ok) return v;
+	const [a, b] = v.value;
+	return ok([a, b]);
+}
 function projectEnv(env, deps) {
 	if (deps.size === 0) return Object.freeze({});
 	const out = {};
@@ -5346,6 +5354,91 @@ function projectEnv(env, deps) {
 	return Object.freeze(out);
 }
 //#endregion
+//#region src/csg/segments.ts
+/**
+* Serializable 2D segment vocabulary — endpoint-parametrized (SVG-style)
+* curve segments shared by the Path node (open spines) and, later, Profile
+* contours. Positions and radii are expressions, so `freeParams` propagates
+* and segment data hashes with the same FNV machinery as every node field.
+*/
+function lineTo(to) {
+	return {
+		kind: "Line",
+		to: asVec2Expr(to)
+	};
+}
+function arcTo(to, radius, options) {
+	return {
+		kind: "Arc",
+		to: asVec2Expr(to),
+		radius: asScalarExpr(radius),
+		largeArc: options?.largeArc ?? false,
+		clockwise: options?.clockwise ?? false
+	};
+}
+function bezierTo(controls, to) {
+	return {
+		kind: "Bezier",
+		controls: controls.map(asVec2Expr),
+		to: asVec2Expr(to)
+	};
+}
+function ellipseArcTo(to, radii, options) {
+	return {
+		kind: "EllipseArc",
+		to: asVec2Expr(to),
+		radii: asVec2Expr(radii),
+		rotation: asScalarExpr(options?.rotation ?? 0),
+		largeArc: options?.largeArc ?? false,
+		clockwise: options?.clockwise ?? false
+	};
+}
+function hashSegments(h0, segments) {
+	let h = fnvMixInt32(h0, segments.length);
+	const mix = (acc, e) => fnvMixHash(acc, e.structuralHash);
+	for (const s of segments) {
+		h = fnvMixString(h, s.kind);
+		h = mix(h, s.to);
+		if (s.kind === "Arc") {
+			h = mix(h, s.radius);
+			h = fnvMixBool(fnvMixBool(h, s.largeArc), s.clockwise);
+		} else if (s.kind === "Bezier") {
+			h = fnvMixInt32(h, s.controls.length);
+			for (const c of s.controls) h = mix(h, c);
+		} else if (s.kind === "EllipseArc") {
+			h = mix(h, s.radii);
+			h = mix(h, s.rotation);
+			h = fnvMixBool(fnvMixBool(h, s.largeArc), s.clockwise);
+		}
+	}
+	return h;
+}
+function segmentFreeParams(segments) {
+	const out = [];
+	for (const s of segments) {
+		out.push(s.to);
+		if (s.kind === "Arc") out.push(s.radius);
+		else if (s.kind === "Bezier") out.push(...s.controls);
+		else if (s.kind === "EllipseArc") out.push(s.radii, s.rotation);
+	}
+	return out;
+}
+function foldSegment(s, foldExpr) {
+	switch (s.kind) {
+		case "Line": return lineTo(foldExpr(s.to));
+		case "Arc": return arcTo(foldExpr(s.to), foldExpr(s.radius), {
+			largeArc: s.largeArc,
+			clockwise: s.clockwise
+		});
+		case "Bezier": return bezierTo(s.controls.map(foldExpr), foldExpr(s.to));
+		case "EllipseArc": return ellipseArcTo(foldExpr(s.to), foldExpr(s.radii), {
+			rotation: foldExpr(s.rotation),
+			largeArc: s.largeArc,
+			clockwise: s.clockwise
+		});
+	}
+}
+//#endregion
 //#region src/csg/builders.ts
 var EMPTY_DEPS = /* @__PURE__ */ new Set();
 function startHash(tag) {
@@ -5522,29 +5615,31 @@ function intersect$1(a, b, tolerance) {
 	};
 }
 function fuseAll$1(shapes, tolerance) {
-	let h = fnvMixInt32(startHash("FuseAll"), shapes.length);
-	for (const s of shapes) h = mix(h, s);
+	const copied = [...shapes];
+	let h = fnvMixInt32(startHash("FuseAll"), copied.length);
+	for (const s of copied) h = mix(h, s);
 	h = mixOptNumber(h, tolerance);
 	return {
 		kind: "FuseAll",
-		shapes,
+		shapes: copied,
 		tolerance,
 		structuralHash: h,
-		freeParams: depsOf(...shapes)
+		freeParams: depsOf(...copied)
 	};
 }
 function cutAll$1(base, tools, tolerance) {
+	const copied = [...tools];
 	let h = mix(startHash("CutAll"), base);
-	h = fnvMixInt32(h, tools.length);
-	for (const t of tools) h = mix(h, t);
+	h = fnvMixInt32(h, copied.length);
+	for (const t of copied) h = mix(h, t);
 	h = mixOptNumber(h, tolerance);
 	return {
 		kind: "CutAll",
 		base,
-		tools,
+		tools: copied,
 		tolerance,
 		structuralHash: h,
-		freeParams: depsOf(base, ...tools)
+		freeParams: depsOf(base, ...copied)
 	};
 }
 function optVec3$1(v) {
@@ -5606,14 +5701,76 @@ function mirror$1(target, options) {
 		freeParams: depsOf(target, nE, atE)
 	};
 }
+function extrude$1(profile, vector) {
+	const ve = asVec3Expr(vector);
+	return {
+		kind: "Extrude",
+		profile,
+		vector: ve,
+		structuralHash: mix(mix(startHash("Extrude"), profile), ve),
+		freeParams: depsOf(profile, ve)
+	};
+}
+/** Open (or incidentally closed) planar path in the XY plane at z = 0,
+*  producing a Wire. Segments come from `lineTo`/`arcTo`/`bezierTo`/
+*  `ellipseArcTo`. */
+function path(start, segments) {
+	const se = asVec2Expr(start);
+	const copied = [...segments];
+	let h = mix(startHash("Path"), se);
+	h = hashSegments(h, copied);
+	return {
+		kind: "Path",
+		start: se,
+		segments: copied,
+		structuralHash: h,
+		freeParams: depsOf(se, ...segmentFreeParams(copied))
+	};
+}
+/** Loft through two or more face-producing sections (default ruled). */
+function loft$1(sections, options) {
+	const copied = [...sections];
+	const ruled = options?.ruled ?? true;
+	let h = fnvMixInt32(startHash("Loft"), copied.length);
+	for (const s of copied) h = mix(h, s);
+	h = fnvMixBool(h, ruled);
+	return {
+		kind: "Loft",
+		sections: copied,
+		ruled,
+		structuralHash: h,
+		freeParams: depsOf(...copied)
+	};
+}
+/** Angle is in degrees (matching `rotate`); defaults to a full revolution
+*  around the Z axis at the origin. Evaluation clamps angles above 360 to one
+*  revolution (kernels diverge past 2*pi) and rejects non-positive angles. */
+function revolve$1(profile, angle = 360, options) {
+	const ae = asScalarExpr(angle);
+	const axisE = optVec3$1(options?.axis);
+	const atE = optVec3$1(options?.at);
+	let h = mix(mix(startHash("Revolve"), profile), ae);
+	h = mixOptExpr(h, axisE);
+	h = mixOptExpr(h, atE);
+	return {
+		kind: "Revolve",
+		profile,
+		angle: ae,
+		axis: axisE,
+		at: atE,
+		structuralHash: h,
+		freeParams: depsOf(profile, ae, axisE, atE)
+	};
+}
 function compound$1(children) {
-	let h = fnvMixInt32(startHash("Compound"), children.length);
-	for (const c of children) h = mix(h, c);
+	const copied = [...children];
+	let h = fnvMixInt32(startHash("Compound"), copied.length);
+	for (const c of copied) h = mix(h, c);
 	return {
 		kind: "Compound",
-		children,
+		children: copied,
 		structuralHash: h,
-		freeParams: depsOf(...children)
+		freeParams: depsOf(...copied)
 	};
 }
 function instance$1(source, placements, fuse = false) {
@@ -5652,6 +5809,10 @@ function outputKindOf(node) {
 		case "Rotate":
 		case "Scale":
 		case "Mirror": return outputKindOf(node.target);
+		case "Extrude":
+		case "Revolve":
+		case "Loft": return "Solid";
+		case "Path": return "Wire";
 		case "Compound": return "Compound";
 		case "Instance": return node.fuse ? "Solid" : "Compound";
 	}
@@ -5931,6 +6092,291 @@ function evalInstance(node, ctx) {
 	return materialize(instance(r.value, node.placements), { fuse: node.fuse });
 }
 //#endregion
+//#region src/csg/evaluators/profileFace.ts
+/** Evaluate a profile child and prove it is an oriented planar face — the
+*  input contract shared by every profile-consuming feature node. */
+function resolveProfileFace(ctx, profile, where) {
+	const p = ctx.evalNode(profile);
+	if (!p.ok) return p;
+	if (!isFace(p.value)) return err(typeCastError("CSG_NOT_FACE", `${where}: node did not produce a Face`));
+	const oriented = orientedFace(p.value);
+	if (!oriented.ok) return err(typeCastError("CSG_NOT_FACE", `${where}: ${oriented.error}`));
+	if (!isPlanarFace(oriented.value)) return err(typeCastError("CSG_NOT_FACE", `${where}: face is not planar`));
+	return ok(oriented.value);
+}
+//#endregion
+//#region src/csg/evaluators/extrude.ts
+function evalExtrude(node, ctx) {
+	const v = evalVec3(node.vector, ctx.env, "Extrude.vector");
+	if (!v.ok) return v;
+	const face = resolveProfileFace(ctx, node.profile, "Extrude.profile");
+	if (!face.ok) return face;
+	return extrude$2(face.value, v.value);
+}
+//#endregion
+//#region src/csg/evaluators/revolve.ts
+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}`));
+	const deg = Math.min(a.value, 360);
+	const axis = node.axis ? evalVec3(node.axis, ctx.env, "Revolve.axis") : ok([
+		0,
+		0,
+		1
+	]);
+	if (!axis.ok) return axis;
+	const at = node.at ? evalVec3(node.at, ctx.env, "Revolve.at") : ok([
+		0,
+		0,
+		0
+	]);
+	if (!at.ok) return at;
+	const face = resolveProfileFace(ctx, node.profile, "Revolve.profile");
+	if (!face.ok) return face;
+	return revolve$2(face.value, at.value, axis.value, deg * Math.PI / 180);
+}
+//#endregion
+//#region src/csg/evaluators/loft.ts
+function evalLoft(node, ctx) {
+	try {
+		var _usingCtx$3 = _usingCtx();
+		if (node.sections.length < 2) return err(validationError("CSG_LOFT_SECTIONS", `Loft requires at least 2 sections, got ${node.sections.length}`));
+		const scope = _usingCtx$3.u(new DisposalScope());
+		const wires = [];
+		for (const [i, section] of node.sections.entries()) {
+			const face = resolveProfileFace(ctx, section, `Loft.sections[${i}]`);
+			if (!face.ok) return face;
+			const w = outerWire(face.value);
+			scope.register(w);
+			wires.push(w);
+		}
+		return loft$2(wires, { ruled: node.ruled });
+	} catch (_) {
+		_usingCtx$3.e = _;
+	} finally {
+		_usingCtx$3.d();
+	}
+}
+//#endregion
+//#region src/csg/evaluators/path.ts
+var EPS = 1e-9;
+function v3(p) {
+	return [
+		p[0],
+		p[1],
+		0
+	];
+}
+function fail(msg) {
+	return err(validationError("CSG_PATH_SEGMENT", `Path: ${msg}`));
+}
+/** SVG-style endpoint circular arc: recover the on-arc midpoint so the edge
+*  can be built as a three-point arc. */
+function circularArcMidpoint(from, to, r, largeArc, clockwise) {
+	const [x1, y1] = from;
+	const [x2, y2] = to;
+	const dx = x2 - x1;
+	const dy = y2 - y1;
+	const d = Math.hypot(dx, dy);
+	if (d < EPS) return fail("Arc: coincident endpoints");
+	if (d > 2 * r + 1e-6) return fail(`Arc: radius ${r} too small for chord ${d}`);
+	const h = Math.sqrt(Math.max(0, r * r - d / 2 * (d / 2)));
+	const ux = dx / d;
+	const uy = dy / d;
+	const sign = clockwise === largeArc ? 1 : -1;
+	const cx = (x1 + x2) / 2 + sign * h * -uy;
+	const cy = (y1 + y2) / 2 + sign * h * ux;
+	const a0 = Math.atan2(y1 - cy, x1 - cx);
+	let a1 = Math.atan2(y2 - cy, x2 - cx);
+	if (clockwise) while (a1 >= a0 - EPS) a1 -= 2 * Math.PI;
+	else while (a1 <= a0 + EPS) a1 += 2 * Math.PI;
+	const amid = (a0 + a1) / 2;
+	return ok([cx + r * Math.cos(amid), cy + r * Math.sin(amid)]);
+}
+/** SVG F.6.5 endpoint-to-center conversion (math y-up; sweep = !clockwise).
+*  Angles are relative to the rotated x-axis. */
+function ellipseArcParams(from, to, radii, phi, largeArc, clockwise) {
+	const sweep = !clockwise;
+	let [rx, ry] = radii;
+	if (rx <= 0 || ry <= 0) return fail("EllipseArc: non-positive radius");
+	const cosPhi = Math.cos(phi);
+	const sinPhi = Math.sin(phi);
+	const hx = (from[0] - to[0]) / 2;
+	const hy = (from[1] - to[1]) / 2;
+	const x1p = cosPhi * hx + sinPhi * hy;
+	const y1p = -sinPhi * hx + cosPhi * hy;
+	const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+	if (lambda > 1) {
+		const s = Math.sqrt(lambda);
+		rx *= s;
+		ry *= s;
+	}
+	const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+	const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+	if (den < EPS) return fail("EllipseArc: coincident endpoints");
+	const coef = (largeArc !== sweep ? 1 : -1) * Math.sqrt(Math.max(0, num / den));
+	const cxp = coef * (rx * y1p / ry);
+	const cyp = coef * (-(ry * x1p) / rx);
+	const cx = cosPhi * cxp - sinPhi * cyp + (from[0] + to[0]) / 2;
+	const cy = sinPhi * cxp + cosPhi * cyp + (from[1] + to[1]) / 2;
+	const theta1 = Math.atan2((y1p - cyp) / ry, (x1p - cxp) / rx);
+	let dTheta = Math.atan2((-y1p - cyp) / ry, (-x1p - cxp) / rx) - theta1;
+	if (!sweep && dTheta > 0) dTheta -= 2 * Math.PI;
+	if (sweep && dTheta < 0) dTheta += 2 * Math.PI;
+	const t1 = dTheta >= 0 ? theta1 : theta1 + dTheta;
+	const t2 = dTheta >= 0 ? theta1 + dTheta : theta1;
+	return ok({
+		center: [cx, cy],
+		theta1: t1,
+		theta2: t2,
+		rx,
+		ry
+	});
+}
+function ellipseEdge(from, seg, ctx) {
+	if (seg.kind !== "EllipseArc") return fail("internal: not an ellipse segment");
+	const to = evalVec2(seg.to, ctx.env, "Path.EllipseArc.to");
+	if (!to.ok) return to;
+	const radii = evalVec2(seg.radii, ctx.env, "Path.EllipseArc.radii");
+	if (!radii.ok) return radii;
+	const rotDeg = evalScalar(seg.rotation, ctx.env, "Path.EllipseArc.rotation");
+	if (!rotDeg.ok) return rotDeg;
+	const phi = rotDeg.value * Math.PI / 180;
+	const p = ellipseArcParams(from, to.value, radii.value, phi, seg.largeArc, seg.clockwise);
+	if (!p.ok) return p;
+	const { center, theta1, theta2, rx, ry } = p.value;
+	let arc;
+	let psi;
+	if (rx >= ry) {
+		arc = makeEllipseArc(rx, ry, theta1, theta2, v3(center), [
+			0,
+			0,
+			1
+		]);
+		psi = phi;
+	} else {
+		arc = makeEllipseArc(ry, rx, theta1 - Math.PI / 2, theta2 - Math.PI / 2, v3(center), [
+			0,
+			0,
+			1
+		]);
+		psi = phi + Math.PI / 2;
+	}
+	if (!arc.ok) return arc;
+	let edge = arc.value;
+	if (Math.abs(psi) > EPS) try {
+		var _usingCtx$2 = _usingCtx();
+		const rotated = rotateEdgeAbout(_usingCtx$2.u(edge), psi * 180 / Math.PI, center);
+		if (!rotated.ok) return rotated;
+		edge = rotated.value;
+	} catch (_) {
+		_usingCtx$2.e = _;
+	} finally {
+		_usingCtx$2.d();
+	}
+	if (seg.clockwise) try {
+		var _usingCtx3 = _usingCtx();
+		const tmp = _usingCtx3.u(edge);
+		edge = flipOrientation(tmp);
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+	return ok(edge);
+}
+/** Rotate an edge about the Z axis at `center` (degrees) via a cheap location
+*  re-tag; returns a fresh, independently-disposable handle. Kernels without
+*  an edge-relocation path (brepkit) surface as a Result error, not a throw. */
+function rotateEdgeAbout(edge, angleDeg, center) {
+	const kernel = getKernel();
+	const { handle, dispose } = kernel.composeTransform([{
+		type: "rotate",
+		angle: angleDeg,
+		axis: [
+			0,
+			0,
+			1
+		],
+		center: [
+			center[0],
+			center[1],
+			0
+		]
+	}]);
+	try {
+		return ok(castShape(kernel.locate(edge.wrapped, handle)));
+	} catch (e) {
+		return err(kernelError("CSG_PATH_ELLIPSE_ROTATE", "Path: kernel cannot relocate ellipse-arc edges", e, { operation: "evalPath" }));
+	} finally {
+		dispose();
+	}
+}
+function segmentEnd(seg, ctx) {
+	return evalVec2(seg.to, ctx.env, `Path.${seg.kind}.to`);
+}
+function segmentToEdge(from, seg, ctx) {
+	switch (seg.kind) {
+		case "Line": {
+			const to = segmentEnd(seg, ctx);
+			if (!to.ok) return to;
+			if (Math.hypot(to.value[0] - from[0], to.value[1] - from[1]) < EPS) return fail("Line: zero length");
+			return ok(makeLine(v3(from), v3(to.value)));
+		}
+		case "Arc": {
+			const to = segmentEnd(seg, ctx);
+			if (!to.ok) return to;
+			const r = evalScalar(seg.radius, ctx.env, "Path.Arc.radius");
+			if (!r.ok) return r;
+			const mid = circularArcMidpoint(from, to.value, r.value, seg.largeArc, seg.clockwise);
+			if (!mid.ok) return mid;
+			return ok(makeThreePointArc(v3(from), v3(mid.value), v3(to.value)));
+		}
+		case "Bezier": {
+			const to = segmentEnd(seg, ctx);
+			if (!to.ok) return to;
+			const controls = [];
+			for (const c of seg.controls) {
+				const cv = evalVec2(c, ctx.env, "Path.Bezier.control");
+				if (!cv.ok) return cv;
+				controls.push(v3(cv.value));
+			}
+			return makeBezierCurve([
+				v3(from),
+				...controls,
+				v3(to.value)
+			]);
+		}
+		case "EllipseArc": return ellipseEdge(from, seg, ctx);
+	}
+}
+function evalPath(node, ctx) {
+	try {
+		var _usingCtx4 = _usingCtx();
+		if (node.segments.length === 0) return fail("at least one segment required");
+		const start = evalVec2(node.start, ctx.env, "Path.start");
+		if (!start.ok) return start;
+		const scope = _usingCtx4.u(new DisposalScope());
+		const edges = [];
+		let cur = start.value;
+		for (const seg of node.segments) {
+			const e = segmentToEdge(cur, seg, ctx);
+			if (!e.ok) return e;
+			scope.register(e.value);
+			edges.push(e.value);
+			const end = segmentEnd(seg, ctx);
+			if (!end.ok) return end;
+			cur = end.value;
+		}
+		return assembleWire(edges);
+	} catch (_) {
+		_usingCtx4.e = _;
+	} finally {
+		_usingCtx4.d();
+	}
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -5955,6 +6401,10 @@ function dispatch(node, ctx) {
 		case "Mirror": return evalMirror(node, ctx);
 		case "Compound": return evalCompound(node, ctx);
 		case "Instance": return evalInstance(node, ctx);
+		case "Extrude": return evalExtrude(node, ctx);
+		case "Revolve": return evalRevolve(node, ctx);
+		case "Loft": return evalLoft(node, ctx);
+		case "Path": return evalPath(node, ctx);
 	}
 }
 function hashExprValue(h, v) {
@@ -6491,6 +6941,34 @@ function booleanToJson(n) {
 function optExprToJson(e) {
 	return e ? exprToJson(e) : void 0;
 }
+function segmentToJson(s) {
+	switch (s.kind) {
+		case "Line": return {
+			kind: "Line",
+			to: exprToJson(s.to)
+		};
+		case "Arc": return {
+			kind: "Arc",
+			to: exprToJson(s.to),
+			radius: exprToJson(s.radius),
+			largeArc: s.largeArc,
+			clockwise: s.clockwise
+		};
+		case "Bezier": return {
+			kind: "Bezier",
+			controls: s.controls.map(exprToJson),
+			to: exprToJson(s.to)
+		};
+		case "EllipseArc": return {
+			kind: "EllipseArc",
+			to: exprToJson(s.to),
+			radii: exprToJson(s.radii),
+			rotation: exprToJson(s.rotation),
+			largeArc: s.largeArc,
+			clockwise: s.clockwise
+		};
+	}
+}
 function transformToJson(n) {
 	switch (n.kind) {
 		case "Translate": return {
@@ -6521,6 +6999,28 @@ function transformToJson(n) {
 	}
 }
 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 === "Compound") return {
 		kind: "Compound",
 		children: n.children.map(nodeToJson)
@@ -6672,6 +7172,10 @@ function readNode(j) {
 		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 "Path": return readPath(j);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -6826,6 +7330,100 @@ function readMirror(j, target) {
 		at: at.value
 	}));
 }
+function readExtrude(j) {
+	const profile = readNode(j["profile"]);
+	if (!profile.ok) return profile;
+	const vector = readExpr(j["vector"]);
+	if (!vector.ok) return vector;
+	return ok(extrude$1(profile.value, vector.value));
+}
+function readRevolve(j) {
+	const profile = readNode(j["profile"]);
+	if (!profile.ok) return profile;
+	const angle = readExpr(j["angle"]);
+	if (!angle.ok) return angle;
+	const axis = readOptExpr(j, "axis");
+	if (!axis.ok) return axis;
+	const at = readOptExpr(j, "at");
+	if (!at.ok) return at;
+	return ok(revolve$1(profile.value, angle.value, {
+		axis: axis.value,
+		at: at.value
+	}));
+}
+function readLoft(j) {
+	const sections = readNodeArray(j["sections"], "Loft.sections");
+	if (!sections.ok) return sections;
+	const ruled = j["ruled"];
+	if (ruled !== void 0 && typeof ruled !== "boolean") return bad("Loft.ruled: not a boolean");
+	return ok(loft$1(sections.value, { ruled }));
+}
+function readFlag(j, key) {
+	const v = j[key];
+	if (v === void 0) return ok(false);
+	return typeof v === "boolean" ? ok(v) : bad(`${key}: not a boolean`);
+}
+function readSegment(j) {
+	if (!isObj(j)) return bad("segment: not an object");
+	const to = readExpr(j["to"]);
+	if (!to.ok) return to;
+	const kind = j["kind"];
+	switch (kind) {
+		case "Line": return ok(lineTo(to.value));
+		case "Arc": {
+			const radius = readExpr(j["radius"]);
+			if (!radius.ok) return radius;
+			const largeArc = readFlag(j, "largeArc");
+			if (!largeArc.ok) return largeArc;
+			const clockwise = readFlag(j, "clockwise");
+			if (!clockwise.ok) return clockwise;
+			return ok(arcTo(to.value, radius.value, {
+				largeArc: largeArc.value,
+				clockwise: clockwise.value
+			}));
+		}
+		case "Bezier": {
+			const raw = j["controls"];
+			if (!Array.isArray(raw)) return bad("Bezier.controls: not array");
+			const controls = [];
+			for (const c of raw) {
+				const r = readExpr(c);
+				if (!r.ok) return r;
+				controls.push(r.value);
+			}
+			return ok(bezierTo(controls, to.value));
+		}
+		case "EllipseArc": {
+			const radii = readExpr(j["radii"]);
+			if (!radii.ok) return radii;
+			const rotation = readExpr(j["rotation"]);
+			if (!rotation.ok) return rotation;
+			const largeArc = readFlag(j, "largeArc");
+			if (!largeArc.ok) return largeArc;
+			const clockwise = readFlag(j, "clockwise");
+			if (!clockwise.ok) return clockwise;
+			return ok(ellipseArcTo(to.value, radii.value, {
+				rotation: rotation.value,
+				largeArc: largeArc.value,
+				clockwise: clockwise.value
+			}));
+		}
+		default: return bad(`unknown segment kind: ${String(kind)}`);
+	}
+}
+function readPath(j) {
+	const start = readExpr(j["start"]);
+	if (!start.ok) return start;
+	const raw = j["segments"];
+	if (!Array.isArray(raw)) return bad("Path.segments: not array");
+	const segments = [];
+	for (const s of raw) {
+		const r = readSegment(s);
+		if (!r.ok) return r;
+		segments.push(r.value);
+	}
+	return ok(path(start.value, segments));
+}
 function readCompound(j) {
 	const children = readNodeArray(j["children"], "Compound.children");
 	return children.ok ? ok(compound$1(children.value)) : children;
@@ -6937,6 +7535,21 @@ function optimizeNode(n) {
 		});
 		case "Compound": return compound$1(n.children.map(optimizeNode).filter((c) => c.kind !== "Empty"));
 		case "Instance": return instance$1(optimizeNode(n.source), n.placements, n.fuse);
+		case "Extrude":
+		case "Revolve":
+		case "Loft":
+		case "Path": return optimizeFeature(n);
+	}
+}
+function optimizeFeature(n) {
+	switch (n.kind) {
+		case "Extrude": return extrude$1(optimizeNode(n.profile), foldExpr(n.vector));
+		case "Revolve": return revolve$1(optimizeNode(n.profile), foldExpr(n.angle), {
+			axis: n.axis ? foldExpr(n.axis) : void 0,
+			at: n.at ? foldExpr(n.at) : void 0
+		});
+		case "Loft": return loft$1(n.sections.map(optimizeNode), { ruled: n.ruled });
+		case "Path": return path(foldExpr(n.start), n.segments.map((s) => foldSegment(s, foldExpr)));
 	}
 }
 function optimizeFuse(a, b, tol) {
@@ -7009,7 +7622,8 @@ function rebuildChildren(n, pred, repl) {
 		case "Circle":
 		case "Line":
 		case "Vertex":
-		case "Empty": return n;
+		case "Empty":
+		case "Path": 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);
@@ -7027,6 +7641,12 @@ function rebuildChildren(n, pred, repl) {
 		});
 		case "Compound": return compound$1(n.children.map((c) => walk(c, pred, repl)));
 		case "Instance": return instance$1(walk(n.source, pred, repl), n.placements, n.fuse);
+		case "Extrude": return extrude$1(walk(n.profile, pred, repl), n.vector);
+		case "Revolve": return revolve$1(walk(n.profile, pred, repl), n.angle, {
+			axis: n.axis,
+			at: n.at
+		});
+		case "Loft": return loft$1(n.sections.map((s) => walk(s, pred, repl)), { ruled: n.ruled });
 	}
 }
 function forEachNode(root, fn) {
@@ -7044,7 +7664,8 @@ function childrenOf(n) {
 		case "Circle":
 		case "Line":
 		case "Vertex":
-		case "Empty": return [];
+		case "Empty":
+		case "Path": return [];
 		case "Fuse":
 		case "Cut":
 		case "Intersect": return [n.a, n.b];
@@ -7056,6 +7677,9 @@ function childrenOf(n) {
 		case "Mirror": 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;
 	}
 }
 function nodeCount(root) {
@@ -7071,9 +7695,11 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	CSG_VERSION: () => 1,
 	Evaluator: () => Evaluator,
 	add: () => add,
+	arcTo: () => arcTo,
 	asScalarExpr: () => asScalarExpr,
 	asVec2Expr: () => asVec2Expr,
 	asVec3Expr: () => asVec3Expr,
+	bezierTo: () => bezierTo,
 	binOp: () => binOp,
 	box: () => box$2,
 	buildVec: () => buildVec,
@@ -7084,9 +7710,11 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	cut: () => cut$1,
 	cutAll: () => cutAll$1,
 	cylinder: () => cylinder$2,
+	ellipseArcTo: () => ellipseArcTo,
 	emptyFace: () => emptyFace,
 	emptySolid: () => emptySolid,
 	emptyWire: () => emptyWire,
+	extrude: () => extrude$1,
 	foldExpr: () => foldExpr,
 	forEachNode: () => forEachNode,
 	fromJSON: () => fromJSON,
@@ -7095,6 +7723,8 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	instance: () => instance$1,
 	intersect: () => intersect$1,
 	line: () => line$1,
+	lineTo: () => lineTo,
+	loft: () => loft$1,
 	mirror: () => mirror$1,
 	mul: () => mul,
 	nodeCount: () => nodeCount,
@@ -7102,8 +7732,10 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	optimize: () => optimize,
 	outputKindOf: () => outputKindOf,
 	param: () => param,
+	path: () => path,
 	polygon: () => polygon$1,
 	replaceNode: () => replaceNode,
+	revolve: () => revolve$1,
 	rotate: () => rotate$1,
 	scale: () => scale$1,
 	sphere: () => sphere$2,