forgecad 0.10.4 → 0.11.0

package/dist/assets/cli/{render-XXol_ET7.js → render-CMNudGb0.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, bH as BoxGeometry, cm as MeshStandardMaterial, a5 as BackSide, bd as PointLight, M as Mesh, ab as MeshBasicMaterial, c$ as localAabbPlaneRelation, i as Vector2, d0 as ShapeUtils, d1 as analyzePhysicalConnectivity, h as Vector3, a0 as Matrix4, d2 as Frustum, J as Box3, a1 as MathUtils, d3 as meshContactDataFor, d4 as AabbSpatialIndex, d5 as detectPhysicalContact, d6 as resolveThicknessInspectionOptions, R as Raycaster, d7 as thicknessColor, d8 as thicknessClass, bf as BufferAttribute, bQ as MeshBVH, b_ as acceleratedRaycast, d9 as requireFiniteNumber, da as requireIntegerAtLeast, db as requirePositiveFiniteNumber, c_ as initBackendForEvaluation, f as Color, bh as COMPARISON_COLORS, aB as resolveForgeRenderStyle, bX as getRenderStylePreset, az as setParamOverrides, bw as runScript, cK as scanProxyGridForBounds, dc as Group, bl as shapeToGeometry, bx as MeshPhysicalMaterial, bO as AdditiveBlending, c1 as scanMaterialShellColor, bV as descriptorToThreeTexture, bW as applyProjectedTexture, dd as createScanProxyGeometry, b3 as LineBasicMaterial, bZ as NormalBlending, by as LineSegments, P as PerspectiveCamera, cH as DEFAULT_VIEW_CONFIG, bD as worldAuthorPlaneToLocal, de as resolveSectionHatchMetrics, cQ as buildGeometryComparisonPointCloud, cO as triangleSoupFromMeshes, O as OrthographicCamera, l as ShaderMaterial, c7 as ZEBRA_STRIPE_FRAGMENT_SHADER, c8 as ZEBRA_STRIPE_VERTEX_SHADER, c2 as ZEBRA_STRIPE_SOFTNESS, c3 as ZEBRA_STRIPE_SCALE, c4 as ZEBRA_LIGHT_COLOR, c5 as ZEBRA_DARK_COLOR, c6 as ZEBRA_ACCENT_COLOR, bP as geometryWithVisibleVertexColors, df as intersectWithPlane, dg as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, d as SRGBColorSpace, dh as parseCameraCliSpec, di 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, cb as SURFACE_FIELD_FRAGMENT_SHADER, cc as SURFACE_FIELD_VERTEX_SHADER, ca as scanMaterialLayerStyles, c9 as SCAN_PROXY_LAYER_STYLES, aX as resolveJointAnimation, aY as resolveJointViewValues, b2 as BufferGeometry, dj as DEFAULT_ROUGHNESS_COLOR_SCALE, bR as makeColorScaleTexture, bS as colorScaleLUT, bT as makeInspectScalarUniforms, b$ as INSPECT_SCALAR_FRAGMENT_SHADER, c0 as INSPECT_SCALAR_VERTEX_SHADER, bg as heatPointsForSide, dk as analyzeCollisionIntersections, dl as serializeCollisionFinding, dm as summarizeThicknessSamples, dn as THICKNESS_COLORS, dp as DEFAULT_THICKNESS_COLOR_SCALE, bc as SpotLight, cq as CylinderGeometry, dq as TorusGeometry, ce as CatmullRomCurve3, cf as TubeGeometry, cU as resolveScalarSceneSampleBudget, dr as DEFAULT_INSPECT_ISOLINE_SPACING, ch as DEFAULT_COLORMAP, bm as buildComparisonHeatPatchGeometry, bn as EdgesGeometry, ds as SphereGeometry, dt as ConeGeometry, bi as comparisonHeatDepthTest, bj as comparisonHeatEdgeOpacity, bk as comparisonHeatPatchOpacity, cY as comparisonCandidateContextOpacity, du as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../backendInit-6C0DLgH0.js";
-import { m as mergeViewportRenderSceneStates, v as validateJointOverrides, b as buildBaseJointValues, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../jointPose-B0blBj9A.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, d7 as localAabbPlaneRelation, i as Vector2, d8 as ShapeUtils, d9 as analyzePhysicalConnectivity, h as Vector3, a0 as Matrix4, da as Frustum, J as Box3, a1 as MathUtils, db as meshContactDataFor, dc as AabbSpatialIndex, dd as detectPhysicalContact, de as resolveThicknessInspectionOptions, df as thicknessColor, dg as thicknessClass, bf as BufferAttribute, R as Raycaster, bS as MeshBVH, c1 as acceleratedRaycast, dh as requireFiniteNumber, di as requireIntegerAtLeast, dj as requirePositiveFiniteNumber, d6 as initBackendForEvaluation, f as Color, bh as COMPARISON_COLORS, aB as resolveForgeRenderStyle, b_ as getRenderStylePreset, az as setParamOverrides, bw as runScript, cN as scanProxyGridForBounds, dk as Group, bl as shapeToGeometry, bx as MeshPhysicalMaterial, bQ as AdditiveBlending, c4 as scanMaterialShellColor, bY as descriptorToThreeTexture, bZ as applyProjectedTexture, dl as createScanProxyGeometry, b3 as LineBasicMaterial, c0 as NormalBlending, by as LineSegments, P as PerspectiveCamera, cK as DEFAULT_VIEW_CONFIG, bF as worldAuthorPlaneToLocal, dm as resolveSectionHatchMetrics, cY as buildGeometryComparisonPointCloud, cW 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, dn as intersectWithPlane, dp as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, d as SRGBColorSpace, dq as parseCameraCliSpec, dr 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, ds 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, dt as analyzeCollisionIntersections, du as serializeCollisionFinding, dv as summarizeThicknessSamples, dw as THICKNESS_COLORS, dx as DEFAULT_THICKNESS_COLOR_SCALE, dy as DEFAULT_INSPECT_ISOLINE_SPACING, bc as SpotLight, ct as CylinderGeometry, dz as TorusGeometry, ch as CatmullRomCurve3, ci as TubeGeometry, d0 as resolveScalarSceneSampleBudget, bm as buildComparisonHeatPatchGeometry, bn as EdgesGeometry, ck as DEFAULT_COLORMAP, dA as SphereGeometry, dB as ConeGeometry, bi as comparisonHeatDepthTest, bj as comparisonHeatEdgeOpacity, bk as comparisonHeatPatchOpacity, d4 as comparisonCandidateContextOpacity, dC as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../backendInit-6a9-ilom.js";
+import { m as mergeViewportRenderSceneStates, v as validateJointOverrides, b as buildBaseJointValues, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../jointPose-CFql5I-u.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,17 +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 makeThicknessRaycastTarget(sourceGeometry, rayMaterial, jumpable) {
+function makeThicknessRaycastTarget(sourceGeometry, rayMaterial) {
   const geometry = sourceGeometry.clone();
   geometry.boundsTree = new MeshBVH(geometry);
   const mesh = new Mesh(geometry, rayMaterial);
   mesh.raycast = acceleratedRaycast;
-  return { mesh, jumpable, geometry };
+  return { mesh, geometry };
 }
-function geometryMaxDimension(geometry) {
+function geometryMaxDimension$1(geometry) {
   geometry.computeBoundingBox();
   const box = geometry.boundingBox;
   if (!box) return 1;
@@ -1339,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,
@@ -1377,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 {
@@ -1395,24 +1419,13 @@ 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 rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
-  const rayTargets = [
-    makeThicknessRaycastTarget(geometry, rayMaterial, false),
-    ...connectedGeometries.map((connectedGeometry) => makeThicknessRaycastTarget(connectedGeometry, rayMaterial, true))
-  ];
+  const rayContext = createThicknessRaycastContext(geometry, options, context);
   try {
-    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) {
@@ -1423,16 +1436,7 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {})
     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
-      );
+      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) {
@@ -1468,14 +1472,743 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {})
       warnings
     };
   } finally {
-    rayTargets.forEach((target) => target.geometry.dispose());
-    rayMaterial.dispose();
+    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 targets = [
+    makeThroughThicknessTarget(sourceGeometry, rayMaterial),
+    ...connectedGeometries.map((geometry) => makeThroughThicknessTarget(geometry, rayMaterial))
+  ];
+  return {
+    raycaster: new Raycaster(),
+    targets,
+    epsilon,
+    far,
+    contactTolerance: options.contactTolerance,
+    minInwardDot: 1e-5,
+    dispose: () => {
+      targets.forEach((target) => target.geometry.dispose());
+      rayMaterial.dispose();
+    }
+  };
+}
+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);
+      }
+    });
+  }
+  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;
@@ -1486,6 +2219,9 @@ function subVec(a, b) {
 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]);
 }
