brepjs 18.124.8 → 18.126.0

package/dist/brepjs.cjs

@@ -254,8 +254,8 @@ function repairMesh(mesh, opts, id) {
 	if (require_errors.isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$8 = require_shapeTypes._usingCtx();
-			const repaired = _usingCtx$8.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
+			var _usingCtx$10 = require_shapeTypes._usingCtx();
+			const repaired = _usingCtx$10.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
 			const vertexCount = repaired.positions.length / 3;
 			return require_errors.ok({
 				vertices: repaired.positions,
@@ -269,9 +269,9 @@ function repairMesh(mesh, opts, id) {
 				}]
 			});
 		} catch (_) {
-			_usingCtx$8.e = _;
+			_usingCtx$10.e = _;
 		} finally {
-			_usingCtx$8.d();
+			_usingCtx$10.d();
 		}
 	} catch (cause) {
 		return require_errors.err(require_errors.computationError("VOXEL_REPAIR_FAILED", cause instanceof Error ? cause.message : "voxel repair failed (grid too large?).", cause));
@@ -350,12 +350,12 @@ function offsetMesh(mesh, distance, opts, id) {
 	if (require_errors.isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$7 = require_shapeTypes._usingCtx();
-			return meshFromResult(_usingCtx$7.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
+			var _usingCtx$9 = require_shapeTypes._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 require_errors.err(require_errors.computationError("VOXEL_OFFSET_FAILED", cause instanceof Error ? cause.message : "voxel offset failed (grid too large?).", cause));
@@ -480,9 +480,9 @@ function resolveGridParams$1(opts) {
 */
 function meshFromField(field) {
 	try {
-		var _usingCtx$6 = require_shapeTypes._usingCtx();
+		var _usingCtx$8 = require_shapeTypes._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();
@@ -502,9 +502,9 @@ function meshFromField(field) {
 			}]
 		});
 	} catch (_) {
-		_usingCtx$6.e = _;
+		_usingCtx$8.e = _;
 	} finally {
-		_usingCtx$6.d();
+		_usingCtx$8.d();
 	}
 }
 function fieldDeletable(raw) {
@@ -1072,13 +1072,13 @@ function latticeInfill(mesh, opts, id) {
 	const { tag, period, thickness, resolution, padding } = resolved.value;
 	try {
 		try {
-			var _usingCtx$5 = require_shapeTypes._usingCtx();
-			const repaired = _usingCtx$5.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness));
+			var _usingCtx$7 = require_shapeTypes._usingCtx();
+			const repaired = _usingCtx$7.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness));
 			return require_errors.ok(toMesh(repaired));
 		} catch (_) {
-			_usingCtx$5.e = _;
+			_usingCtx$7.e = _;
 		} finally {
-			_usingCtx$5.d();
+			_usingCtx$7.d();
 		}
 	} catch (cause) {
 		return require_errors.err(require_errors.computationError("LATTICE_INFILL_FAILED", cause instanceof Error ? cause.message : "lattice infill failed (grid too large?).", cause));
@@ -1557,7 +1557,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;
 }
@@ -1595,7 +1595,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
 	};
@@ -1606,14 +1606,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
@@ -1675,14 +1675,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;
 	}
