forgecad 0.10.2 → 0.10.4

package/dist/assets/cli/{render-B_0lQwKU.js → render-XXol_ET7.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, bx as BoxGeometry, c2 as MeshStandardMaterial, a5 as BackSide, b8 as PointLight, M as Mesh, ab as MeshBasicMaterial, cJ as localAabbPlaneRelation, i as Vector2, cK as ShapeUtils, cL as analyzePhysicalConnectivity, h as Vector3, a0 as Matrix4, cM as Frustum, J as Box3, a1 as MathUtils, cN as meshContactDataFor, cO as AabbSpatialIndex, cP as detectPhysicalContact, cQ as resolveThicknessInspectionOptions, R as Raycaster, cR as thicknessColor, cS as thicknessClass, b0 as BufferAttribute, cT as roughnessClassForAngle, cU as resolveRoughnessInspectionOptions, cV as roughnessColorForAngle, cW as roughnessScoreForAngle, cI as initBackendForEvaluation, f as Color, bb as COMPARISON_COLORS, az as resolveForgeRenderStyle, bG as getRenderStylePreset, ay as setParamOverrides, bm as runScript, cs as scanProxyGridForBounds, cX as Group, bf as shapeToGeometry, bn as MeshPhysicalMaterial, bE as AdditiveBlending, bJ as scanMaterialShellColor, cY as createScanProxyGeometry, aP as LineBasicMaterial, bI as NormalBlending, bo as LineSegments, P as PerspectiveCamera, cp as DEFAULT_VIEW_CONFIG, bt as worldAuthorPlaneToLocal, cZ as resolveSectionHatchMetrics, cA as buildGeometryComparisonPointCloud, cy 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, bF as geometryWithVisibleVertexColors, c_ as intersectWithPlane, c$ as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, d as SRGBColorSpace, d0 as parseCameraCliSpec, d1 as PMREMGenerator, b1 as CanvasTexture, b2 as Object3D, b3 as FogExp2, b4 as Fog, b5 as AmbientLight, b9 as DirectionalLight, b6 as HemisphereLight, aJ 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, aK as resolveJointAnimation, aL as resolveJointViewValues, aO as BufferGeometry, bZ as ROUGHNESS_COLORS, d2 as PointsMaterial, d3 as Points, ba as heatPointsForSide, d4 as analyzeCollisionIntersections, d5 as serializeCollisionFinding, d6 as summarizeThicknessSamples, bY as THICKNESS_GRADIENT_COLORS, d7 as THICKNESS_COLORS, b7 as SpotLight, c6 as CylinderGeometry, d8 as TorusGeometry, bW as CatmullRomCurve3, bX as TubeGeometry, cE as resolveScalarSceneSampleBudget, bg as buildComparisonHeatPatchGeometry, bh as EdgesGeometry, d9 as SphereGeometry, da as ConeGeometry, bc as comparisonHeatDepthTest, bd as comparisonHeatEdgeOpacity, be as comparisonHeatPatchOpacity, cG as comparisonCandidateContextOpacity, db as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../backendInit-ymjonyQp.js";
-import { m as mergeViewportRenderSceneStates, v as validateJointOverrides, b as buildBaseJointValues, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../jointPose-4r8ed8_5.js";
+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";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -1324,6 +1324,13 @@ function clampUnit(value) {
 function cloneGeometryForFaceColors(geometry) {
   return geometry.index ? geometry.toNonIndexed() : geometry.clone();
 }
+function makeThicknessRaycastTarget(sourceGeometry, rayMaterial, jumpable) {
+  const geometry = sourceGeometry.clone();
+  geometry.boundsTree = new MeshBVH(geometry);
+  const mesh = new Mesh(geometry, rayMaterial);
+  mesh.raycast = acceleratedRaycast;
+  return { mesh, jumpable, geometry };
+}
 function geometryMaxDimension(geometry) {
   geometry.computeBoundingBox();
   const box = geometry.boundingBox;
@@ -1399,71 +1406,529 @@ function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {})
   const warnings = [];
   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
-    }))
+    makeThicknessRaycastTarget(geometry, rayMaterial, false),
+    ...connectedGeometries.map((connectedGeometry) => makeThicknessRaycastTarget(connectedGeometry, rayMaterial, true))
   ];
-  const rayTargetMeshes = rayTargets.map((target) => target.mesh);
-  const jumpableMeshes = new Set(rayTargets.filter((target) => target.jumpable).map((target) => target.mesh));
-  const raycaster = new Raycaster();
-  if (surfaceTriangles.length === 0) {
-    warnings.push("No non-degenerate triangle surface was available for thickness sampling.");
-  } else if (surfaceSamples.length < surfaceTriangles.length) {
-    warnings.push(
-      `Area sampling budget ${surfaceSamples.length} covers ${surfaceTriangles.length} surface triangles; increase --thickness-samples for denser analysis.`
-    );
+  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) {
+      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;
+      }
+      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 {
+    rayTargets.forEach((target) => target.geometry.dispose());
+    rayMaterial.dispose();
   }
