forgecad 0.9.5 → 0.9.7

package/dist/assets/cli/{render-BrVVdj_T.js → render-iP9qh475.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, bH as initSolverWasm, bG as initKernel, S as Scene, bI as BoxGeometry, bd as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bJ as localAabbPlaneRelation, h as Vector2, bK as ShapeUtils, a0 as MathUtils, g as Vector3, G as Box3, aU as BufferAttribute, e as Color, aC as resolveForgeRenderStyle, b9 as getRenderStylePreset, ax as setParamOverrides, b6 as runScript, bL as Group, b3 as shapeToGeometry, b7 as MeshPhysicalMaterial, ba as AdditiveBlending, aH as LineBasicMaterial, b8 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bM as intersectWithPlane, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, bN as parseCameraCliSpec, bO as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bz as findJointAnimationClip, p as Plane, Y as Vector4, $ as Matrix4, bg as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bf as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bA as resolveJointAnimation, bB as resolveJointViewValues, R as Raycaster, bP as worldAuthorPlaneToLocal, a$ as SpotLight } from "../sectionPlaneMath-CykEnkvQ.js";
-import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-3DfsSASX.js";
+import { D as DoubleSide, bI as initSolverWasm, bH as initKernel, S as Scene, bJ as BoxGeometry, be as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bK as localAabbPlaneRelation, h as Vector2, bL as ShapeUtils, bM as aabbInteriorOverlaps, bN as aabbOverlapVolume, bO as AabbSpatialIndex, bP as aabbGaps, g as Vector3, R as Raycaster, aU as BufferAttribute, a0 as MathUtils, G as Box3, e as Color, aC as resolveForgeRenderStyle, ba as getRenderStylePreset, ax as setParamOverrides, b7 as runScript, bQ as Group, b3 as shapeToGeometry, b8 as MeshPhysicalMaterial, bb as AdditiveBlending, aH as LineBasicMaterial, b9 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bR as intersectWithPlane, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, bS as parseCameraCliSpec, bT as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bA as findJointAnimationClip, p as Plane, Y as Vector4, $ as Matrix4, bh as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bg as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bB as resolveJointAnimation, bC as resolveJointViewValues, bU as PointsMaterial, bV as Points, b2 as analyzeCollisionIntersections, bW as serializeCollisionFinding, bX as worldAuthorPlaneToLocal, a$ as SpotLight } from "../sectionPlaneMath-BdTjyVfs.js";
+import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-Bngp5MrQ.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -457,146 +457,13 @@ function computeMeshSectionCap(mesh, planeInput) {
     warnings: stitched.warnings.length > 0 ? stitched.warnings : void 0
   };
 }