@@ -1511,9 +2247,7 @@ function maxEdge(positions, a, b, c) {
 }
 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}`
-    );
+    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;
@@ -1541,6 +2275,7 @@ function weld(positions) {
   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);
@@ -1549,15 +2284,31 @@ function weld(positions) {
     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);
-      let vi = remap.get(key);
+      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]);
-        remap.set(key, vi);
+        weldNormals.push(faceNormal);
+        if (bucket) {
+          bucket.push(vi);
+        } else {
+          remap.set(key, [vi]);
+        }
       }
       idx.push(vi);
     }
@@ -1569,6 +2320,29 @@ function weld(positions) {
   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);
@@ -1674,7 +2448,7 @@ function gatherSamples(sampleGrid, p, rings, out) {
     }
   }
 }
-function scatterToVertices(positions, vnormals, samples, spacing, k, gateDot) {
+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;
@@ -1709,7 +2483,8 @@ function scatterToVertices(positions, vnormals, samples, spacing, k, gateDot) {
       const dz = samples.positions[so + 2] - pz;
       const d2 = dx * dx + dy * dy + dz * dz;
       if (d2 > radius2) continue;
-      if (samples.normals[so] * nx + samples.normals[so + 1] * ny + samples.normals[so + 2] * nz < gateDot) 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;
@@ -1737,17 +2512,17 @@ function scatterToVertices(positions, vnormals, samples, spacing, k, gateDot) {
       continue;
     }
     let w = 0;
-    let acc = 0;
+    let accum = 0;
     for (let t = 0; t < count; t += 1) {
       const ww = 1 / Math.max(bestD2[t], IDW_DISTANCE_FLOOR);
       w += ww;
-      acc += ww * bestVal[t];
+      accum += ww * bestVal[t];
     }
-    values[vi] = acc / w;
+    values[vi] = accum / w;
   }
   return { values, holeCount };
 }
-function backfillHoles(values, mesh) {
+function backfillScalarFieldHoles(values, mesh) {
   const vertexCount = values.length;
   const adjacency = Array.from({ length: vertexCount }, () => []);
   for (let t = 0; t < mesh.tris.length; t += 3) {
@@ -1813,6 +2588,10 @@ function reconstructSurfaceScalarField(trianglePositions, samples, options = {})
   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) {
@@ -1828,7 +2607,7 @@ function reconstructSurfaceScalarField(trianglePositions, samples, options = {})
   }
   const normals = vertexNormals(subdivided);
   const effectiveSpacing = sampleSpacing > 0 ? sampleSpacing : 1;
-  const scatter = scatterToVertices(subdivided.positions, normals, samples, effectiveSpacing, k, gateDot);
+  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) {
@@ -1841,7 +2620,7 @@ function reconstructSurfaceScalarField(trianglePositions, samples, options = {})
     valueMin = 0;
     valueMax = 0;
   }
-  backfillHoles(scatter.values, subdivided);
+  backfillScalarFieldHoles(scatter.values, subdivided);
   const vertexCount = subdivided.positions.length / 3;
   return {
     positions: Float32Array.from(subdivided.positions),
@@ -1856,6 +2635,22 @@ function reconstructSurfaceScalarField(trianglePositions, samples, options = {})
     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,
@@ -1997,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);
@@ -2076,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;
@@ -4130,14 +4977,47 @@ function mergeScalarFieldParams(override) {
   }
   return merged;
 }
-function buildScalarSurfaceOverlay(renderable, trianglePositions, samples, domain, fieldParams) {
+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();
-  const scalarSamples = scalarSamplesFromPointSamples(samples);
   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
+    targetEdgeSpacingFactor: SCALAR_SURFACE_TARGET_EDGE_SPACING_FACTOR,
+    ...fieldOptions
   });
   const reconstructMs = performance.now() - reconstructStarted;
   inspectProfileLog("scalar-overlay", {
@@ -4150,24 +5030,11 @@ function buildScalarSurfaceOverlay(renderable, trianglePositions, samples, domai
     reconstructMs: Number(reconstructMs.toFixed(1)),
     totalMs: Number((performance.now() - started).toFixed(1))
   });
-  const colorScale = domain ? { colormap: DEFAULT_COLORMAP, domainMin: domain.min, domainMax: domain.max } : {
-    colormap: DEFAULT_COLORMAP,
-    domainMin: field.valueMin,
-    domainMax: field.valueMax > field.valueMin ? field.valueMax : field.valueMin + 1
-  };
-  return {
-    overlay: {
-      renderable,
-      positions: field.positions,
-      normals: field.normals,
-      index: field.index,
-      aValue: field.values,
-      colorScale,
-      fieldParams
-    },
-    capped: field.capped,
-    holeCount: field.holeCount
-  };
+  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 renderScalarSurfaceOverlays(session, overlays) {
   const started = performance.now();
@@ -4187,20 +5054,37 @@ function renderScalarSurfaceOverlays(session, overlays) {
     ghostMaterial.toneMapped = false;
     renderable.solid.material = ghostMaterial;
     const overlay = overlayById.get(renderable.id);
+    const previousVisible = renderable.solid.visible;
+    if (overlay) renderable.solid.visible = false;
     if (!overlay || overlay.positions.length === 0) {
-      return { renderable, previousMaterial, ghostMaterial, mesh: null, geometry: null, material: null, lut: null };
+      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("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,
@@ -4226,7 +5110,7 @@ function renderScalarSurfaceOverlays(session, overlays) {
     mesh.renderOrder = 5;
     mesh.raycast = () => null;
     renderable.root.add(mesh);
-    return { renderable, previousMaterial, ghostMaterial, mesh, geometry, material, lut };
+    return { renderable, previousMaterial, previousVisible, ghostMaterial, mesh, geometry, material, lut, scalarTexture };
   });
   try {
     const png = withSolidOnlyVisibility(
@@ -4242,21 +5126,25 @@ function renderScalarSurfaceOverlays(session, overlays) {
     });
     return png;
   } finally {
-    replacements.forEach(({ renderable, previousMaterial, ghostMaterial, mesh, geometry, material, lut }) => {
-      if (mesh) renderable.root.remove(mesh);
-      renderable.solid.material = previousMaterial;
-      ghostMaterial.dispose();
-      geometry == null ? void 0 : geometry.dispose();
-      material == null ? void 0 : material.dispose();
-      lut == null ? void 0 : lut.dispose();
-    });
+    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, 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);
+  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]));
@@ -4265,7 +5153,8 @@ function getSessionThicknessInspection(session, rawOptions, fieldOverride) {
   const thicknessColorScale = {
     colormap: DEFAULT_THICKNESS_COLOR_SCALE.colormap,
     domainMin: options.colorMinThickness,
-    domainMax: options.colorMaxThickness
+    domainMax: options.colorMaxThickness,
+    ...{ reversed: true }
   };
   const objects = [];
   const cloudObjects = [];
@@ -4278,7 +5167,6 @@ function getSessionThicknessInspection(session, rawOptions, fieldOverride) {
     neighborSets: raycastConnectivity.neighborIdsByObjectId.size
   });
   session.renderables.forEach((renderable, index) => {
-    var _a2;
     const sourceObject = byId.get(renderable.id);
     const connectedGeometries = connectedThicknessGeometriesFor(raycastConnectivity, renderable);
     const analysisStarted = performance.now();
@@ -4327,25 +5215,32 @@ function getSessionThicknessInspection(session, rawOptions, fieldOverride) {
         ...sample
       });
     });
-    const trianglePositions = (_a2 = analysis.geometry.getAttribute("position")) == null ? void 0 : _a2.array;
-    if (trianglePositions instanceof Float32Array) {
-      const built = buildScalarSurfaceOverlay(
+    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,
-        trianglePositions,
-        analysis.pointSamples,
+        field,
         { min: thicknessColorScale.domainMin, max: thicknessColorScale.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 in-gate sample (filled by nearest neighbor).`);
