forgecad 0.9.5 → 0.9.6

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

@@ -1,8 +1,5 @@
-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, 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";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -269,17 +266,17 @@ function stitchLoops(points, edges) {
   const warnings = [];
   const adjacency = /* @__PURE__ */ new Map();
   const unusedEdges = /* @__PURE__ */ new Set();
-  const edgeKey2 = (a, b) => a < b ? `${a}:${b}` : `${b}:${a}`;
+  const edgeKey = (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(edgeKey2(a, b));
+    unusedEdges.add(edgeKey(a, b));
   }
   const loops = [];
   for (const [edgeA, edgeB] of edges) {
-    const firstKey = edgeKey2(edgeA, edgeB);
+    const firstKey = edgeKey(edgeA, edgeB);
     if (!unusedEdges.has(firstKey)) continue;
     const loop = [edgeA, edgeB];
     unusedEdges.delete(firstKey);
@@ -288,12 +285,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(edgeKey2(current, candidate)));
+      const next = neighbors.find((candidate) => candidate !== previous && unusedEdges.has(edgeKey(current, candidate)));
       if (next === void 0) {
         if (current === edgeA) closed = true;
         break;
       }
-      unusedEdges.delete(edgeKey2(current, next));
+      unusedEdges.delete(edgeKey(current, next));
       if (next === edgeA) {
         closed = true;
         break;
@@ -457,618 +454,6 @@ 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
-};
-const AXIS_NAMES = ["x", "y", "z"];
-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() {
-  return {
-    min: [Infinity, Infinity, Infinity],
-    max: [-Infinity, -Infinity, -Infinity]
-  };
-}
-function expandBBox(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);
-  }
-  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);
-  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 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
-  };
-  const warnings = [];
-  const edges = [];
-  const unionFind = new UnionFind(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 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;
-      }
-      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;
-      }
-    }
-    if (bboxOverlaps2) {
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge(entries, i, j, {
-          kind: "overlap",
-          method: "bbox-overlap",
-          gap: 0,
-          overlapVolume: bboxOverlapVolume(a, b)
-        })
-      );
-    } else {
-      const contact = contactFromBBoxes(a, b, options.contactTolerance);
-      if (!contact.touching) 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()
-      };
-      componentByRoot.set(root, component);
-      rootToComponentIndex.set(root, component.index);
-    }
-    const object = objects[objectIndex];
-    object.componentIndex = rootToComponentIndex.get(root) ?? component.index;
-    component.objectIndexes.push(object.index);
-    component.objectIds.push(object.id);
-    component.objectNames.push(object.name);
-    component.objectCount += 1;
-    component.bodyCount += object.bodyCount;
-    expandBBox(component.bbox, object.bbox.min, object.bbox.max);
-  }
-  const components = [...componentByRoot.values()];
-  return {
-    method: options.exactGeometry ? "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 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) {
-  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;
-    }
-  }
-  return nearest;
-}
-function computeRootDistances(components, gapEdges, 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);
-  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 (const edge of adjacency[current]) {
-      if (visited[edge.to]) 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;
-      }
-    }
-  }
-  return components.map((_, position) => ({
-    rootDistance: distances[position],
-    parentComponentIndex: parents[position],
-    parentGap: parentGaps[position]
-  }));
-}
-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 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,
-    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],
@@ -1204,374 +589,6 @@ ${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 DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
-  smoothAngleDeg: 5,
-  sharpAngleDeg: 30,
-  harshAngleDeg: 90
-};
-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
-  };
-  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}).`);
-  }
-  return options;
-}
-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, summary: emptyRoughnessSummary(), warnings: ["No triangle geometry."] };
-  }
-  const triangleCount = Math.floor(position.count / 3);
-  const normals = new Array(triangleCount);
-  const triangles = new Array(triangleCount);
-  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(a, snap), vertexKey(b, snap), vertexKey(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: [] };
-        edges.set(key, record);
-      }
-      record.triangles.push(tri);
-    }
-  }
-  const { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles } = markTriangleRoughness(edges, triangles, normals);
-  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;
-    }
-  }
-  geometry.setAttribute("color", new BufferAttribute(colors, 3));
-  geometry.setAttribute("roughnessScore", new BufferAttribute(scores, 1));
-  geometry.computeBoundingBox();
-  return {
-    geometry,
-    summary: summarizeRoughnessTriangles(triangles, edgeAngles, edges.size, boundaryEdgeCount, nonManifoldEdgeCount, options),
-    warnings
-  };
-}
-function markTriangleRoughness(edges, triangles, normals) {
-  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);
-      edgeAngles.push(180);
-      continue;
-    }
-    if (edge.triangles.length > 2) {
-      nonManifoldEdgeCount += 1;
-      markTriangles(edge.triangles, triangles, 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);
-    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(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);
-  }
-}
 const canvas = document.getElementById("canvas");
 const exportCanvas = document.createElement("canvas");
 const exportCtx = exportCanvas.getContext("2d");
@@ -2021,92 +1038,6 @@ 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 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;
-    }
-  }
-  geometry.setAttribute("color", new BufferAttribute(colors, 3));
-  rayMaterial.dispose();
-  return { geometry, samples, triangleCount, sampledTriangleCount, sampleStride, warnings };
-}
 function buildMaskEntries(session) {
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   return session.renderables.map((renderable, idx) => {
@@ -2196,6 +1127,7 @@ function decorateConnectivityReport(report) {
   return {
     method: report.method,
     options: report.options,
+    broadphase: report.broadphase,
     objectCount: report.objectCount,
     componentCount: report.componentCount,
     objects,
@@ -2284,6 +1216,7 @@ function decorateDistanceReport(report) {
     maxRootDistance: report.maxRootDistance,
     objects,
     components,
+    gapEdgeCount: report.gapEdgeCount,
     gapEdges: report.gapEdges,
     connectivity: report.connectivity,
     warnings: report.warnings,
@@ -3610,11 +2543,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