brepjs-sheetmetal 0.4.0 → 0.4.2

package/README.md

@@ -300,13 +300,20 @@ authored path. It reads only the B-rep:
   other surface type (cone, sphere, spline, …) is reported `UNSUPPORTED_FACE` and skipped (the unfold never
   silently invents a flat for an unrecognised face).
 - **Pair flats**: the two large parallel planar faces of a panel, a sheet thickness apart, are the
-  mid-surface flat. Thickness is detected as the smallest opposed-planar-pair gap.
+  mid-surface flat. Two antiparallel faces count as opposed only when they face each other (an interior
+  point of one projects inside the other), so a flange's end cap and the adjacent flange's inner face, a
+  bend radius apart across a corner, never pair. Thickness is detected as the smallest opposed-planar-pair
+  gap.
 - **Fit bends**: `fitCylinder(face)` recovers a bend's axis + radius + swept angle from sampled points and
   normals. The axis direction is the common perpendicular of the sampled normals (every cylinder normal is
   ⟂ the axis), recovered as the sign-aligned average of cross products of non-parallel normal pairs; the
-  axis line and radius come from a least-squares circle fit of the points projected onto the plane ⟂ axis;
-  the radius is the mean point-to-axis distance. A fit whose residual exceeds tolerance is rejected (warned).
-  Recovery is high-precision: radius and axis of a known `cylinder()` primitive are recovered to ~1e-6.
+  axis line and radius come from a least-squares circle fit of the points projected onto the plane ⟂ axis,
+  taken relative to their centroid so a part a metre from the origin fits as precisely as one at it; the
+  radius is the mean point-to-axis distance. A fit whose residual exceeds tolerance is rejected (warned).
+  Recovery is high-precision: radius and axis of a known `cylinder()` primitive are recovered to ~1e-6. A
+  bend's inner and outer faces pair only when they share an axis line, differ in radius by the sheet
+  thickness, and overlap along the axis, so matching corner rounds or holes on two parallel walls stay
+  apart.
 - **Build the bend graph** (flats = nodes; a bend connects the two flats it shares edges with), take a
   spanning tree from a root flat, and turn non-tree bends into seam cuts (`SEAM_CUT`, warned).
 - **Unfold** by walking the tree, replacing each cylindrical region with a developed strip of length
@@ -320,8 +327,10 @@ non-uniform thickness, conical/spline bend faces, non-manifold / non-sheet topol
 fit a cylinder within tolerance all surface as warnings inside the `Ok` payload (or a clear `Err` when no
 sheet-metal structure is detected at all, e.g. a bare sphere). The detection is validated by an oracle:
 author a part, take only its `.solid`, run `unfoldSolid`, and confirm the detected unfold reproduces the
-authored unfold's developed area, bend count, flat count, and total flat bbox (single bend, L-bracket,
-U-channel), reading only the solid, never the feature tree.
+authored unfold's developed area, bend count, flat count, and total flat bbox with no warnings (single bend,
+L-bracket, U-channel, and four-sided tray at thicknesses 1, 1.5, 2, and 3 against a 2 mm inner radius: as
+authored, with each side of the bent profile merged into one face as most CAD exports carry it, and placed a
+metre from the origin as parts in an assembly export are), reading only the solid, never the feature tree.
 
 ## Bend tables
 

package/dist/brepjs-sheetmetal.cjs

@@ -1286,6 +1286,61 @@ function reportFromLayout(layout) {
 		totalFlatSize: [maxX - minX, maxY - minY]
 	};
 }
+// \0@oxc-project+runtime@0.155.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
 // src/foreignUnfoldFns.ts
 /** Default neutral-axis K-factor for a purely geometric unfold (mid-surface). */
 var DEFAULT_FOREIGN_K = .5;
@@ -1338,15 +1393,20 @@ function fitCylinder(face) {
 	const axisDir = axisFromNormals(samples.map((s) => s.normal));
 	if (axisDir === null) return null;
 	const basis = perpBasis(axisDir);
-	const pts2 = samples.map((s) => [(0, brepjs.vecDot)(s.point, basis.e1), (0, brepjs.vecDot)(s.point, basis.e2)]);
-	const circle = fitCircle2(pts2);
-	if (circle === null) return null;
-	const axial = (0, brepjs.vecDot)(samples[0]?.point ?? [
+	let centroid = [
 		0,
 		0,
 		0
-	], axisDir);
-	const axisOrigin = (0, brepjs.vecAdd)((0, brepjs.vecAdd)((0, brepjs.vecScale)(basis.e1, circle.cx), (0, brepjs.vecScale)(basis.e2, circle.cy)), (0, brepjs.vecScale)(axisDir, axial));
+	];
+	for (const s of samples) centroid = (0, brepjs.vecAdd)(centroid, s.point);
+	centroid = (0, brepjs.vecScale)(centroid, 1 / samples.length);
+	const pts2 = samples.map((s) => {
+		const d = (0, brepjs.vecSub)(s.point, centroid);
+		return [(0, brepjs.vecDot)(d, basis.e1), (0, brepjs.vecDot)(d, basis.e2)];
+	});
+	const circle = fitCircle2(pts2);
+	if (circle === null) return null;
+	const axisOrigin = (0, brepjs.vecAdd)(centroid, (0, brepjs.vecAdd)((0, brepjs.vecScale)(basis.e1, circle.cx), (0, brepjs.vecScale)(basis.e2, circle.cy)));
 	let sumR = 0;
 	for (const s of samples) sumR += distanceToAxis(s.point, axisOrigin, axisDir);
 	const radius = sumR / samples.length;
@@ -1596,12 +1656,13 @@ function unfoldForeignSolid(solid, opts) {
 			message: `UNSUPPORTED_FACE: surface type '${t.value}' is not a planar panel or cylindrical bend; the unfold ignores it and may be incomplete`
 		});
 	}
