forgecad 0.10.3 → 0.10.5

package/dist/assets/cli/{render-BsngirjC.js → render--SIU27W_.js}

@@ -1,8 +1,8 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { D as DoubleSide, a as Scene, bw as BoxGeometry, c1 as MeshStandardMaterial, a5 as BackSide, b2 as PointLight, M as Mesh, af as MeshBasicMaterial, cF as localAabbPlaneRelation, i as Vector2, cG as ShapeUtils, cH as analyzePhysicalConnectivity, h as Vector3, a0 as Matrix4, cI as Frustum, J as Box3, a1 as MathUtils, cJ as meshContactDataFor, cK as AabbSpatialIndex, cL as detectPhysicalContact, cM as resolveThicknessInspectionOptions, R as Raycaster, cN as thicknessColor, cO as thicknessClass, a6 as BufferAttribute, cE as initBackendForEvaluation, f as Color, b5 as COMPARISON_COLORS, aE as resolveForgeRenderStyle, bG as getRenderStylePreset, aD as setParamOverrides, bk as runScript, cp as scanProxyGridForBounds, cP as Group, b9 as shapeToGeometry, bl as MeshPhysicalMaterial, bD as AdditiveBlending, bJ as scanMaterialShellColor, cQ as createScanProxyGeometry, aU as LineBasicMaterial, bI as NormalBlending, bm as LineSegments, P as PerspectiveCamera, cm as DEFAULT_VIEW_CONFIG, bs as worldAuthorPlaneToLocal, cR as resolveSectionHatchMetrics, cv as buildGeometryComparisonPointCloud, ct as triangleSoupFromMeshes, O as OrthographicCamera, l as ShaderMaterial, bP as ZEBRA_STRIPE_FRAGMENT_SHADER, bQ as ZEBRA_STRIPE_VERTEX_SHADER, bK as ZEBRA_STRIPE_SOFTNESS, bL as ZEBRA_STRIPE_SCALE, bM as ZEBRA_LIGHT_COLOR, bN as ZEBRA_DARK_COLOR, bO as ZEBRA_ACCENT_COLOR, bE as geometryWithVisibleVertexColors, cS as intersectWithPlane, cT as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, d as SRGBColorSpace, cU as parseCameraCliSpec, cV as PMREMGenerator, aX as CanvasTexture, aY as Object3D, aZ as FogExp2, a_ as Fog, a$ as AmbientLight, b3 as DirectionalLight, b0 as HemisphereLight, aO as findJointAnimationClip, q as Plane, bT as SURFACE_FIELD_FRAGMENT_SHADER, bU as SURFACE_FIELD_VERTEX_SHADER, bS as scanMaterialLayerStyles, bR as SCAN_PROXY_LAYER_STYLES, aP as resolveJointAnimation, aQ as resolveJointViewValues, aT as BufferGeometry, cW as DEFAULT_ROUGHNESS_COLOR_SCALE, cX as PointsMaterial, cY as Points, b4 as heatPointsForSide, cZ as analyzeCollisionIntersections, c_ as serializeCollisionFinding, c$ as summarizeThicknessSamples, d0 as THICKNESS_GRADIENT_COLORS, d1 as THICKNESS_COLORS, d2 as DEFAULT_THICKNESS_COLOR_SCALE, b1 as SpotLight, c5 as CylinderGeometry, d3 as TorusGeometry, bW as CatmullRomCurve3, bX as TubeGeometry, cz as resolveScalarSceneSampleBudget, d4 as sampleColorScale, ba as buildComparisonHeatPatchGeometry, bb as EdgesGeometry, d5 as SphereGeometry, d6 as ConeGeometry, b6 as comparisonHeatDepthTest, b7 as comparisonHeatEdgeOpacity, b8 as comparisonHeatPatchOpacity, cC as comparisonCandidateContextOpacity, d7 as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../backendInit-DbTkQN9J.js";
-import { m as mergeViewportRenderSceneStates, v as validateJointOverrides, b as buildBaseJointValues, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../jointPose-AMvCywzS.js";
+import { D as DoubleSide, a as Scene, bJ as BoxGeometry, cp as MeshStandardMaterial, a5 as BackSide, bd as PointLight, M as Mesh, ab as MeshBasicMaterial, d2 as localAabbPlaneRelation, i as Vector2, d3 as ShapeUtils, d4 as analyzePhysicalConnectivity, h as Vector3, a0 as Matrix4, d5 as Frustum, J as Box3, a1 as MathUtils, d6 as meshContactDataFor, d7 as AabbSpatialIndex, d8 as detectPhysicalContact, d9 as resolveThicknessInspectionOptions, da as thicknessColor, db as thicknessClass, bf as BufferAttribute, R as Raycaster, bS as MeshBVH, c1 as acceleratedRaycast, dc as requireFiniteNumber, dd as requireIntegerAtLeast, de as requirePositiveFiniteNumber, d1 as initBackendForEvaluation, f as Color, bh as COMPARISON_COLORS, aB as resolveForgeRenderStyle, b_ as getRenderStylePreset, az as setParamOverrides, bw as runScript, cN as scanProxyGridForBounds, df as Group, bl as shapeToGeometry, bx as MeshPhysicalMaterial, bQ as AdditiveBlending, c4 as scanMaterialShellColor, bY as descriptorToThreeTexture, bZ as applyProjectedTexture, dg as createScanProxyGeometry, b3 as LineBasicMaterial, c0 as NormalBlending, by as LineSegments, P as PerspectiveCamera, cK as DEFAULT_VIEW_CONFIG, bF as worldAuthorPlaneToLocal, dh as resolveSectionHatchMetrics, cT as buildGeometryComparisonPointCloud, cR as triangleSoupFromMeshes, O as OrthographicCamera, l as ShaderMaterial, ca as ZEBRA_STRIPE_FRAGMENT_SHADER, cb as ZEBRA_STRIPE_VERTEX_SHADER, c5 as ZEBRA_STRIPE_SOFTNESS, c6 as ZEBRA_STRIPE_SCALE, c7 as ZEBRA_LIGHT_COLOR, c8 as ZEBRA_DARK_COLOR, c9 as ZEBRA_ACCENT_COLOR, bR as geometryWithVisibleVertexColors, di as intersectWithPlane, dj as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, d as SRGBColorSpace, dk as parseCameraCliSpec, dl as PMREMGenerator, b6 as CanvasTexture, b7 as Object3D, b8 as FogExp2, b9 as Fog, ba as AmbientLight, be as DirectionalLight, bb as HemisphereLight, aW as findJointAnimationClip, q as Plane, ce as SURFACE_FIELD_FRAGMENT_SHADER, cf as SURFACE_FIELD_VERTEX_SHADER, cd as scanMaterialLayerStyles, cc as SCAN_PROXY_LAYER_STYLES, aX as resolveJointAnimation, aY as resolveJointViewValues, b2 as BufferGeometry, dm as DEFAULT_ROUGHNESS_COLOR_SCALE, bT as makeColorScaleTexture, bU as colorScaleLUT, bV as makeScalarValueTexture, bW as makeInspectScalarUniforms, c2 as INSPECT_SCALAR_FRAGMENT_SHADER, c3 as INSPECT_SCALAR_VERTEX_SHADER, bg as heatPointsForSide, dn as analyzeCollisionIntersections, dp as serializeCollisionFinding, dq as summarizeThicknessSamples, dr as THICKNESS_COLORS, ds as DEFAULT_THICKNESS_COLOR_SCALE, dt as DEFAULT_INSPECT_ISOLINE_SPACING, bc as SpotLight, ct as CylinderGeometry, du as TorusGeometry, ch as CatmullRomCurve3, ci as TubeGeometry, cX as resolveScalarSceneSampleBudget, bm as buildComparisonHeatPatchGeometry, bn as EdgesGeometry, ck as DEFAULT_COLORMAP, dv as SphereGeometry, dw as ConeGeometry, bi as comparisonHeatDepthTest, bj as comparisonHeatEdgeOpacity, bk as comparisonHeatPatchOpacity, c$ as comparisonCandidateContextOpacity, dx as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../backendInit-mDHk97u7.js";
+import { m as mergeViewportRenderSceneStates, v as validateJointOverrides, b as buildBaseJointValues, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../jointPose-bYMlwU3v.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -1187,12 +1187,12 @@ function planeKey(triangle, snap) {
 }
 function triangleEdgeKeys(triangle, snap) {
   const vertices = [vertexKey$2(triangle.a, snap), vertexKey$2(triangle.b, snap), vertexKey$2(triangle.c, snap)];
-  return [edgeKey$1(vertices[0], vertices[1]), edgeKey$1(vertices[1], vertices[2]), edgeKey$1(vertices[2], vertices[0])];
+  return [edgeKey$2(vertices[0], vertices[1]), edgeKey$2(vertices[1], vertices[2]), edgeKey$2(vertices[2], vertices[0])];
 }
 function vertexKey$2(point, snap) {
   return `${Math.round(point.x / snap)},${Math.round(point.y / snap)},${Math.round(point.z / snap)}`;
 }
-function edgeKey$1(a, b) {
+function edgeKey$2(a, b) {
   return a < b ? `${a}|${b}` : `${b}|${a}`;
 }
 const MIN_TRIANGLE_AREA = 1e-12;
@@ -1321,10 +1321,17 @@ function fract(value) {
 function clampUnit(value) {
   return Math.min(1 - 1e-9, Math.max(1e-9, value));
 }
-function cloneGeometryForFaceColors(geometry) {
+function cloneGeometryForFaceColors$1(geometry) {
   return geometry.index ? geometry.toNonIndexed() : geometry.clone();
 }
-function geometryMaxDimension(geometry) {
+function makeThicknessRaycastTarget(sourceGeometry, rayMaterial) {
+  const geometry = sourceGeometry.clone();
+  geometry.boundsTree = new MeshBVH(geometry);
+  const mesh = new Mesh(geometry, rayMaterial);
+  mesh.raycast = acceleratedRaycast;
+  return { mesh, geometry };
+}
+function geometryMaxDimension$1(geometry) {
   geometry.computeBoundingBox();
   const box = geometry.boundingBox;
   if (!box) return 1;
@@ -1332,34 +1339,47 @@ function geometryMaxDimension(geometry) {
   box.getSize(size);
   return Math.max(1, size.x, size.y, size.z);
 }
-function firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, jumpableMeshes, point, direction, epsilon, far, contactTolerance) {
+function createThicknessRaycastContext(sourceGeometry, rawOptions = {}, context = {}) {
+  const options = resolveThicknessInspectionOptions(rawOptions);
+  const connectedGeometries = context.connectedGeometries ?? [];
+  const maxDim = Math.max(geometryMaxDimension$1(sourceGeometry), ...connectedGeometries.map(geometryMaxDimension$1));
+  const epsilon = Math.max(1e-4, maxDim * 1e-6);
+  const far = Math.max(maxDim * 4, options.maxThickness * 4, 1);
+  const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
+  const rayTargets = [
+    makeThicknessRaycastTarget(sourceGeometry, rayMaterial),
+    ...connectedGeometries.map((connectedGeometry) => makeThicknessRaycastTarget(connectedGeometry, rayMaterial))
+  ];
+  return {
+    raycaster: new Raycaster(),
+    rayTargetMeshes: rayTargets.map((target) => target.mesh),
+    epsilon,
+    far,
+    contactTolerance: options.contactTolerance,
+    dispose: () => {
+      rayTargets.forEach((target) => target.geometry.dispose());
+      rayMaterial.dispose();
+    }
+  };
+}
+function firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, point, direction, epsilon, far, contactTolerance) {
   const origin = point.clone().addScaledVector(direction, epsilon);
   raycaster.set(origin, direction);
   raycaster.near = epsilon;
   raycaster.far = far;
   const hits = raycaster.intersectObjects(rayTargetMeshes, false);
+  const minDistance = Math.max(epsilon, contactTolerance);
   for (const hit of hits) {
-    if (hit.distance <= epsilon) continue;
-    if (hit.distance <= contactTolerance && jumpableMeshes.has(hit.object)) continue;
+    if (hit.distance <= minDistance) continue;
     return hit.distance + epsilon;
   }
   return null;
 }
-function triangleThickness(raycaster, rayTargetMeshes, jumpableMeshes, centroid, normal, epsilon, far, contactTolerance) {
-  const forward = firstOppositeSurfaceDistance(
-    raycaster,
-    rayTargetMeshes,
-    jumpableMeshes,
-    centroid,
-    normal,
-    epsilon,
-    far,
-    contactTolerance
-  );
+function triangleThickness(raycaster, rayTargetMeshes, centroid, normal, epsilon, far, contactTolerance) {
+  const forward = firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, centroid, normal, epsilon, far, contactTolerance);
   const backward = firstOppositeSurfaceDistance(
     raycaster,
     rayTargetMeshes,
-    jumpableMeshes,
     centroid,
     normal.clone().negate(),
     epsilon,
@@ -1370,9 +1390,20 @@ function triangleThickness(raycaster, rayTargetMeshes, jumpableMeshes, centroid,
   if (backward == null) return forward;
   return Math.min(forward, backward);
 }
+function measureThicknessAtPoint(context, point, normal) {
+  return triangleThickness(
+    context.raycaster,
+    context.rayTargetMeshes,
+    point,
+    normal,
+    context.epsilon,
+    context.far,
+    context.contactTolerance
+  );
+}
 function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {}) {
   const options = resolveThicknessInspectionOptions(rawOptions);
-  const geometry = cloneGeometryForFaceColors(sourceGeometry);
+  const geometry = cloneGeometryForFaceColors$1(sourceGeometry);
   const position = geometry.getAttribute("position");
   if (!position || position.count < 3) {
     return {
@@ -1388,82 +1419,1238 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {})
   const triangleCount = Math.floor(position.count / 3);
   const surfaceTriangles = readSurfaceTriangles(position);
   const surfaceSamples = sampleSurfaceTriangles(surfaceTriangles, options.maxSamplesPerObject);
-  const connectedGeometries = context.connectedGeometries ?? [];
-  const maxDim = Math.max(geometryMaxDimension(geometry), ...connectedGeometries.map(geometryMaxDimension));
-  const epsilon = Math.max(1e-4, maxDim * 1e-6);
-  const far = Math.max(maxDim * 4, options.maxThickness * 4, 1);
   const colors = new Float32Array(position.count * 3);
   const triangleThicknessValues = new Array(triangleCount).fill(void 0);
   const samples = [];
   const pointSamples = [];
   const warnings = [];
+  const rayContext = createThicknessRaycastContext(geometry, options, context);
+  try {
+    if (surfaceTriangles.length === 0) {
+      warnings.push("No non-degenerate triangle surface was available for thickness sampling.");
+    } else if (surfaceSamples.length < surfaceTriangles.length) {
+      warnings.push(
+        `Area sampling budget ${surfaceSamples.length} covers ${surfaceTriangles.length} surface triangles; increase --thickness-samples for denser analysis.`
+      );
+    }
+    const sampledTriangleIndexes = /* @__PURE__ */ new Set();
+    for (const sample of surfaceSamples) {
+      sampledTriangleIndexes.add(sample.triangle.index);
+      const thickness = measureThicknessAtPoint(rayContext, sample.position, sample.normal);
+      samples.push({ thickness, area: sample.area });
+      const previous = triangleThicknessValues[sample.triangle.index];
+      if (previous === void 0 || previous == null || thickness != null && thickness < previous) {
+        triangleThicknessValues[sample.triangle.index] = thickness;
+      }
+      pointSamples.push({
+        position: [sample.position.x, sample.position.y, sample.position.z],
+        normal: [sample.normal.x, sample.normal.y, sample.normal.z],
+        value: thickness,
+        className: thicknessClass(thickness, options),
+        color: thicknessColor(thickness, options),
+        area: sample.area
+      });
+    }
+    for (let tri = 0; tri < triangleCount; tri += 1) {
+      const color = thicknessColor(triangleThicknessValues[tri], options);
+      const offset = tri * 3;
+      for (let vertex = 0; vertex < 3; vertex += 1) {
+        const colorOffset = (offset + vertex) * 3;
+        colors[colorOffset] = color[0] / 255;
+        colors[colorOffset + 1] = color[1] / 255;
+        colors[colorOffset + 2] = color[2] / 255;
+      }
+    }
+    geometry.setAttribute("color", new BufferAttribute(colors, 3));
+    return {
+      geometry,
+      samples,
+      pointSamples,
+      triangleCount,
+      sampledTriangleCount: sampledTriangleIndexes.size,
+      sampleStride: Math.max(1, Math.ceil(Math.max(1, surfaceTriangles.length) / Math.max(1, sampledTriangleIndexes.size))),
+      warnings
+    };
+  } finally {
+    rayContext.dispose();
+  }
+}
+const DEFAULT_TEXTURE_SIZE_CAP = 4096;
+const DEFAULT_TARGET_TEXEL_SPACING_FACTOR = 0.5;
+const DEFAULT_PLANAR_TARGET_TEXEL_SPACING_FACTOR = 0.12;
+const PATCH_GUTTER = 2;
+const MIN_PATCH_SIDE = 4;
+const MAX_PACK_ATTEMPTS = 8;
+const CREASE_NORMAL_DOT = Math.SQRT1_2;
+const PLANAR_COMPONENT_NORMAL_DOT = Math.cos(Math.PI / 180);
+function nextPowerOfTwo(value) {
+  return 2 ** Math.ceil(Math.log2(Math.max(1, value)));
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function vertexAt(position, index, out) {
+  return out.fromBufferAttribute(position, index);
+}
+function triangleMetrics(position, tri, a, b, c) {
+  vertexAt(position, tri * 3, a);
+  vertexAt(position, tri * 3 + 1, b);
+  vertexAt(position, tri * 3 + 2, c);
+  const ab = b.distanceTo(a);
+  const bc = c.distanceTo(b);
+  const ca = a.distanceTo(c);
+  const area = b.clone().sub(a).cross(c.clone().sub(a)).length() * 0.5;
+  return { area, maxEdge: Math.max(ab, bc, ca) };
+}
+function buildTriangleInfos(position) {
+  const triangleCount = Math.floor(position.count / 3);
+  const infos = [];
+  const box = new Box3();
+  const a = new Vector3();
+  const b = new Vector3();
+  const c = new Vector3();
+  const ab = new Vector3();
+  const ac = new Vector3();
+  for (let i = 0; i < position.count; i += 1) {
+    box.expandByPoint(vertexAt(position, i, a));
+  }
+  const size = new Vector3();
+  box.getSize(size);
+  const tolerance = Math.max(size.length() * 1e-5, Number.EPSILON);
+  for (let tri = 0; tri < triangleCount; tri += 1) {
+    const va = vertexAt(position, tri * 3, a).clone();
+    const vb = vertexAt(position, tri * 3 + 1, b).clone();
+    const vc = vertexAt(position, tri * 3 + 2, c).clone();
+    const abLen = va.distanceTo(vb);
+    const bcLen = vb.distanceTo(vc);
+    const caLen = vc.distanceTo(va);
+    ab.subVectors(vb, va);
+    ac.subVectors(vc, va);
+    const normal = ab.clone().cross(ac);
+    const area = normal.length() * 0.5;
+    normal.normalize();
+    infos.push({
+      tri,
+      a: va,
+      b: vb,
+      c: vc,
+      normal,
+      area,
+      maxEdge: Math.max(abLen, bcLen, caLen)
+    });
+  }
+  return { infos, tolerance };
+}
+function quantizedPointKey(point, tolerance) {
+  const inv = 1 / tolerance;
+  return `${Math.round(point.x * inv)},${Math.round(point.y * inv)},${Math.round(point.z * inv)}`;
+}
+function edgeKey$1(left, right) {
+  return left < right ? `${left}|${right}` : `${right}|${left}`;
+}
+function triangleVertexKeys(info, tolerance) {
+  return [quantizedPointKey(info.a, tolerance), quantizedPointKey(info.b, tolerance), quantizedPointKey(info.c, tolerance)];
+}
+function buildTriangleAdjacency(infos, tolerance) {
+  const edgeToTris = /* @__PURE__ */ new Map();
+  for (const info of infos) {
+    const keys = triangleVertexKeys(info, tolerance);
+    for (const [left, right] of [
+      [keys[0], keys[1]],
+      [keys[1], keys[2]],
+      [keys[2], keys[0]]
+    ]) {
+      const key = edgeKey$1(left, right);
+      const tris = edgeToTris.get(key) ?? [];
+      tris.push(info.tri);
+      edgeToTris.set(key, tris);
+    }
+  }
+  const adjacency = Array.from({ length: infos.length }, () => /* @__PURE__ */ new Set());
+  for (const tris of edgeToTris.values()) {
+    for (let i = 0; i < tris.length; i += 1) {
+      for (let j = i + 1; j < tris.length; j += 1) {
+        adjacency[tris[i]].add(tris[j]);
+        adjacency[tris[j]].add(tris[i]);
+      }
+    }
+  }
+  return adjacency.map((neighbors) => [...neighbors]);
+}
+function triangleOnPlane(info, origin, normal, tolerance) {
+  return Math.abs(info.a.clone().sub(origin).dot(normal)) <= tolerance && Math.abs(info.b.clone().sub(origin).dot(normal)) <= tolerance && Math.abs(info.c.clone().sub(origin).dot(normal)) <= tolerance;
+}
+function detectPlanarComponents(infos, tolerance) {
+  const adjacency = buildTriangleAdjacency(infos, tolerance);
+  const assigned = new Array(infos.length).fill(false);
+  const components = [];
+  for (const seed of infos) {
+    if (assigned[seed.tri] || seed.area <= 0) continue;
+    const queue = [seed.tri];
+    const component = [];
+    assigned[seed.tri] = true;
+    for (let cursor = 0; cursor < queue.length; cursor += 1) {
+      const tri = queue[cursor];
+      component.push(tri);
+      for (const neighborTri of adjacency[tri]) {
+        if (assigned[neighborTri]) continue;
+        const neighbor = infos[neighborTri];
+        if (neighbor.area <= 0) continue;
+        if (neighbor.normal.dot(seed.normal) < PLANAR_COMPONENT_NORMAL_DOT) continue;
+        if (!triangleOnPlane(neighbor, seed.a, seed.normal, tolerance)) continue;
+        assigned[neighborTri] = true;
+        queue.push(neighborTri);
+      }
+    }
+    if (component.length > 1) components.push(component);
+  }
+  return components;
+}
+function planarBasis(component, infos) {
+  const origin = infos[component[0]].a.clone();
+  const normal = new Vector3();
+  let bestEdge = new Vector3(1, 0, 0);
+  let bestEdgeLength = 0;
+  for (const tri of component) {
+    const info = infos[tri];
+    normal.addScaledVector(info.normal, info.area);
+    for (const [left, right] of [
+      [info.a, info.b],
+      [info.b, info.c],
+      [info.c, info.a]
+    ]) {
+      const edge = right.clone().sub(left);
+      const length = edge.length();
+      if (length > bestEdgeLength) {
+        bestEdgeLength = length;
+        bestEdge = edge;
+      }
+    }
+  }
+  normal.normalize();
+  const uAxis = bestEdge.sub(normal.clone().multiplyScalar(bestEdge.dot(normal)));
+  if (uAxis.lengthSq() < 1e-12) {
+    uAxis.copy(Math.abs(normal.z) < 0.9 ? new Vector3(0, 0, 1) : new Vector3(1, 0, 0));
+    uAxis.sub(normal.clone().multiplyScalar(uAxis.dot(normal)));
+  }
+  uAxis.normalize();
+  const vAxis = normal.clone().cross(uAxis).normalize();
+  return { origin, normal, uAxis, vAxis };
+}
+function planarCoordinate(point, patch) {
+  const relative = point.clone().sub(patch.origin);
+  return [relative.dot(patch.uAxis), relative.dot(patch.vAxis)];
+}
+function buildPlanarPatch(component, infos, targetTexel) {
+  const basis = planarBasis(component, infos);
+  let minU = Infinity;
+  let maxU = -Infinity;
+  let minV = Infinity;
+  let maxV = -Infinity;
+  for (const tri of component) {
+    const info = infos[tri];
+    for (const point of [info.a, info.b, info.c]) {
+      const [u, v] = planarCoordinate(point, basis);
+      minU = Math.min(minU, u);
+      maxU = Math.max(maxU, u);
+      minV = Math.min(minV, v);
+      maxV = Math.max(maxV, v);
+    }
+  }
+  const spanU = Math.max(maxU - minU, targetTexel);
+  const spanV = Math.max(maxV - minV, targetTexel);
+  const innerU = Math.max(1, Math.ceil(spanU / targetTexel));
+  const innerV = Math.max(1, Math.ceil(spanV / targetTexel));
+  return {
+    kind: "planar",
+    tris: component,
+    width: innerU + PATCH_GUTTER * 2 + 1,
+    height: innerV + PATCH_GUTTER * 2 + 1,
+    innerU,
+    innerV,
+    x: 0,
+    y: 0,
+    ...basis,
+    minU,
+    maxU,
+    minV,
+    maxV
+  };
+}
+function buildScalarPatches(infos, planarComponents, targetTexel, planarTargetTexel) {
+  const planarTriSet = new Set(planarComponents.flat());
+  const patches = planarComponents.map((component) => buildPlanarPatch(component, infos, planarTargetTexel));
+  for (const info of infos) {
+    if (planarTriSet.has(info.tri)) continue;
+    const inner = Math.max(1, Math.ceil(info.maxEdge / targetTexel));
+    const side = Math.max(MIN_PATCH_SIDE, inner + PATCH_GUTTER * 2 + 1);
+    patches.push({
+      kind: "triangle",
+      tri: info.tri,
+      width: side,
+      height: side,
+      side,
+      inner: side - PATCH_GUTTER * 2 - 1,
+      x: 0,
+      y: 0
+    });
+  }
+  return patches;
+}
+function packPatches(position, sampleSpacing, options) {
+  const textureSizeCap = Math.max(64, Math.floor(options.textureSizeCap ?? DEFAULT_TEXTURE_SIZE_CAP));
+  const targetFactor = options.targetTexelSpacingFactor ?? DEFAULT_TARGET_TEXEL_SPACING_FACTOR;
+  const planarTargetFactor = options.planarTargetTexelSpacingFactor ?? DEFAULT_PLANAR_TARGET_TEXEL_SPACING_FACTOR;
+  const triangleCount = Math.floor(position.count / 3);
+  const { infos, tolerance } = buildTriangleInfos(position);
+  const planarComponents = detectPlanarComponents(infos, tolerance);
+  let targetTexel = Math.max(1e-6, sampleSpacing * targetFactor);
+  let planarTargetTexel = Math.max(1e-6, sampleSpacing * planarTargetFactor);
+  let capped = false;
+  for (let attempt = 0; attempt < MAX_PACK_ATTEMPTS; attempt += 1) {
+    const patches = buildScalarPatches(infos, planarComponents, targetTexel, planarTargetTexel);
+    const patchArea = patches.reduce((sum, patch) => sum + patch.width * patch.height, 0);
+    let width = nextPowerOfTwo(Math.ceil(Math.sqrt(patchArea)));
+    width = clamp(width, 256, textureSizeCap);
+    const maxPatchWidth = patches.reduce((max, patch) => Math.max(max, patch.width), 0);
+    const maxPatchHeight = patches.reduce((max, patch) => Math.max(max, patch.height), 0);
+    const maxPatchDimension = Math.max(maxPatchWidth, maxPatchHeight);
+    width = Math.max(width, Math.min(textureSizeCap, nextPowerOfTwo(maxPatchWidth)));
+    let x = 0;
+    let y = 0;
+    let rowH = 0;
+    for (const patch of [...patches].sort((left, right) => right.height - left.height || right.width - left.width)) {
+      if (x + patch.width > width) {
+        x = 0;
+        y += rowH;
+        rowH = 0;
+      }
+      patch.x = x;
+      patch.y = y;
+      x += patch.width;
+      rowH = Math.max(rowH, patch.height);
+    }
+    const height = nextPowerOfTwo(y + rowH);
+    if (maxPatchDimension <= textureSizeCap && height <= textureSizeCap) {
+      const byTri = new Array(triangleCount);
+      patches.forEach((patch) => {
+        if (patch.kind === "planar") {
+          for (const tri of patch.tris) byTri[tri] = patch;
+        } else {
+          byTri[patch.tri] = patch;
+        }
+      });
+      return { patches, patchByTri: byTri, width, height, capped };
+    }
+    capped = true;
+    const grow = Math.sqrt(Math.max(height / textureSizeCap, maxPatchDimension / textureSizeCap)) * 1.05;
+    targetTexel *= grow;
+    planarTargetTexel *= grow;
+  }
+  throw new Error(`buildThicknessSurfaceScalarField: could not pack scalar texture atlas within ${textureSizeCap}px`);
+}
+function projectToRightTriangle(u, v) {
+  let uu = clamp(u, 0, 1);
+  let vv = clamp(v, 0, 1);
+  const sum = uu + vv;
+  if (sum > 1) {
+    uu /= sum;
+    vv /= sum;
+  }
+  return [uu, vv];
+}
+function triangleParamForTexel(px, py, inner) {
+  return projectToRightTriangle((px - PATCH_GUTTER) / inner, (py - PATCH_GUTTER) / inner);
+}
+function barycentric2d(px, py, ax, ay, bx, by, cx, cy) {
+  const v0x = bx - ax;
+  const v0y = by - ay;
+  const v1x = cx - ax;
+  const v1y = cy - ay;
+  const v2x = px - ax;
+  const v2y = py - ay;
+  const d00 = v0x * v0x + v0y * v0y;
+  const d01 = v0x * v1x + v0y * v1y;
+  const d11 = v1x * v1x + v1y * v1y;
+  const d20 = v2x * v0x + v2y * v0y;
+  const d21 = v2x * v1x + v2y * v1y;
+  const denom = d00 * d11 - d01 * d01;
+  if (Math.abs(denom) < 1e-12) return null;
+  const v = (d11 * d20 - d01 * d21) / denom;
+  const w = (d00 * d21 - d01 * d20) / denom;
+  return [1 - v - w, v, w];
+}
+function setPlanarVertexUv(uvs, vertexIndex, point, patch, textureWidth, textureHeight) {
+  const [u, v] = planarCoordinate(point, patch);
+  const spanU = Math.max(patch.maxU - patch.minU, 1e-9);
+  const spanV = Math.max(patch.maxV - patch.minV, 1e-9);
+  const gridU = PATCH_GUTTER + (u - patch.minU) / spanU * patch.innerU;
+  const gridV = PATCH_GUTTER + (v - patch.minV) / spanV * patch.innerV;
+  uvs[vertexIndex * 2] = (patch.x + gridU + 0.5) / textureWidth;
+  uvs[vertexIndex * 2 + 1] = (patch.y + gridV + 0.5) / textureHeight;
+}
+function rasterizePlanarPatch(values, textureWidth, textureHeight, patch, position, measurement, measurementContext) {
+  const spanU = Math.max(patch.maxU - patch.minU, 1e-9);
+  const spanV = Math.max(patch.maxV - patch.minV, 1e-9);
+  const a = new Vector3();
+  const b = new Vector3();
+  const c = new Vector3();
+  const point = new Vector3();
+  for (const tri of patch.tris) {
+    vertexAt(position, tri * 3, a);
+    vertexAt(position, tri * 3 + 1, b);
+    vertexAt(position, tri * 3 + 2, c);
+    const [au, av] = planarCoordinate(a, patch);
+    const [bu, bv] = planarCoordinate(b, patch);
+    const [cu, cv] = planarCoordinate(c, patch);
+    const ax = PATCH_GUTTER + (au - patch.minU) / spanU * patch.innerU;
+    const ay = PATCH_GUTTER + (av - patch.minV) / spanV * patch.innerV;
+    const bx = PATCH_GUTTER + (bu - patch.minU) / spanU * patch.innerU;
+    const by = PATCH_GUTTER + (bv - patch.minV) / spanV * patch.innerV;
+    const cx = PATCH_GUTTER + (cu - patch.minU) / spanU * patch.innerU;
+    const cy = PATCH_GUTTER + (cv - patch.minV) / spanV * patch.innerV;
+    const minX = clamp(Math.floor(Math.min(ax, bx, cx)) - 1, 0, patch.width - 1);
+    const maxX = clamp(Math.ceil(Math.max(ax, bx, cx)) + 1, 0, patch.width - 1);
+    const minY = clamp(Math.floor(Math.min(ay, by, cy)) - 1, 0, patch.height - 1);
+    const maxY = clamp(Math.ceil(Math.max(ay, by, cy)) + 1, 0, patch.height - 1);
+    for (let py = minY; py <= maxY; py += 1) {
+      for (let px = minX; px <= maxX; px += 1) {
+        const bary = barycentric2d(px, py, ax, ay, bx, by, cx, cy);
+        if (!bary) continue;
+        const [wa, wb, wc] = bary;
+        if (wa < -1e-6 || wb < -1e-6 || wc < -1e-6) continue;
+        point.copy(a).multiplyScalar(wa).addScaledVector(b, wb).addScaledVector(c, wc);
+        const value = measurement.measureAtPoint(measurementContext, point, patch.normal);
+        if (value == null) continue;
+        const texelX = patch.x + px;
+        const texelY = patch.y + py;
+        if (texelX < 0 || texelY < 0 || texelX >= textureWidth || texelY >= textureHeight) continue;
+        values[texelY * textureWidth + texelX] = value;
+      }
+    }
+  }
+}
+function fillPatchHoles(values, width, patch, fill) {
+  const minX = patch.x;
+  const minY = patch.y;
+  const maxX = patch.x + patch.width;
+  const maxY = patch.y + patch.height;
+  for (let pass = 0; pass < Math.max(8, patch.width, patch.height); pass += 1) {
+    let changed = false;
+    for (let y = minY; y < maxY; y += 1) {
+      for (let x = minX; x < maxX; x += 1) {
+        const idx = y * width + x;
+        if (Number.isFinite(values[idx])) continue;
+        let sum = 0;
+        let count = 0;
+        for (let dy = -1; dy <= 1; dy += 1) {
+          for (let dx = -1; dx <= 1; dx += 1) {
+            if (dx === 0 && dy === 0) continue;
+            const xx = x + dx;
+            const yy = y + dy;
+            if (xx < minX || yy < minY || xx >= maxX || yy >= maxY) continue;
+            const value = values[yy * width + xx];
+            if (!Number.isFinite(value)) continue;
+            sum += value;
+            count += 1;
+          }
+        }
+        if (count > 0) {
+          values[idx] = sum / count;
+          changed = true;
+        }
+      }
+    }
+    if (!changed) break;
+  }
+  for (let y = minY; y < maxY; y += 1) {
+    for (let x = minX; x < maxX; x += 1) {
+      const idx = y * width + x;
+      if (!Number.isFinite(values[idx])) values[idx] = fill;
+    }
+  }
+}
+function fillUnusedTextureCells(values, fill) {
+  for (let i = 0; i < values.length; i += 1) {
+    if (!Number.isFinite(values[i])) values[i] = fill;
+  }
+}
+function valueRange(values) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const value of values) {
+    if (!Number.isFinite(value)) continue;
+    if (value < min) min = value;
+    if (value > max) max = value;
+  }
+  return Number.isFinite(min) && Number.isFinite(max) ? { min, max } : { min: 0, max: 0 };
+}
+function sampleNearest(values, width, height, u, v) {
+  const x = clamp(Math.round(u * width - 0.5), 0, width - 1);
+  const y = clamp(Math.round(v * height - 0.5), 0, height - 1);
+  return values[y * width + x];
+}
+function buildCreaseAwareRenderNormals(position) {
+  const normals = new Float32Array(position.count * 3);
+  const a = new Vector3();
+  const b = new Vector3();
+  const c = new Vector3();
+  const face = new Vector3();
+  const box = new Box3();
+  for (let i = 0; i < position.count; i += 1) {
+    box.expandByPoint(vertexAt(position, i, a));
+  }
+  const size = new Vector3();
+  box.getSize(size);
+  const tolerance = Math.max(size.length() * 1e-5, Number.EPSILON);
+  const inv = 1 / tolerance;
+  const buckets = /* @__PURE__ */ new Map();
+  for (let tri = 0; tri < Math.floor(position.count / 3); tri += 1) {
+    vertexAt(position, tri * 3, a);
+    vertexAt(position, tri * 3 + 1, b);
+    vertexAt(position, tri * 3 + 2, c);
+    face.subVectors(b, a).cross(c.clone().sub(a)).normalize();
+    for (let corner = 0; corner < 3; corner += 1) {
+      const vi = tri * 3 + corner;
+      vertexAt(position, vi, a);
+      const key = `${Math.round(a.x * inv)},${Math.round(a.y * inv)},${Math.round(a.z * inv)}`;
+      let groups = buckets.get(key);
+      if (!groups) {
+        groups = [];
+        buckets.set(key, groups);
+      }
+      let group = groups.find((candidate) => candidate.normal.dot(face) >= CREASE_NORMAL_DOT);
+      if (!group) {
+        group = { normal: face.clone(), vertices: [] };
+        groups.push(group);
+      } else {
+        group.normal.add(face).normalize();
+      }
+      group.vertices.push(vi);
+    }
+  }
+  for (const groups of buckets.values()) {
+    for (const group of groups) {
+      for (const vi of group.vertices) {
+        normals[vi * 3] = group.normal.x;
+        normals[vi * 3 + 1] = group.normal.y;
+        normals[vi * 3 + 2] = group.normal.z;
+      }
+    }
+  }
+  return normals;
+}
+function buildMeasuredSurfaceScalarField(sourceGeometry, rawOptions, fieldOptions = {}, context = {}, measurement) {
+  const options = measurement.resolveOptions(rawOptions);
+  const fieldGeometry = sourceGeometry.index ? sourceGeometry.toNonIndexed() : sourceGeometry;
+  try {
+    const position = fieldGeometry.getAttribute("position");
+    if (!position || position.count < 3) {
+      throw new Error(`${measurement.errorPrefix}: sourceGeometry must contain triangle positions`);
+    }
+    const triangleCount = Math.floor(position.count / 3);
+    const a = new Vector3();
+    const b = new Vector3();
+    const c = new Vector3();
+    let surfaceArea = 0;
+    for (let tri = 0; tri < triangleCount; tri += 1) {
+      surfaceArea += triangleMetrics(position, tri, a, b, c).area;
+    }
+    const sampleSpacing = surfaceArea > 0 ? Math.sqrt(surfaceArea / Math.max(1, options.maxSamplesPerObject)) : 1;
+    const { patches, patchByTri, width, height, capped } = packPatches(position, sampleSpacing, fieldOptions);
+    const values = new Float32Array(width * height);
+    values.fill(NaN);
+    const positions = new Float32Array(position.count * 3);
+    const normals = buildCreaseAwareRenderNormals(position);
+    const uvs = new Float32Array(position.count * 2);
+    const index = new Uint32Array(position.count);
+    const aValue = new Float32Array(position.count);
+    const measurementContext = measurement.createContext(fieldGeometry, rawOptions, context);
+    const point = new Vector3();
+    const normal = new Vector3();
+    const ab = new Vector3();
+    const ac = new Vector3();
+    try {
+      for (let i = 0; i < position.count; i += 1) {
+        vertexAt(position, i, point);
+        positions[i * 3] = point.x;
+        positions[i * 3 + 1] = point.y;
+        positions[i * 3 + 2] = point.z;
+        index[i] = i;
+      }
+      for (let tri = 0; tri < triangleCount; tri += 1) {
+        const patch = patchByTri[tri];
+        vertexAt(position, tri * 3, a);
+        vertexAt(position, tri * 3 + 1, b);
+        vertexAt(position, tri * 3 + 2, c);
+        if (patch.kind === "planar") {
+          setPlanarVertexUv(uvs, tri * 3, a, patch, width, height);
+          setPlanarVertexUv(uvs, tri * 3 + 1, b, patch, width, height);
+          setPlanarVertexUv(uvs, tri * 3 + 2, c, patch, width, height);
+          continue;
+        }
+        ab.subVectors(b, a);
+        ac.subVectors(c, a);
+        normal.copy(ab).cross(ac).normalize();
+        uvs[tri * 6] = (patch.x + PATCH_GUTTER + 0.5) / width;
+        uvs[tri * 6 + 1] = (patch.y + PATCH_GUTTER + 0.5) / height;
+        uvs[tri * 6 + 2] = (patch.x + PATCH_GUTTER + patch.inner + 0.5) / width;
+        uvs[tri * 6 + 3] = (patch.y + PATCH_GUTTER + 0.5) / height;
+        uvs[tri * 6 + 4] = (patch.x + PATCH_GUTTER + 0.5) / width;
+        uvs[tri * 6 + 5] = (patch.y + PATCH_GUTTER + patch.inner + 0.5) / height;
+        for (let py = 0; py < patch.side; py += 1) {
+          for (let px = 0; px < patch.side; px += 1) {
+            const [u, v] = triangleParamForTexel(px, py, patch.inner);
+            point.copy(a).addScaledVector(ab, u).addScaledVector(ac, v);
+            const value = measurement.measureAtPoint(measurementContext, point, normal);
+            const texel = (patch.y + py) * width + patch.x + px;
+            if (value != null) values[texel] = value;
+          }
+        }
+      }
+      for (const patch of patches) {
+        if (patch.kind === "planar") rasterizePlanarPatch(values, width, height, patch, position, measurement, measurementContext);
+      }
+    } finally {
+      measurementContext.dispose();
+    }
+    const range = valueRange(values);
+    for (const patch of patches) fillPatchHoles(values, width, patch, range.min);
+    const finalRange = valueRange(values);
+    fillUnusedTextureCells(values, finalRange.min);
+    for (let i = 0; i < position.count; i += 1) {
+      aValue[i] = sampleNearest(values, width, height, uvs[i * 2], uvs[i * 2 + 1]);
+    }
+    return {
+      positions,
+      normals,
+      index,
+      values: aValue,
+      valueMin: finalRange.min,
+      valueMax: finalRange.max,
+      capped,
+      degenerate: false,
+      holeCount: 0,
+      vertexCount: position.count,
+      uvs,
+      textureValues: values,
+      textureWidth: width,
+      textureHeight: height
+    };
+  } finally {
+    if (fieldGeometry !== sourceGeometry) fieldGeometry.dispose();
+  }
+}
+function buildThicknessSurfaceScalarField(sourceGeometry, rawOptions = {}, fieldOptions = {}, context = {}) {
+  return buildMeasuredSurfaceScalarField(sourceGeometry, rawOptions, fieldOptions, context, {
+    errorPrefix: "buildThicknessSurfaceScalarField",
+    resolveOptions: resolveThicknessInspectionOptions,
+    createContext: createThicknessRaycastContext,
+    measureAtPoint: measureThicknessAtPoint
+  });
+}
+function makeThroughThicknessTarget(sourceGeometry, rayMaterial) {
+  const geometry = sourceGeometry.clone();
+  const bvh = new MeshBVH(geometry);
+  geometry.boundsTree = bvh;
+  const mesh = new Mesh(geometry, rayMaterial);
+  mesh.raycast = acceleratedRaycast;
+  return { mesh, geometry, bvh };
+}
+function geometryMaxDimension(geometry) {
+  geometry.computeBoundingBox();
+  const box = geometry.boundingBox;
+  if (!box) return 1;
+  const size = new Vector3();
+  box.getSize(size);
+  return Math.max(1, size.x, size.y, size.z);
+}
+function resolveThroughThicknessInspectionOptions(raw = {}) {
+  return resolveThicknessInspectionOptions(raw);
+}
+function createThroughThicknessContext(sourceGeometry, rawOptions = {}, context = {}) {
+  const options = resolveThroughThicknessInspectionOptions(rawOptions);
+  const connectedGeometries = context.connectedGeometries ?? [];
+  const maxDim = Math.max(geometryMaxDimension(sourceGeometry), ...connectedGeometries.map(geometryMaxDimension));
+  const epsilon = Math.max(1e-4, maxDim * 1e-6);
+  const far = Math.max(maxDim * 4, options.maxThickness * 4, 1);
   const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
-  const rayTargets = [
-    { mesh: new Mesh(geometry, rayMaterial), jumpable: false },
-    ...connectedGeometries.map((connectedGeometry) => ({
-      mesh: new Mesh(connectedGeometry, rayMaterial),
-      jumpable: true
-    }))
+  const targets = [
+    makeThroughThicknessTarget(sourceGeometry, rayMaterial),
+    ...connectedGeometries.map((geometry) => makeThroughThicknessTarget(geometry, rayMaterial))
   ];
-  const rayTargetMeshes = rayTargets.map((target) => target.mesh);
-  const jumpableMeshes = new Set(rayTargets.filter((target) => target.jumpable).map((target) => target.mesh));
-  const raycaster = new Raycaster();
-  if (surfaceTriangles.length === 0) {
-    warnings.push("No non-degenerate triangle surface was available for thickness sampling.");
-  } else if (surfaceSamples.length < surfaceTriangles.length) {
-    warnings.push(
-      `Area sampling budget ${surfaceSamples.length} covers ${surfaceTriangles.length} surface triangles; increase --thickness-samples for denser analysis.`
-    );
-  }
-  const sampledTriangleIndexes = /* @__PURE__ */ new Set();
-  for (const sample of surfaceSamples) {
-    sampledTriangleIndexes.add(sample.triangle.index);
-    const thickness = triangleThickness(
-      raycaster,
-      rayTargetMeshes,
-      jumpableMeshes,
-      sample.position,
-      sample.normal,
-      epsilon,
-      far,
-      options.contactTolerance
-    );
-    samples.push({ thickness, area: sample.area });
-    const previous = triangleThicknessValues[sample.triangle.index];
-    if (previous === void 0 || previous == null || thickness != null && thickness < previous) {
-      triangleThicknessValues[sample.triangle.index] = thickness;
+  return {
+    raycaster: new Raycaster(),
+    targets,
+    epsilon,
+    far,
+    contactTolerance: options.contactTolerance,
+    minInwardDot: 1e-5,
+    dispose: () => {
+      targets.forEach((target) => target.geometry.dispose());
+      rayMaterial.dispose();
     }
-    pointSamples.push({
-      position: [sample.position.x, sample.position.y, sample.position.z],
-      normal: [sample.normal.x, sample.normal.y, sample.normal.z],
-      value: thickness,
-      className: thicknessClass(thickness, options),
-      color: thicknessColor(thickness, options),
-      area: sample.area
+  };
+}
+function firstRayHitDistance(context, point, direction) {
+  const origin = point.clone().addScaledVector(direction, context.epsilon);
+  context.raycaster.set(origin, direction);
+  context.raycaster.near = context.epsilon;
+  context.raycaster.far = context.far;
+  const hits = context.raycaster.intersectObjects(
+    context.targets.map((target) => target.mesh),
+    false
+  );
+  const minDistance = Math.max(context.epsilon, context.contactTolerance);
+  for (const hit of hits) {
+    if (hit.distance <= minDistance) continue;
+    return hit.distance + context.epsilon;
+  }
+  return null;
+}
+function boxDistanceToPointSq(box, point) {
+  const x = point.x < box.min.x ? box.min.x - point.x : point.x > box.max.x ? point.x - box.max.x : 0;
+  const y = point.y < box.min.y ? box.min.y - point.y : point.y > box.max.y ? point.y - box.max.y : 0;
+  const z = point.z < box.min.z ? box.min.z - point.z : point.z > box.max.z ? point.z - box.max.z : 0;
+  return x * x + y * y + z * z;
+}
+function candidateTravelsThroughMaterial(context, point, normal, candidate, candidateDistance) {
+  if (candidateDistance <= Math.max(context.epsilon, context.contactTolerance)) return false;
+  const direction = candidate.clone().sub(point).multiplyScalar(1 / candidateDistance);
+  if (direction.dot(normal) >= -1e-5) return false;
+  const firstHit = firstRayHitDistance(context, point, direction);
+  if (firstHit == null) return false;
+  const tolerance = Math.max(context.contactTolerance, context.epsilon * 8);
+  return Math.abs(firstHit - candidateDistance) <= tolerance;
+}
+function measureThroughThicknessAtPoint(context, point, normal) {
+  let bestDistanceSq = Infinity;
+  const closest = new Vector3();
+  const candidate = new Vector3();
+  for (const target of context.targets) {
+    target.bvh.shapecast({
+      boundsTraverseOrder: (box) => boxDistanceToPointSq(box, point),
+      intersectsBounds: (box) => boxDistanceToPointSq(box, point) < bestDistanceSq,
+      intersectsTriangle: (triangle) => {
+        triangle.closestPointToPoint(point, candidate);
+        const distanceSq = candidate.distanceToSquared(point);
+        if (distanceSq >= bestDistanceSq) return;
+        const distance = Math.sqrt(distanceSq);
+        if (!candidateTravelsThroughMaterial(context, point, normal, candidate, distance)) return;
+        bestDistanceSq = distanceSq;
+        closest.copy(candidate);
+      }
     });
   }
-  for (let tri = 0; tri < triangleCount; tri += 1) {
-    const color = thicknessColor(triangleThicknessValues[tri], options);
-    const offset = tri * 3;
-    for (let vertex = 0; vertex < 3; vertex += 1) {
-      const colorOffset = (offset + vertex) * 3;
-      colors[colorOffset] = color[0] / 255;
-      colors[colorOffset + 1] = color[1] / 255;
-      colors[colorOffset + 2] = color[2] / 255;
+  return Number.isFinite(bestDistanceSq) ? closest.distanceTo(point) : null;
+}
+function cloneGeometryForFaceColors(geometry) {
+  return geometry.index ? geometry.toNonIndexed() : geometry.clone();
+}
+function analyzeThroughThicknessGeometry(sourceGeometry, rawOptions = {}, context = {}) {
+  const options = resolveThroughThicknessInspectionOptions(rawOptions);
+  const geometry = cloneGeometryForFaceColors(sourceGeometry);
+  const position = geometry.getAttribute("position");
+  if (!position || position.count < 3) {
+    return {
+      geometry,
+      samples: [],
+      pointSamples: [],
+      triangleCount: 0,
+      sampledTriangleCount: 0,
+      sampleStride: 1,
+      warnings: ["No triangle geometry."]
+    };
+  }
+  const triangleCount = Math.floor(position.count / 3);
+  const surfaceTriangles = readSurfaceTriangles(position);
+  const surfaceSamples = sampleSurfaceTriangles(surfaceTriangles, options.maxSamplesPerObject);
+  const samples = [];
+  const pointSamples = [];
+  const warnings = [];
+  const throughContext = createThroughThicknessContext(geometry, options, context);
+  try {
+    if (surfaceTriangles.length === 0) {
+      warnings.push("No non-degenerate triangle surface was available for through-thickness sampling.");
+    } else if (surfaceSamples.length < surfaceTriangles.length) {
+      warnings.push(
+        `Area sampling budget ${surfaceSamples.length} covers ${surfaceTriangles.length} surface triangles; increase --thickness-samples for denser analysis.`
+      );
+    }
+    const sampledTriangleIndexes = /* @__PURE__ */ new Set();
+    for (const sample of surfaceSamples) {
+      sampledTriangleIndexes.add(sample.triangle.index);
+      const throughThickness = measureThroughThicknessAtPoint(throughContext, sample.position, sample.normal);
+      samples.push({ thickness: throughThickness, area: sample.area });
+      pointSamples.push({
+        position: [sample.position.x, sample.position.y, sample.position.z],
+        normal: [sample.normal.x, sample.normal.y, sample.normal.z],
+        value: throughThickness,
+        className: thicknessClass(throughThickness, options),
+        color: thicknessColor(throughThickness, options),
+        area: sample.area
+      });
+    }
+    return {
+      geometry,
+      samples,
+      pointSamples,
+      triangleCount,
+      sampledTriangleCount: sampledTriangleIndexes.size,
+      sampleStride: Math.max(1, Math.ceil(Math.max(1, surfaceTriangles.length) / Math.max(1, sampledTriangleIndexes.size))),
+      warnings
+    };
+  } finally {
+    throughContext.dispose();
+  }
+}
+const DEFAULT_VERTEX_CAP = 2e6;
+const DEFAULT_TARGET_EDGE_SPACING_FACTOR = 2;
+const DEFAULT_K = 8;
+const DEFAULT_GATE_DOT = 0.3;
+const CREASE_WELD_DOT = Math.SQRT1_2;
+const SCATTER_CELL_SPACING_FACTOR = 1.5;
+const SCATTER_RADIUS_SPACING_FACTOR = 3;
+const IDW_DISTANCE_FLOOR = 1e-9;
+const MAX_SUBDIVISION_PASSES = 24;
+function subVec(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function crossVec(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function dotVec(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function lenVec(a) {
+  return Math.hypot(a[0], a[1], a[2]);
+}
+function getVert(positions, i) {
+  const o = i * 3;
+  return [positions[o], positions[o + 1], positions[o + 2]];
+}
+function triArea(positions, a, b, c) {
+  const va = getVert(positions, a);
+  return 0.5 * lenVec(crossVec(subVec(getVert(positions, b), va), subVec(getVert(positions, c), va)));
+}
+function triNormal(positions, a, b, c) {
+  const va = getVert(positions, a);
+  const n = crossVec(subVec(getVert(positions, b), va), subVec(getVert(positions, c), va));
+  const l = lenVec(n) || 1;
+  return [n[0] / l, n[1] / l, n[2] / l];
+}
+function edgeLen(positions, a, b) {
+  return lenVec(subVec(getVert(positions, a), getVert(positions, b)));
+}
+function maxEdge(positions, a, b, c) {
+  return Math.max(edgeLen(positions, a, b), edgeLen(positions, b, c), edgeLen(positions, c, a));
+}
+function weld(positions) {
+  if (positions.length % 9 !== 0) {
+    throw new Error(`weld: positions length must be a multiple of 9 (9 floats per triangle), got ${positions.length}`);
+  }
+  positions.length / 3;
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  for (let i = 0; i < positions.length; i += 3) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
+      throw new Error(`weld: non-finite vertex position at float index ${i}`);
+    }
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (z < minZ) minZ = z;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+    if (z > maxZ) maxZ = z;
+  }
+  const diagonal = Math.hypot(maxX - minX, maxY - minY, maxZ - minZ);
+  const tolerance = Math.max(diagonal * 1e-5, Number.EPSILON);
+  const remap = /* @__PURE__ */ new Map();
+  const out = [];
+  const tris = [];
+  const weldNormals = [];
+  const inv = 1 / tolerance;
+  const quantKey = (i) => {
+    const qx = Math.round(positions[i] * inv);
+    const qy = Math.round(positions[i + 1] * inv);
+    const qz = Math.round(positions[i + 2] * inv);
+    return `${qx},${qy},${qz}`;
+  };
+  for (let tri = 0; tri < positions.length; tri += 9) {
+    const faceNormal = rawTriangleNormal(positions, tri);
+    const idx = [];
+    for (let corner = 0; corner < 3; corner += 1) {
+      const o = tri + corner * 3;
+      const key = quantKey(o);
+      const bucket = remap.get(key);
+      let vi;
+      if (bucket) {
+        for (const candidate of bucket) {
+          if (dotVec(weldNormals[candidate], faceNormal) >= CREASE_WELD_DOT) {
+            vi = candidate;
+            weldNormals[candidate] = normalizedSum(weldNormals[candidate], faceNormal);
+            break;
+          }
+        }
+      }
+      if (vi === void 0) {
+        vi = out.length / 3;
+        out.push(positions[o], positions[o + 1], positions[o + 2]);
+        weldNormals.push(faceNormal);
+        if (bucket) {
+          bucket.push(vi);
+        } else {
+          remap.set(key, [vi]);
+        }
+      }
+      idx.push(vi);
+    }
+    if (idx[0] !== idx[1] && idx[1] !== idx[2] && idx[2] !== idx[0]) {
+      tris.push(idx[0], idx[1], idx[2]);
     }
   }
-  geometry.setAttribute("color", new BufferAttribute(colors, 3));
-  rayMaterial.dispose();
+  const distinctVertexCount = out.length / 3;
+  const degenerate = distinctVertexCount < 3 || tris.length === 0;
+  return { positions: out, tris, degenerate };
+}
+function rawTriangleNormal(positions, triOffset) {
+  const ax = positions[triOffset];
+  const ay = positions[triOffset + 1];
+  const az = positions[triOffset + 2];
+  const bx = positions[triOffset + 3];
+  const by = positions[triOffset + 4];
+  const bz = positions[triOffset + 5];
+  const cx = positions[triOffset + 6];
+  const cy = positions[triOffset + 7];
+  const cz = positions[triOffset + 8];
+  const ab = [bx - ax, by - ay, bz - az];
+  const ac = [cx - ax, cy - ay, cz - az];
+  const n = crossVec(ab, ac);
+  const length = lenVec(n);
+  if (!(length > 0)) return [0, 0, 0];
+  return [n[0] / length, n[1] / length, n[2] / length];
+}
+function normalizedSum(a, b) {
+  const sum = [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+  const length = lenVec(sum);
+  if (!(length > 0)) return a;
+  return [sum[0] / length, sum[1] / length, sum[2] / length];
+}
+function adaptiveSubdivide(mesh, targetEdge, vertexCap) {
+  requirePositiveFiniteNumber(targetEdge, "adaptiveSubdivide targetEdge");
+  requireIntegerAtLeast(vertexCap, "adaptiveSubdivide vertexCap", 3);
+  const positions = mesh.positions.slice();
+  let tris = mesh.tris.slice();
+  let capped = false;
+  const keyOf = (a, b) => a < b ? `${a}_${b}` : `${b}_${a}`;
+  for (let pass = 0; pass < MAX_SUBDIVISION_PASSES; pass += 1) {
+    const next = [];
+    const midCache = /* @__PURE__ */ new Map();
+    let changed = false;
+    const getMid = (a, b) => {
+      const key = keyOf(a, b);
+      let mi = midCache.get(key);
+      if (mi === void 0) {
+        mi = positions.length / 3;
+        const ao = a * 3;
+        const bo = b * 3;
+        positions.push(
+          (positions[ao] + positions[bo]) / 2,
+          (positions[ao + 1] + positions[bo + 1]) / 2,
+          (positions[ao + 2] + positions[bo + 2]) / 2
+        );
+        midCache.set(key, mi);
+      }
+      return mi;
+    };
+    for (let t = 0; t < tris.length; t += 3) {
+      const a = tris[t];
+      const b = tris[t + 1];
+      const c = tris[t + 2];
+      const vertexCount = positions.length / 3;
+      if (maxEdge(positions, a, b, c) > targetEdge && vertexCount < vertexCap) {
+        const ab = getMid(a, b);
+        const bc = getMid(b, c);
+        const ca = getMid(c, a);
+        next.push(a, ab, ca, ab, b, bc, ca, bc, c, ab, bc, ca);
+        changed = true;
+      } else {
+        if (positions.length / 3 >= vertexCap) capped = true;
+        next.push(a, b, c);
+      }
+    }
+    tris = next;
+    if (!changed) break;
+  }
+  return { positions, tris, capped };
+}
+function vertexNormals(mesh) {
+  const vertexCount = mesh.positions.length / 3;
+  const acc = new Float32Array(vertexCount * 3);
+  for (let t = 0; t < mesh.tris.length; t += 3) {
+    const a = mesh.tris[t];
+    const b = mesh.tris[t + 1];
+    const c = mesh.tris[t + 2];
+    const n = triNormal(mesh.positions, a, b, c);
+    const area = triArea(mesh.positions, a, b, c);
+    const nx = n[0] * area;
+    const ny = n[1] * area;
+    const nz = n[2] * area;
+    for (const vi of [a, b, c]) {
+      acc[vi * 3] += nx;
+      acc[vi * 3 + 1] += ny;
+      acc[vi * 3 + 2] += nz;
+    }
+  }
+  for (let i = 0; i < vertexCount; i += 1) {
+    const o = i * 3;
+    const l = Math.hypot(acc[o], acc[o + 1], acc[o + 2]) || 1;
+    acc[o] /= l;
+    acc[o + 1] /= l;
+    acc[o + 2] /= l;
+  }
+  return acc;
+}
+function buildSampleGrid(positions, cell) {
+  const grid = /* @__PURE__ */ new Map();
+  const sampleCount = positions.length / 3;
+  for (let i = 0; i < sampleCount; i += 1) {
+    const o = i * 3;
+    const key = `${Math.floor(positions[o] / cell)},${Math.floor(positions[o + 1] / cell)},${Math.floor(positions[o + 2] / cell)}`;
+    let arr = grid.get(key);
+    if (!arr) {
+      arr = [];
+      grid.set(key, arr);
+    }
+    arr.push(i);
+  }
+  return { grid, cell };
+}
+function gatherSamples(sampleGrid, p, rings, out) {
+  out.length = 0;
+  const { cell, grid } = sampleGrid;
+  const bx = Math.floor(p[0] / cell);
+  const by = Math.floor(p[1] / cell);
+  const bz = Math.floor(p[2] / cell);
+  for (let dx = -rings; dx <= rings; dx += 1) {
+    for (let dy = -rings; dy <= rings; dy += 1) {
+      for (let dz = -rings; dz <= rings; dz += 1) {
+        const arr = grid.get(`${bx + dx},${by + dy},${bz + dz}`);
+        if (arr) for (const i of arr) out.push(i);
+      }
+    }
+  }
+}
+function scatterToVertices(positions, vnormals, samples, spacing, k, gateDot, normalGateMode = "signed") {
+  const cell = spacing * SCATTER_CELL_SPACING_FACTOR;
+  const sampleGrid = buildSampleGrid(samples.positions, cell);
+  const radius = spacing * SCATTER_RADIUS_SPACING_FACTOR;
+  const radius2 = radius * radius;
+  const vertexCount = positions.length / 3;
+  const values = new Float32Array(vertexCount);
+  let holeCount = 0;
+  const candidates = [];
+  const scratchP = [0, 0, 0];
+  const bestD2 = new Float64Array(k);
+  const bestVal = new Float64Array(k);
+  for (let vi = 0; vi < vertexCount; vi += 1) {
+    const pi = vi * 3;
+    const px = positions[pi];
+    const py = positions[pi + 1];
+    const pz = positions[pi + 2];
+    const nx = vnormals[pi];
+    const ny = vnormals[pi + 1];
+    const nz = vnormals[pi + 2];
+    scratchP[0] = px;
+    scratchP[1] = py;
+    scratchP[2] = pz;
+    gatherSamples(sampleGrid, scratchP, 3, candidates);
+    let count = 0;
+    let worst = 0;
+    let worstD2 = -Infinity;
+    for (let c = 0; c < candidates.length; c += 1) {
+      const si = candidates[c];
+      const so = si * 3;
+      const dx = samples.positions[so] - px;
+      const dy = samples.positions[so + 1] - py;
+      const dz = samples.positions[so + 2] - pz;
+      const d2 = dx * dx + dy * dy + dz * dz;
+      if (d2 > radius2) continue;
+      const normalDot = samples.normals[so] * nx + samples.normals[so + 1] * ny + samples.normals[so + 2] * nz;
+      if ((normalGateMode === "absolute" ? Math.abs(normalDot) : normalDot) < gateDot) continue;
+      const val = samples.values[si];
+      if (count < k) {
+        bestD2[count] = d2;
+        bestVal[count] = val;
+        if (d2 > worstD2) {
+          worstD2 = d2;
+          worst = count;
+        }
+        count += 1;
+      } else if (d2 < worstD2) {
+        bestD2[worst] = d2;
+        bestVal[worst] = val;
+        worstD2 = -Infinity;
+        for (let t = 0; t < k; t += 1) {
+          if (bestD2[t] > worstD2) {
+            worstD2 = bestD2[t];
+            worst = t;
+          }
+        }
+      }
+    }
+    if (count === 0) {
+      holeCount += 1;
+      values[vi] = NaN;
+      continue;
+    }
+    let w = 0;
+    let accum = 0;
+    for (let t = 0; t < count; t += 1) {
+      const ww = 1 / Math.max(bestD2[t], IDW_DISTANCE_FLOOR);
+      w += ww;
+      accum += ww * bestVal[t];
+    }
+    values[vi] = accum / w;
+  }
+  return { values, holeCount };
+}
+function backfillScalarFieldHoles(values, mesh) {
+  const vertexCount = values.length;
+  const adjacency = Array.from({ length: vertexCount }, () => []);
+  for (let t = 0; t < mesh.tris.length; t += 3) {
+    const a = mesh.tris[t];
+    const b = mesh.tris[t + 1];
+    const c = mesh.tris[t + 2];
+    adjacency[a].push(b, c);
+    adjacency[b].push(a, c);
+    adjacency[c].push(a, b);
+  }
+  let frontier = [];
+  for (let i = 0; i < vertexCount; i += 1) {
+    if (Number.isFinite(values[i])) frontier.push(i);
+  }
+  if (frontier.length === 0) {
+    values.fill(0);
+    return;
+  }
+  while (frontier.length > 0) {
+    const nextFrontier = [];
+    for (const v of frontier) {
+      const val = values[v];
+      for (const n of adjacency[v]) {
+        if (!Number.isFinite(values[n])) {
+          values[n] = val;
+          nextFrontier.push(n);
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+}
+function reconstructSurfaceScalarField(trianglePositions, samples, options = {}) {
+  if (!(trianglePositions instanceof Float32Array)) {
+    throw new Error("reconstructSurfaceScalarField: trianglePositions must be a Float32Array");
+  }
+  if (trianglePositions.length === 0 || trianglePositions.length % 9 !== 0) {
+    throw new Error(
+      `reconstructSurfaceScalarField: trianglePositions length must be a positive multiple of 9, got ${trianglePositions.length}`
+    );
+  }
+  if (!(samples.positions instanceof Float32Array) || !(samples.values instanceof Float32Array) || !(samples.normals instanceof Float32Array)) {
+    throw new Error("reconstructSurfaceScalarField: samples positions/values/normals must be Float32Arrays");
+  }
+  const sampleCount = samples.values.length;
+  if (sampleCount === 0) {
+    throw new Error("reconstructSurfaceScalarField: samples must be non-empty");
+  }
+  if (samples.positions.length !== sampleCount * 3) {
+    throw new Error(
+      `reconstructSurfaceScalarField: samples.positions length ${samples.positions.length} must equal values*3 (${sampleCount * 3})`
+    );
+  }
+  if (samples.normals.length !== sampleCount * 3) {
+    throw new Error(
+      `reconstructSurfaceScalarField: samples.normals length ${samples.normals.length} must equal values*3 (${sampleCount * 3})`
+    );
+  }
+  for (let i = 0; i < sampleCount; i += 1) {
+    requireFiniteNumber(samples.values[i], `samples.values[${i}]`);
+  }
+  const vertexCap = options.vertexCap === void 0 ? DEFAULT_VERTEX_CAP : requireIntegerAtLeast(options.vertexCap, "vertexCap", 3);
+  const targetEdgeSpacingFactor = options.targetEdgeSpacingFactor === void 0 ? DEFAULT_TARGET_EDGE_SPACING_FACTOR : requirePositiveFiniteNumber(options.targetEdgeSpacingFactor, "targetEdgeSpacingFactor");
+  const k = options.k === void 0 ? DEFAULT_K : requireIntegerAtLeast(options.k, "k", 1);
+  const gateDot = options.gateDot === void 0 ? DEFAULT_GATE_DOT : requireFiniteNumber(options.gateDot, "gateDot");
+  const normalGateMode = options.normalGateMode ?? "signed";
+  if (normalGateMode !== "signed" && normalGateMode !== "absolute") {
+    throw new Error(`reconstructSurfaceScalarField: normalGateMode must be 'signed' or 'absolute', got '${normalGateMode}'`);
+  }
+  const welded = weld(trianglePositions);
+  let surfaceArea = 0;
+  for (let t = 0; t < welded.tris.length; t += 3) {
+    surfaceArea += triArea(welded.positions, welded.tris[t], welded.tris[t + 1], welded.tris[t + 2]);
+  }
+  const sampleSpacing = surfaceArea > 0 ? Math.sqrt(surfaceArea / sampleCount) : 0;
+  let subdivided;
+  if (welded.degenerate || !(sampleSpacing > 0)) {
+    subdivided = { positions: welded.positions, tris: welded.tris, capped: false };
+  } else {
+    const targetEdge = targetEdgeSpacingFactor * sampleSpacing;
+    subdivided = adaptiveSubdivide(welded, targetEdge, vertexCap);
+  }
+  const normals = vertexNormals(subdivided);
+  const effectiveSpacing = sampleSpacing > 0 ? sampleSpacing : 1;
+  const scatter = scatterToVertices(subdivided.positions, normals, samples, effectiveSpacing, k, gateDot, normalGateMode);
+  let valueMin = Infinity;
+  let valueMax = -Infinity;
+  for (let i = 0; i < scatter.values.length; i += 1) {
+    const v = scatter.values[i];
+    if (!Number.isFinite(v)) continue;
+    if (v < valueMin) valueMin = v;
+    if (v > valueMax) valueMax = v;
+  }
+  if (!Number.isFinite(valueMin) || !Number.isFinite(valueMax)) {
+    valueMin = 0;
+    valueMax = 0;
+  }
+  backfillScalarFieldHoles(scatter.values, subdivided);
+  const vertexCount = subdivided.positions.length / 3;
   return {
-    geometry,
-    samples,
-    pointSamples,
-    triangleCount,
-    sampledTriangleCount: sampledTriangleIndexes.size,
-    sampleStride: Math.max(1, Math.ceil(Math.max(1, surfaceTriangles.length) / Math.max(1, sampledTriangleIndexes.size))),
-    warnings
+    positions: Float32Array.from(subdivided.positions),
+    normals,
+    index: Uint32Array.from(subdivided.tris),
+    values: scatter.values,
+    valueMin,
+    valueMax,
+    capped: subdivided.capped,
+    degenerate: welded.degenerate,
+    holeCount: scatter.holeCount,
+    vertexCount
   };
 }
+function stressSurfaceToScalarSamples(surface) {
+  const positions = new Float32Array(surface.samples.length * 3);
+  const normals = new Float32Array(surface.samples.length * 3);
+  const values = new Float32Array(surface.samples.length);
+  surface.samples.forEach((sample, index) => {
+    const base = index * 3;
+    positions[base] = sample.position[0];
+    positions[base + 1] = sample.position[1];
+    positions[base + 2] = sample.position[2];
+    normals[base] = sample.normal[0];
+    normals[base + 1] = sample.normal[1];
+    normals[base + 2] = sample.normal[2];
+    values[index] = sample.value;
+  });
+  return { positions, normals, values };
+}
 const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
   smoothAngleDeg: 5,
   sharpAngleDeg: 30,
@@ -1605,13 +2792,15 @@ function percentile(sorted, q) {
   return Number(sorted[index].toFixed(2));
 }
 const DEG_PER_RAD = 180 / Math.PI;
+const ROUGHNESS_HOTSPOT_LIMIT = 16;
+const ROUGHNESS_HOTSPOT_RADIUS_FRACTION = 0.03;
 function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
   const options = resolveRoughnessInspectionOptions(rawOptions);
   const geometry = sourceGeometry.index ? sourceGeometry.toNonIndexed() : sourceGeometry.clone();
   const position = geometry.getAttribute("position");
   const warnings = [];
   if (!position || position.count < 3) {
-    return { geometry, pointSamples: [], summary: emptyRoughnessSummary(), warnings: ["No triangle geometry."] };
+    return { geometry, pointSamples: [], hotSpots: [], summary: emptyRoughnessSummary(), warnings: ["No triangle geometry."] };
   }
   const triangleCount = Math.floor(position.count / 3);
   const normals = new Array(triangleCount);
@@ -1684,16 +2873,66 @@ function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
       area: sample.area
     };
   });
+  const hotSpots = selectRoughnessHotSpots(pointSamples, bbox, options.sharpAngleDeg);
   geometry.setAttribute("color", new BufferAttribute(colors, 3));
   geometry.setAttribute("roughnessScore", new BufferAttribute(scores, 1));
   geometry.computeBoundingBox();
   return {
     geometry,
     pointSamples,
+    hotSpots,
     summary: summarizeRoughnessTriangles(triangles, edgeAngles, edges.size, boundaryEdgeCount, nonManifoldEdgeCount, options),
     warnings
   };
 }
+function selectRoughnessHotSpots(samples, bbox, minAngleDeg) {
+  const size = bbox.getSize(new Vector3());
+  const clusterRadius = Math.max(size.length() * ROUGHNESS_HOTSPOT_RADIUS_FRACTION, 1e-6);
+  const clusterRadiusSq = clusterRadius * clusterRadius;
+  const candidates = samples.filter((sample) => sample.value !== null && Number.isFinite(sample.value) && sample.value >= minAngleDeg).sort((lhs, rhs) => {
+    const valueDelta = (rhs.value ?? -Infinity) - (lhs.value ?? -Infinity);
+    if (Math.abs(valueDelta) > 1e-9) return valueDelta;
+    return (rhs.area ?? 0) - (lhs.area ?? 0);
+  });
+  const clusters = [];
+  for (const candidate of candidates) {
+    const cluster = clusters.find((entry) => squaredDistance(candidate.position, entry.representative.position) <= clusterRadiusSq);
+    if (cluster) {
+      cluster.count += 1;
+      cluster.area += candidate.area ?? 0;
+      const value = candidate.value ?? -Infinity;
+      if (value > cluster.peakValue) {
+        cluster.peakValue = value;
+        cluster.representative = candidate;
+      }
+      continue;
+    }
+    clusters.push({
+      representative: candidate,
+      peakValue: candidate.value ?? 0,
+      count: 1,
+      area: candidate.area ?? 0
+    });
+  }
+  return clusters.sort((lhs, rhs) => {
+    const valueDelta = rhs.peakValue - lhs.peakValue;
+    if (Math.abs(valueDelta) > 1e-9) return valueDelta;
+    if (rhs.count !== lhs.count) return rhs.count - lhs.count;
+    return rhs.area - lhs.area;
+  }).slice(0, ROUGHNESS_HOTSPOT_LIMIT).map((cluster, index) => ({
+    ...cluster.representative,
+    rank: index + 1,
+    clusterRadius,
+    nearbySampleCount: cluster.count,
+    nearbyArea: Number(cluster.area.toFixed(6))
+  }));
+}
+function squaredDistance(a, b) {
+  const dx = a[0] - b[0];
+  const dy = a[1] - b[1];
+  const dz = a[2] - b[2];
+  return dx * dx + dy * dy + dz * dz;
+}
 function markTriangleRoughness(edges, triangles, normals, triangleEdgeAngles) {
   const edgeAngles = [];
   let boundaryEdgeCount = 0;
@@ -2001,6 +3240,16 @@ function createCaptureDebugLogger(enabled) {
     console.info(`[forge-capture:debug] +${sinceStart}ms Δ${delta}ms ${phase}${detailText}`);
   };
 }
+function setInspectProfileEnabled(enabled) {
+  window.__forgeInspectProfile = enabled === true;
+}
+function inspectProfileEnabled() {
+  return window.__forgeInspectProfile === true;
+}
+function inspectProfileLog(phase, detail) {
+  if (!inspectProfileEnabled()) return;
+  console.info(`[forge-inspect-profile] ${phase} ${JSON.stringify(detail)}`);
+}
 class EmptyInspectionShape {
   intersect() {
     return {
@@ -3675,28 +4924,120 @@ function bboxFromGeometry(geometry) {
     max: bbox ? [bbox.max.x, bbox.max.y, bbox.max.z] : [0, 0, 0]
   };
 }
-function pointBuffersFromSamples(samples, colorScale, offset = 0.025) {
-  const positions = new Float32Array(samples.length * 3);
-  const colors = new Float32Array(samples.length * 3);
-  samples.forEach((sample, index) => {
+const SCALAR_SURFACE_VERTEX_CAP = 2e6;
+const SCALAR_SURFACE_TARGET_EDGE_SPACING_FACTOR = 8;
+function scalarSamplesFromPointSamples(samples) {
+  const finite = samples.filter((sample) => sample.value != null && Number.isFinite(sample.value));
+  const positions = new Float32Array(finite.length * 3);
+  const values = new Float32Array(finite.length);
+  const normals = new Float32Array(finite.length * 3);
+  finite.forEach((sample, index) => {
     const base = index * 3;
-    positions[base] = sample.position[0] + sample.normal[0] * offset;
-    positions[base + 1] = sample.position[1] + sample.normal[1] * offset;
-    positions[base + 2] = sample.position[2] + sample.normal[2] * offset;
-    if (colorScale && sample.value != null && Number.isFinite(sample.value)) {
-      const [r, g, b] = sampleColorScale(colorScale, sample.value);
-      colors[base] = r / 255;
-      colors[base + 1] = g / 255;
-      colors[base + 2] = b / 255;
-    } else {
-      colors[base] = sample.color[0] / 255;
-      colors[base + 1] = sample.color[1] / 255;
-      colors[base + 2] = sample.color[2] / 255;
+    positions[base] = sample.position[0];
+    positions[base + 1] = sample.position[1];
+    positions[base + 2] = sample.position[2];
+    normals[base] = sample.normal[0];
+    normals[base + 1] = sample.normal[1];
+    normals[base + 2] = sample.normal[2];
+    values[index] = sample.value;
+  });
+  return { positions, values, normals };
+}
+const DEFAULT_SCALAR_FIELD_PARAMS = {
+  quantizeBands: 0,
+  isoEnabled: false,
+  isoSpacing: 0,
+  isoLineWidthPx: 1.5,
+  criticalEnabled: false,
+  criticalThreshold: 0,
+  shadingEnabled: true
+};
+function mergeScalarFieldParams(override) {
+  if (!override) return DEFAULT_SCALAR_FIELD_PARAMS;
+  const merged = { ...DEFAULT_SCALAR_FIELD_PARAMS };
+  if (override.quantizeBands !== void 0) {
+    const bands = override.quantizeBands;
+    if (!Number.isInteger(bands) || bands < 0) {
+      throw new RangeError(`Heatmap band count must be a non-negative integer, got ${bands}.`);
+    }
+    merged.quantizeBands = bands;
+  }
+  if (override.isoEnabled !== void 0) {
+    merged.isoEnabled = override.isoEnabled;
+  }
+  if (merged.isoEnabled && merged.isoSpacing <= 0) {
+    merged.isoSpacing = DEFAULT_INSPECT_ISOLINE_SPACING;
+  }
+  if (override.isoLineWidthPx !== void 0) {
+    const width = override.isoLineWidthPx;
+    if (!Number.isFinite(width) || width <= 0) {
+      throw new RangeError(`Heatmap isoline width must be a finite positive number of pixels, got ${width}.`);
     }
+    merged.isoLineWidthPx = width;
+  }
+  return merged;
+}
+function scalarFieldColorOverride(override) {
+  return {
+    colormap: override == null ? void 0 : override.colormap,
+    reversed: (override == null ? void 0 : override.reversed) === true
+  };
+}
+function scalarSurfaceOverlayFromField(renderable, field, domain, fieldParams, colorOverride = {}) {
+  const colormap = colorOverride.colormap ?? DEFAULT_COLORMAP;
+  const reversed = colorOverride.reversed === true ? { reversed: true } : {};
+  const colorScale = domain ? { colormap, domainMin: domain.min, domainMax: domain.max, ...reversed } : {
+    colormap,
+    domainMin: field.valueMin,
+    domainMax: field.valueMax > field.valueMin ? field.valueMax : field.valueMin + 1,
+    ...reversed
+  };
+  return {
+    overlay: {
+      renderable,
+      positions: field.positions,
+      normals: field.normals,
+      index: field.index,
+      aValue: field.values,
+      uvs: "uvs" in field ? field.uvs : void 0,
+      textureValues: "textureValues" in field ? field.textureValues : void 0,
+      textureWidth: "textureWidth" in field ? field.textureWidth : void 0,
+      textureHeight: "textureHeight" in field ? field.textureHeight : void 0,
+      colorScale,
+      fieldParams
+    },
+    capped: field.capped,
+    holeCount: field.holeCount
+  };
+}
+function buildScalarSurfaceOverlayFromSamples(renderable, trianglePositions, scalarSamples, domain, fieldParams, fieldOptions = {}, colorOverride = {}) {
+  const started = performance.now();
+  if (scalarSamples.values.length === 0) return null;
+  const reconstructStarted = performance.now();
+  const field = reconstructSurfaceScalarField(trianglePositions, scalarSamples, {
+    vertexCap: SCALAR_SURFACE_VERTEX_CAP,
+    targetEdgeSpacingFactor: SCALAR_SURFACE_TARGET_EDGE_SPACING_FACTOR,
+    ...fieldOptions
   });
-  return { positions, colors };
+  const reconstructMs = performance.now() - reconstructStarted;
+  inspectProfileLog("scalar-overlay", {
+    object: renderable.name,
+    samples: scalarSamples.values.length,
+    inputTriangles: trianglePositions.length / 9,
+    vertices: field.vertexCount,
+    capped: field.capped,
+    holes: field.holeCount,
+    reconstructMs: Number(reconstructMs.toFixed(1)),
+    totalMs: Number((performance.now() - started).toFixed(1))
+  });
+  return scalarSurfaceOverlayFromField(renderable, field, domain, fieldParams, colorOverride);
+}
+function buildScalarSurfaceOverlay(renderable, trianglePositions, samples, domain, fieldParams) {
+  const scalarSamples = scalarSamplesFromPointSamples(samples);
+  return buildScalarSurfaceOverlayFromSamples(renderable, trianglePositions, scalarSamples, domain, fieldParams);
 }
-function renderScalarPointOverlays(session, overlays) {
+function renderScalarSurfaceOverlays(session, overlays) {
+  const started = performance.now();
   const r = getRenderer(session.size, session.pixelRatio);
   const overlayById = new Map(overlays.map((overlay) => [overlay.renderable.id, overlay]));
   const replacements = session.renderables.map((renderable) => {
@@ -3713,49 +5054,98 @@ function renderScalarPointOverlays(session, overlays) {
     ghostMaterial.toneMapped = false;
     renderable.solid.material = ghostMaterial;
     const overlay = overlayById.get(renderable.id);
-    if (!overlay || overlay.positions.length === 0)
-      return { renderable, previousMaterial, ghostMaterial, points: null, geometry: null, material: null };
+    const previousVisible = renderable.solid.visible;
+    if (overlay) renderable.solid.visible = false;
+    if (!overlay || overlay.positions.length === 0) {
+      return {
+        renderable,
+        previousMaterial,
+        previousVisible,
+        ghostMaterial,
+        mesh: null,
+        geometry: null,
+        material: null,
+        lut: null,
+        scalarTexture: null
+      };
+    }
     const geometry = new BufferGeometry();
     geometry.setAttribute("position", new BufferAttribute(overlay.positions, 3));
-    geometry.setAttribute("color", new BufferAttribute(overlay.colors, 3));
-    const material = new PointsMaterial({
-      size: 3,
-      sizeAttenuation: false,
-      vertexColors: true,
-      depthTest: true,
-      depthWrite: false,
-      clippingPlanes: renderable.solidMaterial.clippingPlanes ?? void 0
+    geometry.setAttribute("normal", new BufferAttribute(overlay.normals, 3));
+    geometry.setAttribute("aValue", new BufferAttribute(overlay.aValue, 1));
+    geometry.setAttribute("uv", new BufferAttribute(overlay.uvs ?? new Float32Array(overlay.positions.length / 3 * 2), 2));
+    geometry.setIndex(new BufferAttribute(overlay.index, 1));
+    const lut = makeColorScaleTexture(colorScaleLUT(overlay.colorScale.colormap));
+    trackTextureDecode(lut);
+    const scalarTexture = overlay.textureValues && overlay.textureWidth && overlay.textureHeight ? makeScalarValueTexture(overlay.textureValues, overlay.textureWidth, overlay.textureHeight) : null;
+    if (scalarTexture) trackTextureDecode(scalarTexture);
+    const uniforms = makeInspectScalarUniforms({
+      colorScale: lut,
+      scalarTexture,
+      domainMin: overlay.colorScale.domainMin,
+      domainMax: overlay.colorScale.domainMax,
+      colorScaleReversed: overlay.colorScale.reversed === true,
+      quantizeBands: overlay.fieldParams.quantizeBands,
+      isoEnabled: overlay.fieldParams.isoEnabled,
+      isoSpacing: overlay.fieldParams.isoSpacing,
+      isoLineWidthPx: overlay.fieldParams.isoLineWidthPx,
+      criticalEnabled: overlay.fieldParams.criticalEnabled,
+      criticalThreshold: overlay.fieldParams.criticalThreshold,
+      shadingEnabled: overlay.fieldParams.shadingEnabled
+    });
+    const clippingPlanes = renderable.solidMaterial.clippingPlanes ?? void 0;
+    const material = new ShaderMaterial({
+      vertexShader: INSPECT_SCALAR_VERTEX_SHADER,
+      fragmentShader: INSPECT_SCALAR_FRAGMENT_SHADER,
+      uniforms,
+      side: DoubleSide,
+      clippingPlanes,
+      // Engage the shader's `#include <clipping_planes_*>` chunks only when section
+      // planes are actually present (NUM_CLIPPING_PLANES define is gated on this),
+      // so heatmap surfaces honor section cuts the same as the ghosted solid does.
+      clipping: Boolean(clippingPlanes && clippingPlanes.length > 0)
     });
     material.toneMapped = false;
-    const points = new Points(geometry, material);
-    points.renderOrder = 5;
-    points.raycast = () => null;
-    renderable.root.add(points);
-    return { renderable, previousMaterial, ghostMaterial, points, geometry, material };
+    const mesh = new Mesh(geometry, material);
+    mesh.renderOrder = 5;
+    mesh.raycast = () => null;
+    renderable.root.add(mesh);
+    return { renderable, previousMaterial, previousVisible, ghostMaterial, mesh, geometry, material, lut, scalarTexture };
   });
   try {
-    return withSolidOnlyVisibility(
+    const png = withSolidOnlyVisibility(
       session,
       () => withTemporarySceneBackground(session, new Color(0), () => {
         r.render(session.scene, session.camera);
         return captureRenderedPng(session.size);
       })
     );
-  } finally {
-    replacements.forEach(({ renderable, previousMaterial, ghostMaterial, points, geometry, material }) => {
-      if (points) renderable.root.remove(points);
-      renderable.solid.material = previousMaterial;
-      ghostMaterial.dispose();
-      geometry == null ? void 0 : geometry.dispose();
-      material == null ? void 0 : material.dispose();
+    inspectProfileLog("scalar-render", {
+      overlays: overlays.length,
+      totalMs: Number((performance.now() - started).toFixed(1))
     });
+    return png;
+  } finally {
+    replacements.forEach(
+      ({ renderable, previousMaterial, previousVisible, ghostMaterial, mesh, geometry, material, lut, scalarTexture }) => {
+        if (mesh) renderable.root.remove(mesh);
+        renderable.solid.material = previousMaterial;
+        renderable.solid.visible = previousVisible;
+        ghostMaterial.dispose();
+        geometry == null ? void 0 : geometry.dispose();
+        material == null ? void 0 : material.dispose();
+        lut == null ? void 0 : lut.dispose();
+        scalarTexture == null ? void 0 : scalarTexture.dispose();
+      }
+    );
   }
 }
-function getSessionThicknessInspection(session, rawOptions) {
+function getSessionThicknessInspection(session, rawOptions, fieldOverride) {
   var _a;
   const resolvedOptions = resolveThicknessInspectionOptions(rawOptions);
   const { options, sampleBudget } = withSceneSampleBudget(session, resolvedOptions, (rawOptions == null ? void 0 : rawOptions.maxSamplesPerObject) !== void 0);
-  const optionsKey = inspectionOptionsKey({ options, sampleBudget });
+  const fieldParams = { ...mergeScalarFieldParams(fieldOverride), shadingEnabled: false };
+  const optionsKey = inspectionOptionsKey({ options, sampleBudget, fieldParams });
   if (((_a = session.thicknessInspection) == null ? void 0 : _a.optionsKey) === optionsKey) return session.thicknessInspection;
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   const warnings = [];
@@ -3763,17 +5153,30 @@ function getSessionThicknessInspection(session, rawOptions) {
   const thicknessColorScale = {
     colormap: DEFAULT_THICKNESS_COLOR_SCALE.colormap,
     domainMin: options.colorMinThickness,
-    domainMax: options.colorMaxThickness
+    domainMax: options.colorMaxThickness,
+    ...{ reversed: true }
   };
   const objects = [];
   const cloudObjects = [];
   const points = [];
   const overlays = [];
+  const connectivityStarted = performance.now();
   const raycastConnectivity = buildThicknessRaycastConnectivityContext(session);
+  inspectProfileLog("thickness-connectivity", {
+    ms: Number((performance.now() - connectivityStarted).toFixed(1)),
+    neighborSets: raycastConnectivity.neighborIdsByObjectId.size
+  });
   session.renderables.forEach((renderable, index) => {
     const sourceObject = byId.get(renderable.id);
-    const analysis = analyzeThicknessGeometry(renderable.solid.geometry, options, {
-      connectedGeometries: connectedThicknessGeometriesFor(raycastConnectivity, renderable)
+    const connectedGeometries = connectedThicknessGeometriesFor(raycastConnectivity, renderable);
+    const analysisStarted = performance.now();
+    const analysis = analyzeThicknessGeometry(renderable.solid.geometry, options, { connectedGeometries });
+    inspectProfileLog("thickness-analysis", {
+      object: renderable.name,
+      samples: analysis.pointSamples.length,
+      triangles: analysis.triangleCount,
+      connectedGeometries: connectedGeometries.length,
+      ms: Number((performance.now() - analysisStarted).toFixed(1))
     });
     const bbox = bboxFromGeometry(analysis.geometry);
     const summary = summarizeThicknessSamples(analysis.samples, options);
@@ -3812,7 +5215,34 @@ function getSessionThicknessInspection(session, rawOptions) {
         ...sample
       });
     });
-    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples, thicknessColorScale) });
+    if (analysis.pointSamples.length > 0) {
+      const scalarStarted = performance.now();
+      const field = buildThicknessSurfaceScalarField(analysis.geometry, options, {}, { connectedGeometries });
+      inspectProfileLog("thickness-scalar-overlay", {
+        object: renderable.name,
+        vertices: field.vertexCount,
+        capped: field.capped,
+        holes: field.holeCount,
+        ms: Number((performance.now() - scalarStarted).toFixed(1))
+      });
+      const built = scalarSurfaceOverlayFromField(
+        renderable,
+        field,
+        { min: thicknessColorScale.domainMin, max: thicknessColorScale.domainMax },
+        fieldParams
+      );
+      overlays.push(built.overlay);
+      if (built.capped) {
+        warnings.push(
+          `${renderable.name}: scalar surface hit the ${SCALAR_SURFACE_VERTEX_CAP.toLocaleString()} vertex cap; raise the sample budget or reduce object size for full resolution.`
+        );
+      }
+      if (built.holeCount > 0) {
+        warnings.push(
+          `${renderable.name}: ${built.holeCount} scalar texture samples had ambiguous edge thickness (filled from neighboring texels).`
+        );
+      }
+    }
     analysis.geometry.dispose();
   });
   const state = {
@@ -3835,9 +5265,6 @@ function getSessionThicknessInspection(session, rawOptions) {
       objects,
       warnings,
       style: {
-        // gradientColors is the legacy 'thickness-classic' rainbow, kept for
-        // back-compat. colorScale is the truth the viewport/CLI now render with.
-        gradientColors: THICKNESS_GRADIENT_COLORS.map((color) => [...color]),
         colorScale: thicknessColorScale,
         colorMinThickness: options.colorMinThickness,
         colorMaxThickness: options.colorMaxThickness,
@@ -3848,26 +5275,228 @@ function getSessionThicknessInspection(session, rawOptions) {
   session.thicknessInspection = state;
   return state;
 }
-function renderCurrentThickness(session, rawOptions) {
-  const state = getSessionThicknessInspection(session, rawOptions);
-  return { png: renderScalarPointOverlays(session, state.overlays), report: state.report, pointCloud: state.pointCloud };
+function renderCurrentThickness(session, rawOptions, fieldOverride) {
+  const state = getSessionThicknessInspection(session, rawOptions, fieldOverride);
+  return { png: renderScalarSurfaceOverlays(session, state.overlays), report: state.report, pointCloud: state.pointCloud };
+}
+function getSessionThroughThicknessInspection(session, rawOptions, fieldOverride) {
+  var _a;
+  const resolvedOptions = resolveThicknessInspectionOptions(rawOptions);
+  const { options, sampleBudget } = withSceneSampleBudget(session, resolvedOptions, (rawOptions == null ? void 0 : rawOptions.maxSamplesPerObject) !== void 0);
+  const fieldParams = { ...mergeScalarFieldParams(fieldOverride), shadingEnabled: false };
+  const optionsKey = inspectionOptionsKey({ options, sampleBudget, fieldParams });
+  if (((_a = session.throughThicknessInspection) == null ? void 0 : _a.optionsKey) === optionsKey) return session.throughThicknessInspection;
+  const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
+  const warnings = [];
+  maybePushSceneSampleBudgetWarning(warnings, "Minimum solid span", sampleBudget);
+  const colorScale = {
+    colormap: DEFAULT_THICKNESS_COLOR_SCALE.colormap,
+    domainMin: options.colorMinThickness,
+    domainMax: options.colorMaxThickness,
+    ...{ reversed: true }
+  };
+  const objects = [];
+  const cloudObjects = [];
+  const points = [];
+  const overlays = [];
+  const connectivityStarted = performance.now();
+  const raycastConnectivity = buildThicknessRaycastConnectivityContext(session);
+  inspectProfileLog("through-thickness-connectivity", {
+    ms: Number((performance.now() - connectivityStarted).toFixed(1)),
+    neighborSets: raycastConnectivity.neighborIdsByObjectId.size
+  });
+  session.renderables.forEach((renderable, index) => {
+    const sourceObject = byId.get(renderable.id);
+    const connectedGeometries = connectedThicknessGeometriesFor(raycastConnectivity, renderable);
+    const analysisStarted = performance.now();
+    const analysis = analyzeThroughThicknessGeometry(renderable.solid.geometry, options, { connectedGeometries });
+    inspectProfileLog("through-thickness-analysis", {
+      object: renderable.name,
+      samples: analysis.pointSamples.length,
+      triangles: analysis.triangleCount,
+      connectedGeometries: connectedGeometries.length,
+      ms: Number((performance.now() - analysisStarted).toFixed(1))
+    });
+    const bbox = bboxFromGeometry(analysis.geometry);
+    const summary = summarizeThicknessSamples(analysis.samples, options);
+    if (analysis.warnings.length > 0) {
+      analysis.warnings.forEach((warning) => warnings.push(`${renderable.name}: ${warning}`));
+    }
+    const objectIndex = index + 1;
+    objects.push({
+      index: objectIndex,
+      id: renderable.id,
+      name: renderable.name,
+      groupName: renderable.groupName,
+      treePath: sourceObject == null ? void 0 : sourceObject.treePath,
+      mock: (sourceObject == null ? void 0 : sourceObject.mock) === true,
+      triangleCount: analysis.triangleCount,
+      sampledTriangleCount: analysis.sampledTriangleCount,
+      sampleStride: analysis.sampleStride,
+      bbox,
+      ...summary
+    });
+    cloudObjects.push({
+      index: objectIndex,
+      id: renderable.id,
+      name: renderable.name,
+      groupName: renderable.groupName,
+      treePath: sourceObject == null ? void 0 : sourceObject.treePath,
+      mock: (sourceObject == null ? void 0 : sourceObject.mock) === true,
+      sampleCount: analysis.pointSamples.length,
+      bbox
+    });
+    analysis.pointSamples.forEach((sample) => {
+      points.push({
+        objectIndex,
+        objectId: renderable.id,
+        objectName: renderable.name,
+        ...sample
+      });
+    });
+    if (analysis.pointSamples.length > 0) {
+      const trianglePositions = cloneGeometryPositions(analysis.geometry);
+      if (trianglePositions) {
+        const built = buildScalarSurfaceOverlay(
+          renderable,
+          trianglePositions,
+          analysis.pointSamples,
+          { min: colorScale.domainMin, max: colorScale.domainMax },
+          fieldParams
+        );
+        if (built) {
+          overlays.push(built.overlay);
+          if (built.capped) {
+            warnings.push(
+              `${renderable.name}: scalar surface hit the ${SCALAR_SURFACE_VERTEX_CAP.toLocaleString()} vertex cap; raise the sample budget or reduce object size for full resolution.`
+            );
+          }
+          if (built.holeCount > 0) {
+            warnings.push(
+              `${renderable.name}: ${built.holeCount} surface vertices had no finite minimum-solid-span sample nearby (filled by nearest neighbor).`
+            );
+          }
+        }
+      }
+    }
+    analysis.geometry.dispose();
+  });
+  const state = {
+    optionsKey,
+    overlays,
+    pointCloud: {
+      schemaVersion: 1,
+      property: "throughThickness",
+      coordinateSpace: "object-local",
+      units: "model",
+      sampleCount: points.length,
+      objects: cloudObjects,
+      points
+    },
+    report: {
+      method: "mesh-nearest-through-boundary-bvh",
+      options,
+      sampleBudget,
+      objectCount: objects.length,
+      objects,
+      warnings,
+      style: {
+        colorScale,
+        colorMinThickness: options.colorMinThickness,
+        colorMaxThickness: options.colorMaxThickness,
+        unknownColor: THICKNESS_COLORS.unknown
+      }
+    }
+  };
+  session.throughThicknessInspection = state;
+  return state;
+}
+function renderCurrentThroughThickness(session, rawOptions, fieldOverride) {
+  const state = getSessionThroughThicknessInspection(session, rawOptions, fieldOverride);
+  return { png: renderScalarSurfaceOverlays(session, state.overlays), report: state.report, pointCloud: state.pointCloud };
 }
 const ROUGHNESS_SMOOTH_OPACITY = 0.16;
 const ROUGHNESS_HARSH_OPACITY = 1;
-function renderCurrentRoughness(session, rawOptions) {
-  const state = getSessionRoughnessInspection(session, rawOptions);
-  return { png: renderScalarPointOverlays(session, state.overlays), report: state.report, pointCloud: state.pointCloud };
+function renderCurrentRoughness(session, rawOptions, fieldOverride) {
+  const state = getSessionRoughnessInspection(session, rawOptions, fieldOverride);
+  return { png: renderScalarSurfaceOverlays(session, state.overlays), report: state.report, pointCloud: state.pointCloud };
+}
+function stressSamplesForRenderable(surface, renderable, useAllSamples) {
+  const samples = useAllSamples ? surface.samples : surface.samples.filter((sample) => sample.partName === renderable.name || sample.partName === renderable.groupName);
+  if (samples.length === 0) return null;
+  return { ...surface, samples };
+}
+function renderCurrentStressSurface(session, surface, fieldOverride) {
+  var _a;
+  const fieldParams = mergeScalarFieldParams(fieldOverride);
+  const colorOverride = scalarFieldColorOverride(fieldOverride);
+  const overlays = [];
+  const warnings = [];
+  const useAllSamples = session.renderables.length === 1;
+  const domain = {
+    min: surface.domain.min,
+    max: surface.domain.max > surface.domain.min ? surface.domain.max : surface.domain.min + 1
+  };
+  for (const renderable of session.renderables) {
+    const scopedSurface = stressSamplesForRenderable(surface, renderable, useAllSamples);
+    if (!scopedSurface) continue;
+    const trianglePositions = (_a = renderable.solid.geometry.getAttribute("position")) == null ? void 0 : _a.array;
+    if (!(trianglePositions instanceof Float32Array)) {
+      warnings.push(`${renderable.name}: rendered geometry has no Float32Array position buffer for stress heatmap.`);
+      continue;
+    }
+    const built = buildScalarSurfaceOverlayFromSamples(
+      renderable,
+      trianglePositions,
+      stressSurfaceToScalarSamples(scopedSurface),
+      domain,
+      fieldParams,
+      { normalGateMode: "absolute" },
+      colorOverride
+    );
+    if (!built) continue;
+    overlays.push(built.overlay);
+    if (built.capped) {
+      throw new Error(
+        `${renderable.name}: scalar surface hit the ${SCALAR_SURFACE_VERTEX_CAP.toLocaleString()} vertex cap; refusing to render an incomplete stress heatmap.`
+      );
+    }
+    if (built.holeCount > 0) {
+      throw new Error(
+        `${renderable.name}: ${built.holeCount} surface vertices had no in-gate stress sample; refusing to render a filled stress heatmap.`
+      );
+    }
+  }
+  if (overlays.length === 0) {
+    throw new Error("Stress surface samples did not match any rendered model surface.");
+  }
+  return {
+    png: renderScalarSurfaceOverlays(session, overlays),
+    report: {
+      method: "solver-stress-surface-v1",
+      field: surface.field,
+      unit: surface.unit,
+      coordinateSpace: surface.coordinateSpace,
+      sampleCount: surface.samples.length,
+      valueMin: surface.valueMin,
+      valueMax: surface.valueMax,
+      hotSpots: surface.hotSpots,
+      warnings
+    }
+  };
 }
-function getSessionRoughnessInspection(session, rawOptions) {
+function getSessionRoughnessInspection(session, rawOptions, fieldOverride) {
   var _a;
   const resolvedOptions = resolveRoughnessInspectionOptions(rawOptions);
   const { options, sampleBudget } = withSceneSampleBudget(session, resolvedOptions, (rawOptions == null ? void 0 : rawOptions.maxSamplesPerObject) !== void 0);
-  const optionsKey = inspectionOptionsKey({ options, sampleBudget });
+  const fieldParams = mergeScalarFieldParams(fieldOverride);
+  const optionsKey = inspectionOptionsKey({ options, sampleBudget, fieldParams });
   if (((_a = session.roughnessInspection) == null ? void 0 : _a.optionsKey) === optionsKey) return session.roughnessInspection;
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   const warnings = [];
   maybePushSceneSampleBudgetWarning(warnings, "Roughness", sampleBudget);
   const objects = [];
+  const hotSpotCandidates = [];
   const cloudObjects = [];
   const points = [];
   const overlays = [];
@@ -3886,6 +5515,7 @@ function getSessionRoughnessInspection(session, rawOptions) {
   });
   const roughnessColorScale = Number.isFinite(roughnessMin) && roughnessMax > roughnessMin ? { colormap: DEFAULT_ROUGHNESS_COLOR_SCALE.colormap, domainMin: roughnessMin, domainMax: roughnessMax } : DEFAULT_ROUGHNESS_COLOR_SCALE;
   session.renderables.forEach((renderable, index) => {
+    var _a2;
     const analysis = analysesByIndex[index];
     const bbox = bboxFromGeometry(analysis.geometry);
     const sourceObject = byId.get(renderable.id);
@@ -3921,9 +5551,42 @@ function getSessionRoughnessInspection(session, rawOptions) {
         ...sample
       });
     });
-    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples, roughnessColorScale) });
+    analysis.hotSpots.forEach((hotSpot) => {
+      hotSpotCandidates.push({
+        ...hotSpot,
+        rank: 0,
+        objectRank: hotSpot.rank,
+        objectIndex,
+        objectId: renderable.id,
+        objectName: renderable.name
+      });
+    });
+    const trianglePositions = (_a2 = analysis.geometry.getAttribute("position")) == null ? void 0 : _a2.array;
+    if (trianglePositions instanceof Float32Array) {
+      const built = buildScalarSurfaceOverlay(renderable, trianglePositions, analysis.pointSamples, null, fieldParams);
+      if (built) {
+        overlays.push(built.overlay);
+        if (built.capped) {
+          warnings.push(
+            `${renderable.name}: scalar surface hit the ${SCALAR_SURFACE_VERTEX_CAP.toLocaleString()} vertex cap; raise the sample budget or reduce object size for full resolution.`
+          );
+        }
+        if (built.holeCount > 0) {
+          warnings.push(`${renderable.name}: ${built.holeCount} surface vertices had no in-gate sample (filled by nearest neighbor).`);
+        }
+      }
+    }
     analysis.geometry.dispose();
   });
+  const hotSpots = hotSpotCandidates.sort((lhs, rhs) => {
+    const valueDelta = (rhs.value ?? -Infinity) - (lhs.value ?? -Infinity);
+    if (Math.abs(valueDelta) > 1e-9) return valueDelta;
+    if (rhs.nearbySampleCount !== lhs.nearbySampleCount) return rhs.nearbySampleCount - lhs.nearbySampleCount;
+    const areaDelta = rhs.nearbyArea - lhs.nearbyArea;
+    if (Math.abs(areaDelta) > 1e-9) return areaDelta;
+    if (lhs.objectIndex !== rhs.objectIndex) return lhs.objectIndex - rhs.objectIndex;
+    return lhs.objectRank - rhs.objectRank;
+  }).map((hotSpot, index) => ({ ...hotSpot, rank: index + 1 }));
   const state = {
     optionsKey,
     overlays,
@@ -3942,6 +5605,7 @@ function getSessionRoughnessInspection(session, rawOptions) {
       sampleBudget,
       objectCount: objects.length,
       objects,
+      hotSpots,
       warnings,
       style: {
         // Legacy class colors kept for back-compat; colorScale is the truth the
@@ -5073,6 +6737,60 @@ Available renderable objects: ${available}`;
   }
   return "No visible renderable objects found.";
 }
+const PENDING_TEXTURE_DECODES = /* @__PURE__ */ new Set();
+function trackTextureDecode(texture) {
+  PENDING_TEXTURE_DECODES.add(textureDecoded(texture));
+}
+function textureDecoded(texture) {
+  return new Promise((resolve) => {
+    var _a;
+    const finish = () => {
+      texture.needsUpdate = true;
+      resolve();
+    };
+    const forgeDecoded = (_a = texture.userData) == null ? void 0 : _a.forgeDecoded;
+    if (forgeDecoded) {
+      forgeDecoded.then(
+        () => finish(),
+        () => finish()
+      );
+      return;
+    }
+    const image = texture.image;
+    if (image && typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+      finish();
+      return;
+    }
+    if (image && typeof image.decode === "function") {
+      image.decode().then(finish, finish);
+      return;
+    }
+    if (image && (image.naturalWidth > 0 || image.complete && image.width > 0)) {
+      finish();
+      return;
+    }
+    if (image && "onload" in image) {
+      const prevLoad = image.onload;
+      const prevError = image.onerror;
+      image.onload = (ev) => {
+        if (typeof prevLoad === "function") prevLoad.call(image, ev);
+        finish();
+      };
+      image.onerror = (ev) => {
+        if (typeof prevError === "function") prevError.call(image, ev);
+        finish();
+      };
+      return;
+    }
+    finish();
+  });
+}
+async function awaitPendingTextureDecodes() {
+  if (PENDING_TEXTURE_DECODES.size === 0) return;
+  const pending = Array.from(PENDING_TEXTURE_DECODES);
+  PENDING_TEXTURE_DECODES.clear();
+  await Promise.all(pending);
+}
 function createSession(code, opts) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
   const size = (opts == null ? void 0 : opts.size) ?? 1024;
@@ -5426,6 +7144,12 @@ Fix one:
         depthWrite: materialOpacity >= 0.99 && materialTransmission <= 0,
         clippingPlanes: applicableCutPlanes
       });
+      const textureDescriptor = mp == null ? void 0 : mp.texture;
+      if (textureDescriptor && solidMaterial instanceof MeshPhysicalMaterial) {
+        const projectedTexture = descriptorToThreeTexture(textureDescriptor.image, { colorSpace: "srgb" });
+        applyProjectedTexture(solidMaterial, textureDescriptor.projection, projectedTexture);
+        trackTextureDecode(projectedTexture);
+      }
       solid = new Mesh(geo.solid, solidMaterial);
       if (isScanRenderStyle) {
         const scanProxyGeometry = createScanProxyGeometry(geo.solid, { grid: scanProxyGrid ?? void 0 });
@@ -5572,6 +7296,7 @@ Fix one:
     collisionEntries,
     collisionReport: null,
     thicknessInspection: null,
+    throughThicknessInspection: null,
     roughnessInspection: null,
     joints,
     jointCouplings,
@@ -5618,6 +7343,7 @@ async function emitInspectProgress(opts, event) {
 }
 window.__forgeRender = async (code, opts) => {
   var _a, _b, _c;
+  setInspectProfileEnabled(opts == null ? void 0 : opts.debug);
   const requestedCameraTokens = (opts == null ? void 0 : opts.cameras) ?? (opts == null ? void 0 : opts.angles);
   const hasDirectionalCameraTokens = Array.isArray(requestedCameraTokens) && requestedCameraTokens.length > 0;
   if ((opts == null ? void 0 : opts.viewName) && hasDirectionalCameraTokens) {
@@ -5635,6 +7361,7 @@ window.__forgeRender = async (code, opts) => {
   const built = createSession(code, {
     size: (opts == null ? void 0 : opts.size) || 1024,
     pixelRatio: (opts == null ? void 0 : opts.pixelRatio) || 1,
+    debug: opts == null ? void 0 : opts.debug,
     quality: opts == null ? void 0 : opts.quality,
     allFiles: opts == null ? void 0 : opts.allFiles,
     binaryFiles: opts == null ? void 0 : opts.binaryFiles,
@@ -5654,7 +7381,7 @@ window.__forgeRender = async (code, opts) => {
     scanGranularity: opts == null ? void 0 : opts.scanGranularity,
     respectAuthoredSceneStyle: opts == null ? void 0 : opts.respectAuthoredSceneStyle,
     cutaway: (opts == null ? void 0 : opts.cutaway) ?? null,
-    includeConnectivity: requestedChannels.has("connectivity") || requestedChannels.has("floating") || requestedChannels.has("distance") || requestedChannels.has("thickness"),
+    includeConnectivity: requestedChannels.has("connectivity") || requestedChannels.has("floating") || requestedChannels.has("distance") || requestedChannels.has("throughThickness") || requestedChannels.has("thickness"),
     includeCollisions: requestedChannels.has("collisions"),
     capture: "orbit"
   });
@@ -5697,6 +7424,7 @@ window.__forgeRender = async (code, opts) => {
       return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
   }
+  await awaitPendingTextureDecodes();
   await emitInspectProgress(opts, { type: "session-done", objectCount: session.objects.length });
   const renderMode = (opts == null ? void 0 : opts.renderMode) === "wireframe" ? "wireframe" : "solid";
   const edgePreset = (opts == null ? void 0 : opts.edges) ?? "off";
@@ -5732,7 +7460,9 @@ window.__forgeRender = async (code, opts) => {
   const comparisonRenders = {};
   const collisionRenders = {};
   const thicknessRenders = {};
+  const throughThicknessRenders = {};
   const roughnessRenders = {};
+  const stressRenders = {};
   let maskObjects = [];
   let connectivityReport = null;
   let floatingReport = null;
@@ -5742,8 +7472,11 @@ window.__forgeRender = async (code, opts) => {
   let comparisonPointCloud = null;
   let collisionReport = null;
   let thicknessReport = null;
+  let throughThicknessReport = null;
   let roughnessReport = null;
+  let stressReport = null;
   let thicknessPointCloud = null;
+  let throughThicknessPointCloud = null;
   let roughnessPointCloud = null;
   let sectionEvidence = null;
   const framingViews = {};
@@ -5822,7 +7555,7 @@ window.__forgeRender = async (code, opts) => {
       }
       if (requestedChannels.has("roughness")) {
         await markChannelViewStart("roughness", label);
-        const roughness = renderCurrentRoughness(session, opts == null ? void 0 : opts.roughness);
+        const roughness = renderCurrentRoughness(session, opts == null ? void 0 : opts.roughness, opts == null ? void 0 : opts.scalarFieldParams);
         roughnessRenders[label] = roughness.png;
         roughnessReport = roughness.report;
         roughnessPointCloud = roughness.pointCloud;
@@ -5877,12 +7610,28 @@ window.__forgeRender = async (code, opts) => {
       }
       if (requestedChannels.has("thickness")) {
         await markChannelViewStart("thickness", label);
-        const thickness = renderCurrentThickness(session, opts == null ? void 0 : opts.thickness);
+        const thickness = renderCurrentThickness(session, opts == null ? void 0 : opts.thickness, opts == null ? void 0 : opts.scalarFieldParams);
         thicknessRenders[label] = thickness.png;
         thicknessReport = thickness.report;
         thicknessPointCloud = thickness.pointCloud;
         await markChannelViewDone("thickness", label);
       }
+      if (requestedChannels.has("stress")) {
+        if (!(opts == null ? void 0 : opts.stressSurface)) throw new Error("stress channel requires solver-produced stressSurface evidence.");
+        await markChannelViewStart("stress", label);
+        const stress = renderCurrentStressSurface(session, opts.stressSurface, opts.scalarFieldParams);
+        stressRenders[label] = stress.png;
+        stressReport = stress.report;
+        await markChannelViewDone("stress", label);
+      }
+      if (requestedChannels.has("throughThickness")) {
+        await markChannelViewStart("throughThickness", label);
+        const throughThickness = renderCurrentThroughThickness(session, opts == null ? void 0 : opts.thickness, opts == null ? void 0 : opts.scalarFieldParams);
+        throughThicknessRenders[label] = throughThickness.png;
+        throughThicknessReport = throughThickness.report;
+        throughThicknessPointCloud = throughThickness.pointCloud;
+        await markChannelViewDone("throughThickness", label);
+      }
     } catch (e) {
       if (comparisonSession) disposeSession(comparisonSession);
       disposeSession(session);
@@ -5991,6 +7740,19 @@ window.__forgeRender = async (code, opts) => {
     } : {
       views: thicknessRenders
     },
+    stress: stressReport ? {
+      ...stressReport,
+      views: stressRenders
+    } : {
+      views: stressRenders
+    },
+    throughThickness: throughThicknessReport ? {
+      ...throughThicknessReport,
+      pointCloud: throughThicknessPointCloud,
+      views: throughThicknessRenders
+    } : {
+      views: throughThicknessRenders
+    },
     section: sectionEvidence,
     bbox: session.bbox,
     volume: session.volume,
@@ -6022,6 +7784,7 @@ window.__forgeCaptureInit = async (code, opts) => {
   if (!built.ok) {
     return built;
   }
+  await awaitPendingTextureDecodes();
   captureSession = built.session;
   return {
     ok: true,