forgecad 0.9.7 → 0.9.8

package/dist/assets/{inspectWorker-Dll4eVyD.js → inspectWorker-BZ2CkQZr.js}

@@ -11132,7 +11132,7 @@ if (typeof window !== "undefined") {
   }
 }
 const DEFAULT_LEAF_SIZE = 8;
-function cloneVec3$1(value) {
+function cloneVec3$2(value) {
   return [value[0], value[1], value[2]];
 }
 function emptyBounds() {
@@ -11200,14 +11200,14 @@ class AabbSpatialIndex {
       nodeCount += 1;
       const bounds = boundsFor(entries, indexes);
       if (indexes.length <= this.leafSize) {
-        return { min: cloneVec3$1(bounds.min), max: cloneVec3$1(bounds.max), left: null, right: null, indexes };
+        return { min: cloneVec3$2(bounds.min), max: cloneVec3$2(bounds.max), left: null, right: null, indexes };
       }
       const axis = longestAxis(bounds);
       indexes.sort((a, b) => centerOnAxis(entries[a], axis) - centerOnAxis(entries[b], axis) || a - b);
       const mid = Math.max(1, Math.floor(indexes.length / 2));
       return {
-        min: cloneVec3$1(bounds.min),
-        max: cloneVec3$1(bounds.max),
+        min: cloneVec3$2(bounds.min),
+        max: cloneVec3$2(bounds.max),
         left: build(indexes.slice(0, mid)),
         right: build(indexes.slice(mid)),
         indexes: null
@@ -11270,13 +11270,333 @@ class AabbSpatialIndex {
     };
   }
 }
+const AXIS_NAMES = ["x", "y", "z"];
+function nearestBoundaryGap(a, b, axis) {
+  return Math.min(Math.abs(a.max[axis] - b.min[axis]), Math.abs(b.max[axis] - a.min[axis]));
+}
+function hasPositiveGap(gaps) {
+  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
+}
+function contactFromBBoxes(a, b, tolerance) {
+  const gaps = aabbGaps(a, b);
+  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
+  if (largestGap > tolerance) return { touching: false, gap: largestGap };
+  const separatedAxes = gaps.map((gap, axis) => ({ gap, axis })).filter((entry) => entry.gap > 0);
+  if (separatedAxes.length > 0) {
+    const nearest2 = separatedAxes.reduce((best, entry) => entry.gap > best.gap ? entry : best, separatedAxes[0]);
+    return { touching: true, gap: nearest2.gap, axis: AXIS_NAMES[nearest2.axis] };
+  }
+  const boundaryAxes = AXIS_NAMES.map((axisName, axis) => ({
+    axis,
+    axisName,
+    gap: nearestBoundaryGap(a, b, axis)
+  })).filter((entry) => entry.gap <= tolerance);
+  if (boundaryAxes.length === 0) return { touching: false, gap: 0 };
+  const nearest = boundaryAxes.reduce((best, entry) => entry.gap < best.gap ? entry : best, boundaryAxes[0]);
+  return { touching: true, gap: nearest.gap, axis: nearest.axisName };
+}
+function isFiniteTriangle(positions, offset) {
+  for (let index = 0; index < 9; index += 1) {
+    if (!Number.isFinite(positions[offset + index])) return false;
+  }
+  return true;
+}
+function triangleRef(positions, offset) {
+  if (!isFiniteTriangle(positions, offset)) return null;
+  const ax = positions[offset];
+  const ay = positions[offset + 1];
+  const az = positions[offset + 2];
+  const bx = positions[offset + 3];
+  const by = positions[offset + 4];
+  const bz = positions[offset + 5];
+  const cx = positions[offset + 6];
+  const cy = positions[offset + 7];
+  const cz = positions[offset + 8];
+  return {
+    offset,
+    min: [Math.min(ax, bx, cx), Math.min(ay, by, cy), Math.min(az, bz, cz)],
+    max: [Math.max(ax, bx, cx), Math.max(ay, by, cy), Math.max(az, bz, cz)]
+  };
+}
+function meshContactDataFor(entry) {
+  const positions = entry.positions;
+  if (!positions || positions.length < 9) return null;
+  const triangleCount = Math.floor(positions.length / 9);
+  const triangles = [];
+  for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
+    const triangle = triangleRef(positions, triangleIndex * 9);
+    if (triangle) triangles.push(triangle);
+  }
+  if (triangles.length === 0) return null;
+  return {
+    positions,
+    vertexCount: triangleCount * 3,
+    triangles
+  };
+}
+function distSq(px, py, pz, qx, qy, qz) {
+  const dx = px - qx;
+  const dy = py - qy;
+  const dz = pz - qz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function pointSegmentDistanceSq(point, start, end) {
+  const dx = end[0] - start[0];
+  const dy = end[1] - start[1];
+  const dz = end[2] - start[2];
+  const lengthSq = dx * dx + dy * dy + dz * dz;
+  if (lengthSq <= 1e-20) return distSq(point[0], point[1], point[2], start[0], start[1], start[2]);
+  const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy + (point[2] - start[2]) * dz) / lengthSq));
+  return distSq(point[0], point[1], point[2], start[0] + t * dx, start[1] + t * dy, start[2] + t * dz);
+}
+function pointTriangleDistanceSq(px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz) {
+  const abx = bx - ax;
+  const aby = by - ay;
+  const abz = bz - az;
+  const acx = cx - ax;
+  const acy = cy - ay;
+  const acz = cz - az;
+  const apx = px - ax;
+  const apy = py - ay;
+  const apz = pz - az;
+  const d1 = abx * apx + aby * apy + abz * apz;
+  const d2 = acx * apx + acy * apy + acz * apz;
+  if (d1 <= 0 && d2 <= 0) return distSq(px, py, pz, ax, ay, az);
+  const bpx = px - bx;
+  const bpy = py - by;
+  const bpz = pz - bz;
+  const d3 = abx * bpx + aby * bpy + abz * bpz;
+  const d4 = acx * bpx + acy * bpy + acz * bpz;
+  if (d3 >= 0 && d4 <= d3) return distSq(px, py, pz, bx, by, bz);
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+    const v2 = d1 / (d1 - d3);
+    return distSq(px, py, pz, ax + v2 * abx, ay + v2 * aby, az + v2 * abz);
+  }
+  const cpx = px - cx;
+  const cpy = py - cy;
+  const cpz = pz - cz;
+  const d5 = abx * cpx + aby * cpy + abz * cpz;
+  const d6 = acx * cpx + acy * cpy + acz * cpz;
+  if (d6 >= 0 && d5 <= d6) return distSq(px, py, pz, cx, cy, cz);
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+    const w2 = d2 / (d2 - d6);
+    return distSq(px, py, pz, ax + w2 * acx, ay + w2 * acy, az + w2 * acz);
+  }
+  const va = d3 * d6 - d5 * d4;
+  if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
+    const bcx = cx - bx;
+    const bcy = cy - by;
+    const bcz = cz - bz;
+    const w2 = (d4 - d3) / (d4 - d3 + d5 - d6);
+    return distSq(px, py, pz, bx + w2 * bcx, by + w2 * bcy, bz + w2 * bcz);
+  }
+  const barycentricTotal = va + vb + vc;
+  if (!Number.isFinite(barycentricTotal) || Math.abs(barycentricTotal) < 1e-20) {
+    return Math.min(distSq(px, py, pz, ax, ay, az), distSq(px, py, pz, bx, by, bz), distSq(px, py, pz, cx, cy, cz));
+  }
+  const denom = 1 / barycentricTotal;
+  const v = vb * denom;
+  const w = vc * denom;
+  return distSq(px, py, pz, ax + abx * v + acx * w, ay + aby * v + acy * w, az + abz * v + acz * w);
+}
+function segmentSegmentDistanceSq(a0, a1, b0, b1) {
+  const ux = a1[0] - a0[0];
+  const uy = a1[1] - a0[1];
+  const uz = a1[2] - a0[2];
+  const vx = b1[0] - b0[0];
+  const vy = b1[1] - b0[1];
+  const vz = b1[2] - b0[2];
+  const wx = a0[0] - b0[0];
+  const wy = a0[1] - b0[1];
+  const wz = a0[2] - b0[2];
+  const a = ux * ux + uy * uy + uz * uz;
+  const b = ux * vx + uy * vy + uz * vz;
+  const c = vx * vx + vy * vy + vz * vz;
+  const d = ux * wx + uy * wy + uz * wz;
+  const e = vx * wx + vy * wy + vz * wz;
+  const denom = a * c - b * b;
+  let sNumerator = denom;
+  let sDenominator = denom;
+  let tNumerator = denom;
+  let tDenominator = denom;
+  if (a <= 1e-20) return pointSegmentDistanceSq(a0, b0, b1);
+  if (c <= 1e-20) return pointSegmentDistanceSq(b0, a0, a1);
+  if (denom < 1e-20) {
+    sNumerator = 0;
+    sDenominator = 1;
+    tNumerator = e;
+    tDenominator = c;
+  } else {
+    sNumerator = b * e - c * d;
+    tNumerator = a * e - b * d;
+    if (sNumerator < 0) {
+      sNumerator = 0;
+      tNumerator = e;
+      tDenominator = c;
+    } else if (sNumerator > sDenominator) {
+      sNumerator = sDenominator;
+      tNumerator = e + b;
+      tDenominator = c;
+    }
+  }
+  if (tNumerator < 0) {
+    tNumerator = 0;
+    if (-d < 0) {
+      sNumerator = 0;
+    } else if (-d > a) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d;
+      sDenominator = a;
+    }
+  } else if (tNumerator > tDenominator) {
+    tNumerator = tDenominator;
+    if (-d + b < 0) {
+      sNumerator = 0;
+    } else if (-d + b > a) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d + b;
+      sDenominator = a;
+    }
+  }
+  const s = Math.abs(sNumerator) < 1e-20 ? 0 : sNumerator / sDenominator;
+  const t = Math.abs(tNumerator) < 1e-20 ? 0 : tNumerator / tDenominator;
+  const dx = wx + s * ux - t * vx;
+  const dy = wy + s * uy - t * vy;
+  const dz = wz + s * uz - t * vz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function trianglePoint(positions, triangle, corner) {
+  const offset = triangle.offset + corner * 3;
+  return [positions[offset], positions[offset + 1], positions[offset + 2]];
+}
+function bboxDistanceSq(a, b) {
+  let total = 0;
+  for (let axis = 0; axis < 3; axis += 1) {
+    const gap = Math.max(0, a.min[axis] - b.max[axis], b.min[axis] - a.max[axis]);
+    total += gap * gap;
+  }
+  return total;
+}
+function triangleDistanceSq(aPositions, a, bPositions, b) {
+  const a0 = trianglePoint(aPositions, a, 0);
+  const a1 = trianglePoint(aPositions, a, 1);
+  const a2 = trianglePoint(aPositions, a, 2);
+  const b0 = trianglePoint(bPositions, b, 0);
+  const b1 = trianglePoint(bPositions, b, 1);
+  const b2 = trianglePoint(bPositions, b, 2);
+  return Math.min(
+    pointTriangleDistanceSq(a0[0], a0[1], a0[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b2[0], b2[1], b2[2]),
+    pointTriangleDistanceSq(a1[0], a1[1], a1[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b2[0], b2[1], b2[2]),
+    pointTriangleDistanceSq(a2[0], a2[1], a2[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b2[0], b2[1], b2[2]),
+    pointTriangleDistanceSq(b0[0], b0[1], b0[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    pointTriangleDistanceSq(b1[0], b1[1], b1[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    pointTriangleDistanceSq(b2[0], b2[1], b2[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    segmentSegmentDistanceSq(a0, a1, b0, b1),
+    segmentSegmentDistanceSq(a0, a1, b1, b2),
+    segmentSegmentDistanceSq(a0, a1, b2, b0),
+    segmentSegmentDistanceSq(a1, a2, b0, b1),
+    segmentSegmentDistanceSq(a1, a2, b1, b2),
+    segmentSegmentDistanceSq(a1, a2, b2, b0),
+    segmentSegmentDistanceSq(a2, a0, b0, b1),
+    segmentSegmentDistanceSq(a2, a0, b1, b2),
+    segmentSegmentDistanceSq(a2, a0, b2, b0)
+  );
+}
+function meshEntriesContactDistance(a, b, tolerance) {
+  const toleranceSq = tolerance * tolerance;
+  let bestDistanceSq = Infinity;
+  for (const aTriangle of a.triangles) {
+    for (const bTriangle of b.triangles) {
+      if (bboxDistanceSq(aTriangle, bTriangle) > toleranceSq) continue;
+      const distanceSq = triangleDistanceSq(a.positions, aTriangle, b.positions, bTriangle);
+      if (distanceSq > toleranceSq) continue;
+      if (distanceSq <= 1e-20) return 0;
+      bestDistanceSq = Math.min(bestDistanceSq, distanceSq);
+    }
+  }
+  return Number.isFinite(bestDistanceSq) ? Math.sqrt(bestDistanceSq) : null;
+}
+function intersectionVolume(a, b) {
+  try {
+    const hit = a.shape.intersect(b.shape);
+    if (hit.isEmpty()) return { volume: 0 };
+    const volume = hit.volume();
+    return { volume: Number.isFinite(volume) ? volume : 0 };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { volume: null, warning: `Could not boolean-test ${a.name} against ${b.name}: ${message}` };
+  }
+}
+function detectPhysicalContact(a, b, options, meshCache = {}) {
+  const gaps = aabbGaps(a, b);
+  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
+  if (largestGap > options.contactTolerance) return { contact: null };
+  const sourceMesh = meshCache.sourceMesh !== void 0 ? meshCache.sourceMesh : meshContactDataFor(a);
+  const targetMesh = meshCache.targetMesh !== void 0 ? meshCache.targetMesh : meshContactDataFor(b);
+  if (sourceMesh && targetMesh) {
+    const distance = meshEntriesContactDistance(sourceMesh, targetMesh, options.contactTolerance);
+    if (distance != null) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "mesh-surface-distance",
+          gap: distance
+        }
+      };
+    }
+  }
+  const bboxOverlaps = !hasPositiveGap(gaps) && aabbInteriorOverlaps(a, b);
+  if (options.exactGeometry && bboxOverlaps) {
+    if (aabbOverlapVolume(a, b) <= options.minOverlapVolume) return { contact: null };
+    const overlap = intersectionVolume(a, b);
+    if (overlap.volume != null && overlap.volume > options.minOverlapVolume) {
+      return {
+        contact: {
+          kind: "overlap",
+          method: "boolean-intersection",
+          gap: 0,
+          overlapVolume: overlap.volume
+        },
+        warning: overlap.warning
+      };
+    }
+    return { contact: null, warning: overlap.warning };
+  }
+  if (bboxOverlaps && options.mergeOverlappingBBoxes) {
+    return {
+      contact: {
+        kind: "overlap",
+        method: "bbox-overlap",
+        gap: 0,
+        overlapVolume: aabbOverlapVolume(a, b)
+      }
+    };
+  }
+  if (options.mergeTouchingBBoxes) {
+    const contact = contactFromBBoxes(a, b, options.contactTolerance);
+    if (contact.touching) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "bbox-contact",
+          gap: contact.gap,
+          axis: contact.axis
+        }
+      };
+    }
+  }
+  return { contact: null };
+}
 const DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
   contactTolerance: 0.05,
   minOverlapVolume: 0.1,
   exactGeometry: true
 };
-const AXIS_NAMES = ["x", "y", "z"];
-let UnionFind$1 = class UnionFind {
+let UnionFind$2 = class UnionFind {
   constructor(size) {
     __publicField(this, "parent");
     __publicField(this, "rank");
@@ -11306,27 +11626,21 @@ let UnionFind$1 = class UnionFind {
     this.rank[rootA] += 1;
   }
 };
-function cloneVec3(value) {
+function cloneVec3$1(value) {
   return [value[0], value[1], value[2]];
 }
-function emptyBBox$1() {
+function emptyBBox$2() {
   return {
     min: [Infinity, Infinity, Infinity],
     max: [-Infinity, -Infinity, -Infinity]
   };
 }
-function expandBBox$1(target, min, max) {
+function expandBBox$2(target, min, max) {
   for (let axis = 0; axis < 3; axis += 1) {
     target.min[axis] = Math.min(target.min[axis], min[axis]);
     target.max[axis] = Math.max(target.max[axis], max[axis]);
   }
 }
-function 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);
@@ -11338,36 +11652,7 @@ function collectCandidatePairs(entries, 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) {
+function bodyCountForEntry$1(entry) {
   if (typeof entry.bodyCount === "number" && Number.isFinite(entry.bodyCount)) {
     return Math.max(0, Math.round(entry.bodyCount));
   }
@@ -11397,53 +11682,23 @@ function analyzePhysicalConnectivity(entries, rawOptions = {}) {
   };
   const warnings = [];
   const edges = [];
-  const unionFind = new UnionFind$1(entries.length);
+  const unionFind = new UnionFind$2(entries.length);
+  const meshDataByIndex = /* @__PURE__ */ new Map();
+  entries.forEach((entry, index) => {
+    const meshData = meshContactDataFor(entry);
+    if (meshData) meshDataByIndex.set(index, meshData);
+  });
   for (const pair of collectCandidatePairs(entries, options.contactTolerance)) {
     const i = pair.sourceIndex;
     const j = pair.targetIndex;
-    const 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 detection = detectPhysicalContact(entries[i], entries[j], options, {
+      sourceMesh: meshDataByIndex.get(i) ?? null,
+      targetMesh: meshDataByIndex.get(j) ?? null
+    });
+    if (detection.warning) warnings.push(detection.warning);
+    if (!detection.contact) continue;
+    unionFind.union(i, j);
+    edges.push(makeEdge(entries, i, j, detection.contact));
   }
   const objects = entries.map((entry, index) => ({
     index,
@@ -11452,10 +11707,10 @@ function analyzePhysicalConnectivity(entries, rawOptions = {}) {
     groupName: entry.groupName,
     treePath: entry.treePath,
     mock: entry.mock === true,
-    bodyCount: bodyCountForEntry(entry),
+    bodyCount: bodyCountForEntry$1(entry),
     bbox: {
-      min: cloneVec3(entry.min),
-      max: cloneVec3(entry.max)
+      min: cloneVec3$1(entry.min),
+      max: cloneVec3$1(entry.max)
     },
     componentIndex: 0
   }));
@@ -11472,7 +11727,7 @@ function analyzePhysicalConnectivity(entries, rawOptions = {}) {
         objectNames: [],
         objectCount: 0,
         bodyCount: 0,
-        bbox: emptyBBox$1()
+        bbox: emptyBBox$2()
       };
       componentByRoot.set(root, component);
       rootToComponentIndex.set(root, component.index);
@@ -11484,11 +11739,11 @@ function analyzePhysicalConnectivity(entries, rawOptions = {}) {
     component.objectNames.push(object.name);
     component.objectCount += 1;
     component.bodyCount += object.bodyCount;
-    expandBBox$1(component.bbox, object.bbox.min, object.bbox.max);
+    expandBBox$2(component.bbox, object.bbox.min, object.bbox.max);
   }
   const components = [...componentByRoot.values()];
   return {
-    method: options.exactGeometry ? "boolean-overlap-plus-bbox-contact" : "bbox-neighborhood",
+    method: options.exactGeometry ? "mesh-contact-plus-boolean-overlap" : "bbox-neighborhood",
     options,
     objectCount: objects.length,
     componentCount: components.length,
@@ -11689,6 +11944,185 @@ function analyzeDistanceInspection(entries, rawOptions = {}) {
     warnings: [...connectivity.warnings]
   };
 }
+const DEFAULT_CONTACT_TOLERANCE = 0.05;
+const DEFAULT_BED_TOLERANCE = 0.05;
+const DEFAULT_GROUND_Z = 0;
+const MIN_SHAPE_OVERLAP_VOLUME = 1e-9;
+let UnionFind$1 = class UnionFind2 {
+  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 bodyCountForEntry(entry) {
+  if (typeof entry.bodyCount === "number" && Number.isFinite(entry.bodyCount)) {
+    return Math.max(0, Math.round(entry.bodyCount));
+  }
+  return 1;
+}
+function resolveNonNegative(value, fallback) {
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function resolveFinite(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function analyzeFloatingInspection(entries, rawOptions = {}) {
+  const options = {
+    contactTolerance: resolveNonNegative(rawOptions.contactTolerance, DEFAULT_CONTACT_TOLERANCE),
+    bedTolerance: resolveNonNegative(rawOptions.bedTolerance, DEFAULT_BED_TOLERANCE),
+    groundZ: resolveFinite(rawOptions.groundZ, DEFAULT_GROUND_Z)
+  };
+  const unionFind = new UnionFind$1(entries.length);
+  const contacts = [];
+  const warnings = [];
+  const meshDataByIndex = /* @__PURE__ */ new Map();
+  entries.forEach((entry, index2) => {
+    const meshData = meshContactDataFor(entry);
+    if (meshData) meshDataByIndex.set(index2, meshData);
+  });
+  const candidateTolerance = options.contactTolerance > 0 ? options.contactTolerance : Number.EPSILON;
+  const index = new AabbSpatialIndex(entries);
+  const contactOptions = {
+    contactTolerance: options.contactTolerance,
+    minOverlapVolume: MIN_SHAPE_OVERLAP_VOLUME,
+    exactGeometry: true,
+    mergeOverlappingBBoxes: false,
+    mergeTouchingBBoxes: false
+  };
+  for (const pair of index.overlapPairs({ padding: candidateTolerance }).pairs) {
+    const source = entries[pair.sourceIndex];
+    const target = entries[pair.targetIndex];
+    const detection = detectPhysicalContact(source, target, contactOptions, {
+      sourceMesh: meshDataByIndex.get(pair.sourceIndex) ?? null,
+      targetMesh: meshDataByIndex.get(pair.targetIndex) ?? null
+    });
+    if (detection.warning) warnings.push(detection.warning);
+    if (!detection.contact) continue;
+    unionFind.union(pair.sourceIndex, pair.targetIndex);
+    contacts.push({
+      sourceIndex: pair.sourceIndex,
+      targetIndex: pair.targetIndex,
+      sourceId: source.id,
+      targetId: target.id,
+      sourceName: source.name,
+      targetName: target.name,
+      gap: detection.contact.gap
+    });
+  }
+  const objects = entries.map((entry, entryIndex) => ({
+    index: entryIndex,
+    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,
+    isRootComponent: false,
+    isBedSupported: entry.min[2] <= options.groundZ + options.bedTolerance,
+    isFloating: false
+  }));
+  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(),
+        isRoot: false,
+        isBedSupported: false,
+        isFloating: false
+      };
+      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;
+    component.isBedSupported || (component.isBedSupported = object.isBedSupported);
+    expandBBox$1(component.bbox, object.bbox.min, object.bbox.max);
+  }
+  const components = [...componentByRoot.values()];
+  for (const component of components) {
+    component.isRoot = false;
+    component.isFloating = !component.isBedSupported;
+  }
+  const componentByIndex = new Map(components.map((component) => [component.index, component]));
+  for (const object of objects) {
+    const component = componentByIndex.get(object.componentIndex);
+    object.isRootComponent = false;
+    object.isBedSupported = (component == null ? void 0 : component.isBedSupported) ?? object.isBedSupported;
+    object.isFloating = (component == null ? void 0 : component.isFloating) ?? false;
+  }
+  return {
+    method: "mesh-contact-ground-reachability",
+    options,
+    rootComponentIndex: null,
+    objectCount: objects.length,
+    componentCount: components.length,
+    floatingComponentCount: components.filter((component) => component.isFloating).length,
+    floatingObjectCount: objects.filter((object) => object.isFloating).length,
+    floatingBodyCount: components.filter((component) => component.isFloating).reduce((total, component) => total + component.bodyCount, 0),
+    contacts,
+    objects,
+    components,
+    warnings
+  };
+}
 const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
   smoothAngleDeg: 5,
   sharpAngleDeg: 30,
@@ -12086,7 +12520,8 @@ const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
   minThickness: 1.2,
   warnThickness: 2,
   maxThickness: 6,
-  maxSamplesPerObject: 5e3
+  maxSamplesPerObject: 5e3,
+  contactTolerance: DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance
 };
 const THICKNESS_COLORS = {
   critical: [255, 28, 28],
@@ -12102,6 +12537,13 @@ function finitePositive(value, fallback, label) {
   }
   return value;
 }
+function finiteNonNegative(value, fallback, label) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative finite number.`);
+  }
+  return value;
+}
 function resolveThicknessInspectionOptions(raw = {}) {
   const minThickness = finitePositive(raw.minThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.minThickness, "minThickness");
   const warnThickness = finitePositive(raw.warnThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.warnThickness, "warnThickness");
@@ -12111,6 +12553,11 @@ function resolveThicknessInspectionOptions(raw = {}) {
     DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxSamplesPerObject,
     "maxSamplesPerObject"
   );
+  const contactTolerance = finiteNonNegative(
+    raw.contactTolerance,
+    DEFAULT_THICKNESS_INSPECTION_OPTIONS.contactTolerance,
+    "contactTolerance"
+  );
   if (minThickness > warnThickness) {
     throw new Error("minThickness must be less than or equal to warnThickness.");
   }
@@ -12121,7 +12568,8 @@ function resolveThicknessInspectionOptions(raw = {}) {
     minThickness,
     warnThickness,
     maxThickness,
-    maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject))
+    maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject)),
+    contactTolerance
   };
 }
 function lerp$1(a, b, t) {
@@ -12162,22 +12610,45 @@ function geometryMaxDimension(geometry) {
   box.getSize(size);
   return Math.max(1, size.x, size.y, size.z);
 }
-function firstOppositeSurfaceDistance(raycaster, mesh, point, direction, epsilon, far) {
+function firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, jumpableMeshes, point, direction, epsilon, far, contactTolerance) {
   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);
+  const hits = raycaster.intersectObjects(rayTargetMeshes, false);
+  for (const hit of hits) {
+    if (hit.distance <= epsilon) continue;
+    if (hit.distance <= contactTolerance && jumpableMeshes.has(hit.object)) continue;
+    return hit.distance + epsilon;
+  }
+  return null;
+}
+function triangleThickness(raycaster, rayTargetMeshes, jumpableMeshes, centroid, normal, epsilon, far, contactTolerance) {
+  const forward = firstOppositeSurfaceDistance(
+    raycaster,
+    rayTargetMeshes,
+    jumpableMeshes,
+    centroid,
+    normal,
+    epsilon,
+    far,
+    contactTolerance
+  );
+  const backward = firstOppositeSurfaceDistance(
+    raycaster,
+    rayTargetMeshes,
+    jumpableMeshes,
+    centroid,
+    normal.clone().negate(),
+    epsilon,
+    far,
+    contactTolerance
+  );
   if (forward == null) return backward;
   if (backward == null) return forward;
   return Math.min(forward, backward);
 }
-function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}) {
+function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {}) {
   const options = resolveThicknessInspectionOptions(rawOptions);
   const geometry = cloneGeometryForFaceColors(sourceGeometry);
   const position = geometry.getAttribute("position");
@@ -12195,7 +12666,8 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}) {
   const triangleCount = Math.floor(position.count / 3);
   const surfaceTriangles = readSurfaceTriangles(position);
   const surfaceSamples = sampleSurfaceTriangles(surfaceTriangles, options.maxSamplesPerObject);
-  const maxDim = geometryMaxDimension(geometry);
+  const connectedGeometries = context.connectedGeometries ?? [];
+  const maxDim = Math.max(geometryMaxDimension(geometry), ...connectedGeometries.map(geometryMaxDimension));
   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);
@@ -12204,7 +12676,15 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}) {
   const pointSamples = [];
   const warnings = [];
   const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
-  const rayMesh = new Mesh(geometry, rayMaterial);
+  const rayTargets = [
+    { mesh: new Mesh(geometry, rayMaterial), jumpable: false },
+    ...connectedGeometries.map((connectedGeometry) => ({
+      mesh: new Mesh(connectedGeometry, rayMaterial),
+      jumpable: true
+    }))
+  ];
+  const rayTargetMeshes = rayTargets.map((target) => target.mesh);
+  const jumpableMeshes = new Set(rayTargets.filter((target) => target.jumpable).map((target) => target.mesh));
   const raycaster = new Raycaster();
   if (surfaceTriangles.length === 0) {
     warnings.push("No non-degenerate triangle surface was available for thickness sampling.");
@@ -12216,7 +12696,16 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}) {
   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);
+    const thickness = triangleThickness(
+      raycaster,
+      rayTargetMeshes,
+      jumpableMeshes,
+      sample.position,
+      sample.normal,
+      epsilon,
+      far,
+      options.contactTolerance
+    );
     samples.push({ thickness, area: sample.area });
     const previous = triangleThicknessValues[sample.triangle.index];
     if (previous === void 0 || previous == null || thickness != null && thickness < previous) {
@@ -12254,7 +12743,7 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}) {
   };
 }
 const DEFAULT_VERTEX_TOLERANCE = 1e-5;
-class UnionFind2 {
+class UnionFind3 {
   constructor(size) {
     __publicField(this, "parent");
     __publicField(this, "rank");
@@ -12313,7 +12802,7 @@ function analyzeMeshConnectedComponents(positions, vertexTolerance = DEFAULT_VER
   const vertexComponentIndexes = new Int32Array(vertexCount);
   if (triangleCount === 0) return { components: [], vertexComponentIndexes };
   const tolerance = Number.isFinite(vertexTolerance) && vertexTolerance > 0 ? vertexTolerance : DEFAULT_VERTEX_TOLERANCE;
-  const unionFind = new UnionFind2(triangleCount);
+  const unionFind = new UnionFind3(triangleCount);
   const vertexOwnerByKey = /* @__PURE__ */ new Map();
   for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
     for (let corner = 0; corner < 3; corner += 1) {
@@ -12364,12 +12853,25 @@ function objectConnectivityEntry(object) {
     shape: object.shape,
     min: object.min,
     max: object.max,
+    positions: object.positions,
     groupName: object.groupName,
     treePath: object.treePath,
     mock: object.mock,
     bodyCount: 1
   };
 }
+function componentPositions(sourcePositions, component) {
+  const out = new Float32Array(component.triangleIndexes.length * 9);
+  let outOffset = 0;
+  for (const triangleIndex of component.triangleIndexes) {
+    const sourceOffset = triangleIndex * 9;
+    for (let offset = 0; offset < 9; offset += 1) {
+      out[outOffset + offset] = sourcePositions[sourceOffset + offset];
+    }
+    outOffset += 9;
+  }
+  return out;
+}
 function buildMeshBodyConnectivityInput(objects, options) {
   const entries = [];
   const bodyIdsByObjectId = /* @__PURE__ */ new Map();
@@ -12393,6 +12895,7 @@ function buildMeshBodyConnectivityInput(objects, options) {
         shape: options.bodyShape(object, component),
         min: component.bbox.min,
         max: component.bbox.max,
+        positions: componentPositions(object.positions, component),
         groupName: object.groupName,
         treePath: object.treePath,
         mock: object.mock,
@@ -12427,6 +12930,8 @@ function meshVertexColorBuffersFor(input, colorForEntryId) {
   }
   return out;
 }
+const FLOATING_HIGHLIGHT_COLOR = [255, 68, 16];
+const FLOATING_HIDDEN_COLOR = [0, 0, 0];
 const MASK_PALETTE = [
   [230, 25, 75],
   [60, 180, 75],
@@ -12475,6 +12980,149 @@ function distanceColorForRootDistance(distance, maxDistance) {
   if (t <= 0.5) return rgbToHex(lerpRgb(DISTANCE_NEAR_COLOR, DISTANCE_MID_COLOR, t * 2));
   return rgbToHex(lerpRgb(DISTANCE_MID_COLOR, DISTANCE_FAR_COLOR, (t - 0.5) * 2));
 }
+const MIN_FIELD_GRID_SIZE = 18;
+const MAX_FIELD_GRID_SIZE = 32;
+const MAX_BLEND_SAMPLES = 12;
+const MAX_SEARCH_RADIUS = 5;
+const SAMPLE_RING_OFFSETS = [];
+for (let radius = 0; radius <= MAX_SEARCH_RADIUS; radius += 1) {
+  const ring = [];
+  for (let x = -radius; x <= radius; x += 1) {
+    for (let y = -radius; y <= radius; y += 1) {
+      for (let z = -radius; z <= radius; z += 1) {
+        if (Math.max(Math.abs(x), Math.abs(y), Math.abs(z)) === radius) ring.push([x, y, z]);
+      }
+    }
+  }
+  SAMPLE_RING_OFFSETS.push(ring);
+}
+function gridKey(x, y, z) {
+  return `${x},${y},${z}`;
+}
+function buildGeometryBounds(geometry) {
+  const position = geometry.getAttribute("position");
+  if (!position || position.count === 0) return null;
+  const bounds = new Box3().setFromBufferAttribute(position);
+  if (bounds.isEmpty()) return null;
+  const size = bounds.getSize(new Vector3());
+  const pad = Math.max(size.x, size.y, size.z, 1) * 1e-5;
+  bounds.expandByScalar(pad);
+  return bounds;
+}
+function buildSampleGrid(pointCloud) {
+  const sampleCount = Math.floor(pointCloud.positions.length / 3);
+  if (sampleCount <= 0) return null;
+  const bounds = new Box3();
+  const point = new Vector3();
+  for (let sample = 0; sample < sampleCount; sample += 1) {
+    const offset = sample * 3;
+    bounds.expandByPoint(point.set(pointCloud.positions[offset], pointCloud.positions[offset + 1], pointCloud.positions[offset + 2]));
+  }
+  const size = bounds.getSize(new Vector3());
+  const maxDim = Math.max(size.x, size.y, size.z);
+  const cellSize = maxDim > 0 ? Math.max(maxDim / Math.cbrt(sampleCount), 1e-6) : 1;
+  const cells = /* @__PURE__ */ new Map();
+  for (let sample = 0; sample < sampleCount; sample += 1) {
+    const offset = sample * 3;
+    const x = Math.floor((pointCloud.positions[offset] - bounds.min.x) / cellSize);
+    const y = Math.floor((pointCloud.positions[offset + 1] - bounds.min.y) / cellSize);
+    const z = Math.floor((pointCloud.positions[offset + 2] - bounds.min.z) / cellSize);
+    const key = gridKey(x, y, z);
+    const entries = cells.get(key);
+    if (entries) {
+      entries.push(sample);
+    } else {
+      cells.set(key, [sample]);
+    }
+  }
+  return { origin: bounds.min, cellSize, cells };
+}
+function fieldGridSizeForSampleCount(sampleCount) {
+  if (sampleCount <= 0) return MIN_FIELD_GRID_SIZE;
+  const scaled = Math.ceil(Math.cbrt(sampleCount) * 2.6);
+  return Math.max(MIN_FIELD_GRID_SIZE, Math.min(MAX_FIELD_GRID_SIZE, scaled));
+}
+function distanceSquaredToSample(pointCloud, sample, point) {
+  const offset = sample * 3;
+  return (pointCloud.positions[offset] - point.x) ** 2 + (pointCloud.positions[offset + 1] - point.y) ** 2 + (pointCloud.positions[offset + 2] - point.z) ** 2;
+}
+function nearestSamples(point, pointCloud, sampleGrid) {
+  const baseX = Math.floor((point.x - sampleGrid.origin.x) / sampleGrid.cellSize);
+  const baseY = Math.floor((point.y - sampleGrid.origin.y) / sampleGrid.cellSize);
+  const baseZ = Math.floor((point.z - sampleGrid.origin.z) / sampleGrid.cellSize);
+  const found = [];
+  for (const ring of SAMPLE_RING_OFFSETS) {
+    for (const [dx, dy, dz] of ring) {
+      const entries = sampleGrid.cells.get(gridKey(baseX + dx, baseY + dy, baseZ + dz));
+      if (!entries) continue;
+      for (const sample of entries) {
+        found.push({ sample, distSq: distanceSquaredToSample(pointCloud, sample, point) });
+      }
+    }
+    if (found.length >= MAX_BLEND_SAMPLES) break;
+  }
+  if (found.length === 0) {
+    const sampleCount = Math.floor(pointCloud.positions.length / 3);
+    for (let sample = 0; sample < sampleCount; sample += 1) {
+      found.push({ sample, distSq: distanceSquaredToSample(pointCloud, sample, point) });
+    }
+  }
+  found.sort((a, b) => a.distSq - b.distSq);
+  return found.slice(0, MAX_BLEND_SAMPLES);
+}
+function blendedColorAt(point, pointCloud, sampleGrid) {
+  const samples = nearestSamples(point, pointCloud, sampleGrid);
+  if (samples.length === 0) return [90, 90, 90];
+  const sigma = Math.max(sampleGrid.cellSize * 1.65, 1e-6);
+  const sigmaSq = sigma * sigma;
+  let weightSum = 0;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  for (const { sample, distSq: distSq2 } of samples) {
+    const colorOffset = sample * 3;
+    const weight = Math.exp(-distSq2 / (2 * sigmaSq)) + 1e-4 / Math.max(distSq2, 1e-8);
+    weightSum += weight;
+    r += (pointCloud.colors[colorOffset] ?? 0.35) * 255 * weight;
+    g += (pointCloud.colors[colorOffset + 1] ?? 0.35) * 255 * weight;
+    b += (pointCloud.colors[colorOffset + 2] ?? 0.35) * 255 * weight;
+  }
+  if (weightSum <= 0) return [90, 90, 90];
+  return [r / weightSum, g / weightSum, b / weightSum];
+}
+function buildInspectHeatmapFieldData(geometry, pointCloud) {
+  const bounds = buildGeometryBounds(geometry);
+  const sampleGrid = buildSampleGrid(pointCloud);
+  if (!bounds || !sampleGrid) return null;
+  const gridSize = fieldGridSizeForSampleCount(Math.floor(pointCloud.positions.length / 3));
+  const boundsSize = bounds.getSize(new Vector3());
+  const data = new Uint8Array(gridSize * gridSize * gridSize * 4);
+  const point = new Vector3();
+  let dataOffset = 0;
+  for (let y = 0; y < gridSize; y += 1) {
+    for (let z = 0; z < gridSize; z += 1) {
+      for (let x = 0; x < gridSize; x += 1) {
+        point.set(
+          bounds.min.x + boundsSize.x * x / (gridSize - 1),
+          bounds.min.y + boundsSize.y * y / (gridSize - 1),
+          bounds.min.z + boundsSize.z * z / (gridSize - 1)
+        );
+        const [r, g, b] = blendedColorAt(point, pointCloud, sampleGrid);
+        data[dataOffset] = Math.max(0, Math.min(255, Math.round(r)));
+        data[dataOffset + 1] = Math.max(0, Math.min(255, Math.round(g)));
+        data[dataOffset + 2] = Math.max(0, Math.min(255, Math.round(b)));
+        data[dataOffset + 3] = 255;
+        dataOffset += 4;
+      }
+    }
+  }
+  return {
+    data,
+    boundsMin: [bounds.min.x, bounds.min.y, bounds.min.z],
+    boundsSize: [boundsSize.x, boundsSize.y, boundsSize.z],
+    gridSize
+  };
+}
 const workerScope = self;
 class EmptyIntersectionShape {
   intersect() {
@@ -12524,6 +13172,7 @@ function objectColorsFor(objects, input, colorByEntryId) {
 }
 function analyzeScalarChannel(request) {
   const pointObjects = [];
+  const heatmapFieldObjects = [];
   const warnings = [];
   for (const object of request.objects) {
     if (!object.positions || object.positions.length < 9) continue;
@@ -12532,6 +13181,13 @@ function analyzeScalarChannel(request) {
       const analysis = request.channel === "thickness" ? analyzeThicknessGeometry(geometry, request.thickness) : analyzeRoughnessGeometry(geometry, request.roughness);
       analysis.warnings.forEach((warning) => warnings.push(`${object.name}: ${warning}`));
       const buffers = pointBuffers(analysis.pointSamples);
+      const field = buildInspectHeatmapFieldData(analysis.geometry, buffers);
+      if (field) {
+        heatmapFieldObjects.push({
+          objectId: object.id,
+          ...field
+        });
+      }
       pointObjects.push({
         objectId: object.id,
         sampleCount: analysis.pointSamples.length,
@@ -12547,6 +13203,7 @@ function analyzeScalarChannel(request) {
     objectColors: {},
     pointObjects,
     meshColorObjects: [],
+    heatmapFieldObjects,
     warnings
   };
 }
@@ -12576,6 +13233,21 @@ function analyzeConnectivityChannel(request) {
       objectColors: objectColorsFor(request.objects, bodyInput, colorByEntryId2),
       pointObjects: [],
       meshColorObjects: meshColorObjectsFor(bodyInput, colorByEntryId2),
+      heatmapFieldObjects: [],
+      warnings: report2.warnings
+    };
+  }
+  if (request.channel === "floating") {
+    const report2 = analyzeFloatingInspection(entries, { groundZ: request.groundZ });
+    const colorByEntryId2 = new Map(
+      report2.objects.map((object) => [object.id, rgbToHex(object.isFloating ? FLOATING_HIGHLIGHT_COLOR : FLOATING_HIDDEN_COLOR)])
+    );
+    return {
+      channel: request.channel,
+      objectColors: objectColorsFor(request.objects, bodyInput, colorByEntryId2),
+      pointObjects: [],
+      meshColorObjects: meshColorObjectsFor(bodyInput, colorByEntryId2),
+      heatmapFieldObjects: [],
       warnings: report2.warnings
     };
   }
@@ -12586,13 +13258,15 @@ function analyzeConnectivityChannel(request) {
     objectColors: objectColorsFor(request.objects, bodyInput, colorByEntryId),
     pointObjects: [],
     meshColorObjects: meshColorObjectsFor(bodyInput, colorByEntryId),
+    heatmapFieldObjects: [],
     warnings: report.warnings
   };
 }
 function transferFor(result) {
   return [
     ...result.pointObjects.flatMap((object) => [object.positions.buffer, object.colors.buffer]),
-    ...result.meshColorObjects.map((object) => object.colors.buffer)
+    ...result.meshColorObjects.map((object) => object.colors.buffer),
+    ...result.heatmapFieldObjects.map((object) => object.data.buffer)
   ];
 }
 self.onmessage = (event) => {