@@ -1693,16 +1693,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;
@@ -1712,7 +1712,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;
@@ -1722,7 +1722,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({
@@ -1739,7 +1739,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({
@@ -1795,7 +1795,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;
@@ -1934,7 +1934,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
@@ -3901,7 +3901,7 @@ function drill(shape, options) {
 */
 function pocket(shape, options) {
 	try {
-		var _usingCtx$4 = require_shapeTypes._usingCtx();
+		var _usingCtx$6 = require_shapeTypes._usingCtx();
 		const s = resolve(shape);
 		const { profile, depth } = options;
 		if (depth <= 0) return require_errors.err(require_errors.validationError("POCKET_INVALID_DEPTH", "Pocket depth must be positive"));
@@ -3910,7 +3910,7 @@ function pocket(shape, options) {
 		const targetFace = targetResult.value;
 		const normal = require_faceFns.normalAt(targetFace);
 		const center = require_faceFns.faceCenter(targetFace);
-		const scope = _usingCtx$4.u(new require_shapeTypes.DisposalScope());
+		const scope = _usingCtx$6.u(new require_shapeTypes.DisposalScope());
 		const { wire: w, owned } = toWire(profile);
 		if (owned) scope.register(w);
 		const faceResult = require_surfaceBuilders.makeFace(w);
@@ -3923,9 +3923,9 @@ function pocket(shape, options) {
 		scope.register(toolResult.value);
 		return require_solidBuilders.cut(s, toolResult.value, { unsafe: true });
 	} catch (_) {
-		_usingCtx$4.e = _;
+		_usingCtx$6.e = _;
 	} finally {
-		_usingCtx$4.d();
+		_usingCtx$6.d();
 	}
 }
 /**
@@ -4515,12 +4515,12 @@ function makeInternalGearProfileWire(params) {
 }
 function makeProfileWire(params, isInternal) {
 	try {
-		var _usingCtx$3 = require_shapeTypes._usingCtx();
+		var _usingCtx$5 = require_shapeTypes._usingCtx();
 		const { teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, samples = adaptiveSampleCount(moduleSize) } = params;
 		if (teeth < 4) return require_errors.err(require_errors.validationError("GEAR_TEETH_TOO_FEW", `gear needs ≥ 4 teeth, got ${teeth}`));
 		if (moduleSize <= 0) return require_errors.err(require_errors.validationError("GEAR_MODULE_NONPOSITIVE", `module must be > 0, got ${moduleSize}`));
 		const tm = gearGeometry(teeth, moduleSize, pressureAngle, shift, clearance, flankThinning, isInternal);
-		const scope = _usingCtx$3.u(new require_shapeTypes.DisposalScope());
+		const scope = _usingCtx$5.u(new require_shapeTypes.DisposalScope());
 		const allEdges = [];
 		for (let i = 0; i < teeth; i++) {
 			const periodEdges = buildToothPeriodEdges(tm, i, teeth, samples, scope);
@@ -4531,9 +4531,9 @@ function makeProfileWire(params, isInternal) {
 		if (require_errors.isErr(wireResult)) return wireResult;
 		return require_errors.ok(wireResult.value);
 	} catch (_) {
-		_usingCtx$3.e = _;
+		_usingCtx$5.e = _;
 	} finally {
-		_usingCtx$3.d();
+		_usingCtx$5.d();
 	}
 }
 //#endregion
@@ -4714,8 +4714,8 @@ function resolvePlanetaryParams(params) {
 }
 function makeOuterCircleWire(radius) {
 	try {
-		var _usingCtx$2 = require_shapeTypes._usingCtx();
-		const circleEdge = _usingCtx$2.u(new require_shapeTypes.DisposalScope()).register(require_surfaceBuilders.makeCircle(radius, [
+		var _usingCtx$4 = require_shapeTypes._usingCtx();
+		const circleEdge = _usingCtx$4.u(new require_shapeTypes.DisposalScope()).register(require_surfaceBuilders.makeCircle(radius, [
 			0,
 			0,
 			0
@@ -4728,9 +4728,9 @@ function makeOuterCircleWire(radius) {
 		if (require_errors.isErr(wireResult)) return wireResult;
 		return require_errors.ok(wireResult.value);
 	} catch (_) {
-		_usingCtx$2.e = _;
+		_usingCtx$4.e = _;
 	} finally {
-		_usingCtx$2.d();
+		_usingCtx$4.d();
 	}
 }
 function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
@@ -5327,6 +5327,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 require_errors.ok([a, b]);
+}
 function projectEnv(env, deps) {
 	if (deps.size === 0) return Object.freeze({});
 	const out = {};
@@ -5337,6 +5345,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) {
@@ -5513,29 +5606,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) {
@@ -5597,14 +5692,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) {
@@ -5643,6 +5800,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";
 	}
@@ -5922,6 +6083,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 (!require_shapeTypes.isFace(p.value)) return require_errors.err(require_errors.typeCastError("CSG_NOT_FACE", `${where}: node did not produce a Face`));
+	const oriented = require_validityTypes.orientedFace(p.value);
+	if (!oriented.ok) return require_errors.err(require_errors.typeCastError("CSG_NOT_FACE", `${where}: ${oriented.error}`));
+	if (!require_validityTypes.isPlanarFace(oriented.value)) return require_errors.err(require_errors.typeCastError("CSG_NOT_FACE", `${where}: face is not planar`));
+	return require_errors.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 require_textBlueprints.extrude(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 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,
+		0,
+		1
+	]);
+	if (!axis.ok) return axis;
+	const at = node.at ? evalVec3(node.at, ctx.env, "Revolve.at") : require_errors.ok([
+		0,
+		0,
+		0
+	]);
+	if (!at.ok) return at;
+	const face = resolveProfileFace(ctx, node.profile, "Revolve.profile");
+	if (!face.ok) return face;
+	return require_textBlueprints.revolve(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 = require_shapeTypes._usingCtx();
+		if (node.sections.length < 2) return require_errors.err(require_errors.validationError("CSG_LOFT_SECTIONS", `Loft requires at least 2 sections, got ${node.sections.length}`));
+		const scope = _usingCtx$3.u(new require_shapeTypes.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 = require_faceFns.outerWire(face.value);
+			scope.register(w);
+			wires.push(w);
+		}
+		return require_loftFns.loft(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 require_errors.err(require_errors.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 require_errors.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 require_errors.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 = require_surfaceBuilders.makeEllipseArc(rx, ry, theta1, theta2, v3(center), [
+			0,
+			0,
+			1
+		]);
+		psi = phi;
+	} else {
+		arc = require_surfaceBuilders.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 = require_shapeTypes._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 = require_shapeTypes._usingCtx();
+		const tmp = _usingCtx3.u(edge);
+		edge = require_curveFns.flipOrientation(tmp);
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+	return require_errors.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 = require_shapeTypes.getKernel();
+	const { handle, dispose } = kernel.composeTransform([{
+		type: "rotate",
+		angle: angleDeg,
+		axis: [
+			0,
+			0,
+			1
+		],
+		center: [
+			center[0],
+			center[1],
+			0
+		]
+	}]);
+	try {
+		return require_errors.ok(require_shapeTypes.castShape(kernel.locate(edge.wrapped, handle)));
+	} catch (e) {
+		return require_errors.err(require_errors.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 require_errors.ok(require_surfaceBuilders.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 require_errors.ok(require_surfaceBuilders.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 require_surfaceBuilders.makeBezierCurve([
+				v3(from),
+				...controls,
+				v3(to.value)
+			]);
+		}
+		case "EllipseArc": return ellipseEdge(from, seg, ctx);
+	}
+}
+function evalPath(node, ctx) {
+	try {
+		var _usingCtx4 = require_shapeTypes._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 require_shapeTypes.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 require_surfaceBuilders.assembleWire(edges);
+	} catch (_) {
+		_usingCtx4.e = _;
+	} finally {
+		_usingCtx4.d();
+	}
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -5946,6 +6392,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) {
@@ -6482,6 +6932,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 {
@@ -6512,6 +6990,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)
@@ -6663,6 +7163,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)}`);
 	}
 }
@@ -6817,6 +7321,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 require_errors.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 require_errors.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 require_errors.ok(loft$1(sections.value, { ruled }));
+}
+function readFlag(j, key) {
+	const v = j[key];
+	if (v === void 0) return require_errors.ok(false);
+	return typeof v === "boolean" ? require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.ok(path(start.value, segments));
+}
 function readCompound(j) {
 	const children = readNodeArray(j["children"], "Compound.children");
 	return children.ok ? require_errors.ok(compound$1(children.value)) : children;
@@ -6928,6 +7526,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) {
@@ -7000,7 +7613,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);
@@ -7018,6 +7632,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) {
@@ -7035,7 +7655,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];
@@ -7047,6 +7668,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) {
@@ -7062,9 +7686,11 @@ var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__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,
@@ -7075,9 +7701,11 @@ var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__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,
@@ -7086,6 +7714,8 @@ var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	instance: () => instance$1,
 	intersect: () => intersect$1,
 	line: () => line$1,
+	lineTo: () => lineTo,
+	loft: () => loft$1,
 	mirror: () => mirror$1,
 	mul: () => mul,
 	nodeCount: () => nodeCount,
@@ -7093,8 +7723,10 @@ var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__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,