forgecad 0.9.8 → 0.9.9

package/dist/assets/cli/{render-BI3gLMXz.js → render-CXVrHY8q.js}

@@ -1,8 +1,8 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { D as DoubleSide, bT as initSolverWasm, bS as initKernel, S as Scene, bU as BoxGeometry, bo as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bV as localAabbPlaneRelation, h as Vector2, bW as ShapeUtils, bX as aabbGaps, bY as aabbInteriorOverlaps, bZ as aabbOverlapVolume, b_ as AabbSpatialIndex, g as Vector3, R as Raycaster, aU as BufferAttribute, a0 as MathUtils, G as Box3, e as Color, aC as resolveForgeRenderStyle, bb as getRenderStylePreset, ax as setParamOverrides, b7 as runScript, b$ as Group, b3 as shapeToGeometry, b8 as MeshPhysicalMaterial, bc as AdditiveBlending, aH as LineBasicMaterial, b9 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bi as ZEBRA_STRIPE_FRAGMENT_SHADER, bj as ZEBRA_STRIPE_VERTEX_SHADER, bd as ZEBRA_STRIPE_SOFTNESS, be as ZEBRA_STRIPE_SCALE, bf as ZEBRA_LIGHT_COLOR, bg as ZEBRA_DARK_COLOR, bh as ZEBRA_ACCENT_COLOR, ba as geometryWithVisibleVertexColors, c0 as intersectWithPlane, c1 as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, c2 as parseCameraCliSpec, c3 as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bK as findJointAnimationClip, p as Plane, bk as SURFACE_FIELD_FRAGMENT_SHADER, bl as SURFACE_FIELD_VERTEX_SHADER, Y as Vector4, $ as Matrix4, br as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bq as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bL as resolveJointAnimation, bM as resolveJointViewValues, c4 as PointsMaterial, c5 as Points, b2 as analyzeCollisionIntersections, c6 as serializeCollisionFinding, c7 as worldAuthorPlaneToLocal, a$ as SpotLight, bR as resolveScalarSceneSampleBudget } from "../scalar-sampling-budget-iBAeF8RM.js";
-import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-BIvOkPK3.js";
+import { D as DoubleSide, bX as initSolverWasm, bW as initKernel, S as Scene, bY as BoxGeometry, bs as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bZ as localAabbPlaneRelation, h as Vector2, b_ as ShapeUtils, b$ as analyzePhysicalConnectivity, c0 as meshContactDataFor, c1 as AabbSpatialIndex, c2 as detectPhysicalContact, g as Vector3, c3 as resolveThicknessInspectionOptions, R as Raycaster, c4 as thicknessColor, c5 as thicknessClass, aU as BufferAttribute, c6 as roughnessClassForAngle, a0 as MathUtils, c7 as resolveRoughnessInspectionOptions, G as Box3, c8 as roughnessColorForAngle, c9 as roughnessScoreForAngle, e as Color, aC as resolveForgeRenderStyle, bb as getRenderStylePreset, ax as setParamOverrides, b7 as runScript, ca as Group, b3 as shapeToGeometry, b8 as MeshPhysicalMaterial, bc as AdditiveBlending, aH as LineBasicMaterial, b9 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bi as ZEBRA_STRIPE_FRAGMENT_SHADER, bj as ZEBRA_STRIPE_VERTEX_SHADER, bd as ZEBRA_STRIPE_SOFTNESS, be as ZEBRA_STRIPE_SCALE, bf as ZEBRA_LIGHT_COLOR, bg as ZEBRA_DARK_COLOR, bh as ZEBRA_ACCENT_COLOR, ba as geometryWithVisibleVertexColors, cb as intersectWithPlane, cc as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, cd as parseCameraCliSpec, ce as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bO as findJointAnimationClip, p as Plane, bk as SURFACE_FIELD_FRAGMENT_SHADER, bl as SURFACE_FIELD_VERTEX_SHADER, Y as Vector4, $ as Matrix4, bv as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bu as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bP as resolveJointAnimation, bQ as resolveJointViewValues, bo as ROUGHNESS_COLORS, cf as PointsMaterial, cg as Points, b2 as analyzeCollisionIntersections, ch as serializeCollisionFinding, ci as summarizeThicknessSamples, br as THICKNESS_COLORS, cj as worldAuthorPlaneToLocal, a$ as SpotLight, bV as resolveScalarSceneSampleBudget } from "../scalar-sampling-budget-Bmewod18.js";
+import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-CWO8rHlt.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -457,489 +457,6 @@ function computeMeshSectionCap(mesh, planeInput) {
     warnings: stitched.warnings.length > 0 ? stitched.warnings : void 0
   };
 }