-const DEFAULT_COLLISION_INSPECTION_OPTIONS = {
-  minOverlapVolume: 0.1
-};
-function cloneVec3$1(value) {
-  return [value[0], value[1], value[2]];
-}
-function isIdentityTransform(matrix) {
-  if (!matrix) return true;
-  const identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-  return identity.every((value, index) => Math.abs(matrix[index] - value) <= 1e-12);
-}
-function transformPoint(matrix, point) {
-  const [x, y, z] = point;
-  return [
-    matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12],
-    matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13],
-    matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14]
-  ];
-}
-function transformBBox(min, max, matrix) {
-  const corners = [
-    [min[0], min[1], min[2]],
-    [min[0], min[1], max[2]],
-    [min[0], max[1], min[2]],
-    [min[0], max[1], max[2]],
-    [max[0], min[1], min[2]],
-    [max[0], min[1], max[2]],
-    [max[0], max[1], min[2]],
-    [max[0], max[1], max[2]]
-  ];
-  const outMin = [Infinity, Infinity, Infinity];
-  const outMax = [-Infinity, -Infinity, -Infinity];
-  for (const corner of corners) {
-    const transformed = transformPoint(matrix, corner);
-    for (let axis = 0; axis < 3; axis += 1) {
-      outMin[axis] = Math.min(outMin[axis], transformed[axis]);
-      outMax[axis] = Math.max(outMax[axis], transformed[axis]);
-    }
-  }
-  return { min: outMin, max: outMax };
-}
-function prepareEntry$1(entry) {
-  if (isIdentityTransform(entry.transform)) {
-    return {
-      ...entry,
-      min: cloneVec3$1(entry.min),
-      max: cloneVec3$1(entry.max)
-    };
-  }
-  const bbox = transformBBox(entry.min, entry.max, entry.transform);
-  return {
-    ...entry,
-    shape: entry.shape.transform(entry.transform),
-    min: bbox.min,
-    max: bbox.max
-  };
-}
-function bboxOverlaps(a, b) {
-  return [0, 1, 2].every((axis) => a.min[axis] < b.max[axis] && a.max[axis] > b.min[axis]);
-}
-function collisionId(a, b) {
-  return `${a.id}__${b.id}`;
-}
-function serializeCollisionFinding(finding) {
-  return {
-    index: finding.index,
-    id: finding.id,
-    sourceIndex: finding.sourceIndex,
-    targetIndex: finding.targetIndex,
-    sourceId: finding.sourceId,
-    targetId: finding.targetId,
-    sourceName: finding.sourceName,
-    targetName: finding.targetName,
-    overlapVolume: finding.overlapVolume
-  };
-}
-function analyzeCollisionIntersections(entries, rawOptions = {}) {
-  const options = {
-    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_COLLISION_INSPECTION_OPTIONS.minOverlapVolume
-  };
-  const warnings = [];
-  const collisions = [];
-  const preparedEntries = entries.map((entry) => prepareEntry$1(entry));
-  for (let i = 0; i < preparedEntries.length; i += 1) {
-    for (let j = i + 1; j < preparedEntries.length; j += 1) {
-      const a = preparedEntries[i];
-      const b = preparedEntries[j];
-      if (!bboxOverlaps(a, b)) continue;
-      try {
-        const hit = a.shape.intersect(b.shape);
-        if (hit.isEmpty()) continue;
-        const overlapVolume = hit.volume();
-        if (!Number.isFinite(overlapVolume) || overlapVolume <= options.minOverlapVolume) continue;
-        collisions.push({
-          index: collisions.length + 1,
-          id: collisionId(a, b),
-          sourceIndex: i,
-          targetIndex: j,
-          sourceId: a.id,
-          targetId: b.id,
-          sourceName: a.name,
-          targetName: b.name,
-          overlapVolume,
-          shape: hit
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        warnings.push(`Could not boolean-test ${a.name} against ${b.name}: ${message}`);
-      }
-    }
-  }
-  const objects = preparedEntries.map((entry, index) => ({
-    index,
-    id: entry.id,
-    name: entry.name,
-    groupName: entry.groupName,
-    treePath: entry.treePath,
-    mock: entry.mock === true,
-    bbox: {
-      min: cloneVec3$1(entry.min),
-      max: cloneVec3$1(entry.max)
-    }
-  }));
-  return {
-    method: "boolean-intersection",
-    options,
-    objectCount: objects.length,
-    collisionCount: collisions.length,
-    objects,
-    collisions,
-    warnings
-  };
-}
 const DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
   contactTolerance: 0.05,
   minOverlapVolume: 0.1,
-  exactGeometry: false
+  exactGeometry: true
 };
 const AXIS_NAMES = ["x", "y", "z"];
-class UnionFind {
+let UnionFind$1 = class UnionFind {
   constructor(size) {
     __publicField(this, "parent");
     __publicField(this, "rank");
@@ -625,103 +492,42 @@ class UnionFind {
     this.parent[rootB] = rootA;
     this.rank[rootA] += 1;
   }
-}
+};
 function cloneVec3(value) {
   return [value[0], value[1], value[2]];
 }
-function emptyBBox() {
+function emptyBBox$1() {
   return {
     min: [Infinity, Infinity, Infinity],
     max: [-Infinity, -Infinity, -Infinity]
   };
 }
-function expandBBox(target, min, max) {
+function expandBBox$1(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 intervalGap$1(aMin, aMax, bMin, bMax) {
-  if (aMax < bMin) return bMin - aMax;
-  if (bMax < aMin) return aMin - bMax;
-  return 0;
-}
 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 bboxGaps(a, b) {
-  return [
-    intervalGap$1(a.min[0], a.max[0], b.min[0], b.max[0]),
-    intervalGap$1(a.min[1], a.max[1], b.min[1], b.max[1]),
-    intervalGap$1(a.min[2], a.max[2], b.min[2], b.max[2])
-  ];
-}
-function maxGap(gaps) {
-  return Math.max(gaps[0], gaps[1], gaps[2]);
-}
 function hasPositiveGap(gaps) {
   return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
 }
-function bboxInteriorOverlaps(a, b) {
-  for (let axis = 0; axis < 3; axis += 1) {
-    if (Math.min(a.max[axis], b.max[axis]) - Math.max(a.min[axis], b.min[axis]) <= 0) return false;
-  }
-  return true;
-}
-function bboxOverlapVolume(a, b) {
-  let volume = 1;
-  for (let axis = 0; axis < 3; axis += 1) {
-    volume *= Math.max(0, Math.min(a.max[axis], b.max[axis]) - Math.max(a.min[axis], b.min[axis]));
-  }
-  return volume;
-}
-function estimateSweepPairCount(entries, axis, tolerance) {
-  const ordered = entries.map((entry) => ({ min: entry.min[axis], max: entry.max[axis] })).sort((a, b) => a.min - b.min || a.max - b.max);
-  const endValues = ordered.map((entry) => entry.max + tolerance).sort((a, b) => a - b);
-  let expired = 0;
-  let count = 0;
-  for (let seen = 0; seen < ordered.length; seen += 1) {
-    const currentMin = ordered[seen].min;
-    while (expired < seen && endValues[expired] < currentMin) expired += 1;
-    count += seen - expired;
-  }
-  return count;
-}
-function chooseSweepAxis(entries, tolerance) {
-  let bestAxis = 0;
-  let bestCount = estimateSweepPairCount(entries, bestAxis, tolerance);
-  for (const axis of [1, 2]) {
-    const count = estimateSweepPairCount(entries, axis, tolerance);
-    if (count < bestCount) {
-      bestAxis = axis;
-      bestCount = count;
-    }
-  }
-  return bestAxis;
-}
 function collectCandidatePairs(entries, tolerance) {
   if (entries.length < 2) return [];
-  const axis = chooseSweepAxis(entries, tolerance);
-  const ordered = entries.map((entry, index) => ({ entry, index })).sort((a, b) => a.entry.min[axis] - b.entry.min[axis] || a.entry.max[axis] - b.entry.max[axis] || a.index - b.index);
-  let active = [];
-  const pairs = [];
-  for (const current of ordered) {
-    active = active.filter((candidate) => candidate.entry.max[axis] + tolerance >= current.entry.min[axis]);
-    for (const candidate of active) {
-      const gaps = bboxGaps(candidate.entry, current.entry);
-      if (maxGap(gaps) > tolerance) continue;
-      const sourceIndex = Math.min(candidate.index, current.index);
-      const targetIndex = Math.max(candidate.index, current.index);
-      pairs.push({ sourceIndex, targetIndex, gaps });
-    }
-    active.push(current);
-  }
+  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 contactFromBBoxes(a, b, tolerance) {
-  const gaps = bboxGaps(a, b);
-  const largestGap = maxGap(gaps);
+  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) {
@@ -768,21 +574,24 @@ function makeEdge(entries, sourceIndex, targetIndex, 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: rawOptions.exactGeometry ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.exactGeometry
+    exactGeometry,
+    mergeOverlappingBBoxes: rawOptions.mergeOverlappingBBoxes ?? !exactGeometry,
+    mergeTouchingBBoxes: rawOptions.mergeTouchingBBoxes ?? !exactGeometry
   };
   const warnings = [];
   const edges = [];
-  const unionFind = new UnionFind(entries.length);
+  const unionFind = new UnionFind$1(entries.length);
   for (const pair of collectCandidatePairs(entries, options.contactTolerance)) {
     const i = pair.sourceIndex;
     const j = pair.targetIndex;
     const a = entries[i];
     const b = entries[j];
-    const bboxOverlaps2 = !hasPositiveGap(pair.gaps) && bboxInteriorOverlaps(a, b);
-    if (options.exactGeometry && bboxOverlaps2) {
+    const bboxOverlaps = !hasPositiveGap(pair.gaps) && aabbInteriorOverlaps(a, b);
+    if (options.exactGeometry && bboxOverlaps) {
       const overlap = intersectionVolume(a, b);
       if (overlap.warning) warnings.push(overlap.warning);
       if (overlap.volume != null && overlap.volume > options.minOverlapVolume) {
@@ -797,32 +606,21 @@ function analyzePhysicalConnectivity(entries, rawOptions = {}) {
         );
         continue;
       }
-      if (overlap.volume != null && overlap.volume > 0) {
-        unionFind.union(i, j);
-        edges.push(
-          makeEdge(entries, i, j, {
-            kind: "touching",
-            method: "boolean-intersection",
-            gap: 0,
-            overlapVolume: overlap.volume
-          })
-        );
-        continue;
-      }
+      continue;
     }
-    if (bboxOverlaps2) {
+    if (bboxOverlaps && options.mergeOverlappingBBoxes) {
       unionFind.union(i, j);
       edges.push(
         makeEdge(entries, i, j, {
           kind: "overlap",
           method: "bbox-overlap",
           gap: 0,
-          overlapVolume: bboxOverlapVolume(a, b)
+          overlapVolume: aabbOverlapVolume(a, b)
         })
       );
     } else {
       const contact = contactFromBBoxes(a, b, options.contactTolerance);
-      if (!contact.touching) continue;
+      if (!contact.touching || !options.mergeTouchingBBoxes) continue;
       unionFind.union(i, j);
       edges.push(
         makeEdge(entries, i, j, {
@@ -861,7 +659,7 @@ function analyzePhysicalConnectivity(entries, rawOptions = {}) {
         objectNames: [],
         objectCount: 0,
         bodyCount: 0,
-        bbox: emptyBBox()
+        bbox: emptyBBox$1()
       };
       componentByRoot.set(root, component);
       rootToComponentIndex.set(root, component.index);
@@ -873,7 +671,7 @@ function analyzePhysicalConnectivity(entries, rawOptions = {}) {
     component.objectNames.push(object.name);
     component.objectCount += 1;
     component.bodyCount += object.bodyCount;
-    expandBBox(component.bbox, object.bbox.min, object.bbox.max);
+    expandBBox$1(component.bbox, object.bbox.min, object.bbox.max);
   }
   const components = [...componentByRoot.values()];
   return {
@@ -919,64 +717,38 @@ function defaultRootComponentIndex(components) {
   if (components.length === 0) return null;
   return components.reduce((best, component) => compareDefaultRoot(component, best) > 0 ? component : best, components[0]).index;
 }
-function buildGapEdges(components) {
-  const edges = [];
-  for (let i = 0; i < components.length; i += 1) {
-    for (let j = i + 1; j < components.length; j += 1) {
-      const source = components[i];
-      const target = components[j];
-      const gap = bboxGap(source, target);
-      if (!Number.isFinite(gap.gap)) continue;
-      edges.push({
-        sourceComponentIndex: source.index,
-        targetComponentIndex: target.index,
-        sourceObjectNames: [...source.objectNames],
-        targetObjectNames: [...target.objectNames],
-        gap: gap.gap,
-        axisGaps: gap.axisGaps
-      });
-    }
-  }
-  return edges;
-}
 function componentPositionByIndex(components) {
   return new Map(components.map((component, position) => [component.index, position]));
 }
-function computeNearestComponents(components, gapEdges) {
+function computeNearestComponents(components) {
   const nearest = components.map(() => ({ nearestGap: null, nearestComponentIndex: null }));
-  const positions = componentPositionByIndex(components);
-  for (const edge of gapEdges) {
-    const sourcePosition = positions.get(edge.sourceComponentIndex);
-    const targetPosition = positions.get(edge.targetComponentIndex);
-    if (sourcePosition == null || targetPosition == null) continue;
-    const source = nearest[sourcePosition];
-    if (source.nearestGap == null || edge.gap < source.nearestGap - EPSILON || Math.abs(edge.gap - source.nearestGap) <= EPSILON && edge.targetComponentIndex < (source.nearestComponentIndex ?? Infinity)) {
-      source.nearestGap = edge.gap;
-      source.nearestComponentIndex = edge.targetComponentIndex;
-    }
-    const target = nearest[targetPosition];
-    if (target.nearestGap == null || edge.gap < target.nearestGap - EPSILON || Math.abs(edge.gap - target.nearestGap) <= EPSILON && edge.sourceComponentIndex < (target.nearestComponentIndex ?? Infinity)) {
-      target.nearestGap = edge.gap;
-      target.nearestComponentIndex = edge.sourceComponentIndex;
+  for (let sourcePosition = 0; sourcePosition < components.length; sourcePosition += 1) {
+    for (let targetPosition = sourcePosition + 1; targetPosition < components.length; targetPosition += 1) {
+      const sourceComponent = components[sourcePosition];
+      const targetComponent = components[targetPosition];
+      const edge = bboxGap(sourceComponent, targetComponent);
+      if (!Number.isFinite(edge.gap)) continue;
+      const source = nearest[sourcePosition];
+      if (source.nearestGap == null || edge.gap < source.nearestGap - EPSILON || Math.abs(edge.gap - source.nearestGap) <= EPSILON && targetComponent.index < (source.nearestComponentIndex ?? Infinity)) {
+        source.nearestGap = edge.gap;
+        source.nearestComponentIndex = targetComponent.index;
+      }
+      const target = nearest[targetPosition];
+      if (target.nearestGap == null || edge.gap < target.nearestGap - EPSILON || Math.abs(edge.gap - target.nearestGap) <= EPSILON && sourceComponent.index < (target.nearestComponentIndex ?? Infinity)) {
+        target.nearestGap = edge.gap;
+        target.nearestComponentIndex = sourceComponent.index;
+      }
     }
   }
   return nearest;
 }
-function computeRootDistances(components, gapEdges, rootComponentIndex) {
+function computeRootDistances(components, rootComponentIndex) {
   if (rootComponentIndex == null) return [];
   const positions = componentPositionByIndex(components);
   const rootPosition = positions.get(rootComponentIndex);
   if (rootPosition == null) {
     throw new Error(`rootComponentIndex ${rootComponentIndex} does not match any physical component`);
   }
-  const adjacency = components.map(() => []);
-  for (const edge of gapEdges) {
-    const sourcePosition = positions.get(edge.sourceComponentIndex);
-    const targetPosition = positions.get(edge.targetComponentIndex);
-    if (sourcePosition == null || targetPosition == null) continue;
-    adjacency[sourcePosition].push({ to: targetPosition, gap: edge.gap });
-    adjacency[targetPosition].push({ to: sourcePosition, gap: edge.gap });
-  }
   const visited = components.map(() => false);
   const distances = components.map(() => Infinity);
   const parents = components.map(() => null);
@@ -992,13 +764,15 @@ function computeRootDistances(components, gapEdges, rootComponentIndex) {
     }
     if (current === -1 || !Number.isFinite(distances[current])) break;
     visited[current] = true;
-    for (const edge of adjacency[current]) {
-      if (visited[edge.to]) continue;
+    for (let targetPosition = 0; targetPosition < components.length; targetPosition += 1) {
+      if (visited[targetPosition] || targetPosition === current) continue;
+      const edge = bboxGap(components[current], components[targetPosition]);
+      if (!Number.isFinite(edge.gap)) continue;
       const nextDistance = distances[current] + edge.gap;
-      if (nextDistance < distances[edge.to] - EPSILON || Math.abs(nextDistance - distances[edge.to]) <= EPSILON && components[current].index < (parents[edge.to] ?? Infinity)) {
-        distances[edge.to] = nextDistance;
-        parents[edge.to] = components[current].index;
-        parentGaps[edge.to] = edge.gap;
+      if (nextDistance < distances[targetPosition] - EPSILON || Math.abs(nextDistance - distances[targetPosition]) <= EPSILON && components[current].index < (parents[targetPosition] ?? Infinity)) {
+        distances[targetPosition] = nextDistance;
+        parents[targetPosition] = components[current].index;
+        parentGaps[targetPosition] = edge.gap;
       }
     }
   }
@@ -1008,12 +782,44 @@ function computeRootDistances(components, gapEdges, rootComponentIndex) {
     parentGap: parentGaps[position]
   }));
 }
+function makeGapEdge(source, target) {
+  const gap = bboxGap(source, target);
+  return {
+    sourceComponentIndex: source.index,
+    targetComponentIndex: target.index,
+    sourceObjectNames: [...source.objectNames],
+    targetObjectNames: [...target.objectNames],
+    gap: gap.gap,
+    axisGaps: gap.axisGaps
+  };
+}
+function compactGapEdges(components, nearest, rooted) {
+  const componentByIndex = new Map(components.map((component) => [component.index, component]));
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  const add = (sourceIndex, targetIndex) => {
+    if (targetIndex == null || sourceIndex === targetIndex) return;
+    const source = componentByIndex.get(Math.min(sourceIndex, targetIndex));
+    const target = componentByIndex.get(Math.max(sourceIndex, targetIndex));
+    if (!source || !target) return;
+    const key = `${source.index}:${target.index}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push(makeGapEdge(source, target));
+  };
+  components.forEach((component, position) => {
+    var _a, _b;
+    add(component.index, ((_a = nearest[position]) == null ? void 0 : _a.nearestComponentIndex) ?? null);
+    add(component.index, ((_b = rooted[position]) == null ? void 0 : _b.parentComponentIndex) ?? null);
+  });
+  return edges.sort((a, b) => a.sourceComponentIndex - b.sourceComponentIndex || a.targetComponentIndex - b.targetComponentIndex);
+}
 function analyzeDistanceInspection(entries, rawOptions = {}) {
   const connectivity = analyzePhysicalConnectivity(entries, rawOptions);
   const rootComponentIndex = rawOptions.rootComponentIndex ?? defaultRootComponentIndex(connectivity.components);
-  const gapEdges = buildGapEdges(connectivity.components);
-  const nearest = computeNearestComponents(connectivity.components, gapEdges);
-  const rooted = computeRootDistances(connectivity.components, gapEdges, rootComponentIndex);
+  const nearest = computeNearestComponents(connectivity.components);
+  const rooted = computeRootDistances(connectivity.components, rootComponentIndex);
+  const gapEdges = compactGapEdges(connectivity.components, nearest, rooted);
   const componentByIndex = /* @__PURE__ */ new Map();
   const components = connectivity.components.map((component, position) => {
     var _a, _b;
@@ -1059,6 +865,7 @@ function analyzeDistanceInspection(entries, rawOptions = {}) {
     componentCount: connectivity.componentCount,
     rootComponentIndex,
     maxRootDistance,
+    gapEdgeCount: connectivity.components.length * (connectivity.components.length - 1) / 2,
     objects,
     components,
     gapEdges,
@@ -1334,10 +1141,210 @@ function summarizeThicknessSamples(samples, options) {
     unresolvedAreaPercent: percent(unresolvedArea, totalArea)
   };
 }
+const MIN_TRIANGLE_AREA = 1e-12;
+const R2_ALPHA = 0.7548776662466927;
+const R2_BETA = 0.5698402909980532;
+function readSurfaceTriangles(position) {
+  const triangles = [];
+  const a = new Vector3();
+  const b = new Vector3();
+  const c = new Vector3();
+  const ac = new Vector3();
+  const normal = new Vector3();
+  const triangleCount = Math.floor(position.count / 3);
+  for (let tri = 0; tri < triangleCount; tri += 1) {
+    const offset = tri * 3;
+    a.fromBufferAttribute(position, offset);
+    b.fromBufferAttribute(position, offset + 1);
+    c.fromBufferAttribute(position, offset + 2);
+    normal.subVectors(b, a).cross(ac.subVectors(c, a));
+    const areaTwice = normal.length();
+    if (areaTwice <= MIN_TRIANGLE_AREA) continue;
+    triangles.push({
+      index: tri,
+      a: a.clone(),
+      b: b.clone(),
+      c: c.clone(),
+      normal: normal.clone().multiplyScalar(1 / areaTwice),
+      area: areaTwice * 0.5
+    });
+  }
+  return triangles;
+}
+function allocateAreaSampleCounts(triangles, maxSamples) {
+  const sampleBudget = Math.max(1, Math.floor(maxSamples));
+  const counts = new Array(triangles.length).fill(0);
+  if (triangles.length === 0) return counts;
+  const totalArea = triangles.reduce((sum, triangle) => sum + triangle.area, 0);
+  if (!(totalArea > 0)) return counts;
+  const remainders = triangles.map((triangle, index) => {
+    const quota = triangle.area / totalArea * sampleBudget;
+    const whole = Math.floor(quota);
+    counts[index] += whole;
+    return { index, fraction: quota - whole, area: triangle.area };
+  });
+  let left = sampleBudget - counts.reduce((sum, count) => sum + count, 0);
+  remainders.sort((a, b) => b.fraction - a.fraction || b.area - a.area || a.index - b.index);
+  for (const entry of remainders) {
+    if (left <= 0) break;
+    counts[entry.index] += 1;
+    left -= 1;
+  }
+  return counts;
+}
+function sampleSurfaceTriangles(triangles, maxSamples) {
+  const counts = allocateAreaSampleCounts(triangles, maxSamples);
+  const samples = [];
+  const position = new Vector3();
+  let sampleIndex = 0;
+  triangles.forEach((triangle, triangleListIndex) => {
+    const count = counts[triangleListIndex];
+    if (count <= 0) return;
+    for (let localIndex = 0; localIndex < count; localIndex += 1) {
+      const barycentric = triangleBarycentricSample(triangle.index, localIndex, sampleIndex);
+      position.copy(triangle.a).multiplyScalar(barycentric[0]).addScaledVector(triangle.b, barycentric[1]).addScaledVector(triangle.c, barycentric[2]);
+      samples.push({
+        triangle,
+        position: position.clone(),
+        normal: triangle.normal.clone(),
+        area: triangle.area / count,
+        barycentric,
+        sampleIndex,
+        triangleSampleIndex: localIndex,
+        triangleSampleCount: count
+      });
+      sampleIndex += 1;
+    }
+  });
+  return samples;
+}
+function totalSurfaceArea(triangles) {
+  return triangles.reduce((sum, triangle) => sum + triangle.area, 0);
+}
+function triangleBarycentricSample(triangleIndex, triangleSampleIndex, sampleIndex) {
+  const seedA = hash01((triangleIndex + 1) * 1013);
+  const seedB = hash01((triangleIndex + 1) * 9176);
+  const u = clampUnit(fract(seedA + (sampleIndex + 1) * R2_ALPHA));
+  const v = clampUnit(fract(seedB + (triangleSampleIndex + 1) * R2_BETA));
+  const root = Math.sqrt(u);
+  return [1 - root, root * (1 - v), root * v];
+}
+function hash01(value) {
+  return fract(Math.sin(value * 12.9898) * 43758.5453123);
+}
+function fract(value) {
+  return value - Math.floor(value);
+}
+function clampUnit(value) {
+  return Math.min(1 - 1e-9, Math.max(1e-9, value));
+}
+function cloneGeometryForFaceColors(geometry) {
+  return geometry.index ? geometry.toNonIndexed() : geometry.clone();
+}
+function geometryMaxDimension(geometry) {
+  geometry.computeBoundingBox();
+  const box = geometry.boundingBox;
+  if (!box) return 1;
+  const size = new Vector3();
+  box.getSize(size);
+  return Math.max(1, size.x, size.y, size.z);
+}
+function firstOppositeSurfaceDistance(raycaster, mesh, point, direction, epsilon, far) {
+  const origin = point.clone().addScaledVector(direction, epsilon);
+  raycaster.set(origin, direction);
+  raycaster.near = epsilon;
+  raycaster.far = far;
+  const hit = raycaster.intersectObject(mesh, false).find((entry) => entry.distance > epsilon);
+  return hit ? hit.distance + epsilon : null;
+}
+function triangleThickness(raycaster, mesh, centroid, normal, epsilon, far) {
+  const forward = firstOppositeSurfaceDistance(raycaster, mesh, centroid, normal, epsilon, far);
+  const backward = firstOppositeSurfaceDistance(raycaster, mesh, centroid, normal.clone().negate(), epsilon, far);
+  if (forward == null) return backward;
+  if (backward == null) return forward;
+  return Math.min(forward, backward);
+}
+function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}) {
+  const options = resolveThicknessInspectionOptions(rawOptions);
+  const geometry = cloneGeometryForFaceColors(sourceGeometry);
+  const position = geometry.getAttribute("position");
+  if (!position || position.count < 3) {
+    return {
+      geometry,
+      samples: [],
+      pointSamples: [],
+      triangleCount: 0,
+      sampledTriangleCount: 0,
+      sampleStride: 1,
+      warnings: ["No triangle geometry."]
+    };
+  }
+  const triangleCount = Math.floor(position.count / 3);
+  const surfaceTriangles = readSurfaceTriangles(position);
+  const surfaceSamples = sampleSurfaceTriangles(surfaceTriangles, options.maxSamplesPerObject);
+  const maxDim = geometryMaxDimension(geometry);
+  const epsilon = Math.max(1e-4, maxDim * 1e-6);
+  const far = Math.max(maxDim * 4, options.maxThickness * 4, 1);
+  const colors = new Float32Array(position.count * 3);
+  const triangleThicknessValues = new Array(triangleCount).fill(void 0);
+  const samples = [];
+  const pointSamples = [];
+  const warnings = [];
+  const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
+  const rayMesh = new Mesh(geometry, rayMaterial);
+  const raycaster = new Raycaster();
+  if (surfaceTriangles.length === 0) {
+    warnings.push("No non-degenerate triangle surface was available for thickness sampling.");
+  } else if (surfaceSamples.length < surfaceTriangles.length) {
+    warnings.push(
+      `Area sampling budget ${surfaceSamples.length} covers ${surfaceTriangles.length} surface triangles; increase --thickness-samples for denser analysis.`
+    );
+  }
+  const sampledTriangleIndexes = /* @__PURE__ */ new Set();
+  for (const sample of surfaceSamples) {
+    sampledTriangleIndexes.add(sample.triangle.index);
+    const thickness = triangleThickness(raycaster, rayMesh, sample.position, sample.normal, epsilon, far);
+    samples.push({ thickness, area: sample.area });
+    const previous = triangleThicknessValues[sample.triangle.index];
+    if (previous === void 0 || previous == null || thickness != null && thickness < previous) {
+      triangleThicknessValues[sample.triangle.index] = thickness;
+    }
+    pointSamples.push({
+      position: [sample.position.x, sample.position.y, sample.position.z],
+      normal: [sample.normal.x, sample.normal.y, sample.normal.z],
+      value: thickness,
+      className: thicknessClass(thickness, options),
+      color: thicknessColor(thickness, options),
+      area: sample.area
+    });
+  }
+  for (let tri = 0; tri < triangleCount; tri += 1) {
+    const color = thicknessColor(triangleThicknessValues[tri], options);
+    const offset = tri * 3;
+    for (let vertex = 0; vertex < 3; vertex += 1) {
+      const colorOffset = (offset + vertex) * 3;
+      colors[colorOffset] = color[0] / 255;
+      colors[colorOffset + 1] = color[1] / 255;
+      colors[colorOffset + 2] = color[2] / 255;
+    }
+  }
+  geometry.setAttribute("color", new BufferAttribute(colors, 3));
+  rayMaterial.dispose();
+  return {
+    geometry,
+    samples,
+    pointSamples,
+    triangleCount,
+    sampledTriangleCount: sampledTriangleIndexes.size,
+    sampleStride: Math.max(1, Math.ceil(Math.max(1, surfaceTriangles.length) / Math.max(1, sampledTriangleIndexes.size))),
+    warnings
+  };
+}
 const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
   smoothAngleDeg: 5,
   sharpAngleDeg: 30,
-  harshAngleDeg: 90
+  harshAngleDeg: 90,
+  maxSamplesPerObject: 5e3
 };
 const ROUGHNESS_COLORS = {
   smooth: [62, 72, 84],
@@ -1349,7 +1356,8 @@ 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
+    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}).`);
@@ -1360,7 +1368,13 @@ function resolveRoughnessInspectionOptions(raw = {}) {
   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}).`);
   }
-  return options;
+  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";
@@ -1473,11 +1487,12 @@ function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
   const position = geometry.getAttribute("position");
   const warnings = [];
   if (!position || position.count < 3) {
-    return { geometry, summary: emptyRoughnessSummary(), warnings: ["No triangle geometry."] };
+    return { geometry, pointSamples: [], summary: emptyRoughnessSummary(), warnings: ["No triangle geometry."] };
   }
   const triangleCount = Math.floor(position.count / 3);
   const normals = new Array(triangleCount);
   const triangles = new Array(triangleCount);
+  const triangleEdgeAngles = Array.from({ length: triangleCount }, () => [0, 0, 0]);
   const edges = /* @__PURE__ */ new Map();
   const colors = new Float32Array(position.count * 3);
   const scores = new Float32Array(position.count);
@@ -1497,18 +1512,19 @@ function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
     const areaTwice = normal.length();
     triangles[tri] = { area: areaTwice * 0.5, maxAngleDeg: 0 };
     normals[tri] = areaTwice > 1e-12 ? normal.multiplyScalar(1 / areaTwice).clone() : new Vector3(0, 0, 1);
-    const keys = [vertexKey(a, snap), vertexKey(b, snap), vertexKey(c, snap)];
+    const keys = [vertexKey$1(a, snap), vertexKey$1(b, snap), vertexKey$1(c, snap)];
     for (let edge = 0; edge < 3; edge += 1) {
       const key = edgeKey(keys[edge], keys[(edge + 1) % 3]);
       let record = edges.get(key);
       if (!record) {
-        record = { triangles: [] };
+        record = { triangles: [], triangleEdges: [] };
         edges.set(key, record);
       }
       record.triangles.push(tri);
+      record.triangleEdges.push({ triangle: tri, edge });
     }
   }
-  const { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles } = markTriangleRoughness(edges, triangles, normals);
+  const { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles } = markTriangleRoughness(edges, triangles, normals, triangleEdgeAngles);
   if (boundaryEdgeCount > 0) warnings.push(`${boundaryEdgeCount} boundary edge(s) were treated as harsh roughness.`);
   if (nonManifoldEdgeCount > 0) warnings.push(`${nonManifoldEdgeCount} non-manifold edge(s) were treated as harsh roughness.`);
   for (let tri = 0; tri < triangleCount; tri += 1) {
@@ -1524,36 +1540,57 @@ function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
       scores[offset + vertex] = score;
     }
   }
+  const surfaceTriangles = readSurfaceTriangles(position);
+  const surfaceSamples = sampleSurfaceTriangles(surfaceTriangles, options.maxSamplesPerObject);
+  const edgeInfluenceRadius = roughnessEdgeInfluenceRadius(surfaceTriangles, surfaceSamples.length);
+  const pointSamples = surfaceSamples.map((sample) => {
+    const angleDeg = roughnessAngleAtSample(
+      sample.position,
+      sample.triangle,
+      triangleEdgeAngles[sample.triangle.index],
+      edgeInfluenceRadius
+    );
+    const color = roughnessColorForAngle(angleDeg, options);
+    return {
+      position: [sample.position.x, sample.position.y, sample.position.z],
+      normal: [sample.normal.x, sample.normal.y, sample.normal.z],
+      value: angleDeg,
+      className: roughnessClassForAngle(angleDeg, options),
+      color,
+      area: sample.area
+    };
+  });
   geometry.setAttribute("color", new BufferAttribute(colors, 3));
   geometry.setAttribute("roughnessScore", new BufferAttribute(scores, 1));
   geometry.computeBoundingBox();
   return {
     geometry,
+    pointSamples,
     summary: summarizeRoughnessTriangles(triangles, edgeAngles, edges.size, boundaryEdgeCount, nonManifoldEdgeCount, options),
     warnings
   };
 }
-function markTriangleRoughness(edges, triangles, normals) {
+function markTriangleRoughness(edges, triangles, normals, triangleEdgeAngles) {
   const edgeAngles = [];
   let boundaryEdgeCount = 0;
   let nonManifoldEdgeCount = 0;
   for (const edge of edges.values()) {
     if (edge.triangles.length === 1) {
       boundaryEdgeCount += 1;
-      markTriangles(edge.triangles, triangles, 180);
+      markEdge(edge, triangles, triangleEdgeAngles, 180);
       edgeAngles.push(180);
       continue;
     }
     if (edge.triangles.length > 2) {
       nonManifoldEdgeCount += 1;
-      markTriangles(edge.triangles, triangles, 180);
+      markEdge(edge, triangles, triangleEdgeAngles, 180);
       edgeAngles.push(180);
       continue;
     }
     const [first, second] = edge.triangles;
     const dot = MathUtils.clamp(normals[first].dot(normals[second]), -1, 1);
     const angleDeg = Math.acos(dot) * DEG_PER_RAD;
-    markTriangles(edge.triangles, triangles, angleDeg);
+    markEdge(edge, triangles, triangleEdgeAngles, angleDeg);
     edgeAngles.push(angleDeg);
   }
   return { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles };
@@ -1561,17 +1598,218 @@ function markTriangleRoughness(edges, triangles, normals) {
 function readVertex(position, index, target) {
   target.set(position.getX(index), position.getY(index), position.getZ(index));
 }
-function vertexKey(point, snap) {
+function vertexKey$1(point, snap) {
   return `${Math.round(point.x / snap)},${Math.round(point.y / snap)},${Math.round(point.z / snap)}`;
 }
 function edgeKey(a, b) {
   return a < b ? `${a}|${b}` : `${b}|${a}`;
 }
-function markTriangles(indices, triangles, angleDeg) {
-  for (const index of indices) {
-    triangles[index].maxAngleDeg = Math.max(triangles[index].maxAngleDeg, angleDeg);
+function markEdge(edge, triangles, triangleEdgeAngles, angleDeg) {
+  for (const { triangle, edge: edgeIndex } of edge.triangleEdges) {
+    triangles[triangle].maxAngleDeg = Math.max(triangles[triangle].maxAngleDeg, angleDeg);
+    triangleEdgeAngles[triangle][edgeIndex] = Math.max(triangleEdgeAngles[triangle][edgeIndex], angleDeg);
   }
 }
+function roughnessEdgeInfluenceRadius(triangles, sampleCount) {
+  if (triangles.length === 0 || sampleCount <= 0) return 0;
+  return Math.sqrt(totalSurfaceArea(triangles) / sampleCount);
+}
+function roughnessAngleAtSample(point, triangle, edgeAngles, influenceRadius) {
+  let angle = 0;
+  for (let edge = 0; edge < 3; edge += 1) {
+    const edgeAngle = edgeAngles[edge] ?? 0;
+    if (edgeAngle <= 0) continue;
+    const distance = pointDistanceToTriangleEdge(point, triangle, edge);
+    if (distance <= influenceRadius) angle = Math.max(angle, edgeAngle);
+  }
+  return angle;
+}
+function pointDistanceToTriangleEdge(point, triangle, edge) {
+  if (edge === 0) return pointSegmentDistance(point, triangle.a, triangle.b);
+  if (edge === 1) return pointSegmentDistance(point, triangle.b, triangle.c);
+  return pointSegmentDistance(point, triangle.c, triangle.a);
+}
+function pointSegmentDistance(point, start, end) {
+  const segment = end.clone().sub(start);
+  const lengthSq = segment.lengthSq();
+  if (lengthSq <= 1e-18) return point.distanceTo(start);
+  const t = MathUtils.clamp(point.clone().sub(start).dot(segment) / lengthSq, 0, 1);
+  return point.distanceTo(segment.multiplyScalar(t).add(start));
+}
+const DEFAULT_VERTEX_TOLERANCE = 1e-5;
+class UnionFind2 {
+  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 emptyBBox() {
+  return {
+    min: [Infinity, Infinity, Infinity],
+    max: [-Infinity, -Infinity, -Infinity]
+  };
+}
+function expandBBox(bbox, x, y, z) {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return;
+  bbox.min[0] = Math.min(bbox.min[0], x);
+  bbox.min[1] = Math.min(bbox.min[1], y);
+  bbox.min[2] = Math.min(bbox.min[2], z);
+  bbox.max[0] = Math.max(bbox.max[0], x);
+  bbox.max[1] = Math.max(bbox.max[1], y);
+  bbox.max[2] = Math.max(bbox.max[2], z);
+}
+function vertexKey(positions, vertexIndex, tolerance) {
+  const base = vertexIndex * 3;
+  const x = positions[base];
+  const y = positions[base + 1];
+  const z = positions[base + 2];
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return null;
+  return `${Math.round(x / tolerance)},${Math.round(y / tolerance)},${Math.round(z / tolerance)}`;
+}
+function analyzeMeshConnectedComponents(positions, vertexTolerance = DEFAULT_VERTEX_TOLERANCE) {
+  const vertexCount = Math.floor(positions.length / 3);
+  const triangleCount = Math.floor(vertexCount / 3);
+  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 UnionFind2(triangleCount);
+  const vertexOwnerByKey = /* @__PURE__ */ new Map();
+  for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
+    for (let corner = 0; corner < 3; corner += 1) {
+      const key = vertexKey(positions, triangleIndex * 3 + corner, tolerance);
+      if (key == null) continue;
+      const owner = vertexOwnerByKey.get(key);
+      if (owner === void 0) {
+        vertexOwnerByKey.set(key, triangleIndex);
+      } else {
+        unionFind.union(triangleIndex, owner);
+      }
+    }
+  }
+  const componentIndexByRoot = /* @__PURE__ */ new Map();
+  const components = [];
+  for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
+    const root = unionFind.find(triangleIndex);
+    let componentIndex = componentIndexByRoot.get(root);
+    if (componentIndex === void 0) {
+      componentIndex = components.length;
+      componentIndexByRoot.set(root, componentIndex);
+      components.push({
+        index: componentIndex,
+        triangleIndexes: [],
+        vertexCount: 0,
+        bbox: emptyBBox()
+      });
+    }
+    const component = components[componentIndex];
+    component.triangleIndexes.push(triangleIndex);
+    component.vertexCount += 3;
+    for (let corner = 0; corner < 3; corner += 1) {
+      const vertexIndex = triangleIndex * 3 + corner;
+      const base = vertexIndex * 3;
+      vertexComponentIndexes[vertexIndex] = componentIndex;
+      expandBBox(component.bbox, positions[base], positions[base + 1], positions[base + 2]);
+    }
+  }
+  return { components, vertexComponentIndexes };
+}
+function isFiniteComponent(component) {
+  return component.bbox.min.every(Number.isFinite) && component.bbox.max.every(Number.isFinite);
+}
+function objectConnectivityEntry(object) {
+  return {
+    id: object.id,
+    name: object.name,
+    shape: object.shape,
+    min: object.min,
+    max: object.max,
+    groupName: object.groupName,
+    treePath: object.treePath,
+    mock: object.mock,
+    bodyCount: 1
+  };
+}
+function buildMeshBodyConnectivityInput(objects, options) {
+  const entries = [];
+  const bodyIdsByObjectId = /* @__PURE__ */ new Map();
+  const vertexComponentIndexesByObjectId = /* @__PURE__ */ new Map();
+  for (const object of objects) {
+    if (!object.positions || object.positions.length < 9) {
+      entries.push(objectConnectivityEntry(object));
+      continue;
+    }
+    const meshComponents = analyzeMeshConnectedComponents(object.positions);
+    const finiteComponents = meshComponents.components.filter(isFiniteComponent);
+    if (finiteComponents.length <= 1) {
+      entries.push(objectConnectivityEntry(object));
+      continue;
+    }
+    const bodyIds = Array.from({ length: meshComponents.components.length }, (_, index) => `${object.id}:body:${index + 1}`);
+    for (const component of finiteComponents) {
+      entries.push({
+        id: bodyIds[component.index],
+        name: `${object.name} body ${component.index + 1}`,
+        shape: options.bodyShape(object, component),
+        min: component.bbox.min,
+        max: component.bbox.max,
+        groupName: object.groupName,
+        treePath: object.treePath,
+        mock: object.mock,
+        bodyCount: 1
+      });
+    }
+    bodyIdsByObjectId.set(object.id, bodyIds);
+    vertexComponentIndexesByObjectId.set(object.id, meshComponents.vertexComponentIndexes);
+  }
+  return { entries, bodyIdsByObjectId, vertexComponentIndexesByObjectId };
+}
+function meshVertexColorBuffersFor(input, colorForEntryId) {
+  const out = /* @__PURE__ */ new Map();
+  const colorByEntryId = /* @__PURE__ */ new Map();
+  for (const [objectId, vertexComponentIndexes] of input.vertexComponentIndexesByObjectId) {
+    const bodyIds = input.bodyIdsByObjectId.get(objectId);
+    if (!bodyIds) continue;
+    const colors = new Float32Array(vertexComponentIndexes.length * 3);
+    for (let vertexIndex = 0; vertexIndex < vertexComponentIndexes.length; vertexIndex += 1) {
+      const bodyId = bodyIds[vertexComponentIndexes[vertexIndex]];
+      let color = colorByEntryId.get(bodyId);
+      if (!color) {
+        color = colorForEntryId(bodyId);
+        colorByEntryId.set(bodyId, color);
+      }
+      const offset = vertexIndex * 3;
+      colors[offset] = color[0];
+      colors[offset + 1] = color[1];
+      colors[offset + 2] = color[2];
+    }
+    out.set(objectId, colors);
+  }
+  return out;
+}
 const canvas = document.getElementById("canvas");
 const exportCanvas = document.createElement("canvas");
 const exportCtx = exportCanvas.getContext("2d");
@@ -1605,6 +1843,14 @@ function createCaptureDebugLogger(enabled) {
     console.info(`[forge-capture:debug] +${sinceStart}ms Δ${delta}ms ${phase}${detailText}`);
   };
 }
+class EmptyInspectionShape {
+  intersect() {
+    return {
+      isEmpty: () => true,
+      volume: () => 0
+    };
+  }
+}
 const COLLISION_SOURCE_OPACITY = 0.22;
 const COLLISION_SOURCE_COLOR = [180, 200, 220];
 const COLLISION_HIGHLIGHT_COLOR = [255, 68, 16];
@@ -1648,6 +1894,31 @@ const MASK_PALETTE = [
   [0, 0, 128],
   [128, 128, 128]
 ];
+function cloneShapePositions(shape) {
+  const geometry = shapeToGeometry(shape);
+  try {
+    const position = geometry.solid.getAttribute("position");
+    if (!position) return void 0;
+    return new Float32Array(position.array);
+  } finally {
+    geometry.solid.dispose();
+    geometry.edges.dispose();
+  }
+}
+function meshConnectivitySource(entry) {
+  const bb = entry.shape.boundingBox();
+  return {
+    id: entry.source.id,
+    name: entry.source.name,
+    shape: entry.shape,
+    min: [bb.min[0], bb.min[1], bb.min[2]],
+    max: [bb.max[0], bb.max[1], bb.max[2]],
+    groupName: entry.source.groupName,
+    treePath: entry.source.treePath,
+    mock: entry.source.mock,
+    positions: cloneShapePositions(entry.shape)
+  };
+}
 function summarizeSceneGeometry(entries) {
   const min = [Infinity, Infinity, Infinity];
   const max = [-Infinity, -Infinity, -Infinity];
@@ -2021,91 +2292,16 @@ function distanceColorForRootDistance(distance, maxDistance) {
   if (t <= 0.5) return lerpColor(DISTANCE_NEAR_COLOR, DISTANCE_MID_COLOR, t * 2);
   return lerpColor(DISTANCE_MID_COLOR, DISTANCE_FAR_COLOR, (t - 0.5) * 2);
 }
-function cloneGeometryForFaceColors(geometry) {
-  return geometry.index ? geometry.toNonIndexed() : geometry.clone();
-}
-function geometryMaxDimension(geometry) {
-  geometry.computeBoundingBox();
-  const box = geometry.boundingBox;
-  if (!box) return 1;
-  const size = new Vector3();
-  box.getSize(size);
-  return Math.max(1, size.x, size.y, size.z);
-}
-function firstOppositeSurfaceDistance(raycaster, mesh, point, direction, epsilon, far) {
-  const origin = point.clone().addScaledVector(direction, epsilon);
-  raycaster.set(origin, direction);
-  raycaster.near = epsilon;
-  raycaster.far = far;
-  const hit = raycaster.intersectObject(mesh, false).find((entry) => entry.distance > epsilon);
-  return hit ? hit.distance + epsilon : null;
-}
-function triangleThickness(raycaster, mesh, centroid, normal, epsilon, far) {
-  const forward = firstOppositeSurfaceDistance(raycaster, mesh, centroid, normal, epsilon, far);
-  const backward = firstOppositeSurfaceDistance(raycaster, mesh, centroid, normal.clone().negate(), epsilon, far);
-  if (forward == null) return backward;
-  if (backward == null) return forward;
-  return Math.min(forward, backward);
+function rgbFloats(color) {
+  return [color[0] / 255, color[1] / 255, color[2] / 255];
 }
-function analyzeThicknessGeometry(sourceGeometry, options) {
-  const geometry = cloneGeometryForFaceColors(sourceGeometry);
-  const position = geometry.getAttribute("position");
-  if (!position || position.count < 3) {
-    return { geometry, samples: [], triangleCount: 0, sampledTriangleCount: 0, sampleStride: 1, warnings: ["No triangle geometry."] };
-  }
-  const triangleCount = Math.floor(position.count / 3);
-  const sampleStride = Math.max(1, Math.ceil(triangleCount / options.maxSamplesPerObject));
-  const maxDim = geometryMaxDimension(geometry);
-  const epsilon = Math.max(1e-4, maxDim * 1e-6);
-  const far = Math.max(maxDim * 4, options.maxThickness * 4, 1);
-  const colors = new Float32Array(position.count * 3);
-  const samples = [];
-  const warnings = [];
-  const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
-  const rayMesh = new Mesh(geometry, rayMaterial);
-  const raycaster = new Raycaster();
-  if (sampleStride > 1) {
-    warnings.push(`Triangle sampling stride ${sampleStride}; increase --thickness-samples for denser analysis.`);
-  }
-  const a = new Vector3();
-  const b = new Vector3();
-  const c = new Vector3();
-  const normal = new Vector3();
-  const centroid = new Vector3();
-  let sampledTriangleCount = 0;
-  let lastThickness = null;
-  for (let tri = 0; tri < triangleCount; tri += 1) {
-    const offset = tri * 3;
-    a.fromBufferAttribute(position, offset);
-    b.fromBufferAttribute(position, offset + 1);
-    c.fromBufferAttribute(position, offset + 2);
-    normal.subVectors(b, a).cross(new Vector3().subVectors(c, a));
-    const areaTwice = normal.length();
-    const area = areaTwice * 0.5;
-    let thickness = lastThickness;
-    if (tri % sampleStride === 0) {
-      sampledTriangleCount += 1;
-      if (areaTwice <= 1e-12) {
-        thickness = null;
-      } else {
-        normal.multiplyScalar(1 / areaTwice);
-        centroid.copy(a).add(b).add(c).multiplyScalar(1 / 3);
-        thickness = triangleThickness(raycaster, rayMesh, centroid, normal, epsilon, far);
-      }
-      lastThickness = thickness;
-      samples.push({ thickness, area });
-    }
-    const color = thicknessColor(thickness, options);
-    for (let vertex = 0; vertex < 3; vertex += 1) {
-      const colorOffset = (offset + vertex) * 3;
-      colors[colorOffset] = color[0] / 255;
-      colors[colorOffset + 1] = color[1] / 255;
-      colors[colorOffset + 2] = color[2] / 255;
-    }
-  }
+function geometryWithVertexColors(renderable, colors) {
+  if (!colors) return null;
+  const position = renderable.solid.geometry.getAttribute("position");
+  if (!position || colors.length !== position.count * 3) return null;
+  const geometry = renderable.solid.geometry.clone();
   geometry.setAttribute("color", new BufferAttribute(colors, 3));
-  rayMaterial.dispose();
-  return { geometry, samples, triangleCount, sampledTriangleCount, sampleStride, warnings };
+  return geometry;
 }
 function buildMaskEntries(session) {
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
@@ -2196,6 +2392,7 @@ function decorateConnectivityReport(report) {
   return {
     method: report.method,
     options: report.options,
+    broadphase: report.broadphase,
     objectCount: report.objectCount,
     componentCount: report.componentCount,
     objects,
@@ -2208,30 +2405,26 @@ function renderCurrentConnectivity(session, rawReport) {
   const r = getRenderer(session.size, session.pixelRatio);
   const report = rawReport ?? analyzeSessionConnectivity(session);
   const byId = new Map(report.objects.map((object) => [object.id, object]));
+  const vertexColorsById = session.connectivityBodyInput ? meshVertexColorBuffersFor(session.connectivityBodyInput, (entryId) => {
+    const object = byId.get(entryId);
+    return rgbFloats(object ? maskColorForIndex(object.componentIndex) : [128, 128, 128]);
+  }) : /* @__PURE__ */ new Map();
   const replacements = session.renderables.map((renderable) => {
     const object = byId.get(renderable.id);
     const color = object ? maskColorForIndex(object.componentIndex) : [128, 128, 128];
-    const material = new ShaderMaterial({
-      uniforms: {
-        connectivityColor: { value: new Vector3(color[0] / 255, color[1] / 255, color[2] / 255) }
-      },
-      vertexShader: `
-        void main() {
-          gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-        }
-      `,
-      fragmentShader: `
-        precision highp float;
-        uniform vec3 connectivityColor;
-        void main() {
-          gl_FragColor = vec4(connectivityColor, 1.0);
-        }
-      `
+    const previousMaterial = renderable.solid.material;
+    const previousGeometry = renderable.solid.geometry;
+    const vertexGeometry = geometryWithVertexColors(renderable, vertexColorsById.get(renderable.id));
+    const material = new MeshBasicMaterial({
+      color: vertexGeometry ? 16777215 : new Color(color[0] / 255, color[1] / 255, color[2] / 255),
+      vertexColors: Boolean(vertexGeometry),
+      side: DoubleSide,
+      clippingPlanes: renderable.solidMaterial.clippingPlanes ?? null
     });
     material.toneMapped = false;
-    const previousMaterial = renderable.solid.material;
+    if (vertexGeometry) renderable.solid.geometry = vertexGeometry;
     renderable.solid.material = material;
-    return { renderable, previousMaterial, material };
+    return { renderable, previousMaterial, previousGeometry, vertexGeometry, material };
   });
   try {
     const png = withSolidOnlyVisibility(
@@ -2244,8 +2437,10 @@ function renderCurrentConnectivity(session, rawReport) {
     );
     return { png, report: decorateConnectivityReport(report) };
   } finally {
-    replacements.forEach(({ renderable, previousMaterial, material }) => {
+    replacements.forEach(({ renderable, previousMaterial, previousGeometry, vertexGeometry, material }) => {
       renderable.solid.material = previousMaterial;
+      renderable.solid.geometry = previousGeometry;
+      vertexGeometry == null ? void 0 : vertexGeometry.dispose();
       material.dispose();
     });
   }
@@ -2284,6 +2479,7 @@ function decorateDistanceReport(report) {
     maxRootDistance: report.maxRootDistance,
     objects,
     components,
+    gapEdgeCount: report.gapEdgeCount,
     gapEdges: report.gapEdges,
     connectivity: report.connectivity,
     warnings: report.warnings,
@@ -2303,30 +2499,26 @@ function renderCurrentDistance(session) {
   const r = getRenderer(session.size, session.pixelRatio);
   const report = decorateDistanceReport(analyzeSessionDistance(session));
   const byId = new Map(report.objects.map((object) => [object.id, object]));
+  const vertexColorsById = session.connectivityBodyInput ? meshVertexColorBuffersFor(session.connectivityBodyInput, (entryId) => {
+    var _a;
+    return rgbFloats(((_a = byId.get(entryId)) == null ? void 0 : _a.color) ?? DISTANCE_UNKNOWN_COLOR);
+  }) : /* @__PURE__ */ new Map();
   const replacements = session.renderables.map((renderable) => {
     const object = byId.get(renderable.id);
     const color = (object == null ? void 0 : object.color) ?? DISTANCE_UNKNOWN_COLOR;
-    const material = new ShaderMaterial({
-      uniforms: {
-        distanceColor: { value: new Vector3(color[0] / 255, color[1] / 255, color[2] / 255) }
-      },
-      vertexShader: `
-        void main() {
-          gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-        }
-      `,
-      fragmentShader: `
-        precision highp float;
-        uniform vec3 distanceColor;
-        void main() {
-          gl_FragColor = vec4(distanceColor, 1.0);
-        }
-      `
+    const previousMaterial = renderable.solid.material;
+    const previousGeometry = renderable.solid.geometry;
+    const vertexGeometry = geometryWithVertexColors(renderable, vertexColorsById.get(renderable.id));
+    const material = new MeshBasicMaterial({
+      color: vertexGeometry ? 16777215 : new Color(color[0] / 255, color[1] / 255, color[2] / 255),
+      vertexColors: Boolean(vertexGeometry),
+      side: DoubleSide,
+      clippingPlanes: renderable.solidMaterial.clippingPlanes ?? null
     });
     material.toneMapped = false;
-    const previousMaterial = renderable.solid.material;
+    if (vertexGeometry) renderable.solid.geometry = vertexGeometry;
     renderable.solid.material = material;
-    return { renderable, previousMaterial, material };
+    return { renderable, previousMaterial, previousGeometry, vertexGeometry, material };
   });
   try {
     const png = withSolidOnlyVisibility(
@@ -2339,8 +2531,10 @@ function renderCurrentDistance(session) {
     );
     return { png, report };
   } finally {
-    replacements.forEach(({ renderable, previousMaterial, material }) => {
+    replacements.forEach(({ renderable, previousMaterial, previousGeometry, vertexGeometry, material }) => {
       renderable.solid.material = previousMaterial;
+      renderable.solid.geometry = previousGeometry;
+      vertexGeometry == null ? void 0 : vertexGeometry.dispose();
       material.dispose();
     });
   }
@@ -2440,26 +2634,113 @@ function renderCurrentCollisions(session) {
     collisionMaterials.forEach((material) => material.dispose());
   }
 }
-function renderCurrentThickness(session, rawOptions) {
+function inspectionOptionsKey(value) {
+  return JSON.stringify(value ?? {});
+}
+function bboxFromGeometry(geometry) {
+  geometry.computeBoundingBox();
+  const bbox = geometry.boundingBox;
+  return {
+    min: bbox ? [bbox.min.x, bbox.min.y, bbox.min.z] : [0, 0, 0],
+    max: bbox ? [bbox.max.x, bbox.max.y, bbox.max.z] : [0, 0, 0]
+  };
+}
+function pointBuffersFromSamples(samples, offset = 0.025) {
+  const positions = new Float32Array(samples.length * 3);
+  const colors = new Float32Array(samples.length * 3);
+  samples.forEach((sample, index) => {
+    const base = index * 3;
+    positions[base] = sample.position[0] + sample.normal[0] * offset;
+    positions[base + 1] = sample.position[1] + sample.normal[1] * offset;
+    positions[base + 2] = sample.position[2] + sample.normal[2] * offset;
+    colors[base] = sample.color[0] / 255;
+    colors[base + 1] = sample.color[1] / 255;
+    colors[base + 2] = sample.color[2] / 255;
+  });
+  return { positions, colors };
+}
+function renderScalarPointOverlays(session, overlays) {
   const r = getRenderer(session.size, session.pixelRatio);
+  const overlayById = new Map(overlays.map((overlay) => [overlay.renderable.id, overlay]));
+  const replacements = session.renderables.map((renderable) => {
+    const previousMaterial = renderable.solid.material;
+    const ghostMaterial = new MeshBasicMaterial({
+      color: new Color(2502970),
+      transparent: true,
+      opacity: 0.24,
+      depthWrite: true,
+      depthTest: true,
+      side: DoubleSide,
+      clippingPlanes: renderable.solidMaterial.clippingPlanes ?? void 0
+    });
+    ghostMaterial.toneMapped = false;
+    renderable.solid.material = ghostMaterial;
+    const overlay = overlayById.get(renderable.id);
+    if (!overlay || overlay.positions.length === 0)
+      return { renderable, previousMaterial, ghostMaterial, points: null, geometry: null, material: null };
+    const geometry = new BufferGeometry();
+    geometry.setAttribute("position", new BufferAttribute(overlay.positions, 3));
+    geometry.setAttribute("color", new BufferAttribute(overlay.colors, 3));
+    const material = new PointsMaterial({
+      size: 3,
+      sizeAttenuation: false,
+      vertexColors: true,
+      depthTest: true,
+      depthWrite: false,
+      clippingPlanes: renderable.solidMaterial.clippingPlanes ?? void 0
+    });
+    material.toneMapped = false;
+    const points = new Points(geometry, material);
+    points.renderOrder = 5;
+    points.raycast = () => null;
+    renderable.root.add(points);
+    return { renderable, previousMaterial, ghostMaterial, points, geometry, material };
+  });
+  try {
+    return withSolidOnlyVisibility(
+      session,
+      () => withTemporarySceneBackground(session, new Color(0), () => {
+        updateSdfRaymarchUniforms(session);
+        r.render(session.scene, session.camera);
+        return captureRenderedPng(session.size);
+      })
+    );
+  } finally {
+    replacements.forEach(({ renderable, previousMaterial, ghostMaterial, points, geometry, material }) => {
+      if (points) renderable.root.remove(points);
+      renderable.solid.material = previousMaterial;
+      ghostMaterial.dispose();
+      geometry == null ? void 0 : geometry.dispose();
+      material == null ? void 0 : material.dispose();
+    });
+  }
+}
+function getSessionThicknessInspection(session, rawOptions) {
+  var _a;
   const options = resolveThicknessInspectionOptions(rawOptions);
-  const material = new MeshBasicMaterial({ vertexColors: true });
-  material.toneMapped = false;
+  const optionsKey = inspectionOptionsKey(options);
+  if (((_a = session.thicknessInspection) == null ? void 0 : _a.optionsKey) === optionsKey) return session.thicknessInspection;
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   const warnings = [];
   const objects = [];
-  const replacements = session.renderables.map((renderable, index) => {
-    const previousMaterial = renderable.solid.material;
-    const previousGeometry = renderable.solid.geometry;
-    const analysis = analyzeThicknessGeometry(previousGeometry, options);
-    const bbox = analysis.geometry.boundingBox;
-    const summary = summarizeThicknessSamples(analysis.samples, options);
+  const cloudObjects = [];
+  const points = [];
+  const overlays = [];
+  session.renderables.forEach((renderable, index) => {
     const sourceObject = byId.get(renderable.id);
+    if (renderable.sdfRaymarch) {
+      warnings.push(`${renderable.name}: SDF raymarch objects are not included in mesh thickness inspection.`);
+      return;
+    }
+    const analysis = analyzeThicknessGeometry(renderable.solid.geometry, options);
+    const bbox = bboxFromGeometry(analysis.geometry);
+    const summary = summarizeThicknessSamples(analysis.samples, options);
     if (analysis.warnings.length > 0) {
       analysis.warnings.forEach((warning) => warnings.push(`${renderable.name}: ${warning}`));
     }
+    const objectIndex = index + 1;
     objects.push({
-      index: index + 1,
+      index: objectIndex,
       id: renderable.id,
       name: renderable.name,
       groupName: renderable.groupName,
@@ -2468,174 +2749,154 @@ function renderCurrentThickness(session, rawOptions) {
       triangleCount: analysis.triangleCount,
       sampledTriangleCount: analysis.sampledTriangleCount,
       sampleStride: analysis.sampleStride,
-      bbox: {
-        min: bbox ? [bbox.min.x, bbox.min.y, bbox.min.z] : [0, 0, 0],
-        max: bbox ? [bbox.max.x, bbox.max.y, bbox.max.z] : [0, 0, 0]
-      },
+      bbox,
       ...summary
     });
-    renderable.solid.geometry = analysis.geometry;
-    renderable.solid.material = material;
-    return { renderable, previousMaterial, previousGeometry, geometry: analysis.geometry };
+    cloudObjects.push({
+      index: objectIndex,
+      id: renderable.id,
+      name: renderable.name,
+      groupName: renderable.groupName,
+      treePath: sourceObject == null ? void 0 : sourceObject.treePath,
+      mock: (sourceObject == null ? void 0 : sourceObject.mock) === true,
+      sampleCount: analysis.pointSamples.length,
+      bbox
+    });
+    analysis.pointSamples.forEach((sample) => {
+      points.push({
+        objectIndex,
+        objectId: renderable.id,
+        objectName: renderable.name,
+        ...sample
+      });
+    });
+    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples) });
+    analysis.geometry.dispose();
   });
-  try {
-    const png = withSolidOnlyVisibility(
-      session,
-      () => withTemporarySceneBackground(session, new Color(0), () => {
-        updateSdfRaymarchUniforms(session);
-        r.render(session.scene, session.camera);
-        return captureRenderedPng(session.size);
-      })
-    );
-    return {
-      png,
-      report: {
-        method: "mesh-normal-raycast",
-        options,
-        objectCount: objects.length,
-        objects,
-        warnings,
-        style: {
-          criticalColor: THICKNESS_COLORS.critical,
-          warningColor: THICKNESS_COLORS.warning,
-          okColor: THICKNESS_COLORS.ok,
-          thickColor: THICKNESS_COLORS.thick,
-          unknownColor: THICKNESS_COLORS.unknown
-        }
+  const state = {
+    optionsKey,
+    overlays,
+    pointCloud: {
+      schemaVersion: 1,
+      property: "thickness",
+      coordinateSpace: "object-local",
+      units: "model",
+      sampleCount: points.length,
+      objects: cloudObjects,
+      points
+    },
+    report: {
+      method: "mesh-normal-raycast",
+      options,
+      objectCount: objects.length,
+      objects,
+      warnings,
+      style: {
+        criticalColor: THICKNESS_COLORS.critical,
+        warningColor: THICKNESS_COLORS.warning,
+        okColor: THICKNESS_COLORS.ok,
+        thickColor: THICKNESS_COLORS.thick,
+        unknownColor: THICKNESS_COLORS.unknown
       }
-    };
-  } finally {
-    replacements.forEach(({ renderable, previousMaterial, previousGeometry, geometry }) => {
-      renderable.solid.geometry = previousGeometry;
-      renderable.solid.material = previousMaterial;
-      geometry.dispose();
-    });
-    material.dispose();
-  }
+    }
+  };
+  session.thicknessInspection = state;
+  return state;
+}
+function renderCurrentThickness(session, rawOptions) {
+  const state = getSessionThicknessInspection(session, rawOptions);
+  return { png: renderScalarPointOverlays(session, state.overlays), report: state.report, pointCloud: state.pointCloud };
 }
 const ROUGHNESS_SMOOTH_OPACITY = 0.16;
 const ROUGHNESS_HARSH_OPACITY = 1;
-function createRoughnessMaterial(clippingPlanes) {
-  const material = new ShaderMaterial({
-    transparent: true,
-    depthTest: true,
-    depthWrite: true,
-    clippingPlanes: clippingPlanes ?? void 0,
-    uniforms: {
-      smoothOpacity: { value: ROUGHNESS_SMOOTH_OPACITY },
-      harshOpacity: { value: ROUGHNESS_HARSH_OPACITY }
-    },
-    vertexShader: `
-      attribute vec3 color;
-      attribute float roughnessScore;
-      varying vec3 vColor;
-      varying float vRoughnessScore;
-      varying vec3 vViewNormal;
-
-      void main() {
-        vColor = color;
-        vRoughnessScore = roughnessScore;
-        vViewNormal = normalize(normalMatrix * normal);
-        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-      }
-    `,
-    fragmentShader: `
-      precision highp float;
-      uniform float smoothOpacity;
-      uniform float harshOpacity;
-      varying vec3 vColor;
-      varying float vRoughnessScore;
-      varying vec3 vViewNormal;
-
-      void main() {
-        vec3 shadowLight = normalize(vec3(0.32, 0.42, 0.84));
-        float shade = 0.34 + 0.48 * max(dot(normalize(vViewNormal), shadowLight), 0.0);
-        vec3 smoothShadow = vec3(0.26, 0.30, 0.35) * shade;
-        float colorMix = smoothstep(0.04, 0.35, vRoughnessScore);
-        vec3 finalColor = mix(smoothShadow, vColor, colorMix);
-        float alpha = mix(smoothOpacity, harshOpacity, smoothstep(0.02, 0.55, vRoughnessScore));
-        gl_FragColor = vec4(finalColor, alpha);
-      }
-    `
-  });
-  material.toneMapped = false;
-  return material;
-}
 function renderCurrentRoughness(session, rawOptions) {
-  const r = getRenderer(session.size, session.pixelRatio);
+  const state = getSessionRoughnessInspection(session, rawOptions);
+  return { png: renderScalarPointOverlays(session, state.overlays), report: state.report, pointCloud: state.pointCloud };
+}
+function getSessionRoughnessInspection(session, rawOptions) {
+  var _a;
   const options = resolveRoughnessInspectionOptions(rawOptions);
+  const optionsKey = inspectionOptionsKey(options);
+  if (((_a = session.roughnessInspection) == null ? void 0 : _a.optionsKey) === optionsKey) return session.roughnessInspection;
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   const warnings = [];
   const objects = [];
-  const replacements = session.renderables.map((renderable, index) => {
-    const previousMaterial = renderable.solid.material;
-    const previousGeometry = renderable.solid.geometry;
+  const cloudObjects = [];
+  const points = [];
+  const overlays = [];
+  session.renderables.forEach((renderable, index) => {
     if (renderable.sdfRaymarch) {
-      const material2 = new MeshBasicMaterial({ transparent: true, opacity: 0, depthWrite: false });
-      material2.toneMapped = false;
-      renderable.solid.material = material2;
       warnings.push(`${renderable.name}: SDF raymarch objects are not included in mesh roughness inspection.`);
-      return { renderable, previousMaterial, previousGeometry, material: material2, geometry: null };
+      return;
     }
-    const analysis = analyzeRoughnessGeometry(previousGeometry, options);
-    const bbox = analysis.geometry.boundingBox;
+    const analysis = analyzeRoughnessGeometry(renderable.solid.geometry, options);
+    const bbox = bboxFromGeometry(analysis.geometry);
     const sourceObject = byId.get(renderable.id);
     if (analysis.warnings.length > 0) {
       analysis.warnings.forEach((warning) => warnings.push(`${renderable.name}: ${warning}`));
     }
+    const objectIndex = index + 1;
     objects.push({
-      index: index + 1,
+      index: objectIndex,
       id: renderable.id,
       name: renderable.name,
       groupName: renderable.groupName,
       treePath: sourceObject == null ? void 0 : sourceObject.treePath,
       mock: (sourceObject == null ? void 0 : sourceObject.mock) === true,
-      bbox: {
-        min: bbox ? [bbox.min.x, bbox.min.y, bbox.min.z] : [0, 0, 0],
-        max: bbox ? [bbox.max.x, bbox.max.y, bbox.max.z] : [0, 0, 0]
-      },
+      bbox,
       ...analysis.summary
     });
-    const material = createRoughnessMaterial(renderable.solidMaterial.clippingPlanes);
-    renderable.solid.geometry = analysis.geometry;
-    renderable.solid.material = material;
-    return { renderable, previousMaterial, previousGeometry, material, geometry: analysis.geometry };
+    cloudObjects.push({
+      index: objectIndex,
+      id: renderable.id,
+      name: renderable.name,
+      groupName: renderable.groupName,
+      treePath: sourceObject == null ? void 0 : sourceObject.treePath,
+      mock: (sourceObject == null ? void 0 : sourceObject.mock) === true,
+      sampleCount: analysis.pointSamples.length,
+      bbox
+    });
+    analysis.pointSamples.forEach((sample) => {
+      points.push({
+        objectIndex,
+        objectId: renderable.id,
+        objectName: renderable.name,
+        ...sample
+      });
+    });
+    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples) });
+    analysis.geometry.dispose();
   });
-  try {
-    const png = withSolidOnlyVisibility(
-      session,
-      () => withTemporarySceneBackground(session, new Color(0), () => {
-        updateSdfRaymarchUniforms(session);
-        r.render(session.scene, session.camera);
-        return captureRenderedPng(session.size);
-      })
-    );
-    return {
-      png,
-      report: {
-        method: "mesh-dihedral-angle",
-        options,
-        objectCount: objects.length,
-        objects,
-        warnings,
-        style: {
-          smoothColor: ROUGHNESS_COLORS.smooth,
-          moderateColor: ROUGHNESS_COLORS.moderate,
-          sharpColor: ROUGHNESS_COLORS.sharp,
-          harshColor: ROUGHNESS_COLORS.harsh,
-          smoothOpacity: ROUGHNESS_SMOOTH_OPACITY,
-          harshOpacity: ROUGHNESS_HARSH_OPACITY
-        }
+  const state = {
+    optionsKey,
+    overlays,
+    pointCloud: {
+      schemaVersion: 1,
+      property: "roughness",
+      coordinateSpace: "object-local",
+      units: "degrees",
+      sampleCount: points.length,
+      objects: cloudObjects,
+      points
+    },
+    report: {
+      method: "mesh-dihedral-angle",
+      options,
+      objectCount: objects.length,
+      objects,
+      warnings,
+      style: {
+        smoothColor: ROUGHNESS_COLORS.smooth,
+        moderateColor: ROUGHNESS_COLORS.moderate,
+        sharpColor: ROUGHNESS_COLORS.sharp,
+        harshColor: ROUGHNESS_COLORS.harsh,
+        smoothOpacity: ROUGHNESS_SMOOTH_OPACITY,
+        harshOpacity: ROUGHNESS_HARSH_OPACITY
       }
-    };
-  } finally {
-    replacements.forEach(({ renderable, previousMaterial, previousGeometry, material, geometry }) => {
-      renderable.solid.geometry = previousGeometry;
-      renderable.solid.material = previousMaterial;
-      geometry == null ? void 0 : geometry.dispose();
-      material.dispose();
-    });
-  }
+    }
+  };
+  session.roughnessInspection = state;
+  return state;
 }
 function emptySectionSvg() {
   return {
@@ -3524,19 +3785,8 @@ function createSession(code, opts) {
     name: entry.source.name,
     shape: entry.shape
   }));
-  const connectivityEntries = (opts == null ? void 0 : opts.includeConnectivity) ? shapeVisibleObjs.map((entry) => {
-    const bb2 = entry.shape.boundingBox();
-    return {
-      id: entry.source.id,
-      name: entry.source.name,
-      shape: entry.shape,
-      min: [bb2.min[0], bb2.min[1], bb2.min[2]],
-      max: [bb2.max[0], bb2.max[1], bb2.max[2]],
-      groupName: entry.source.groupName,
-      treePath: entry.source.treePath,
-      mock: entry.source.mock
-    };
-  }) : [];
+  const connectivityBodyInput = (opts == null ? void 0 : opts.includeConnectivity) ? buildMeshBodyConnectivityInput(shapeVisibleObjs.map(meshConnectivitySource), { bodyShape: () => new EmptyInspectionShape() }) : null;
+  const connectivityEntries = (connectivityBodyInput == null ? void 0 : connectivityBodyInput.entries) ?? [];
   const collisionEntries = (opts == null ? void 0 : opts.includeCollisions) ? shapeVisibleObjs.map((entry) => {
     const bb2 = entry.shape.boundingBox();
     return {
@@ -3610,11 +3860,7 @@ function createSession(code, opts) {
       requestedSceneState = mergeViewportRenderSceneStates(requestedSceneState, {
         camera: {
           projectionMode: "perspective",
-          position: [
-            center.x + dir[0] * tokenDistance,
-            center.y + dir[1] * tokenDistance,
-            center.z + dir[2] * tokenDistance
-          ],
+          position: [center.x + dir[0] * tokenDistance, center.y + dir[1] * tokenDistance, center.z + dir[2] * tokenDistance],
           target: [center.x, center.y, center.z],
           up: [0, 0, 1],
           fov: cameraFov
@@ -3843,10 +4089,13 @@ function createSession(code, opts) {
     renderables,
     sectionShapes,
     connectivityEntries,
+    connectivityBodyInput,
     physicalConnectivity: null,
     distanceReport: null,
     collisionEntries,
     collisionReport: null,
+    thicknessInspection: null,
+    roughnessInspection: null,
     joints,
     jointCouplings,
     animationClips,
@@ -3951,6 +4200,8 @@ window.__forgeRender = async (code, opts) => {
   let collisionReport = null;
   let thicknessReport = null;
   let roughnessReport = null;
+  let thicknessPointCloud = null;
+  let roughnessPointCloud = null;
   let sectionAtlas = null;
   const channelViewCounts = /* @__PURE__ */ new Map();
   const markChannelViewStart = async (channel, view) => {
@@ -3996,6 +4247,7 @@ window.__forgeRender = async (code, opts) => {
         const roughness = renderCurrentRoughness(session, opts == null ? void 0 : opts.roughness);
         roughnessRenders[label] = roughness.png;
         roughnessReport = roughness.report;
+        roughnessPointCloud = roughness.pointCloud;
         await markChannelViewDone("roughness", label);
       }
       if (requestedChannels.has("mask")) {
@@ -4034,6 +4286,7 @@ window.__forgeRender = async (code, opts) => {
         const thickness = renderCurrentThickness(session, opts == null ? void 0 : opts.thickness);
         thicknessRenders[label] = thickness.png;
         thicknessReport = thickness.report;
+        thicknessPointCloud = thickness.pointCloud;
         await markChannelViewDone("thickness", label);
       }
     } catch (e) {
@@ -4060,6 +4313,7 @@ window.__forgeRender = async (code, opts) => {
     normals: normalRenders,
     roughness: roughnessReport ? {
       ...roughnessReport,
+      pointCloud: roughnessPointCloud,
       views: roughnessRenders
     } : {
       views: roughnessRenders
@@ -4088,6 +4342,7 @@ window.__forgeRender = async (code, opts) => {
     },
     thickness: thicknessReport ? {
       ...thicknessReport,
+      pointCloud: thicknessPointCloud,
       views: thicknessRenders
     } : {
       views: thicknessRenders