brepjs-sheetmetal 0.4.4 → 0.5.0

package/README.md

@@ -94,6 +94,12 @@ feature in that region's **local** frame: `(0, 0)` is the region's near corner,
   profile is built in region-local coords, then placed via the region's world frame (origin/u/v/n), so a
   hole authored on a folded flange lands on the flange face, not the base plane. Rejects a feature outside
   the region (`CUTOUT_OUT_OF_BOUNDS`) and guards a valid, single-bodied result (`CUTOUT_SEVERED_SOLID`).
+- `addCutouts(part, specs)` punches a list of cutouts in **one** boolean cut. Each `addCutout` call is a cut
+  on the solid that the call before it made larger, so a chain of calls slows down as it goes. Use
+  `addCutouts` for a vent pattern or a row of holes: the result is the same part, with the features recorded
+  in `specs` order. A spec that fails validation fails the whole call.
+- A round hole is a true cylinder in the solid, and an obround slot has true arcs. Their developed loops are
+  polylines of 48 segments for a full circle.
 - `unfold` emits the matching developed loop at the cutout's flat-pattern location (mapped through the same
   region's developed frame) and drops `developedArea` by the cutout areas.
 

package/dist/api.d.ts

@@ -33,6 +33,8 @@ export declare function autoReliefs(part: SheetMetalPart, spec?: ReliefSpec): Re
 export declare function relieveCorner(part: SheetMetalPart, flangeIdA: string, flangeIdB: string, spec?: ReliefSpec): Result<SheetMetalPart>;
 /** Punch a cutout (hole / slot / polygon) through a named flat region's thickness. */
 export declare function addCutout(part: SheetMetalPart, spec: CutoutSpec): Result<SheetMetalPart>;
+/** Punch many cutouts in one boolean cut. Use this for a pattern of cutouts. */
+export declare function addCutouts(part: SheetMetalPart, specs: readonly CutoutSpec[]): Result<SheetMetalPart>;
 /** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
 export declare function addHole(part: SheetMetalPart, region: string, x: number, y: number, diameter: number): Result<SheetMetalPart>;
 /** Punch a slot (rectangular or obround) centred at region-local `(x, y)`. */

package/dist/brepjs-sheetmetal.cjs