-  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 DEFAULT_VERTEX_CAP = 2e6;
+const DEFAULT_TARGET_EDGE_SPACING_FACTOR = 2;
+const DEFAULT_K = 8;
+const DEFAULT_GATE_DOT = 0.3;
+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 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}`
     );
-    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;
+  }
+  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 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 idx = [];
+    for (let corner = 0; corner < 3; corner += 1) {
+      const o = tri + corner * 3;
+      const key = quantKey(o);
+      let vi = remap.get(key);
+      if (vi === void 0) {
+        vi = out.length / 3;
+        out.push(positions[o], positions[o + 1], positions[o + 2]);
+        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]);
     }
-    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;
+  const distinctVertexCount = out.length / 3;
+  const degenerate = distinctVertexCount < 3 || tris.length === 0;
+  return { positions: out, tris, degenerate };
+}
+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;
     }
   }
-  geometry.setAttribute("color", new BufferAttribute(colors, 3));
-  rayMaterial.dispose();
+  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) {
+  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;
+      if (samples.normals[so] * nx + samples.normals[so + 1] * ny + samples.normals[so + 2] * nz < 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 acc = 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];
+    }
+    values[vi] = acc / w;
+  }
+  return { values, holeCount };
+}
+function backfillHoles(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 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);
+  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;
+  }
+  backfillHoles(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
   };
 }
+const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
+  smoothAngleDeg: 5,
+  sharpAngleDeg: 30,
+  harshAngleDeg: 90,
+  maxSamplesPerObject: 5e3
+};
+const ROUGHNESS_COLORS = {
+  smooth: [62, 72, 84],
+  moderate: [255, 214, 0],
+  sharp: [255, 124, 34],
+  harsh: [255, 42, 96]
+};
+function resolveRoughnessInspectionOptions(raw = {}) {
+  const options = {
+    smoothAngleDeg: raw.smoothAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.smoothAngleDeg,
+    sharpAngleDeg: raw.sharpAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.sharpAngleDeg,
+    harshAngleDeg: raw.harshAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.harshAngleDeg,
+    maxSamplesPerObject: raw.maxSamplesPerObject ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.maxSamplesPerObject
+  };
+  if (!Number.isFinite(options.smoothAngleDeg) || options.smoothAngleDeg < 0) {
+    throw new Error(`smoothAngleDeg must be a finite non-negative angle (got ${options.smoothAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.sharpAngleDeg) || options.sharpAngleDeg <= options.smoothAngleDeg) {
+    throw new Error(`sharpAngleDeg must be greater than smoothAngleDeg (got ${options.sharpAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.harshAngleDeg) || options.harshAngleDeg <= options.sharpAngleDeg || options.harshAngleDeg > 180) {
+    throw new Error(`harshAngleDeg must be greater than sharpAngleDeg and <= 180 (got ${options.harshAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.maxSamplesPerObject) || options.maxSamplesPerObject <= 0) {
+    throw new Error(`maxSamplesPerObject must be a positive finite number (got ${options.maxSamplesPerObject}).`);
+  }
+  return {
+    ...options,
+    maxSamplesPerObject: Math.max(1, Math.floor(options.maxSamplesPerObject))
+  };
+}
+function roughnessClassForAngle(angleDeg, options) {
+  if (angleDeg >= options.harshAngleDeg) return "harsh";
+  if (angleDeg >= options.sharpAngleDeg) return "sharp";
+  if (angleDeg >= options.smoothAngleDeg) return "moderate";
+  return "smooth";
+}
+function roughnessScoreForAngle(angleDeg, options) {
+  if (angleDeg < options.sharpAngleDeg) return 0;
+  if (angleDeg < options.harshAngleDeg) {
+    return MathUtils.lerp(0.48, 0.82, (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg));
+  }
+  return 1;
+}
+function roughnessColorForAngle(angleDeg, options) {
+  const cls = roughnessClassForAngle(angleDeg, options);
+  if (cls === "smooth" || cls === "harsh") return ROUGHNESS_COLORS[cls];
+  if (cls === "moderate") {
+    return lerpRgb(
+      ROUGHNESS_COLORS.moderate,
+      ROUGHNESS_COLORS.sharp,
+      (angleDeg - options.smoothAngleDeg) / (options.sharpAngleDeg - options.smoothAngleDeg)
+    );
+  }
+  return lerpRgb(
+    ROUGHNESS_COLORS.sharp,
+    ROUGHNESS_COLORS.harsh,
+    (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg)
+  );
+}
+function lerpRgb(a, b, t) {
+  const clamped = MathUtils.clamp(t, 0, 1);
+  return [
+    Math.round(MathUtils.lerp(a[0], b[0], clamped)),
+    Math.round(MathUtils.lerp(a[1], b[1], clamped)),
+    Math.round(MathUtils.lerp(a[2], b[2], clamped))
+  ];
+}
 function emptyRoughnessSummary() {
   return {
     triangleCount: 0,
@@ -1928,6 +2393,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 {
@@ -3602,21 +4077,100 @@ function bboxFromGeometry(geometry) {
     max: bbox ? [bbox.max.x, bbox.max.y, bbox.max.z] : [0, 0, 0]
   };
 }
-function pointBuffersFromSamples(samples, 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;
-    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 buildScalarSurfaceOverlay(renderable, trianglePositions, samples, domain, fieldParams) {
+  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
   });
-  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))
+  });
+  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
+  };
 }
