forgecad 0.9.4 → 0.9.6

package/dist/assets/cli/{render-Kw5hLEcL.js → render-CFtwKCCY.js}

@@ -1,8 +1,5 @@
-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, bH as initSolverWasm, bG as initKernel, S as Scene, bI as BoxGeometry, bd as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bJ as localAabbPlaneRelation, h as Vector2, bK as ShapeUtils, g as Vector3, e as Color, aC as resolveForgeRenderStyle, b9 as getRenderStylePreset, ax as setParamOverrides, b6 as runScript, a0 as MathUtils, G as Box3, bL as Group, b3 as shapeToGeometry, b7 as MeshPhysicalMaterial, ba as AdditiveBlending, aH as LineBasicMaterial, b8 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bM as intersectWithPlane, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, bN as parseCameraCliSpec, bO as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bz as findJointAnimationClip, p as Plane, Y as Vector4, $ as Matrix4, bg as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bf as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bA as resolveJointAnimation, bB as resolveJointViewValues, R as Raycaster, aU as BufferAttribute, bP as worldAuthorPlaneToLocal, a$ as SpotLight } from "../sectionPlaneMath-C8N0w8o3.js";
-import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-tvtNKNRi.js";
+import { D as DoubleSide, bM as initSolverWasm, bL as initKernel, S as Scene, bN as BoxGeometry, bg as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bO as localAabbPlaneRelation, h as Vector2, bP as ShapeUtils, g as Vector3, e as Color, aC as resolveForgeRenderStyle, bc as getRenderStylePreset, ax as setParamOverrides, b7 as runScript, a0 as MathUtils, G as Box3, bQ as Group, b3 as shapeToGeometry, b8 as MeshPhysicalMaterial, bd as AdditiveBlending, aH as LineBasicMaterial, b9 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bR as resolveRoughnessInspectionOptions, bb as analyzeRoughnessGeometry, bS as ROUGHNESS_COLORS, bJ as analyzePhysicalConnectivity, bT as resolveThicknessInspectionOptions, ba as analyzeThicknessGeometry, bU as summarizeThicknessSamples, bV as THICKNESS_COLORS, bW as intersectWithPlane, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, bX as parseCameraCliSpec, bY as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bC as findJointAnimationClip, p as Plane, Y as Vector4, $ as Matrix4, bj as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bi as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bD as resolveJointAnimation, bE as resolveJointViewValues, bK as analyzeDistanceInspection, b2 as analyzeCollisionIntersections, bZ as serializeCollisionFinding, b_ as worldAuthorPlaneToLocal, a$ as SpotLight, aU as BufferAttribute } from "../distance-BEC2RjJi.js";
+import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-BuAXF2jh.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -457,617 +454,37 @@ function computeMeshSectionCap(mesh, planeInput) {
     warnings: stitched.warnings.length > 0 ? stitched.warnings : void 0
   };
 }
