forgecad 0.9.7 → 0.9.9

package/dist/assets/cli/{render-iP9qh475.js → render-CXVrHY8q.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, bX as initSolverWasm, bW as initKernel, S as Scene, bY as BoxGeometry, bs as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bZ as localAabbPlaneRelation, h as Vector2, b_ as ShapeUtils, b$ as analyzePhysicalConnectivity, c0 as meshContactDataFor, c1 as AabbSpatialIndex, c2 as detectPhysicalContact, g as Vector3, c3 as resolveThicknessInspectionOptions, R as Raycaster, c4 as thicknessColor, c5 as thicknessClass, aU as BufferAttribute, c6 as roughnessClassForAngle, a0 as MathUtils, c7 as resolveRoughnessInspectionOptions, G as Box3, c8 as roughnessColorForAngle, c9 as roughnessScoreForAngle, e as Color, aC as resolveForgeRenderStyle, bb as getRenderStylePreset, ax as setParamOverrides, b7 as runScript, ca 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, cb as intersectWithPlane, cc as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, cd as parseCameraCliSpec, ce as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bO as findJointAnimationClip, p as Plane, bk as SURFACE_FIELD_FRAGMENT_SHADER, bl as SURFACE_FIELD_VERTEX_SHADER, Y as Vector4, $ as Matrix4, bv as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bu as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bP as resolveJointAnimation, bQ as resolveJointViewValues, bo as ROUGHNESS_COLORS, cf as PointsMaterial, cg as Points, b2 as analyzeCollisionIntersections, ch as serializeCollisionFinding, ci as summarizeThicknessSamples, br as THICKNESS_COLORS, cj as worldAuthorPlaneToLocal, a$ as SpotLight, bV as resolveScalarSceneSampleBudget } from "../scalar-sampling-budget-Bmewod18.js";
+import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-CWO8rHlt.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -457,234 +457,6 @@ function computeMeshSectionCap(mesh, planeInput) {
     warnings: stitched.warnings.length > 0 ? stitched.warnings : void 0
   };
 }
