forgecad 0.9.7 → 0.9.8

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

@@ -1,8 +1,8 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { D as DoubleSide, bI as initSolverWasm, bH as initKernel, S as Scene, bJ as BoxGeometry, be as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bK as localAabbPlaneRelation, h as Vector2, bL as ShapeUtils, bM as aabbInteriorOverlaps, bN as aabbOverlapVolume, bO as AabbSpatialIndex, bP as aabbGaps, g as Vector3, R as Raycaster, aU as BufferAttribute, a0 as MathUtils, G as Box3, e as Color, aC as resolveForgeRenderStyle, ba as getRenderStylePreset, ax as setParamOverrides, b7 as runScript, bQ as Group, b3 as shapeToGeometry, b8 as MeshPhysicalMaterial, bb as AdditiveBlending, aH as LineBasicMaterial, b9 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bR as intersectWithPlane, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, bS as parseCameraCliSpec, bT as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bA as findJointAnimationClip, p as Plane, Y as Vector4, $ as Matrix4, bh as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bg as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bB as resolveJointAnimation, bC as resolveJointViewValues, bU as PointsMaterial, bV as Points, b2 as analyzeCollisionIntersections, bW as serializeCollisionFinding, bX as worldAuthorPlaneToLocal, a$ as SpotLight } from "../sectionPlaneMath-BdTjyVfs.js";
-import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-Bngp5MrQ.js";
+import { D as DoubleSide, bT as initSolverWasm, bS as initKernel, S as Scene, bU as BoxGeometry, bo as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bV as localAabbPlaneRelation, h as Vector2, bW as ShapeUtils, bX as aabbGaps, bY as aabbInteriorOverlaps, bZ as aabbOverlapVolume, b_ as AabbSpatialIndex, g as Vector3, R as Raycaster, aU as BufferAttribute, a0 as MathUtils, G as Box3, e as Color, aC as resolveForgeRenderStyle, bb as getRenderStylePreset, ax as setParamOverrides, b7 as runScript, b$ as Group, b3 as shapeToGeometry, b8 as MeshPhysicalMaterial, bc as AdditiveBlending, aH as LineBasicMaterial, b9 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bi as ZEBRA_STRIPE_FRAGMENT_SHADER, bj as ZEBRA_STRIPE_VERTEX_SHADER, bd as ZEBRA_STRIPE_SOFTNESS, be as ZEBRA_STRIPE_SCALE, bf as ZEBRA_LIGHT_COLOR, bg as ZEBRA_DARK_COLOR, bh as ZEBRA_ACCENT_COLOR, ba as geometryWithVisibleVertexColors, c0 as intersectWithPlane, c1 as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, c2 as parseCameraCliSpec, c3 as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bK as findJointAnimationClip, p as Plane, bk as SURFACE_FIELD_FRAGMENT_SHADER, bl as SURFACE_FIELD_VERTEX_SHADER, Y as Vector4, $ as Matrix4, br as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bq as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bL as resolveJointAnimation, bM as resolveJointViewValues, c4 as PointsMaterial, c5 as Points, b2 as analyzeCollisionIntersections, c6 as serializeCollisionFinding, c7 as worldAuthorPlaneToLocal, a$ as SpotLight, bR as resolveScalarSceneSampleBudget } from "../scalar-sampling-budget-iBAeF8RM.js";
+import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-BIvOkPK3.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -457,13 +457,333 @@ function computeMeshSectionCap(mesh, planeInput) {
     warnings: stitched.warnings.length > 0 ? stitched.warnings : void 0
   };
 }