@@ -1686,14 +1686,14 @@ function describePlanar(face) {
 /** True if `point` (already on the face's surface) lies within the face's trimmed boundary. */
 function liesOnFace(face, point) {
 	try {
-		var _usingCtx$1 = _usingCtx();
-		const probe = _usingCtx$1.u((0, brepjs.vertex)(point));
+		var _usingCtx$2 = _usingCtx();
+		const probe = _usingCtx$2.u((0, brepjs.vertex)(point));
 		const d = (0, brepjs.measureDistance)(probe, face);
 		return d.ok && d.value < GEOM_TOL;
 	} catch (_) {
-		_usingCtx$1.e = _;
+		_usingCtx$2.e = _;
 	} finally {
-		_usingCtx$1.d();
+		_usingCtx$2.d();
 	}
 }
 /** Normal-direction gap between two planar faces, or `null` unless they are antiparallel. */
@@ -1935,6 +1935,9 @@ function buildBendGraph(flats, bends, warnings) {
 			if (bendTouchesFlat(bend, flat)) touching.push(fi);
 		}
 		if (touching.length < 2) {
+			const [only] = touching;
+			const flat = only !== void 0 ? flats[only] : void 0;
+			if (flat !== void 0 && goesThroughFlat(bend, flat)) continue;
 			warnings.push({
 				code: "DETECTION_INCOMPLETE",
 				message: `bend '${bend.id}' connects ${touching.length} flats (expected 2); ignored`,
@@ -1954,11 +1957,28 @@ function buildBendGraph(flats, bends, warnings) {
 	}
 	return { edges };
 }
+/**
+* True for a cylinder that goes through the sheet: a round hole, the end of an
+* obround slot or a rounded corner of the outline. A bend axis lies in the plane
+* of its flats; this axis is along the flat normal, and the cylinder meets both
+* faces of the panel. A boss or a blind recess meets one face only, so it keeps
+* its warning.
+*/
+function goesThroughFlat(bend, flat) {
+	if (Math.abs((0, brepjs.vecDot)(bend.fit.axisDir, flat.normal)) <= .99) return false;
+	return flat.faces.every((ff) => bend.faces.some((bf) => facesShareEdge(bf, ff)));
+}
 /** True if any of the bend's faces shares an edge with either face of the flat. */
 function bendTouchesFlat(bend, flat) {
-	for (const bf of bend.faces) for (const ff of flat.faces) if ((0, brepjs.sharedEdges)(bf, ff).length > 0) return true;
+	for (const bf of bend.faces) for (const ff of flat.faces) if (facesShareEdge(bf, ff)) return true;
 	return false;
 }
+/** True if two faces share an edge. `sharedEdges` returns handles that the caller owns. */
+function facesShareEdge(a, b) {
+	const edges = (0, brepjs.sharedEdges)(a, b);
+	for (const edge of edges) edge.delete();
+	return edges.length > 0;
+}
 /**
 * Lay out detected flats into the developed plane. A spanning tree over the bend
 * graph (BFS from flat 0) places each flat as a rectangle and each tree bend as a
@@ -3327,7 +3347,10 @@ function dist2(a, b) {
 var EPS$5 = 1e-6;
 /** A hair of over-cut so the tool pokes through both faces cleanly. */
 var HAIR$1 = .05;
-/** Polyline segments approximating a circular boundary (hole / obround end cap). */
+/**
+* Polyline segments approximating a circular boundary (hole / obround end cap) in
+* the developed loop. The 3D cut tool keeps the true circle and arcs.
+*/
 var CIRCLE_SEGMENTS$1 = 48;
 /**
 * Punch a cutout (hole / slot / polygon) through a named flat region's thickness.
@@ -3338,42 +3361,78 @@ var CIRCLE_SEGMENTS$1 = 48;
 * mapped through the region's developed {@link Frame2} and recorded as a
 * {@link CutoutFeature}, so {@link unfold} emits the matching loop in the flat
 * pattern and {@link fold} can replay it. Guards a valid, single-bodied solid.
+*
+* Each call is one boolean cut on a solid that the cut before it made larger. For
+* a pattern of cutouts, {@link addCutouts} makes one cut for all of them.
 */
 function addCutout(part, spec) {
-	if (part.solid === void 0) return (0, brepjs.err)((0, brepjs.validationError)("NO_SOLID", "addCutout: part has no folded solid to cut"));
-	const regionId = resolveRegionId(spec.region);
-	const treeResult = featureTree(part);
-	if (!treeResult.ok) return treeResult;
-	const tree = treeResult.value;
-	const framesResult = worldFrames(part, tree);
-	if (!framesResult.ok) return framesResult;
-	const worldFrame = framesResult.value.get(regionId);
-	if (worldFrame === void 0) return (0, brepjs.err)((0, brepjs.validationError)("UNKNOWN_REGION", `addCutout: region '${spec.region}' not found`));
-	const localResult = localLoop(spec);
-	if (!localResult.ok) return localResult;
-	const local = localResult.value;
-	const oob = checkInBounds(local, regionExtent(part, regionId, worldFrame));
-	if (oob !== void 0) return (0, brepjs.err)((0, brepjs.validationError)("CUTOUT_OUT_OF_BOUNDS", oob));
-	const dev = developedFrame(part, regionId, tree);
-	if (!dev.ok) return dev;
-	const toolResult = buildTool(local, worldFrame, part.thickness);
-	if (!toolResult.ok) return toolResult;
-	const cutResult = (0, brepjs.cut)(part.solid, toolResult.value);
-	if (!cutResult.ok) return cutResult;
-	const solid = normalizeSolid(cutResult.value);
-	if (!(0, brepjs.isValid)(solid) || (0, brepjs.getSolids)(solid).length > 1) return (0, brepjs.err)((0, brepjs.validationError)("CUTOUT_SEVERED_SOLID", `addCutout: ${spec.kind} on region '${spec.region}' severs the part into multiple bodies`));
-	const loop = local.map((p) => mapToFrame2(p, dev.value));
-	const feature = {
-		spec,
-		region: regionId,
-		loop,
-		area: polygonArea(loop)
-	};
-	return (0, brepjs.ok)({
-		...part,
-		solid,
-		cutouts: [...part.cutouts ?? [], feature]
-	});
+	return punch(part, [spec], "addCutout");
+}
+/**
+* Punch many cutouts in one boolean cut. The result is the same part that a chain
+* of {@link addCutout} calls gives, with the features recorded in `specs` order,
+* but the cost does not grow with the square of the count. A spec that fails
+* validation fails the whole call, and no cutout is made.
+*/
+function addCutouts(part, specs) {
+	return punch(part, specs, "addCutouts");
+}
+function punch(part, specs, label) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		if (part.solid === void 0) return (0, brepjs.err)((0, brepjs.validationError)("NO_SOLID", `${label}: part has no folded solid to cut`));
+		if (specs.length === 0) return (0, brepjs.ok)(part);
+		const treeResult = featureTree(part);
+		if (!treeResult.ok) return treeResult;
+		const tree = treeResult.value;
+		const framesResult = worldFrames(part, tree);
+		if (!framesResult.ok) return framesResult;
+		const layout = layoutTree(part, tree, part.baseLength, part.width);
+		if (!layout.ok) return layout;
+		const scope = _usingCtx$1.u(new brepjs.DisposalScope());
+		const tools = [];
+		const features = [];
+		for (const spec of specs) {
+			const regionId = resolveRegionId(spec.region);
+			const worldFrame = framesResult.value.get(regionId);
+			if (worldFrame === void 0) return (0, brepjs.err)((0, brepjs.validationError)("UNKNOWN_REGION", `${label}: region '${spec.region}' not found`));
+			const localResult = localLoop(spec);
+			if (!localResult.ok) return localResult;
+			const local = localResult.value;
+			const oob = checkInBounds(outlineBounds(spec, local), regionExtent(part, regionId, worldFrame));
+			if (oob !== void 0) return (0, brepjs.err)((0, brepjs.validationError)("CUTOUT_OUT_OF_BOUNDS", oob));
+			const dev = developedFrame(layout.value, regionId);
+			if (!dev.ok) return dev;
+			const toolResult = buildTool(spec, local, worldFrame, part.thickness, scope);
+			if (!toolResult.ok) return toolResult;
+			tools.push(scope.register(toolResult.value));
+			const loop = local.map((p) => mapToFrame2(p, dev.value));
+			features.push({
+				spec,
+				region: regionId,
+				loop,
+				area: polygonArea(loop)
+			});
+		}
+		const [only] = tools;
+		const cutResult = tools.length === 1 && only !== void 0 ? (0, brepjs.cut)(part.solid, only) : (0, brepjs.cutAll)(part.solid, tools);
+		if (!cutResult.ok) return cutResult;
+		const solid = normalizeSolid(cutResult.value);
+		if (!(0, brepjs.isValid)(solid) || (0, brepjs.getSolids)(solid).length > 1) {
+			const [first] = specs;
+			const what = specs.length === 1 && first !== void 0 ? `${first.kind} on region '${first.region}' severs` : `the ${specs.length} cutouts sever`;
+			return (0, brepjs.err)((0, brepjs.validationError)("CUTOUT_SEVERED_SOLID", `${label}: ${what} the part into multiple bodies`));
+		}
+		return (0, brepjs.ok)({
+			...part,
+			solid,
+			cutouts: [...part.cutouts ?? [], ...features]
+		});
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
 }
 /** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
 function addHole(part, region, x, y, diameter) {
@@ -3420,7 +3479,9 @@ function regionFrames(part, region) {
 	if (!framesResult.ok) return framesResult;
 	const world = framesResult.value.get(regionId);
 	if (world === void 0) return (0, brepjs.err)((0, brepjs.validationError)("UNKNOWN_REGION", `region '${region}' not found`));
-	const dev = developedFrame(part, regionId, tree);
+	const layout = layoutTree(part, tree, part.baseLength, part.width);
+	if (!layout.ok) return layout;
+	const dev = developedFrame(layout.value, regionId);
 	if (!dev.ok) return dev;
 	return (0, brepjs.ok)({
 		regionId,
@@ -3494,45 +3555,107 @@ function regionExtent(part, regionId, worldFrame) {
 		vMax: worldFrame.vLen
 	};
 }
-/** First out-of-bounds message, or undefined if the whole loop lies inside the region. */
-function checkInBounds(local, ext) {
-	for (const [x, y] of local) if (x < -1e-6 || x > ext.uMax + EPS$5 || y < -1e-6 || y > ext.vMax + EPS$5) return `cutout point (${x.toFixed(3)}, ${y.toFixed(3)}) lies outside region extent [0,${ext.uMax}]×[0,${ext.vMax}]`;
+/**
+* Local-frame bounding box of the outline that the 3D tool cuts. A hole and the
+* ends of an obround slot are true circles, which reach past the vertices of
+* their developed polyline, so their boxes come from the circle centres.
+*/
+function outlineBounds(spec, local) {
+	if (spec.kind === "hole") {
+		const r = spec.diameter / 2;
+		return {
+			xMin: spec.x - r,
+			xMax: spec.x + r,
+			yMin: spec.y - r,
+			yMax: spec.y + r
+		};
+	}
+	if (spec.kind === "slot" && spec.round === true) {
+		const hw = spec.width / 2;
+		const straight = Math.max(spec.length / 2 - hw, 0);
+		const rad = (spec.angleDeg ?? 0) * Math.PI / 180;
+		const dx = Math.abs(straight * Math.cos(rad)) + hw;
+		const dy = Math.abs(straight * Math.sin(rad)) + hw;
+		return {
+			xMin: spec.x - dx,
+			xMax: spec.x + dx,
+			yMin: spec.y - dy,
+			yMax: spec.y + dy
+		};
+	}
+	const xs = local.map((p) => p[0]);
+	const ys = local.map((p) => p[1]);
+	return {
+		xMin: Math.min(...xs),
+		xMax: Math.max(...xs),
+		yMin: Math.min(...ys),
+		yMax: Math.max(...ys)
+	};
+}
+/** Out-of-bounds message, or undefined if the whole outline lies inside the region. */
+function checkInBounds(b, ext) {
+	if (b.xMin < -1e-6 || b.xMax > ext.uMax + EPS$5 || b.yMin < -1e-6 || b.yMax > ext.vMax + EPS$5) return `cutout extent [${b.xMin.toFixed(3)}, ${b.xMax.toFixed(3)}]×[${b.yMin.toFixed(3)}, ${b.yMax.toFixed(3)}] lies outside region extent [0,${ext.uMax}]×[0,${ext.vMax}]`;
 }
 /**
-* Build the 3D cut tool: the local loop placed onto the region's bottom surface
-* (`origin + x·u + y·v − HAIR·n`), turned into a face, and extruded through the
-* sheet by `thickness + 2·HAIR` along +n. Using the world frame's `u`/`v`/`n` is
-* what lands the cut on the correct folded face.
+* Build the 3D cut tool on the region's bottom surface, a hair below it
+* (`origin + x·u + y·v − HAIR·n`), through the sheet by `thickness + 2·HAIR` along
+* +n. Using the world frame's `u`/`v`/`n` is what lands the cut on the correct
+* folded face. A hole is a true cylinder and an obround slot has true arcs, so a
+* round cutout adds one or two curved faces to the solid, not one planar face for
+* each segment of its developed loop. Intermediate shapes go to `scope`.
 */
-function buildTool(local, f, thickness) {
+function buildTool(spec, local, f, thickness, scope) {
 	const base = (0, brepjs.vecAdd)(f.origin, (0, brepjs.vecScale)(f.n, -.05));
-	const worldPts = local.map(([x, y]) => (0, brepjs.vecAdd)((0, brepjs.vecAdd)(base, (0, brepjs.vecScale)(f.u, x)), (0, brepjs.vecScale)(f.v, y)));
-	const edges = [];
-	for (let i = 0; i < worldPts.length; i += 1) {
-		const a = worldPts[i];
-		const b = worldPts[(i + 1) % worldPts.length];
-		if (a === void 0 || b === void 0) return (0, brepjs.err)((0, brepjs.validationError)("CUTOUT_TOOL_FAILED", "failed to index cutout loop points"));
-		edges.push((0, brepjs.line)(a, b));
-	}
+	const toWorld = ([x, y]) => (0, brepjs.vecAdd)((0, brepjs.vecAdd)(base, (0, brepjs.vecScale)(f.u, x)), (0, brepjs.vecScale)(f.v, y));
+	const depth = thickness + 2 * HAIR$1;
+	if (spec.kind === "hole") return (0, brepjs.ok)((0, brepjs.cylinder)(spec.diameter / 2, depth, {
+		at: toWorld([spec.x, spec.y]),
+		axis: f.n
+	}));
+	const edges = spec.kind === "slot" && spec.round === true ? obroundEdges(spec, toWorld) : polylineEdges(local, toWorld);
+	for (const e of edges) scope.register(e);
 	const wire = (0, brepjs.wireLoop)(edges);
 	if (!wire.ok) return wire;
+	scope.register(wire.value);
 	if (!(0, brepjs.isPlanarWire)(wire.value)) return (0, brepjs.err)((0, brepjs.validationError)("CUTOUT_TOOL_FAILED", "cutout profile wire is not planar"));
 	const profile = (0, brepjs.face)(wire.value);
 	if (!profile.ok) return profile;
-	const depth = thickness + 2 * HAIR$1;
+	scope.register(profile.value);
 	return (0, brepjs.extrude)(profile.value, [
 		f.n[0] * depth,
 		f.n[1] * depth,
 		f.n[2] * depth
 	]);
 }
-/** Developed-plane {@link Frame2} of a region (base or flange) via the unfold layout. */
-function developedFrame(part, regionId, tree) {
-	const treeResult = tree !== void 0 ? (0, brepjs.ok)(tree) : featureTree(part);
-	if (!treeResult.ok) return treeResult;
-	const layout = layoutTree(part, treeResult.value, part.baseLength, part.width);
-	if (!layout.ok) return layout;
-	const placed = layout.value.flats.find((p) => p.id === regionId);
+function polylineEdges(local, toWorld) {
+	const pts = local.map(toWorld);
+	return pts.map((a, i) => (0, brepjs.line)(a, pts[(i + 1) % pts.length] ?? a));
+}
+/**
+* Edges of an obround slot: two straight sides joined by two semicircles of radius
+* `width/2`. A slot as wide as it is long has no straight side, so it is two
+* semicircles (a circle).
+*/
+function obroundEdges(spec, toWorld) {
+	const hw = spec.width / 2;
+	const straight = Math.max(spec.length / 2 - hw, 0);
+	const rad = (spec.angleDeg ?? 0) * Math.PI / 180;
+	const c = Math.cos(rad);
+	const s = Math.sin(rad);
+	const at = (x, y) => toWorld([spec.x + x * c - y * s, spec.y + x * s + y * c]);
+	const rightBottom = at(straight, -hw);
+	const rightTop = at(straight, hw);
+	const leftTop = at(-straight, hw);
+	const leftBottom = at(-straight, -hw);
+	const edges = [(0, brepjs.threePointArc)(rightBottom, at(straight + hw, 0), rightTop)];
+	if (straight > EPS$5) edges.push((0, brepjs.line)(rightTop, leftTop));
+	edges.push((0, brepjs.threePointArc)(leftTop, at(-straight - hw, 0), leftBottom));
+	if (straight > EPS$5) edges.push((0, brepjs.line)(leftBottom, rightBottom));
+	return edges;
+}
+/** Developed-plane {@link Frame2} of a region (base or flange) in the unfold layout. */
+function developedFrame(layout, regionId) {
+	const placed = layout.flats.find((p) => p.id === regionId);
 	if (placed === void 0) return (0, brepjs.err)((0, brepjs.validationError)("UNKNOWN_REGION", `developedFrame: region '${regionId}' missing from layout`));
 	return (0, brepjs.ok)(placed.frame);
 }
@@ -4212,22 +4335,17 @@ function foldWithWarnings(input) {
 		if (!relieved.ok) return relieved;
 		part = relieved.value;
 	}
-	for (const spec of input.baseCutouts ?? []) {
-		const cutResult = addCutout(part, {
-			...spec,
-			region: ROOT_FLAT_ID
-		});
-		if (!cutResult.ok) return cutResult;
-		part = cutResult.value;
-	}
-	for (const region of input.regions) for (const spec of region.cutouts ?? []) {
-		const cutResult = addCutout(part, {
-			...spec,
-			region: region.id
-		});
-		if (!cutResult.ok) return cutResult;
-		part = cutResult.value;
-	}
+	const cutoutSpecs = (input.baseCutouts ?? []).map((spec) => ({
+		...spec,
+		region: ROOT_FLAT_ID
+	}));
+	for (const region of input.regions) for (const spec of region.cutouts ?? []) cutoutSpecs.push({
+		...spec,
+		region: region.id
+	});
+	const cutResult = addCutouts(part, cutoutSpecs);
+	if (!cutResult.ok) return cutResult;
+	part = cutResult.value;
 	for (const spec of input.baseTabs ?? []) {
 		const tabbed = addTab(part, {
 			...spec,
@@ -7104,6 +7222,10 @@ function relieveCorner(part, flangeIdA, flangeIdB, spec) {
 function addCutout$1(part, spec) {
 	return addCutout(part, spec);
 }
+/** Punch many cutouts in one boolean cut. Use this for a pattern of cutouts. */
+function addCutouts$1(part, specs) {
+	return addCutouts(part, specs);
+}
 /** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
 function addHole$1(part, region, x, y, diameter) {
 	return addHole(part, region, x, y, diameter);
@@ -7266,6 +7388,10 @@ var SheetMetalPartHandle = class SheetMetalPartHandle {
 	cutout(spec) {
 		return new SheetMetalPartHandle(unwrapOrThrow(addCutout$1(this.part, spec)));
 	}
+	/** Punch many cutouts in one boolean cut. Use this for a pattern of cutouts. */
+	cutouts(specs) {
+		return new SheetMetalPartHandle(unwrapOrThrow(addCutouts$1(this.part, specs)));
+	}
 	/** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
 	hole(region, x, y, diameter) {
 		return new SheetMetalPartHandle(unwrapOrThrow(addHole$1(this.part, region, x, y, diameter)));
@@ -7421,6 +7547,9 @@ var SheetMetalBuilder = class SheetMetalBuilder {
 	cutout(spec) {
 		return this.build().cutout(spec);
 	}
+	cutouts(specs) {
+		return this.build().cutouts(specs);
+	}
 	hole(region, x, y, diameter) {
 		return this.build().hole(region, x, y, diameter);
 	}
@@ -7502,6 +7631,7 @@ exports.SheetMetalPartHandle = SheetMetalPartHandle;
 exports.addBendRelief = addBendRelief;
 exports.addBendTable = addBendTable;
 exports.addCutout = addCutout;
+exports.addCutouts = addCutouts;
 exports.addForm = addForm;
 exports.addHole = addHole;
 exports.addPolygonCutout = addPolygonCutout;

package/dist/brepjs-sheetmetal.js

@@ -1,4 +1,4 @@
-import { box, curveEndPoint, curveStartPoint, cut, cylinder, err, extrude, face, faceCenter, fuse, getBounds, getEdges, getFaces, getSolids, getSurfaceType, intersect, isErr, isOk, isPlanarWire, isSolid, isValid, line, measureArea, measureDistance, measureLength, measureVolume, normalAt, ok, pointOnSurface, rotate, sharedEdges, translate, validationError, vecAdd, vecCross, vecDot, vecLength, vecNormalize, vecScale, vecSub, vertex, wire, wireLoop } from "brepjs";
+import { DisposalScope, box, curveEndPoint, curveStartPoint, cut, cutAll, cylinder, err, extrude, face, faceCenter, fuse, getBounds, getEdges, getFaces, getSolids, getSurfaceType, intersect, isErr, isOk, isPlanarWire, isSolid, isValid, line, measureArea, measureDistance, measureLength, measureVolume, normalAt, ok, pointOnSurface, rotate, sharedEdges, threePointArc, translate, validationError, vecAdd, vecCross, vecDot, vecLength, vecNormalize, vecScale, vecSub, vertex, wire, wireLoop } from "brepjs";
 // src/materials.ts
 var DEFAULT_K_FACTOR = .44;
 function gauge(name, thickness, kFactor = DEFAULT_K_FACTOR) {
@@ -1685,14 +1685,14 @@ function describePlanar(face) {
 /** True if `point` (already on the face's surface) lies within the face's trimmed boundary. */
 function liesOnFace(face, point) {
 	try {
-		var _usingCtx$1 = _usingCtx();
-		const probe = _usingCtx$1.u(vertex(point));
+		var _usingCtx$2 = _usingCtx();
+		const probe = _usingCtx$2.u(vertex(point));
 		const d = measureDistance(probe, face);
 		return d.ok && d.value < GEOM_TOL;
 	} catch (_) {
-		_usingCtx$1.e = _;
+		_usingCtx$2.e = _;
 	} finally {
-		_usingCtx$1.d();
+		_usingCtx$2.d();
 	}
 }
 /** Normal-direction gap between two planar faces, or `null` unless they are antiparallel. */
@@ -1934,6 +1934,9 @@ function buildBendGraph(flats, bends, warnings) {
 			if (bendTouchesFlat(bend, flat)) touching.push(fi);
 		}
 		if (touching.length < 2) {
+			const [only] = touching;
+			const flat = only !== void 0 ? flats[only] : void 0;
+			if (flat !== void 0 && goesThroughFlat(bend, flat)) continue;
 			warnings.push({
 				code: "DETECTION_INCOMPLETE",
 				message: `bend '${bend.id}' connects ${touching.length} flats (expected 2); ignored`,
@@ -1953,11 +1956,28 @@ function buildBendGraph(flats, bends, warnings) {
 	}
 	return { edges };
 }
+/**
+* True for a cylinder that goes through the sheet: a round hole, the end of an
+* obround slot or a rounded corner of the outline. A bend axis lies in the plane
+* of its flats; this axis is along the flat normal, and the cylinder meets both
+* faces of the panel. A boss or a blind recess meets one face only, so it keeps
+* its warning.
+*/
+function goesThroughFlat(bend, flat) {
+	if (Math.abs(vecDot(bend.fit.axisDir, flat.normal)) <= .99) return false;
+	return flat.faces.every((ff) => bend.faces.some((bf) => facesShareEdge(bf, ff)));
+}
 /** True if any of the bend's faces shares an edge with either face of the flat. */
 function bendTouchesFlat(bend, flat) {
-	for (const bf of bend.faces) for (const ff of flat.faces) if (sharedEdges(bf, ff).length > 0) return true;
+	for (const bf of bend.faces) for (const ff of flat.faces) if (facesShareEdge(bf, ff)) return true;
 	return false;
 }
+/** True if two faces share an edge. `sharedEdges` returns handles that the caller owns. */
+function facesShareEdge(a, b) {
+	const edges = sharedEdges(a, b);
+	for (const edge of edges) edge.delete();
+	return edges.length > 0;
+}
 /**
 * Lay out detected flats into the developed plane. A spanning tree over the bend
 * graph (BFS from flat 0) places each flat as a rectangle and each tree bend as a
@@ -3326,7 +3346,10 @@ function dist2(a, b) {
 var EPS$5 = 1e-6;
 /** A hair of over-cut so the tool pokes through both faces cleanly. */
 var HAIR$1 = .05;
-/** Polyline segments approximating a circular boundary (hole / obround end cap). */
+/**
+* Polyline segments approximating a circular boundary (hole / obround end cap) in
+* the developed loop. The 3D cut tool keeps the true circle and arcs.
+*/
 var CIRCLE_SEGMENTS$1 = 48;
 /**
 * Punch a cutout (hole / slot / polygon) through a named flat region's thickness.
@@ -3337,42 +3360,78 @@ var CIRCLE_SEGMENTS$1 = 48;
 * mapped through the region's developed {@link Frame2} and recorded as a
 * {@link CutoutFeature}, so {@link unfold} emits the matching loop in the flat
 * pattern and {@link fold} can replay it. Guards a valid, single-bodied solid.
+*
+* Each call is one boolean cut on a solid that the cut before it made larger. For
+* a pattern of cutouts, {@link addCutouts} makes one cut for all of them.
 */
 function addCutout(part, spec) {
-	if (part.solid === void 0) return err(validationError("NO_SOLID", "addCutout: part has no folded solid to cut"));
-	const regionId = resolveRegionId(spec.region);
-	const treeResult = featureTree(part);
-	if (!treeResult.ok) return treeResult;
-	const tree = treeResult.value;
-	const framesResult = worldFrames(part, tree);
-	if (!framesResult.ok) return framesResult;
-	const worldFrame = framesResult.value.get(regionId);
-	if (worldFrame === void 0) return err(validationError("UNKNOWN_REGION", `addCutout: region '${spec.region}' not found`));
-	const localResult = localLoop(spec);
-	if (!localResult.ok) return localResult;
-	const local = localResult.value;
-	const oob = checkInBounds(local, regionExtent(part, regionId, worldFrame));
-	if (oob !== void 0) return err(validationError("CUTOUT_OUT_OF_BOUNDS", oob));
-	const dev = developedFrame(part, regionId, tree);
-	if (!dev.ok) return dev;
-	const toolResult = buildTool(local, worldFrame, part.thickness);
-	if (!toolResult.ok) return toolResult;
-	const cutResult = cut(part.solid, toolResult.value);
-	if (!cutResult.ok) return cutResult;
-	const solid = normalizeSolid(cutResult.value);
-	if (!isValid(solid) || getSolids(solid).length > 1) return err(validationError("CUTOUT_SEVERED_SOLID", `addCutout: ${spec.kind} on region '${spec.region}' severs the part into multiple bodies`));
-	const loop = local.map((p) => mapToFrame2(p, dev.value));
-	const feature = {
-		spec,
-		region: regionId,
-		loop,
-		area: polygonArea(loop)
-	};
-	return ok({
-		...part,
-		solid,
-		cutouts: [...part.cutouts ?? [], feature]
-	});
+	return punch(part, [spec], "addCutout");
+}
+/**
+* Punch many cutouts in one boolean cut. The result is the same part that a chain
+* of {@link addCutout} calls gives, with the features recorded in `specs` order,
+* but the cost does not grow with the square of the count. A spec that fails
+* validation fails the whole call, and no cutout is made.
+*/
+function addCutouts(part, specs) {
+	return punch(part, specs, "addCutouts");
+}
+function punch(part, specs, label) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		if (part.solid === void 0) return err(validationError("NO_SOLID", `${label}: part has no folded solid to cut`));
+		if (specs.length === 0) return ok(part);
+		const treeResult = featureTree(part);
+		if (!treeResult.ok) return treeResult;
+		const tree = treeResult.value;
+		const framesResult = worldFrames(part, tree);
+		if (!framesResult.ok) return framesResult;
+		const layout = layoutTree(part, tree, part.baseLength, part.width);
+		if (!layout.ok) return layout;
+		const scope = _usingCtx$1.u(new DisposalScope());
+		const tools = [];
+		const features = [];
+		for (const spec of specs) {
+			const regionId = resolveRegionId(spec.region);
+			const worldFrame = framesResult.value.get(regionId);
+			if (worldFrame === void 0) return err(validationError("UNKNOWN_REGION", `${label}: region '${spec.region}' not found`));
+			const localResult = localLoop(spec);
+			if (!localResult.ok) return localResult;
+			const local = localResult.value;
+			const oob = checkInBounds(outlineBounds(spec, local), regionExtent(part, regionId, worldFrame));
+			if (oob !== void 0) return err(validationError("CUTOUT_OUT_OF_BOUNDS", oob));
+			const dev = developedFrame(layout.value, regionId);
+			if (!dev.ok) return dev;
+			const toolResult = buildTool(spec, local, worldFrame, part.thickness, scope);
+			if (!toolResult.ok) return toolResult;
+			tools.push(scope.register(toolResult.value));
+			const loop = local.map((p) => mapToFrame2(p, dev.value));
+			features.push({
+				spec,
+				region: regionId,
+				loop,
+				area: polygonArea(loop)
+			});
+		}
+		const [only] = tools;
+		const cutResult = tools.length === 1 && only !== void 0 ? cut(part.solid, only) : cutAll(part.solid, tools);
+		if (!cutResult.ok) return cutResult;
+		const solid = normalizeSolid(cutResult.value);
+		if (!isValid(solid) || getSolids(solid).length > 1) {
+			const [first] = specs;
+			const what = specs.length === 1 && first !== void 0 ? `${first.kind} on region '${first.region}' severs` : `the ${specs.length} cutouts sever`;
+			return err(validationError("CUTOUT_SEVERED_SOLID", `${label}: ${what} the part into multiple bodies`));
+		}
+		return ok({
+			...part,
+			solid,
+			cutouts: [...part.cutouts ?? [], ...features]
+		});
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
 }
 /** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
 function addHole(part, region, x, y, diameter) {
@@ -3419,7 +3478,9 @@ function regionFrames(part, region) {
 	if (!framesResult.ok) return framesResult;
 	const world = framesResult.value.get(regionId);
 	if (world === void 0) return err(validationError("UNKNOWN_REGION", `region '${region}' not found`));
-	const dev = developedFrame(part, regionId, tree);
+	const layout = layoutTree(part, tree, part.baseLength, part.width);
+	if (!layout.ok) return layout;
+	const dev = developedFrame(layout.value, regionId);
 	if (!dev.ok) return dev;
 	return ok({
 		regionId,
@@ -3493,45 +3554,107 @@ function regionExtent(part, regionId, worldFrame) {
 		vMax: worldFrame.vLen
 	};
 }
-/** First out-of-bounds message, or undefined if the whole loop lies inside the region. */
-function checkInBounds(local, ext) {
-	for (const [x, y] of local) if (x < -1e-6 || x > ext.uMax + EPS$5 || y < -1e-6 || y > ext.vMax + EPS$5) return `cutout point (${x.toFixed(3)}, ${y.toFixed(3)}) lies outside region extent [0,${ext.uMax}]×[0,${ext.vMax}]`;
+/**
+* Local-frame bounding box of the outline that the 3D tool cuts. A hole and the
+* ends of an obround slot are true circles, which reach past the vertices of
+* their developed polyline, so their boxes come from the circle centres.
+*/
+function outlineBounds(spec, local) {
+	if (spec.kind === "hole") {
+		const r = spec.diameter / 2;
+		return {
+			xMin: spec.x - r,
+			xMax: spec.x + r,
+			yMin: spec.y - r,
+			yMax: spec.y + r
+		};
+	}
+	if (spec.kind === "slot" && spec.round === true) {
+		const hw = spec.width / 2;
+		const straight = Math.max(spec.length / 2 - hw, 0);
+		const rad = (spec.angleDeg ?? 0) * Math.PI / 180;
+		const dx = Math.abs(straight * Math.cos(rad)) + hw;
+		const dy = Math.abs(straight * Math.sin(rad)) + hw;
+		return {
+			xMin: spec.x - dx,
+			xMax: spec.x + dx,
+			yMin: spec.y - dy,
+			yMax: spec.y + dy
+		};
+	}
+	const xs = local.map((p) => p[0]);
+	const ys = local.map((p) => p[1]);
+	return {
+		xMin: Math.min(...xs),
+		xMax: Math.max(...xs),
+		yMin: Math.min(...ys),
+		yMax: Math.max(...ys)
+	};
+}
+/** Out-of-bounds message, or undefined if the whole outline lies inside the region. */
+function checkInBounds(b, ext) {
+	if (b.xMin < -1e-6 || b.xMax > ext.uMax + EPS$5 || b.yMin < -1e-6 || b.yMax > ext.vMax + EPS$5) return `cutout extent [${b.xMin.toFixed(3)}, ${b.xMax.toFixed(3)}]×[${b.yMin.toFixed(3)}, ${b.yMax.toFixed(3)}] lies outside region extent [0,${ext.uMax}]×[0,${ext.vMax}]`;
 }
 /**
-* Build the 3D cut tool: the local loop placed onto the region's bottom surface
-* (`origin + x·u + y·v − HAIR·n`), turned into a face, and extruded through the
-* sheet by `thickness + 2·HAIR` along +n. Using the world frame's `u`/`v`/`n` is
-* what lands the cut on the correct folded face.
+* Build the 3D cut tool on the region's bottom surface, a hair below it
+* (`origin + x·u + y·v − HAIR·n`), through the sheet by `thickness + 2·HAIR` along
+* +n. Using the world frame's `u`/`v`/`n` is what lands the cut on the correct
+* folded face. A hole is a true cylinder and an obround slot has true arcs, so a
+* round cutout adds one or two curved faces to the solid, not one planar face for
+* each segment of its developed loop. Intermediate shapes go to `scope`.
 */
-function buildTool(local, f, thickness) {
+function buildTool(spec, local, f, thickness, scope) {
 	const base = vecAdd(f.origin, vecScale(f.n, -.05));
-	const worldPts = local.map(([x, y]) => vecAdd(vecAdd(base, vecScale(f.u, x)), vecScale(f.v, y)));
-	const edges = [];
-	for (let i = 0; i < worldPts.length; i += 1) {
-		const a = worldPts[i];
-		const b = worldPts[(i + 1) % worldPts.length];
-		if (a === void 0 || b === void 0) return err(validationError("CUTOUT_TOOL_FAILED", "failed to index cutout loop points"));
-		edges.push(line(a, b));
-	}
+	const toWorld = ([x, y]) => vecAdd(vecAdd(base, vecScale(f.u, x)), vecScale(f.v, y));
+	const depth = thickness + 2 * HAIR$1;
+	if (spec.kind === "hole") return ok(cylinder(spec.diameter / 2, depth, {
+		at: toWorld([spec.x, spec.y]),
+		axis: f.n
+	}));
+	const edges = spec.kind === "slot" && spec.round === true ? obroundEdges(spec, toWorld) : polylineEdges(local, toWorld);
+	for (const e of edges) scope.register(e);
 	const wire = wireLoop(edges);
 	if (!wire.ok) return wire;
+	scope.register(wire.value);
 	if (!isPlanarWire(wire.value)) return err(validationError("CUTOUT_TOOL_FAILED", "cutout profile wire is not planar"));
 	const profile = face(wire.value);
 	if (!profile.ok) return profile;
-	const depth = thickness + 2 * HAIR$1;
+	scope.register(profile.value);
 	return extrude(profile.value, [
 		f.n[0] * depth,
 		f.n[1] * depth,
 		f.n[2] * depth
 	]);
 }
-/** Developed-plane {@link Frame2} of a region (base or flange) via the unfold layout. */
-function developedFrame(part, regionId, tree) {
-	const treeResult = tree !== void 0 ? ok(tree) : featureTree(part);
-	if (!treeResult.ok) return treeResult;
-	const layout = layoutTree(part, treeResult.value, part.baseLength, part.width);
-	if (!layout.ok) return layout;
-	const placed = layout.value.flats.find((p) => p.id === regionId);
+function polylineEdges(local, toWorld) {
+	const pts = local.map(toWorld);
+	return pts.map((a, i) => line(a, pts[(i + 1) % pts.length] ?? a));
+}
+/**
+* Edges of an obround slot: two straight sides joined by two semicircles of radius
+* `width/2`. A slot as wide as it is long has no straight side, so it is two
+* semicircles (a circle).
+*/
+function obroundEdges(spec, toWorld) {
+	const hw = spec.width / 2;
+	const straight = Math.max(spec.length / 2 - hw, 0);
+	const rad = (spec.angleDeg ?? 0) * Math.PI / 180;
+	const c = Math.cos(rad);
+	const s = Math.sin(rad);
+	const at = (x, y) => toWorld([spec.x + x * c - y * s, spec.y + x * s + y * c]);
+	const rightBottom = at(straight, -hw);
+	const rightTop = at(straight, hw);
+	const leftTop = at(-straight, hw);
+	const leftBottom = at(-straight, -hw);
+	const edges = [threePointArc(rightBottom, at(straight + hw, 0), rightTop)];
+	if (straight > EPS$5) edges.push(line(rightTop, leftTop));
+	edges.push(threePointArc(leftTop, at(-straight - hw, 0), leftBottom));
+	if (straight > EPS$5) edges.push(line(leftBottom, rightBottom));
+	return edges;
+}
+/** Developed-plane {@link Frame2} of a region (base or flange) in the unfold layout. */
+function developedFrame(layout, regionId) {
+	const placed = layout.flats.find((p) => p.id === regionId);
 	if (placed === void 0) return err(validationError("UNKNOWN_REGION", `developedFrame: region '${regionId}' missing from layout`));
 	return ok(placed.frame);
 }
@@ -4211,22 +4334,17 @@ function foldWithWarnings(input) {
 		if (!relieved.ok) return relieved;
 		part = relieved.value;
 	}
-	for (const spec of input.baseCutouts ?? []) {
-		const cutResult = addCutout(part, {
-			...spec,
-			region: ROOT_FLAT_ID
-		});
-		if (!cutResult.ok) return cutResult;
-		part = cutResult.value;
-	}
-	for (const region of input.regions) for (const spec of region.cutouts ?? []) {
-		const cutResult = addCutout(part, {
-			...spec,
-			region: region.id
-		});
-		if (!cutResult.ok) return cutResult;
-		part = cutResult.value;
-	}
+	const cutoutSpecs = (input.baseCutouts ?? []).map((spec) => ({
+		...spec,
+		region: ROOT_FLAT_ID
+	}));
+	for (const region of input.regions) for (const spec of region.cutouts ?? []) cutoutSpecs.push({
+		...spec,
+		region: region.id
+	});
+	const cutResult = addCutouts(part, cutoutSpecs);
+	if (!cutResult.ok) return cutResult;
+	part = cutResult.value;
 	for (const spec of input.baseTabs ?? []) {
 		const tabbed = addTab(part, {
 			...spec,
@@ -7103,6 +7221,10 @@ function relieveCorner(part, flangeIdA, flangeIdB, spec) {
 function addCutout$1(part, spec) {
 	return addCutout(part, spec);
 }
+/** Punch many cutouts in one boolean cut. Use this for a pattern of cutouts. */
+function addCutouts$1(part, specs) {
+	return addCutouts(part, specs);
+}
 /** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
 function addHole$1(part, region, x, y, diameter) {
 	return addHole(part, region, x, y, diameter);
@@ -7265,6 +7387,10 @@ var SheetMetalPartHandle = class SheetMetalPartHandle {
 	cutout(spec) {
 		return new SheetMetalPartHandle(unwrapOrThrow(addCutout$1(this.part, spec)));
 	}
+	/** Punch many cutouts in one boolean cut. Use this for a pattern of cutouts. */
+	cutouts(specs) {
+		return new SheetMetalPartHandle(unwrapOrThrow(addCutouts$1(this.part, specs)));
+	}
 	/** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
 	hole(region, x, y, diameter) {
 		return new SheetMetalPartHandle(unwrapOrThrow(addHole$1(this.part, region, x, y, diameter)));
@@ -7420,6 +7546,9 @@ var SheetMetalBuilder = class SheetMetalBuilder {
 	cutout(spec) {
 		return this.build().cutout(spec);
 	}
+	cutouts(specs) {
+		return this.build().cutouts(specs);
+	}
 	hole(region, x, y, diameter) {
 		return this.build().hole(region, x, y, diameter);
 	}
@@ -7489,4 +7618,4 @@ function foldFlat(input) {
 function fromSolid(solid, opts) {
 	return new ForeignSolidHandle(solid, opts);
 }
-export { ALUMINUM_GAUGES, DEFAULT_K_FACTOR, ForeignSolidHandle, MATERIALS, ROOT_FLAT_ID, STEEL_GAUGES, SheetMetalBuilder, SheetMetalError, SheetMetalPartHandle, addBendRelief, addBendTable, addCutout, addForm, addHole, addPolygonCutout, addSlot, addTab, allowance, author, authorContourFlange, authorLoftedFlange, authorPart, autoBendReliefs, autoMiterCorner, autoReliefs, baseEdgeRef, bendAllowance, bendRelief, bendTable, buildFeatureGraph, buildFeatureTree, buildReport, contourFlange, cornerRelief, developed, developedLength, emboss, featureTree, fitCylinder, flatPatternToDXF, flatPatternToPolylines, fold, foldFlat, fold$1 as foldPart, foldWithWarnings, fromPart, fromSolid, getBendTable, getMaterial, hem, jog, loftedFlange, louver, miter, miterCorner, miterCut, multiPatternToDXF, nest, nestToDXF, neutralRadius, partToFlatInput, patternBbox, patternToFlatInput, pointInPolygon, polygonBounds, polygonsOverlap, polygonsOverlapWithClearance, registerBendTable, relieveCorner, report, reportFrom, reportFromUnfold, reportJSON, reportToJSON, resolveAllowance, resolveBendAllowance, segmentsIntersect, sheetMetal, signedArea, tabAndSlot, toDXF, transformPolygon, unfold, unfoldForeignSolid, unfold$1 as unfoldPart, unfoldSolid, validate, validatePart, wireToPolygon };
+export { ALUMINUM_GAUGES, DEFAULT_K_FACTOR, ForeignSolidHandle, MATERIALS, ROOT_FLAT_ID, STEEL_GAUGES, SheetMetalBuilder, SheetMetalError, SheetMetalPartHandle, addBendRelief, addBendTable, addCutout, addCutouts, addForm, addHole, addPolygonCutout, addSlot, addTab, allowance, author, authorContourFlange, authorLoftedFlange, authorPart, autoBendReliefs, autoMiterCorner, autoReliefs, baseEdgeRef, bendAllowance, bendRelief, bendTable, buildFeatureGraph, buildFeatureTree, buildReport, contourFlange, cornerRelief, developed, developedLength, emboss, featureTree, fitCylinder, flatPatternToDXF, flatPatternToPolylines, fold, foldFlat, fold$1 as foldPart, foldWithWarnings, fromPart, fromSolid, getBendTable, getMaterial, hem, jog, loftedFlange, louver, miter, miterCorner, miterCut, multiPatternToDXF, nest, nestToDXF, neutralRadius, partToFlatInput, patternBbox, patternToFlatInput, pointInPolygon, polygonBounds, polygonsOverlap, polygonsOverlapWithClearance, registerBendTable, relieveCorner, report, reportFrom, reportFromUnfold, reportJSON, reportToJSON, resolveAllowance, resolveBendAllowance, segmentsIntersect, sheetMetal, signedArea, tabAndSlot, toDXF, transformPolygon, unfold, unfoldForeignSolid, unfold$1 as unfoldPart, unfoldSolid, validate, validatePart, wireToPolygon };

package/dist/cutoutFns.d.ts

@@ -12,8 +12,18 @@ type Pt2 = [number, number];
  * mapped through the region's developed {@link Frame2} and recorded as a
  * {@link CutoutFeature}, so {@link unfold} emits the matching loop in the flat
  * pattern and {@link fold} can replay it. Guards a valid, single-bodied solid.
+ *
+ * Each call is one boolean cut on a solid that the cut before it made larger. For
+ * a pattern of cutouts, {@link addCutouts} makes one cut for all of them.
  */
 export declare function addCutout(part: SheetMetalPart, spec: CutoutSpec): Result<SheetMetalPart>;
+/**
+ * Punch many cutouts in one boolean cut. The result is the same part that a chain
+ * of {@link addCutout} calls gives, with the features recorded in `specs` order,
+ * but the cost does not grow with the square of the count. A spec that fails
+ * validation fails the whole call, and no cutout is made.
+ */
+export declare function addCutouts(part: SheetMetalPart, specs: readonly CutoutSpec[]): Result<SheetMetalPart>;
 /** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
 export declare function addHole(part: SheetMetalPart, region: string, x: number, y: number, diameter: number): Result<SheetMetalPart>;
 /** Punch a slot centred at `(x, y)`: `length` along the slot axis by `width` across. */

package/dist/facade.d.ts

@@ -24,6 +24,8 @@ declare class SheetMetalPartHandle {
     cornerRelief(flangeIdA: string, flangeIdB: string, spec?: ReliefSpec): SheetMetalPartHandle;
     /** Punch a cutout (hole / slot / polygon) through a named flat region. */
     cutout(spec: CutoutSpec): SheetMetalPartHandle;
+    /** Punch many cutouts in one boolean cut. Use this for a pattern of cutouts. */
+    cutouts(specs: readonly CutoutSpec[]): SheetMetalPartHandle;
     /** Punch a circular hole of `diameter` centred at region-local `(x, y)`. */
     hole(region: string, x: number, y: number, diameter: number): SheetMetalPartHandle;
     /** Punch a slot (rectangular or obround) centred at region-local `(x, y)`. */
@@ -123,6 +125,7 @@ declare class SheetMetalBuilder {
     autoReliefs(spec?: ReliefSpec): SheetMetalPartHandle;
     cornerRelief(flangeIdA: string, flangeIdB: string, spec?: ReliefSpec): SheetMetalPartHandle;
     cutout(spec: CutoutSpec): SheetMetalPartHandle;
+    cutouts(specs: readonly CutoutSpec[]): SheetMetalPartHandle;
     hole(region: string, x: number, y: number, diameter: number): SheetMetalPartHandle;
     slot(region: string, opts: {
         x: number;

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export type { AuthorSpec, BaseFlatSpec, FlangeSpec, FlangeSide, SeamSpec, } from
 export { miterCut, autoMiterCorner } from './miterFns.js';
 export type { MiterPlane } from './miterFns.js';
 export { addBendRelief, autoBendReliefs, cornerRelief } from './reliefFns.js';
-export { addCutout, addHole, addSlot, addPolygonCutout } from './cutoutFns.js';
+export { addCutout, addCutouts, addHole, addSlot, addPolygonCutout } from './cutoutFns.js';
 export { addTab, tabAndSlot } from './tabFns.js';
 export type { SlotPlacement } from './tabFns.js';
 export { addForm, louver, emboss } from './formFns.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs-sheetmetal",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "Sheet-metal CAD domain for brepjs — flange authoring, auto-miter, fold/unfold flat patterns",
   "keywords": [
     "sheet-metal",