-const DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
-  contactTolerance: 0.05,
-  minOverlapVolume: 0.1,
-  exactGeometry: true
-};
-const AXIS_NAMES = ["x", "y", "z"];
-let UnionFind$1 = class UnionFind {
-  constructor(size) {
-    __publicField(this, "parent");
-    __publicField(this, "rank");
-    this.parent = Array.from({ length: size }, (_, index) => index);
-    this.rank = Array.from({ length: size }, () => 0);
-  }
-  find(value) {
-    const parent = this.parent[value];
-    if (parent === value) return value;
-    const root = this.find(parent);
-    this.parent[value] = root;
-    return root;
-  }
-  union(a, b) {
-    const rootA = this.find(a);
-    const rootB = this.find(b);
-    if (rootA === rootB) return;
-    if (this.rank[rootA] < this.rank[rootB]) {
-      this.parent[rootA] = rootB;
-      return;
-    }
-    if (this.rank[rootA] > this.rank[rootB]) {
-      this.parent[rootB] = rootA;
-      return;
-    }
-    this.parent[rootB] = rootA;
-    this.rank[rootA] += 1;
-  }
-};
-function cloneVec3(value) {
-  return [value[0], value[1], value[2]];
-}
-function emptyBBox$1() {
-  return {
-    min: [Infinity, Infinity, Infinity],
-    max: [-Infinity, -Infinity, -Infinity]
-  };
-}
-function expandBBox$1(target, min, max) {
-  for (let axis = 0; axis < 3; axis += 1) {
-    target.min[axis] = Math.min(target.min[axis], min[axis]);
-    target.max[axis] = Math.max(target.max[axis], max[axis]);
-  }
-}
-function nearestBoundaryGap(a, b, axis) {
-  return Math.min(Math.abs(a.max[axis] - b.min[axis]), Math.abs(b.max[axis] - a.min[axis]));
-}
-function hasPositiveGap(gaps) {
-  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
-}
-function collectCandidatePairs(entries, tolerance) {
-  if (entries.length < 2) return [];
-  const index = new AabbSpatialIndex(entries);
-  const pairs = index.overlapPairs({ padding: tolerance }).pairs.map((pair) => ({
-    sourceIndex: pair.sourceIndex,
-    targetIndex: pair.targetIndex,
-    gaps: aabbGaps(entries[pair.sourceIndex], entries[pair.targetIndex])
-  })).filter((pair) => Math.max(pair.gaps[0], pair.gaps[1], pair.gaps[2]) <= tolerance);
-  pairs.sort((a, b) => a.sourceIndex - b.sourceIndex || a.targetIndex - b.targetIndex);
-  return pairs;
-}
-function contactFromBBoxes(a, b, tolerance) {
-  const gaps = aabbGaps(a, b);
-  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
-  if (largestGap > tolerance) return { touching: false, gap: largestGap };
-  const separatedAxes = gaps.map((gap, axis) => ({ gap, axis })).filter((entry) => entry.gap > 0);
-  if (separatedAxes.length > 0) {
-    const nearest2 = separatedAxes.reduce((best, entry) => entry.gap > best.gap ? entry : best, separatedAxes[0]);
-    return { touching: true, gap: nearest2.gap, axis: AXIS_NAMES[nearest2.axis] };
-  }
-  const boundaryAxes = AXIS_NAMES.map((axisName, axis) => ({
-    axis,
-    axisName,
-    gap: nearestBoundaryGap(a, b, axis)
-  })).filter((entry) => entry.gap <= tolerance);
-  if (boundaryAxes.length === 0) return { touching: false, gap: 0 };
-  const nearest = boundaryAxes.reduce((best, entry) => entry.gap < best.gap ? entry : best, boundaryAxes[0]);
-  return { touching: true, gap: nearest.gap, axis: nearest.axisName };
-}
-function intersectionVolume(a, b) {
-  try {
-    const hit = a.shape.intersect(b.shape);
-    if (hit.isEmpty()) return { volume: 0 };
-    const volume = hit.volume();
-    return { volume: Number.isFinite(volume) ? volume : 0 };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { volume: null, warning: `Could not boolean-test ${a.name} against ${b.name}: ${message}` };
-  }
-}
-function bodyCountForEntry(entry) {
-  if (typeof entry.bodyCount === "number" && Number.isFinite(entry.bodyCount)) {
-    return Math.max(0, Math.round(entry.bodyCount));
-  }
-  return 1;
-}
-function makeEdge(entries, sourceIndex, targetIndex, edge) {
-  const source = entries[sourceIndex];
-  const target = entries[targetIndex];
-  return {
-    sourceIndex,
-    targetIndex,
-    sourceId: source.id,
-    targetId: target.id,
-    sourceName: source.name,
-    targetName: target.name,
-    ...edge
-  };
-}
-function analyzePhysicalConnectivity(entries, rawOptions = {}) {
-  const exactGeometry = rawOptions.exactGeometry ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.exactGeometry;
-  const options = {
-    contactTolerance: rawOptions.contactTolerance ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance,
-    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.minOverlapVolume,
-    exactGeometry,
-    mergeOverlappingBBoxes: rawOptions.mergeOverlappingBBoxes ?? !exactGeometry,
-    mergeTouchingBBoxes: rawOptions.mergeTouchingBBoxes ?? !exactGeometry
-  };
-  const warnings = [];
-  const edges = [];
-  const unionFind = new UnionFind$1(entries.length);
-  for (const pair of collectCandidatePairs(entries, options.contactTolerance)) {
-    const i = pair.sourceIndex;
-    const j = pair.targetIndex;
-    const a = entries[i];
-    const b = entries[j];
-    const bboxOverlaps = !hasPositiveGap(pair.gaps) && aabbInteriorOverlaps(a, b);
-    if (options.exactGeometry && bboxOverlaps) {
-      const overlap = intersectionVolume(a, b);
-      if (overlap.warning) warnings.push(overlap.warning);
-      if (overlap.volume != null && overlap.volume > options.minOverlapVolume) {
-        unionFind.union(i, j);
-        edges.push(
-          makeEdge(entries, i, j, {
-            kind: "overlap",
-            method: "boolean-intersection",
-            gap: 0,
-            overlapVolume: overlap.volume
-          })
-        );
-        continue;
-      }
-      continue;
-    }
-    if (bboxOverlaps && options.mergeOverlappingBBoxes) {
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge(entries, i, j, {
-          kind: "overlap",
-          method: "bbox-overlap",
-          gap: 0,
-          overlapVolume: aabbOverlapVolume(a, b)
-        })
-      );
-    } else {
-      const contact = contactFromBBoxes(a, b, options.contactTolerance);
-      if (!contact.touching || !options.mergeTouchingBBoxes) continue;
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge(entries, i, j, {
-          kind: "touching",
-          method: "bbox-contact",
-          gap: contact.gap,
-          axis: contact.axis
-        })
-      );
-    }
-  }
-  const objects = entries.map((entry, index) => ({
-    index,
-    id: entry.id,
-    name: entry.name,
-    groupName: entry.groupName,
-    treePath: entry.treePath,
-    mock: entry.mock === true,
-    bodyCount: bodyCountForEntry(entry),
-    bbox: {
-      min: cloneVec3(entry.min),
-      max: cloneVec3(entry.max)
-    },
-    componentIndex: 0
-  }));
-  const componentByRoot = /* @__PURE__ */ new Map();
-  const rootToComponentIndex = /* @__PURE__ */ new Map();
-  for (let objectIndex = 0; objectIndex < objects.length; objectIndex += 1) {
-    const root = unionFind.find(objectIndex);
-    let component = componentByRoot.get(root);
-    if (!component) {
-      component = {
-        index: componentByRoot.size + 1,
-        objectIndexes: [],
-        objectIds: [],
-        objectNames: [],
-        objectCount: 0,
-        bodyCount: 0,
-        bbox: emptyBBox$1()
-      };
-      componentByRoot.set(root, component);
-      rootToComponentIndex.set(root, component.index);
-    }
-    const object = objects[objectIndex];
-    object.componentIndex = rootToComponentIndex.get(root) ?? component.index;
-    component.objectIndexes.push(object.index);
-    component.objectIds.push(object.id);
-    component.objectNames.push(object.name);
-    component.objectCount += 1;
-    component.bodyCount += object.bodyCount;
-    expandBBox$1(component.bbox, object.bbox.min, object.bbox.max);
-  }
-  const components = [...componentByRoot.values()];
-  return {
-    method: options.exactGeometry ? "boolean-overlap-plus-bbox-contact" : "bbox-neighborhood",
-    options,
-    objectCount: objects.length,
-    componentCount: components.length,
-    objects,
-    components,
-    edges,
-    warnings
-  };
-}
 const EPSILON = 1e-9;
 function intervalGap(aMin, aMax, bMin, bMax) {
   if (aMax < bMin) return bMin - aMax;
@@ -876,6 +648,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 UnionFind {
+  constructor(size) {
+    __publicField(this, "parent");
+    __publicField(this, "rank");
+    this.parent = Array.from({ length: size }, (_, index) => index);
+    this.rank = Array.from({ length: size }, () => 0);
+  }
+  find(value) {
+    const parent = this.parent[value];
+    if (parent === value) return value;
+    const root = this.find(parent);
+    this.parent[value] = root;
+    return root;
+  }
+  union(a, b) {
+    const rootA = this.find(a);
+    const rootB = this.find(b);
+    if (rootA === rootB) return;
+    if (this.rank[rootA] < this.rank[rootB]) {
+      this.parent[rootA] = rootB;
+      return;
+    }
+    if (this.rank[rootA] > this.rank[rootB]) {
+      this.parent[rootB] = rootA;
+      return;
+    }
+    this.parent[rootB] = rootA;
+    this.rank[rootA] += 1;
+  }
+};
+function cloneVec3(value) {
+  return [value[0], value[1], value[2]];
+}
+function emptyBBox$1() {
+  return {
+    min: [Infinity, Infinity, Infinity],
+    max: [-Infinity, -Infinity, -Infinity]
+  };
+}
+function expandBBox$1(target, min, max) {
+  for (let axis = 0; axis < 3; axis += 1) {
+    target.min[axis] = Math.min(target.min[axis], min[axis]);
+    target.max[axis] = Math.max(target.max[axis], max[axis]);
+  }
+}
+function 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 +859,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 +888,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 +932,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 +966,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 +981,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,
@@ -1011,136 +998,6 @@ ${body}
     pathCount
   };
 }