-        }
+      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();
@@ -4384,12 +5279,212 @@ 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, 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, fieldOverride) {
   var _a;
   const resolvedOptions = resolveRoughnessInspectionOptions(rawOptions);
@@ -4401,6 +5496,7 @@ function getSessionRoughnessInspection(session, rawOptions, fieldOverride) {
   const warnings = [];
   maybePushSceneSampleBudgetWarning(warnings, "Roughness", sampleBudget);
   const objects = [];
+  const hotSpotCandidates = [];
   const cloudObjects = [];
   const points = [];
   const overlays = [];
@@ -4455,6 +5551,16 @@ function getSessionRoughnessInspection(session, rawOptions, fieldOverride) {
         ...sample
       });
     });
+    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);
@@ -4472,6 +5578,15 @@ function getSessionRoughnessInspection(session, rawOptions, fieldOverride) {
     }
     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,
@@ -4490,10 +5605,11 @@ function getSessionRoughnessInspection(session, rawOptions, fieldOverride) {
       sampleBudget,
       objectCount: objects.length,
       objects,
+      hotSpots,
       warnings,
       style: {
         // Legacy class colors kept for back-compat; colorScale is the truth the
-        // viewport/CLI now render with (continuous viridis over the data domain).
+        // viewport/CLI now render with (continuous scalar colormap over the data domain).
         colorScale: roughnessColorScale,
         smoothColor: ROUGHNESS_COLORS.smooth,
         moderateColor: ROUGHNESS_COLORS.moderate,
@@ -6180,6 +7296,7 @@ Fix one:
     collisionEntries,
     collisionReport: null,
     thicknessInspection: null,
+    throughThicknessInspection: null,
     roughnessInspection: null,
     joints,
     jointCouplings,
@@ -6264,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"
   });
@@ -6343,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;
@@ -6353,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 = {};
@@ -6494,6 +7616,22 @@ window.__forgeRender = async (code, opts) => {
         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);
@@ -6602,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,