brepjs 18.126.0 → 18.127.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$10 = require_shapeTypes._usingCtx();
-			const repaired = _usingCtx$10.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
+			var _usingCtx$11 = require_shapeTypes._usingCtx();
+			const repaired = _usingCtx$11.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$10.e = _;
+			_usingCtx$11.e = _;
 		} finally {
-			_usingCtx$10.d();
+			_usingCtx$11.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$9 = require_shapeTypes._usingCtx();
-			return meshFromResult(_usingCtx$9.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
+			var _usingCtx$10 = require_shapeTypes._usingCtx();
+			return meshFromResult(_usingCtx$10.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
 		} catch (_) {
-			_usingCtx$9.e = _;
+			_usingCtx$10.e = _;
 		} finally {
-			_usingCtx$9.d();
+			_usingCtx$10.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$8 = require_shapeTypes._usingCtx();
+		var _usingCtx$9 = require_shapeTypes._usingCtx();
 		const rawResult = field.contour();
-		const { positions, normals, indices } = _usingCtx$8.u({
+		const { positions, normals, indices } = _usingCtx$9.u({
 			value: rawResult,
 			[Symbol.dispose]() {
 				rawResult.free();
@@ -502,9 +502,9 @@ function meshFromField(field) {
 			}]
 		});
 	} catch (_) {
-		_usingCtx$8.e = _;
+		_usingCtx$9.e = _;
 	} finally {
-		_usingCtx$8.d();
+		_usingCtx$9.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$7 = require_shapeTypes._usingCtx();
-			const repaired = _usingCtx$7.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness));
+			var _usingCtx$8 = require_shapeTypes._usingCtx();
+			const repaired = _usingCtx$8.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness));
 			return require_errors.ok(toMesh(repaired));
 		} catch (_) {
-			_usingCtx$7.e = _;
+			_usingCtx$8.e = _;
 		} finally {
-			_usingCtx$7.d();
+			_usingCtx$8.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));
@@ -3901,7 +3901,7 @@ function drill(shape, options) {
 */
 function pocket(shape, options) {
 	try {
-		var _usingCtx$6 = require_shapeTypes._usingCtx();
+		var _usingCtx$7 = 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$6.u(new require_shapeTypes.DisposalScope());
+		const scope = _usingCtx$7.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$6.e = _;
+		_usingCtx$7.e = _;
 	} finally {
-		_usingCtx$6.d();
+		_usingCtx$7.d();
 	}
 }
 /**
@@ -4515,12 +4515,12 @@ function makeInternalGearProfileWire(params) {
 }
 function makeProfileWire(params, isInternal) {
 	try {
-		var _usingCtx$5 = require_shapeTypes._usingCtx();
+		var _usingCtx$6 = 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$5.u(new require_shapeTypes.DisposalScope());
+		const scope = _usingCtx$6.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$5.e = _;
+		_usingCtx$6.e = _;
 	} finally {
-		_usingCtx$5.d();
+		_usingCtx$6.d();
 	}
 }
 //#endregion
@@ -4714,8 +4714,8 @@ function resolvePlanetaryParams(params) {
 }
 function makeOuterCircleWire(radius) {
 	try {
-		var _usingCtx$4 = require_shapeTypes._usingCtx();
-		const circleEdge = _usingCtx$4.u(new require_shapeTypes.DisposalScope()).register(require_surfaceBuilders.makeCircle(radius, [
+		var _usingCtx$5 = require_shapeTypes._usingCtx();
+		const circleEdge = _usingCtx$5.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$4.e = _;
+		_usingCtx$5.e = _;
 	} finally {
-		_usingCtx$4.d();
+		_usingCtx$5.d();
 	}
 }
 function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
@@ -5702,6 +5702,22 @@ function extrude$1(profile, vector) {
 		freeParams: depsOf(profile, ve)
 	};
 }
+/** Sweep a face-producing profile along a Wire/Edge-producing spine.
+*  `frenet` is canonicalized (default false) so the default and explicit
+*  forms share one content address. */
+function sweep$2(profile, spine, options) {
+	const frenet = options?.frenet ?? false;
+	let h = mix(mix(startHash("Sweep"), profile), spine);
+	h = fnvMixBool(h, frenet);
+	return {
+		kind: "Sweep",
+		profile,
+		spine,
+		frenet,
+		structuralHash: h,
+		freeParams: depsOf(profile, spine)
+	};
+}
 /** Open (or incidentally closed) planar path in the XY plane at z = 0,
 *  producing a Wire. Segments come from `lineTo`/`arcTo`/`bezierTo`/
 *  `ellipseArcTo`. */
@@ -5802,7 +5818,8 @@ function outputKindOf(node) {
 		case "Mirror": return outputKindOf(node.target);
 		case "Extrude":
 		case "Revolve":
-		case "Loft": return "Solid";
+		case "Loft":
+		case "Sweep": return "Solid";
 		case "Path": return "Wire";
 		case "Compound": return "Compound";
 		case "Instance": return node.fuse ? "Solid" : "Compound";
@@ -6131,9 +6148,9 @@ function evalRevolve(node, ctx) {
 //#region src/csg/evaluators/loft.ts
 function evalLoft(node, ctx) {
 	try {
-		var _usingCtx$3 = require_shapeTypes._usingCtx();
+		var _usingCtx$4 = 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 scope = _usingCtx$4.u(new require_shapeTypes.DisposalScope());
 		const wires = [];
 		for (const [i, section] of node.sections.entries()) {
 			const face = resolveProfileFace(ctx, section, `Loft.sections[${i}]`);
@@ -6144,9 +6161,9 @@ function evalLoft(node, ctx) {
 		}
 		return require_loftFns.loft(wires, { ruled: node.ruled });
 	} catch (_) {
-		_usingCtx$3.e = _;
+		_usingCtx$4.e = _;
 	} finally {
-		_usingCtx$3.d();
+		_usingCtx$4.d();
 	}
 }
 //#endregion
@@ -6257,14 +6274,14 @@ function ellipseEdge(from, seg, ctx) {
 	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);
+		var _usingCtx$3 = require_shapeTypes._usingCtx();
+		const rotated = rotateEdgeAbout(_usingCtx$3.u(edge), psi * 180 / Math.PI, center);
 		if (!rotated.ok) return rotated;
 		edge = rotated.value;
 	} catch (_) {
-		_usingCtx$2.e = _;
+		_usingCtx$3.e = _;
 	} finally {
-		_usingCtx$2.d();
+		_usingCtx$3.d();
 	}
 	if (seg.clockwise) try {
 		var _usingCtx3 = require_shapeTypes._usingCtx();
@@ -6368,6 +6385,39 @@ function evalPath(node, ctx) {
 	}
 }
 //#endregion
+//#region src/csg/evaluators/sweep.ts
+function evalSweep(node, ctx) {
+	try {
+		var _usingCtx$2 = require_shapeTypes._usingCtx();
+		const face = resolveProfileFace(ctx, node.profile, "Sweep.profile");
+		if (!face.ok) return face;
+		const spineShape = ctx.evalNode(node.spine);
+		if (!spineShape.ok) return spineShape;
+		const scope = _usingCtx$2.u(new require_shapeTypes.DisposalScope());
+		let spine;
+		if (require_shapeTypes.isWire(spineShape.value)) spine = spineShape.value;
+		else if (require_shapeTypes.isEdge(spineShape.value)) {
+			const wrapped = require_surfaceBuilders.assembleWire([spineShape.value]);
+			if (!wrapped.ok) return wrapped;
+			scope.register(wrapped.value);
+			spine = wrapped.value;
+		} else return require_errors.err(require_errors.typeCastError("CSG_SWEEP_SPINE", "Sweep.spine: node did not produce a Wire or Edge"));
+		const profileWire = require_faceFns.outerWire(face.value);
+		scope.register(profileWire);
+		const r = require_loftFns.sweep(profileWire, spine, { frenet: node.frenet });
+		if (!r.ok) return r;
+		if (Array.isArray(r.value)) {
+			for (const s of r.value) s[Symbol.dispose]();
+			return require_errors.err(require_errors.typeCastError("CSG_SWEEP_SPINE", "Sweep: unexpected shell-mode result"));
+		}
+		return require_errors.ok(r.value);
+	} catch (_) {
+		_usingCtx$2.e = _;
+	} finally {
+		_usingCtx$2.d();
+	}
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -6396,6 +6446,7 @@ function dispatch(node, ctx) {
 		case "Revolve": return evalRevolve(node, ctx);
 		case "Loft": return evalLoft(node, ctx);
 		case "Path": return evalPath(node, ctx);
+		case "Sweep": return evalSweep(node, ctx);
 	}
 }
 function hashExprValue(h, v) {
@@ -6802,9 +6853,10 @@ function withEvaluator(options, fn) {
 		_usingCtx$1.d();
 	}
 }
+var MIN_CSG_VERSION = 1;
 function toJSON(node) {
 	return {
-		csgVersion: 1,
+		csgVersion: 2,
 		root: nodeToJson(node)
 	};
 }
@@ -7012,6 +7064,12 @@ function nodeToJson(n) {
 		start: exprToJson(n.start),
 		segments: n.segments.map(segmentToJson)
 	};
+	if (n.kind === "Sweep") return {
+		kind: "Sweep",
+		profile: nodeToJson(n.profile),
+		spine: nodeToJson(n.spine),
+		frenet: n.frenet
+	};
 	if (n.kind === "Compound") return {
 		kind: "Compound",
 		children: n.children.map(nodeToJson)
@@ -7055,7 +7113,7 @@ function readVec2(v, where) {
 function fromJSON(envelope) {
 	if (!isObj(envelope)) return bad("input is not an object");
 	const v = envelope["csgVersion"];
-	if (v !== 1) return bad(`unsupported csgVersion ${String(v)} (expected 1)`);
+	if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_CSG_VERSION || v > 2) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..2)`);
 	const root = envelope["root"];
 	return readNode(root);
 }
@@ -7167,6 +7225,7 @@ function readNode(j) {
 		case "Revolve": return readRevolve(j);
 		case "Loft": return readLoft(j);
 		case "Path": return readPath(j);
+		case "Sweep": return readSweep(j);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -7402,6 +7461,15 @@ function readSegment(j) {
 		default: return bad(`unknown segment kind: ${String(kind)}`);
 	}
 }
+function readSweep(j) {
+	const profile = readNode(j["profile"]);
+	if (!profile.ok) return profile;
+	const spine = readNode(j["spine"]);
+	if (!spine.ok) return spine;
+	const frenet = readFlag(j, "frenet");
+	if (!frenet.ok) return frenet;
+	return require_errors.ok(sweep$2(profile.value, spine.value, { frenet: frenet.value }));
+}
 function readPath(j) {
 	const start = readExpr(j["start"]);
 	if (!start.ok) return start;
@@ -7529,6 +7597,7 @@ function optimizeNode(n) {
 		case "Extrude":
 		case "Revolve":
 		case "Loft":
+		case "Sweep":
 		case "Path": return optimizeFeature(n);
 	}
 }
@@ -7540,6 +7609,7 @@ function optimizeFeature(n) {
 			at: n.at ? foldExpr(n.at) : void 0
 		});
 		case "Loft": return loft$1(n.sections.map(optimizeNode), { ruled: n.ruled });
+		case "Sweep": return sweep$2(optimizeNode(n.profile), optimizeNode(n.spine), { frenet: n.frenet });
 		case "Path": return path(foldExpr(n.start), n.segments.map((s) => foldSegment(s, foldExpr)));
 	}
 }
@@ -7638,6 +7708,7 @@ function rebuildChildren(n, pred, repl) {
 			at: n.at
 		});
 		case "Loft": return loft$1(n.sections.map((s) => walk(s, pred, repl)), { ruled: n.ruled });
+		case "Sweep": return sweep$2(walk(n.profile, pred, repl), walk(n.spine, pred, repl), { frenet: n.frenet });
 	}
 }
 function forEachNode(root, fn) {
@@ -7671,6 +7742,7 @@ function childrenOf(n) {
 		case "Extrude":
 		case "Revolve": return [n.profile];
 		case "Loft": return n.sections;
+		case "Sweep": return [n.profile, n.spine];
 	}
 }
 function nodeCount(root) {
@@ -7683,7 +7755,7 @@ function nodeCount(root) {
 //#endregion
 //#region src/ns/csg.ts
 var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
-	CSG_VERSION: () => 1,
+	CSG_VERSION: () => 2,
 	Evaluator: () => Evaluator,
 	add: () => add,
 	arcTo: () => arcTo,
@@ -7730,6 +7802,7 @@ var csg_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	rotate: () => rotate$1,
 	scale: () => scale$1,
 	sphere: () => sphere$2,
+	sweep: () => sweep$2,
 	toJSON: () => toJSON,
 	torus: () => torus$2,
 	translate: () => translate$1,

package/dist/brepjs.js

@@ -264,8 +264,8 @@ function repairMesh(mesh, opts, id) {
 	if (isErr(engine)) return engine;
 	try {
 		try {
-			var _usingCtx$10 = _usingCtx();
-			const repaired = _usingCtx$10.u(engine.value.repair_mesh(mesh.vertices, mesh.triangles, resolution, padding));
+			var _usingCtx$11 = _usingCtx();
+			const repaired = _usingCtx$11.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$10.e = _;
+			_usingCtx$11.e = _;
 		} finally {
-			_usingCtx$10.d();
+			_usingCtx$11.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$9 = _usingCtx();
-			return meshFromResult(_usingCtx$9.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
+			var _usingCtx$10 = _usingCtx();
+			return meshFromResult(_usingCtx$10.u(engine.value.offset_mesh(mesh.vertices, mesh.triangles, distance, params.value.resolution, params.value.padding)));
 		} catch (_) {
-			_usingCtx$9.e = _;
+			_usingCtx$10.e = _;
 		} finally {
-			_usingCtx$9.d();
+			_usingCtx$10.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$8 = _usingCtx();
+		var _usingCtx$9 = _usingCtx();
 		const rawResult = field.contour();
-		const { positions, normals, indices } = _usingCtx$8.u({
+		const { positions, normals, indices } = _usingCtx$9.u({
 			value: rawResult,
 			[Symbol.dispose]() {
 				rawResult.free();
@@ -512,9 +512,9 @@ function meshFromField(field) {
 			}]
 		});
 	} catch (_) {
-		_usingCtx$8.e = _;
+		_usingCtx$9.e = _;
 	} finally {
-		_usingCtx$8.d();
+		_usingCtx$9.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$7 = _usingCtx();
-			const repaired = _usingCtx$7.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness));
+			var _usingCtx$8 = _usingCtx();
+			const repaired = _usingCtx$8.u(engine.value.lattice_infill(mesh.vertices, mesh.triangles, resolution, padding, tag, period, thickness));
 			return ok(toMesh(repaired));
 		} catch (_) {
-			_usingCtx$7.e = _;
+			_usingCtx$8.e = _;
 		} finally {
-			_usingCtx$7.d();
+			_usingCtx$8.d();
 		}
 	} catch (cause) {
 		return err(computationError("LATTICE_INFILL_FAILED", cause instanceof Error ? cause.message : "lattice infill failed (grid too large?).", cause));
@@ -3910,7 +3910,7 @@ function drill(shape, options) {
 */
 function pocket(shape, options) {
 	try {
-		var _usingCtx$6 = _usingCtx();
+		var _usingCtx$7 = _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$6.u(new DisposalScope());
+		const scope = _usingCtx$7.u(new DisposalScope());
 		const { wire: w, owned } = toWire(profile);
 		if (owned) scope.register(w);
 		const faceResult = makeFace(w);
@@ -3932,9 +3932,9 @@ function pocket(shape, options) {
 		scope.register(toolResult.value);
 		return cut$2(s, toolResult.value, { unsafe: true });
 	} catch (_) {
-		_usingCtx$6.e = _;
+		_usingCtx$7.e = _;
 	} finally {
-		_usingCtx$6.d();
+		_usingCtx$7.d();
 	}
 }
 /**
@@ -4524,12 +4524,12 @@ function makeInternalGearProfileWire(params) {
 }
 function makeProfileWire(params, isInternal) {
 	try {
-		var _usingCtx$5 = _usingCtx();
+		var _usingCtx$6 = _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$5.u(new DisposalScope());
+		const scope = _usingCtx$6.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$5.e = _;
+		_usingCtx$6.e = _;
 	} finally {
-		_usingCtx$5.d();
+		_usingCtx$6.d();
 	}
 }
 //#endregion
@@ -4723,8 +4723,8 @@ function resolvePlanetaryParams(params) {
 }
 function makeOuterCircleWire(radius) {
 	try {
-		var _usingCtx$4 = _usingCtx();
-		const circleEdge = _usingCtx$4.u(new DisposalScope()).register(makeCircle(radius, [
+		var _usingCtx$5 = _usingCtx();
+		const circleEdge = _usingCtx$5.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$4.e = _;
+		_usingCtx$5.e = _;
 	} finally {
-		_usingCtx$4.d();
+		_usingCtx$5.d();
 	}
 }
 function finalizeExternalSolid(wire, thickness, bore, geom, diagnostics) {
@@ -5711,6 +5711,22 @@ function extrude$1(profile, vector) {
 		freeParams: depsOf(profile, ve)
 	};
 }
+/** Sweep a face-producing profile along a Wire/Edge-producing spine.
+*  `frenet` is canonicalized (default false) so the default and explicit
+*  forms share one content address. */
+function sweep$2(profile, spine, options) {
+	const frenet = options?.frenet ?? false;
+	let h = mix(mix(startHash("Sweep"), profile), spine);
+	h = fnvMixBool(h, frenet);
+	return {
+		kind: "Sweep",
+		profile,
+		spine,
+		frenet,
+		structuralHash: h,
+		freeParams: depsOf(profile, spine)
+	};
+}
 /** Open (or incidentally closed) planar path in the XY plane at z = 0,
 *  producing a Wire. Segments come from `lineTo`/`arcTo`/`bezierTo`/
 *  `ellipseArcTo`. */
@@ -5811,7 +5827,8 @@ function outputKindOf(node) {
 		case "Mirror": return outputKindOf(node.target);
 		case "Extrude":
 		case "Revolve":
-		case "Loft": return "Solid";
+		case "Loft":
+		case "Sweep": return "Solid";
 		case "Path": return "Wire";
 		case "Compound": return "Compound";
 		case "Instance": return node.fuse ? "Solid" : "Compound";
@@ -6140,9 +6157,9 @@ function evalRevolve(node, ctx) {
 //#region src/csg/evaluators/loft.ts
 function evalLoft(node, ctx) {
 	try {
-		var _usingCtx$3 = _usingCtx();
+		var _usingCtx$4 = _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 scope = _usingCtx$4.u(new DisposalScope());
 		const wires = [];
 		for (const [i, section] of node.sections.entries()) {
 			const face = resolveProfileFace(ctx, section, `Loft.sections[${i}]`);
@@ -6153,9 +6170,9 @@ function evalLoft(node, ctx) {
 		}
 		return loft$2(wires, { ruled: node.ruled });
 	} catch (_) {
-		_usingCtx$3.e = _;
+		_usingCtx$4.e = _;
 	} finally {
-		_usingCtx$3.d();
+		_usingCtx$4.d();
 	}
 }
 //#endregion
@@ -6266,14 +6283,14 @@ function ellipseEdge(from, seg, ctx) {
 	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);
+		var _usingCtx$3 = _usingCtx();
+		const rotated = rotateEdgeAbout(_usingCtx$3.u(edge), psi * 180 / Math.PI, center);
 		if (!rotated.ok) return rotated;
 		edge = rotated.value;
 	} catch (_) {
-		_usingCtx$2.e = _;
+		_usingCtx$3.e = _;
 	} finally {
-		_usingCtx$2.d();
+		_usingCtx$3.d();
 	}
 	if (seg.clockwise) try {
 		var _usingCtx3 = _usingCtx();
@@ -6377,6 +6394,39 @@ function evalPath(node, ctx) {
 	}
 }
 //#endregion
+//#region src/csg/evaluators/sweep.ts
+function evalSweep(node, ctx) {
+	try {
+		var _usingCtx$2 = _usingCtx();
+		const face = resolveProfileFace(ctx, node.profile, "Sweep.profile");
+		if (!face.ok) return face;
+		const spineShape = ctx.evalNode(node.spine);
+		if (!spineShape.ok) return spineShape;
+		const scope = _usingCtx$2.u(new DisposalScope());
+		let spine;
+		if (isWire(spineShape.value)) spine = spineShape.value;
+		else if (isEdge(spineShape.value)) {
+			const wrapped = assembleWire([spineShape.value]);
+			if (!wrapped.ok) return wrapped;
+			scope.register(wrapped.value);
+			spine = wrapped.value;
+		} else return err(typeCastError("CSG_SWEEP_SPINE", "Sweep.spine: node did not produce a Wire or Edge"));
+		const profileWire = outerWire(face.value);
+		scope.register(profileWire);
+		const r = sweep$1(profileWire, spine, { frenet: node.frenet });
+		if (!r.ok) return r;
+		if (Array.isArray(r.value)) {
+			for (const s of r.value) s[Symbol.dispose]();
+			return err(typeCastError("CSG_SWEEP_SPINE", "Sweep: unexpected shell-mode result"));
+		}
+		return ok(r.value);
+	} catch (_) {
+		_usingCtx$2.e = _;
+	} finally {
+		_usingCtx$2.d();
+	}
+}
+//#endregion
 //#region src/csg/evaluate.ts
 function dispatch(node, ctx) {
 	switch (node.kind) {
@@ -6405,6 +6455,7 @@ function dispatch(node, ctx) {
 		case "Revolve": return evalRevolve(node, ctx);
 		case "Loft": return evalLoft(node, ctx);
 		case "Path": return evalPath(node, ctx);
+		case "Sweep": return evalSweep(node, ctx);
 	}
 }
 function hashExprValue(h, v) {
@@ -6811,9 +6862,10 @@ function withEvaluator(options, fn) {
 		_usingCtx$1.d();
 	}
 }
+var MIN_CSG_VERSION = 1;
 function toJSON(node) {
 	return {
-		csgVersion: 1,
+		csgVersion: 2,
 		root: nodeToJson(node)
 	};
 }
@@ -7021,6 +7073,12 @@ function nodeToJson(n) {
 		start: exprToJson(n.start),
 		segments: n.segments.map(segmentToJson)
 	};
+	if (n.kind === "Sweep") return {
+		kind: "Sweep",
+		profile: nodeToJson(n.profile),
+		spine: nodeToJson(n.spine),
+		frenet: n.frenet
+	};
 	if (n.kind === "Compound") return {
 		kind: "Compound",
 		children: n.children.map(nodeToJson)
@@ -7064,7 +7122,7 @@ function readVec2(v, where) {
 function fromJSON(envelope) {
 	if (!isObj(envelope)) return bad("input is not an object");
 	const v = envelope["csgVersion"];
-	if (v !== 1) return bad(`unsupported csgVersion ${String(v)} (expected 1)`);
+	if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_CSG_VERSION || v > 2) return bad(`unsupported csgVersion ${String(v)} (expected ${MIN_CSG_VERSION}..2)`);
 	const root = envelope["root"];
 	return readNode(root);
 }
@@ -7176,6 +7234,7 @@ function readNode(j) {
 		case "Revolve": return readRevolve(j);
 		case "Loft": return readLoft(j);
 		case "Path": return readPath(j);
+		case "Sweep": return readSweep(j);
 		default: return bad(`unknown node kind: ${String(kind)}`);
 	}
 }
@@ -7411,6 +7470,15 @@ function readSegment(j) {
 		default: return bad(`unknown segment kind: ${String(kind)}`);
 	}
 }
+function readSweep(j) {
+	const profile = readNode(j["profile"]);
+	if (!profile.ok) return profile;
+	const spine = readNode(j["spine"]);
+	if (!spine.ok) return spine;
+	const frenet = readFlag(j, "frenet");
+	if (!frenet.ok) return frenet;
+	return ok(sweep$2(profile.value, spine.value, { frenet: frenet.value }));
+}
 function readPath(j) {
 	const start = readExpr(j["start"]);
 	if (!start.ok) return start;
@@ -7538,6 +7606,7 @@ function optimizeNode(n) {
 		case "Extrude":
 		case "Revolve":
 		case "Loft":
+		case "Sweep":
 		case "Path": return optimizeFeature(n);
 	}
 }
@@ -7549,6 +7618,7 @@ function optimizeFeature(n) {
 			at: n.at ? foldExpr(n.at) : void 0
 		});
 		case "Loft": return loft$1(n.sections.map(optimizeNode), { ruled: n.ruled });
+		case "Sweep": return sweep$2(optimizeNode(n.profile), optimizeNode(n.spine), { frenet: n.frenet });
 		case "Path": return path(foldExpr(n.start), n.segments.map((s) => foldSegment(s, foldExpr)));
 	}
 }
@@ -7647,6 +7717,7 @@ function rebuildChildren(n, pred, repl) {
 			at: n.at
 		});
 		case "Loft": return loft$1(n.sections.map((s) => walk(s, pred, repl)), { ruled: n.ruled });
+		case "Sweep": return sweep$2(walk(n.profile, pred, repl), walk(n.spine, pred, repl), { frenet: n.frenet });
 	}
 }
 function forEachNode(root, fn) {
@@ -7680,6 +7751,7 @@ function childrenOf(n) {
 		case "Extrude":
 		case "Revolve": return [n.profile];
 		case "Loft": return n.sections;
+		case "Sweep": return [n.profile, n.spine];
 	}
 }
 function nodeCount(root) {
@@ -7692,7 +7764,7 @@ function nodeCount(root) {
 //#endregion
 //#region src/ns/csg.ts
 var csg_exports = /* @__PURE__ */ __exportAll({
-	CSG_VERSION: () => 1,
+	CSG_VERSION: () => 2,
 	Evaluator: () => Evaluator,
 	add: () => add,
 	arcTo: () => arcTo,
@@ -7739,6 +7811,7 @@ var csg_exports = /* @__PURE__ */ __exportAll({
 	rotate: () => rotate$1,
 	scale: () => scale$1,
 	sphere: () => sphere$2,
+	sweep: () => sweep$2,
 	toJSON: () => toJSON,
 	torus: () => torus$2,
 	translate: () => translate$1,

package/dist/csg/builders.d.ts

@@ -1,7 +1,7 @@
 import { ScalarInput, Vec2Input, Vec3Input } from './expressions.js';
 import { Segment2D } from './segments.js';
 import { Matrix4x4 } from '../core/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, PathNode, 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, PathNode, 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;
@@ -35,6 +35,13 @@ export interface MirrorOptions {
 }
 export declare function mirror(target: IRNode, options?: MirrorOptions): MirrorNode;
 export declare function extrude(profile: FaceNode, vector: Vec3Input): ExtrudeNode;
+export interface SweepNodeOptions {
+    readonly frenet?: boolean | undefined;
+}
+/** Sweep a face-producing profile along a Wire/Edge-producing spine.
+ *  `frenet` is canonicalized (default false) so the default and explicit
+ *  forms share one content address. */
+export declare function sweep(profile: FaceNode, spine: IRNode, options?: SweepNodeOptions): SweepNode;
 /** Open (or incidentally closed) planar path in the XY plane at z = 0,
  *  producing a Wire. Segments come from `lineTo`/`arcTo`/`bezierTo`/
  *  `ellipseArcTo`. */

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

@@ -0,0 +1,5 @@
+import { Result } from '../../core/result.js';
+import { AnyShape, Dimension } from '../../core/shapeTypes.js';
+import { SweepNode } from '../types.js';
+import { EvalContext } from './context.js';
+export declare function evalSweep(node: SweepNode, 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, path, compound, instance, type RevolveOptions, type LoftOptions, 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, path, 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, PathNode, InstanceNode, SolidNode, FaceNode, EdgeNode, VertexNode, AnyNode, } from './types.js';
+export type { IRNode, NodeKind, OutputKind, PrimitiveNode, BooleanNode, TransformIRNode, ExtrudeNode, RevolveNode, LoftNode, SweepNode, PathNode, InstanceNode, SolidNode, FaceNode, EdgeNode, VertexNode, AnyNode, } from './types.js';
 export { outputKindOf } from './types.js';
 export { lineTo, arcTo, bezierTo, ellipseArcTo, type Segment2D, type SegmentOptions, type EllipseArcOptions, } from './segments.js';
 export { Evaluator, withEvaluator, type EvaluatorOptions, type StepInfo, type CacheStats, } from './evaluate.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 = 1;
+export declare const CSG_VERSION = 2;
 export interface CsgEnvelope {
     readonly csgVersion: number;
     readonly root: unknown;

package/dist/csg/types.d.ts

@@ -124,6 +124,15 @@ export interface RevolveNode extends IRNodeBase {
     readonly axis?: Expr | undefined;
     readonly at?: Expr | undefined;
 }
+export interface SweepNode extends IRNodeBase {
+    readonly kind: 'Sweep';
+    /** Must produce OutputKind 'Face'. */
+    readonly profile: IRNode;
+    /** Must produce OutputKind 'Wire' or 'Edge' (Line, Circle, Path). */
+    readonly spine: IRNode;
+    /** Canonicalized by the builder (default false). */
+    readonly frenet: boolean;
+}
 export interface PathNode extends IRNodeBase {
     readonly kind: 'Path';
     /** Vec2 start point; the path lies in the XY plane (z = 0) and is lifted
@@ -154,7 +163,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 | PathNode | CompoundNode | InstanceNode;
+export type IRNode = PrimitiveNode | BooleanNode | TransformIRNode | ExtrudeNode | RevolveNode | LoftNode | SweepNode | PathNode | 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.126.0",
+  "version": "18.127.0",
   "description": "Web CAD library with pluggable geometry kernel",
   "keywords": [
     "cad",