forgecad 0.9.6 → 0.9.7

package/dist/assets/cli/{render-CFtwKCCY.js → render-iP9qh475.js}

@@ -1,5 +1,8 @@
-import { D as DoubleSide, bM as initSolverWasm, bL as initKernel, S as Scene, bN as BoxGeometry, bg as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bO as localAabbPlaneRelation, h as Vector2, bP as ShapeUtils, g as Vector3, e as Color, aC as resolveForgeRenderStyle, bc as getRenderStylePreset, ax as setParamOverrides, b7 as runScript, a0 as MathUtils, G as Box3, bQ as Group, b3 as shapeToGeometry, b8 as MeshPhysicalMaterial, bd as AdditiveBlending, aH as LineBasicMaterial, b9 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bR as resolveRoughnessInspectionOptions, bb as analyzeRoughnessGeometry, bS as ROUGHNESS_COLORS, bJ as analyzePhysicalConnectivity, bT as resolveThicknessInspectionOptions, ba as analyzeThicknessGeometry, bU as summarizeThicknessSamples, bV as THICKNESS_COLORS, bW as intersectWithPlane, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, bX as parseCameraCliSpec, bY as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bC as findJointAnimationClip, p as Plane, Y as Vector4, $ as Matrix4, bj as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bi as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bD as resolveJointAnimation, bE as resolveJointViewValues, bK as analyzeDistanceInspection, b2 as analyzeCollisionIntersections, bZ as serializeCollisionFinding, b_ as worldAuthorPlaneToLocal, a$ as SpotLight, aU as BufferAttribute } from "../distance-BEC2RjJi.js";
-import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-BuAXF2jh.js";
+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, 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,
@@ -266,17 +269,17 @@ function stitchLoops(points, edges) {
   const warnings = [];
   const adjacency = /* @__PURE__ */ new Map();
   const unusedEdges = /* @__PURE__ */ new Set();
-  const edgeKey = (a, b) => a < b ? `${a}:${b}` : `${b}:${a}`;
+  const edgeKey2 = (a, b) => a < b ? `${a}:${b}` : `${b}:${a}`;
   for (const [a, b] of edges) {
     if (!adjacency.has(a)) adjacency.set(a, []);
     if (!adjacency.has(b)) adjacency.set(b, []);
     (_a = adjacency.get(a)) == null ? void 0 : _a.push(b);
     (_b = adjacency.get(b)) == null ? void 0 : _b.push(a);
-    unusedEdges.add(edgeKey(a, b));
+    unusedEdges.add(edgeKey2(a, b));
   }
   const loops = [];
   for (const [edgeA, edgeB] of edges) {
-    const firstKey = edgeKey(edgeA, edgeB);
+    const firstKey = edgeKey2(edgeA, edgeB);
     if (!unusedEdges.has(firstKey)) continue;
     const loop = [edgeA, edgeB];
     unusedEdges.delete(firstKey);
@@ -285,12 +288,12 @@ function stitchLoops(points, edges) {
     let closed = false;
     for (let guard = 0; guard < points.length + edges.length + 8; guard += 1) {
       const neighbors = adjacency.get(current) ?? [];
-      const next = neighbors.find((candidate) => candidate !== previous && unusedEdges.has(edgeKey(current, candidate)));
+      const next = neighbors.find((candidate) => candidate !== previous && unusedEdges.has(edgeKey2(current, candidate)));
       if (next === void 0) {
         if (current === edgeA) closed = true;
         break;
       }
-      unusedEdges.delete(edgeKey(current, next));
+      unusedEdges.delete(edgeKey2(current, next));
       if (next === edgeA) {
         closed = true;
         break;
@@ -454,6 +457,425 @@ function computeMeshSectionCap(mesh, planeInput) {
     warnings: stitched.warnings.length > 0 ? stitched.warnings : void 0
   };
 }
+const DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
+  contactTolerance: 0.05,
+  minOverlapVolume: 0.1,
+  exactGeometry: true
+};
+const AXIS_NAMES = ["x", "y", "z"];
+let UnionFind$1 = 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(value) {
+  return [value[0], value[1], value[2]];
+}
+function emptyBBox$1() {
+  return {
+    min: [Infinity, Infinity, Infinity],
+    max: [-Infinity, -Infinity, -Infinity]
+  };
+}
+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 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 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 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 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 bodyCountForEntry(entry) {
+  if (typeof entry.bodyCount === "number" && Number.isFinite(entry.bodyCount)) {
+    return Math.max(0, Math.round(entry.bodyCount));
+  }
+  return 1;
+}
+function makeEdge(entries, sourceIndex, targetIndex, edge) {
+  const source = entries[sourceIndex];
+  const target = entries[targetIndex];
+  return {
+    sourceIndex,
+    targetIndex,
+    sourceId: source.id,
+    targetId: target.id,
+    sourceName: source.name,
+    targetName: target.name,
+    ...edge
+  };
+}
+function analyzePhysicalConnectivity(entries, rawOptions = {}) {
+  const exactGeometry = rawOptions.exactGeometry ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.exactGeometry;
+  const options = {
+    contactTolerance: rawOptions.contactTolerance ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance,
+    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.minOverlapVolume,
+    exactGeometry,
+    mergeOverlappingBBoxes: rawOptions.mergeOverlappingBBoxes ?? !exactGeometry,
+    mergeTouchingBBoxes: rawOptions.mergeTouchingBBoxes ?? !exactGeometry
+  };
+  const warnings = [];
+  const edges = [];
+  const unionFind = new UnionFind$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 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) {
+        unionFind.union(i, j);
+        edges.push(
+          makeEdge(entries, i, j, {
+            kind: "overlap",
+            method: "boolean-intersection",
+            gap: 0,
+            overlapVolume: overlap.volume
+          })
+        );
+        continue;
+      }
+      continue;
+    }
+    if (bboxOverlaps && options.mergeOverlappingBBoxes) {
+      unionFind.union(i, j);
+      edges.push(
+        makeEdge(entries, i, j, {
+          kind: "overlap",
+          method: "bbox-overlap",
+          gap: 0,
+          overlapVolume: aabbOverlapVolume(a, b)
+        })
+      );
+    } else {
+      const contact = contactFromBBoxes(a, b, options.contactTolerance);
+      if (!contact.touching || !options.mergeTouchingBBoxes) continue;
+      unionFind.union(i, j);
+      edges.push(
+        makeEdge(entries, i, j, {
+          kind: "touching",
+          method: "bbox-contact",
+          gap: contact.gap,
+          axis: contact.axis
+        })
+      );
+    }
+  }
+  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(entry),
+    bbox: {
+      min: cloneVec3(entry.min),
+      max: cloneVec3(entry.max)
+    },
+    componentIndex: 0
+  }));
+  const componentByRoot = /* @__PURE__ */ new Map();
+  const rootToComponentIndex = /* @__PURE__ */ new Map();
+  for (let objectIndex = 0; objectIndex < objects.length; objectIndex += 1) {
+    const root = unionFind.find(objectIndex);
+    let component = componentByRoot.get(root);
+    if (!component) {
+      component = {
+        index: componentByRoot.size + 1,
+        objectIndexes: [],
+        objectIds: [],
+        objectNames: [],
+        objectCount: 0,
+        bodyCount: 0,
+        bbox: emptyBBox$1()
+      };
+      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$1(component.bbox, object.bbox.min, object.bbox.max);
+  }
+  const components = [...componentByRoot.values()];
+  return {
+    method: options.exactGeometry ? "boolean-overlap-plus-bbox-contact" : "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;
+  if (bMax < aMin) return aMin - bMax;
+  return 0;
+}
+function bboxGap(a, b) {
+  const axisGaps = [
+    intervalGap(a.bbox.min[0], a.bbox.max[0], b.bbox.min[0], b.bbox.max[0]),
+    intervalGap(a.bbox.min[1], a.bbox.max[1], b.bbox.min[1], b.bbox.max[1]),
+    intervalGap(a.bbox.min[2], a.bbox.max[2], b.bbox.min[2], b.bbox.max[2])
+  ];
+  const gap = Math.sqrt(axisGaps[0] ** 2 + axisGaps[1] ** 2 + axisGaps[2] ** 2);
+  return { gap, axisGaps };
+}
+function bboxVolume(component) {
+  const dx = Math.max(0, component.bbox.max[0] - component.bbox.min[0]);
+  const dy = Math.max(0, component.bbox.max[1] - component.bbox.min[1]);
+  const dz = Math.max(0, component.bbox.max[2] - component.bbox.min[2]);
+  return dx * dy * dz;
+}
+function compareDefaultRoot(a, b) {
+  if (a.bodyCount !== b.bodyCount) return a.bodyCount - b.bodyCount;
+  if (a.objectCount !== b.objectCount) return a.objectCount - b.objectCount;
+  const volumeDelta = bboxVolume(a) - bboxVolume(b);
+  if (Math.abs(volumeDelta) > EPSILON) return volumeDelta;
+  return b.index - a.index;
+}
+function defaultRootComponentIndex(components) {
+  if (components.length === 0) return null;
+  return components.reduce((best, component) => compareDefaultRoot(component, best) > 0 ? component : best, components[0]).index;
+}
+function componentPositionByIndex(components) {
+  return new Map(components.map((component, position) => [component.index, position]));
+}
+function computeNearestComponents(components) {
+  const nearest = components.map(() => ({ nearestGap: null, nearestComponentIndex: null }));
+  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, 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 visited = components.map(() => false);
+  const distances = components.map(() => Infinity);
+  const parents = components.map(() => null);
+  const parentGaps = components.map(() => null);
+  distances[rootPosition] = 0;
+  for (; ; ) {
+    let current = -1;
+    for (let i = 0; i < components.length; i += 1) {
+      if (visited[i]) continue;
+      if (current === -1 || distances[i] < distances[current] - EPSILON || Math.abs(distances[i] - distances[current]) <= EPSILON && components[i].index < components[current].index) {
+        current = i;
+      }
+    }
+    if (current === -1 || !Number.isFinite(distances[current])) break;
+    visited[current] = true;
+    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[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;
+      }
+    }
+  }
+  return components.map((_, position) => ({
+    rootDistance: distances[position],
+    parentComponentIndex: parents[position],
+    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 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;
+    const rootData = rooted[position] ?? {
+      rootDistance: rootComponentIndex === component.index ? 0 : Infinity,
+      parentComponentIndex: null,
+      parentGap: null
+    };
+    const decorated = {
+      ...component,
+      isRoot: component.index === rootComponentIndex,
+      rootDistance: rootData.rootDistance,
+      nearestGap: ((_a = nearest[position]) == null ? void 0 : _a.nearestGap) ?? null,
+      nearestComponentIndex: ((_b = nearest[position]) == null ? void 0 : _b.nearestComponentIndex) ?? null,
+      parentComponentIndex: rootData.parentComponentIndex,
+      parentGap: rootData.parentGap
+    };
+    componentByIndex.set(component.index, decorated);
+    return decorated;
+  });
+  const objects = connectivity.objects.map((object) => {
+    const component = componentByIndex.get(object.componentIndex);
+    return {
+      ...object,
+      rootDistance: (component == null ? void 0 : component.rootDistance) ?? Infinity,
+      nearestGap: (component == null ? void 0 : component.nearestGap) ?? null,
+      nearestComponentIndex: (component == null ? void 0 : component.nearestComponentIndex) ?? null,
+      parentComponentIndex: (component == null ? void 0 : component.parentComponentIndex) ?? null,
+      parentGap: (component == null ? void 0 : component.parentGap) ?? null
+    };
+  });
+  const finiteDistances = components.map((component) => component.rootDistance).filter(Number.isFinite);
+  const maxRootDistance = finiteDistances.length > 0 ? Math.max(...finiteDistances) : 0;
+  return {
+    method: "physical-component-bbox-gap-graph",
+    distanceMethod: "axis-aligned-bbox-gap",
+    options: {
+      contactTolerance: connectivity.options.contactTolerance,
+      minOverlapVolume: connectivity.options.minOverlapVolume,
+      rootComponentIndex
+    },
+    objectCount: connectivity.objectCount,
+    componentCount: connectivity.componentCount,
+    rootComponentIndex,
+    maxRootDistance,
+    gapEdgeCount: connectivity.components.length * (connectivity.components.length - 1) / 2,
+    objects,
+    components,
+    gapEdges,
+    connectivity: {
+      method: connectivity.method,
+      edges: connectivity.edges
+    },
+    warnings: [...connectivity.warnings]
+  };
+}
 const CAMERA_TOKEN_DIRECTIONS = {
   front: [0, -1, 0.2],
   back: [0, 1, 0.2],
@@ -589,6 +1011,805 @@ ${body}
     pathCount
   };
 }
