forgecad 0.9.7 → 0.9.9

package/dist/assets/{sectionPlaneMath-BdTjyVfs.js → scalar-sampling-budget-Bmewod18.js}

@@ -806,11 +806,11 @@ function isFinitePositive$3(value) {
 function isFiniteNonNegative(value) {
   return Number.isFinite(value) && value >= 0;
 }
-function cloneVec3$5(vec2) {
+function cloneVec3$6(vec2) {
   return [vec2[0], vec2[1], vec2[2]];
 }
 function cloneFaceAxis(vec2) {
-  return vec2 ? cloneVec3$5(vec2) : void 0;
+  return vec2 ? cloneVec3$6(vec2) : void 0;
 }
 function cloneSheetMetalModel(model) {
   if (!model) return null;
@@ -1120,8 +1120,8 @@ function lowerSheetMetalBasePlan(model, output) {
 function descriptor(name, center, normal, planar, uAxis, vAxis, semantic = "face", memberNames = [name], coplanar = planar) {
   return {
     name,
-    center: cloneVec3$5(center),
-    normal: cloneVec3$5(normal),
+    center: cloneVec3$6(center),
+    normal: cloneVec3$6(normal),
     planar,
     uAxis: cloneFaceAxis(uAxis),
     vAxis: cloneFaceAxis(vAxis),
@@ -1374,10 +1374,10 @@ function describeSheetMetalPlanarRegionFrames(model, output) {
     const size = sheetMetalPlanarRegionSize(derived, face.name);
     return {
       name: face.name,
-      center: cloneVec3$5(face.center),
-      normal: cloneVec3$5(face.normal),
-      uAxis: cloneVec3$5(face.uAxis),
-      vAxis: cloneVec3$5(face.vAxis),
+      center: cloneVec3$6(face.center),
+      normal: cloneVec3$6(face.normal),
+      uAxis: cloneVec3$6(face.uAxis),
+      vAxis: cloneVec3$6(face.vAxis),
       width: size.width,
       height: size.height,
       thickness: derived.thickness
@@ -8367,7 +8367,7 @@ function sub$7(a2, b) {
 function cross$8(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function makeEdge(name, start, end, faceName, curve) {
+function makeEdge$1(name, start, end, faceName, curve) {
   return {
     name,
     start,
@@ -8411,10 +8411,10 @@ function buildSurfaceSheetTopology(boundaries, options = {}) {
     surface: options.surface
   });
   const edges = /* @__PURE__ */ new Map();
-  edges.set("u0", makeEdge("u0", u0Start, u0End, faceName, (_a3 = options.edgeCurves) == null ? void 0 : _a3.u0));
-  edges.set("u1", makeEdge("u1", u1Start, u1End, faceName, (_b3 = options.edgeCurves) == null ? void 0 : _b3.u1));
-  edges.set("v0", makeEdge("v0", v0Start, v0End, faceName, (_c2 = options.edgeCurves) == null ? void 0 : _c2.v0));
-  edges.set("v1", makeEdge("v1", v1Start, v1End, faceName, (_d2 = options.edgeCurves) == null ? void 0 : _d2.v1));
+  edges.set("u0", makeEdge$1("u0", u0Start, u0End, faceName, (_a3 = options.edgeCurves) == null ? void 0 : _a3.u0));
+  edges.set("u1", makeEdge$1("u1", u1Start, u1End, faceName, (_b3 = options.edgeCurves) == null ? void 0 : _b3.u1));
+  edges.set("v0", makeEdge$1("v0", v0Start, v0End, faceName, (_c2 = options.edgeCurves) == null ? void 0 : _c2.v0));
+  edges.set("v1", makeEdge$1("v1", v1Start, v1End, faceName, (_d2 = options.edgeCurves) == null ? void 0 : _d2.v1));
   return { faces, edges };
 }
 function attachSurfaceSheetTopology(shape, boundaries, options = {}) {
@@ -8432,7 +8432,7 @@ function attachSurfaceSheetTopology(shape, boundaries, options = {}) {
   });
   return shape;
 }
-function cloneVec3$4(value) {
+function cloneVec3$5(value) {
   return [value[0], value[1], value[2]];
 }
 function cloneNurbsFaceTrimLoop(loop) {
@@ -8454,38 +8454,38 @@ function cloneFaceSurface(surface) {
   if (!surface) return void 0;
   switch (surface.kind) {
     case "plane":
-      return { kind: "plane", normal: cloneVec3$4(surface.normal) };
+      return { kind: "plane", normal: cloneVec3$5(surface.normal) };
     case "cylinder":
       return {
         kind: "cylinder",
-        origin: cloneVec3$4(surface.origin),
-        axis: cloneVec3$4(surface.axis),
+        origin: cloneVec3$5(surface.origin),
+        axis: cloneVec3$5(surface.axis),
         radius: surface.radius,
         height: surface.height
       };
     case "cone":
       return {
         kind: "cone",
-        origin: cloneVec3$4(surface.origin),
-        axis: cloneVec3$4(surface.axis),
+        origin: cloneVec3$5(surface.origin),
+        axis: cloneVec3$5(surface.axis),
         radiusBottom: surface.radiusBottom,
         radiusTop: surface.radiusTop,
         height: surface.height
       };
     case "sphere":
-      return { kind: "sphere", center: cloneVec3$4(surface.center), radius: surface.radius };
+      return { kind: "sphere", center: cloneVec3$5(surface.center), radius: surface.radius };
     case "torus":
       return {
         kind: "torus",
-        center: cloneVec3$4(surface.center),
-        axis: cloneVec3$4(surface.axis),
+        center: cloneVec3$5(surface.center),
+        axis: cloneVec3$5(surface.axis),
         majorRadius: surface.majorRadius,
         minorRadius: surface.minorRadius
       };
     case "ruled":
       return {
         kind: "ruled",
-        rails: surface.rails.map((rail2) => rail2.map(cloneVec3$4))
+        rails: surface.rails.map((rail2) => rail2.map(cloneVec3$5))
       };
     case "nurbs":
       return {
@@ -8498,9 +8498,9 @@ function cloneEdgeCurve(curve) {
   if (!curve) return void 0;
   switch (curve.kind) {
     case "line":
-      return { ...curve, start: cloneVec3$4(curve.start), end: cloneVec3$4(curve.end) };
+      return { ...curve, start: cloneVec3$5(curve.start), end: cloneVec3$5(curve.end) };
     case "circle":
-      return { ...curve, center: cloneVec3$4(curve.center), axis: cloneVec3$4(curve.axis) };
+      return { ...curve, center: cloneVec3$5(curve.center), axis: cloneVec3$5(curve.axis) };
     case "surfaceIso":
       return { ...curve, parameterRange: [curve.parameterRange[0], curve.parameterRange[1]] };
     case "nurbsUv":
@@ -8518,7 +8518,7 @@ function cloneEdgeCurve(curve) {
   }
 }
 function makeLineEdgeCurve(start, end, faceName) {
-  return faceName ? { kind: "line", start: cloneVec3$4(start), end: cloneVec3$4(end), faceName } : { kind: "line", start: cloneVec3$4(start), end: cloneVec3$4(end) };
+  return faceName ? { kind: "line", start: cloneVec3$5(start), end: cloneVec3$5(end), faceName } : { kind: "line", start: cloneVec3$5(start), end: cloneVec3$5(end) };
 }
 function edgeCurveFaceName(curve) {
   switch (curve.kind) {
@@ -10605,7 +10605,7 @@ async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
   const Module = (await __vitePreload(async () => {
-    const { default: __vite_default__ } = await import("./manifold-DjYsd7A_.js");
+    const { default: __vite_default__ } = await import("./manifold-BRdhoQy5.js");
     return { default: __vite_default__ };
   }, true ? [] : void 0)).default;
   performance.mark("manifold:imported");
@@ -22489,7 +22489,7 @@ function marchingTetrahedra(sdfFn, bounds, edgeLength2) {
   };
 }
 const EPS$8 = 1e-9;
-function finitePositive(value) {
+function finitePositive$1(value) {
   return Number.isFinite(value) && value > EPS$8;
 }
 function clampNonNegative(value) {
@@ -22508,7 +22508,7 @@ function distancePreservingMatrixScale(matrix) {
   const sx = length4(col0);
   const sy = length4(col1);
   const sz = length4(col2);
-  if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
+  if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
   if (Math.abs(sx - sy) > EPS$8 || Math.abs(sx - sz) > EPS$8) return null;
   if (Math.abs(dot2(col0, col1)) > EPS$8 || Math.abs(dot2(col0, col2)) > EPS$8 || Math.abs(dot2(col1, col2)) > EPS$8) return null;
   return sx;
@@ -22525,7 +22525,7 @@ function transformStepDistanceScale(step) {
       const sx = Math.abs(step.x);
       const sy = Math.abs(step.y);
       const sz = Math.abs(step.z);
-      if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
+      if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
       return Math.abs(sx - sy) <= EPS$8 && Math.abs(sx - sz) <= EPS$8 ? sx : null;
     }
   }
@@ -22565,7 +22565,7 @@ function translatedPlan(base, z2) {
   };
 }
 function offsetCylinderDimensions(plan, thickness) {
-  if (!finitePositive(plan.height)) return null;
+  if (!finitePositive$1(plan.height)) return null;
   const radiusTop = plan.radiusTop ?? plan.radius;
   const slope = (radiusTop - plan.radius) / plan.height;
   const normalScale = Math.hypot(1, slope);
@@ -22574,7 +22574,7 @@ function offsetCylinderDimensions(plan, thickness) {
   const height = zMax - zMin;
   const radiusBottom = plan.radius + thickness * (normalScale - slope);
   const offsetRadiusTop = radiusTop + thickness * (normalScale + slope);
-  if (!finitePositive(height) || radiusBottom < -EPS$8 || offsetRadiusTop < -EPS$8) return null;
+  if (!finitePositive$1(height) || radiusBottom < -EPS$8 || offsetRadiusTop < -EPS$8) return null;
   return {
     zMin,
     height,
@@ -22632,7 +22632,7 @@ function rectangleCandidatePointsFromProfile(plan) {
     case "rect": {
       const width = Math.abs(plan.width);
       const height = Math.abs(plan.height);
-      if (!finitePositive(width) || !finitePositive(height)) return null;
+      if (!finitePositive$1(width) || !finitePositive$1(height)) return null;
       const halfWidth = width / 2;
       const halfHeight = height / 2;
       const points = [
@@ -22666,7 +22666,7 @@ function rectangleFootprintFromProfile(plan) {
   const [xMin, xMax] = xs;
   const [zMin, zMax] = zs;
   if (xMin == null || xMax == null || zMin == null || zMax == null) return null;
-  if (xMin < -EPS$8 || !finitePositive(xMax) || !finitePositive(zMax - zMin)) return null;
+  if (xMin < -EPS$8 || !finitePositive$1(xMax) || !finitePositive$1(zMax - zMin)) return null;
   const hasCorner = (x2, z2) => points.some(([px2, pz2]) => sameScalar$1(px2, x2) && sameScalar$1(pz2, z2));
   if (!hasCorner(xMin, zMin) || !hasCorner(xMax, zMin) || !hasCorner(xMax, zMax) || !hasCorner(xMin, zMax)) return null;
   return {
@@ -22679,7 +22679,7 @@ function rectangleFootprintFromProfile(plan) {
 function circleFootprintFromProfile(plan) {
   if (plan.kind !== "circle") return null;
   const radius = Math.abs(plan.radius);
-  if (!finitePositive(radius)) return null;
+  if (!finitePositive$1(radius)) return null;
   const center = transformProfilePointThrough$1([0, 0], plan.transforms);
   const xPoint = transformProfilePointThrough$1([1, 0], plan.transforms);
   const yPoint = transformProfilePointThrough$1([0, 1], plan.transforms);
@@ -22688,7 +22688,7 @@ function circleFootprintFromProfile(plan) {
   const xScale = Math.hypot(xAxis[0], xAxis[1]);
   const yScale = Math.hypot(yAxis[0], yAxis[1]);
   const dot2 = xAxis[0] * yAxis[0] + xAxis[1] * yAxis[1];
-  if (!finitePositive(xScale) || !finitePositive(yScale)) return null;
+  if (!finitePositive$1(xScale) || !finitePositive$1(yScale)) return null;
   if (Math.abs(xScale - yScale) > EPS$8 || Math.abs(dot2) > EPS$8 * xScale * yScale) return null;
   return {
     center,
@@ -22701,7 +22701,7 @@ function fullCircleRevolveTorusPlan(plan, minorRadiusOffset = 0) {
   const circle2 = circleFootprintFromProfile(plan.profile);
   if (!circle2 || circle2.center[0] <= EPS$8) return null;
   const minorRadius = circle2.radius + minorRadiusOffset;
-  if (!finitePositive(minorRadius) || minorRadius >= circle2.center[0] - EPS$8) return null;
+  if (!finitePositive$1(minorRadius) || minorRadius >= circle2.center[0] - EPS$8) return null;
   return translatedPlan(
     {
       kind: "torus",
@@ -22748,7 +22748,7 @@ function offsetFullRectRevolvePlan(plan, thickness) {
   const innerRadius = rectangle.innerRadius - thickness;
   const outerRadius = rectangle.outerRadius + thickness;
   const height = rectangle.zMax - rectangle.zMin + 2 * thickness;
-  if (innerRadius < -EPS$8 || !finitePositive(outerRadius) || !finitePositive(height) || outerRadius <= innerRadius + EPS$8) return null;
+  if (innerRadius < -EPS$8 || !finitePositive$1(outerRadius) || !finitePositive$1(height) || outerRadius <= innerRadius + EPS$8) return null;
   const zCenter = (rectangle.zMin + rectangle.zMax) / 2;
   if (innerRadius <= EPS$8) {
     return translatedPlan(
@@ -22789,11 +22789,11 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
       };
     }
     case "box": {
-      if (!finitePositive(base.z)) return null;
+      if (!finitePositive$1(base.z)) return null;
       const x2 = Math.abs(base.x) + 2 * thickness;
       const y2 = Math.abs(base.y) + 2 * thickness;
       const z2 = base.z + 2 * thickness;
-      if (!finitePositive(x2) || !finitePositive(y2) || !finitePositive(z2)) return null;
+      if (!finitePositive$1(x2) || !finitePositive$1(y2) || !finitePositive$1(z2)) return null;
       return translatedPlan(
         {
           kind: "box",
@@ -22820,7 +22820,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "sphere": {
       const radius = base.radius + thickness;
-      if (!finitePositive(radius)) return null;
+      if (!finitePositive$1(radius)) return null;
       return {
         kind: "sphere",
         radius,
@@ -22829,7 +22829,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "torus": {
       const minorRadius = base.minorRadius + thickness;
-      if (!finitePositive(minorRadius) || minorRadius >= base.majorRadius - EPS$8) return null;
+      if (!finitePositive$1(minorRadius) || minorRadius >= base.majorRadius - EPS$8) return null;
       return {
         kind: "torus",
         majorRadius: base.majorRadius,
@@ -30683,17 +30683,17 @@ function emptyFaceTable() {
     blockedQueries: []
   };
 }
-function cloneVec3$3(vec2) {
+function cloneVec3$4(vec2) {
   return [vec2[0], vec2[1], vec2[2]];
 }
 function cloneFaceRefValue(face) {
   return {
     ...face,
-    normal: cloneVec3$3(face.normal),
-    center: cloneVec3$3(face.center),
+    normal: cloneVec3$4(face.normal),
+    center: cloneVec3$4(face.center),
     query: cloneFaceQueryRef(face.query),
-    uAxis: face.uAxis ? cloneVec3$3(face.uAxis) : void 0,
-    vAxis: face.vAxis ? cloneVec3$3(face.vAxis) : void 0,
+    uAxis: face.uAxis ? cloneVec3$4(face.uAxis) : void 0,
+    vAxis: face.vAxis ? cloneVec3$4(face.vAxis) : void 0,
     surface: cloneFaceSurface(face.surface),
     descendant: face.descendant ? cloneFaceDescendantMetadata(face.descendant) : void 0
   };
@@ -31548,11 +31548,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
       for (const descriptor2 of describeSheetMetalFaces(plan.model, plan.output)) {
         registerFace(table2, {
           name: descriptor2.name,
-          normal: cloneVec3$3(descriptor2.normal),
-          center: cloneVec3$3(descriptor2.center),
+          normal: cloneVec3$4(descriptor2.normal),
+          center: cloneVec3$4(descriptor2.center),
           planar: descriptor2.planar,
-          uAxis: descriptor2.uAxis ? cloneVec3$3(descriptor2.uAxis) : void 0,
-          vAxis: descriptor2.vAxis ? cloneVec3$3(descriptor2.vAxis) : void 0,
+          uAxis: descriptor2.uAxis ? cloneVec3$4(descriptor2.uAxis) : void 0,
+          vAxis: descriptor2.vAxis ? cloneVec3$4(descriptor2.vAxis) : void 0,
           query: createTrackedFaceQuery(descriptor2.name, owner),
           descendant: createFaceDescendantMetadata(descriptor2.semantic, descriptor2.memberNames, descriptor2.coplanar)
         });
@@ -31579,7 +31579,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
             baseFace.center[2] - baseFace.normal[2] * plan.thickness
           ],
           normal: [-baseFace.normal[0], -baseFace.normal[1], -baseFace.normal[2]],
-          uAxis: baseFace.uAxis ? cloneVec3$3(baseFace.uAxis) : void 0,
+          uAxis: baseFace.uAxis ? cloneVec3$4(baseFace.uAxis) : void 0,
           vAxis: baseFace.vAxis ? [-baseFace.vAxis[0], -baseFace.vAxis[1], -baseFace.vAxis[2]] : void 0,
           query: createdQuery
         });
@@ -31645,15 +31645,15 @@ function resolveShapeFaceTableInternal(plan, owner) {
       if (counterboreFloorQuery && plan.hole.counterbore) {
         registerFace(table2, {
           name: "counterbore-floor",
-          normal: cloneVec3$3(workplane.normal),
+          normal: cloneVec3$4(workplane.normal),
           center: [
             origin[0] + inward[0] * plan.hole.counterbore.depth,
             origin[1] + inward[1] * plan.hole.counterbore.depth,
             origin[2] + inward[2] * plan.hole.counterbore.depth
           ],
           planar: true,
-          uAxis: cloneVec3$3(workplane.u),
-          vAxis: cloneVec3$3(workplane.v),
+          uAxis: cloneVec3$4(workplane.u),
+          vAxis: cloneVec3$4(workplane.v),
           query: counterboreFloorQuery
         });
       }
@@ -31677,11 +31677,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
       if (floorQuery) {
         registerFace(table2, {
           name: "floor",
-          normal: cloneVec3$3(workplane.normal),
+          normal: cloneVec3$4(workplane.normal),
           center: [origin[0] + inward[0] * forward.depth, origin[1] + inward[1] * forward.depth, origin[2] + inward[2] * forward.depth],
           planar: true,
-          uAxis: cloneVec3$3(workplane.u),
-          vAxis: cloneVec3$3(workplane.v),
+          uAxis: cloneVec3$4(workplane.u),
+          vAxis: cloneVec3$4(workplane.v),
           query: floorQuery
         });
       }
@@ -31692,7 +31692,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
           normal: [-workplane.normal[0], -workplane.normal[1], -workplane.normal[2]],
           center: [origin[0] - inward[0] * reverse.depth, origin[1] - inward[1] * reverse.depth, origin[2] - inward[2] * reverse.depth],
           planar: true,
-          uAxis: cloneVec3$3(workplane.u),
+          uAxis: cloneVec3$4(workplane.u),
           vAxis: [-workplane.v[0], -workplane.v[1], -workplane.v[2]],
           query: capQuery
         });
@@ -31871,11 +31871,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
         })();
         registerFace(table2, {
           name: "floor",
-          normal: cloneVec3$3(placement.workplane.normal),
+          normal: cloneVec3$4(placement.workplane.normal),
           center: floorCenter,
           planar: true,
-          uAxis: cloneVec3$3(placement.workplane.u),
-          vAxis: cloneVec3$3(placement.workplane.v),
+          uAxis: cloneVec3$4(placement.workplane.u),
+          vAxis: cloneVec3$4(placement.workplane.v),
           query: floorQuery
         });
       }
@@ -31890,7 +31890,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
             origin[2] - depthDir[2] * reverse.depth
           ],
           planar: true,
-          uAxis: cloneVec3$3(placement.workplane.u),
+          uAxis: cloneVec3$4(placement.workplane.u),
           vAxis: [-placement.workplane.v[0], -placement.workplane.v[1], -placement.workplane.v[2]],
           query: capQuery
         });
@@ -32076,7 +32076,7 @@ function preservedShapeFaceQueries(basePlan) {
   return listShapeFaceQueries(basePlan);
 }
 const PLACEMENT_REFERENCE_KINDS = ["points", "edges", "surfaces", "objects"];
-function cloneVec3$2(value, label) {
+function cloneVec3$3(value, label) {
   if (!Array.isArray(value) || value.length < 3) {
     throw new Error(`${label} must be a [x, y, z] tuple`);
   }
@@ -32102,23 +32102,23 @@ function isBoundsObject(value) {
 function toObjectBounds(value, label) {
   if (isBoundsObject(value)) {
     return {
-      min: cloneVec3$2(value.min, `${label}.min`),
-      max: cloneVec3$2(value.max, `${label}.max`)
+      min: cloneVec3$3(value.min, `${label}.min`),
+      max: cloneVec3$3(value.max, `${label}.max`)
     };
   }
   if (typeof value === "object" && value != null) {
     if ("boundingBox" in value && typeof value.boundingBox === "function") {
       const bounds = value.boundingBox();
       return {
-        min: cloneVec3$2(bounds.min, `${label}.min`),
-        max: cloneVec3$2(bounds.max, `${label}.max`)
+        min: cloneVec3$3(bounds.min, `${label}.min`),
+        max: cloneVec3$3(bounds.max, `${label}.max`)
       };
     }
     if ("_bbox" in value && typeof value._bbox === "function") {
       const bounds = value._bbox();
       return {
-        min: cloneVec3$2(bounds.min, `${label}.min`),
-        max: cloneVec3$2(bounds.max, `${label}.max`)
+        min: cloneVec3$3(bounds.min, `${label}.min`),
+        max: cloneVec3$3(bounds.max, `${label}.max`)
       };
     }
   }
@@ -32162,24 +32162,24 @@ function createPlacementReferences() {
 function clonePlacementReferences(refs) {
   const out = createPlacementReferences();
   for (const [name, point2] of Object.entries(refs.points)) {
-    out.points[name] = cloneVec3$2(point2, `points.${name}`);
+    out.points[name] = cloneVec3$3(point2, `points.${name}`);
   }
   for (const [name, edge] of Object.entries(refs.edges)) {
     out.edges[name] = {
-      start: cloneVec3$2(edge.start, `edges.${name}.start`),
-      end: cloneVec3$2(edge.end, `edges.${name}.end`)
+      start: cloneVec3$3(edge.start, `edges.${name}.start`),
+      end: cloneVec3$3(edge.end, `edges.${name}.end`)
     };
   }
   for (const [name, surface] of Object.entries(refs.surfaces)) {
     out.surfaces[name] = {
-      center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
-      normal: cloneVec3$2(surface.normal, `surfaces.${name}.normal`)
+      center: cloneVec3$3(surface.center, `surfaces.${name}.center`),
+      normal: cloneVec3$3(surface.normal, `surfaces.${name}.normal`)
     };
   }
   for (const [name, objectRef] of Object.entries(refs.objects)) {
     out.objects[name] = {
-      min: cloneVec3$2(objectRef.min, `objects.${name}.min`),
-      max: cloneVec3$2(objectRef.max, `objects.${name}.max`)
+      min: cloneVec3$3(objectRef.min, `objects.${name}.min`),
+      max: cloneVec3$3(objectRef.max, `objects.${name}.max`)
     };
   }
   return out;
@@ -32187,18 +32187,18 @@ function clonePlacementReferences(refs) {
 function normalizePlacementReferenceInput(input = {}) {
   const out = createPlacementReferences();
   for (const [name, point2] of Object.entries(input.points ?? {})) {
-    out.points[name] = cloneVec3$2(point2, `points.${name}`);
+    out.points[name] = cloneVec3$3(point2, `points.${name}`);
   }
   for (const [name, edge] of Object.entries(input.edges ?? {})) {
     out.edges[name] = {
-      start: cloneVec3$2(edge.start, `edges.${name}.start`),
-      end: cloneVec3$2(edge.end, `edges.${name}.end`)
+      start: cloneVec3$3(edge.start, `edges.${name}.start`),
+      end: cloneVec3$3(edge.end, `edges.${name}.end`)
     };
   }
   for (const [name, surface] of Object.entries(input.surfaces ?? {})) {
     out.surfaces[name] = {
-      center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
-      normal: normalizeVector$1(cloneVec3$2(surface.normal, `surfaces.${name}.normal`))
+      center: cloneVec3$3(surface.center, `surfaces.${name}.center`),
+      normal: normalizeVector$1(cloneVec3$3(surface.normal, `surfaces.${name}.normal`))
     };
   }
   for (const [name, objectRef] of Object.entries(input.objects ?? {})) {
@@ -32209,23 +32209,23 @@ function normalizePlacementReferenceInput(input = {}) {
 function mergePlacementReferences(...refsList) {
   const out = createPlacementReferences();
   for (const refs of refsList) {
-    for (const [name, point2] of Object.entries(refs.points)) out.points[name] = cloneVec3$2(point2, `points.${name}`);
+    for (const [name, point2] of Object.entries(refs.points)) out.points[name] = cloneVec3$3(point2, `points.${name}`);
     for (const [name, edge] of Object.entries(refs.edges)) {
       out.edges[name] = {
-        start: cloneVec3$2(edge.start, `edges.${name}.start`),
-        end: cloneVec3$2(edge.end, `edges.${name}.end`)
+        start: cloneVec3$3(edge.start, `edges.${name}.start`),
+        end: cloneVec3$3(edge.end, `edges.${name}.end`)
       };
     }
     for (const [name, surface] of Object.entries(refs.surfaces)) {
       out.surfaces[name] = {
-        center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
-        normal: cloneVec3$2(surface.normal, `surfaces.${name}.normal`)
+        center: cloneVec3$3(surface.center, `surfaces.${name}.center`),
+        normal: cloneVec3$3(surface.normal, `surfaces.${name}.normal`)
       };
     }
     for (const [name, objectRef] of Object.entries(refs.objects)) {
       out.objects[name] = {
-        min: cloneVec3$2(objectRef.min, `objects.${name}.min`),
-        max: cloneVec3$2(objectRef.max, `objects.${name}.max`)
+        min: cloneVec3$3(objectRef.min, `objects.${name}.min`),
+        max: cloneVec3$3(objectRef.max, `objects.${name}.max`)
       };
     }
   }
@@ -32269,7 +32269,7 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       const point2 = refs.points[name];
       if (!point2) return null;
       if (selector != null) placementRefSelectorError(originalRef, "does not support selectors");
-      return cloneVec3$2(point2, `points.${name}`);
+      return cloneVec3$3(point2, `points.${name}`);
     }
     case "edges": {
       const edge = refs.edges[name];
@@ -32277,8 +32277,8 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       if (selector == null || selector === "midpoint" || selector === "center") {
         return midpoint$2(edge.start, edge.end);
       }
-      if (selector === "start") return cloneVec3$2(edge.start, `edges.${name}.start`);
-      if (selector === "end") return cloneVec3$2(edge.end, `edges.${name}.end`);
+      if (selector === "start") return cloneVec3$3(edge.start, `edges.${name}.start`);
+      if (selector === "end") return cloneVec3$3(edge.end, `edges.${name}.end`);
       placementRefSelectorError(originalRef, "supports only .start, .end, or .midpoint");
     }
     case "surfaces": {
@@ -32287,7 +32287,7 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       if (selector != null && selector !== "center") {
         placementRefSelectorError(originalRef, "supports only .center");
       }
-      return cloneVec3$2(surface.center, `surfaces.${name}.center`);
+      return cloneVec3$3(surface.center, `surfaces.${name}.center`);
     }
     case "objects": {
       const objectRef = refs.objects[name];
@@ -35372,7 +35372,7 @@ function attachTopologyRewritePropagation(plan, propagation) {
 }
 const DEFAULT_TOLERANCE$2 = 1;
 const DEFAULT_ANGLE_TOLERANCE = 10;
-function distSq(a2, b) {
+function distSq$1(a2, b) {
   const dx = a2[0] - b[0], dy = a2[1] - b[1], dz = a2[2] - b[2];
   return dx * dx + dy * dy + dz * dz;
 }
@@ -35464,7 +35464,7 @@ function applyFilters(edges, query) {
   }
   if (query.near) {
     const pt = query.near;
-    result = result.slice().sort((a2, b) => distSq(a2.midpoint, pt) - distSq(b.midpoint, pt));
+    result = result.slice().sort((a2, b) => distSq$1(a2.midpoint, pt) - distSq$1(b.midpoint, pt));
   }
   return result;
 }
@@ -35528,10 +35528,10 @@ function coalesceEdges(segments, tolerance = 0.01) {
 }
 function minEndpointGap(a2, b) {
   return Math.min(
-    Math.sqrt(distSq(a2.start, b.start)),
-    Math.sqrt(distSq(a2.start, b.end)),
-    Math.sqrt(distSq(a2.end, b.start)),
-    Math.sqrt(distSq(a2.end, b.end))
+    Math.sqrt(distSq$1(a2.start, b.start)),
+    Math.sqrt(distSq$1(a2.start, b.end)),
+    Math.sqrt(distSq$1(a2.end, b.start)),
+    Math.sqrt(distSq$1(a2.end, b.end))
   );
 }
 function mergeCollinearGroup(group2, index2) {
@@ -53237,11 +53237,11 @@ function inverseLerp(x2, y2, value) {
     return 0;
   }
 }
-function lerp$5(x2, y2, t) {
+function lerp$6(x2, y2, t) {
   return (1 - t) * x2 + t * y2;
 }
 function damp(x2, y2, lambda, dt) {
-  return lerp$5(x2, y2, 1 - Math.exp(-lambda * dt));
+  return lerp$6(x2, y2, 1 - Math.exp(-lambda * dt));
 }
 function pingpong(x2, length4 = 1) {
   return length4 - Math.abs(euclideanModulo(x2, length4 * 2) - length4);
@@ -53434,7 +53434,7 @@ const MathUtils = {
    * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
    * @return {number} The interpolated value.
    */
-  lerp: lerp$5,
+  lerp: lerp$6,
   /**
    * Smoothly interpolate a number from `x` to `y` in  a spring-like manner using a delta
    * time to maintain frame rate independent movement. For details, see
@@ -62388,9 +62388,9 @@ class Color {
   lerpHSL(color, alpha) {
     this.getHSL(_hslA);
     color.getHSL(_hslB);
-    const h = lerp$5(_hslA.h, _hslB.h, alpha);
-    const s = lerp$5(_hslA.s, _hslB.s, alpha);
-    const l = lerp$5(_hslA.l, _hslB.l, alpha);
+    const h = lerp$6(_hslA.h, _hslB.h, alpha);
+    const s = lerp$6(_hslA.s, _hslB.s, alpha);
+    const l = lerp$6(_hslA.l, _hslB.l, alpha);
     this.setHSL(h, s, l);
     return this;
   }
@@ -94501,6 +94501,19 @@ const Viewport = {
     collectRenderLabel(text, at, options);
   }
 };
+const NO_SURFACE_FIELD = {
+  enabled: false,
+  kind: "precision",
+  baseColor: "#000000",
+  darkColor: "#000000",
+  lineColor: "#000000",
+  nodeColor: "#000000",
+  accentColor: "#000000",
+  spacing: 1,
+  lineWidth: 0.01,
+  glow: 0,
+  objectColorMix: 0
+};
 const DEFAULT_RENDER_STYLE = "classic";
 const RENDER_STYLE_OPTIONS = [
   {
@@ -94522,6 +94535,16 @@ const RENDER_STYLE_OPTIONS = [
     id: "glass",
     label: "Glass",
     description: "Showcase lighting for authored transparent materials."
+  },
+  {
+    id: "precision",
+    label: "Precision",
+    description: "Dense, thin surface-field contours for technical inspection."
+  },
+  {
+    id: "hybrid",
+    label: "Hybrid",
+    description: "Topo-led surface contours with a quiet orthogonal field."
   }
 ];
 const RENDER_STYLE_IDS = new Set(RENDER_STYLE_OPTIONS.map((option) => option.id));
@@ -94577,7 +94600,8 @@ const PRESETS = {
       color: "#ffffff",
       opacity: 0,
       scale: 1
-    }
+    },
+    surfaceField: NO_SURFACE_FIELD
   },
   studio: {
     id: "studio",
@@ -94630,7 +94654,8 @@ const PRESETS = {
       color: "#f7fffb",
       opacity: 0.055,
       scale: 1.006
-    }
+    },
+    surfaceField: NO_SURFACE_FIELD
   },
   fast: {
     id: "fast",
@@ -94683,7 +94708,8 @@ const PRESETS = {
       color: "#fff6df",
       opacity: 0,
       scale: 1
-    }
+    },
+    surfaceField: NO_SURFACE_FIELD
   },
   glass: {
     id: "glass",
@@ -94736,6 +94762,139 @@ const PRESETS = {
       color: "#e8fff8",
       opacity: 0.13,
       scale: 1.012
+    },
+    surfaceField: NO_SURFACE_FIELD
+  },
+  precision: {
+    id: "precision",
+    label: "Precision",
+    background: "#0c1011",
+    toneMappingExposure: 1.06,
+    environmentIntensity: 0.35,
+    canvasDpr: { live: 1, idleMax: 1.45 },
+    lights: {
+      ambientIntensity: 0.36,
+      keyIntensity: 1.25,
+      keyColor: "#f2fff9",
+      keyPosition: [95, -120, 145],
+      fillIntensity: 0.32,
+      fillColor: "#cbeee8",
+      fillPosition: [-80, 70, 80],
+      rimIntensity: 0.28,
+      rimColor: "#d1fff7",
+      rimPosition: [-105, -75, 120],
+      hemisphereSky: "#d1fff7",
+      hemisphereGround: "#111616",
+      hemisphereIntensity: 0.3
+    },
+    material: {
+      metalness: 0,
+      roughness: 0.68,
+      clearcoat: 0,
+      clearcoatRoughness: 0.6,
+      reflectivity: 0.18,
+      specularIntensity: 0.62,
+      opacity: 1,
+      transmission: 0,
+      thickness: 0,
+      authoredTransparent: {
+        roughness: 0.42,
+        clearcoat: 0.08,
+        clearcoatRoughness: 0.46,
+        reflectivity: 0.24,
+        specularIntensity: 0.72,
+        transmission: 0,
+        thickness: 0.2
+      }
+    },
+    edge: {
+      color: "#d1fff7",
+      opacity: 0.26
+    },
+    glassShell: {
+      enabled: false,
+      color: "#d1fff7",
+      opacity: 0,
+      scale: 1
+    },
+    surfaceField: {
+      enabled: true,
+      kind: "precision",
+      baseColor: "#3d5659",
+      darkColor: "#070b0c",
+      lineColor: "#d1fff7",
+      nodeColor: "#fff4bc",
+      accentColor: "#ffb66f",
+      spacing: 0.22,
+      lineWidth: 36e-4,
+      glow: 0.2,
+      objectColorMix: 0.35
+    }
+  },
+  hybrid: {
+    id: "hybrid",
+    label: "Hybrid",
+    background: "#0b1312",
+    toneMappingExposure: 1.08,
+    environmentIntensity: 0.42,
+    canvasDpr: { live: 1, idleMax: 1.45 },
+    lights: {
+      ambientIntensity: 0.38,
+      keyIntensity: 1.32,
+      keyColor: "#f2fff9",
+      keyPosition: [100, -125, 145],
+      fillIntensity: 0.34,
+      fillColor: "#c9fff2",
+      fillPosition: [-80, 78, 85],
+      rimIntensity: 0.34,
+      rimColor: "#d7ff86",
+      rimPosition: [-105, -80, 125],
+      hemisphereSky: "#bfffee",
+      hemisphereGround: "#101810",
+      hemisphereIntensity: 0.32
+    },
+    material: {
+      metalness: 0,
+      roughness: 0.66,
+      clearcoat: 0,
+      clearcoatRoughness: 0.6,
+      reflectivity: 0.2,
+      specularIntensity: 0.66,
+      opacity: 1,
+      transmission: 0,
+      thickness: 0,
+      authoredTransparent: {
+        roughness: 0.4,
+        clearcoat: 0.08,
+        clearcoatRoughness: 0.46,
+        reflectivity: 0.24,
+        specularIntensity: 0.74,
+        transmission: 0,
+        thickness: 0.2
+      }
+    },
+    edge: {
+      color: "#defdf7",
+      opacity: 0.28
+    },
+    glassShell: {
+      enabled: false,
+      color: "#defdf7",
+      opacity: 0,
+      scale: 1
+    },
+    surfaceField: {
+      enabled: true,
+      kind: "hybrid",
+      baseColor: "#32645e",
+      darkColor: "#07100f",
+      lineColor: "#95fff0",
+      nodeColor: "#ffe098",
+      accentColor: "#d7ff86",
+      spacing: 0.3,
+      lineWidth: 5e-3,
+      glow: 0.4,
+      objectColorMix: 0.28
     }
   }
 };
@@ -96566,7 +96725,7 @@ function scale$1(v, s) {
 function dot$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function lerp$4(a2, b, t) {
+function lerp$5(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function frameMatrix$1(x2, y2, z2, p2) {
@@ -96642,9 +96801,9 @@ function interpolateQuery(a2, b, t) {
   }
   return {
     side: sideA,
-    u: lerp$4(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$4(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$5(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$5(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$5(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 function resolvePathQueries(points) {
@@ -96769,7 +96928,7 @@ class ProductSkin {
   }
   /** Interpolate center, width, and depth at a normalized v or absolute axis value. */
   stationAt(vOrAxis) {
-    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$4(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
+    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$5(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
     const sorted = this.stations;
     for (let index2 = 0; index2 < sorted.length - 1; index2 += 1) {
       const a2 = sorted[index2];
@@ -96781,12 +96940,12 @@ class ProductSkin {
       const t = clamp$5((axisValue - aAxis) / span, 0, 1);
       return {
         axisValue,
-        center: [lerp$4(a2.center[0], b.center[0], t), lerp$4(a2.center[1], b.center[1], t), lerp$4(a2.center[2], b.center[2], t)],
-        width: lerp$4(a2.profile.width, b.profile.width, t),
-        depth: lerp$4(a2.profile.depth, b.profile.depth, t),
+        center: [lerp$5(a2.center[0], b.center[0], t), lerp$5(a2.center[1], b.center[1], t), lerp$5(a2.center[2], b.center[2], t)],
+        width: lerp$5(a2.profile.width, b.profile.width, t),
+        depth: lerp$5(a2.profile.depth, b.profile.depth, t),
         dWidth: (b.profile.width - a2.profile.width) / span,
         dDepth: (b.profile.depth - a2.profile.depth) / span,
-        exponent: lerp$4(profileExponent(a2), profileExponent(b), t),
+        exponent: lerp$5(profileExponent(a2), profileExponent(b), t),
         kind: a2.profile.kind === b.profile.kind ? a2.profile.kind : "custom"
       };
     }
@@ -97619,7 +97778,7 @@ function requirePositive$3(value, label) {
 function clamp$4(value, min2, max2) {
   return Math.max(min2, Math.min(max2, value));
 }
-function lerp$3(a2, b, t) {
+function lerp$4(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function add(a2, b) {
@@ -97669,19 +97828,19 @@ function transformLocal(point2, tangentAcross, normal, tangentAlong, x2, y2, z2
 function interpolateCylinder(a2, b, t, mode) {
   let delta = b.angle - a2.angle;
   if (mode === "shortest" && Math.abs(delta) > 180) delta -= Math.sign(delta) * 360;
-  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$3(a2.z, b.z, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$4(a2.z, b.z, t), offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolatePlane(a2, b, t) {
-  return { kind: "plane", x: lerp$3(a2.x, b.x, t), y: lerp$3(a2.y, b.y, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "plane", x: lerp$4(a2.x, b.x, t), y: lerp$4(a2.y, b.y, t), offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolateProductSkin(a2, b, t) {
   if ((a2.side ?? b.side) !== (b.side ?? a2.side)) throw new Error("SurfacePath on ProductSkin currently supports one side per path; split side transitions into separate members.");
   return {
     kind: "productSkin",
     side: a2.side ?? b.side,
-    u: lerp$3(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$3(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$4(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$4(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 class SurfacePath {
@@ -98779,7 +98938,7 @@ function counterboresForPlate(spec2, width, height, thickness, diagnostics) {
 function minWidthAcrossAlongRange(widthAtT, length4, minAlong, maxAlong) {
   let minWidth = Number.POSITIVE_INFINITY;
   for (let index2 = 0; index2 <= 8; index2 += 1) {
-    const along = lerp$3(minAlong, maxAlong, index2 / 8);
+    const along = lerp$4(minAlong, maxAlong, index2 / 8);
     const t = Math.max(0, Math.min(1, (along + length4 / 2) / Math.max(length4, 1e-8)));
     minWidth = Math.min(minWidth, widthAtT(t));
   }
@@ -99079,7 +99238,7 @@ function pathParameterAtDistance(samples, distance2) {
     const segmentLength = Math.hypot(b.point[0] - a2.point[0], b.point[1] - a2.point[1], b.point[2] - a2.point[2]);
     if (traveled + segmentLength >= distance2) {
       const localT = segmentLength <= 1e-8 ? 0 : (distance2 - traveled) / segmentLength;
-      return lerp$3(a2.t, b.t, localT);
+      return lerp$4(a2.t, b.t, localT);
     }
     traveled += segmentLength;
   }
@@ -99132,7 +99291,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], false));
     }
   }
@@ -99142,7 +99301,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], true));
     }
   }
@@ -99154,7 +99313,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex < acrossSegments; acrossIndex += 1) {
-      const across = lerp$3(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
       filled[alongIndex][acrossIndex] = !holes.some((hole2) => pointInProfileLoop([across, along], hole2));
     }
   }
@@ -101354,7 +101513,7 @@ function midpoint$1(a2, b) {
   requireVec3$1(b, "b");
   return [(a2[0] + b[0]) / 2, (a2[1] + b[1]) / 2, (a2[2] + b[2]) / 2];
 }
-function lerp$2(a2, b, t) {
+function lerp$3(a2, b, t) {
   requireVec3$1(a2, "a");
   requireVec3$1(b, "b");
   requireFiniteNumber(t, "t");
@@ -101384,7 +101543,7 @@ const Points2 = {
   /** Center point between two 3D points. */
   midpoint: midpoint$1,
   /** Linearly interpolate between two 3D points. t=0 returns a, t=1 returns b. */
-  lerp: lerp$2,
+  lerp: lerp$3,
   /** Unit direction vector from a to b. Throws if a and b are the same point. */
   direction,
   /** Move a point along a direction vector by a given amount. */
@@ -121920,7 +122079,7 @@ function railCrossAt(rail2, position) {
     const b = points[index2 + 1];
     if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
       const t = (position - a2.position) / (b.position - a2.position);
-      return [lerp$1(a2.cross[0], b.cross[0], t), lerp$1(a2.cross[1], b.cross[1], t)];
+      return [lerp$2(a2.cross[0], b.cross[0], t), lerp$2(a2.cross[1], b.cross[1], t)];
     }
   }
   throw new Error("Loft guide rail does not cover requested station position");
@@ -121958,7 +122117,7 @@ function crossPointForAxis(axis, point2) {
   if (axis === "Y") return [point2[0], -point2[2]];
   return [point2[0], point2[1]];
 }
-function lerp$1(a2, b, t) {
+function lerp$2(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function loftWithGuideRails(stations, rails, options = {}) {
@@ -122082,13 +122241,13 @@ function sketchBounds(profile) {
 }
 function lerpBounds(a2, b, t) {
   return {
-    minX: lerp(a2.minX, b.minX, t),
-    maxX: lerp(a2.maxX, b.maxX, t),
-    minY: lerp(a2.minY, b.minY, t),
-    maxY: lerp(a2.maxY, b.maxY, t)
+    minX: lerp$1(a2.minX, b.minX, t),
+    maxX: lerp$1(a2.maxX, b.maxX, t),
+    minY: lerp$1(a2.minY, b.minY, t),
+    maxY: lerp$1(a2.maxY, b.maxY, t)
   };
 }
-function lerp(a2, b, t) {
+function lerp$1(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function mapLoftPath2D(path2, label, mapper) {
@@ -339496,6 +339655,14 @@ function createForgeRuntimeModule(bindings) {
   runtime.default = runtime;
   return runtime;
 }
+function finalizeForgeJsImport(moduleExports, importedDims) {
+  if (moduleExports instanceof Assembly) {
+    return new ImportedAssembly(moduleExports, moduleExports.getReferences());
+  }
+  if (!(moduleExports instanceof Shape$1)) return moduleExports;
+  if (importedDims.length === 0) return moduleExports;
+  return setShapeDimensions(moduleExports, [...getShapeDimensions(moduleExports), ...importedDims]);
+}
 const DEFAULT_RAYMARCH_STEPS = 360;
 const MIN_RAYMARCH_STEP = 0.012;
 function classifySdfPreviewNode(node) {
@@ -340417,7 +340584,7 @@ function isRenderableEntryResult(value) {
   return containsRenderableLeaf(value, /* @__PURE__ */ new WeakSet());
 }
 function containsRenderableLeaf(value, seen2) {
-  if (value instanceof Shape$1 || value instanceof Sketch || value instanceof SdfShape || value instanceof ShapeGroup || value instanceof GCodeBuilder || value instanceof Assembly || value instanceof SolvedAssembly) {
+  if (value instanceof Shape$1 || value instanceof Sketch || value instanceof SdfShape || value instanceof ShapeGroup || value instanceof GCodeBuilder || value instanceof Assembly || value instanceof ImportedAssembly || value instanceof SolvedAssembly) {
     return true;
   }
   if (!value || typeof value !== "object") return false;
@@ -340439,11 +340606,6 @@ function hasExplicitModuleExports(exportsValue, initialExportsRef) {
   const keys = Object.keys(exportsValue);
   return keys.some((key) => key !== "__esModule");
 }
-function finalizeForgeJsImport(moduleExports, importedDims) {
-  if (!(moduleExports instanceof Shape$1)) return moduleExports;
-  if (importedDims.length === 0) return moduleExports;
-  return setShapeDimensions(moduleExports, [...getShapeDimensions(moduleExports), ...importedDims]);
-}
 function mapScriptResultToScene(args) {
   var _a3;
   const objects = [];
@@ -340571,6 +340733,19 @@ function mapScriptResultToScene(args) {
       value.solve().toSceneObjects().forEach((item, index2) => processNamedItem(item, `${name}.${index2 + 1}`, `${index2 + 1}`, name, treePath, inheritedTags));
       return;
     }
+    if (value instanceof ImportedAssembly) {
+      const group2 = value.toGroup();
+      group2.children.forEach((child, index2) => {
+        flattenGroupChild(
+          child,
+          groupChildLabel(group2, name, index2),
+          name,
+          [...treePath, shapeGroupChildSegment(group2, index2)],
+          mergeSceneTags(inheritedTags, group2.tagsForChild(index2))
+        );
+      });
+      return;
+    }
     if (value instanceof SolvedAssembly) {
       value.toSceneObjects().forEach((item, index2) => processNamedItem(item, `${name}.${index2 + 1}`, `${index2 + 1}`, name, treePath, inheritedTags));
       return;
@@ -340726,6 +340901,12 @@ function mapScriptResultToScene(args) {
       const label = `Object ${index2 + 1}`;
       processNamedItem(item, label, label);
     });
+  } else if (result instanceof ImportedAssembly) {
+    const group2 = result.toGroup();
+    group2.children.forEach((child, index2) => {
+      const label = rootGroupChildLabel(group2, index2);
+      flattenGroupChild(child, label, void 0, [label], group2.tagsForChild(index2));
+    });
   } else if (result instanceof ShapeGroup) {
     result.children.forEach((child, i) => {
       const label = rootGroupChildLabel(result, i);
@@ -340764,7 +340945,7 @@ function mapScriptResultToScene(args) {
       }
       processRenderableTree(item, label, label);
     });
-  } else if (result !== null && typeof result === "object" && !Array.isArray(result) && !(result instanceof Shape$1) && !(result instanceof Sketch) && !(result instanceof SdfShape) && !(result instanceof ShapeGroup) && !(result instanceof GCodeBuilder) && !(result instanceof Assembly) && !(result instanceof SolvedAssembly)) {
+  } else if (result !== null && typeof result === "object" && !Array.isArray(result) && !(result instanceof Shape$1) && !(result instanceof Sketch) && !(result instanceof SdfShape) && !(result instanceof ShapeGroup) && !(result instanceof GCodeBuilder) && !(result instanceof Assembly) && !(result instanceof ImportedAssembly) && !(result instanceof SolvedAssembly)) {
     const obj = result;
     const defaultValue = obj.default;
     if (defaultValue && isRenderableEntryResult(defaultValue)) {
@@ -340852,7 +341033,7 @@ Fix one:
     sketch: objects.length === 1 ? objects[0].sketch : null,
     objects,
     extraDimensions: shapeDimensions,
-    error: objects.length > 0 || args.allowEmptyResult ? null : "No renderable objects found. Return a Shape, Sketch, SdfShape, array, or object tree containing renderable values."
+    error: objects.length > 0 || args.allowEmptyResult ? null : "No renderable objects found. Return a Shape, Sketch, SdfShape, Assembly, ImportedAssembly, array, or object tree containing renderable values."
   };
 }
 const FORGE_RUNTIME_MODULE_SPECIFIERS = /* @__PURE__ */ new Set(["forgecad", "@forge/runtime", "@forgecad/runtime"]);
@@ -341149,6 +341330,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       composeChain,
       assembly,
       Assembly,
+      ImportedAssembly,
       port: () => {
         throw new Error("port() has been renamed to connector(). Update your script.");
       },
@@ -341550,7 +341732,7 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
   }
 }
 const DEFAULT_LEAF_SIZE = 8;
-function cloneVec3$1(value) {
+function cloneVec3$2(value) {
   return [value[0], value[1], value[2]];
 }
 function emptyBounds() {
@@ -341618,14 +341800,14 @@ class AabbSpatialIndex {
       nodeCount += 1;
       const bounds = boundsFor(entries, indexes);
       if (indexes.length <= this.leafSize) {
-        return { min: cloneVec3$1(bounds.min), max: cloneVec3$1(bounds.max), left: null, right: null, indexes };
+        return { min: cloneVec3$2(bounds.min), max: cloneVec3$2(bounds.max), left: null, right: null, indexes };
       }
       const axis = longestAxis(bounds);
       indexes.sort((a2, b) => centerOnAxis(entries[a2], axis) - centerOnAxis(entries[b], axis) || a2 - b);
       const mid = Math.max(1, Math.floor(indexes.length / 2));
       return {
-        min: cloneVec3$1(bounds.min),
-        max: cloneVec3$1(bounds.max),
+        min: cloneVec3$2(bounds.min),
+        max: cloneVec3$2(bounds.max),
         left: build(indexes.slice(0, mid)),
         right: build(indexes.slice(mid)),
         indexes: null
@@ -341691,7 +341873,7 @@ class AabbSpatialIndex {
 const DEFAULT_COLLISION_INSPECTION_OPTIONS = {
   minOverlapVolume: 0.1
 };
-function cloneVec3(value) {
+function cloneVec3$1(value) {
   return [value[0], value[1], value[2]];
 }
 function isIdentityTransform(matrix) {
@@ -341733,8 +341915,8 @@ function prepareEntry(entry) {
   if (isIdentityTransform(entry.transform)) {
     return {
       ...entry,
-      min: cloneVec3(entry.min),
-      max: cloneVec3(entry.max)
+      min: cloneVec3$1(entry.min),
+      max: cloneVec3$1(entry.max)
     };
   }
   const bbox = transformBBox(entry.min, entry.max, entry.transform);
@@ -341753,7 +341935,7 @@ function shouldSkipPair(a2, b, options) {
   if (options.skipMockPairs && a2.mock && b.mock) return true;
   return false;
 }
-function collectCandidatePairs(entries, options) {
+function collectCandidatePairs$1(entries, options) {
   const index2 = new AabbSpatialIndex(entries, 1);
   const result = index2.overlapPairs({
     padding: options.bboxPadding,
@@ -341794,11 +341976,17 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   const warnings = [];
   const collisions = [];
   const preparedEntries = entries.map((entry) => prepareEntry(entry));
-  const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs(preparedEntries, options);
-  const limitedCandidatePairs = options.maxCandidatePairs === null ? candidatePairs : candidatePairs.slice(0, options.maxCandidatePairs);
-  const pairLimitSkippedPairCount = candidatePairs.length - limitedCandidatePairs.length;
+  const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs$1(preparedEntries, options);
+  const exactCandidatePairs = candidatePairs.filter((pair) => pair.bboxOverlapVolume > options.minOverlapVolume);
+  const bboxVolumePrunedPairCount = candidatePairs.length - exactCandidatePairs.length;
+  const limitedCandidatePairs = options.maxCandidatePairs === null ? exactCandidatePairs : exactCandidatePairs.slice(0, options.maxCandidatePairs);
+  const pairLimitSkippedPairCount = exactCandidatePairs.length - limitedCandidatePairs.length;
   let testedPairCount = 0;
   let timeBudgetStopped = false;
+  const exactCheckedKeys = /* @__PURE__ */ new Set();
+  const pairKey = (pair) => `${pair.sourceIndex}:${pair.targetIndex}`;
+  const exactCandidateKeys = new Set(exactCandidatePairs.map(pairKey));
+  const limitedCandidateKeys = new Set(limitedCandidatePairs.map(pairKey));
   const exactStarted = performance.now();
   for (const pair of limitedCandidatePairs) {
     if (options.maxElapsedMs !== null && (options.maxElapsedMs <= 0 || performance.now() - exactStarted >= options.maxElapsedMs)) {
@@ -341806,6 +341994,7 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
       break;
     }
     testedPairCount += 1;
+    exactCheckedKeys.add(pairKey(pair));
     const a2 = preparedEntries[pair.sourceIndex];
     const b = preparedEntries[pair.targetIndex];
     try {
@@ -341836,10 +342025,11 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   const bboxCandidates = options.includeBBoxCandidates ? candidatePairs.map((pair, index2) => {
     const source = preparedEntries[pair.sourceIndex];
     const target = preparedEntries[pair.targetIndex];
-    const exactChecked = index2 < testedPairCount;
+    const exactChecked = exactCheckedKeys.has(pairKey(pair));
     let skippedBy;
     if (!exactChecked) {
-      skippedBy = index2 >= limitedCandidatePairs.length ? "pair-limit" : "time-budget";
+      const key = pairKey(pair);
+      skippedBy = !exactCandidateKeys.has(key) ? "bbox-volume-threshold" : limitedCandidateKeys.has(key) ? "time-budget" : "pair-limit";
     }
     return {
       index: index2 + 1,
@@ -341872,8 +342062,8 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
     treePath: entry.treePath,
     mock: entry.mock === true,
     bbox: {
-      min: cloneVec3(entry.min),
-      max: cloneVec3(entry.max)
+      min: cloneVec3$1(entry.min),
+      max: cloneVec3$1(entry.max)
     }
   }));
   return {
@@ -341883,10 +342073,12 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
       method: "aabb-bvh",
       allPairCount: preparedEntries.length * (preparedEntries.length - 1) / 2,
       bboxPairChecks,
+      bboxVolumePrunedPairCount,
       booleanPairChecks: testedPairCount
     },
     objectCount: objects.length,
     candidatePairCount: candidatePairs.length,
+    bboxVolumePrunedPairCount,
     testedPairCount,
     skippedPairCount,
     pairLimitSkippedPairCount,
@@ -341899,6 +342091,892 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
     warnings
   };
 }
+const SURFACE_FIELD_VERTEX_SHADER = `
+  varying vec3 vWorldPos;
+  varying vec3 vNormalW;
+
+  void main() {
+    vec4 world = modelMatrix * vec4(position, 1.0);
+    vWorldPos = world.xyz;
+    vNormalW = normalize(mat3(modelMatrix) * normal);
+    gl_Position = projectionMatrix * viewMatrix * world;
+  }
+`;
+const SURFACE_FIELD_FRAGMENT_SHADER = `
+  uniform float uGlow;
+  uniform float uLineWidth;
+  uniform float uObjectColorMix;
+  uniform float uFieldScale;
+  uniform float uSpacing;
+  uniform int uFieldKind;
+  uniform vec3 uAccentColor;
+  uniform vec3 uBaseColor;
+  uniform vec3 uDarkColor;
+  uniform vec3 uLineColor;
+  uniform vec3 uNodeColor;
+  uniform vec3 uObjectColor;
+
+  varying vec3 vNormalW;
+  varying vec3 vWorldPos;
+
+  float gridLine(float coord, float spacing, float width) {
+    float distanceToLine = abs(fract(coord / spacing + 0.5) - 0.5) * spacing;
+    return 1.0 - smoothstep(width, width * 2.7, distanceToLine);
+  }
+
+  float intersectionFade(float axisNormal) {
+    return 1.0 - smoothstep(0.72, 0.98, abs(axisNormal));
+  }
+
+  void main() {
+    vec3 normalW = normalize(vNormalW);
+    vec3 viewDir = normalize(cameraPosition - vWorldPos);
+    vec3 lightDir = normalize(vec3(-0.38, 0.72, 0.58));
+    float lit = max(dot(normalW, lightDir), 0.0);
+    float rim = pow(1.0 - max(dot(normalW, viewDir), 0.0), 2.35);
+    vec3 fieldPos = vWorldPos / uFieldScale;
+
+    float xFade = intersectionFade(normalW.x);
+    float yFade = intersectionFade(normalW.y);
+    float zFade = intersectionFade(normalW.z);
+
+    float lx = gridLine(fieldPos.x, uSpacing, uLineWidth) * xFade;
+    float ly = gridLine(fieldPos.y, uSpacing, uLineWidth) * yFade;
+    float lz = gridLine(fieldPos.z, uSpacing, uLineWidth) * zFade;
+    float mx = gridLine(fieldPos.x, uSpacing * 0.5, uLineWidth * 0.52) * xFade * 0.34;
+    float my = gridLine(fieldPos.y, uSpacing * 0.5, uLineWidth * 0.52) * yFade * 0.34;
+    float mz = gridLine(fieldPos.z, uSpacing * 0.5, uLineWidth * 0.52) * zFade * 0.34;
+    float majorX = gridLine(fieldPos.x, uSpacing * 4.0, uLineWidth * 1.25) * xFade;
+    float majorY = gridLine(fieldPos.y, uSpacing * 4.0, uLineWidth * 1.25) * yFade;
+    float majorZ = gridLine(fieldPos.z, uSpacing * 4.0, uLineWidth * 1.25) * zFade;
+
+    float contour = max(max(lx, ly), lz);
+    float minorContour = max(max(mx, my), mz);
+    float majorContour = max(max(majorX, majorY), majorZ);
+    float pairNode = max(max(min(lx, ly), min(lx, lz)), min(ly, lz));
+    float topoScale = max(max(lz, mz), majorZ);
+    float lineMask = max(max(contour * 0.74, minorContour), majorContour * 0.54);
+    float nodeMask = pairNode * 0.035;
+
+    if (uFieldKind == 1) {
+      lineMask = max(topoScale, max(mx, my) * 0.42);
+      nodeMask = pairNode * 0.06;
+    }
+
+    vec3 body = mix(uBaseColor, uObjectColor, uObjectColorMix);
+    vec3 base = mix(uDarkColor, body, 0.34 + lit * 0.66) + rim * uAccentColor * 0.14;
+    vec3 color = mix(base, uLineColor, clamp(lineMask * 0.58, 0.0, 1.0));
+    color += uLineColor * lineMask * uGlow * 0.22;
+    color += uNodeColor * nodeMask * uGlow * 0.28;
+    color += sin(gl_FragCoord.y * 3.14159) * 0.008;
+
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+const ZEBRA_STRIPE_SCALE = 18;
+const ZEBRA_STRIPE_SOFTNESS = 0.16;
+const ZEBRA_DARK_COLOR = "#05070a";
+const ZEBRA_LIGHT_COLOR = "#f2f4ec";
+const ZEBRA_ACCENT_COLOR = "#3bd6ff";
+const ZEBRA_STRIPE_VERTEX_SHADER = `
+  varying vec3 vViewNormal;
+  varying vec3 vViewPosition;
+
+  void main() {
+    vec4 viewPosition = modelViewMatrix * vec4(position, 1.0);
+    vViewPosition = viewPosition.xyz;
+    vViewNormal = normalize(normalMatrix * normal);
+    gl_Position = projectionMatrix * viewPosition;
+  }
+`;
+const ZEBRA_STRIPE_FRAGMENT_SHADER = `
+  precision highp float;
+
+  uniform vec3 uAccentColor;
+  uniform vec3 uDarkColor;
+  uniform vec3 uLightColor;
+  uniform float uStripeScale;
+  uniform float uStripeSoftness;
+
+  varying vec3 vViewNormal;
+  varying vec3 vViewPosition;
+
+  void main() {
+    vec3 normal = normalize(vViewNormal);
+    if (!gl_FrontFacing) {
+      normal = -normal;
+    }
+
+    vec3 eyeDirection = normalize(-vViewPosition);
+    vec3 reflection = normalize(reflect(-eyeDirection, normal));
+    float stripePhase = reflection.x * 0.92 + reflection.y * 0.28 + reflection.z * 0.18;
+    float stripeWave = sin(stripePhase * uStripeScale);
+    float stripeMask = smoothstep(-uStripeSoftness, uStripeSoftness, stripeWave);
+
+    float grazing = pow(1.0 - clamp(dot(normal, eyeDirection), 0.0, 1.0), 1.8);
+    float secondaryWave = sin((reflection.y - reflection.z * 0.45) * uStripeScale * 0.45);
+    float secondary = smoothstep(0.72, 1.0, secondaryWave) * 0.12;
+
+    vec3 bands = mix(uDarkColor, uLightColor, stripeMask);
+    vec3 color = mix(bands, uAccentColor, grazing * 0.18);
+    color += uLightColor * secondary * (0.35 + grazing * 0.4);
+
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+function isVisibleColor(colors, vertexIndex) {
+  const offset2 = vertexIndex * 3;
+  return colors[offset2] > 1e-6 || colors[offset2 + 1] > 1e-6 || colors[offset2 + 2] > 1e-6;
+}
+function copyAttribute(attribute, vertexIndexes) {
+  const itemSize = attribute.itemSize;
+  const source = attribute.array;
+  const out = new Float32Array(vertexIndexes.length * itemSize);
+  vertexIndexes.forEach((vertexIndex, outIndex) => {
+    const sourceOffset = vertexIndex * itemSize;
+    const outOffset = outIndex * itemSize;
+    for (let component = 0; component < itemSize; component += 1) {
+      out[outOffset + component] = source[sourceOffset + component];
+    }
+  });
+  return new BufferAttribute(out, itemSize, attribute.normalized);
+}
+function selectedTriangleVertexIndexes(geometry, colors) {
+  const position = geometry.getAttribute("position");
+  if (!position || colors.length !== position.count * 3) return [];
+  const selected = [];
+  const index2 = geometry.getIndex();
+  if (index2) {
+    const values = index2.array;
+    for (let triangle = 0; triangle + 2 < index2.count; triangle += 3) {
+      const a2 = values[triangle];
+      const b = values[triangle + 1];
+      const c2 = values[triangle + 2];
+      if (isVisibleColor(colors, a2) || isVisibleColor(colors, b) || isVisibleColor(colors, c2)) {
+        selected.push(a2, b, c2);
+      }
+    }
+    return selected;
+  }
+  for (let vertex2 = 0; vertex2 + 2 < position.count; vertex2 += 3) {
+    if (isVisibleColor(colors, vertex2) || isVisibleColor(colors, vertex2 + 1) || isVisibleColor(colors, vertex2 + 2)) {
+      selected.push(vertex2, vertex2 + 1, vertex2 + 2);
+    }
+  }
+  return selected;
+}
+function geometryWithVisibleVertexColors(geometry, colors) {
+  const vertexIndexes = selectedTriangleVertexIndexes(geometry, colors);
+  if (vertexIndexes.length === 0) return null;
+  const out = new BufferGeometry();
+  for (const name of ["position", "normal"]) {
+    const attribute = geometry.getAttribute(name);
+    if (attribute) out.setAttribute(name, copyAttribute(attribute, vertexIndexes));
+  }
+  const colorAttribute = copyAttribute(new BufferAttribute(colors, 3), vertexIndexes);
+  out.setAttribute("color", colorAttribute);
+  return out;
+}
+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(a2, b, t) {
+  const clamped = MathUtils.clamp(t, 0, 1);
+  return [
+    Math.round(MathUtils.lerp(a2[0], b[0], clamped)),
+    Math.round(MathUtils.lerp(a2[1], b[1], clamped)),
+    Math.round(MathUtils.lerp(a2[2], b[2], clamped))
+  ];
+}
+const AXIS_NAMES = ["x", "y", "z"];
+function nearestBoundaryGap(a2, b, axis) {
+  return Math.min(Math.abs(a2.max[axis] - b.min[axis]), Math.abs(b.max[axis] - a2.min[axis]));
+}
+function hasPositiveGap(gaps) {
+  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
+}
+function contactFromBBoxes(a2, b, tolerance) {
+  const gaps = aabbGaps(a2, 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(a2, 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, offset2) {
+  for (let index2 = 0; index2 < 9; index2 += 1) {
+    if (!Number.isFinite(positions[offset2 + index2])) return false;
+  }
+  return true;
+}
+function triangleRef(positions, offset2) {
+  if (!isFiniteTriangle(positions, offset2)) return null;
+  const ax = positions[offset2];
+  const ay = positions[offset2 + 1];
+  const az = positions[offset2 + 2];
+  const bx = positions[offset2 + 3];
+  const by = positions[offset2 + 4];
+  const bz = positions[offset2 + 5];
+  const cx = positions[offset2 + 6];
+  const cy = positions[offset2 + 7];
+  const cz = positions[offset2 + 8];
+  return {
+    offset: offset2,
+    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(px2, py2, pz2, qx, qy, qz) {
+  const dx = px2 - qx;
+  const dy = py2 - qy;
+  const dz = pz2 - qz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function pointSegmentDistanceSq(point2, 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(point2[0], point2[1], point2[2], start[0], start[1], start[2]);
+  const t = Math.max(0, Math.min(1, ((point2[0] - start[0]) * dx + (point2[1] - start[1]) * dy + (point2[2] - start[2]) * dz) / lengthSq));
+  return distSq(point2[0], point2[1], point2[2], start[0] + t * dx, start[1] + t * dy, start[2] + t * dz);
+}
+function pointTriangleDistanceSq(px2, py2, pz2, 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 = px2 - ax;
+  const apy = py2 - ay;
+  const apz = pz2 - az;
+  const d1 = abx * apx + aby * apy + abz * apz;
+  const d2 = acx * apx + acy * apy + acz * apz;
+  if (d1 <= 0 && d2 <= 0) return distSq(px2, py2, pz2, ax, ay, az);
+  const bpx = px2 - bx;
+  const bpy = py2 - by;
+  const bpz = pz2 - bz;
+  const d3 = abx * bpx + aby * bpy + abz * bpz;
+  const d4 = acx * bpx + acy * bpy + acz * bpz;
+  if (d3 >= 0 && d4 <= d3) return distSq(px2, py2, pz2, bx, by, bz);
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+    const v22 = d1 / (d1 - d3);
+    return distSq(px2, py2, pz2, ax + v22 * abx, ay + v22 * aby, az + v22 * abz);
+  }
+  const cpx = px2 - cx;
+  const cpy = py2 - cy;
+  const cpz = pz2 - cz;
+  const d5 = abx * cpx + aby * cpy + abz * cpz;
+  const d6 = acx * cpx + acy * cpy + acz * cpz;
+  if (d6 >= 0 && d5 <= d6) return distSq(px2, py2, pz2, cx, cy, cz);
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+    const w22 = d2 / (d2 - d6);
+    return distSq(px2, py2, pz2, ax + w22 * acx, ay + w22 * acy, az + w22 * 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 w22 = (d4 - d3) / (d4 - d3 + d5 - d6);
+    return distSq(px2, py2, pz2, bx + w22 * bcx, by + w22 * bcy, bz + w22 * bcz);
+  }
+  const barycentricTotal = va + vb + vc;
+  if (!Number.isFinite(barycentricTotal) || Math.abs(barycentricTotal) < 1e-20) {
+    return Math.min(distSq(px2, py2, pz2, ax, ay, az), distSq(px2, py2, pz2, bx, by, bz), distSq(px2, py2, pz2, cx, cy, cz));
+  }
+  const denom = 1 / barycentricTotal;
+  const v = vb * denom;
+  const w2 = vc * denom;
+  return distSq(px2, py2, pz2, ax + abx * v + acx * w2, ay + aby * v + acy * w2, az + abz * v + acz * w2);
+}
+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 a2 = ux * ux + uy * uy + uz * uz;
+  const b = ux * vx + uy * vy + uz * vz;
+  const c2 = vx * vx + vy * vy + vz * vz;
+  const d2 = ux * wx + uy * wy + uz * wz;
+  const e = vx * wx + vy * wy + vz * wz;
+  const denom = a2 * c2 - b * b;
+  let sNumerator = denom;
+  let sDenominator = denom;
+  let tNumerator = denom;
+  let tDenominator = denom;
+  if (a2 <= 1e-20) return pointSegmentDistanceSq(a0, b0, b1);
+  if (c2 <= 1e-20) return pointSegmentDistanceSq(b0, a0, a1);
+  if (denom < 1e-20) {
+    sNumerator = 0;
+    sDenominator = 1;
+    tNumerator = e;
+    tDenominator = c2;
+  } else {
+    sNumerator = b * e - c2 * d2;
+    tNumerator = a2 * e - b * d2;
+    if (sNumerator < 0) {
+      sNumerator = 0;
+      tNumerator = e;
+      tDenominator = c2;
+    } else if (sNumerator > sDenominator) {
+      sNumerator = sDenominator;
+      tNumerator = e + b;
+      tDenominator = c2;
+    }
+  }
+  if (tNumerator < 0) {
+    tNumerator = 0;
+    if (-d2 < 0) {
+      sNumerator = 0;
+    } else if (-d2 > a2) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d2;
+      sDenominator = a2;
+    }
+  } else if (tNumerator > tDenominator) {
+    tNumerator = tDenominator;
+    if (-d2 + b < 0) {
+      sNumerator = 0;
+    } else if (-d2 + b > a2) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d2 + b;
+      sDenominator = a2;
+    }
+  }
+  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 offset2 = triangle.offset + corner * 3;
+  return [positions[offset2], positions[offset2 + 1], positions[offset2 + 2]];
+}
+function bboxDistanceSq(a2, b) {
+  let total = 0;
+  for (let axis = 0; axis < 3; axis += 1) {
+    const gap = Math.max(0, a2.min[axis] - b.max[axis], b.min[axis] - a2.max[axis]);
+    total += gap * gap;
+  }
+  return total;
+}
+function triangleDistanceSq(aPositions, a2, bPositions, b) {
+  const a0 = trianglePoint(aPositions, a2, 0);
+  const a1 = trianglePoint(aPositions, a2, 1);
+  const a22 = trianglePoint(aPositions, a2, 2);
+  const b0 = trianglePoint(bPositions, b, 0);
+  const b1 = trianglePoint(bPositions, b, 1);
+  const b22 = 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], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(a1[0], a1[1], a1[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(a22[0], a22[1], a22[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(b0[0], b0[1], b0[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a22[0], a22[1], a22[2]),
+    pointTriangleDistanceSq(b1[0], b1[1], b1[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a22[0], a22[1], a22[2]),
+    pointTriangleDistanceSq(b22[0], b22[1], b22[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a22[0], a22[1], a22[2]),
+    segmentSegmentDistanceSq(a0, a1, b0, b1),
+    segmentSegmentDistanceSq(a0, a1, b1, b22),
+    segmentSegmentDistanceSq(a0, a1, b22, b0),
+    segmentSegmentDistanceSq(a1, a22, b0, b1),
+    segmentSegmentDistanceSq(a1, a22, b1, b22),
+    segmentSegmentDistanceSq(a1, a22, b22, b0),
+    segmentSegmentDistanceSq(a22, a0, b0, b1),
+    segmentSegmentDistanceSq(a22, a0, b1, b22),
+    segmentSegmentDistanceSq(a22, a0, b22, b0)
+  );
+}
+function meshEntriesContactDistance(a2, b, tolerance) {
+  const toleranceSq = tolerance * tolerance;
+  let bestDistanceSq = Infinity;
+  for (const aTriangle of a2.triangles) {
+    for (const bTriangle of b.triangles) {
+      if (bboxDistanceSq(aTriangle, bTriangle) > toleranceSq) continue;
+      const distanceSq = triangleDistanceSq(a2.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(a2, b) {
+  try {
+    const hit = a2.shape.intersect(b.shape);
+    if (hit.isEmpty()) return { volume: 0 };
+    const volume = hit.volume();
+    return { volume: Number.isFinite(volume) ? volume : 0 };
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return { volume: null, warning: `Could not boolean-test ${a2.name} against ${b.name}: ${message}` };
+  }
+}
+function detectPhysicalContact(a2, b, options, meshCache = {}) {
+  const gaps = aabbGaps(a2, 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(a2);
+  const targetMesh = meshCache.targetMesh !== void 0 ? meshCache.targetMesh : meshContactDataFor(b);
+  if (sourceMesh && targetMesh) {
+    const distance2 = meshEntriesContactDistance(sourceMesh, targetMesh, options.contactTolerance);
+    if (distance2 != null) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "mesh-surface-distance",
+          gap: distance2
+        }
+      };
+    }
+  }
+  const bboxOverlaps = !hasPositiveGap(gaps) && aabbInteriorOverlaps(a2, b);
+  if (options.exactGeometry && bboxOverlaps) {
+    if (aabbOverlapVolume(a2, b) <= options.minOverlapVolume) return { contact: null };
+    const overlap = intersectionVolume(a2, 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(a2, b)
+      }
+    };
+  }
+  if (options.mergeTouchingBBoxes) {
+    const contact = contactFromBBoxes(a2, 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
+};
+class UnionFind {
+  constructor(size) {
+    __publicField(this, "parent");
+    __publicField(this, "rank");
+    this.parent = Array.from({ length: size }, (_2, index2) => index2);
+    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(a2, b) {
+    const rootA = this.find(a2);
+    const rootB = this.find(b);
+    if (rootA === rootB) return;
+    if (this.rank[rootA] < this.rank[rootB]) {
+      this.parent[rootA] = rootB;
+      return;
+    }
+    if (this.rank[rootA] > this.rank[rootB]) {
+      this.parent[rootB] = rootA;
+      return;
+    }
+    this.parent[rootB] = rootA;
+    this.rank[rootA] += 1;
+  }
+}
+function cloneVec3(value) {
+  return [value[0], value[1], value[2]];
+}
+function emptyBBox() {
+  return {
+    min: [Infinity, Infinity, Infinity],
+    max: [-Infinity, -Infinity, -Infinity]
+  };
+}
+function expandBBox(target, min2, max2) {
+  for (let axis = 0; axis < 3; axis += 1) {
+    target.min[axis] = Math.min(target.min[axis], min2[axis]);
+    target.max[axis] = Math.max(target.max[axis], max2[axis]);
+  }
+}
+function collectCandidatePairs(entries, tolerance) {
+  if (entries.length < 2) return [];
+  const index2 = new AabbSpatialIndex(entries);
+  const pairs = index2.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((a2, b) => a2.sourceIndex - b.sourceIndex || a2.targetIndex - b.targetIndex);
+  return pairs;
+}
+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(entries.length);
+  const meshDataByIndex = /* @__PURE__ */ new Map();
+  entries.forEach((entry, index2) => {
+    const meshData = meshContactDataFor(entry);
+    if (meshData) meshDataByIndex.set(index2, meshData);
+  });
+  for (const pair of collectCandidatePairs(entries, options.contactTolerance)) {
+    const i = pair.sourceIndex;
+    const j = pair.targetIndex;
+    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, index2) => ({
+    index: index2,
+    id: entry.id,
+    name: entry.name,
+    groupName: entry.groupName,
+    treePath: entry.treePath,
+    mock: entry.mock === true,
+    bodyCount: bodyCountForEntry(entry),
+    bbox: {
+      min: cloneVec3(entry.min),
+      max: cloneVec3(entry.max)
+    },
+    componentIndex: 0
+  }));
+  const componentByRoot = /* @__PURE__ */ new Map();
+  const rootToComponentIndex = /* @__PURE__ */ new Map();
+  for (let objectIndex = 0; objectIndex < objects.length; objectIndex += 1) {
+    const root = unionFind.find(objectIndex);
+    let component = componentByRoot.get(root);
+    if (!component) {
+      component = {
+        index: componentByRoot.size + 1,
+        objectIndexes: [],
+        objectIds: [],
+        objectNames: [],
+        objectCount: 0,
+        bodyCount: 0,
+        bbox: emptyBBox()
+      };
+      componentByRoot.set(root, component);
+      rootToComponentIndex.set(root, component.index);
+    }
+    const object = objects[objectIndex];
+    object.componentIndex = rootToComponentIndex.get(root) ?? component.index;
+    component.objectIndexes.push(object.index);
+    component.objectIds.push(object.id);
+    component.objectNames.push(object.name);
+    component.objectCount += 1;
+    component.bodyCount += object.bodyCount;
+    expandBBox(component.bbox, object.bbox.min, object.bbox.max);
+  }
+  const components = [...componentByRoot.values()];
+  return {
+    method: options.exactGeometry ? "mesh-contact-plus-boolean-overlap" : "bbox-neighborhood",
+    options,
+    objectCount: objects.length,
+    componentCount: components.length,
+    objects,
+    components,
+    edges,
+    warnings
+  };
+}
+const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
+  minThickness: 1.2,
+  warnThickness: 2,
+  maxThickness: 6,
+  maxSamplesPerObject: 5e3,
+  contactTolerance: DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance
+};
+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 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");
+  const maxThickness = finitePositive(raw.maxThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxThickness, "maxThickness");
+  const maxSamplesPerObject = finitePositive(
+    raw.maxSamplesPerObject,
+    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.");
+  }
+  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)),
+    contactTolerance
+  };
+}
+function lerp(a2, b, t) {
+  return a2 + (b - a2) * Math.max(0, Math.min(1, t));
+}
+function lerpColor(a2, b, t) {
+  return [Math.round(lerp(a2[0], b[0], t)), Math.round(lerp(a2[1], b[1], t)), Math.round(lerp(a2[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(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(THICKNESS_COLORS.ok, THICKNESS_COLORS.thick, ((thickness ?? 0) - options.warnThickness) / span);
+  }
+  return THICKNESS_COLORS.thick;
+}
+function sampleArea(sample) {
+  const area2 = sample.area ?? 1;
+  return Number.isFinite(area2) && area2 > 0 ? area2 : 1;
+}
+function weightedQuantile(samples, q) {
+  if (samples.length === 0) return null;
+  const sorted = [...samples].sort((a2, b) => a2.thickness - b.thickness);
+  const totalArea = sorted.reduce((sum2, sample) => sum2 + 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 area2 = sampleArea(sample);
+    totalArea += area2;
+    const value = sample.thickness;
+    if (value == null || !Number.isFinite(value) || value <= 0) {
+      unresolvedArea += area2;
+      continue;
+    }
+    resolved.push({ thickness: value, area: area2 });
+    resolvedArea += area2;
+    weightedSum += value * area2;
+    if (value <= options.minThickness) {
+      criticalArea += area2;
+    } else if (value <= options.warnThickness) {
+      warningArea += area2;
+    }
+  }
+  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 VECTOR_KEYS = /* @__PURE__ */ new Set(["pos", "position", "target", "lookat", "aim", "up"]);
 const roundNumber = (value, digits) => {
   const scale2 = 10 ** digits;
@@ -342070,6 +343148,28 @@ function localAabbPlaneRelation(min2, max2, plane, eps = 1e-7) {
   if (minDistance > -eps) return "positive";
   return "crossing";
 }
+const DEFAULT_SCALAR_SCENE_BUDGET_OBJECTS = 15;
+const DEFAULT_SCALAR_SCENE_MIN_SAMPLES_PER_OBJECT = 100;
+function resolveScalarSceneSampleBudget(args) {
+  const objectCount = Math.max(0, Math.floor(args.objectCount));
+  const requestedMaxSamplesPerObject = Math.max(1, Math.floor(args.maxSamplesPerObject));
+  const sceneBudgetObjectCount = Math.max(1, Math.floor(args.sceneBudgetObjectCount ?? DEFAULT_SCALAR_SCENE_BUDGET_OBJECTS));
+  const minSamplesPerObject = Math.max(1, Math.floor(args.minSamplesPerObject ?? DEFAULT_SCALAR_SCENE_MIN_SAMPLES_PER_OBJECT));
+  const explicitMaxSamplesPerObject = args.explicitMaxSamplesPerObject === true;
+  const sceneMaxSamples = requestedMaxSamplesPerObject * sceneBudgetObjectCount;
+  const budgeted = objectCount <= 0 || objectCount <= sceneBudgetObjectCount || explicitMaxSamplesPerObject ? requestedMaxSamplesPerObject : Math.max(minSamplesPerObject, Math.floor(sceneMaxSamples / objectCount));
+  const effectiveMaxSamplesPerObject = Math.min(requestedMaxSamplesPerObject, budgeted);
+  return {
+    objectCount,
+    requestedMaxSamplesPerObject,
+    effectiveMaxSamplesPerObject,
+    sceneBudgetObjectCount,
+    sceneMaxSamples,
+    minSamplesPerObject,
+    explicitMaxSamplesPerObject,
+    capped: effectiveMaxSamplesPerObject < requestedMaxSamplesPerObject
+  };
+}
 export {
   Matrix4 as $,
   ACESFilmicToneMapping as A,
@@ -342165,7 +343265,7 @@ export {
   DEFAULT_ACTIVE_BACKEND as ay,
   isConstraintSketch as az,
   PCFShadowMap as b,
-  initKernelManifoldOnly as b$,
+  analyzePhysicalConnectivity as b$,
   PointLight as b0,
   DirectionalLight as b1,
   analyzeCollisionIntersections as b2,
@@ -342176,61 +343276,85 @@ export {
   runScript as b7,
   MeshPhysicalMaterial as b8,
   LineSegments as b9,
-  findJointAnimationClip as bA,
-  resolveJointAnimation as bB,
-  resolveJointViewValues as bC,
-  getShapePorts as bD,
-  getShapeUsedPorts as bE,
-  DEFAULT_VIEW_CONFIG as bF,
-  getKernelFaceNameForTriangle as bG,
-  initKernel as bH,
-  initSolverWasm as bI,
-  BoxGeometry as bJ,
-  localAabbPlaneRelation as bK,
-  ShapeUtils as bL,
-  aabbInteriorOverlaps as bM,
-  aabbOverlapVolume as bN,
-  AabbSpatialIndex as bO,
-  aabbGaps as bP,
-  Group as bQ,
-  intersectWithPlane as bR,
-  parseCameraCliSpec as bS,
-  PMREMGenerator as bT,
-  PointsMaterial as bU,
-  Points$1 as bV,
-  serializeCollisionFinding as bW,
-  worldAuthorPlaneToLocal as bX,
-  generateCuttingLayoutPdf as bY,
-  getCameraForwardVector as bZ,
-  RENDER_STYLE_OPTIONS as b_,
-  getRenderStylePreset as ba,
-  AdditiveBlending as bb,
-  CatmullRomCurve3 as bc,
-  TubeGeometry as bd,
-  MeshStandardMaterial as be,
-  compileSdfNode3 as bf,
-  buildSdfRaymarchFragmentShader as bg,
-  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bh,
-  Shape2 as bi,
-  ShapeGeometry as bj,
-  ShaderLib as bk,
-  CylinderGeometry as bl,
-  parseViewportCameraState as bm,
-  createResolvedExplodeConfig as bn,
-  explodeBoundsCenter as bo,
-  explodeMergeBounds as bp,
-  resolveExplodeDirective as bq,
-  computeExplodeMotion as br,
-  getSketchWorldMatrix as bs,
-  explodeAdd as bt,
-  hasExplodeOverride as bu,
-  resolveExplodeLocalFanDirection as bv,
-  explodeMul as bw,
-  explodeLeafFanStage as bx,
-  normalizeCutPlane as by,
-  toClippingPlane as bz,
+  parseViewportCameraState as bA,
+  createResolvedExplodeConfig as bB,
+  explodeBoundsCenter as bC,
+  explodeMergeBounds as bD,
+  resolveExplodeDirective as bE,
+  computeExplodeMotion as bF,
+  getSketchWorldMatrix as bG,
+  explodeAdd as bH,
+  hasExplodeOverride as bI,
+  resolveExplodeLocalFanDirection as bJ,
+  explodeMul as bK,
+  explodeLeafFanStage as bL,
+  normalizeCutPlane as bM,
+  toClippingPlane as bN,
+  findJointAnimationClip as bO,
+  resolveJointAnimation as bP,
+  resolveJointViewValues as bQ,
+  getShapePorts as bR,
+  getShapeUsedPorts as bS,
+  DEFAULT_VIEW_CONFIG as bT,
+  getKernelFaceNameForTriangle as bU,
+  resolveScalarSceneSampleBudget as bV,
+  initKernel as bW,
+  initSolverWasm as bX,
+  BoxGeometry as bY,
+  localAabbPlaneRelation as bZ,
+  ShapeUtils as b_,
+  geometryWithVisibleVertexColors as ba,
+  getRenderStylePreset as bb,
+  AdditiveBlending as bc,
+  ZEBRA_STRIPE_SOFTNESS as bd,
+  ZEBRA_STRIPE_SCALE as be,
+  ZEBRA_LIGHT_COLOR as bf,
+  ZEBRA_DARK_COLOR as bg,
+  ZEBRA_ACCENT_COLOR as bh,
+  ZEBRA_STRIPE_FRAGMENT_SHADER as bi,
+  ZEBRA_STRIPE_VERTEX_SHADER as bj,
+  SURFACE_FIELD_FRAGMENT_SHADER as bk,
+  SURFACE_FIELD_VERTEX_SHADER as bl,
+  CatmullRomCurve3 as bm,
+  TubeGeometry as bn,
+  ROUGHNESS_COLORS as bo,
+  DEFAULT_ROUGHNESS_INSPECTION_OPTIONS as bp,
+  DEFAULT_THICKNESS_INSPECTION_OPTIONS as bq,
+  THICKNESS_COLORS as br,
+  MeshStandardMaterial as bs,
+  compileSdfNode3 as bt,
+  buildSdfRaymarchFragmentShader as bu,
+  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bv,
+  Shape2 as bw,
+  ShapeGeometry as bx,
+  ShaderLib as by,
+  CylinderGeometry as bz,
   SRGBColorSpace as c,
-  __viteBrowserExternal$1 as c0,
+  meshContactDataFor as c0,
+  AabbSpatialIndex as c1,
+  detectPhysicalContact as c2,
+  resolveThicknessInspectionOptions as c3,
+  thicknessColor as c4,
+  thicknessClass as c5,
+  roughnessClassForAngle as c6,
+  resolveRoughnessInspectionOptions as c7,
+  roughnessColorForAngle as c8,
+  roughnessScoreForAngle as c9,
+  Group as ca,
+  intersectWithPlane as cb,
+  setActiveBackend as cc,
+  parseCameraCliSpec as cd,
+  PMREMGenerator as ce,
+  PointsMaterial as cf,
+  Points$1 as cg,
+  serializeCollisionFinding as ch,
+  summarizeThicknessSamples as ci,
+  worldAuthorPlaneToLocal as cj,
+  generateCuttingLayoutPdf as ck,
+  getCameraForwardVector as cl,
+  RENDER_STYLE_OPTIONS as cm,
+  initKernelManifoldOnly as cn,
+  __viteBrowserExternal$1 as co,
   Layers as d,
   Color as e,
   RGBAFormat as f,