-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) => {
@@ -3633,62 +4187,108 @@ 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 };
+    if (!overlay || overlay.positions.length === 0) {
+      return { renderable, previousMaterial, ghostMaterial, mesh: null, geometry: null, material: null, lut: 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.setIndex(new BufferAttribute(overlay.index, 1));
+    const lut = makeColorScaleTexture(colorScaleLUT(overlay.colorScale.colormap));
+    trackTextureDecode(lut);
+    const uniforms = makeInspectScalarUniforms({
+      colorScale: lut,
+      domainMin: overlay.colorScale.domainMin,
+      domainMax: overlay.colorScale.domainMax,
+      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, ghostMaterial, mesh, geometry, material, lut };
   });
   try {
-    return withSolidOnlyVisibility(
+    const png = withSolidOnlyVisibility(
       session,
       () => withTemporarySceneBackground(session, new Color(0), () => {
         r.render(session.scene, session.camera);
         return captureRenderedPng(session.size);
       })
     );
+    inspectProfileLog("scalar-render", {
+      overlays: overlays.length,
+      totalMs: Number((performance.now() - started).toFixed(1))
+    });
+    return png;
   } finally {
-    replacements.forEach(({ renderable, previousMaterial, ghostMaterial, points, geometry, material }) => {
-      if (points) renderable.root.remove(points);
+    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();
     });
   }
 }
-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);
+  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 = [];
   maybePushSceneSampleBudgetWarning(warnings, "Thickness", sampleBudget);
+  const thicknessColorScale = {
+    colormap: DEFAULT_THICKNESS_COLOR_SCALE.colormap,
+    domainMin: options.colorMinThickness,
+    domainMax: options.colorMaxThickness
+  };
   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) => {
+    var _a2;
     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);
@@ -3727,7 +4327,27 @@ function getSessionThicknessInspection(session, rawOptions) {
         ...sample
       });
     });
-    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples) });
+    const trianglePositions = (_a2 = analysis.geometry.getAttribute("position")) == null ? void 0 : _a2.array;
+    if (trianglePositions instanceof Float32Array) {
+      const built = buildScalarSurfaceOverlay(
+        renderable,
+        trianglePositions,
+        analysis.pointSamples,
+        { 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).`);
+        }
+      }
+    }
     analysis.geometry.dispose();
   });
   const state = {
@@ -3750,7 +4370,7 @@ function getSessionThicknessInspection(session, rawOptions) {
       objects,
       warnings,
       style: {
-        gradientColors: THICKNESS_GRADIENT_COLORS.map((color) => [...color]),
+        colorScale: thicknessColorScale,
         colorMinThickness: options.colorMinThickness,
         colorMaxThickness: options.colorMaxThickness,
         unknownColor: THICKNESS_COLORS.unknown
@@ -3760,21 +4380,22 @@ 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 };
 }
 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 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 = [];
@@ -3783,8 +4404,23 @@ function getSessionRoughnessInspection(session, rawOptions) {
   const cloudObjects = [];
   const points = [];
   const overlays = [];
-  session.renderables.forEach((renderable, index) => {
+  let roughnessMin = Infinity;
+  let roughnessMax = -Infinity;
+  const analysesByIndex = [];
+  session.renderables.forEach((renderable) => {
     const analysis = analyzeRoughnessGeometry(renderable.solid.geometry, options);
+    analysesByIndex.push(analysis);
+    for (const sample of analysis.pointSamples) {
+      if (sample.value != null && Number.isFinite(sample.value)) {
+        if (sample.value < roughnessMin) roughnessMin = sample.value;
+        if (sample.value > roughnessMax) roughnessMax = sample.value;
+      }
+    }
+  });
+  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);
     if (analysis.warnings.length > 0) {
@@ -3819,7 +4455,21 @@ function getSessionRoughnessInspection(session, rawOptions) {
         ...sample
       });
     });
-    overlays.push({ renderable, ...pointBuffersFromSamples(analysis.pointSamples) });
+    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 state = {
@@ -3842,6 +4492,9 @@ function getSessionRoughnessInspection(session, rawOptions) {
       objects,
       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).
+        colorScale: roughnessColorScale,
         smoothColor: ROUGHNESS_COLORS.smooth,
         moderateColor: ROUGHNESS_COLORS.moderate,
         sharpColor: ROUGHNESS_COLORS.sharp,
@@ -4968,6 +5621,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;
@@ -5321,6 +6028,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 });
@@ -5513,6 +6226,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) {
@@ -5530,6 +6244,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,
@@ -5592,6 +6307,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";
@@ -5717,7 +6433,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;
@@ -5772,7 +6488,7 @@ 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;
@@ -5917,6 +6633,7 @@ window.__forgeCaptureInit = async (code, opts) => {
   if (!built.ok) {
     return built;
   }
+  await awaitPendingTextureDecodes();
   captureSession = built.session;
   return {
     ok: true,