-const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
-  minThickness: 1.2,
-  warnThickness: 2,
-  maxThickness: 6,
-  maxSamplesPerObject: 5e3
-};
-const THICKNESS_COLORS = {
-  critical: [255, 28, 28],
-  warning: [255, 150, 0],
-  ok: [60, 220, 90],
-  thick: [70, 145, 255],
-  unknown: [90, 90, 90]
-};
-function finitePositive(value, fallback, label) {
-  if (value === void 0) return fallback;
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${label} must be a positive finite number.`);
-  }
-  return value;
-}
-function resolveThicknessInspectionOptions(raw = {}) {
-  const minThickness = finitePositive(raw.minThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.minThickness, "minThickness");
-  const warnThickness = finitePositive(raw.warnThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.warnThickness, "warnThickness");
-  const maxThickness = finitePositive(raw.maxThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxThickness, "maxThickness");
-  const maxSamplesPerObject = finitePositive(
-    raw.maxSamplesPerObject,
-    DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxSamplesPerObject,
-    "maxSamplesPerObject"
-  );
-  if (minThickness > warnThickness) {
-    throw new Error("minThickness must be less than or equal to warnThickness.");
-  }
-  if (warnThickness > maxThickness) {
-    throw new Error("warnThickness must be less than or equal to maxThickness.");
-  }
-  return {
-    minThickness,
-    warnThickness,
-    maxThickness,
-    maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject))
-  };
-}
-function lerp(a, b, t) {
-  return a + (b - a) * Math.max(0, Math.min(1, t));
-}
-function lerpColor$1(a, b, t) {
-  return [Math.round(lerp(a[0], b[0], t)), Math.round(lerp(a[1], b[1], t)), Math.round(lerp(a[2], b[2], t))];
-}
-function thicknessClass(thickness, options) {
-  if (thickness == null || !Number.isFinite(thickness) || thickness <= 0) return "unknown";
-  if (thickness <= options.minThickness) return "critical";
-  if (thickness <= options.warnThickness) return "warning";
-  if (thickness <= options.maxThickness) return "ok";
-  return "thick";
-}
-function thicknessColor(thickness, options) {
-  const cls = thicknessClass(thickness, options);
-  if (cls === "unknown") return THICKNESS_COLORS.unknown;
-  if (cls === "critical") return THICKNESS_COLORS.critical;
-  if (cls === "warning") {
-    const span = Math.max(1e-9, options.warnThickness - options.minThickness);
-    return lerpColor$1(THICKNESS_COLORS.critical, THICKNESS_COLORS.warning, ((thickness ?? 0) - options.minThickness) / span);
-  }
-  if (cls === "ok") {
-    const span = Math.max(1e-9, options.maxThickness - options.warnThickness);
-    return lerpColor$1(THICKNESS_COLORS.ok, THICKNESS_COLORS.thick, ((thickness ?? 0) - options.warnThickness) / span);
-  }
-  return THICKNESS_COLORS.thick;
-}
-function sampleArea(sample) {
-  const area = sample.area ?? 1;
-  return Number.isFinite(area) && area > 0 ? area : 1;
-}
-function weightedQuantile(samples, q) {
-  if (samples.length === 0) return null;
-  const sorted = [...samples].sort((a, b) => a.thickness - b.thickness);
-  const totalArea = sorted.reduce((sum, sample) => sum + sample.area, 0);
-  const target = totalArea * Math.max(0, Math.min(1, q));
-  let cumulative = 0;
-  for (const sample of sorted) {
-    cumulative += sample.area;
-    if (cumulative >= target) return sample.thickness;
-  }
-  return sorted[sorted.length - 1].thickness;
-}
-function percent(part, total) {
-  if (total <= 0) return 0;
-  return part / total * 100;
-}
-function summarizeThicknessSamples(samples, options) {
-  const resolved = [];
-  let totalArea = 0;
-  let resolvedArea = 0;
-  let unresolvedArea = 0;
-  let criticalArea = 0;
-  let warningArea = 0;
-  let weightedSum = 0;
-  for (const sample of samples) {
-    const area = sampleArea(sample);
-    totalArea += area;
-    const value = sample.thickness;
-    if (value == null || !Number.isFinite(value) || value <= 0) {
-      unresolvedArea += area;
-      continue;
-    }
-    resolved.push({ thickness: value, area });
-    resolvedArea += area;
-    weightedSum += value * area;
-    if (value <= options.minThickness) {
-      criticalArea += area;
-    } else if (value <= options.warnThickness) {
-      warningArea += area;
-    }
-  }
-  const values = resolved.map((sample) => sample.thickness);
-  return {
-    sampleCount: samples.length,
-    resolvedCount: resolved.length,
-    unresolvedCount: samples.length - resolved.length,
-    minThickness: values.length > 0 ? Math.min(...values) : null,
-    p05Thickness: weightedQuantile(resolved, 0.05),
-    medianThickness: weightedQuantile(resolved, 0.5),
-    meanThickness: resolvedArea > 0 ? weightedSum / resolvedArea : null,
-    maxThickness: values.length > 0 ? Math.max(...values) : null,
-    criticalAreaPercent: percent(criticalArea, resolvedArea),
-    warningAreaPercent: percent(warningArea, resolvedArea),
-    belowWarnAreaPercent: percent(criticalArea + warningArea, resolvedArea),
-    unresolvedAreaPercent: percent(unresolvedArea, totalArea)
-  };
-}
 const MIN_TRIANGLE_AREA = 1e-12;
 const R2_ALPHA = 0.7548776662466927;
 const R2_BETA = 0.5698402909980532;
@@ -1249,22 +1106,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 +1162,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 +1172,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 +1192,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) {
@@ -1340,79 +1238,6 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}) {
     warnings
   };
 }
-const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
-  smoothAngleDeg: 5,
-  sharpAngleDeg: 30,
-  harshAngleDeg: 90,
-  maxSamplesPerObject: 5e3
-};
-const ROUGHNESS_COLORS = {
-  smooth: [62, 72, 84],
-  moderate: [255, 214, 0],
-  sharp: [255, 124, 34],
-  harsh: [255, 42, 96]
-};
-function resolveRoughnessInspectionOptions(raw = {}) {
-  const options = {
-    smoothAngleDeg: raw.smoothAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.smoothAngleDeg,
-    sharpAngleDeg: raw.sharpAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.sharpAngleDeg,
-    harshAngleDeg: raw.harshAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.harshAngleDeg,
-    maxSamplesPerObject: raw.maxSamplesPerObject ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.maxSamplesPerObject
-  };
-  if (!Number.isFinite(options.smoothAngleDeg) || options.smoothAngleDeg < 0) {
-    throw new Error(`smoothAngleDeg must be a finite non-negative angle (got ${options.smoothAngleDeg}).`);
-  }
-  if (!Number.isFinite(options.sharpAngleDeg) || options.sharpAngleDeg <= options.smoothAngleDeg) {
-    throw new Error(`sharpAngleDeg must be greater than smoothAngleDeg (got ${options.sharpAngleDeg}).`);
-  }
-  if (!Number.isFinite(options.harshAngleDeg) || options.harshAngleDeg <= options.sharpAngleDeg || options.harshAngleDeg > 180) {
-    throw new Error(`harshAngleDeg must be greater than sharpAngleDeg and <= 180 (got ${options.harshAngleDeg}).`);
-  }
-  if (!Number.isFinite(options.maxSamplesPerObject) || options.maxSamplesPerObject <= 0) {
-    throw new Error(`maxSamplesPerObject must be a positive finite number (got ${options.maxSamplesPerObject}).`);
-  }
-  return {
-    ...options,
-    maxSamplesPerObject: Math.max(1, Math.floor(options.maxSamplesPerObject))
-  };
-}
-function roughnessClassForAngle(angleDeg, options) {
-  if (angleDeg >= options.harshAngleDeg) return "harsh";
-  if (angleDeg >= options.sharpAngleDeg) return "sharp";
-  if (angleDeg >= options.smoothAngleDeg) return "moderate";
-  return "smooth";
-}
-function roughnessScoreForAngle(angleDeg, options) {
-  if (angleDeg < options.sharpAngleDeg) return 0;
-  if (angleDeg < options.harshAngleDeg) {
-    return MathUtils.lerp(0.48, 0.82, (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg));
-  }
-  return 1;
-}
-function roughnessColorForAngle(angleDeg, options) {
-  const cls = roughnessClassForAngle(angleDeg, options);
-  if (cls === "smooth" || cls === "harsh") return ROUGHNESS_COLORS[cls];
-  if (cls === "moderate") {
-    return lerpRgb(
-      ROUGHNESS_COLORS.moderate,
-      ROUGHNESS_COLORS.sharp,
-      (angleDeg - options.smoothAngleDeg) / (options.sharpAngleDeg - options.smoothAngleDeg)
-    );
-  }
-  return lerpRgb(
-    ROUGHNESS_COLORS.sharp,
-    ROUGHNESS_COLORS.harsh,
-    (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg)
-  );
-}
-function lerpRgb(a, b, t) {
-  const clamped = MathUtils.clamp(t, 0, 1);
-  return [
-    Math.round(MathUtils.lerp(a[0], b[0], clamped)),
-    Math.round(MathUtils.lerp(a[1], b[1], clamped)),
-    Math.round(MathUtils.lerp(a[2], b[2], clamped))
-  ];
-}
 function emptyRoughnessSummary() {
   return {
     triangleCount: 0,
@@ -1747,12 +1572,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 +1614,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 +1693,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 +1736,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 +1753,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 +2105,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 +2239,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 +2448,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 +2603,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 +2699,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 +2799,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 +2873,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 +2903,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 +2972,7 @@ function getSessionRoughnessInspection(session, rawOptions) {
     report: {
       method: "mesh-dihedral-angle",
       options,
+      sampleBudget,
       objectCount: objects.length,
       objects,
       warnings,
@@ -2900,14 +2991,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 +3056,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 +3106,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 +3825,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 +3907,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 +3963,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 +4070,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 +4096,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 +4179,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 +4209,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 +4231,10 @@ function createSession(code, opts) {
     sectionShapes,
     connectivityEntries,
     connectivityBodyInput,
+    floatingGroundZ,
     physicalConnectivity: null,
     distanceReport: null,
+    floatingReport: null,
     collisionEntries,
     collisionReport: null,
     thicknessInspection: null,
@@ -4121,6 +4264,7 @@ function createSession(code, opts) {
 }
 async function setup() {
   await init();
+  setActiveBackend(CLI_DEFAULT_BACKEND);
   window.__forgeCaptureCapabilities = CAPTURE_RUNTIME_CAPABILITIES;
   window.__forgeReady = true;
 }
@@ -4161,7 +4305,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 +4332,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 +4389,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 +4419,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 +4470,7 @@ window.__forgeRender = async (code, opts) => {
     renders,
     depth: depthRenders,
     normals: normalRenders,
+    zebra: zebraRenders,
     roughness: roughnessReport ? {
       ...roughnessReport,
       pointCloud: roughnessPointCloud,
@@ -4328,6 +4488,12 @@ window.__forgeRender = async (code, opts) => {
     } : {
       views: connectivityRenders
     },
+    floating: floatingReport ? {
+      ...floatingReport,
+      views: floatingRenders
+    } : {
+      views: floatingRenders
+    },
     distance: distanceReport ? {
       ...distanceReport,
       views: distanceRenders