forgecad 0.9.8 → 0.9.9

package/dist/assets/{scalar-sampling-budget-iBAeF8RM.js → scalar-sampling-budget-Bmewod18.js}

@@ -806,11 +806,11 @@ function isFinitePositive$3(value) {
 function isFiniteNonNegative(value) {
   return Number.isFinite(value) && value >= 0;
 }
-function cloneVec3$5(vec2) {
+function cloneVec3$6(vec2) {
   return [vec2[0], vec2[1], vec2[2]];
 }
 function cloneFaceAxis(vec2) {
-  return vec2 ? cloneVec3$5(vec2) : void 0;
+  return vec2 ? cloneVec3$6(vec2) : void 0;
 }
 function cloneSheetMetalModel(model) {
   if (!model) return null;
@@ -1120,8 +1120,8 @@ function lowerSheetMetalBasePlan(model, output) {
 function descriptor(name, center, normal, planar, uAxis, vAxis, semantic = "face", memberNames = [name], coplanar = planar) {
   return {
     name,
-    center: cloneVec3$5(center),
-    normal: cloneVec3$5(normal),
+    center: cloneVec3$6(center),
+    normal: cloneVec3$6(normal),
     planar,
     uAxis: cloneFaceAxis(uAxis),
     vAxis: cloneFaceAxis(vAxis),
@@ -1374,10 +1374,10 @@ function describeSheetMetalPlanarRegionFrames(model, output) {
     const size = sheetMetalPlanarRegionSize(derived, face.name);
     return {
       name: face.name,
-      center: cloneVec3$5(face.center),
-      normal: cloneVec3$5(face.normal),
-      uAxis: cloneVec3$5(face.uAxis),
-      vAxis: cloneVec3$5(face.vAxis),
+      center: cloneVec3$6(face.center),
+      normal: cloneVec3$6(face.normal),
+      uAxis: cloneVec3$6(face.uAxis),
+      vAxis: cloneVec3$6(face.vAxis),
       width: size.width,
       height: size.height,
       thickness: derived.thickness
@@ -8367,7 +8367,7 @@ function sub$7(a2, b) {
 function cross$8(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function makeEdge(name, start, end, faceName, curve) {
+function makeEdge$1(name, start, end, faceName, curve) {
   return {
     name,
     start,
@@ -8411,10 +8411,10 @@ function buildSurfaceSheetTopology(boundaries, options = {}) {
     surface: options.surface
   });
   const edges = /* @__PURE__ */ new Map();
-  edges.set("u0", makeEdge("u0", u0Start, u0End, faceName, (_a3 = options.edgeCurves) == null ? void 0 : _a3.u0));
-  edges.set("u1", makeEdge("u1", u1Start, u1End, faceName, (_b3 = options.edgeCurves) == null ? void 0 : _b3.u1));
-  edges.set("v0", makeEdge("v0", v0Start, v0End, faceName, (_c2 = options.edgeCurves) == null ? void 0 : _c2.v0));
-  edges.set("v1", makeEdge("v1", v1Start, v1End, faceName, (_d2 = options.edgeCurves) == null ? void 0 : _d2.v1));
+  edges.set("u0", makeEdge$1("u0", u0Start, u0End, faceName, (_a3 = options.edgeCurves) == null ? void 0 : _a3.u0));
+  edges.set("u1", makeEdge$1("u1", u1Start, u1End, faceName, (_b3 = options.edgeCurves) == null ? void 0 : _b3.u1));
+  edges.set("v0", makeEdge$1("v0", v0Start, v0End, faceName, (_c2 = options.edgeCurves) == null ? void 0 : _c2.v0));
+  edges.set("v1", makeEdge$1("v1", v1Start, v1End, faceName, (_d2 = options.edgeCurves) == null ? void 0 : _d2.v1));
   return { faces, edges };
 }
 function attachSurfaceSheetTopology(shape, boundaries, options = {}) {
@@ -8432,7 +8432,7 @@ function attachSurfaceSheetTopology(shape, boundaries, options = {}) {
   });
   return shape;
 }
-function cloneVec3$4(value) {
+function cloneVec3$5(value) {
   return [value[0], value[1], value[2]];
 }
 function cloneNurbsFaceTrimLoop(loop) {
@@ -8454,38 +8454,38 @@ function cloneFaceSurface(surface) {
   if (!surface) return void 0;
   switch (surface.kind) {
     case "plane":
-      return { kind: "plane", normal: cloneVec3$4(surface.normal) };
+      return { kind: "plane", normal: cloneVec3$5(surface.normal) };
     case "cylinder":
       return {
         kind: "cylinder",
-        origin: cloneVec3$4(surface.origin),
-        axis: cloneVec3$4(surface.axis),
+        origin: cloneVec3$5(surface.origin),
+        axis: cloneVec3$5(surface.axis),
         radius: surface.radius,
         height: surface.height
       };
     case "cone":
       return {
         kind: "cone",
-        origin: cloneVec3$4(surface.origin),
-        axis: cloneVec3$4(surface.axis),
+        origin: cloneVec3$5(surface.origin),
+        axis: cloneVec3$5(surface.axis),
         radiusBottom: surface.radiusBottom,
         radiusTop: surface.radiusTop,
         height: surface.height
       };
     case "sphere":
-      return { kind: "sphere", center: cloneVec3$4(surface.center), radius: surface.radius };
+      return { kind: "sphere", center: cloneVec3$5(surface.center), radius: surface.radius };
     case "torus":
       return {
         kind: "torus",
-        center: cloneVec3$4(surface.center),
-        axis: cloneVec3$4(surface.axis),
+        center: cloneVec3$5(surface.center),
+        axis: cloneVec3$5(surface.axis),
         majorRadius: surface.majorRadius,
         minorRadius: surface.minorRadius
       };
     case "ruled":
       return {
         kind: "ruled",
-        rails: surface.rails.map((rail2) => rail2.map(cloneVec3$4))
+        rails: surface.rails.map((rail2) => rail2.map(cloneVec3$5))
       };
     case "nurbs":
       return {
@@ -8498,9 +8498,9 @@ function cloneEdgeCurve(curve) {
   if (!curve) return void 0;
   switch (curve.kind) {
     case "line":
-      return { ...curve, start: cloneVec3$4(curve.start), end: cloneVec3$4(curve.end) };
+      return { ...curve, start: cloneVec3$5(curve.start), end: cloneVec3$5(curve.end) };
     case "circle":
-      return { ...curve, center: cloneVec3$4(curve.center), axis: cloneVec3$4(curve.axis) };
+      return { ...curve, center: cloneVec3$5(curve.center), axis: cloneVec3$5(curve.axis) };
     case "surfaceIso":
       return { ...curve, parameterRange: [curve.parameterRange[0], curve.parameterRange[1]] };
     case "nurbsUv":
@@ -8518,7 +8518,7 @@ function cloneEdgeCurve(curve) {
   }
 }
 function makeLineEdgeCurve(start, end, faceName) {
-  return faceName ? { kind: "line", start: cloneVec3$4(start), end: cloneVec3$4(end), faceName } : { kind: "line", start: cloneVec3$4(start), end: cloneVec3$4(end) };
+  return faceName ? { kind: "line", start: cloneVec3$5(start), end: cloneVec3$5(end), faceName } : { kind: "line", start: cloneVec3$5(start), end: cloneVec3$5(end) };
 }
 function edgeCurveFaceName(curve) {
   switch (curve.kind) {
@@ -10605,7 +10605,7 @@ async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
   const Module = (await __vitePreload(async () => {
-    const { default: __vite_default__ } = await import("./manifold-C6-sZYQN.js");
+    const { default: __vite_default__ } = await import("./manifold-BRdhoQy5.js");
     return { default: __vite_default__ };
   }, true ? [] : void 0)).default;
   performance.mark("manifold:imported");
@@ -22489,7 +22489,7 @@ function marchingTetrahedra(sdfFn, bounds, edgeLength2) {
   };
 }
 const EPS$8 = 1e-9;
-function finitePositive(value) {
+function finitePositive$1(value) {
   return Number.isFinite(value) && value > EPS$8;
 }
 function clampNonNegative(value) {
@@ -22508,7 +22508,7 @@ function distancePreservingMatrixScale(matrix) {
   const sx = length4(col0);
   const sy = length4(col1);
   const sz = length4(col2);
-  if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
+  if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
   if (Math.abs(sx - sy) > EPS$8 || Math.abs(sx - sz) > EPS$8) return null;
   if (Math.abs(dot2(col0, col1)) > EPS$8 || Math.abs(dot2(col0, col2)) > EPS$8 || Math.abs(dot2(col1, col2)) > EPS$8) return null;
   return sx;
@@ -22525,7 +22525,7 @@ function transformStepDistanceScale(step) {
       const sx = Math.abs(step.x);
       const sy = Math.abs(step.y);
       const sz = Math.abs(step.z);
-      if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
+      if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
       return Math.abs(sx - sy) <= EPS$8 && Math.abs(sx - sz) <= EPS$8 ? sx : null;
     }
   }
@@ -22565,7 +22565,7 @@ function translatedPlan(base, z2) {
   };
 }
 function offsetCylinderDimensions(plan, thickness) {
-  if (!finitePositive(plan.height)) return null;
+  if (!finitePositive$1(plan.height)) return null;
   const radiusTop = plan.radiusTop ?? plan.radius;
   const slope = (radiusTop - plan.radius) / plan.height;
   const normalScale = Math.hypot(1, slope);
@@ -22574,7 +22574,7 @@ function offsetCylinderDimensions(plan, thickness) {
   const height = zMax - zMin;
   const radiusBottom = plan.radius + thickness * (normalScale - slope);
   const offsetRadiusTop = radiusTop + thickness * (normalScale + slope);
-  if (!finitePositive(height) || radiusBottom < -EPS$8 || offsetRadiusTop < -EPS$8) return null;
+  if (!finitePositive$1(height) || radiusBottom < -EPS$8 || offsetRadiusTop < -EPS$8) return null;
   return {
     zMin,
     height,
@@ -22632,7 +22632,7 @@ function rectangleCandidatePointsFromProfile(plan) {
     case "rect": {
       const width = Math.abs(plan.width);
       const height = Math.abs(plan.height);
-      if (!finitePositive(width) || !finitePositive(height)) return null;
+      if (!finitePositive$1(width) || !finitePositive$1(height)) return null;
       const halfWidth = width / 2;
       const halfHeight = height / 2;
       const points = [
@@ -22666,7 +22666,7 @@ function rectangleFootprintFromProfile(plan) {
   const [xMin, xMax] = xs;
   const [zMin, zMax] = zs;
   if (xMin == null || xMax == null || zMin == null || zMax == null) return null;
-  if (xMin < -EPS$8 || !finitePositive(xMax) || !finitePositive(zMax - zMin)) return null;
+  if (xMin < -EPS$8 || !finitePositive$1(xMax) || !finitePositive$1(zMax - zMin)) return null;
   const hasCorner = (x2, z2) => points.some(([px2, pz2]) => sameScalar$1(px2, x2) && sameScalar$1(pz2, z2));
   if (!hasCorner(xMin, zMin) || !hasCorner(xMax, zMin) || !hasCorner(xMax, zMax) || !hasCorner(xMin, zMax)) return null;
   return {
@@ -22679,7 +22679,7 @@ function rectangleFootprintFromProfile(plan) {
 function circleFootprintFromProfile(plan) {
   if (plan.kind !== "circle") return null;
   const radius = Math.abs(plan.radius);
-  if (!finitePositive(radius)) return null;
+  if (!finitePositive$1(radius)) return null;
   const center = transformProfilePointThrough$1([0, 0], plan.transforms);
   const xPoint = transformProfilePointThrough$1([1, 0], plan.transforms);
   const yPoint = transformProfilePointThrough$1([0, 1], plan.transforms);
@@ -22688,7 +22688,7 @@ function circleFootprintFromProfile(plan) {
   const xScale = Math.hypot(xAxis[0], xAxis[1]);
   const yScale = Math.hypot(yAxis[0], yAxis[1]);
   const dot2 = xAxis[0] * yAxis[0] + xAxis[1] * yAxis[1];
-  if (!finitePositive(xScale) || !finitePositive(yScale)) return null;
+  if (!finitePositive$1(xScale) || !finitePositive$1(yScale)) return null;
   if (Math.abs(xScale - yScale) > EPS$8 || Math.abs(dot2) > EPS$8 * xScale * yScale) return null;
   return {
     center,
@@ -22701,7 +22701,7 @@ function fullCircleRevolveTorusPlan(plan, minorRadiusOffset = 0) {
   const circle2 = circleFootprintFromProfile(plan.profile);
   if (!circle2 || circle2.center[0] <= EPS$8) return null;
   const minorRadius = circle2.radius + minorRadiusOffset;
-  if (!finitePositive(minorRadius) || minorRadius >= circle2.center[0] - EPS$8) return null;
+  if (!finitePositive$1(minorRadius) || minorRadius >= circle2.center[0] - EPS$8) return null;
   return translatedPlan(
     {
       kind: "torus",
@@ -22748,7 +22748,7 @@ function offsetFullRectRevolvePlan(plan, thickness) {
   const innerRadius = rectangle.innerRadius - thickness;
   const outerRadius = rectangle.outerRadius + thickness;
   const height = rectangle.zMax - rectangle.zMin + 2 * thickness;
-  if (innerRadius < -EPS$8 || !finitePositive(outerRadius) || !finitePositive(height) || outerRadius <= innerRadius + EPS$8) return null;
+  if (innerRadius < -EPS$8 || !finitePositive$1(outerRadius) || !finitePositive$1(height) || outerRadius <= innerRadius + EPS$8) return null;
   const zCenter = (rectangle.zMin + rectangle.zMax) / 2;
   if (innerRadius <= EPS$8) {
     return translatedPlan(
@@ -22789,11 +22789,11 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
       };
     }
     case "box": {
-      if (!finitePositive(base.z)) return null;
+      if (!finitePositive$1(base.z)) return null;
       const x2 = Math.abs(base.x) + 2 * thickness;
       const y2 = Math.abs(base.y) + 2 * thickness;
       const z2 = base.z + 2 * thickness;
-      if (!finitePositive(x2) || !finitePositive(y2) || !finitePositive(z2)) return null;
+      if (!finitePositive$1(x2) || !finitePositive$1(y2) || !finitePositive$1(z2)) return null;
       return translatedPlan(
         {
           kind: "box",
@@ -22820,7 +22820,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "sphere": {
       const radius = base.radius + thickness;
-      if (!finitePositive(radius)) return null;
+      if (!finitePositive$1(radius)) return null;
       return {
         kind: "sphere",
         radius,
@@ -22829,7 +22829,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "torus": {
       const minorRadius = base.minorRadius + thickness;
-      if (!finitePositive(minorRadius) || minorRadius >= base.majorRadius - EPS$8) return null;
+      if (!finitePositive$1(minorRadius) || minorRadius >= base.majorRadius - EPS$8) return null;
       return {
         kind: "torus",
         majorRadius: base.majorRadius,
@@ -30683,17 +30683,17 @@ function emptyFaceTable() {
     blockedQueries: []
   };
 }
-function cloneVec3$3(vec2) {
+function cloneVec3$4(vec2) {
   return [vec2[0], vec2[1], vec2[2]];
 }
 function cloneFaceRefValue(face) {
   return {
     ...face,
-    normal: cloneVec3$3(face.normal),
-    center: cloneVec3$3(face.center),
+    normal: cloneVec3$4(face.normal),
+    center: cloneVec3$4(face.center),
     query: cloneFaceQueryRef(face.query),
-    uAxis: face.uAxis ? cloneVec3$3(face.uAxis) : void 0,
-    vAxis: face.vAxis ? cloneVec3$3(face.vAxis) : void 0,
+    uAxis: face.uAxis ? cloneVec3$4(face.uAxis) : void 0,
+    vAxis: face.vAxis ? cloneVec3$4(face.vAxis) : void 0,
     surface: cloneFaceSurface(face.surface),
     descendant: face.descendant ? cloneFaceDescendantMetadata(face.descendant) : void 0
   };
@@ -31548,11 +31548,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
       for (const descriptor2 of describeSheetMetalFaces(plan.model, plan.output)) {
         registerFace(table2, {
           name: descriptor2.name,
-          normal: cloneVec3$3(descriptor2.normal),
-          center: cloneVec3$3(descriptor2.center),
+          normal: cloneVec3$4(descriptor2.normal),
+          center: cloneVec3$4(descriptor2.center),
           planar: descriptor2.planar,
-          uAxis: descriptor2.uAxis ? cloneVec3$3(descriptor2.uAxis) : void 0,
-          vAxis: descriptor2.vAxis ? cloneVec3$3(descriptor2.vAxis) : void 0,
+          uAxis: descriptor2.uAxis ? cloneVec3$4(descriptor2.uAxis) : void 0,
+          vAxis: descriptor2.vAxis ? cloneVec3$4(descriptor2.vAxis) : void 0,
           query: createTrackedFaceQuery(descriptor2.name, owner),
           descendant: createFaceDescendantMetadata(descriptor2.semantic, descriptor2.memberNames, descriptor2.coplanar)
         });
@@ -31579,7 +31579,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
             baseFace.center[2] - baseFace.normal[2] * plan.thickness
           ],
           normal: [-baseFace.normal[0], -baseFace.normal[1], -baseFace.normal[2]],
-          uAxis: baseFace.uAxis ? cloneVec3$3(baseFace.uAxis) : void 0,
+          uAxis: baseFace.uAxis ? cloneVec3$4(baseFace.uAxis) : void 0,
           vAxis: baseFace.vAxis ? [-baseFace.vAxis[0], -baseFace.vAxis[1], -baseFace.vAxis[2]] : void 0,
           query: createdQuery
         });
@@ -31645,15 +31645,15 @@ function resolveShapeFaceTableInternal(plan, owner) {
       if (counterboreFloorQuery && plan.hole.counterbore) {
         registerFace(table2, {
           name: "counterbore-floor",
-          normal: cloneVec3$3(workplane.normal),
+          normal: cloneVec3$4(workplane.normal),
           center: [
             origin[0] + inward[0] * plan.hole.counterbore.depth,
             origin[1] + inward[1] * plan.hole.counterbore.depth,
             origin[2] + inward[2] * plan.hole.counterbore.depth
           ],
           planar: true,
-          uAxis: cloneVec3$3(workplane.u),
-          vAxis: cloneVec3$3(workplane.v),
+          uAxis: cloneVec3$4(workplane.u),
+          vAxis: cloneVec3$4(workplane.v),
           query: counterboreFloorQuery
         });
       }
@@ -31677,11 +31677,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
       if (floorQuery) {
         registerFace(table2, {
           name: "floor",
-          normal: cloneVec3$3(workplane.normal),
+          normal: cloneVec3$4(workplane.normal),
           center: [origin[0] + inward[0] * forward.depth, origin[1] + inward[1] * forward.depth, origin[2] + inward[2] * forward.depth],
           planar: true,
-          uAxis: cloneVec3$3(workplane.u),
-          vAxis: cloneVec3$3(workplane.v),
+          uAxis: cloneVec3$4(workplane.u),
+          vAxis: cloneVec3$4(workplane.v),
           query: floorQuery
         });
       }
@@ -31692,7 +31692,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
           normal: [-workplane.normal[0], -workplane.normal[1], -workplane.normal[2]],
           center: [origin[0] - inward[0] * reverse.depth, origin[1] - inward[1] * reverse.depth, origin[2] - inward[2] * reverse.depth],
           planar: true,
-          uAxis: cloneVec3$3(workplane.u),
+          uAxis: cloneVec3$4(workplane.u),
           vAxis: [-workplane.v[0], -workplane.v[1], -workplane.v[2]],
           query: capQuery
         });
@@ -31871,11 +31871,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
         })();
         registerFace(table2, {
           name: "floor",
-          normal: cloneVec3$3(placement.workplane.normal),
+          normal: cloneVec3$4(placement.workplane.normal),
           center: floorCenter,
           planar: true,
-          uAxis: cloneVec3$3(placement.workplane.u),
-          vAxis: cloneVec3$3(placement.workplane.v),
+          uAxis: cloneVec3$4(placement.workplane.u),
+          vAxis: cloneVec3$4(placement.workplane.v),
           query: floorQuery
         });
       }
@@ -31890,7 +31890,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
             origin[2] - depthDir[2] * reverse.depth
           ],
           planar: true,
-          uAxis: cloneVec3$3(placement.workplane.u),
+          uAxis: cloneVec3$4(placement.workplane.u),
           vAxis: [-placement.workplane.v[0], -placement.workplane.v[1], -placement.workplane.v[2]],
           query: capQuery
         });
@@ -32076,7 +32076,7 @@ function preservedShapeFaceQueries(basePlan) {
   return listShapeFaceQueries(basePlan);
 }
 const PLACEMENT_REFERENCE_KINDS = ["points", "edges", "surfaces", "objects"];
-function cloneVec3$2(value, label) {
+function cloneVec3$3(value, label) {
   if (!Array.isArray(value) || value.length < 3) {
     throw new Error(`${label} must be a [x, y, z] tuple`);
   }
@@ -32102,23 +32102,23 @@ function isBoundsObject(value) {
 function toObjectBounds(value, label) {
   if (isBoundsObject(value)) {
     return {
-      min: cloneVec3$2(value.min, `${label}.min`),
-      max: cloneVec3$2(value.max, `${label}.max`)
+      min: cloneVec3$3(value.min, `${label}.min`),
+      max: cloneVec3$3(value.max, `${label}.max`)
     };
   }
   if (typeof value === "object" && value != null) {
     if ("boundingBox" in value && typeof value.boundingBox === "function") {
       const bounds = value.boundingBox();
       return {
-        min: cloneVec3$2(bounds.min, `${label}.min`),
-        max: cloneVec3$2(bounds.max, `${label}.max`)
+        min: cloneVec3$3(bounds.min, `${label}.min`),
+        max: cloneVec3$3(bounds.max, `${label}.max`)
       };
     }
     if ("_bbox" in value && typeof value._bbox === "function") {
       const bounds = value._bbox();
       return {
-        min: cloneVec3$2(bounds.min, `${label}.min`),
-        max: cloneVec3$2(bounds.max, `${label}.max`)
+        min: cloneVec3$3(bounds.min, `${label}.min`),
+        max: cloneVec3$3(bounds.max, `${label}.max`)
       };
     }
   }
@@ -32162,24 +32162,24 @@ function createPlacementReferences() {
 function clonePlacementReferences(refs) {
   const out = createPlacementReferences();
   for (const [name, point2] of Object.entries(refs.points)) {
-    out.points[name] = cloneVec3$2(point2, `points.${name}`);
+    out.points[name] = cloneVec3$3(point2, `points.${name}`);
   }
   for (const [name, edge] of Object.entries(refs.edges)) {
     out.edges[name] = {
-      start: cloneVec3$2(edge.start, `edges.${name}.start`),
-      end: cloneVec3$2(edge.end, `edges.${name}.end`)
+      start: cloneVec3$3(edge.start, `edges.${name}.start`),
+      end: cloneVec3$3(edge.end, `edges.${name}.end`)
     };
   }
   for (const [name, surface] of Object.entries(refs.surfaces)) {
     out.surfaces[name] = {
-      center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
-      normal: cloneVec3$2(surface.normal, `surfaces.${name}.normal`)
+      center: cloneVec3$3(surface.center, `surfaces.${name}.center`),
+      normal: cloneVec3$3(surface.normal, `surfaces.${name}.normal`)
     };
   }
   for (const [name, objectRef] of Object.entries(refs.objects)) {
     out.objects[name] = {
-      min: cloneVec3$2(objectRef.min, `objects.${name}.min`),
-      max: cloneVec3$2(objectRef.max, `objects.${name}.max`)
+      min: cloneVec3$3(objectRef.min, `objects.${name}.min`),
+      max: cloneVec3$3(objectRef.max, `objects.${name}.max`)
     };
   }
   return out;
@@ -32187,18 +32187,18 @@ function clonePlacementReferences(refs) {
 function normalizePlacementReferenceInput(input = {}) {
   const out = createPlacementReferences();
   for (const [name, point2] of Object.entries(input.points ?? {})) {
-    out.points[name] = cloneVec3$2(point2, `points.${name}`);
+    out.points[name] = cloneVec3$3(point2, `points.${name}`);
   }
   for (const [name, edge] of Object.entries(input.edges ?? {})) {
     out.edges[name] = {
-      start: cloneVec3$2(edge.start, `edges.${name}.start`),
-      end: cloneVec3$2(edge.end, `edges.${name}.end`)
+      start: cloneVec3$3(edge.start, `edges.${name}.start`),
+      end: cloneVec3$3(edge.end, `edges.${name}.end`)
     };
   }
   for (const [name, surface] of Object.entries(input.surfaces ?? {})) {
     out.surfaces[name] = {
-      center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
-      normal: normalizeVector$1(cloneVec3$2(surface.normal, `surfaces.${name}.normal`))
+      center: cloneVec3$3(surface.center, `surfaces.${name}.center`),
+      normal: normalizeVector$1(cloneVec3$3(surface.normal, `surfaces.${name}.normal`))
     };
   }
   for (const [name, objectRef] of Object.entries(input.objects ?? {})) {
@@ -32209,23 +32209,23 @@ function normalizePlacementReferenceInput(input = {}) {
 function mergePlacementReferences(...refsList) {
   const out = createPlacementReferences();
   for (const refs of refsList) {
-    for (const [name, point2] of Object.entries(refs.points)) out.points[name] = cloneVec3$2(point2, `points.${name}`);
+    for (const [name, point2] of Object.entries(refs.points)) out.points[name] = cloneVec3$3(point2, `points.${name}`);
     for (const [name, edge] of Object.entries(refs.edges)) {
       out.edges[name] = {
-        start: cloneVec3$2(edge.start, `edges.${name}.start`),
-        end: cloneVec3$2(edge.end, `edges.${name}.end`)
+        start: cloneVec3$3(edge.start, `edges.${name}.start`),
+        end: cloneVec3$3(edge.end, `edges.${name}.end`)
       };
     }
     for (const [name, surface] of Object.entries(refs.surfaces)) {
       out.surfaces[name] = {
-        center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
-        normal: cloneVec3$2(surface.normal, `surfaces.${name}.normal`)
+        center: cloneVec3$3(surface.center, `surfaces.${name}.center`),
+        normal: cloneVec3$3(surface.normal, `surfaces.${name}.normal`)
       };
     }
     for (const [name, objectRef] of Object.entries(refs.objects)) {
       out.objects[name] = {
-        min: cloneVec3$2(objectRef.min, `objects.${name}.min`),
-        max: cloneVec3$2(objectRef.max, `objects.${name}.max`)
+        min: cloneVec3$3(objectRef.min, `objects.${name}.min`),
+        max: cloneVec3$3(objectRef.max, `objects.${name}.max`)
       };
     }
   }
@@ -32269,7 +32269,7 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       const point2 = refs.points[name];
       if (!point2) return null;
       if (selector != null) placementRefSelectorError(originalRef, "does not support selectors");
-      return cloneVec3$2(point2, `points.${name}`);
+      return cloneVec3$3(point2, `points.${name}`);
     }
     case "edges": {
       const edge = refs.edges[name];
@@ -32277,8 +32277,8 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       if (selector == null || selector === "midpoint" || selector === "center") {
         return midpoint$2(edge.start, edge.end);
       }
-      if (selector === "start") return cloneVec3$2(edge.start, `edges.${name}.start`);
-      if (selector === "end") return cloneVec3$2(edge.end, `edges.${name}.end`);
+      if (selector === "start") return cloneVec3$3(edge.start, `edges.${name}.start`);
+      if (selector === "end") return cloneVec3$3(edge.end, `edges.${name}.end`);
       placementRefSelectorError(originalRef, "supports only .start, .end, or .midpoint");
     }
     case "surfaces": {
@@ -32287,7 +32287,7 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       if (selector != null && selector !== "center") {
         placementRefSelectorError(originalRef, "supports only .center");
       }
-      return cloneVec3$2(surface.center, `surfaces.${name}.center`);
+      return cloneVec3$3(surface.center, `surfaces.${name}.center`);
     }
     case "objects": {
       const objectRef = refs.objects[name];
@@ -35372,7 +35372,7 @@ function attachTopologyRewritePropagation(plan, propagation) {
 }
 const DEFAULT_TOLERANCE$2 = 1;
 const DEFAULT_ANGLE_TOLERANCE = 10;
-function distSq(a2, b) {
+function distSq$1(a2, b) {
   const dx = a2[0] - b[0], dy = a2[1] - b[1], dz = a2[2] - b[2];
   return dx * dx + dy * dy + dz * dz;
 }
@@ -35464,7 +35464,7 @@ function applyFilters(edges, query) {
   }
   if (query.near) {
     const pt = query.near;
-    result = result.slice().sort((a2, b) => distSq(a2.midpoint, pt) - distSq(b.midpoint, pt));
+    result = result.slice().sort((a2, b) => distSq$1(a2.midpoint, pt) - distSq$1(b.midpoint, pt));
   }
   return result;
 }
@@ -35528,10 +35528,10 @@ function coalesceEdges(segments, tolerance = 0.01) {
 }
 function minEndpointGap(a2, b) {
   return Math.min(
-    Math.sqrt(distSq(a2.start, b.start)),
-    Math.sqrt(distSq(a2.start, b.end)),
-    Math.sqrt(distSq(a2.end, b.start)),
-    Math.sqrt(distSq(a2.end, b.end))
+    Math.sqrt(distSq$1(a2.start, b.start)),
+    Math.sqrt(distSq$1(a2.start, b.end)),
+    Math.sqrt(distSq$1(a2.end, b.start)),
+    Math.sqrt(distSq$1(a2.end, b.end))
   );
 }
 function mergeCollinearGroup(group2, index2) {
@@ -53237,11 +53237,11 @@ function inverseLerp(x2, y2, value) {
     return 0;
   }
 }
-function lerp$5(x2, y2, t) {
+function lerp$6(x2, y2, t) {
   return (1 - t) * x2 + t * y2;
 }
 function damp(x2, y2, lambda, dt) {
-  return lerp$5(x2, y2, 1 - Math.exp(-lambda * dt));
+  return lerp$6(x2, y2, 1 - Math.exp(-lambda * dt));
 }
 function pingpong(x2, length4 = 1) {
   return length4 - Math.abs(euclideanModulo(x2, length4 * 2) - length4);
@@ -53434,7 +53434,7 @@ const MathUtils = {
    * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
    * @return {number} The interpolated value.
    */
-  lerp: lerp$5,
+  lerp: lerp$6,
   /**
    * Smoothly interpolate a number from `x` to `y` in  a spring-like manner using a delta
    * time to maintain frame rate independent movement. For details, see
@@ -62388,9 +62388,9 @@ class Color {
   lerpHSL(color, alpha) {
     this.getHSL(_hslA);
     color.getHSL(_hslB);
-    const h = lerp$5(_hslA.h, _hslB.h, alpha);
-    const s = lerp$5(_hslA.s, _hslB.s, alpha);
-    const l = lerp$5(_hslA.l, _hslB.l, alpha);
+    const h = lerp$6(_hslA.h, _hslB.h, alpha);
+    const s = lerp$6(_hslA.s, _hslB.s, alpha);
+    const l = lerp$6(_hslA.l, _hslB.l, alpha);
     this.setHSL(h, s, l);
     return this;
   }
@@ -96725,7 +96725,7 @@ function scale$1(v, s) {
 function dot$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function lerp$4(a2, b, t) {
+function lerp$5(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function frameMatrix$1(x2, y2, z2, p2) {
@@ -96801,9 +96801,9 @@ function interpolateQuery(a2, b, t) {
   }
   return {
     side: sideA,
-    u: lerp$4(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$4(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$5(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$5(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$5(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 function resolvePathQueries(points) {
@@ -96928,7 +96928,7 @@ class ProductSkin {
   }
   /** Interpolate center, width, and depth at a normalized v or absolute axis value. */
   stationAt(vOrAxis) {
-    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$4(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
+    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$5(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
     const sorted = this.stations;
     for (let index2 = 0; index2 < sorted.length - 1; index2 += 1) {
       const a2 = sorted[index2];
@@ -96940,12 +96940,12 @@ class ProductSkin {
       const t = clamp$5((axisValue - aAxis) / span, 0, 1);
       return {
         axisValue,
-        center: [lerp$4(a2.center[0], b.center[0], t), lerp$4(a2.center[1], b.center[1], t), lerp$4(a2.center[2], b.center[2], t)],
-        width: lerp$4(a2.profile.width, b.profile.width, t),
-        depth: lerp$4(a2.profile.depth, b.profile.depth, t),
+        center: [lerp$5(a2.center[0], b.center[0], t), lerp$5(a2.center[1], b.center[1], t), lerp$5(a2.center[2], b.center[2], t)],
+        width: lerp$5(a2.profile.width, b.profile.width, t),
+        depth: lerp$5(a2.profile.depth, b.profile.depth, t),
         dWidth: (b.profile.width - a2.profile.width) / span,
         dDepth: (b.profile.depth - a2.profile.depth) / span,
-        exponent: lerp$4(profileExponent(a2), profileExponent(b), t),
+        exponent: lerp$5(profileExponent(a2), profileExponent(b), t),
         kind: a2.profile.kind === b.profile.kind ? a2.profile.kind : "custom"
       };
     }
@@ -97778,7 +97778,7 @@ function requirePositive$3(value, label) {
 function clamp$4(value, min2, max2) {
   return Math.max(min2, Math.min(max2, value));
 }
-function lerp$3(a2, b, t) {
+function lerp$4(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function add(a2, b) {
@@ -97828,19 +97828,19 @@ function transformLocal(point2, tangentAcross, normal, tangentAlong, x2, y2, z2
 function interpolateCylinder(a2, b, t, mode) {
   let delta = b.angle - a2.angle;
   if (mode === "shortest" && Math.abs(delta) > 180) delta -= Math.sign(delta) * 360;
-  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$3(a2.z, b.z, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$4(a2.z, b.z, t), offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolatePlane(a2, b, t) {
-  return { kind: "plane", x: lerp$3(a2.x, b.x, t), y: lerp$3(a2.y, b.y, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "plane", x: lerp$4(a2.x, b.x, t), y: lerp$4(a2.y, b.y, t), offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolateProductSkin(a2, b, t) {
   if ((a2.side ?? b.side) !== (b.side ?? a2.side)) throw new Error("SurfacePath on ProductSkin currently supports one side per path; split side transitions into separate members.");
   return {
     kind: "productSkin",
     side: a2.side ?? b.side,
-    u: lerp$3(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$3(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$4(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$4(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 class SurfacePath {
@@ -98938,7 +98938,7 @@ function counterboresForPlate(spec2, width, height, thickness, diagnostics) {
 function minWidthAcrossAlongRange(widthAtT, length4, minAlong, maxAlong) {
   let minWidth = Number.POSITIVE_INFINITY;
   for (let index2 = 0; index2 <= 8; index2 += 1) {
-    const along = lerp$3(minAlong, maxAlong, index2 / 8);
+    const along = lerp$4(minAlong, maxAlong, index2 / 8);
     const t = Math.max(0, Math.min(1, (along + length4 / 2) / Math.max(length4, 1e-8)));
     minWidth = Math.min(minWidth, widthAtT(t));
   }
@@ -99238,7 +99238,7 @@ function pathParameterAtDistance(samples, distance2) {
     const segmentLength = Math.hypot(b.point[0] - a2.point[0], b.point[1] - a2.point[1], b.point[2] - a2.point[2]);
     if (traveled + segmentLength >= distance2) {
       const localT = segmentLength <= 1e-8 ? 0 : (distance2 - traveled) / segmentLength;
-      return lerp$3(a2.t, b.t, localT);
+      return lerp$4(a2.t, b.t, localT);
     }
     traveled += segmentLength;
   }
@@ -99291,7 +99291,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], false));
     }
   }
@@ -99301,7 +99301,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], true));
     }
   }
@@ -99313,7 +99313,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex < acrossSegments; acrossIndex += 1) {
-      const across = lerp$3(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
       filled[alongIndex][acrossIndex] = !holes.some((hole2) => pointInProfileLoop([across, along], hole2));
     }
   }
@@ -101513,7 +101513,7 @@ function midpoint$1(a2, b) {
   requireVec3$1(b, "b");
   return [(a2[0] + b[0]) / 2, (a2[1] + b[1]) / 2, (a2[2] + b[2]) / 2];
 }
-function lerp$2(a2, b, t) {
+function lerp$3(a2, b, t) {
   requireVec3$1(a2, "a");
   requireVec3$1(b, "b");
   requireFiniteNumber(t, "t");
@@ -101543,7 +101543,7 @@ const Points2 = {
   /** Center point between two 3D points. */
   midpoint: midpoint$1,
   /** Linearly interpolate between two 3D points. t=0 returns a, t=1 returns b. */
-  lerp: lerp$2,
+  lerp: lerp$3,
   /** Unit direction vector from a to b. Throws if a and b are the same point. */
   direction,
   /** Move a point along a direction vector by a given amount. */
@@ -122079,7 +122079,7 @@ function railCrossAt(rail2, position) {
     const b = points[index2 + 1];
     if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
       const t = (position - a2.position) / (b.position - a2.position);
-      return [lerp$1(a2.cross[0], b.cross[0], t), lerp$1(a2.cross[1], b.cross[1], t)];
+      return [lerp$2(a2.cross[0], b.cross[0], t), lerp$2(a2.cross[1], b.cross[1], t)];
     }
   }
   throw new Error("Loft guide rail does not cover requested station position");
@@ -122117,7 +122117,7 @@ function crossPointForAxis(axis, point2) {
   if (axis === "Y") return [point2[0], -point2[2]];
   return [point2[0], point2[1]];
 }
-function lerp$1(a2, b, t) {
+function lerp$2(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function loftWithGuideRails(stations, rails, options = {}) {
@@ -122241,13 +122241,13 @@ function sketchBounds(profile) {
 }
 function lerpBounds(a2, b, t) {
   return {
-    minX: lerp(a2.minX, b.minX, t),
-    maxX: lerp(a2.maxX, b.maxX, t),
-    minY: lerp(a2.minY, b.minY, t),
-    maxY: lerp(a2.maxY, b.maxY, t)
+    minX: lerp$1(a2.minX, b.minX, t),
+    maxX: lerp$1(a2.maxX, b.maxX, t),
+    minY: lerp$1(a2.minY, b.minY, t),
+    maxY: lerp$1(a2.maxY, b.maxY, t)
   };
 }
-function lerp(a2, b, t) {
+function lerp$1(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function mapLoftPath2D(path2, label, mapper) {
@@ -341732,7 +341732,7 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
   }
 }
 const DEFAULT_LEAF_SIZE = 8;
-function cloneVec3$1(value) {
+function cloneVec3$2(value) {
   return [value[0], value[1], value[2]];
 }
 function emptyBounds() {
@@ -341800,14 +341800,14 @@ class AabbSpatialIndex {
       nodeCount += 1;
       const bounds = boundsFor(entries, indexes);
       if (indexes.length <= this.leafSize) {
-        return { min: cloneVec3$1(bounds.min), max: cloneVec3$1(bounds.max), left: null, right: null, indexes };
+        return { min: cloneVec3$2(bounds.min), max: cloneVec3$2(bounds.max), left: null, right: null, indexes };
       }
       const axis = longestAxis(bounds);
       indexes.sort((a2, b) => centerOnAxis(entries[a2], axis) - centerOnAxis(entries[b], axis) || a2 - b);
       const mid = Math.max(1, Math.floor(indexes.length / 2));
       return {
-        min: cloneVec3$1(bounds.min),
-        max: cloneVec3$1(bounds.max),
+        min: cloneVec3$2(bounds.min),
+        max: cloneVec3$2(bounds.max),
         left: build(indexes.slice(0, mid)),
         right: build(indexes.slice(mid)),
         indexes: null
@@ -341873,7 +341873,7 @@ class AabbSpatialIndex {
 const DEFAULT_COLLISION_INSPECTION_OPTIONS = {
   minOverlapVolume: 0.1
 };
-function cloneVec3(value) {
+function cloneVec3$1(value) {
   return [value[0], value[1], value[2]];
 }
 function isIdentityTransform(matrix) {
@@ -341915,8 +341915,8 @@ function prepareEntry(entry) {
   if (isIdentityTransform(entry.transform)) {
     return {
       ...entry,
-      min: cloneVec3(entry.min),
-      max: cloneVec3(entry.max)
+      min: cloneVec3$1(entry.min),
+      max: cloneVec3$1(entry.max)
     };
   }
   const bbox = transformBBox(entry.min, entry.max, entry.transform);
@@ -341935,7 +341935,7 @@ function shouldSkipPair(a2, b, options) {
   if (options.skipMockPairs && a2.mock && b.mock) return true;
   return false;
 }
-function collectCandidatePairs(entries, options) {
+function collectCandidatePairs$1(entries, options) {
   const index2 = new AabbSpatialIndex(entries, 1);
   const result = index2.overlapPairs({
     padding: options.bboxPadding,
@@ -341976,7 +341976,7 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   const warnings = [];
   const collisions = [];
   const preparedEntries = entries.map((entry) => prepareEntry(entry));
-  const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs(preparedEntries, options);
+  const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs$1(preparedEntries, options);
   const exactCandidatePairs = candidatePairs.filter((pair) => pair.bboxOverlapVolume > options.minOverlapVolume);
   const bboxVolumePrunedPairCount = candidatePairs.length - exactCandidatePairs.length;
   const limitedCandidatePairs = options.maxCandidatePairs === null ? exactCandidatePairs : exactCandidatePairs.slice(0, options.maxCandidatePairs);
@@ -342062,8 +342062,8 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
     treePath: entry.treePath,
     mock: entry.mock === true,
     bbox: {
-      min: cloneVec3(entry.min),
-      max: cloneVec3(entry.max)
+      min: cloneVec3$1(entry.min),
+      max: cloneVec3$1(entry.max)
     }
   }));
   return {
@@ -342277,6 +342277,706 @@ function geometryWithVisibleVertexColors(geometry, colors) {
   out.setAttribute("color", colorAttribute);
   return out;
 }
+const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
+  smoothAngleDeg: 5,
+  sharpAngleDeg: 30,
+  harshAngleDeg: 90,
+  maxSamplesPerObject: 5e3
+};
+const ROUGHNESS_COLORS = {
+  smooth: [62, 72, 84],
+  moderate: [255, 214, 0],
+  sharp: [255, 124, 34],
+  harsh: [255, 42, 96]
+};
+function resolveRoughnessInspectionOptions(raw = {}) {
+  const options = {
+    smoothAngleDeg: raw.smoothAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.smoothAngleDeg,
+    sharpAngleDeg: raw.sharpAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.sharpAngleDeg,
+    harshAngleDeg: raw.harshAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.harshAngleDeg,
+    maxSamplesPerObject: raw.maxSamplesPerObject ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.maxSamplesPerObject
+  };
+  if (!Number.isFinite(options.smoothAngleDeg) || options.smoothAngleDeg < 0) {
+    throw new Error(`smoothAngleDeg must be a finite non-negative angle (got ${options.smoothAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.sharpAngleDeg) || options.sharpAngleDeg <= options.smoothAngleDeg) {
+    throw new Error(`sharpAngleDeg must be greater than smoothAngleDeg (got ${options.sharpAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.harshAngleDeg) || options.harshAngleDeg <= options.sharpAngleDeg || options.harshAngleDeg > 180) {
+    throw new Error(`harshAngleDeg must be greater than sharpAngleDeg and <= 180 (got ${options.harshAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.maxSamplesPerObject) || options.maxSamplesPerObject <= 0) {
+    throw new Error(`maxSamplesPerObject must be a positive finite number (got ${options.maxSamplesPerObject}).`);
+  }
+  return {
+    ...options,
+    maxSamplesPerObject: Math.max(1, Math.floor(options.maxSamplesPerObject))
+  };
+}
+function roughnessClassForAngle(angleDeg, options) {
+  if (angleDeg >= options.harshAngleDeg) return "harsh";
+  if (angleDeg >= options.sharpAngleDeg) return "sharp";
+  if (angleDeg >= options.smoothAngleDeg) return "moderate";
+  return "smooth";
+}
+function roughnessScoreForAngle(angleDeg, options) {
+  if (angleDeg < options.sharpAngleDeg) return 0;
+  if (angleDeg < options.harshAngleDeg) {
+    return MathUtils.lerp(0.48, 0.82, (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg));
+  }
+  return 1;
+}
+function roughnessColorForAngle(angleDeg, options) {
+  const cls = roughnessClassForAngle(angleDeg, options);
+  if (cls === "smooth" || cls === "harsh") return ROUGHNESS_COLORS[cls];
+  if (cls === "moderate") {
+    return lerpRgb(
+      ROUGHNESS_COLORS.moderate,
+      ROUGHNESS_COLORS.sharp,
+      (angleDeg - options.smoothAngleDeg) / (options.sharpAngleDeg - options.smoothAngleDeg)
+    );
+  }
+  return lerpRgb(
+    ROUGHNESS_COLORS.sharp,
+    ROUGHNESS_COLORS.harsh,
+    (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg)
+  );
+}
+function lerpRgb(a2, b, t) {
+  const clamped = MathUtils.clamp(t, 0, 1);
+  return [
+    Math.round(MathUtils.lerp(a2[0], b[0], clamped)),
+    Math.round(MathUtils.lerp(a2[1], b[1], clamped)),
+    Math.round(MathUtils.lerp(a2[2], b[2], clamped))
+  ];
+}
+const AXIS_NAMES = ["x", "y", "z"];
+function nearestBoundaryGap(a2, b, axis) {
+  return Math.min(Math.abs(a2.max[axis] - b.min[axis]), Math.abs(b.max[axis] - a2.min[axis]));
+}
+function hasPositiveGap(gaps) {
+  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
+}
+function contactFromBBoxes(a2, b, tolerance) {
+  const gaps = aabbGaps(a2, b);
+  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
+  if (largestGap > tolerance) return { touching: false, gap: largestGap };
+  const separatedAxes = gaps.map((gap, axis) => ({ gap, axis })).filter((entry) => entry.gap > 0);
+  if (separatedAxes.length > 0) {
+    const nearest2 = separatedAxes.reduce((best, entry) => entry.gap > best.gap ? entry : best, separatedAxes[0]);
+    return { touching: true, gap: nearest2.gap, axis: AXIS_NAMES[nearest2.axis] };
+  }
+  const boundaryAxes = AXIS_NAMES.map((axisName, axis) => ({
+    axis,
+    axisName,
+    gap: nearestBoundaryGap(a2, b, axis)
+  })).filter((entry) => entry.gap <= tolerance);
+  if (boundaryAxes.length === 0) return { touching: false, gap: 0 };
+  const nearest = boundaryAxes.reduce((best, entry) => entry.gap < best.gap ? entry : best, boundaryAxes[0]);
+  return { touching: true, gap: nearest.gap, axis: nearest.axisName };
+}
+function isFiniteTriangle(positions, offset2) {
+  for (let index2 = 0; index2 < 9; index2 += 1) {
+    if (!Number.isFinite(positions[offset2 + index2])) return false;
+  }
+  return true;
+}
+function triangleRef(positions, offset2) {
+  if (!isFiniteTriangle(positions, offset2)) return null;
+  const ax = positions[offset2];
+  const ay = positions[offset2 + 1];
+  const az = positions[offset2 + 2];
+  const bx = positions[offset2 + 3];
+  const by = positions[offset2 + 4];
+  const bz = positions[offset2 + 5];
+  const cx = positions[offset2 + 6];
+  const cy = positions[offset2 + 7];
+  const cz = positions[offset2 + 8];
+  return {
+    offset: offset2,
+    min: [Math.min(ax, bx, cx), Math.min(ay, by, cy), Math.min(az, bz, cz)],
+    max: [Math.max(ax, bx, cx), Math.max(ay, by, cy), Math.max(az, bz, cz)]
+  };
+}
+function meshContactDataFor(entry) {
+  const positions = entry.positions;
+  if (!positions || positions.length < 9) return null;
+  const triangleCount = Math.floor(positions.length / 9);
+  const triangles = [];
+  for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
+    const triangle = triangleRef(positions, triangleIndex * 9);
+    if (triangle) triangles.push(triangle);
+  }
+  if (triangles.length === 0) return null;
+  return {
+    positions,
+    vertexCount: triangleCount * 3,
+    triangles
+  };
+}
+function distSq(px2, py2, pz2, qx, qy, qz) {
+  const dx = px2 - qx;
+  const dy = py2 - qy;
+  const dz = pz2 - qz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function pointSegmentDistanceSq(point2, start, end) {
+  const dx = end[0] - start[0];
+  const dy = end[1] - start[1];
+  const dz = end[2] - start[2];
+  const lengthSq = dx * dx + dy * dy + dz * dz;
+  if (lengthSq <= 1e-20) return distSq(point2[0], point2[1], point2[2], start[0], start[1], start[2]);
+  const t = Math.max(0, Math.min(1, ((point2[0] - start[0]) * dx + (point2[1] - start[1]) * dy + (point2[2] - start[2]) * dz) / lengthSq));
+  return distSq(point2[0], point2[1], point2[2], start[0] + t * dx, start[1] + t * dy, start[2] + t * dz);
+}
+function pointTriangleDistanceSq(px2, py2, pz2, ax, ay, az, bx, by, bz, cx, cy, cz) {
+  const abx = bx - ax;
+  const aby = by - ay;
+  const abz = bz - az;
+  const acx = cx - ax;
+  const acy = cy - ay;
+  const acz = cz - az;
+  const apx = px2 - ax;
+  const apy = py2 - ay;
+  const apz = pz2 - az;
+  const d1 = abx * apx + aby * apy + abz * apz;
+  const d2 = acx * apx + acy * apy + acz * apz;
+  if (d1 <= 0 && d2 <= 0) return distSq(px2, py2, pz2, ax, ay, az);
+  const bpx = px2 - bx;
+  const bpy = py2 - by;
+  const bpz = pz2 - bz;
+  const d3 = abx * bpx + aby * bpy + abz * bpz;
+  const d4 = acx * bpx + acy * bpy + acz * bpz;
+  if (d3 >= 0 && d4 <= d3) return distSq(px2, py2, pz2, bx, by, bz);
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+    const v22 = d1 / (d1 - d3);
+    return distSq(px2, py2, pz2, ax + v22 * abx, ay + v22 * aby, az + v22 * abz);
+  }
+  const cpx = px2 - cx;
+  const cpy = py2 - cy;
+  const cpz = pz2 - cz;
+  const d5 = abx * cpx + aby * cpy + abz * cpz;
+  const d6 = acx * cpx + acy * cpy + acz * cpz;
+  if (d6 >= 0 && d5 <= d6) return distSq(px2, py2, pz2, cx, cy, cz);
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+    const w22 = d2 / (d2 - d6);
+    return distSq(px2, py2, pz2, ax + w22 * acx, ay + w22 * acy, az + w22 * acz);
+  }
+  const va = d3 * d6 - d5 * d4;
+  if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
+    const bcx = cx - bx;
+    const bcy = cy - by;
+    const bcz = cz - bz;
+    const w22 = (d4 - d3) / (d4 - d3 + d5 - d6);
+    return distSq(px2, py2, pz2, bx + w22 * bcx, by + w22 * bcy, bz + w22 * bcz);
+  }
+  const barycentricTotal = va + vb + vc;
+  if (!Number.isFinite(barycentricTotal) || Math.abs(barycentricTotal) < 1e-20) {
+    return Math.min(distSq(px2, py2, pz2, ax, ay, az), distSq(px2, py2, pz2, bx, by, bz), distSq(px2, py2, pz2, cx, cy, cz));
+  }
+  const denom = 1 / barycentricTotal;
+  const v = vb * denom;
+  const w2 = vc * denom;
+  return distSq(px2, py2, pz2, ax + abx * v + acx * w2, ay + aby * v + acy * w2, az + abz * v + acz * w2);
+}
+function segmentSegmentDistanceSq(a0, a1, b0, b1) {
+  const ux = a1[0] - a0[0];
+  const uy = a1[1] - a0[1];
+  const uz = a1[2] - a0[2];
+  const vx = b1[0] - b0[0];
+  const vy = b1[1] - b0[1];
+  const vz = b1[2] - b0[2];
+  const wx = a0[0] - b0[0];
+  const wy = a0[1] - b0[1];
+  const wz = a0[2] - b0[2];
+  const a2 = ux * ux + uy * uy + uz * uz;
+  const b = ux * vx + uy * vy + uz * vz;
+  const c2 = vx * vx + vy * vy + vz * vz;
+  const d2 = ux * wx + uy * wy + uz * wz;
+  const e = vx * wx + vy * wy + vz * wz;
+  const denom = a2 * c2 - b * b;
+  let sNumerator = denom;
+  let sDenominator = denom;
+  let tNumerator = denom;
+  let tDenominator = denom;
+  if (a2 <= 1e-20) return pointSegmentDistanceSq(a0, b0, b1);
+  if (c2 <= 1e-20) return pointSegmentDistanceSq(b0, a0, a1);
+  if (denom < 1e-20) {
+    sNumerator = 0;
+    sDenominator = 1;
+    tNumerator = e;
+    tDenominator = c2;
+  } else {
+    sNumerator = b * e - c2 * d2;
+    tNumerator = a2 * e - b * d2;
+    if (sNumerator < 0) {
+      sNumerator = 0;
+      tNumerator = e;
+      tDenominator = c2;
+    } else if (sNumerator > sDenominator) {
+      sNumerator = sDenominator;
+      tNumerator = e + b;
+      tDenominator = c2;
+    }
+  }
+  if (tNumerator < 0) {
+    tNumerator = 0;
+    if (-d2 < 0) {
+      sNumerator = 0;
+    } else if (-d2 > a2) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d2;
+      sDenominator = a2;
+    }
+  } else if (tNumerator > tDenominator) {
+    tNumerator = tDenominator;
+    if (-d2 + b < 0) {
+      sNumerator = 0;
+    } else if (-d2 + b > a2) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d2 + b;
+      sDenominator = a2;
+    }
+  }
+  const s = Math.abs(sNumerator) < 1e-20 ? 0 : sNumerator / sDenominator;
+  const t = Math.abs(tNumerator) < 1e-20 ? 0 : tNumerator / tDenominator;
+  const dx = wx + s * ux - t * vx;
+  const dy = wy + s * uy - t * vy;
+  const dz = wz + s * uz - t * vz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function trianglePoint(positions, triangle, corner) {
+  const offset2 = triangle.offset + corner * 3;
+  return [positions[offset2], positions[offset2 + 1], positions[offset2 + 2]];
+}
+function bboxDistanceSq(a2, b) {
+  let total = 0;
+  for (let axis = 0; axis < 3; axis += 1) {
+    const gap = Math.max(0, a2.min[axis] - b.max[axis], b.min[axis] - a2.max[axis]);
+    total += gap * gap;
+  }
+  return total;
+}
+function triangleDistanceSq(aPositions, a2, bPositions, b) {
+  const a0 = trianglePoint(aPositions, a2, 0);
+  const a1 = trianglePoint(aPositions, a2, 1);
+  const a22 = trianglePoint(aPositions, a2, 2);
+  const b0 = trianglePoint(bPositions, b, 0);
+  const b1 = trianglePoint(bPositions, b, 1);
+  const b22 = trianglePoint(bPositions, b, 2);
+  return Math.min(
+    pointTriangleDistanceSq(a0[0], a0[1], a0[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(a1[0], a1[1], a1[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(a22[0], a22[1], a22[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(b0[0], b0[1], b0[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a22[0], a22[1], a22[2]),
+    pointTriangleDistanceSq(b1[0], b1[1], b1[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a22[0], a22[1], a22[2]),
+    pointTriangleDistanceSq(b22[0], b22[1], b22[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a22[0], a22[1], a22[2]),
+    segmentSegmentDistanceSq(a0, a1, b0, b1),
+    segmentSegmentDistanceSq(a0, a1, b1, b22),
+    segmentSegmentDistanceSq(a0, a1, b22, b0),
+    segmentSegmentDistanceSq(a1, a22, b0, b1),
+    segmentSegmentDistanceSq(a1, a22, b1, b22),
+    segmentSegmentDistanceSq(a1, a22, b22, b0),
+    segmentSegmentDistanceSq(a22, a0, b0, b1),
+    segmentSegmentDistanceSq(a22, a0, b1, b22),
+    segmentSegmentDistanceSq(a22, a0, b22, b0)
+  );
+}
+function meshEntriesContactDistance(a2, b, tolerance) {
+  const toleranceSq = tolerance * tolerance;
+  let bestDistanceSq = Infinity;
+  for (const aTriangle of a2.triangles) {
+    for (const bTriangle of b.triangles) {
+      if (bboxDistanceSq(aTriangle, bTriangle) > toleranceSq) continue;
+      const distanceSq = triangleDistanceSq(a2.positions, aTriangle, b.positions, bTriangle);
+      if (distanceSq > toleranceSq) continue;
+      if (distanceSq <= 1e-20) return 0;
+      bestDistanceSq = Math.min(bestDistanceSq, distanceSq);
+    }
+  }
+  return Number.isFinite(bestDistanceSq) ? Math.sqrt(bestDistanceSq) : null;
+}
+function intersectionVolume(a2, b) {
+  try {
+    const hit = a2.shape.intersect(b.shape);
+    if (hit.isEmpty()) return { volume: 0 };
+    const volume = hit.volume();
+    return { volume: Number.isFinite(volume) ? volume : 0 };
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return { volume: null, warning: `Could not boolean-test ${a2.name} against ${b.name}: ${message}` };
+  }
+}
+function detectPhysicalContact(a2, b, options, meshCache = {}) {
+  const gaps = aabbGaps(a2, b);
+  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
+  if (largestGap > options.contactTolerance) return { contact: null };
+  const sourceMesh = meshCache.sourceMesh !== void 0 ? meshCache.sourceMesh : meshContactDataFor(a2);
+  const targetMesh = meshCache.targetMesh !== void 0 ? meshCache.targetMesh : meshContactDataFor(b);
+  if (sourceMesh && targetMesh) {
+    const distance2 = meshEntriesContactDistance(sourceMesh, targetMesh, options.contactTolerance);
+    if (distance2 != null) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "mesh-surface-distance",
+          gap: distance2
+        }
+      };
+    }
+  }
+  const bboxOverlaps = !hasPositiveGap(gaps) && aabbInteriorOverlaps(a2, b);
+  if (options.exactGeometry && bboxOverlaps) {
+    if (aabbOverlapVolume(a2, b) <= options.minOverlapVolume) return { contact: null };
+    const overlap = intersectionVolume(a2, b);
+    if (overlap.volume != null && overlap.volume > options.minOverlapVolume) {
+      return {
+        contact: {
+          kind: "overlap",
+          method: "boolean-intersection",
+          gap: 0,
+          overlapVolume: overlap.volume
+        },
+        warning: overlap.warning
+      };
+    }
+    return { contact: null, warning: overlap.warning };
+  }
+  if (bboxOverlaps && options.mergeOverlappingBBoxes) {
+    return {
+      contact: {
+        kind: "overlap",
+        method: "bbox-overlap",
+        gap: 0,
+        overlapVolume: aabbOverlapVolume(a2, b)
+      }
+    };
+  }
+  if (options.mergeTouchingBBoxes) {
+    const contact = contactFromBBoxes(a2, b, options.contactTolerance);
+    if (contact.touching) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "bbox-contact",
+          gap: contact.gap,
+          axis: contact.axis
+        }
+      };
+    }
+  }
+  return { contact: null };
+}
+const DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
+  contactTolerance: 0.05,
+  minOverlapVolume: 0.1,
+  exactGeometry: true
+};
+class UnionFind {
+  constructor(size) {
+    __publicField(this, "parent");
+    __publicField(this, "rank");
+    this.parent = Array.from({ length: size }, (_2, index2) => index2);
+    this.rank = Array.from({ length: size }, () => 0);
+  }
+  find(value) {
+    const parent = this.parent[value];
+    if (parent === value) return value;
+    const root = this.find(parent);
+    this.parent[value] = root;
+    return root;
+  }
+  union(a2, b) {
+    const rootA = this.find(a2);
+    const rootB = this.find(b);
+    if (rootA === rootB) return;
+    if (this.rank[rootA] < this.rank[rootB]) {
+      this.parent[rootA] = rootB;
+      return;
+    }
+    if (this.rank[rootA] > this.rank[rootB]) {
+      this.parent[rootB] = rootA;
+      return;
+    }
+    this.parent[rootB] = rootA;
+    this.rank[rootA] += 1;
+  }
+}
+function cloneVec3(value) {
+  return [value[0], value[1], value[2]];
+}
+function emptyBBox() {
+  return {
+    min: [Infinity, Infinity, Infinity],
+    max: [-Infinity, -Infinity, -Infinity]
+  };
+}
+function expandBBox(target, min2, max2) {
+  for (let axis = 0; axis < 3; axis += 1) {
+    target.min[axis] = Math.min(target.min[axis], min2[axis]);
+    target.max[axis] = Math.max(target.max[axis], max2[axis]);
+  }
+}
+function collectCandidatePairs(entries, tolerance) {
+  if (entries.length < 2) return [];
+  const index2 = new AabbSpatialIndex(entries);
+  const pairs = index2.overlapPairs({ padding: tolerance }).pairs.map((pair) => ({
+    sourceIndex: pair.sourceIndex,
+    targetIndex: pair.targetIndex,
+    gaps: aabbGaps(entries[pair.sourceIndex], entries[pair.targetIndex])
+  })).filter((pair) => Math.max(pair.gaps[0], pair.gaps[1], pair.gaps[2]) <= tolerance);
+  pairs.sort((a2, b) => a2.sourceIndex - b.sourceIndex || a2.targetIndex - b.targetIndex);
+  return pairs;
+}
+function bodyCountForEntry(entry) {
+  if (typeof entry.bodyCount === "number" && Number.isFinite(entry.bodyCount)) {
+    return Math.max(0, Math.round(entry.bodyCount));
+  }
+  return 1;
+}
+function makeEdge(entries, sourceIndex, targetIndex, edge) {
+  const source = entries[sourceIndex];
+  const target = entries[targetIndex];
+  return {
+    sourceIndex,
+    targetIndex,
+    sourceId: source.id,
+    targetId: target.id,
+    sourceName: source.name,
+    targetName: target.name,
+    ...edge
+  };
+}
+function analyzePhysicalConnectivity(entries, rawOptions = {}) {
+  const exactGeometry = rawOptions.exactGeometry ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.exactGeometry;
+  const options = {
+    contactTolerance: rawOptions.contactTolerance ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance,
+    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.minOverlapVolume,
+    exactGeometry,
+    mergeOverlappingBBoxes: rawOptions.mergeOverlappingBBoxes ?? !exactGeometry,
+    mergeTouchingBBoxes: rawOptions.mergeTouchingBBoxes ?? !exactGeometry
+  };
+  const warnings = [];
+  const edges = [];
+  const unionFind = new UnionFind(entries.length);
+  const meshDataByIndex = /* @__PURE__ */ new Map();
+  entries.forEach((entry, index2) => {
+    const meshData = meshContactDataFor(entry);
+    if (meshData) meshDataByIndex.set(index2, meshData);
+  });
+  for (const pair of collectCandidatePairs(entries, options.contactTolerance)) {
+    const i = pair.sourceIndex;
+    const j = pair.targetIndex;
+    const detection = detectPhysicalContact(entries[i], entries[j], options, {
+      sourceMesh: meshDataByIndex.get(i) ?? null,
+      targetMesh: meshDataByIndex.get(j) ?? null
+    });
+    if (detection.warning) warnings.push(detection.warning);
+    if (!detection.contact) continue;
+    unionFind.union(i, j);
+    edges.push(makeEdge(entries, i, j, detection.contact));
+  }
+  const objects = entries.map((entry, index2) => ({
+    index: index2,
+    id: entry.id,
+    name: entry.name,
+    groupName: entry.groupName,
+    treePath: entry.treePath,
+    mock: entry.mock === true,
+    bodyCount: bodyCountForEntry(entry),
+    bbox: {
+      min: cloneVec3(entry.min),
+      max: cloneVec3(entry.max)
+    },
+    componentIndex: 0
+  }));
+  const componentByRoot = /* @__PURE__ */ new Map();
+  const rootToComponentIndex = /* @__PURE__ */ new Map();
+  for (let objectIndex = 0; objectIndex < objects.length; objectIndex += 1) {
+    const root = unionFind.find(objectIndex);
+    let component = componentByRoot.get(root);
+    if (!component) {
+      component = {
+        index: componentByRoot.size + 1,
+        objectIndexes: [],
+        objectIds: [],
+        objectNames: [],
+        objectCount: 0,
+        bodyCount: 0,
+        bbox: emptyBBox()
+      };
+      componentByRoot.set(root, component);
+      rootToComponentIndex.set(root, component.index);
+    }
+    const object = objects[objectIndex];
+    object.componentIndex = rootToComponentIndex.get(root) ?? component.index;
+    component.objectIndexes.push(object.index);
+    component.objectIds.push(object.id);
+    component.objectNames.push(object.name);
+    component.objectCount += 1;
+    component.bodyCount += object.bodyCount;
+    expandBBox(component.bbox, object.bbox.min, object.bbox.max);
+  }
+  const components = [...componentByRoot.values()];
+  return {
+    method: options.exactGeometry ? "mesh-contact-plus-boolean-overlap" : "bbox-neighborhood",
+    options,
+    objectCount: objects.length,
+    componentCount: components.length,
+    objects,
+    components,
+    edges,
+    warnings
+  };
+}
+const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
+  minThickness: 1.2,
+  warnThickness: 2,
+  maxThickness: 6,
+  maxSamplesPerObject: 5e3,
+  contactTolerance: DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance
+};
+const THICKNESS_COLORS = {
+  critical: [255, 28, 28],
+  warning: [255, 150, 0],
+  ok: [60, 220, 90],
+  thick: [70, 145, 255],
+  unknown: [90, 90, 90]
+};
+function finitePositive(value, fallback, label) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${label} must be a positive finite number.`);
+  }
+  return value;
+}
+function finiteNonNegative(value, fallback, label) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative finite number.`);
+  }
+  return value;
+}
+function resolveThicknessInspectionOptions(raw = {}) {
+  const minThickness = finitePositive(raw.minThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.minThickness, "minThickness");
+  const warnThickness = finitePositive(raw.warnThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.warnThickness, "warnThickness");
+  const maxThickness = finitePositive(raw.maxThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxThickness, "maxThickness");
+  const maxSamplesPerObject = finitePositive(
+    raw.maxSamplesPerObject,
+    DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxSamplesPerObject,
+    "maxSamplesPerObject"
+  );
+  const contactTolerance = finiteNonNegative(
+    raw.contactTolerance,
+    DEFAULT_THICKNESS_INSPECTION_OPTIONS.contactTolerance,
+    "contactTolerance"
+  );
+  if (minThickness > warnThickness) {
+    throw new Error("minThickness must be less than or equal to warnThickness.");
+  }
+  if (warnThickness > maxThickness) {
+    throw new Error("warnThickness must be less than or equal to maxThickness.");
+  }
+  return {
+    minThickness,
+    warnThickness,
+    maxThickness,
+    maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject)),
+    contactTolerance
+  };
+}
+function lerp(a2, b, t) {
+  return a2 + (b - a2) * Math.max(0, Math.min(1, t));
+}
+function lerpColor(a2, b, t) {
+  return [Math.round(lerp(a2[0], b[0], t)), Math.round(lerp(a2[1], b[1], t)), Math.round(lerp(a2[2], b[2], t))];
+}
+function thicknessClass(thickness, options) {
+  if (thickness == null || !Number.isFinite(thickness) || thickness <= 0) return "unknown";
+  if (thickness <= options.minThickness) return "critical";
+  if (thickness <= options.warnThickness) return "warning";
+  if (thickness <= options.maxThickness) return "ok";
+  return "thick";
+}
+function thicknessColor(thickness, options) {
+  const cls = thicknessClass(thickness, options);
+  if (cls === "unknown") return THICKNESS_COLORS.unknown;
+  if (cls === "critical") return THICKNESS_COLORS.critical;
+  if (cls === "warning") {
+    const span = Math.max(1e-9, options.warnThickness - options.minThickness);
+    return lerpColor(THICKNESS_COLORS.critical, THICKNESS_COLORS.warning, ((thickness ?? 0) - options.minThickness) / span);
+  }
+  if (cls === "ok") {
+    const span = Math.max(1e-9, options.maxThickness - options.warnThickness);
+    return lerpColor(THICKNESS_COLORS.ok, THICKNESS_COLORS.thick, ((thickness ?? 0) - options.warnThickness) / span);
+  }
+  return THICKNESS_COLORS.thick;
+}
+function sampleArea(sample) {
+  const area2 = sample.area ?? 1;
+  return Number.isFinite(area2) && area2 > 0 ? area2 : 1;
+}
+function weightedQuantile(samples, q) {
+  if (samples.length === 0) return null;
+  const sorted = [...samples].sort((a2, b) => a2.thickness - b.thickness);
+  const totalArea = sorted.reduce((sum2, sample) => sum2 + sample.area, 0);
+  const target = totalArea * Math.max(0, Math.min(1, q));
+  let cumulative = 0;
+  for (const sample of sorted) {
+    cumulative += sample.area;
+    if (cumulative >= target) return sample.thickness;
+  }
+  return sorted[sorted.length - 1].thickness;
+}
+function percent(part, total) {
+  if (total <= 0) return 0;
+  return part / total * 100;
+}
+function summarizeThicknessSamples(samples, options) {
+  const resolved = [];
+  let totalArea = 0;
+  let resolvedArea = 0;
+  let unresolvedArea = 0;
+  let criticalArea = 0;
+  let warningArea = 0;
+  let weightedSum = 0;
+  for (const sample of samples) {
+    const area2 = sampleArea(sample);
+    totalArea += area2;
+    const value = sample.thickness;
+    if (value == null || !Number.isFinite(value) || value <= 0) {
+      unresolvedArea += area2;
+      continue;
+    }
+    resolved.push({ thickness: value, area: area2 });
+    resolvedArea += area2;
+    weightedSum += value * area2;
+    if (value <= options.minThickness) {
+      criticalArea += area2;
+    } else if (value <= options.warnThickness) {
+      warningArea += area2;
+    }
+  }
+  const values = resolved.map((sample) => sample.thickness);
+  return {
+    sampleCount: samples.length,
+    resolvedCount: resolved.length,
+    unresolvedCount: samples.length - resolved.length,
+    minThickness: values.length > 0 ? Math.min(...values) : null,
+    p05Thickness: weightedQuantile(resolved, 0.05),
+    medianThickness: weightedQuantile(resolved, 0.5),
+    meanThickness: resolvedArea > 0 ? weightedSum / resolvedArea : null,
+    maxThickness: values.length > 0 ? Math.max(...values) : null,
+    criticalAreaPercent: percent(criticalArea, resolvedArea),
+    warningAreaPercent: percent(warningArea, resolvedArea),
+    belowWarnAreaPercent: percent(criticalArea + warningArea, resolvedArea),
+    unresolvedAreaPercent: percent(unresolvedArea, totalArea)
+  };
+}
 const VECTOR_KEYS = /* @__PURE__ */ new Set(["pos", "position", "target", "lookat", "aim", "up"]);
 const roundNumber = (value, digits) => {
   const scale2 = 10 ** digits;
@@ -342565,7 +343265,7 @@ export {
   DEFAULT_ACTIVE_BACKEND as ay,
   isConstraintSketch as az,
   PCFShadowMap as b,
-  Group as b$,
+  analyzePhysicalConnectivity as b$,
   PointLight as b0,
   DirectionalLight as b1,
   analyzeCollisionIntersections as b2,
@@ -342576,33 +343276,33 @@ export {
   runScript as b7,
   MeshPhysicalMaterial as b8,
   LineSegments as b9,
-  resolveExplodeDirective as bA,
-  computeExplodeMotion as bB,
-  getSketchWorldMatrix as bC,
-  explodeAdd as bD,
-  hasExplodeOverride as bE,
-  resolveExplodeLocalFanDirection as bF,
-  explodeMul as bG,
-  explodeLeafFanStage as bH,
-  normalizeCutPlane as bI,
-  toClippingPlane as bJ,
-  findJointAnimationClip as bK,
-  resolveJointAnimation as bL,
-  resolveJointViewValues as bM,
-  getShapePorts as bN,
-  getShapeUsedPorts as bO,
-  DEFAULT_VIEW_CONFIG as bP,
-  getKernelFaceNameForTriangle as bQ,
-  resolveScalarSceneSampleBudget as bR,
-  initKernel as bS,
-  initSolverWasm as bT,
-  BoxGeometry as bU,
-  localAabbPlaneRelation as bV,
-  ShapeUtils as bW,
-  aabbGaps as bX,
-  aabbInteriorOverlaps as bY,
-  aabbOverlapVolume as bZ,
-  AabbSpatialIndex as b_,
+  parseViewportCameraState as bA,
+  createResolvedExplodeConfig as bB,
+  explodeBoundsCenter as bC,
+  explodeMergeBounds as bD,
+  resolveExplodeDirective as bE,
+  computeExplodeMotion as bF,
+  getSketchWorldMatrix as bG,
+  explodeAdd as bH,
+  hasExplodeOverride as bI,
+  resolveExplodeLocalFanDirection as bJ,
+  explodeMul as bK,
+  explodeLeafFanStage as bL,
+  normalizeCutPlane as bM,
+  toClippingPlane as bN,
+  findJointAnimationClip as bO,
+  resolveJointAnimation as bP,
+  resolveJointViewValues as bQ,
+  getShapePorts as bR,
+  getShapeUsedPorts as bS,
+  DEFAULT_VIEW_CONFIG as bT,
+  getKernelFaceNameForTriangle as bU,
+  resolveScalarSceneSampleBudget as bV,
+  initKernel as bW,
+  initSolverWasm as bX,
+  BoxGeometry as bY,
+  localAabbPlaneRelation as bZ,
+  ShapeUtils as b_,
   geometryWithVisibleVertexColors as ba,
   getRenderStylePreset as bb,
   AdditiveBlending as bc,
@@ -342617,32 +343317,44 @@ export {
   SURFACE_FIELD_VERTEX_SHADER as bl,
   CatmullRomCurve3 as bm,
   TubeGeometry as bn,
-  MeshStandardMaterial as bo,
-  compileSdfNode3 as bp,
-  buildSdfRaymarchFragmentShader as bq,
-  SDF_RAYMARCH_PROXY_VERTEX_SHADER as br,
-  Shape2 as bs,
-  ShapeGeometry as bt,
-  ShaderLib as bu,
-  CylinderGeometry as bv,
-  parseViewportCameraState as bw,
-  createResolvedExplodeConfig as bx,
-  explodeBoundsCenter as by,
-  explodeMergeBounds as bz,
+  ROUGHNESS_COLORS as bo,
+  DEFAULT_ROUGHNESS_INSPECTION_OPTIONS as bp,
+  DEFAULT_THICKNESS_INSPECTION_OPTIONS as bq,
+  THICKNESS_COLORS as br,
+  MeshStandardMaterial as bs,
+  compileSdfNode3 as bt,
+  buildSdfRaymarchFragmentShader as bu,
+  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bv,
+  Shape2 as bw,
+  ShapeGeometry as bx,
+  ShaderLib as by,
+  CylinderGeometry as bz,
   SRGBColorSpace as c,
-  intersectWithPlane as c0,
-  setActiveBackend as c1,
-  parseCameraCliSpec as c2,
-  PMREMGenerator as c3,
-  PointsMaterial as c4,
-  Points$1 as c5,
-  serializeCollisionFinding as c6,
-  worldAuthorPlaneToLocal as c7,
-  generateCuttingLayoutPdf as c8,
-  getCameraForwardVector as c9,
-  RENDER_STYLE_OPTIONS as ca,
-  initKernelManifoldOnly as cb,
-  __viteBrowserExternal$1 as cc,
+  meshContactDataFor as c0,
+  AabbSpatialIndex as c1,
+  detectPhysicalContact as c2,
+  resolveThicknessInspectionOptions as c3,
+  thicknessColor as c4,
+  thicknessClass as c5,
+  roughnessClassForAngle as c6,
+  resolveRoughnessInspectionOptions as c7,
+  roughnessColorForAngle as c8,
+  roughnessScoreForAngle as c9,
+  Group as ca,
+  intersectWithPlane as cb,
+  setActiveBackend as cc,
+  parseCameraCliSpec as cd,
+  PMREMGenerator as ce,
+  PointsMaterial as cf,
+  Points$1 as cg,
+  serializeCollisionFinding as ch,
+  summarizeThicknessSamples as ci,
+  worldAuthorPlaneToLocal as cj,
+  generateCuttingLayoutPdf as ck,
+  getCameraForwardVector as cl,
+  RENDER_STYLE_OPTIONS as cm,
+  initKernelManifoldOnly as cn,
+  __viteBrowserExternal$1 as co,
   Layers as d,
   Color as e,
   RGBAFormat as f,