+const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
+  minThickness: 1.2,
+  warnThickness: 2,
+  maxThickness: 6,
+  maxSamplesPerObject: 5e3
+};
+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 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"
+  );
+  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))
+  };
+}
+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;
+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,
+  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,
+    edgeCount: 0,
+    boundaryEdgeCount: 0,
+    nonManifoldEdgeCount: 0,
+    smoothAreaPercent: 0,
+    moderateAreaPercent: 0,
+    sharpAreaPercent: 0,
+    harshAreaPercent: 0,
+    roughAreaPercent: 0,
+    meanAngleDeg: null,
+    p50AngleDeg: null,
+    p90AngleDeg: null,
+    p95AngleDeg: null,
+    p99AngleDeg: null,
+    maxAngleDeg: null,
+    qualityScore: 0
+  };
+}
+function summarizeRoughnessTriangles(triangles, edgeAngles, edgeCount, boundaryEdgeCount, nonManifoldEdgeCount, options) {
+  const areaByClass = {
+    smooth: 0,
+    moderate: 0,
+    sharp: 0,
+    harsh: 0
+  };
+  let totalArea = 0;
+  for (const tri of triangles) {
+    const area = Number.isFinite(tri.area) ? tri.area : 0;
+    totalArea += area;
+    areaByClass[roughnessClassForAngle(tri.maxAngleDeg, options)] += area;
+  }
+  const sortedAngles = [...edgeAngles].sort((lhs, rhs) => lhs - rhs);
+  const meanAngleDeg = sortedAngles.length > 0 ? Number((sortedAngles.reduce((sum, angle) => sum + angle, 0) / sortedAngles.length).toFixed(2)) : null;
+  const qualityScore = totalArea > 0 ? Math.round(
+    MathUtils.clamp(
+      100 * (areaByClass.smooth + areaByClass.moderate * 0.9) / totalArea - 50 * areaByClass.harsh / totalArea,
+      0,
+      100
+    )
+  ) : 0;
+  const safePercent = (value) => totalArea > 0 ? Number((value / totalArea * 100).toFixed(2)) : 0;
+  return {
+    triangleCount: triangles.length,
+    edgeCount,
+    boundaryEdgeCount,
+    nonManifoldEdgeCount,
+    smoothAreaPercent: safePercent(areaByClass.smooth),
+    moderateAreaPercent: safePercent(areaByClass.moderate),
+    sharpAreaPercent: safePercent(areaByClass.sharp),
+    harshAreaPercent: safePercent(areaByClass.harsh),
+    roughAreaPercent: safePercent(areaByClass.sharp + areaByClass.harsh),
+    meanAngleDeg,
+    p50AngleDeg: percentile(sortedAngles, 0.5),
+    p90AngleDeg: percentile(sortedAngles, 0.9),
+    p95AngleDeg: percentile(sortedAngles, 0.95),
+    p99AngleDeg: percentile(sortedAngles, 0.99),
+    maxAngleDeg: sortedAngles.length > 0 ? Number(sortedAngles[sortedAngles.length - 1].toFixed(2)) : null,
+    qualityScore
+  };
+}
+function percentile(sorted, q) {
+  if (sorted.length === 0) return null;
+  const index = MathUtils.clamp(Math.floor(sorted.length * q), 0, sorted.length - 1);
+  return Number(sorted[index].toFixed(2));
+}
+const DEG_PER_RAD = 180 / Math.PI;
+function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
+  const options = resolveRoughnessInspectionOptions(rawOptions);
+  const geometry = sourceGeometry.index ? sourceGeometry.toNonIndexed() : sourceGeometry.clone();
+  const position = geometry.getAttribute("position");
+  const warnings = [];
+  if (!position || position.count < 3) {
+    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);
+  const a = new Vector3();
+  const b = new Vector3();
+  const c = new Vector3();
+  const ac = new Vector3();
+  const normal = new Vector3();
+  const bbox = new Box3().setFromBufferAttribute(position);
+  const snap = Math.max(1e-6, bbox.getSize(new Vector3()).length() * 1e-8);
+  for (let tri = 0; tri < triangleCount; tri += 1) {
+    const offset = tri * 3;
+    readVertex(position, offset, a);
+    readVertex(position, offset + 1, b);
+    readVertex(position, offset + 2, c);
+    normal.subVectors(b, a).cross(ac.subVectors(c, a));
+    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$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: [], triangleEdges: [] };
+        edges.set(key, record);
+      }
+      record.triangles.push(tri);
+      record.triangleEdges.push({ triangle: tri, edge });
+    }
+  }
+  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) {
+    const { maxAngleDeg } = triangles[tri];
+    const color = roughnessColorForAngle(maxAngleDeg, options);
+    const score = roughnessScoreForAngle(maxAngleDeg, 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;
+      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, triangleEdgeAngles) {
+  const edgeAngles = [];
+  let boundaryEdgeCount = 0;
+  let nonManifoldEdgeCount = 0;
+  for (const edge of edges.values()) {
+    if (edge.triangles.length === 1) {
+      boundaryEdgeCount += 1;
+      markEdge(edge, triangles, triangleEdgeAngles, 180);
+      edgeAngles.push(180);
+      continue;
+    }
+    if (edge.triangles.length > 2) {
+      nonManifoldEdgeCount += 1;
+      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;
+    markEdge(edge, triangles, triangleEdgeAngles, angleDeg);
+    edgeAngles.push(angleDeg);
+  }
+  return { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles };
+}
+function readVertex(position, index, target) {
+  target.set(position.getX(index), position.getY(index), position.getZ(index));
+}
+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 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");
@@ -622,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];
@@ -665,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];
@@ -1038,6 +2292,17 @@ 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 rgbFloats(color) {
+  return [color[0] / 255, color[1] / 255, 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));
+  return geometry;
+}
 function buildMaskEntries(session) {
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   return session.renderables.map((renderable, idx) => {
@@ -1140,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(
@@ -1176,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();
     });
   }
@@ -1236,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(
@@ -1272,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();
     });
   }
@@ -1373,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,
@@ -1401,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 {
@@ -2457,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 {
@@ -2772,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,
@@ -2880,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) => {
@@ -2925,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")) {
@@ -2963,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) {
@@ -2989,6 +4313,7 @@ window.__forgeRender = async (code, opts) => {
     normals: normalRenders,
     roughness: roughnessReport ? {
       ...roughnessReport,
+      pointCloud: roughnessPointCloud,
       views: roughnessRenders
     } : {
       views: roughnessRenders
@@ -3017,6 +4342,7 @@ window.__forgeRender = async (code, opts) => {
     },
     thickness: thicknessReport ? {
       ...thicknessReport,
+      pointCloud: thicknessPointCloud,
       views: thicknessRenders
     } : {
       views: thicknessRenders