-	const thicknessResult = detectThickness(planarFaces);
+	const planar = planarFaces.map(describePlanar);
+	const thicknessResult = detectThickness(planar);
 	if (!thicknessResult.ok) return thicknessResult;
 	const thickness = thicknessResult.value;
-	const flats = pairFlats(planarFaces, thickness, warnings);
+	const flats = pairFlats(planar, thickness, warnings);
 	if (flats.length === 0) return (0, brepjs.err)((0, brepjs.validationError)("NO_FLATS", "no planar panel pairs detected; not a recognizable sheet-metal solid"));
-	const layout = layoutForeign(flats, buildBendGraph(flats, pairBends(cylFaces, warnings), warnings), thickness, kFactor, warnings);
+	const layout = layoutForeign(flats, buildBendGraph(flats, pairBends(cylFaces, thickness, warnings), warnings), thickness, kFactor, warnings);
 	if (!layout.ok) return layout;
 	return (0, brepjs.ok)({
 		pattern: layout.value.pattern,
@@ -1609,73 +1670,116 @@ function unfoldForeignSolid(solid, opts) {
 		warnings
 	});
 }
+function describePlanar(face) {
+	const center = (0, brepjs.faceCenter)(face);
+	const n = 4;
+	const candidates = [center];
+	for (let i = 0; i < n; i += 1) for (let j = 0; j < n; j += 1) candidates.push((0, brepjs.pointOnSurface)(face, (i + .5) / n, (j + .5) / n));
+	const interior = candidates.filter((p) => liesOnFace(face, p));
+	return {
+		face,
+		normal: faceNormal(face),
+		center,
+		interior
+	};
+}
+/** 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));
+		const d = (0, brepjs.measureDistance)(probe, face);
+		return d.ok && d.value < GEOM_TOL;
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+/** Normal-direction gap between two planar faces, or `null` unless they are antiparallel. */
+function antiparallelGap(a, b) {
+	if ((0, brepjs.vecDot)(a.normal, b.normal) > -.99) return null;
+	return Math.abs((0, brepjs.vecDot)((0, brepjs.vecSub)(b.center, a.center), a.normal));
+}
+/**
+* Antiparallel faces are the two sides of one panel only if they face each other:
+* an interior point of one projects inside the other. The normal-direction gap
+* alone also matches faces that merely sit on parallel planes, e.g. a flange's end
+* cap and the adjacent flange's inner face across a corner. Their gap is the bend's
+* inner radius, which passes for the sheet thickness as T approaches or exceeds R.
+*/
+function facesOppose(a, b) {
+	return b.interior.some((p) => liesOnFace(a.face, projectToPlane(p, a.normal, a.center))) || a.interior.some((p) => liesOnFace(b.face, projectToPlane(p, b.normal, b.center)));
+}
 /**
-* Detect the sheet thickness as the smallest gap between an antiparallel pair of
-* planar faces (the two faces of one flat panel). For a roughly-uniform-thickness
-* part this gap is the same across panels; a spread beyond tolerance warns.
+* Detect the sheet thickness as the smallest gap between two antiparallel planar
+* faces that oppose each other (the two faces of one flat panel).
 */
 function detectThickness(planar) {
-	const gaps = [];
+	const pairs = [];
 	for (let i = 0; i < planar.length; i += 1) for (let j = i + 1; j < planar.length; j += 1) {
-		const fa = planar[i];
-		const fb = planar[j];
-		if (fa === void 0 || fb === void 0) continue;
-		const na = faceNormal(fa);
-		const nb = faceNormal(fb);
-		if ((0, brepjs.vecDot)(na, nb) > -.99) continue;
-		const ca = (0, brepjs.faceCenter)(fa);
-		const cb = (0, brepjs.faceCenter)(fb);
-		const gap = Math.abs((0, brepjs.vecDot)((0, brepjs.vecSub)(cb, ca), na));
-		if (gap > GEOM_TOL) gaps.push(gap);
+		const a = planar[i];
+		const b = planar[j];
+		if (a === void 0 || b === void 0) continue;
+		const gap = antiparallelGap(a, b);
+		if (gap !== null && gap > GEOM_TOL) pairs.push({
+			gap,
+			a,
+			b
+		});
 	}
-	if (gaps.length === 0) return (0, brepjs.err)((0, brepjs.validationError)("NO_THICKNESS", "could not detect a sheet thickness (no opposed planar pair)"));
-	gaps.sort((a, b) => a - b);
-	return (0, brepjs.ok)(gaps[0]);
+	pairs.sort((p, q) => p.gap - q.gap);
+	const thinnest = pairs.find((p) => facesOppose(p.a, p.b));
+	if (thinnest === void 0) return (0, brepjs.err)((0, brepjs.validationError)("NO_THICKNESS", "could not detect a sheet thickness (no opposed planar pair)"));
+	return (0, brepjs.ok)(thinnest.gap);
+}
+/** Unused face opposing `a` whose gap is nearest the sheet thickness, within tolerance. */
+function bestOpposedPartner(planar, i, thickness, used) {
+	const a = planar[i];
+	if (a === void 0) return null;
+	const candidates = [];
+	for (let j = 0; j < planar.length; j += 1) {
+		const b = planar[j];
+		if (j === i || used.has(j) || b === void 0) continue;
+		const gap = antiparallelGap(a, b);
+		if (gap === null) continue;
+		const e = Math.abs(gap - thickness);
+		if (e <= thickness * .5 + GEOM_TOL) candidates.push({
+			j,
+			e
+		});
+	}
+	candidates.sort((p, q) => p.e - q.e);
+	const match = candidates.find((c) => {
+		const b = planar[c.j];
+		return b !== void 0 && facesOppose(a, b);
+	});
+	return match === void 0 ? null : match.j;
 }
 /**
-* Pair planar faces into flat panels: each panel is two parallel faces a
-* `thickness` apart with overlapping footprints. Greedy nearest-match by gap.
+* Pair planar faces into flat panels: each panel is two antiparallel faces a
+* `thickness` apart that oppose each other. Greedy nearest-match by gap.
 */
 function pairFlats(planar, thickness, warnings) {
 	const used = /* @__PURE__ */ new Set();
 	const flats = [];
 	for (let i = 0; i < planar.length; i += 1) {
 		if (used.has(i)) continue;
-		const fa = planar[i];
-		if (fa === void 0) continue;
-		const na = faceNormal(fa);
-		const ca = (0, brepjs.faceCenter)(fa);
-		let best = -1;
-		let bestErr = Infinity;
-		for (let j = 0; j < planar.length; j += 1) {
-			if (j === i || used.has(j)) continue;
-			const fb = planar[j];
-			if (fb === void 0) continue;
-			const nb = faceNormal(fb);
-			if ((0, brepjs.vecDot)(na, nb) > -.99) continue;
-			const cb = (0, brepjs.faceCenter)(fb);
-			const gap = Math.abs((0, brepjs.vecDot)((0, brepjs.vecSub)(cb, ca), na));
-			const e = Math.abs(gap - thickness);
-			if (e < bestErr) {
-				bestErr = e;
-				best = j;
-			}
-		}
-		if (best < 0 || bestErr > thickness * .5 + GEOM_TOL) {
-			const db = (0, brepjs.getBounds)(fa);
-			const ext = [
-				db.xMax - db.xMin,
-				db.yMax - db.yMin,
-				db.zMax - db.zMin
-			].sort((p, q) => q - p);
-			const inPlaneMin = ext[1] ?? 0;
-			if (inPlaneMin > thickness * 4) warnings.push({
+		const pa = planar[i];
+		if (pa === void 0) continue;
+		const fa = pa.face;
+		const best = bestOpposedPartner(planar, i, thickness, used);
+		if (best === null) {
+			const size = inPlaneSize(fa);
+			if (size.short > thickness * 4) warnings.push({
 				code: "DETECTION_INCOMPLETE",
-				message: `a panel-sized planar face (${(ext[0] ?? 0).toFixed(1)}×${inPlaneMin.toFixed(1)}) has no opposite face at the sheet thickness ${thickness.toFixed(3)}; omitted (possible non-uniform thickness)`
+				message: `a panel-sized planar face (${size.long.toFixed(1)}×${size.short.toFixed(1)}) has no opposite face at the sheet thickness ${thickness.toFixed(3)}; omitted (possible non-uniform thickness)`
 			});
 			continue;
 		}
-		const fb = planar[best];
+		const pb = planar[best];
+		if (pb === void 0) continue;
+		const fb = pb.face;
 		used.add(i);
 		used.add(best);
 		const areaA = (0, brepjs.measureArea)(fa);
@@ -1698,8 +1802,8 @@ function pairFlats(planar, thickness, warnings) {
 		flats.push({
 			id: `flat-${flats.length}`,
 			faces: [fa, fb],
-			normal: na,
-			center: (0, brepjs.vecScale)((0, brepjs.vecAdd)(ca, (0, brepjs.faceCenter)(fb)), .5),
+			normal: pa.normal,
+			center: (0, brepjs.vecScale)((0, brepjs.vecAdd)(pa.center, pb.center), .5),
 			area
 		});
 	}
@@ -1710,10 +1814,61 @@ function pairFlats(planar, thickness, warnings) {
 	return flats;
 }
 /**
+* In-plane size of a planar face: the sides of the rectangle with the same area
+* and perimeter. Unlike a world-axis bounding box it ignores orientation, and a
+* strip of width w along any path (a merged side face tracing the whole bent
+* profile) measures w wide.
+*/
+function inPlaneSize(face) {
+	const area = (0, brepjs.measureArea)(face);
+	let perimeter = 0;
+	let measured = area.ok;
+	for (const edge of (0, brepjs.getEdges)(face)) {
+		const len = (0, brepjs.measureLength)(edge);
+		if (len.ok) perimeter += len.value;
+		else measured = false;
+	}
+	if (!measured || !area.ok) {
+		const b = (0, brepjs.getBounds)(face);
+		const ext = [
+			b.xMax - b.xMin,
+			b.yMax - b.yMin,
+			b.zMax - b.zMin
+		].sort((p, q) => q - p);
+		return {
+			long: ext[0] ?? 0,
+			short: ext[1] ?? 0
+		};
+	}
+	const half = perimeter / 2;
+	const disc = half * half - 4 * area.value;
+	const short = disc > 0 ? (half - Math.sqrt(disc)) / 2 : half / 2;
+	return {
+		long: half - short,
+		short
+	};
+}
+/**
+* The inner and outer faces of one bend share an axis line, differ in radius by
+* the sheet thickness, and cover the same stretch of the axis. A shared axis line
+* alone also matches separate features that happen to line up, such as matching
+* corner rounds or holes on two parallel walls.
+*/
+function isBendMate(a, b, thickness) {
+	const axis = a.fit.axisDir;
+	if (Math.abs((0, brepjs.vecDot)(axis, b.fit.axisDir)) < .99) return false;
+	if (distanceToAxis(b.fit.axisOrigin, a.fit.axisOrigin, axis) > GEOM_TOL * 10) return false;
+	const radiusGap = Math.abs(a.fit.radius - b.fit.radius);
+	if (Math.abs(radiusGap - thickness) > thickness * .5 + GEOM_TOL) return false;
+	const ra = axialRange(a.face, axis);
+	const rb = axialRange(b.face, axis);
+	return Math.min(ra.max, rb.max) - Math.max(ra.min, rb.min) > GEOM_TOL;
+}
+/**
 * Pair cylindrical faces into bends: each bend has an inner + outer coaxial face
 * (same axis, radii a thickness apart) or, failing a pair, a single fitted face.
 */
-function pairBends(cyl, warnings) {
+function pairBends(cyl, thickness, warnings) {
 	const fitted = [];
 	for (const face of cyl) {
 		const fit = fitCylinder(face);
@@ -1739,9 +1894,7 @@ function pairBends(cyl, warnings) {
 		for (let j = i + 1; j < fitted.length; j += 1) {
 			if (used.has(j)) continue;
 			const b = fitted[j];
-			if (b === void 0) continue;
-			if (Math.abs((0, brepjs.vecDot)(a.fit.axisDir, b.fit.axisDir)) < .99) continue;
-			if (distanceToAxis(b.fit.axisOrigin, a.fit.axisOrigin, a.fit.axisDir) > GEOM_TOL * 10) continue;
+			if (b === void 0 || !isBendMate(a, b, thickness)) continue;
 			mate = j;
 			break;
 		}
@@ -1886,20 +2039,21 @@ function layoutForeign(flats, graph, thickness, kFactor, warnings) {
 		const axis = bend.fit.axisDir;
 		const span = bendSpan.get(bend) ?? bendAxialExtent(bend);
 		const placement = placeChildFlat(parentPlace, child, bend, axis, span, dev.value);
+		const bendLine = segment2(placement.bendA, placement.bendB);
+		if (bendLine === null) {
+			warnings.push({
+				code: "DETECTION_INCOMPLETE",
+				message: `bend '${bend.id}' has no length along ${parent.id} (zero span, or an axis that crosses the flat instead of lying in it); ${child.id} and the flats beyond it are left out of the layout`,
+				featureId: bend.id
+			});
+			continue;
+		}
 		placed.set(tb.child, placement.child);
 		rects.push(placement.strip);
 		rects.push(flatRect2(placement.child));
 		bendLines.push({
 			id: bend.id,
-			line: (0, brepjs.line)([
-				placement.bendA[0],
-				placement.bendA[1],
-				0
-			], [
-				placement.bendB[0],
-				placement.bendB[1],
-				0
-			]),
+			line: bendLine,
 			angleDeg: bend.angleDeg,
 			direction,
 			inward: [-placement.outDir2[0], -placement.outDir2[1]]
@@ -1916,7 +2070,8 @@ function layoutForeign(flats, graph, thickness, kFactor, warnings) {
 	}
 	const bbox = aabb2(rects);
 	const outline = buildRectOutline2(bbox);
-	const outlineWire = (0, brepjs.wireLoop)(outline);
+	if (!outline.ok) return outline;
+	const outlineWire = (0, brepjs.wireLoop)(outline.value);
 	if (!outlineWire.ok) return outlineWire;
 	const pattern = {
 		outline: outlineWire.value,
@@ -2109,8 +2264,30 @@ function aabb2(rects) {
 		y1
 	};
 }
+/** A 2D segment as an edge, or `null` when it is too short or not finite to build one. */
+function segment2(a, b) {
+	const len = Math.hypot(b[0] - a[0], b[1] - a[1]);
+	if (!Number.isFinite(len) || len < GEOM_TOL) return null;
+	return (0, brepjs.line)([
+		a[0],
+		a[1],
+		0
+	], [
+		b[0],
+		b[1],
+		0
+	]);
+}
 function buildRectOutline2(b) {
-	return [
+	const w = b.x1 - b.x0;
+	const h = b.y1 - b.y0;
+	if (![
+		b.x0,
+		b.y0,
+		b.x1,
+		b.y1
+	].every(Number.isFinite) || w < GEOM_TOL || h < GEOM_TOL) return (0, brepjs.err)((0, brepjs.validationError)("DEGENERATE_LAYOUT", `the developed outline is degenerate (${w}×${h})`));
+	return (0, brepjs.ok)([
 		(0, brepjs.line)([
 			b.x0,
 			b.y0,
@@ -2147,21 +2324,27 @@ function buildRectOutline2(b) {
 			b.y0,
 			0
 		])
-	];
+	]);
 }
-/** Axial extent of a bend (its cylindrical face span along the fitted axis). */
-function bendAxialExtent(bend) {
-	const face = bend.faces[0];
-	if (face === void 0) return 0;
-	const axis = bend.fit.axisDir;
-	const samples = sampleFace(face, 6);
+/** Range of a face's sampled points along `axis`. */
+function axialRange(face, axis) {
 	let min = Infinity;
 	let max = -Infinity;
-	for (const s of samples) {
+	for (const s of sampleFace(face, 6)) {
 		const a = (0, brepjs.vecDot)(s.point, axis);
 		min = Math.min(min, a);
 		max = Math.max(max, a);
 	}
+	return {
+		min,
+		max
+	};
+}
+/** Axial extent of a bend (its cylindrical face span along the fitted axis). */
+function bendAxialExtent(bend) {
+	const face = bend.faces[0];
+	if (face === void 0) return 0;
+	const { min, max } = axialRange(face, bend.fit.axisDir);
 	return Number.isFinite(max - min) ? max - min : 0;
 }
 /**

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, measureVolume, normalAt, ok, pointOnSurface, rotate, sharedEdges, translate, validationError, vecAdd, vecCross, vecDot, vecLength, vecNormalize, vecScale, vecSub, wire, wireLoop } from "brepjs";
+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";
 // src/materials.ts
 var DEFAULT_K_FACTOR = .44;
 function gauge(name, thickness, kFactor = DEFAULT_K_FACTOR) {
@@ -1285,6 +1285,61 @@ function reportFromLayout(layout) {
 		totalFlatSize: [maxX - minX, maxY - minY]
 	};
 }
+// \0@oxc-project+runtime@0.155.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
 // src/foreignUnfoldFns.ts
 /** Default neutral-axis K-factor for a purely geometric unfold (mid-surface). */
 var DEFAULT_FOREIGN_K = .5;
@@ -1337,15 +1392,20 @@ function fitCylinder(face) {
 	const axisDir = axisFromNormals(samples.map((s) => s.normal));
 	if (axisDir === null) return null;
 	const basis = perpBasis(axisDir);
-	const pts2 = samples.map((s) => [vecDot(s.point, basis.e1), vecDot(s.point, basis.e2)]);
-	const circle = fitCircle2(pts2);
-	if (circle === null) return null;
-	const axial = vecDot(samples[0]?.point ?? [
+	let centroid = [
 		0,
 		0,
 		0
-	], axisDir);
-	const axisOrigin = vecAdd(vecAdd(vecScale(basis.e1, circle.cx), vecScale(basis.e2, circle.cy)), vecScale(axisDir, axial));
+	];
+	for (const s of samples) centroid = vecAdd(centroid, s.point);
+	centroid = vecScale(centroid, 1 / samples.length);
+	const pts2 = samples.map((s) => {
+		const d = vecSub(s.point, centroid);
+		return [vecDot(d, basis.e1), vecDot(d, basis.e2)];
+	});
+	const circle = fitCircle2(pts2);
+	if (circle === null) return null;
+	const axisOrigin = vecAdd(centroid, vecAdd(vecScale(basis.e1, circle.cx), vecScale(basis.e2, circle.cy)));
 	let sumR = 0;
 	for (const s of samples) sumR += distanceToAxis(s.point, axisOrigin, axisDir);
 	const radius = sumR / samples.length;
@@ -1595,12 +1655,13 @@ function unfoldForeignSolid(solid, opts) {
 			message: `UNSUPPORTED_FACE: surface type '${t.value}' is not a planar panel or cylindrical bend; the unfold ignores it and may be incomplete`
 		});
 	}
-	const thicknessResult = detectThickness(planarFaces);
+	const planar = planarFaces.map(describePlanar);
+	const thicknessResult = detectThickness(planar);
 	if (!thicknessResult.ok) return thicknessResult;
 	const thickness = thicknessResult.value;
-	const flats = pairFlats(planarFaces, thickness, warnings);
+	const flats = pairFlats(planar, thickness, warnings);
 	if (flats.length === 0) return err(validationError("NO_FLATS", "no planar panel pairs detected; not a recognizable sheet-metal solid"));
-	const layout = layoutForeign(flats, buildBendGraph(flats, pairBends(cylFaces, warnings), warnings), thickness, kFactor, warnings);
+	const layout = layoutForeign(flats, buildBendGraph(flats, pairBends(cylFaces, thickness, warnings), warnings), thickness, kFactor, warnings);
 	if (!layout.ok) return layout;
 	return ok({
 		pattern: layout.value.pattern,
@@ -1608,73 +1669,116 @@ function unfoldForeignSolid(solid, opts) {
 		warnings
 	});
 }
+function describePlanar(face) {
+	const center = faceCenter(face);
+	const n = 4;
+	const candidates = [center];
+	for (let i = 0; i < n; i += 1) for (let j = 0; j < n; j += 1) candidates.push(pointOnSurface(face, (i + .5) / n, (j + .5) / n));
+	const interior = candidates.filter((p) => liesOnFace(face, p));
+	return {
+		face,
+		normal: faceNormal(face),
+		center,
+		interior
+	};
+}
+/** 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));
+		const d = measureDistance(probe, face);
+		return d.ok && d.value < GEOM_TOL;
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+/** Normal-direction gap between two planar faces, or `null` unless they are antiparallel. */
+function antiparallelGap(a, b) {
+	if (vecDot(a.normal, b.normal) > -.99) return null;
+	return Math.abs(vecDot(vecSub(b.center, a.center), a.normal));
+}
+/**
+* Antiparallel faces are the two sides of one panel only if they face each other:
+* an interior point of one projects inside the other. The normal-direction gap
+* alone also matches faces that merely sit on parallel planes, e.g. a flange's end
+* cap and the adjacent flange's inner face across a corner. Their gap is the bend's
+* inner radius, which passes for the sheet thickness as T approaches or exceeds R.
+*/
+function facesOppose(a, b) {
+	return b.interior.some((p) => liesOnFace(a.face, projectToPlane(p, a.normal, a.center))) || a.interior.some((p) => liesOnFace(b.face, projectToPlane(p, b.normal, b.center)));
+}
 /**
-* Detect the sheet thickness as the smallest gap between an antiparallel pair of
-* planar faces (the two faces of one flat panel). For a roughly-uniform-thickness
-* part this gap is the same across panels; a spread beyond tolerance warns.
+* Detect the sheet thickness as the smallest gap between two antiparallel planar
+* faces that oppose each other (the two faces of one flat panel).
 */
 function detectThickness(planar) {
-	const gaps = [];
+	const pairs = [];
 	for (let i = 0; i < planar.length; i += 1) for (let j = i + 1; j < planar.length; j += 1) {
-		const fa = planar[i];
-		const fb = planar[j];
-		if (fa === void 0 || fb === void 0) continue;
-		const na = faceNormal(fa);
-		const nb = faceNormal(fb);
-		if (vecDot(na, nb) > -.99) continue;
-		const ca = faceCenter(fa);
-		const cb = faceCenter(fb);
-		const gap = Math.abs(vecDot(vecSub(cb, ca), na));
-		if (gap > GEOM_TOL) gaps.push(gap);
+		const a = planar[i];
+		const b = planar[j];
+		if (a === void 0 || b === void 0) continue;
+		const gap = antiparallelGap(a, b);
+		if (gap !== null && gap > GEOM_TOL) pairs.push({
+			gap,
+			a,
+			b
+		});
 	}
-	if (gaps.length === 0) return err(validationError("NO_THICKNESS", "could not detect a sheet thickness (no opposed planar pair)"));
-	gaps.sort((a, b) => a - b);
-	return ok(gaps[0]);
+	pairs.sort((p, q) => p.gap - q.gap);
+	const thinnest = pairs.find((p) => facesOppose(p.a, p.b));
+	if (thinnest === void 0) return err(validationError("NO_THICKNESS", "could not detect a sheet thickness (no opposed planar pair)"));
+	return ok(thinnest.gap);
+}
+/** Unused face opposing `a` whose gap is nearest the sheet thickness, within tolerance. */
+function bestOpposedPartner(planar, i, thickness, used) {
+	const a = planar[i];
+	if (a === void 0) return null;
+	const candidates = [];
+	for (let j = 0; j < planar.length; j += 1) {
+		const b = planar[j];
+		if (j === i || used.has(j) || b === void 0) continue;
+		const gap = antiparallelGap(a, b);
+		if (gap === null) continue;
+		const e = Math.abs(gap - thickness);
+		if (e <= thickness * .5 + GEOM_TOL) candidates.push({
+			j,
+			e
+		});
+	}
+	candidates.sort((p, q) => p.e - q.e);
+	const match = candidates.find((c) => {
+		const b = planar[c.j];
+		return b !== void 0 && facesOppose(a, b);
+	});
+	return match === void 0 ? null : match.j;
 }
 /**
-* Pair planar faces into flat panels: each panel is two parallel faces a
-* `thickness` apart with overlapping footprints. Greedy nearest-match by gap.
+* Pair planar faces into flat panels: each panel is two antiparallel faces a
+* `thickness` apart that oppose each other. Greedy nearest-match by gap.
 */
 function pairFlats(planar, thickness, warnings) {
 	const used = /* @__PURE__ */ new Set();
 	const flats = [];
 	for (let i = 0; i < planar.length; i += 1) {
 		if (used.has(i)) continue;
-		const fa = planar[i];
-		if (fa === void 0) continue;
-		const na = faceNormal(fa);
-		const ca = faceCenter(fa);
-		let best = -1;
-		let bestErr = Infinity;
-		for (let j = 0; j < planar.length; j += 1) {
-			if (j === i || used.has(j)) continue;
-			const fb = planar[j];
-			if (fb === void 0) continue;
-			const nb = faceNormal(fb);
-			if (vecDot(na, nb) > -.99) continue;
-			const cb = faceCenter(fb);
-			const gap = Math.abs(vecDot(vecSub(cb, ca), na));
-			const e = Math.abs(gap - thickness);
-			if (e < bestErr) {
-				bestErr = e;
-				best = j;
-			}
-		}
-		if (best < 0 || bestErr > thickness * .5 + GEOM_TOL) {
-			const db = getBounds(fa);
-			const ext = [
-				db.xMax - db.xMin,
-				db.yMax - db.yMin,
-				db.zMax - db.zMin
-			].sort((p, q) => q - p);
-			const inPlaneMin = ext[1] ?? 0;
-			if (inPlaneMin > thickness * 4) warnings.push({
+		const pa = planar[i];
+		if (pa === void 0) continue;
+		const fa = pa.face;
+		const best = bestOpposedPartner(planar, i, thickness, used);
+		if (best === null) {
+			const size = inPlaneSize(fa);
+			if (size.short > thickness * 4) warnings.push({
 				code: "DETECTION_INCOMPLETE",
-				message: `a panel-sized planar face (${(ext[0] ?? 0).toFixed(1)}×${inPlaneMin.toFixed(1)}) has no opposite face at the sheet thickness ${thickness.toFixed(3)}; omitted (possible non-uniform thickness)`
+				message: `a panel-sized planar face (${size.long.toFixed(1)}×${size.short.toFixed(1)}) has no opposite face at the sheet thickness ${thickness.toFixed(3)}; omitted (possible non-uniform thickness)`
 			});
 			continue;
 		}
-		const fb = planar[best];
+		const pb = planar[best];
+		if (pb === void 0) continue;
+		const fb = pb.face;
 		used.add(i);
 		used.add(best);
 		const areaA = measureArea(fa);
@@ -1697,8 +1801,8 @@ function pairFlats(planar, thickness, warnings) {
 		flats.push({
 			id: `flat-${flats.length}`,
 			faces: [fa, fb],
-			normal: na,
-			center: vecScale(vecAdd(ca, faceCenter(fb)), .5),
+			normal: pa.normal,
+			center: vecScale(vecAdd(pa.center, pb.center), .5),
 			area
 		});
 	}
@@ -1709,10 +1813,61 @@ function pairFlats(planar, thickness, warnings) {
 	return flats;
 }
 /**
+* In-plane size of a planar face: the sides of the rectangle with the same area
+* and perimeter. Unlike a world-axis bounding box it ignores orientation, and a
+* strip of width w along any path (a merged side face tracing the whole bent
+* profile) measures w wide.
+*/
+function inPlaneSize(face) {
+	const area = measureArea(face);
+	let perimeter = 0;
+	let measured = area.ok;
+	for (const edge of getEdges(face)) {
+		const len = measureLength(edge);
+		if (len.ok) perimeter += len.value;
+		else measured = false;
+	}
+	if (!measured || !area.ok) {
+		const b = getBounds(face);
+		const ext = [
+			b.xMax - b.xMin,
+			b.yMax - b.yMin,
+			b.zMax - b.zMin
+		].sort((p, q) => q - p);
+		return {
+			long: ext[0] ?? 0,
+			short: ext[1] ?? 0
+		};
+	}
+	const half = perimeter / 2;
+	const disc = half * half - 4 * area.value;
+	const short = disc > 0 ? (half - Math.sqrt(disc)) / 2 : half / 2;
+	return {
+		long: half - short,
+		short
+	};
+}
+/**
+* The inner and outer faces of one bend share an axis line, differ in radius by
+* the sheet thickness, and cover the same stretch of the axis. A shared axis line
+* alone also matches separate features that happen to line up, such as matching
+* corner rounds or holes on two parallel walls.
+*/
+function isBendMate(a, b, thickness) {
+	const axis = a.fit.axisDir;
+	if (Math.abs(vecDot(axis, b.fit.axisDir)) < .99) return false;
+	if (distanceToAxis(b.fit.axisOrigin, a.fit.axisOrigin, axis) > GEOM_TOL * 10) return false;
+	const radiusGap = Math.abs(a.fit.radius - b.fit.radius);
+	if (Math.abs(radiusGap - thickness) > thickness * .5 + GEOM_TOL) return false;
+	const ra = axialRange(a.face, axis);
+	const rb = axialRange(b.face, axis);
+	return Math.min(ra.max, rb.max) - Math.max(ra.min, rb.min) > GEOM_TOL;
+}
+/**
 * Pair cylindrical faces into bends: each bend has an inner + outer coaxial face
 * (same axis, radii a thickness apart) or, failing a pair, a single fitted face.
 */
-function pairBends(cyl, warnings) {
+function pairBends(cyl, thickness, warnings) {
 	const fitted = [];
 	for (const face of cyl) {
 		const fit = fitCylinder(face);
@@ -1738,9 +1893,7 @@ function pairBends(cyl, warnings) {
 		for (let j = i + 1; j < fitted.length; j += 1) {
 			if (used.has(j)) continue;
 			const b = fitted[j];
-			if (b === void 0) continue;
-			if (Math.abs(vecDot(a.fit.axisDir, b.fit.axisDir)) < .99) continue;
-			if (distanceToAxis(b.fit.axisOrigin, a.fit.axisOrigin, a.fit.axisDir) > GEOM_TOL * 10) continue;
+			if (b === void 0 || !isBendMate(a, b, thickness)) continue;
 			mate = j;
 			break;
 		}
@@ -1885,20 +2038,21 @@ function layoutForeign(flats, graph, thickness, kFactor, warnings) {
 		const axis = bend.fit.axisDir;
 		const span = bendSpan.get(bend) ?? bendAxialExtent(bend);
 		const placement = placeChildFlat(parentPlace, child, bend, axis, span, dev.value);
+		const bendLine = segment2(placement.bendA, placement.bendB);
+		if (bendLine === null) {
+			warnings.push({
+				code: "DETECTION_INCOMPLETE",
+				message: `bend '${bend.id}' has no length along ${parent.id} (zero span, or an axis that crosses the flat instead of lying in it); ${child.id} and the flats beyond it are left out of the layout`,
+				featureId: bend.id
+			});
+			continue;
+		}
 		placed.set(tb.child, placement.child);
 		rects.push(placement.strip);
 		rects.push(flatRect2(placement.child));
 		bendLines.push({
 			id: bend.id,
-			line: line([
-				placement.bendA[0],
-				placement.bendA[1],
-				0
-			], [
-				placement.bendB[0],
-				placement.bendB[1],
-				0
-			]),
+			line: bendLine,
 			angleDeg: bend.angleDeg,
 			direction,
 			inward: [-placement.outDir2[0], -placement.outDir2[1]]
@@ -1915,7 +2069,8 @@ function layoutForeign(flats, graph, thickness, kFactor, warnings) {
 	}
 	const bbox = aabb2(rects);
 	const outline = buildRectOutline2(bbox);
-	const outlineWire = wireLoop(outline);
+	if (!outline.ok) return outline;
+	const outlineWire = wireLoop(outline.value);
 	if (!outlineWire.ok) return outlineWire;
 	const pattern = {
 		outline: outlineWire.value,
@@ -2108,8 +2263,30 @@ function aabb2(rects) {
 		y1
 	};
 }
+/** A 2D segment as an edge, or `null` when it is too short or not finite to build one. */
+function segment2(a, b) {
+	const len = Math.hypot(b[0] - a[0], b[1] - a[1]);
+	if (!Number.isFinite(len) || len < GEOM_TOL) return null;
+	return line([
+		a[0],
+		a[1],
+		0
+	], [
+		b[0],
+		b[1],
+		0
+	]);
+}
 function buildRectOutline2(b) {
-	return [
+	const w = b.x1 - b.x0;
+	const h = b.y1 - b.y0;
+	if (![
+		b.x0,
+		b.y0,
+		b.x1,
+		b.y1
+	].every(Number.isFinite) || w < GEOM_TOL || h < GEOM_TOL) return err(validationError("DEGENERATE_LAYOUT", `the developed outline is degenerate (${w}×${h})`));
+	return ok([
 		line([
 			b.x0,
 			b.y0,
@@ -2146,21 +2323,27 @@ function buildRectOutline2(b) {
 			b.y0,
 			0
 		])
-	];
+	]);
 }
-/** Axial extent of a bend (its cylindrical face span along the fitted axis). */
-function bendAxialExtent(bend) {
-	const face = bend.faces[0];
-	if (face === void 0) return 0;
-	const axis = bend.fit.axisDir;
-	const samples = sampleFace(face, 6);
+/** Range of a face's sampled points along `axis`. */
+function axialRange(face, axis) {
 	let min = Infinity;
 	let max = -Infinity;
-	for (const s of samples) {
+	for (const s of sampleFace(face, 6)) {
 		const a = vecDot(s.point, axis);
 		min = Math.min(min, a);
 		max = Math.max(max, a);
 	}
+	return {
+		min,
+		max
+	};
+}
+/** Axial extent of a bend (its cylindrical face span along the fitted axis). */
+function bendAxialExtent(bend) {
+	const face = bend.faces[0];
+	if (face === void 0) return 0;
+	const { min, max } = axialRange(face, bend.fit.axisDir);
 	return Number.isFinite(max - min) ? max - min : 0;
 }
 /**

package/package.json

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