-const DEFAULT_COLLISION_INSPECTION_OPTIONS = {
-  minOverlapVolume: 0.1
-};
-function cloneVec3$1(value) {
-  return [value[0], value[1], value[2]];
-}
-function isIdentityTransform(matrix) {
-  if (!matrix) return true;
-  const identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-  return identity.every((value, index) => Math.abs(matrix[index] - value) <= 1e-12);
-}
-function transformPoint(matrix, point) {
-  const [x, y, z] = point;
-  return [
-    matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12],
-    matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13],
-    matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14]
-  ];
-}
-function transformBBox(min, max, matrix) {
-  const corners = [
-    [min[0], min[1], min[2]],
-    [min[0], min[1], max[2]],
-    [min[0], max[1], min[2]],
-    [min[0], max[1], max[2]],
-    [max[0], min[1], min[2]],
-    [max[0], min[1], max[2]],
-    [max[0], max[1], min[2]],
-    [max[0], max[1], max[2]]
-  ];
-  const outMin = [Infinity, Infinity, Infinity];
-  const outMax = [-Infinity, -Infinity, -Infinity];
-  for (const corner of corners) {
-    const transformed = transformPoint(matrix, corner);
-    for (let axis = 0; axis < 3; axis += 1) {
-      outMin[axis] = Math.min(outMin[axis], transformed[axis]);
-      outMax[axis] = Math.max(outMax[axis], transformed[axis]);
-    }
-  }
-  return { min: outMin, max: outMax };
-}
-function prepareEntry$1(entry) {
-  if (isIdentityTransform(entry.transform)) {
-    return {
-      ...entry,
-      min: cloneVec3$1(entry.min),
-      max: cloneVec3$1(entry.max)
-    };
-  }
-  const bbox = transformBBox(entry.min, entry.max, entry.transform);
-  return {
-    ...entry,
-    shape: entry.shape.transform(entry.transform),
-    min: bbox.min,
-    max: bbox.max
-  };
-}
-function bboxOverlaps(a, b) {
-  return [0, 1, 2].every((axis) => a.min[axis] < b.max[axis] && a.max[axis] > b.min[axis]);
-}
-function collisionId(a, b) {
-  return `${a.id}__${b.id}`;
-}
-function serializeCollisionFinding(finding) {
-  return {
-    index: finding.index,
-    id: finding.id,
-    sourceIndex: finding.sourceIndex,
-    targetIndex: finding.targetIndex,
-    sourceId: finding.sourceId,
-    targetId: finding.targetId,
-    sourceName: finding.sourceName,
-    targetName: finding.targetName,
-    overlapVolume: finding.overlapVolume
-  };
-}
-function analyzeCollisionIntersections(entries, rawOptions = {}) {
-  const options = {
-    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_COLLISION_INSPECTION_OPTIONS.minOverlapVolume
-  };
-  const warnings = [];
-  const collisions = [];
-  const preparedEntries = entries.map((entry) => prepareEntry$1(entry));
-  for (let i = 0; i < preparedEntries.length; i += 1) {
-    for (let j = i + 1; j < preparedEntries.length; j += 1) {
-      const a = preparedEntries[i];
-      const b = preparedEntries[j];
-      if (!bboxOverlaps(a, b)) continue;
-      try {
-        const hit = a.shape.intersect(b.shape);
-        if (hit.isEmpty()) continue;
-        const overlapVolume = hit.volume();
-        if (!Number.isFinite(overlapVolume) || overlapVolume <= options.minOverlapVolume) continue;
-        collisions.push({
-          index: collisions.length + 1,
-          id: collisionId(a, b),
-          sourceIndex: i,
-          targetIndex: j,
-          sourceId: a.id,
-          targetId: b.id,
-          sourceName: a.name,
-          targetName: b.name,
-          overlapVolume,
-          shape: hit
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        warnings.push(`Could not boolean-test ${a.name} against ${b.name}: ${message}`);
-      }
-    }
-  }
-  const objects = preparedEntries.map((entry, index) => ({
-    index,
-    id: entry.id,
-    name: entry.name,
-    groupName: entry.groupName,
-    treePath: entry.treePath,
-    mock: entry.mock === true,
-    bbox: {
-      min: cloneVec3$1(entry.min),
-      max: cloneVec3$1(entry.max)
-    }
-  }));
-  return {
-    method: "boolean-intersection",
-    options,
-    objectCount: objects.length,
-    collisionCount: collisions.length,
-    objects,
-    collisions,
-    warnings
-  };
-}
-const DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
-  contactTolerance: 0.05,
-  minOverlapVolume: 0.1,
-  exactGeometry: false
+const CAMERA_TOKEN_DIRECTIONS = {
+  front: [0, -1, 0.2],
+  back: [0, 1, 0.2],
+  side: [1, 0, 0.2],
+  right: [1, 0, 0.2],
+  top: [0, -0.01, 1],
+  iso: [0.6, -0.6, 0.4]
 };
-const AXIS_NAMES = ["x", "y", "z"];
-class UnionFind {
-  constructor(size) {
-    __publicField(this, "parent");
-    __publicField(this, "rank");
-    this.parent = Array.from({ length: size }, (_, index) => index);
-    this.rank = Array.from({ length: size }, () => 0);
-  }
-  find(value) {
-    const parent = this.parent[value];
-    if (parent === value) return value;
-    const root = this.find(parent);
-    this.parent[value] = root;
-    return root;
-  }
-  union(a, b) {
-    const rootA = this.find(a);
-    const rootB = this.find(b);
-    if (rootA === rootB) return;
-    if (this.rank[rootA] < this.rank[rootB]) {
-      this.parent[rootA] = rootB;
-      return;
-    }
-    if (this.rank[rootA] > this.rank[rootB]) {
-      this.parent[rootB] = rootA;
-      return;
-    }
-    this.parent[rootB] = rootA;
-    this.rank[rootA] += 1;
-  }
-}
-function cloneVec3(value) {
-  return [value[0], value[1], value[2]];
-}
-function emptyBBox() {
-  return {
-    min: [Infinity, Infinity, Infinity],
-    max: [-Infinity, -Infinity, -Infinity]
-  };
-}
-function expandBBox(target, min, max) {
-  for (let axis = 0; axis < 3; axis += 1) {
-    target.min[axis] = Math.min(target.min[axis], min[axis]);
-    target.max[axis] = Math.max(target.max[axis], max[axis]);
-  }
-}
-function intervalGap$1(aMin, aMax, bMin, bMax) {
-  if (aMax < bMin) return bMin - aMax;
-  if (bMax < aMin) return aMin - bMax;
-  return 0;
-}
-function nearestBoundaryGap(a, b, axis) {
-  return Math.min(Math.abs(a.max[axis] - b.min[axis]), Math.abs(b.max[axis] - a.min[axis]));
-}
-function bboxGaps(a, b) {
-  return [
-    intervalGap$1(a.min[0], a.max[0], b.min[0], b.max[0]),
-    intervalGap$1(a.min[1], a.max[1], b.min[1], b.max[1]),
-    intervalGap$1(a.min[2], a.max[2], b.min[2], b.max[2])
-  ];
-}
-function maxGap(gaps) {
-  return Math.max(gaps[0], gaps[1], gaps[2]);
-}
-function hasPositiveGap(gaps) {
-  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
-}
-function bboxInteriorOverlaps(a, b) {
-  for (let axis = 0; axis < 3; axis += 1) {
-    if (Math.min(a.max[axis], b.max[axis]) - Math.max(a.min[axis], b.min[axis]) <= 0) return false;
-  }
-  return true;
-}
-function bboxOverlapVolume(a, b) {
-  let volume = 1;
-  for (let axis = 0; axis < 3; axis += 1) {
-    volume *= Math.max(0, Math.min(a.max[axis], b.max[axis]) - Math.max(a.min[axis], b.min[axis]));
-  }
-  return volume;
-}
-function estimateSweepPairCount(entries, axis, tolerance) {
-  const ordered = entries.map((entry) => ({ min: entry.min[axis], max: entry.max[axis] })).sort((a, b) => a.min - b.min || a.max - b.max);
-  const endValues = ordered.map((entry) => entry.max + tolerance).sort((a, b) => a - b);
-  let expired = 0;
-  let count = 0;
-  for (let seen = 0; seen < ordered.length; seen += 1) {
-    const currentMin = ordered[seen].min;
-    while (expired < seen && endValues[expired] < currentMin) expired += 1;
-    count += seen - expired;
-  }
-  return count;
-}
-function chooseSweepAxis(entries, tolerance) {
-  let bestAxis = 0;
-  let bestCount = estimateSweepPairCount(entries, bestAxis, tolerance);
-  for (const axis of [1, 2]) {
-    const count = estimateSweepPairCount(entries, axis, tolerance);
-    if (count < bestCount) {
-      bestAxis = axis;
-      bestCount = count;
-    }
-  }
-  return bestAxis;
-}
-function collectCandidatePairs(entries, tolerance) {
-  if (entries.length < 2) return [];
-  const axis = chooseSweepAxis(entries, tolerance);
-  const ordered = entries.map((entry, index) => ({ entry, index })).sort((a, b) => a.entry.min[axis] - b.entry.min[axis] || a.entry.max[axis] - b.entry.max[axis] || a.index - b.index);
-  let active = [];
-  const pairs = [];
-  for (const current of ordered) {
-    active = active.filter((candidate) => candidate.entry.max[axis] + tolerance >= current.entry.min[axis]);
-    for (const candidate of active) {
-      const gaps = bboxGaps(candidate.entry, current.entry);
-      if (maxGap(gaps) > tolerance) continue;
-      const sourceIndex = Math.min(candidate.index, current.index);
-      const targetIndex = Math.max(candidate.index, current.index);
-      pairs.push({ sourceIndex, targetIndex, gaps });
-    }
-    active.push(current);
-  }
-  pairs.sort((a, b) => a.sourceIndex - b.sourceIndex || a.targetIndex - b.targetIndex);
-  return pairs;
-}
-function contactFromBBoxes(a, b, tolerance) {
-  const gaps = bboxGaps(a, b);
-  const largestGap = maxGap(gaps);
-  if (largestGap > tolerance) return { touching: false, gap: largestGap };
-  const separatedAxes = gaps.map((gap, axis) => ({ gap, axis })).filter((entry) => entry.gap > 0);
-  if (separatedAxes.length > 0) {
-    const nearest2 = separatedAxes.reduce((best, entry) => entry.gap > best.gap ? entry : best, separatedAxes[0]);
-    return { touching: true, gap: nearest2.gap, axis: AXIS_NAMES[nearest2.axis] };
-  }
-  const boundaryAxes = AXIS_NAMES.map((axisName, axis) => ({
-    axis,
-    axisName,
-    gap: nearestBoundaryGap(a, b, axis)
-  })).filter((entry) => entry.gap <= tolerance);
-  if (boundaryAxes.length === 0) return { touching: false, gap: 0 };
-  const nearest = boundaryAxes.reduce((best, entry) => entry.gap < best.gap ? entry : best, boundaryAxes[0]);
-  return { touching: true, gap: nearest.gap, axis: nearest.axisName };
-}
-function intersectionVolume(a, b) {
-  try {
-    const hit = a.shape.intersect(b.shape);
-    if (hit.isEmpty()) return { volume: 0 };
-    const volume = hit.volume();
-    return { volume: Number.isFinite(volume) ? volume : 0 };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { volume: null, warning: `Could not boolean-test ${a.name} against ${b.name}: ${message}` };
-  }
-}
-function bodyCountForEntry(entry) {
-  if (typeof entry.bodyCount === "number" && Number.isFinite(entry.bodyCount)) {
-    return Math.max(0, Math.round(entry.bodyCount));
-  }
-  return 1;
-}
-function makeEdge(entries, sourceIndex, targetIndex, edge) {
-  const source = entries[sourceIndex];
-  const target = entries[targetIndex];
-  return {
-    sourceIndex,
-    targetIndex,
-    sourceId: source.id,
-    targetId: target.id,
-    sourceName: source.name,
-    targetName: target.name,
-    ...edge
-  };
+function normalizeCameraDirection(dir) {
+  const len = Math.sqrt(dir[0] ** 2 + dir[1] ** 2 + dir[2] ** 2) || 1;
+  return [dir[0] / len, dir[1] / len, dir[2] / len];
 }
-function analyzePhysicalConnectivity(entries, rawOptions = {}) {
-  const options = {
-    contactTolerance: rawOptions.contactTolerance ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance,
-    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.minOverlapVolume,
-    exactGeometry: rawOptions.exactGeometry ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.exactGeometry
-  };
-  const warnings = [];
-  const edges = [];
-  const unionFind = new UnionFind(entries.length);
-  for (const pair of collectCandidatePairs(entries, options.contactTolerance)) {
-    const i = pair.sourceIndex;
-    const j = pair.targetIndex;
-    const a = entries[i];
-    const b = entries[j];
-    const bboxOverlaps2 = !hasPositiveGap(pair.gaps) && bboxInteriorOverlaps(a, b);
-    if (options.exactGeometry && bboxOverlaps2) {
-      const overlap = intersectionVolume(a, b);
-      if (overlap.warning) warnings.push(overlap.warning);
-      if (overlap.volume != null && overlap.volume > options.minOverlapVolume) {
-        unionFind.union(i, j);
-        edges.push(
-          makeEdge(entries, i, j, {
-            kind: "overlap",
-            method: "boolean-intersection",
-            gap: 0,
-            overlapVolume: overlap.volume
-          })
-        );
-        continue;
-      }
-      if (overlap.volume != null && overlap.volume > 0) {
-        unionFind.union(i, j);
-        edges.push(
-          makeEdge(entries, i, j, {
-            kind: "touching",
-            method: "boolean-intersection",
-            gap: 0,
-            overlapVolume: overlap.volume
-          })
-        );
-        continue;
-      }
-    }
-    if (bboxOverlaps2) {
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge(entries, i, j, {
-          kind: "overlap",
-          method: "bbox-overlap",
-          gap: 0,
-          overlapVolume: bboxOverlapVolume(a, b)
-        })
-      );
-    } else {
-      const contact = contactFromBBoxes(a, b, options.contactTolerance);
-      if (!contact.touching) continue;
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge(entries, i, j, {
-          kind: "touching",
-          method: "bbox-contact",
-          gap: contact.gap,
-          axis: contact.axis
-        })
-      );
-    }
-  }
-  const objects = entries.map((entry, index) => ({
-    index,
-    id: entry.id,
-    name: entry.name,
-    groupName: entry.groupName,
-    treePath: entry.treePath,
-    mock: entry.mock === true,
-    bodyCount: bodyCountForEntry(entry),
-    bbox: {
-      min: cloneVec3(entry.min),
-      max: cloneVec3(entry.max)
-    },
-    componentIndex: 0
-  }));
-  const componentByRoot = /* @__PURE__ */ new Map();
-  const rootToComponentIndex = /* @__PURE__ */ new Map();
-  for (let objectIndex = 0; objectIndex < objects.length; objectIndex += 1) {
-    const root = unionFind.find(objectIndex);
-    let component = componentByRoot.get(root);
-    if (!component) {
-      component = {
-        index: componentByRoot.size + 1,
-        objectIndexes: [],
-        objectIds: [],
-        objectNames: [],
-        objectCount: 0,
-        bodyCount: 0,
-        bbox: emptyBBox()
-      };
-      componentByRoot.set(root, component);
-      rootToComponentIndex.set(root, component.index);
-    }
-    const object = objects[objectIndex];
-    object.componentIndex = rootToComponentIndex.get(root) ?? component.index;
-    component.objectIndexes.push(object.index);
-    component.objectIds.push(object.id);
-    component.objectNames.push(object.name);
-    component.objectCount += 1;
-    component.bodyCount += object.bodyCount;
-    expandBBox(component.bbox, object.bbox.min, object.bbox.max);
-  }
-  const components = [...componentByRoot.values()];
-  return {
-    method: options.exactGeometry ? "boolean-overlap-plus-bbox-contact" : "bbox-neighborhood",
-    options,
-    objectCount: objects.length,
-    componentCount: components.length,
-    objects,
-    components,
-    edges,
-    warnings
-  };
+function sphericalToCameraDirection(azimuthDeg, elevationDeg) {
+  const az = azimuthDeg * Math.PI / 180;
+  const el = elevationDeg * Math.PI / 180;
+  const cosEl = Math.cos(el);
+  return [cosEl * Math.sin(az), -cosEl * Math.cos(az), Math.sin(el)];
 }
-const EPSILON = 1e-9;
-function intervalGap(aMin, aMax, bMin, bMax) {
-  if (aMax < bMin) return bMin - aMax;
-  if (bMax < aMin) return aMin - bMax;
-  return 0;
-}
-function bboxGap(a, b) {
-  const axisGaps = [
-    intervalGap(a.bbox.min[0], a.bbox.max[0], b.bbox.min[0], b.bbox.max[0]),
-    intervalGap(a.bbox.min[1], a.bbox.max[1], b.bbox.min[1], b.bbox.max[1]),
-    intervalGap(a.bbox.min[2], a.bbox.max[2], b.bbox.min[2], b.bbox.max[2])
-  ];
-  const gap = Math.sqrt(axisGaps[0] ** 2 + axisGaps[1] ** 2 + axisGaps[2] ** 2);
-  return { gap, axisGaps };
-}
-function bboxVolume(component) {
-  const dx = Math.max(0, component.bbox.max[0] - component.bbox.min[0]);
-  const dy = Math.max(0, component.bbox.max[1] - component.bbox.min[1]);
-  const dz = Math.max(0, component.bbox.max[2] - component.bbox.min[2]);
-  return dx * dy * dz;
-}
-function compareDefaultRoot(a, b) {
-  if (a.bodyCount !== b.bodyCount) return a.bodyCount - b.bodyCount;
-  if (a.objectCount !== b.objectCount) return a.objectCount - b.objectCount;
-  const volumeDelta = bboxVolume(a) - bboxVolume(b);
-  if (Math.abs(volumeDelta) > EPSILON) return volumeDelta;
-  return b.index - a.index;
-}
-function defaultRootComponentIndex(components) {
-  if (components.length === 0) return null;
-  return components.reduce((best, component) => compareDefaultRoot(component, best) > 0 ? component : best, components[0]).index;
-}
-function buildGapEdges(components) {
-  const edges = [];
-  for (let i = 0; i < components.length; i += 1) {
-    for (let j = i + 1; j < components.length; j += 1) {
-      const source = components[i];
-      const target = components[j];
-      const gap = bboxGap(source, target);
-      if (!Number.isFinite(gap.gap)) continue;
-      edges.push({
-        sourceComponentIndex: source.index,
-        targetComponentIndex: target.index,
-        sourceObjectNames: [...source.objectNames],
-        targetObjectNames: [...target.objectNames],
-        gap: gap.gap,
-        axisGaps: gap.axisGaps
-      });
-    }
-  }
-  return edges;
-}
-function componentPositionByIndex(components) {
-  return new Map(components.map((component, position) => [component.index, position]));
-}
-function computeNearestComponents(components, gapEdges) {
-  const nearest = components.map(() => ({ nearestGap: null, nearestComponentIndex: null }));
-  const positions = componentPositionByIndex(components);
-  for (const edge of gapEdges) {
-    const sourcePosition = positions.get(edge.sourceComponentIndex);
-    const targetPosition = positions.get(edge.targetComponentIndex);
-    if (sourcePosition == null || targetPosition == null) continue;
-    const source = nearest[sourcePosition];
-    if (source.nearestGap == null || edge.gap < source.nearestGap - EPSILON || Math.abs(edge.gap - source.nearestGap) <= EPSILON && edge.targetComponentIndex < (source.nearestComponentIndex ?? Infinity)) {
-      source.nearestGap = edge.gap;
-      source.nearestComponentIndex = edge.targetComponentIndex;
-    }
-    const target = nearest[targetPosition];
-    if (target.nearestGap == null || edge.gap < target.nearestGap - EPSILON || Math.abs(edge.gap - target.nearestGap) <= EPSILON && edge.sourceComponentIndex < (target.nearestComponentIndex ?? Infinity)) {
-      target.nearestGap = edge.gap;
-      target.nearestComponentIndex = edge.sourceComponentIndex;
-    }
-  }
-  return nearest;
-}
-function computeRootDistances(components, gapEdges, rootComponentIndex) {
-  if (rootComponentIndex == null) return [];
-  const positions = componentPositionByIndex(components);
-  const rootPosition = positions.get(rootComponentIndex);
-  if (rootPosition == null) {
-    throw new Error(`rootComponentIndex ${rootComponentIndex} does not match any physical component`);
-  }
-  const adjacency = components.map(() => []);
-  for (const edge of gapEdges) {
-    const sourcePosition = positions.get(edge.sourceComponentIndex);
-    const targetPosition = positions.get(edge.targetComponentIndex);
-    if (sourcePosition == null || targetPosition == null) continue;
-    adjacency[sourcePosition].push({ to: targetPosition, gap: edge.gap });
-    adjacency[targetPosition].push({ to: sourcePosition, gap: edge.gap });
-  }
-  const visited = components.map(() => false);
-  const distances = components.map(() => Infinity);
-  const parents = components.map(() => null);
-  const parentGaps = components.map(() => null);
-  distances[rootPosition] = 0;
-  for (; ; ) {
-    let current = -1;
-    for (let i = 0; i < components.length; i += 1) {
-      if (visited[i]) continue;
-      if (current === -1 || distances[i] < distances[current] - EPSILON || Math.abs(distances[i] - distances[current]) <= EPSILON && components[i].index < components[current].index) {
-        current = i;
-      }
-    }
-    if (current === -1 || !Number.isFinite(distances[current])) break;
-    visited[current] = true;
-    for (const edge of adjacency[current]) {
-      if (visited[edge.to]) continue;
-      const nextDistance = distances[current] + edge.gap;
-      if (nextDistance < distances[edge.to] - EPSILON || Math.abs(nextDistance - distances[edge.to]) <= EPSILON && components[current].index < (parents[edge.to] ?? Infinity)) {
-        distances[edge.to] = nextDistance;
-        parents[edge.to] = components[current].index;
-        parentGaps[edge.to] = edge.gap;
-      }
-    }
+function parseCameraToken(token) {
+  const normalized = token.trim();
+  const preset = CAMERA_TOKEN_DIRECTIONS[normalized];
+  if (preset) return { label: normalized, dir: preset };
+  const parts = normalized.split(":").map((s) => Number.parseFloat(s));
+  if (parts.length >= 2 && parts.length <= 3 && parts.every((n) => Number.isFinite(n))) {
+    const dir = sphericalToCameraDirection(parts[0], parts[1]);
+    const label = `az${parts[0]}_el${parts[1]}`;
+    return { label, dir, distance: parts[2] };
   }
-  return components.map((_, position) => ({
-    rootDistance: distances[position],
-    parentComponentIndex: parents[position],
-    parentGap: parentGaps[position]
-  }));
-}
-function analyzeDistanceInspection(entries, rawOptions = {}) {
-  const connectivity = analyzePhysicalConnectivity(entries, rawOptions);
-  const rootComponentIndex = rawOptions.rootComponentIndex ?? defaultRootComponentIndex(connectivity.components);
-  const gapEdges = buildGapEdges(connectivity.components);
-  const nearest = computeNearestComponents(connectivity.components, gapEdges);
-  const rooted = computeRootDistances(connectivity.components, gapEdges, rootComponentIndex);
-  const componentByIndex = /* @__PURE__ */ new Map();
-  const components = connectivity.components.map((component, position) => {
-    var _a, _b;
-    const rootData = rooted[position] ?? {
-      rootDistance: rootComponentIndex === component.index ? 0 : Infinity,
-      parentComponentIndex: null,
-      parentGap: null
-    };
-    const decorated = {
-      ...component,
-      isRoot: component.index === rootComponentIndex,
-      rootDistance: rootData.rootDistance,
-      nearestGap: ((_a = nearest[position]) == null ? void 0 : _a.nearestGap) ?? null,
-      nearestComponentIndex: ((_b = nearest[position]) == null ? void 0 : _b.nearestComponentIndex) ?? null,
-      parentComponentIndex: rootData.parentComponentIndex,
-      parentGap: rootData.parentGap
-    };
-    componentByIndex.set(component.index, decorated);
-    return decorated;
-  });
-  const objects = connectivity.objects.map((object) => {
-    const component = componentByIndex.get(object.componentIndex);
-    return {
-      ...object,
-      rootDistance: (component == null ? void 0 : component.rootDistance) ?? Infinity,
-      nearestGap: (component == null ? void 0 : component.nearestGap) ?? null,
-      nearestComponentIndex: (component == null ? void 0 : component.nearestComponentIndex) ?? null,
-      parentComponentIndex: (component == null ? void 0 : component.parentComponentIndex) ?? null,
-      parentGap: (component == null ? void 0 : component.parentGap) ?? null
-    };
-  });
-  const finiteDistances = components.map((component) => component.rootDistance).filter(Number.isFinite);
-  const maxRootDistance = finiteDistances.length > 0 ? Math.max(...finiteDistances) : 0;
-  return {
-    method: "physical-component-bbox-gap-graph",
-    distanceMethod: "axis-aligned-bbox-gap",
-    options: {
-      contactTolerance: connectivity.options.contactTolerance,
-      minOverlapVolume: connectivity.options.minOverlapVolume,
-      rootComponentIndex
-    },
-    objectCount: connectivity.objectCount,
-    componentCount: connectivity.componentCount,
-    rootComponentIndex,
-    maxRootDistance,
-    objects,
-    components,
-    gapEdges,
-    connectivity: {
-      method: connectivity.method,
-      edges: connectivity.edges
-    },
-    warnings: [...connectivity.warnings]
-  };
+  throw new Error(
+    `Unknown camera "${token}". Use a preset (front, back, side, right, top, iso) or azimuth:elevation in degrees (e.g. 45:30).`
+  );
 }
 function formatAvailableViews(views) {
   const names = Object.keys(views ?? {}).sort();
@@ -1172,136 +589,6 @@ ${body}
     pathCount
   };
 }
-const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
-  minThickness: 1.2,
-  warnThickness: 2,
-  maxThickness: 6,
-  maxSamplesPerObject: 5e3
-};
-const THICKNESS_COLORS = {
-  critical: [255, 28, 28],
-  warning: [255, 150, 0],
-  ok: [60, 220, 90],
-  thick: [70, 145, 255],
-  unknown: [90, 90, 90]
-};
-function finitePositive(value, fallback, label) {
-  if (value === void 0) return fallback;
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${label} must be a positive finite number.`);
-  }
-  return value;
-}
-function resolveThicknessInspectionOptions(raw = {}) {
-  const minThickness = finitePositive(raw.minThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.minThickness, "minThickness");
-  const warnThickness = finitePositive(raw.warnThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.warnThickness, "warnThickness");
-  const maxThickness = finitePositive(raw.maxThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxThickness, "maxThickness");
-  const maxSamplesPerObject = finitePositive(
-    raw.maxSamplesPerObject,
-    DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxSamplesPerObject,
-    "maxSamplesPerObject"
-  );
-  if (minThickness > warnThickness) {
-    throw new Error("minThickness must be less than or equal to warnThickness.");
-  }
-  if (warnThickness > maxThickness) {
-    throw new Error("warnThickness must be less than or equal to maxThickness.");
-  }
-  return {
-    minThickness,
-    warnThickness,
-    maxThickness,
-    maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject))
-  };
-}
-function lerp(a, b, t) {
-  return a + (b - a) * Math.max(0, Math.min(1, t));
-}
-function lerpColor$1(a, b, t) {
-  return [Math.round(lerp(a[0], b[0], t)), Math.round(lerp(a[1], b[1], t)), Math.round(lerp(a[2], b[2], t))];
-}
-function thicknessClass(thickness, options) {
-  if (thickness == null || !Number.isFinite(thickness) || thickness <= 0) return "unknown";
-  if (thickness <= options.minThickness) return "critical";
-  if (thickness <= options.warnThickness) return "warning";
-  if (thickness <= options.maxThickness) return "ok";
-  return "thick";
-}
-function thicknessColor(thickness, options) {
-  const cls = thicknessClass(thickness, options);
-  if (cls === "unknown") return THICKNESS_COLORS.unknown;
-  if (cls === "critical") return THICKNESS_COLORS.critical;
-  if (cls === "warning") {
-    const span = Math.max(1e-9, options.warnThickness - options.minThickness);
-    return lerpColor$1(THICKNESS_COLORS.critical, THICKNESS_COLORS.warning, ((thickness ?? 0) - options.minThickness) / span);
-  }
-  if (cls === "ok") {
-    const span = Math.max(1e-9, options.maxThickness - options.warnThickness);
-    return lerpColor$1(THICKNESS_COLORS.ok, THICKNESS_COLORS.thick, ((thickness ?? 0) - options.warnThickness) / span);
-  }
-  return THICKNESS_COLORS.thick;
-}
-function sampleArea(sample) {
-  const area = sample.area ?? 1;
-  return Number.isFinite(area) && area > 0 ? area : 1;
-}
-function weightedQuantile(samples, q) {
-  if (samples.length === 0) return null;
-  const sorted = [...samples].sort((a, b) => a.thickness - b.thickness);
-  const totalArea = sorted.reduce((sum, sample) => sum + sample.area, 0);
-  const target = totalArea * Math.max(0, Math.min(1, q));
-  let cumulative = 0;
-  for (const sample of sorted) {
-    cumulative += sample.area;
-    if (cumulative >= target) return sample.thickness;
-  }
-  return sorted[sorted.length - 1].thickness;
-}
-function percent(part, total) {
-  if (total <= 0) return 0;
-  return part / total * 100;
-}
-function summarizeThicknessSamples(samples, options) {
-  const resolved = [];
-  let totalArea = 0;
-  let resolvedArea = 0;
-  let unresolvedArea = 0;
-  let criticalArea = 0;
-  let warningArea = 0;
-  let weightedSum = 0;
-  for (const sample of samples) {
-    const area = sampleArea(sample);
-    totalArea += area;
-    const value = sample.thickness;
-    if (value == null || !Number.isFinite(value) || value <= 0) {
-      unresolvedArea += area;
-      continue;
-    }
-    resolved.push({ thickness: value, area });
-    resolvedArea += area;
-    weightedSum += value * area;
-    if (value <= options.minThickness) {
-      criticalArea += area;
-    } else if (value <= options.warnThickness) {
-      warningArea += area;
-    }
-  }
-  const values = resolved.map((sample) => sample.thickness);
-  return {
-    sampleCount: samples.length,
-    resolvedCount: resolved.length,
-    unresolvedCount: samples.length - resolved.length,
-    minThickness: values.length > 0 ? Math.min(...values) : null,
-    p05Thickness: weightedQuantile(resolved, 0.05),
-    medianThickness: weightedQuantile(resolved, 0.5),
-    meanThickness: resolvedArea > 0 ? weightedSum / resolvedArea : null,
-    maxThickness: values.length > 0 ? Math.max(...values) : null,
-    criticalAreaPercent: percent(criticalArea, resolvedArea),
-    warningAreaPercent: percent(warningArea, resolvedArea),
-    belowWarnAreaPercent: percent(criticalArea + warningArea, resolvedArea),
-    unresolvedAreaPercent: percent(unresolvedArea, totalArea)
-  };
-}
 const canvas = document.getElementById("canvas");
 const exportCanvas = document.createElement("canvas");
 const exportCtx = exportCanvas.getContext("2d");
@@ -1569,39 +856,8 @@ function updateSdfRaymarchUniforms(session) {
     sdf.material.uniforms.uIsOrthographic.value = isOrthographic;
   }
 }
-const ANGLE_DIRS = {
-  front: [0, -1, 0.2],
-  back: [0, 1, 0.2],
-  side: [1, 0, 0.2],
-  right: [1, 0, 0.2],
-  top: [0, -0.01, 1],
-  iso: [0.6, -0.6, 0.4]
-};
-function normalizeVector(dir) {
-  const len = Math.sqrt(dir[0] ** 2 + dir[1] ** 2 + dir[2] ** 2) || 1;
-  return [dir[0] / len, dir[1] / len, dir[2] / len];
-}
-function sphericalToDir(azimuthDeg, elevationDeg) {
-  const az = azimuthDeg * Math.PI / 180;
-  const el = elevationDeg * Math.PI / 180;
-  const cosEl = Math.cos(el);
-  return [cosEl * Math.sin(az), -cosEl * Math.cos(az), Math.sin(el)];
-}
-function parseCameraToken(token) {
-  const preset = ANGLE_DIRS[token];
-  if (preset) return { label: token, dir: preset };
-  const parts = token.split(":").map((s) => Number.parseFloat(s));
-  if (parts.length >= 2 && parts.length <= 3 && parts.every((n) => Number.isFinite(n))) {
-    const dir = sphericalToDir(parts[0], parts[1]);
-    const label = `az${parts[0]}_el${parts[1]}`;
-    return { label, dir, distance: parts[2] };
-  }
-  throw new Error(
-    `Unknown camera "${token}". Use a preset (front, back, side, right, top, iso) or azimuth:elevation in degrees (e.g. 45:30).`
-  );
-}
 function applyDirectionCamera(session, dir, distanceOverride) {
-  const d = normalizeVector(dir);
+  const d = normalizeCameraDirection(dir);
   const dist = distanceOverride ?? session.distance;
   session.camera.position.set(session.center.x + d[0] * dist, session.center.y + d[1] * dist, session.center.z + d[2] * dist);
   session.camera.up.set(0, 0, 1);
@@ -1782,92 +1038,6 @@ function distanceColorForRootDistance(distance, maxDistance) {
   if (t <= 0.5) return lerpColor(DISTANCE_NEAR_COLOR, DISTANCE_MID_COLOR, t * 2);
   return lerpColor(DISTANCE_MID_COLOR, DISTANCE_FAR_COLOR, (t - 0.5) * 2);
 }
-function cloneGeometryForFaceColors(geometry) {
-  return geometry.index ? geometry.toNonIndexed() : geometry.clone();
-}
-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 firstOppositeSurfaceDistance(raycaster, mesh, point, direction, epsilon, far) {
-  const origin = point.clone().addScaledVector(direction, epsilon);
-  raycaster.set(origin, direction);
-  raycaster.near = epsilon;
-  raycaster.far = far;
-  const hit = raycaster.intersectObject(mesh, false).find((entry) => entry.distance > epsilon);
-  return hit ? hit.distance + epsilon : null;
-}
-function triangleThickness(raycaster, mesh, centroid, normal, epsilon, far) {
-  const forward = firstOppositeSurfaceDistance(raycaster, mesh, centroid, normal, epsilon, far);
-  const backward = firstOppositeSurfaceDistance(raycaster, mesh, centroid, normal.clone().negate(), epsilon, far);
-  if (forward == null) return backward;
-  if (backward == null) return forward;
-  return Math.min(forward, backward);
-}
-function analyzeThicknessGeometry(sourceGeometry, options) {
-  const geometry = cloneGeometryForFaceColors(sourceGeometry);
-  const position = geometry.getAttribute("position");
-  if (!position || position.count < 3) {
-    return { geometry, samples: [], triangleCount: 0, sampledTriangleCount: 0, sampleStride: 1, warnings: ["No triangle geometry."] };
-  }
-  const triangleCount = Math.floor(position.count / 3);
-  const sampleStride = Math.max(1, Math.ceil(triangleCount / options.maxSamplesPerObject));
-  const maxDim = geometryMaxDimension(geometry);
-  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 samples = [];
-  const warnings = [];
-  const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
-  const rayMesh = new Mesh(geometry, rayMaterial);
-  const raycaster = new Raycaster();
-  if (sampleStride > 1) {
-    warnings.push(`Triangle sampling stride ${sampleStride}; increase --thickness-samples for denser analysis.`);
-  }
-  const a = new Vector3();
-  const b = new Vector3();
-  const c = new Vector3();
-  const normal = new Vector3();
-  const centroid = new Vector3();
-  let sampledTriangleCount = 0;
-  let lastThickness = null;
-  for (let tri = 0; tri < triangleCount; tri += 1) {
-    const offset = tri * 3;
-    a.fromBufferAttribute(position, offset);
-    b.fromBufferAttribute(position, offset + 1);
-    c.fromBufferAttribute(position, offset + 2);
-    normal.subVectors(b, a).cross(new Vector3().subVectors(c, a));
-    const areaTwice = normal.length();
-    const area = areaTwice * 0.5;
-    let thickness = lastThickness;
-    if (tri % sampleStride === 0) {
-      sampledTriangleCount += 1;
-      if (areaTwice <= 1e-12) {
-        thickness = null;
-      } else {
-        normal.multiplyScalar(1 / areaTwice);
-        centroid.copy(a).add(b).add(c).multiplyScalar(1 / 3);
-        thickness = triangleThickness(raycaster, rayMesh, centroid, normal, epsilon, far);
-      }
-      lastThickness = thickness;
-      samples.push({ thickness, area });
-    }
-    const color = thicknessColor(thickness, options);
-    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));
-  rayMaterial.dispose();
-  return { geometry, samples, triangleCount, sampledTriangleCount, sampleStride, warnings };
-}
 function buildMaskEntries(session) {
   const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
   return session.renderables.map((renderable, idx) => {
@@ -1957,6 +1127,7 @@ function decorateConnectivityReport(report) {
   return {
     method: report.method,
     options: report.options,
+    broadphase: report.broadphase,
     objectCount: report.objectCount,
     componentCount: report.componentCount,
     objects,
@@ -2045,6 +1216,7 @@ function decorateDistanceReport(report) {
     maxRootDistance: report.maxRootDistance,
     objects,
     components,
+    gapEdgeCount: report.gapEdgeCount,
     gapEdges: report.gapEdges,
     connectivity: report.connectivity,
     warnings: report.warnings,
@@ -2274,6 +1446,130 @@ function renderCurrentThickness(session, rawOptions) {
     material.dispose();
   }
 }
+const ROUGHNESS_SMOOTH_OPACITY = 0.16;
+const ROUGHNESS_HARSH_OPACITY = 1;
+function createRoughnessMaterial(clippingPlanes) {
+  const material = new ShaderMaterial({
+    transparent: true,
+    depthTest: true,
+    depthWrite: true,
+    clippingPlanes: clippingPlanes ?? void 0,
+    uniforms: {
+      smoothOpacity: { value: ROUGHNESS_SMOOTH_OPACITY },
+      harshOpacity: { value: ROUGHNESS_HARSH_OPACITY }
+    },
+    vertexShader: `
+      attribute vec3 color;
+      attribute float roughnessScore;
+      varying vec3 vColor;
+      varying float vRoughnessScore;
+      varying vec3 vViewNormal;
+
+      void main() {
+        vColor = color;
+        vRoughnessScore = roughnessScore;
+        vViewNormal = normalize(normalMatrix * normal);
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+      }
+    `,
+    fragmentShader: `
+      precision highp float;
+      uniform float smoothOpacity;
+      uniform float harshOpacity;
+      varying vec3 vColor;
+      varying float vRoughnessScore;
+      varying vec3 vViewNormal;
+
+      void main() {
+        vec3 shadowLight = normalize(vec3(0.32, 0.42, 0.84));
+        float shade = 0.34 + 0.48 * max(dot(normalize(vViewNormal), shadowLight), 0.0);
+        vec3 smoothShadow = vec3(0.26, 0.30, 0.35) * shade;
+        float colorMix = smoothstep(0.04, 0.35, vRoughnessScore);
+        vec3 finalColor = mix(smoothShadow, vColor, colorMix);
+        float alpha = mix(smoothOpacity, harshOpacity, smoothstep(0.02, 0.55, vRoughnessScore));
+        gl_FragColor = vec4(finalColor, alpha);
+      }
+    `
+  });
+  material.toneMapped = false;
+  return material;
+}
+function renderCurrentRoughness(session, rawOptions) {
+  const r = getRenderer(session.size, session.pixelRatio);
+  const options = resolveRoughnessInspectionOptions(rawOptions);
+  const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
+  const warnings = [];
+  const objects = [];
+  const replacements = session.renderables.map((renderable, index) => {
+    const previousMaterial = renderable.solid.material;
+    const previousGeometry = renderable.solid.geometry;
+    if (renderable.sdfRaymarch) {
+      const material2 = new MeshBasicMaterial({ transparent: true, opacity: 0, depthWrite: false });
+      material2.toneMapped = false;
+      renderable.solid.material = material2;
+      warnings.push(`${renderable.name}: SDF raymarch objects are not included in mesh roughness inspection.`);
+      return { renderable, previousMaterial, previousGeometry, material: material2, geometry: null };
+    }
+    const analysis = analyzeRoughnessGeometry(previousGeometry, options);
+    const bbox = analysis.geometry.boundingBox;
+    const sourceObject = byId.get(renderable.id);
+    if (analysis.warnings.length > 0) {
+      analysis.warnings.forEach((warning) => warnings.push(`${renderable.name}: ${warning}`));
+    }
+    objects.push({
+      index: index + 1,
+      id: renderable.id,
+      name: renderable.name,
+      groupName: renderable.groupName,
+      treePath: sourceObject == null ? void 0 : sourceObject.treePath,
+      mock: (sourceObject == null ? void 0 : sourceObject.mock) === true,
+      bbox: {
+        min: bbox ? [bbox.min.x, bbox.min.y, bbox.min.z] : [0, 0, 0],
+        max: bbox ? [bbox.max.x, bbox.max.y, bbox.max.z] : [0, 0, 0]
+      },
+      ...analysis.summary
+    });
+    const material = createRoughnessMaterial(renderable.solidMaterial.clippingPlanes);
+    renderable.solid.geometry = analysis.geometry;
+    renderable.solid.material = material;
+    return { renderable, previousMaterial, previousGeometry, material, geometry: analysis.geometry };
+  });
+  try {
+    const png = withSolidOnlyVisibility(
+      session,
+      () => withTemporarySceneBackground(session, new Color(0), () => {
+        updateSdfRaymarchUniforms(session);
+        r.render(session.scene, session.camera);
+        return captureRenderedPng(session.size);
+      })
+    );
+    return {
+      png,
+      report: {
+        method: "mesh-dihedral-angle",
+        options,
+        objectCount: objects.length,
+        objects,
+        warnings,
+        style: {
+          smoothColor: ROUGHNESS_COLORS.smooth,
+          moderateColor: ROUGHNESS_COLORS.moderate,
+          sharpColor: ROUGHNESS_COLORS.sharp,
+          harshColor: ROUGHNESS_COLORS.harsh,
+          smoothOpacity: ROUGHNESS_SMOOTH_OPACITY,
+          harshOpacity: ROUGHNESS_HARSH_OPACITY
+        }
+      }
+    };
+  } finally {
+    replacements.forEach(({ renderable, previousMaterial, previousGeometry, material, geometry }) => {
+      renderable.solid.geometry = previousGeometry;
+      renderable.solid.material = previousMaterial;
+      geometry == null ? void 0 : geometry.dispose();
+      material.dispose();
+    });
+  }
+}
 function emptySectionSvg() {
   return {
     svg: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="-1 -1 2 2" width="400" height="400"><rect x="-1" y="-1" width="2" height="2" fill="#2a2a2a"/></svg>',
@@ -2756,7 +2052,7 @@ function applyOrbitPose(session, turn, pitchDeg) {
   const pitch = MathUtils.degToRad(clampedPitch);
   const cosPitch = Math.cos(pitch);
   const dir = [Math.sin(yaw) * cosPitch, -Math.cos(yaw) * cosPitch, Math.sin(pitch)];
-  const d = normalizeVector(dir);
+  const d = normalizeCameraDirection(dir);
   session.camera.position.set(
     session.orbitTarget.x + d[0] * session.orbitRadius,
     session.orbitTarget.y + d[1] * session.orbitRadius,
@@ -3190,6 +2486,12 @@ function createSession(code, opts) {
   const scene = new Scene();
   const sceneConfig = result.sceneConfig ?? null;
   try {
+    if ((opts == null ? void 0 : opts.viewName) && (opts == null ? void 0 : opts.cameraToken)) {
+      return {
+        ok: false,
+        error: "Cannot use --view with --camera. Choose either a model-declared view or an explicit camera."
+      };
+    }
     if (opts == null ? void 0 : opts.viewName) {
       if (requestedSceneState == null ? void 0 : requestedSceneState.camera) {
         return {
@@ -3227,6 +2529,30 @@ function createSession(code, opts) {
   const fov = 45;
   const distance = maxDim / (2 * Math.tan(fov * Math.PI / 360)) * 1.6;
   const cameraFov = ((_c = requestedSceneState == null ? void 0 : requestedSceneState.camera) == null ? void 0 : _c.fov) ?? ((_d = sceneConfig == null ? void 0 : sceneConfig.camera) == null ? void 0 : _d.fov) ?? fov;
+  try {
+    if (opts == null ? void 0 : opts.cameraToken) {
+      if (requestedSceneState == null ? void 0 : requestedSceneState.camera) {
+        return {
+          ok: false,
+          error: "Cannot use camera presets/angles with an explicit render camera. Remove --camera-json or the camera field from --scene."
+        };
+      }
+      const parsed = parseCameraToken(opts.cameraToken);
+      const dir = normalizeCameraDirection(parsed.dir);
+      const tokenDistance = parsed.distance ?? distance;
+      requestedSceneState = mergeViewportRenderSceneStates(requestedSceneState, {
+        camera: {
+          projectionMode: "perspective",
+          position: [center.x + dir[0] * tokenDistance, center.y + dir[1] * tokenDistance, center.z + dir[2] * tokenDistance],
+          target: [center.x, center.y, center.z],
+          up: [0, 0, 1],
+          fov: cameraFov
+        }
+      });
+    }
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
   const joints = ((_e = result.jointsView) == null ? void 0 : _e.enabled) === false ? [] : ((_f = result.jointsView) == null ? void 0 : _f.joints) ?? [];
   const jointCouplings = ((_g = result.jointsView) == null ? void 0 : _g.enabled) === false ? [] : ((_h = result.jointsView) == null ? void 0 : _h.couplings) ?? [];
   const animationClips = ((_i = result.jointsView) == null ? void 0 : _i.enabled) === false ? [] : ((_j = result.jointsView) == null ? void 0 : _j.animations) ?? [];
@@ -3525,7 +2851,7 @@ window.__forgeRender = async (code, opts) => {
   const session = built.session;
   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) ?? "thin";
+  const edgePreset = (opts == null ? void 0 : opts.edges) ?? "off";
   setSessionMode(session, renderMode);
   if (renderMode === "solid") {
     session.renderables.forEach((r) => {
@@ -3547,11 +2873,13 @@ window.__forgeRender = async (code, opts) => {
   const distanceRenders = {};
   const collisionRenders = {};
   const thicknessRenders = {};
+  const roughnessRenders = {};
   let maskObjects = [];
   let connectivityReport = null;
   let distanceReport = null;
   let collisionReport = null;
   let thicknessReport = null;
+  let roughnessReport = null;
   let sectionAtlas = null;
   const channelViewCounts = /* @__PURE__ */ new Map();
   const markChannelViewStart = async (channel, view) => {
@@ -3592,6 +2920,13 @@ window.__forgeRender = async (code, opts) => {
         normalRenders[label] = renderCurrentNormals(session);
         await markChannelViewDone("normals", label);
       }
+      if (requestedChannels.has("roughness")) {
+        await markChannelViewStart("roughness", label);
+        const roughness = renderCurrentRoughness(session, opts == null ? void 0 : opts.roughness);
+        roughnessRenders[label] = roughness.png;
+        roughnessReport = roughness.report;
+        await markChannelViewDone("roughness", label);
+      }
       if (requestedChannels.has("mask")) {
         await markChannelViewStart("mask", label);
         const mask = renderCurrentMask(session);
@@ -3652,6 +2987,12 @@ window.__forgeRender = async (code, opts) => {
     renders,
     depth: depthRenders,
     normals: normalRenders,
+    roughness: roughnessReport ? {
+      ...roughnessReport,
+      views: roughnessRenders
+    } : {
+      views: roughnessRenders
+    },
     mask: {
       views: maskRenders,
       objects: maskObjects