+const AXIS_NAMES = ["x", "y", "z"];
+function nearestBoundaryGap(a, b, axis) {
+  return Math.min(Math.abs(a.max[axis] - b.min[axis]), Math.abs(b.max[axis] - a.min[axis]));
+}
+function hasPositiveGap(gaps) {
+  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
+}
+function contactFromBBoxes(a, b, tolerance) {
+  const gaps = aabbGaps(a, b);
+  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
+  if (largestGap > tolerance) return { touching: false, gap: largestGap };
+  const separatedAxes = gaps.map((gap, axis) => ({ gap, axis })).filter((entry) => entry.gap > 0);
+  if (separatedAxes.length > 0) {
+    const nearest2 = separatedAxes.reduce((best, entry) => entry.gap > best.gap ? entry : best, separatedAxes[0]);
+    return { touching: true, gap: nearest2.gap, axis: AXIS_NAMES[nearest2.axis] };
+  }
+  const boundaryAxes = AXIS_NAMES.map((axisName, axis) => ({
+    axis,
+    axisName,
+    gap: nearestBoundaryGap(a, b, axis)
+  })).filter((entry) => entry.gap <= tolerance);
+  if (boundaryAxes.length === 0) return { touching: false, gap: 0 };
+  const nearest = boundaryAxes.reduce((best, entry) => entry.gap < best.gap ? entry : best, boundaryAxes[0]);
+  return { touching: true, gap: nearest.gap, axis: nearest.axisName };
+}
+function isFiniteTriangle(positions, offset) {
+  for (let index = 0; index < 9; index += 1) {
+    if (!Number.isFinite(positions[offset + index])) return false;
+  }
+  return true;
+}
+function triangleRef(positions, offset) {
+  if (!isFiniteTriangle(positions, offset)) return null;
+  const ax = positions[offset];
+  const ay = positions[offset + 1];
+  const az = positions[offset + 2];
+  const bx = positions[offset + 3];
+  const by = positions[offset + 4];
+  const bz = positions[offset + 5];
+  const cx = positions[offset + 6];
+  const cy = positions[offset + 7];
+  const cz = positions[offset + 8];
+  return {
+    offset,
+    min: [Math.min(ax, bx, cx), Math.min(ay, by, cy), Math.min(az, bz, cz)],
+    max: [Math.max(ax, bx, cx), Math.max(ay, by, cy), Math.max(az, bz, cz)]
+  };
+}
+function meshContactDataFor(entry) {
+  const positions = entry.positions;
+  if (!positions || positions.length < 9) return null;
+  const triangleCount = Math.floor(positions.length / 9);
+  const triangles = [];
+  for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
+    const triangle = triangleRef(positions, triangleIndex * 9);
+    if (triangle) triangles.push(triangle);
+  }
+  if (triangles.length === 0) return null;
+  return {
+    positions,
+    vertexCount: triangleCount * 3,
+    triangles
+  };
+}
+function distSq(px, py, pz, qx, qy, qz) {
+  const dx = px - qx;
+  const dy = py - qy;
+  const dz = pz - qz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function pointSegmentDistanceSq(point, start, end) {
+  const dx = end[0] - start[0];
+  const dy = end[1] - start[1];
+  const dz = end[2] - start[2];
+  const lengthSq = dx * dx + dy * dy + dz * dz;
+  if (lengthSq <= 1e-20) return distSq(point[0], point[1], point[2], start[0], start[1], start[2]);
+  const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy + (point[2] - start[2]) * dz) / lengthSq));
+  return distSq(point[0], point[1], point[2], start[0] + t * dx, start[1] + t * dy, start[2] + t * dz);
+}
+function pointTriangleDistanceSq(px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz) {
+  const abx = bx - ax;
+  const aby = by - ay;
+  const abz = bz - az;
+  const acx = cx - ax;
+  const acy = cy - ay;
+  const acz = cz - az;
+  const apx = px - ax;
+  const apy = py - ay;
+  const apz = pz - az;
+  const d1 = abx * apx + aby * apy + abz * apz;
+  const d2 = acx * apx + acy * apy + acz * apz;
+  if (d1 <= 0 && d2 <= 0) return distSq(px, py, pz, ax, ay, az);
+  const bpx = px - bx;
+  const bpy = py - by;
+  const bpz = pz - bz;
+  const d3 = abx * bpx + aby * bpy + abz * bpz;
+  const d4 = acx * bpx + acy * bpy + acz * bpz;
+  if (d3 >= 0 && d4 <= d3) return distSq(px, py, pz, bx, by, bz);
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+    const v2 = d1 / (d1 - d3);
+    return distSq(px, py, pz, ax + v2 * abx, ay + v2 * aby, az + v2 * abz);
+  }
+  const cpx = px - cx;
+  const cpy = py - cy;
+  const cpz = pz - cz;
+  const d5 = abx * cpx + aby * cpy + abz * cpz;
+  const d6 = acx * cpx + acy * cpy + acz * cpz;
+  if (d6 >= 0 && d5 <= d6) return distSq(px, py, pz, cx, cy, cz);
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+    const w2 = d2 / (d2 - d6);
+    return distSq(px, py, pz, ax + w2 * acx, ay + w2 * acy, az + w2 * acz);
+  }
+  const va = d3 * d6 - d5 * d4;
+  if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
+    const bcx = cx - bx;
+    const bcy = cy - by;
+    const bcz = cz - bz;
+    const w2 = (d4 - d3) / (d4 - d3 + d5 - d6);
+    return distSq(px, py, pz, bx + w2 * bcx, by + w2 * bcy, bz + w2 * bcz);
+  }
+  const barycentricTotal = va + vb + vc;
+  if (!Number.isFinite(barycentricTotal) || Math.abs(barycentricTotal) < 1e-20) {
+    return Math.min(distSq(px, py, pz, ax, ay, az), distSq(px, py, pz, bx, by, bz), distSq(px, py, pz, cx, cy, cz));
+  }
+  const denom = 1 / barycentricTotal;
+  const v = vb * denom;
+  const w = vc * denom;
+  return distSq(px, py, pz, ax + abx * v + acx * w, ay + aby * v + acy * w, az + abz * v + acz * w);
+}
+function segmentSegmentDistanceSq(a0, a1, b0, b1) {
+  const ux = a1[0] - a0[0];
+  const uy = a1[1] - a0[1];
+  const uz = a1[2] - a0[2];
+  const vx = b1[0] - b0[0];
+  const vy = b1[1] - b0[1];
+  const vz = b1[2] - b0[2];
+  const wx = a0[0] - b0[0];
+  const wy = a0[1] - b0[1];
+  const wz = a0[2] - b0[2];
+  const a = ux * ux + uy * uy + uz * uz;
+  const b = ux * vx + uy * vy + uz * vz;
+  const c = vx * vx + vy * vy + vz * vz;
+  const d = ux * wx + uy * wy + uz * wz;
+  const e = vx * wx + vy * wy + vz * wz;
+  const denom = a * c - b * b;
+  let sNumerator = denom;
+  let sDenominator = denom;
+  let tNumerator = denom;
+  let tDenominator = denom;
+  if (a <= 1e-20) return pointSegmentDistanceSq(a0, b0, b1);
+  if (c <= 1e-20) return pointSegmentDistanceSq(b0, a0, a1);
+  if (denom < 1e-20) {
+    sNumerator = 0;
+    sDenominator = 1;
+    tNumerator = e;
+    tDenominator = c;
+  } else {
+    sNumerator = b * e - c * d;
+    tNumerator = a * e - b * d;
+    if (sNumerator < 0) {
+      sNumerator = 0;
+      tNumerator = e;
+      tDenominator = c;
+    } else if (sNumerator > sDenominator) {
+      sNumerator = sDenominator;
+      tNumerator = e + b;
+      tDenominator = c;
+    }
+  }
+  if (tNumerator < 0) {
+    tNumerator = 0;
+    if (-d < 0) {
+      sNumerator = 0;
+    } else if (-d > a) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d;
+      sDenominator = a;
+    }
+  } else if (tNumerator > tDenominator) {
+    tNumerator = tDenominator;
+    if (-d + b < 0) {
+      sNumerator = 0;
+    } else if (-d + b > a) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d + b;
+      sDenominator = a;
+    }
+  }
+  const s = Math.abs(sNumerator) < 1e-20 ? 0 : sNumerator / sDenominator;
+  const t = Math.abs(tNumerator) < 1e-20 ? 0 : tNumerator / tDenominator;
+  const dx = wx + s * ux - t * vx;
+  const dy = wy + s * uy - t * vy;
+  const dz = wz + s * uz - t * vz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function trianglePoint(positions, triangle, corner) {
+  const offset = triangle.offset + corner * 3;
+  return [positions[offset], positions[offset + 1], positions[offset + 2]];
+}
+function bboxDistanceSq(a, b) {
+  let total = 0;
+  for (let axis = 0; axis < 3; axis += 1) {
+    const gap = Math.max(0, a.min[axis] - b.max[axis], b.min[axis] - a.max[axis]);
+    total += gap * gap;
+  }
+  return total;
+}
+function triangleDistanceSq(aPositions, a, bPositions, b) {
+  const a0 = trianglePoint(aPositions, a, 0);
+  const a1 = trianglePoint(aPositions, a, 1);
+  const a2 = trianglePoint(aPositions, a, 2);
+  const b0 = trianglePoint(bPositions, b, 0);
+  const b1 = trianglePoint(bPositions, b, 1);
+  const b2 = trianglePoint(bPositions, b, 2);
+  return Math.min(
+    pointTriangleDistanceSq(a0[0], a0[1], a0[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b2[0], b2[1], b2[2]),
+    pointTriangleDistanceSq(a1[0], a1[1], a1[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b2[0], b2[1], b2[2]),
+    pointTriangleDistanceSq(a2[0], a2[1], a2[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b2[0], b2[1], b2[2]),
+    pointTriangleDistanceSq(b0[0], b0[1], b0[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    pointTriangleDistanceSq(b1[0], b1[1], b1[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    pointTriangleDistanceSq(b2[0], b2[1], b2[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    segmentSegmentDistanceSq(a0, a1, b0, b1),
+    segmentSegmentDistanceSq(a0, a1, b1, b2),
+    segmentSegmentDistanceSq(a0, a1, b2, b0),
+    segmentSegmentDistanceSq(a1, a2, b0, b1),
+    segmentSegmentDistanceSq(a1, a2, b1, b2),
+    segmentSegmentDistanceSq(a1, a2, b2, b0),
+    segmentSegmentDistanceSq(a2, a0, b0, b1),
+    segmentSegmentDistanceSq(a2, a0, b1, b2),
+    segmentSegmentDistanceSq(a2, a0, b2, b0)
+  );
+}
+function meshEntriesContactDistance(a, b, tolerance) {
+  const toleranceSq = tolerance * tolerance;
+  let bestDistanceSq = Infinity;
+  for (const aTriangle of a.triangles) {
+    for (const bTriangle of b.triangles) {
+      if (bboxDistanceSq(aTriangle, bTriangle) > toleranceSq) continue;
+      const distanceSq = triangleDistanceSq(a.positions, aTriangle, b.positions, bTriangle);
+      if (distanceSq > toleranceSq) continue;
+      if (distanceSq <= 1e-20) return 0;
+      bestDistanceSq = Math.min(bestDistanceSq, distanceSq);
+    }
+  }
+  return Number.isFinite(bestDistanceSq) ? Math.sqrt(bestDistanceSq) : null;
+}
+function intersectionVolume(a, b) {
+  try {
+    const hit = a.shape.intersect(b.shape);
+    if (hit.isEmpty()) return { volume: 0 };
+    const volume = hit.volume();
+    return { volume: Number.isFinite(volume) ? volume : 0 };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { volume: null, warning: `Could not boolean-test ${a.name} against ${b.name}: ${message}` };
+  }
+}
+function detectPhysicalContact(a, b, options, meshCache = {}) {
+  const gaps = aabbGaps(a, b);
+  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
+  if (largestGap > options.contactTolerance) return { contact: null };
+  const sourceMesh = meshCache.sourceMesh !== void 0 ? meshCache.sourceMesh : meshContactDataFor(a);
+  const targetMesh = meshCache.targetMesh !== void 0 ? meshCache.targetMesh : meshContactDataFor(b);
+  if (sourceMesh && targetMesh) {
+    const distance = meshEntriesContactDistance(sourceMesh, targetMesh, options.contactTolerance);
+    if (distance != null) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "mesh-surface-distance",
+          gap: distance
+        }
+      };
+    }
+  }
+  const bboxOverlaps = !hasPositiveGap(gaps) && aabbInteriorOverlaps(a, b);
+  if (options.exactGeometry && bboxOverlaps) {
+    if (aabbOverlapVolume(a, b) <= options.minOverlapVolume) return { contact: null };
+    const overlap = intersectionVolume(a, b);
+    if (overlap.volume != null && overlap.volume > options.minOverlapVolume) {
+      return {
+        contact: {
+          kind: "overlap",
+          method: "boolean-intersection",
+          gap: 0,
+          overlapVolume: overlap.volume
+        },
+        warning: overlap.warning
+      };
+    }
+    return { contact: null, warning: overlap.warning };
+  }
+  if (bboxOverlaps && options.mergeOverlappingBBoxes) {
+    return {
+      contact: {
+        kind: "overlap",
+        method: "bbox-overlap",
+        gap: 0,
+        overlapVolume: aabbOverlapVolume(a, b)
+      }
+    };
+  }
+  if (options.mergeTouchingBBoxes) {
+    const contact = contactFromBBoxes(a, b, options.contactTolerance);
+    if (contact.touching) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "bbox-contact",
+          gap: contact.gap,
+          axis: contact.axis
+        }
+      };
+    }
+  }
+  return { contact: null };
+}
 const DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
   contactTolerance: 0.05,
   minOverlapVolume: 0.1,
   exactGeometry: true
 };
-const AXIS_NAMES = ["x", "y", "z"];
-let UnionFind$1 = class UnionFind {
+let UnionFind$2 = class UnionFind {
   constructor(size) {
     __publicField(this, "parent");
     __publicField(this, "rank");
@@ -493,27 +813,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);
@@ -525,36 +839,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));
   }
@@ -584,53 +869,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,
@@ -639,10 +894,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
   }));