-const AXIS_NAMES = ["x", "y", "z"];
-function nearestBoundaryGap(a, b, axis) {
-  return Math.min(Math.abs(a.max[axis] - b.min[axis]), Math.abs(b.max[axis] - a.min[axis]));
-}
-function hasPositiveGap(gaps) {
-  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
-}
-function contactFromBBoxes(a, b, tolerance) {
-  const gaps = aabbGaps(a, 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(a, 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, offset) {
-  for (let index = 0; index < 9; index += 1) {
-    if (!Number.isFinite(positions[offset + index])) return false;
-  }
-  return true;
-}
-function triangleRef(positions, offset) {
-  if (!isFiniteTriangle(positions, offset)) return null;
-  const ax = positions[offset];
-  const ay = positions[offset + 1];
-  const az = positions[offset + 2];
-  const bx = positions[offset + 3];
-  const by = positions[offset + 4];
-  const bz = positions[offset + 5];
-  const cx = positions[offset + 6];
-  const cy = positions[offset + 7];
-  const cz = positions[offset + 8];
-  return {
-    offset,
-    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(px, py, pz, qx, qy, qz) {
-  const dx = px - qx;
-  const dy = py - qy;
-  const dz = pz - qz;
-  return dx * dx + dy * dy + dz * dz;
-}
-function pointSegmentDistanceSq(point, 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(point[0], point[1], point[2], start[0], start[1], start[2]);
-  const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy + (point[2] - start[2]) * dz) / lengthSq));
-  return distSq(point[0], point[1], point[2], start[0] + t * dx, start[1] + t * dy, start[2] + t * dz);
-}
-function pointTriangleDistanceSq(px, py, pz, 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 = px - ax;
-  const apy = py - ay;
-  const apz = pz - az;
-  const d1 = abx * apx + aby * apy + abz * apz;
-  const d2 = acx * apx + acy * apy + acz * apz;
-  if (d1 <= 0 && d2 <= 0) return distSq(px, py, pz, ax, ay, az);
-  const bpx = px - bx;
-  const bpy = py - by;
-  const bpz = pz - bz;
-  const d3 = abx * bpx + aby * bpy + abz * bpz;
-  const d4 = acx * bpx + acy * bpy + acz * bpz;
-  if (d3 >= 0 && d4 <= d3) return distSq(px, py, pz, bx, by, bz);
-  const vc = d1 * d4 - d3 * d2;
-  if (vc <= 0 && d1 >= 0 && d3 <= 0) {
-    const v2 = d1 / (d1 - d3);
-    return distSq(px, py, pz, ax + v2 * abx, ay + v2 * aby, az + v2 * abz);
-  }
-  const cpx = px - cx;
-  const cpy = py - cy;
-  const cpz = pz - cz;
-  const d5 = abx * cpx + aby * cpy + abz * cpz;
-  const d6 = acx * cpx + acy * cpy + acz * cpz;
-  if (d6 >= 0 && d5 <= d6) return distSq(px, py, pz, cx, cy, cz);
-  const vb = d5 * d2 - d1 * d6;
-  if (vb <= 0 && d2 >= 0 && d6 <= 0) {
-    const w2 = d2 / (d2 - d6);
-    return distSq(px, py, pz, ax + w2 * acx, ay + w2 * acy, az + w2 * 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 w2 = (d4 - d3) / (d4 - d3 + d5 - d6);
-    return distSq(px, py, pz, bx + w2 * bcx, by + w2 * bcy, bz + w2 * bcz);
-  }
-  const barycentricTotal = va + vb + vc;
-  if (!Number.isFinite(barycentricTotal) || Math.abs(barycentricTotal) < 1e-20) {
-    return Math.min(distSq(px, py, pz, ax, ay, az), distSq(px, py, pz, bx, by, bz), distSq(px, py, pz, cx, cy, cz));
-  }
-  const denom = 1 / barycentricTotal;
-  const v = vb * denom;
-  const w = vc * denom;
-  return distSq(px, py, pz, ax + abx * v + acx * w, ay + aby * v + acy * w, az + abz * v + acz * w);
-}
-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 a = ux * ux + uy * uy + uz * uz;
-  const b = ux * vx + uy * vy + uz * vz;
-  const c = vx * vx + vy * vy + vz * vz;
-  const d = ux * wx + uy * wy + uz * wz;
-  const e = vx * wx + vy * wy + vz * wz;
-  const denom = a * c - b * b;
-  let sNumerator = denom;
-  let sDenominator = denom;
-  let tNumerator = denom;
-  let tDenominator = denom;
-  if (a <= 1e-20) return pointSegmentDistanceSq(a0, b0, b1);
-  if (c <= 1e-20) return pointSegmentDistanceSq(b0, a0, a1);
-  if (denom < 1e-20) {
-    sNumerator = 0;
-    sDenominator = 1;
-    tNumerator = e;
-    tDenominator = c;
-  } else {
-    sNumerator = b * e - c * d;
-    tNumerator = a * e - b * d;
-    if (sNumerator < 0) {
-      sNumerator = 0;
-      tNumerator = e;
-      tDenominator = c;
-    } else if (sNumerator > sDenominator) {
-      sNumerator = sDenominator;
-      tNumerator = e + b;
-      tDenominator = c;
-    }
-  }
-  if (tNumerator < 0) {
-    tNumerator = 0;
-    if (-d < 0) {
-      sNumerator = 0;
-    } else if (-d > a) {
-      sNumerator = sDenominator;
-    } else {
-      sNumerator = -d;
-      sDenominator = a;
-    }
-  } else if (tNumerator > tDenominator) {
-    tNumerator = tDenominator;
-    if (-d + b < 0) {
-      sNumerator = 0;
-    } else if (-d + b > a) {
-      sNumerator = sDenominator;
-    } else {
-      sNumerator = -d + b;
-      sDenominator = a;
-    }
-  }
-  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 offset = triangle.offset + corner * 3;
-  return [positions[offset], positions[offset + 1], positions[offset + 2]];
-}
-function bboxDistanceSq(a, b) {
-  let total = 0;
-  for (let axis = 0; axis < 3; axis += 1) {
-    const gap = Math.max(0, a.min[axis] - b.max[axis], b.min[axis] - a.max[axis]);
-    total += gap * gap;
-  }
-  return total;
-}
-function triangleDistanceSq(aPositions, a, bPositions, b) {
-  const a0 = trianglePoint(aPositions, a, 0);
-  const a1 = trianglePoint(aPositions, a, 1);
-  const a2 = trianglePoint(aPositions, a, 2);
-  const b0 = trianglePoint(bPositions, b, 0);
-  const b1 = trianglePoint(bPositions, b, 1);
-  const b2 = 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], b2[0], b2[1], b2[2]),
-    pointTriangleDistanceSq(a1[0], a1[1], a1[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b2[0], b2[1], b2[2]),
-    pointTriangleDistanceSq(a2[0], a2[1], a2[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b2[0], b2[1], b2[2]),
-    pointTriangleDistanceSq(b0[0], b0[1], b0[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
-    pointTriangleDistanceSq(b1[0], b1[1], b1[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
-    pointTriangleDistanceSq(b2[0], b2[1], b2[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
-    segmentSegmentDistanceSq(a0, a1, b0, b1),
-    segmentSegmentDistanceSq(a0, a1, b1, b2),
-    segmentSegmentDistanceSq(a0, a1, b2, b0),
-    segmentSegmentDistanceSq(a1, a2, b0, b1),
-    segmentSegmentDistanceSq(a1, a2, b1, b2),
-    segmentSegmentDistanceSq(a1, a2, b2, b0),
-    segmentSegmentDistanceSq(a2, a0, b0, b1),
-    segmentSegmentDistanceSq(a2, a0, b1, b2),
-    segmentSegmentDistanceSq(a2, a0, b2, b0)
-  );
-}
-function meshEntriesContactDistance(a, b, tolerance) {
-  const toleranceSq = tolerance * tolerance;
-  let bestDistanceSq = Infinity;
-  for (const aTriangle of a.triangles) {
-    for (const bTriangle of b.triangles) {
-      if (bboxDistanceSq(aTriangle, bTriangle) > toleranceSq) continue;
-      const distanceSq = triangleDistanceSq(a.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(a, b) {
-  try {
-    const hit = a.shape.intersect(b.shape);
-    if (hit.isEmpty()) return { volume: 0 };
-    const volume = hit.volume();
-    return { volume: Number.isFinite(volume) ? volume : 0 };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { volume: null, warning: `Could not boolean-test ${a.name} against ${b.name}: ${message}` };
-  }
-}
-function detectPhysicalContact(a, b, options, meshCache = {}) {
-  const gaps = aabbGaps(a, 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(a);
-  const targetMesh = meshCache.targetMesh !== void 0 ? meshCache.targetMesh : meshContactDataFor(b);
-  if (sourceMesh && targetMesh) {
-    const distance = meshEntriesContactDistance(sourceMesh, targetMesh, options.contactTolerance);
-    if (distance != null) {
-      return {
-        contact: {
-          kind: "touching",
-          method: "mesh-surface-distance",
-          gap: distance
-        }
-      };
-    }
-  }
-  const bboxOverlaps = !hasPositiveGap(gaps) && aabbInteriorOverlaps(a, b);
-  if (options.exactGeometry && bboxOverlaps) {
-    if (aabbOverlapVolume(a, b) <= options.minOverlapVolume) return { contact: null };
-    const overlap = intersectionVolume(a, 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(a, b)
-      }
-    };
-  }
-  if (options.mergeTouchingBBoxes) {
-    const contact = contactFromBBoxes(a, 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
-};
-let UnionFind$2 = class UnionFind {
-  constructor(size) {
-    __publicField(this, "parent");
-    __publicField(this, "rank");
-    this.parent = Array.from({ length: size }, (_, index) => index);
-    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(a, b) {
-    const rootA = this.find(a);
-    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$1(value) {
-  return [value[0], value[1], value[2]];
-}
-function emptyBBox$2() {
-  return {
-    min: [Infinity, Infinity, Infinity],
-    max: [-Infinity, -Infinity, -Infinity]
-  };
-}
-function expandBBox$2(target, min, max) {
-  for (let axis = 0; axis < 3; axis += 1) {
-    target.min[axis] = Math.min(target.min[axis], min[axis]);
-    target.max[axis] = Math.max(target.max[axis], max[axis]);
-  }
-}
-function collectCandidatePairs(entries, tolerance) {
-  if (entries.length < 2) return [];
-  const index = new AabbSpatialIndex(entries);
-  const pairs = index.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((a, b) => a.sourceIndex - b.sourceIndex || a.targetIndex - b.targetIndex);
-  return pairs;
-}
-function bodyCountForEntry$1(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$2(entries.length);
-  const meshDataByIndex = /* @__PURE__ */ new Map();
-  entries.forEach((entry, index) => {
-    const meshData = meshContactDataFor(entry);
-    if (meshData) meshDataByIndex.set(index, 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, index) => ({
-    index,
-    id: entry.id,
-    name: entry.name,
-    groupName: entry.groupName,
-    treePath: entry.treePath,
-    mock: entry.mock === true,
-    bodyCount: bodyCountForEntry$1(entry),
-    bbox: {
-      min: cloneVec3$1(entry.min),
-      max: cloneVec3$1(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$2()
-      };
-      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$2(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 EPSILON = 1e-9;
 function intervalGap(aMin, aMax, bMin, bMax) {
   if (aMax < bMin) return bMin - aMax;
@@ -1135,7 +652,7 @@ const DEFAULT_CONTACT_TOLERANCE = 0.05;
 const DEFAULT_BED_TOLERANCE = 0.05;
 const DEFAULT_GROUND_Z = 0;
 const MIN_SHAPE_OVERLAP_VOLUME = 1e-9;
-let UnionFind$1 = class UnionFind2 {
+let UnionFind$1 = class UnionFind {
   constructor(size) {
     __publicField(this, "parent");
     __publicField(this, "rank");
@@ -1481,150 +998,6 @@ ${body}
     pathCount
   };
 }
-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(a, b, t) {
-  return a + (b - a) * Math.max(0, Math.min(1, t));
-}
-function lerpColor$1(a, b, t) {
-  return [Math.round(lerp(a[0], b[0], t)), Math.round(lerp(a[1], b[1], t)), Math.round(lerp(a[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$1(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$1(THICKNESS_COLORS.ok, THICKNESS_COLORS.thick, ((thickness ?? 0) - options.warnThickness) / span);
-  }
-  return THICKNESS_COLORS.thick;
-}
-function sampleArea(sample) {
-  const area = sample.area ?? 1;
-  return Number.isFinite(area) && area > 0 ? area : 1;
-}
-function weightedQuantile(samples, q) {
-  if (samples.length === 0) return null;
-  const sorted = [...samples].sort((a, b) => a.thickness - b.thickness);
-  const totalArea = sorted.reduce((sum, sample) => sum + 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 area = sampleArea(sample);
-    totalArea += area;
-    const value = sample.thickness;
-    if (value == null || !Number.isFinite(value) || value <= 0) {
-      unresolvedArea += area;
-      continue;
-    }
-    resolved.push({ thickness: value, area });
-    resolvedArea += area;
-    weightedSum += value * area;
-    if (value <= options.minThickness) {
-      criticalArea += area;
-    } else if (value <= options.warnThickness) {
-      warningArea += area;
-    }
-  }
-  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 MIN_TRIANGLE_AREA = 1e-12;
 const R2_ALPHA = 0.7548776662466927;
 const R2_BETA = 0.5698402909980532;
@@ -1865,79 +1238,6 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {})
     warnings
   };
 }
-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(a, b, t) {
-  const clamped = MathUtils.clamp(t, 0, 1);
-  return [
-    Math.round(MathUtils.lerp(a[0], b[0], clamped)),
-    Math.round(MathUtils.lerp(a[1], b[1], clamped)),
-    Math.round(MathUtils.lerp(a[2], b[2], clamped))
-  ];
-}
 function emptyRoughnessSummary() {
   return {
     triangleCount: 0,
@@ -2162,7 +1462,7 @@ function pointSegmentDistance(point, start, end) {
   return point.distanceTo(segment.multiplyScalar(t).add(start));
 }
 const DEFAULT_VERTEX_TOLERANCE = 1e-5;
-class UnionFind3 {
+class UnionFind2 {
   constructor(size) {
     __publicField(this, "parent");
     __publicField(this, "rank");
@@ -2221,7 +1521,7 @@ function analyzeMeshConnectedComponents(positions, vertexTolerance = DEFAULT_VER
   const vertexComponentIndexes = new Int32Array(vertexCount);
   if (triangleCount === 0) return { components: [], vertexComponentIndexes };
   const tolerance = Number.isFinite(vertexTolerance) && vertexTolerance > 0 ? vertexTolerance : DEFAULT_VERTEX_TOLERANCE;
-  const unionFind = new UnionFind3(triangleCount);
+  const unionFind = new UnionFind2(triangleCount);
   const vertexOwnerByKey = /* @__PURE__ */ new Map();
   for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
     for (let corner = 0; corner < 3; corner += 1) {