@@ -659,7 +914,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);
@@ -671,11 +926,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,
@@ -876,6 +1131,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 CAMERA_TOKEN_DIRECTIONS = {
   front: [0, -1, 0.2],
   back: [0, 1, 0.2],
@@ -908,6 +1342,7 @@ function parseCameraToken(token) {
     `Unknown camera "${token}". Use a preset (front, back, side, right, top, iso) or azimuth:elevation in degrees (e.g. 45:30).`
   );
 }
+const CLI_DEFAULT_BACKEND = "manifold";
 function formatAvailableViews(views) {
   const names = Object.keys(views ?? {}).sort();
   if (names.length === 0) {
@@ -936,14 +1371,36 @@ function resolveNamedSceneViewCamera(sceneConfig, viewName) {
   }
   return sceneViewCameraToViewportCameraState(view.camera);
 }
-function edgesStrokeAttrs(preset) {
+function paletteForTheme(theme) {
+  if (theme === "cad-section") {
+    return {
+      background: "#f7f7f4",
+      fill: "#e6e8eb",
+      stroke: "#20262e",
+      hatchStroke: "#a8afb7",
+      strokeThin: 0.22,
+      strokeBold: 0.55,
+      useHatch: true
+    };
+  }
+  return {
+    background: "#2a2a2a",
+    fill: "#4488cc",
+    stroke: "#224466",
+    hatchStroke: "#224466",
+    strokeThin: 0.3,
+    strokeBold: 0.8,
+    useHatch: false
+  };
+}
+function edgesStrokeAttrs(preset, palette) {
   switch (preset) {
     case "off":
       return 'stroke="none"';
     case "bold":
-      return 'stroke="#224466" stroke-width="0.8"';
+      return `stroke="${palette.stroke}" stroke-width="${palette.strokeBold}"`;
     default:
-      return 'stroke="#224466" stroke-width="0.3"';
+      return `stroke="${palette.stroke}" stroke-width="${palette.strokeThin}"`;
   }
 }
 function combineBounds(left, right) {
@@ -958,6 +1415,19 @@ function escapeAttribute(value) {
 function polygonPath(poly) {
   return `${poly.map((point, index) => `${index === 0 ? "M" : "L"}${point[0].toFixed(3)},${(-point[1]).toFixed(3)}`).join(" ")} Z`;
 }
+function compoundPolygonPath(polygons) {
+  return polygons.map(polygonPath).join(" ");
+}
+function hatchDefs(palette) {
+  if (!palette.useHatch) return "";
+  return `  <defs>
+    <pattern id="forge-section-hatch" patternUnits="userSpaceOnUse" width="4" height="4" patternTransform="rotate(45)">
+      <rect width="4" height="4" fill="${palette.fill}"/>
+      <line x1="0" y1="0" x2="0" y2="4" stroke="${palette.hatchStroke}" stroke-width="0.28"/>
+    </pattern>
+  </defs>
+`;
+}
 function prepareEntry(entry) {
   const polygons = entry.sketch.toPolygons();
   if (polygons.length === 0) {
@@ -979,7 +1449,9 @@ function buildSketchSvgDocument(entries, options = {}) {
     throw new Error("Sketch SVG export requires at least one sketch payload.");
   }
   const edges = options.edges ?? "thin";
-  const strokeAttrs = edgesStrokeAttrs(edges);
+  const palette = paletteForTheme(options.theme ?? "debug");
+  const strokeAttrs = edgesStrokeAttrs(edges, palette);
+  const fill = palette.useHatch ? "url(#forge-section-hatch)" : palette.fill;
   const prepared = entries.map(prepareEntry);
   const combinedBounds = prepared.reduce((acc, entry) => combineBounds(acc, entry.bounds), prepared[0].bounds);
   const margin = 2;
@@ -992,17 +1464,15 @@ function buildSketchSvgDocument(entries, options = {}) {
   let pathCount = 0;
   const body = prepared.map((entry) => {
     const label = entry.name ? ` data-name="${escapeAttribute(entry.name)}"` : "";
-    const paths = entry.polygons.map((poly) => {
-      pathCount += 1;
-      return `    <path d="${polygonPath(poly)}" fill="#4488cc" ${strokeAttrs}/>`;
-    }).join("\n");
+    pathCount += entry.polygons.length;
     return `  <g${label}>
-${paths}
+    <path d="${compoundPolygonPath(entry.polygons)}" fill="${fill}" fill-rule="evenodd" ${strokeAttrs}/>
   </g>`;
   }).join("\n");
   return {
     svg: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${minX.toFixed(1)} ${(-maxY).toFixed(1)} ${width.toFixed(1)} ${height.toFixed(1)}" width="${Math.max(width * 4, 400)}" height="${Math.max(height * 4, 400)}">
-  <rect x="${minX.toFixed(1)}" y="${(-maxY).toFixed(1)}" width="${width.toFixed(1)}" height="${height.toFixed(1)}" fill="#2a2a2a"/>
+  <rect x="${minX.toFixed(1)}" y="${(-maxY).toFixed(1)}" width="${width.toFixed(1)}" height="${height.toFixed(1)}" fill="${palette.background}"/>
+${hatchDefs(palette)}
 ${body}
 </svg>`,
     width,
@@ -1015,7 +1485,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],
@@ -1031,6 +1502,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");
@@ -1040,6 +1518,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.");
   }
@@ -1050,7 +1533,8 @@ function resolveThicknessInspectionOptions(raw = {}) {
     minThickness,
     warnThickness,
     maxThickness,
-    maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject))
+    maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject)),
+    contactTolerance
   };
 }
 function lerp(a, b, t) {
@@ -1249,22 +1733,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;
+  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, 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);
+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");
@@ -1282,7 +1789,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);
@@ -1291,7 +1799,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.");
@@ -1303,7 +1819,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) {
@@ -1637,7 +2162,7 @@ function pointSegmentDistance(point, start, end) {
   return point.distanceTo(segment.multiplyScalar(t).add(start));
 }
 const DEFAULT_VERTEX_TOLERANCE = 1e-5;
-class UnionFind2 {
+class UnionFind3 {
   constructor(size) {
     __publicField(this, "parent");
     __publicField(this, "rank");
@@ -1696,7 +2221,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) {
@@ -1747,12 +2272,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();
@@ -1776,6 +2314,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,
@@ -1854,6 +2393,9 @@ class EmptyInspectionShape {
 const COLLISION_SOURCE_OPACITY = 0.22;
 const COLLISION_SOURCE_COLOR = [180, 200, 220];
 const COLLISION_HIGHLIGHT_COLOR = [255, 68, 16];
+const FLOATING_HIGHLIGHT_COLOR = [255, 68, 16];
+const FLOATING_CONTEXT_COLOR = [38, 49, 58];
+const FLOATING_HIDDEN_COLOR = [0, 0, 0];
 const COLLISION_PALETTE = [
   COLLISION_HIGHLIGHT_COLOR,
   [0, 204, 255],
@@ -1894,18 +2436,13 @@ const MASK_PALETTE = [
   [0, 0, 128],
   [128, 128, 128]
 ];
-function cloneShapePositions(shape) {
-  const geometry = shapeToGeometry(shape);
-  try {
-    const position = geometry.solid.getAttribute("position");
-    if (!position) return void 0;
-    return new Float32Array(position.array);
-  } finally {
-    geometry.solid.dispose();
-    geometry.edges.dispose();
-  }
+function cloneGeometryPositions(geometry) {
+  if (!geometry) return void 0;
+  const position = geometry.getAttribute("position");
+  if (!position) return void 0;
+  return new Float32Array(position.array);
 }
-function meshConnectivitySource(entry) {
+function meshConnectivitySource(entry, positions) {
   const bb = entry.shape.boundingBox();
   return {
     id: entry.source.id,
@@ -1916,7 +2453,7 @@ function meshConnectivitySource(entry) {
     groupName: entry.source.groupName,
     treePath: entry.source.treePath,
     mock: entry.source.mock,
-    positions: cloneShapePositions(entry.shape)
+    positions
   };
 }
 function summarizeSceneGeometry(entries) {
@@ -2268,6 +2805,37 @@ function renderCurrentNormals(session) {
     normalMaterial.dispose();
   }
 }
+function renderCurrentZebra(session) {
+  const r = getRenderer(session.size, session.pixelRatio);
+  const zebraMaterial = new ShaderMaterial({
+    uniforms: {
+      uAccentColor: { value: new Color(ZEBRA_ACCENT_COLOR) },
+      uDarkColor: { value: new Color(ZEBRA_DARK_COLOR) },
+      uLightColor: { value: new Color(ZEBRA_LIGHT_COLOR) },
+      uStripeScale: { value: ZEBRA_STRIPE_SCALE },
+      uStripeSoftness: { value: ZEBRA_STRIPE_SOFTNESS }
+    },
+    vertexShader: ZEBRA_STRIPE_VERTEX_SHADER,
+    fragmentShader: ZEBRA_STRIPE_FRAGMENT_SHADER,
+    side: DoubleSide
+  });
+  zebraMaterial.toneMapped = false;
+  const prevOverride = session.scene.overrideMaterial;
+  session.scene.overrideMaterial = zebraMaterial;
+  try {
+    return withSolidOnlyVisibility(
+      session,
+      () => withTemporarySceneBackground(session, new Color(0), () => {
+        updateSdfRaymarchUniforms(session);
+        r.render(session.scene, session.camera);
+        return captureRenderedPng(session.size);
+      })
+    );
+  } finally {
+    session.scene.overrideMaterial = prevOverride;
+    zebraMaterial.dispose();
+  }
+}
 function maskColorForIndex(index) {
   return MASK_PALETTE[(index - 1) % MASK_PALETTE.length];
 }
@@ -2371,6 +2939,47 @@ function analyzeSessionConnectivity(session) {
   }
   return session.physicalConnectivity;
 }
+function addContactNeighbor(target, sourceId, targetId) {
+  let neighbors = target.get(sourceId);
+  if (!neighbors) {
+    neighbors = /* @__PURE__ */ new Set();
+    target.set(sourceId, neighbors);
+  }
+  neighbors.add(targetId);
+}
+function baseObjectIdForConnectivityEntry(entryId, renderableIds) {
+  if (renderableIds.has(entryId)) return entryId;
+  const bodySuffixIndex = entryId.lastIndexOf(":body:");
+  if (bodySuffixIndex <= 0) return null;
+  const baseId = entryId.slice(0, bodySuffixIndex);
+  return renderableIds.has(baseId) ? baseId : null;
+}
+function buildThicknessRaycastConnectivityContext(session) {
+  const report = analyzeSessionConnectivity(session);
+  const renderableById = new Map(
+    session.renderables.filter((renderable) => !renderable.sdfRaymarch).map((renderable) => [renderable.id, renderable])
+  );
+  const renderableIds = new Set(renderableById.keys());
+  const neighborIdsByObjectId = /* @__PURE__ */ new Map();
+  for (const edge of report.edges) {
+    const sourceId = baseObjectIdForConnectivityEntry(edge.sourceId, renderableIds);
+    const targetId = baseObjectIdForConnectivityEntry(edge.targetId, renderableIds);
+    if (!sourceId || !targetId || sourceId === targetId) continue;
+    addContactNeighbor(neighborIdsByObjectId, sourceId, targetId);
+    addContactNeighbor(neighborIdsByObjectId, targetId, sourceId);
+  }
+  return { neighborIdsByObjectId, renderableById };
+}
+function connectedThicknessGeometriesFor(context, source) {
+  const neighborIds = context.neighborIdsByObjectId.get(source.id);
+  if (!neighborIds) return [];
+  const geometries = [];
+  for (const neighborId of neighborIds) {
+    const renderable = context.renderableById.get(neighborId);
+    if (renderable) geometries.push(renderable.solid.geometry);
+  }
+  return geometries;
+}
 function decorateConnectivityReport(report) {
   const components = report.components.map((component) => {
     const color = maskColorForIndex(component.index);
@@ -2539,6 +3148,151 @@ function renderCurrentDistance(session) {
     });
   }
 }
+function analyzeSessionFloating(session) {
+  if (!session.floatingReport) {
+    session.floatingReport = analyzeFloatingInspection(session.connectivityEntries, { groundZ: session.floatingGroundZ });
+  }
+  return session.floatingReport;
+}
+function decorateFloatingReport(report) {
+  const components = report.components.map((component) => {
+    const color = component.isFloating ? FLOATING_HIGHLIGHT_COLOR : FLOATING_HIDDEN_COLOR;
+    return {
+      ...component,
+      color,
+      hex: colorHex(color)
+    };
+  });
+  const objectByComponentIndex = new Map(components.map((component) => [component.index, component]));
+  const objects = report.objects.map((object) => {
+    var _a;
+    const color = ((_a = objectByComponentIndex.get(object.componentIndex)) == null ? void 0 : _a.color) ?? FLOATING_HIDDEN_COLOR;
+    return {
+      ...object,
+      color,
+      hex: colorHex(color)
+    };
+  });
+  return {
+    method: report.method,
+    options: report.options,
+    rootComponentIndex: report.rootComponentIndex,
+    objectCount: report.objectCount,
+    componentCount: report.componentCount,
+    floatingComponentCount: report.floatingComponentCount,
+    floatingObjectCount: report.floatingObjectCount,
+    floatingBodyCount: report.floatingBodyCount,
+    objects,
+    components,
+    contacts: report.contacts,
+    warnings: report.warnings,
+    style: {
+      highlightColor: FLOATING_HIGHLIGHT_COLOR,
+      highlightHex: colorHex(FLOATING_HIGHLIGHT_COLOR),
+      contextColor: FLOATING_CONTEXT_COLOR,
+      contextHex: colorHex(FLOATING_CONTEXT_COLOR),
+      hiddenColor: FLOATING_HIDDEN_COLOR,
+      hiddenHex: colorHex(FLOATING_HIDDEN_COLOR)
+    }
+  };
+}
+function renderCurrentFloating(session) {
+  const r = getRenderer(session.size, session.pixelRatio);
+  const report = decorateFloatingReport(analyzeSessionFloating(session));
+  const byId = new Map(report.objects.map((object) => [object.id, object]));
+  const vertexColorsById = session.connectivityBodyInput ? meshVertexColorBuffersFor(session.connectivityBodyInput, (entryId) => {
+    var _a;
+    return rgbFloats(((_a = byId.get(entryId)) == null ? void 0 : _a.color) ?? FLOATING_HIDDEN_COLOR);
+  }) : /* @__PURE__ */ new Map();
+  const replacements = session.renderables.map((renderable) => {
+    var _a;
+    const object = byId.get(renderable.id);
+    const colors = vertexColorsById.get(renderable.id);
+    const vertexGeometry = colors ? geometryWithVisibleVertexColors(renderable.solid.geometry, colors) : null;
+    const previousMaterial = renderable.solid.material;
+    const previousGeometry = renderable.solid.geometry;
+    const previousVisible = renderable.solid.visible;
+    const previousWireVisible = renderable.wire.visible;
+    const previousShellVisible = (_a = renderable.shell) == null ? void 0 : _a.visible;
+    const contextMaterial = new MeshBasicMaterial({
+      color: colorHex(FLOATING_CONTEXT_COLOR),
+      transparent: true,
+      opacity: 0.18,
+      side: DoubleSide,
+      depthWrite: false,
+      clippingPlanes: renderable.solidMaterial.clippingPlanes ?? null
+    });
+    contextMaterial.toneMapped = false;
+    const highlightMaterial = new MeshBasicMaterial({
+      color: vertexGeometry ? 16777215 : colorHex(FLOATING_HIGHLIGHT_COLOR),
+      vertexColors: Boolean(vertexGeometry),
+      side: DoubleSide,
+      depthWrite: false,
+      clippingPlanes: renderable.solidMaterial.clippingPlanes ?? null,
+      polygonOffset: true,
+      polygonOffsetFactor: -1,
+      polygonOffsetUnits: -1
+    });
+    highlightMaterial.toneMapped = false;
+    renderable.solid.material = contextMaterial;
+    renderable.solid.geometry = previousGeometry;
+    renderable.solid.visible = true;
+    const highlightGeometry = vertexGeometry ?? ((object == null ? void 0 : object.isFloating) === true ? previousGeometry : null);
+    const highlightMesh = highlightGeometry ? new Mesh(highlightGeometry, highlightMaterial) : null;
+    if (highlightMesh) {
+      highlightMesh.renderOrder = 5;
+      highlightMesh.raycast = () => null;
+      renderable.root.add(highlightMesh);
+    }
+    renderable.wire.visible = false;
+    if (renderable.shell) renderable.shell.visible = false;
+    return {
+      renderable,
+      previousMaterial,
+      previousGeometry,
+      previousVisible,
+      previousWireVisible,
+      previousShellVisible,
+      vertexGeometry,
+      contextMaterial,
+      highlightMaterial,
+      highlightMesh
+    };
+  });
+  try {
+    const png = withTemporarySceneBackground(session, new Color(0), () => {
+      updateSdfRaymarchUniforms(session);
+      r.render(session.scene, session.camera);
+      return captureRenderedPng(session.size);
+    });
+    return { png, report };
+  } finally {
+    replacements.forEach(
+      ({
+        renderable,
+        previousMaterial,
+        previousGeometry,
+        previousVisible,
+        previousWireVisible,
+        previousShellVisible,
+        vertexGeometry,
+        contextMaterial,
+        highlightMaterial,
+        highlightMesh
+      }) => {
+        if (highlightMesh) renderable.root.remove(highlightMesh);
+        renderable.solid.material = previousMaterial;
+        renderable.solid.geometry = previousGeometry;
+        renderable.solid.visible = previousVisible;
+        renderable.wire.visible = previousWireVisible;
+        if (renderable.shell && previousShellVisible !== void 0) renderable.shell.visible = previousShellVisible;
+        vertexGeometry == null ? void 0 : vertexGeometry.dispose();
+        contextMaterial.dispose();
+        highlightMaterial.dispose();
+      }
+    );
+  }
+}
 function analyzeSessionCollisions(session) {
   if (!session.collisionReport) {
     session.collisionReport = analyzeCollisionIntersections(session.collisionEntries);
@@ -2549,7 +3303,15 @@ function decorateCollisionReport(report) {
   return {
     method: report.method,
     options: report.options,
+    broadphase: report.broadphase,
     objectCount: report.objectCount,
+    candidatePairCount: report.candidatePairCount,
+    bboxVolumePrunedPairCount: report.bboxVolumePrunedPairCount,
+    testedPairCount: report.testedPairCount,
+    skippedPairCount: report.skippedPairCount,
+    pairLimitSkippedPairCount: report.pairLimitSkippedPairCount,
+    timeBudgetSkippedPairCount: report.timeBudgetSkippedPairCount,
+    exactCheckMs: report.exactCheckMs,
     collisionCount: report.collisionCount,
     objects: report.objects,
     collisions: report.collisions.map((finding) => {
@@ -2637,6 +3399,26 @@ function renderCurrentCollisions(session) {
 function inspectionOptionsKey(value) {
   return JSON.stringify(value ?? {});
 }
+function scalarInspectableObjectCount(session) {
+  return session.renderables.filter((renderable) => !renderable.sdfRaymarch).length;
+}
+function withSceneSampleBudget(session, options, explicitMaxSamplesPerObject) {
+  const sampleBudget = resolveScalarSceneSampleBudget({
+    objectCount: scalarInspectableObjectCount(session),
+    maxSamplesPerObject: options.maxSamplesPerObject,
+    explicitMaxSamplesPerObject
+  });
+  return {
+    options: { ...options, maxSamplesPerObject: sampleBudget.effectiveMaxSamplesPerObject },
+    sampleBudget
+  };
+}
+function maybePushSceneSampleBudgetWarning(warnings, channel, sampleBudget) {
+  if (!sampleBudget.capped) return;
+  warnings.push(
+    `${channel} inspection scene budget lowered maxSamplesPerObject from ${sampleBudget.requestedMaxSamplesPerObject} to ${sampleBudget.effectiveMaxSamplesPerObject} across ${sampleBudget.objectCount} mesh object(s); pass the sample-count flag to override.`
+  );
+}
 function bboxFromGeometry(geometry) {
   geometry.computeBoundingBox();
   const bbox = geometry.boundingBox;
@@ -2717,22 +3499,27 @@ function renderScalarPointOverlays(session, overlays) {
 }
 function getSessionThicknessInspection(session, rawOptions) {
   var _a;
-  const options = resolveThicknessInspectionOptions(rawOptions);
-  const optionsKey = inspectionOptionsKey(options);
+  const resolvedOptions = resolveThicknessInspectionOptions(rawOptions);
+  const { options, sampleBudget } = withSceneSampleBudget(session, resolvedOptions, (rawOptions == null ? void 0 : rawOptions.maxSamplesPerObject) !== void 0);
+  const optionsKey = inspectionOptionsKey({ options, sampleBudget });
   if (((_a = session.thicknessInspection) == null ? void 0 : _a.optionsKey) === optionsKey) return session.thicknessInspection;
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   const warnings = [];
+  maybePushSceneSampleBudgetWarning(warnings, "Thickness", sampleBudget);
   const objects = [];
   const cloudObjects = [];
   const points = [];
   const overlays = [];
+  const raycastConnectivity = buildThicknessRaycastConnectivityContext(session);
   session.renderables.forEach((renderable, index) => {
     const sourceObject = byId.get(renderable.id);
     if (renderable.sdfRaymarch) {
       warnings.push(`${renderable.name}: SDF raymarch objects are not included in mesh thickness inspection.`);
       return;
     }
-    const analysis = analyzeThicknessGeometry(renderable.solid.geometry, options);
+    const analysis = analyzeThicknessGeometry(renderable.solid.geometry, options, {
+      connectedGeometries: connectedThicknessGeometriesFor(raycastConnectivity, renderable)
+    });
     const bbox = bboxFromGeometry(analysis.geometry);
     const summary = summarizeThicknessSamples(analysis.samples, options);
     if (analysis.warnings.length > 0) {
@@ -2786,8 +3573,9 @@ function getSessionThicknessInspection(session, rawOptions) {
       points
     },
     report: {
-      method: "mesh-normal-raycast",
+      method: "mesh-normal-raycast-contact-aware",
       options,
+      sampleBudget,
       objectCount: objects.length,
       objects,
       warnings,
@@ -2815,11 +3603,13 @@ function renderCurrentRoughness(session, rawOptions) {
 }
 function getSessionRoughnessInspection(session, rawOptions) {
   var _a;
-  const options = resolveRoughnessInspectionOptions(rawOptions);
-  const optionsKey = inspectionOptionsKey(options);
+  const resolvedOptions = resolveRoughnessInspectionOptions(rawOptions);
+  const { options, sampleBudget } = withSceneSampleBudget(session, resolvedOptions, (rawOptions == null ? void 0 : rawOptions.maxSamplesPerObject) !== void 0);
+  const optionsKey = inspectionOptionsKey({ options, sampleBudget });
   if (((_a = session.roughnessInspection) == null ? void 0 : _a.optionsKey) === optionsKey) return session.roughnessInspection;
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   const warnings = [];
+  maybePushSceneSampleBudgetWarning(warnings, "Roughness", sampleBudget);
   const objects = [];
   const cloudObjects = [];
   const points = [];
@@ -2882,6 +3672,7 @@ function getSessionRoughnessInspection(session, rawOptions) {
     report: {
       method: "mesh-dihedral-angle",
       options,
+      sampleBudget,
       objectCount: objects.length,
       objects,
       warnings,
@@ -2900,14 +3691,14 @@ function getSessionRoughnessInspection(session, rawOptions) {
 }
 function emptySectionSvg() {
   return {
-    svg: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="-1 -1 2 2" width="400" height="400"><rect x="-1" y="-1" width="2" height="2" fill="#2a2a2a"/></svg>',
+    svg: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="-1 -1 2 2" width="400" height="400"><rect x="-1" y="-1" width="2" height="2" fill="#f7f7f4"/></svg>',
     width: 0,
     height: 0,
     area: 0,
     pathCount: 0
   };
 }
-async function svgToPngDataUrl(svg, size, background = "#2a2a2a") {
+async function svgToPngDataUrl(svg, size, background = "#f7f7f4") {
   if (!exportCtx) {
     throw new Error("Could not create export canvas context.");
   }
@@ -2965,7 +3756,7 @@ async function renderSectionAtlas(session, opts) {
           sectionSketches.push({ name: entry.name, sketch });
         }
       }
-      const svgDocument = sectionSketches.length > 0 ? buildSketchSvgDocument(sectionSketches, { edges: "thin" }) : emptySectionSvg();
+      const svgDocument = sectionSketches.length > 0 ? buildSketchSvgDocument(sectionSketches, { edges: "thin", theme: "cad-section" }) : emptySectionSvg();
       slices.push({
         index,
         offset,
@@ -3015,6 +3806,37 @@ function addRenderStyleLights(scene, style) {
     new HemisphereLight(new Color(lights.hemisphereSky), new Color(lights.hemisphereGround), lights.hemisphereIntensity)
   );
 }
+function fieldKindUniform(kind) {
+  return kind === "hybrid" ? 1 : 0;
+}
+function createSurfaceFieldMaterial({
+  field,
+  objectColor,
+  clippingPlanes,
+  fieldScale
+}) {
+  return new ShaderMaterial({
+    vertexShader: SURFACE_FIELD_VERTEX_SHADER,
+    fragmentShader: SURFACE_FIELD_FRAGMENT_SHADER,
+    uniforms: {
+      uAccentColor: { value: new Color(field.accentColor) },
+      uBaseColor: { value: new Color(field.baseColor) },
+      uDarkColor: { value: new Color(field.darkColor) },
+      uFieldKind: { value: fieldKindUniform(field.kind) },
+      uFieldScale: { value: fieldScale },
+      uGlow: { value: field.glow },
+      uLineColor: { value: new Color(field.lineColor) },
+      uLineWidth: { value: field.lineWidth },
+      uNodeColor: { value: new Color(field.nodeColor) },
+      uObjectColor: { value: objectColor },
+      uObjectColorMix: { value: field.objectColorMix },
+      uSpacing: { value: field.spacing }
+    },
+    side: DoubleSide,
+    toneMapped: false,
+    clippingPlanes
+  });
+}
 function createSceneLight(def) {
   const color = def.color ? new Color(def.color) : new Color(16777215);
   const intensity = def.intensity ?? 1;
@@ -3703,7 +4525,7 @@ function isFocusVisible(obj, focus, hide) {
   return true;
 }
 function createSession(code, opts) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
   const size = (opts == null ? void 0 : opts.size) ?? 1024;
   const pixelRatio = (opts == null ? void 0 : opts.pixelRatio) ?? 1;
   const debug = createCaptureDebugLogger(opts == null ? void 0 : opts.debug);
@@ -3785,8 +4607,6 @@ function createSession(code, opts) {
     name: entry.source.name,
     shape: entry.shape
   }));
-  const connectivityBodyInput = (opts == null ? void 0 : opts.includeConnectivity) ? buildMeshBodyConnectivityInput(shapeVisibleObjs.map(meshConnectivitySource), { bodyShape: () => new EmptyInspectionShape() }) : null;
-  const connectivityEntries = (connectivityBodyInput == null ? void 0 : connectivityBodyInput.entries) ?? [];
   const collisionEntries = (opts == null ? void 0 : opts.includeCollisions) ? shapeVisibleObjs.map((entry) => {
     const bb2 = entry.shape.boundingBox();
     return {
@@ -3843,6 +4663,7 @@ function createSession(code, opts) {
   const bsize = new Vector3();
   bb.getSize(bsize);
   const maxDim = Math.max(1, bsize.x, bsize.y, bsize.z);
+  const surfaceFieldScale = maxDim / 5;
   const fov = 45;
   const distance = maxDim / (2 * Math.tan(fov * Math.PI / 360)) * 1.6;
   const cameraFov = ((_c = requestedSceneState == null ? void 0 : requestedSceneState.camera) == null ? void 0 : _c.fov) ?? ((_d = sceneConfig == null ? void 0 : sceneConfig.camera) == null ? void 0 : _d.fov) ?? fov;
@@ -3949,15 +4770,17 @@ function createSession(code, opts) {
         edgeSegments: Math.floor((((_m = geo.edges.getAttribute("position")) == null ? void 0 : _m.count) ?? 0) / 2)
       });
       const materialDefaults = renderStylePreset.material;
+      const surfaceField = renderStylePreset.surfaceField;
       const authoredMaterialOpacity = mp == null ? void 0 : mp.opacity;
       const authoredMaterialTransmission = mp == null ? void 0 : mp.transmission;
       const hasAuthoredTransparency = authoredMaterialOpacity !== void 0 && authoredMaterialOpacity < 0.99 || authoredMaterialTransmission !== void 0 && authoredMaterialTransmission > 0;
       const transparentDefaults = hasAuthoredTransparency ? materialDefaults.authoredTransparent : materialDefaults;
       const materialOpacity = Math.min(obj.opacity, authoredMaterialOpacity ?? materialDefaults.opacity);
       const materialTransmission = authoredMaterialTransmission ?? transparentDefaults.transmission;
+      const objectColor = parseColor(obj.color, CAD_MATERIAL_PROPS.color);
       const solidMaterialProps = {
         ...CAD_MATERIAL_PROPS,
-        color: parseColor(obj.color, CAD_MATERIAL_PROPS.color),
+        color: objectColor,
         metalness: (mp == null ? void 0 : mp.metalness) ?? materialDefaults.metalness,
         roughness: (mp == null ? void 0 : mp.roughness) ?? transparentDefaults.roughness,
         clearcoat: (mp == null ? void 0 : mp.clearcoat) ?? transparentDefaults.clearcoat,
@@ -3973,7 +4796,12 @@ function createSession(code, opts) {
         ...(mp == null ? void 0 : mp.emissiveIntensity) !== void 0 && { emissiveIntensity: mp.emissiveIntensity },
         ...(mp == null ? void 0 : mp.wireframe) && { wireframe: true }
       };
-      solidMaterial = new MeshPhysicalMaterial({
+      solidMaterial = surfaceField.enabled ? createSurfaceFieldMaterial({
+        field: surfaceField,
+        objectColor,
+        clippingPlanes: applicableCutPlanes,
+        fieldScale: surfaceFieldScale
+      }) : new MeshPhysicalMaterial({
         ...solidMaterialProps,
         transparent: materialOpacity < 1 || materialTransmission > 0,
         opacity: materialOpacity,
@@ -4051,6 +4879,19 @@ function createSession(code, opts) {
       ...sdfRaymarch ? { sdfRaymarch } : {}
     });
   }
+  const renderableById = new Map(renderables.map((renderable) => [renderable.id, renderable]));
+  const connectivityBodyInput = (opts == null ? void 0 : opts.includeConnectivity) ? buildMeshBodyConnectivityInput(
+    shapeVisibleObjs.map(
+      (entry) => {
+        var _a2;
+        return meshConnectivitySource(entry, cloneGeometryPositions((_a2 = renderableById.get(entry.source.id)) == null ? void 0 : _a2.solid.geometry));
+      }
+    ),
+    { bodyShape: () => new EmptyInspectionShape() }
+  ) : null;
+  const connectivityEntries = (connectivityBodyInput == null ? void 0 : connectivityBodyInput.entries) ?? [];
+  const groundOffset = Number.isFinite((_n = sceneConfig == null ? void 0 : sceneConfig.ground) == null ? void 0 : _n.offset) ? sceneConfig.ground.offset : 0;
+  const floatingGroundZ = bbox.min[2] - groundOffset;
   let sceneConfigCameraState = null;
   if ((sceneConfig == null ? void 0 : sceneConfig.camera) && !(requestedSceneState == null ? void 0 : requestedSceneState.camera)) {
     const cam = sceneConfig.camera;
@@ -4068,7 +4909,7 @@ function createSession(code, opts) {
   }
   const cameraSpec = sceneConfigCameraState && (opts == null ? void 0 : opts.capture) === "section-sweep" ? fitCameraStateToBounds(sceneConfigCameraState, bbox, cameraFov) : (requestedSceneState == null ? void 0 : requestedSceneState.camera) ?? sceneConfigCameraState;
   const cameraRig = buildCameraRig(center, distance, maxDim, cameraSpec, cameraFov);
-  const explicitCameraFov = (cameraSpec == null ? void 0 : cameraSpec.fov) ?? ((_n = sceneConfig == null ? void 0 : sceneConfig.camera) == null ? void 0 : _n.fov);
+  const explicitCameraFov = (cameraSpec == null ? void 0 : cameraSpec.fov) ?? ((_o = sceneConfig == null ? void 0 : sceneConfig.camera) == null ? void 0 : _o.fov);
   if (explicitCameraFov && cameraRig.camera instanceof PerspectiveCamera) {
     cameraRig.camera.fov = explicitCameraFov;
     cameraRig.camera.updateProjectionMatrix();
@@ -4090,8 +4931,10 @@ function createSession(code, opts) {
     sectionShapes,
     connectivityEntries,
     connectivityBodyInput,
+    floatingGroundZ,
     physicalConnectivity: null,
     distanceReport: null,
+    floatingReport: null,
     collisionEntries,
     collisionReport: null,
     thicknessInspection: null,
@@ -4121,6 +4964,7 @@ function createSession(code, opts) {
 }
 async function setup() {
   await init();
+  setActiveBackend(CLI_DEFAULT_BACKEND);
   window.__forgeCaptureCapabilities = CAPTURE_RUNTIME_CAPABILITIES;
   window.__forgeReady = true;
 }
@@ -4161,7 +5005,7 @@ window.__forgeRender = async (code, opts) => {
     hide: opts == null ? void 0 : opts.hide,
     paramOverrides: opts == null ? void 0 : opts.paramOverrides,
     renderStyle: opts == null ? void 0 : opts.renderStyle,
-    includeConnectivity: requestedChannels.has("connectivity") || requestedChannels.has("distance"),
+    includeConnectivity: requestedChannels.has("connectivity") || requestedChannels.has("floating") || requestedChannels.has("distance") || requestedChannels.has("thickness"),
     includeCollisions: requestedChannels.has("collisions"),
     capture: "orbit"
   });
@@ -4188,14 +5032,17 @@ window.__forgeRender = async (code, opts) => {
   const renders = {};
   const depthRenders = {};
   const normalRenders = {};
+  const zebraRenders = {};
   const maskRenders = {};
   const connectivityRenders = {};
+  const floatingRenders = {};
   const distanceRenders = {};
   const collisionRenders = {};
   const thicknessRenders = {};
   const roughnessRenders = {};
   let maskObjects = [];
   let connectivityReport = null;
+  let floatingReport = null;
   let distanceReport = null;
   let collisionReport = null;
   let thicknessReport = null;
@@ -4242,6 +5089,11 @@ window.__forgeRender = async (code, opts) => {
         normalRenders[label] = renderCurrentNormals(session);
         await markChannelViewDone("normals", label);
       }
+      if (requestedChannels.has("zebra")) {
+        await markChannelViewStart("zebra", label);
+        zebraRenders[label] = renderCurrentZebra(session);
+        await markChannelViewDone("zebra", label);
+      }
       if (requestedChannels.has("roughness")) {
         await markChannelViewStart("roughness", label);
         const roughness = renderCurrentRoughness(session, opts == null ? void 0 : opts.roughness);
@@ -4267,6 +5119,13 @@ window.__forgeRender = async (code, opts) => {
         connectivityReport = connectivity.report;
         await markChannelViewDone("connectivity", label);
       }
+      if (requestedChannels.has("floating")) {
+        await markChannelViewStart("floating", label);
+        const floating = renderCurrentFloating(session);
+        floatingRenders[label] = floating.png;
+        floatingReport = floating.report;
+        await markChannelViewDone("floating", label);
+      }
       if (requestedChannels.has("distance")) {
         await markChannelViewStart("distance", label);
         const distance = renderCurrentDistance(session);
@@ -4311,6 +5170,7 @@ window.__forgeRender = async (code, opts) => {
     renders,
     depth: depthRenders,
     normals: normalRenders,
+    zebra: zebraRenders,
     roughness: roughnessReport ? {
       ...roughnessReport,
       pointCloud: roughnessPointCloud,
@@ -4328,6 +5188,12 @@ window.__forgeRender = async (code, opts) => {
     } : {
       views: connectivityRenders
     },
+    floating: floatingReport ? {
+      ...floatingReport,
+      views: floatingRenders
+    } : {
+      views: floatingRenders
+    },
     distance: distanceReport ? {
       ...distanceReport,
       views: distanceRenders