forgecad 0.9.5 → 0.9.7

package/dist/assets/{app-CFy7g5WP.js → app-BE2nD6Yz.js}

@@ -1,10 +1,10 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/EditorApp-DS0AIUrZ.css","assets/landing-proof-driven-B7_RpP79.css","assets/PricingPage-BMedqFef.css"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/EditorApp-DfFT2Dn8.css","assets/landing-proof-driven-B7_RpP79.css","assets/PricingPage-BMedqFef.css"])))=>i.map(i=>d[i]);
 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);
 var _a2;
-import { c as create, r as reactExports, j as jsxRuntimeExports, a as createWithEqualityFn, R as React, T as Tb, s as schedulerExports, b as clientExports, d as reactDomExports, u as useParams, e as useSearchParams, f as useNavigate, L as Link, B as BrowserRouter, g as Routes, h as Route, N as Navigate } from "./vendor-react-Da3A2QmU.js";
-import { _ as __vitePreload, z as zipSync, s as strToU8, W as WebGLRenderer, R as Raycaster, O as OrthographicCamera$1, P as PerspectiveCamera$1, S as Scene, a as PCFSoftShadowMap, V as VSMShadowMap, b as PCFShadowMap, B as BasicShadowMap, C as ColorManagement, L as LinearSRGBColorSpace, c as SRGBColorSpace, N as NoToneMapping, A as ACESFilmicToneMapping, d as Layers, e as Color, f as RGBAFormat, U as UnsignedByteType, g as Vector3, h as Vector2, i as Clock, T as THREE, D as DoubleSide, j as REVISION, M as Mesh, I as IcosahedronGeometry, k as ShaderMaterial, l as Spherical, Q as Quaternion, m as MOUSE, n as TOUCH, o as Ray, p as Plane, q as DataTextureLoader, H as HalfFloatType, F as FloatType, r as DataUtils, t as LinearFilter, u as RedFormat, v as InstancedBufferGeometry, w as Float32BufferAttribute, x as InstancedInterleavedBuffer, y as InterleavedBufferAttribute, E as WireframeGeometry, G as Box3, J as Sphere, K as UniformsUtils, X as UniformsLib, Y as Vector4, Z as Line3, $ as Matrix4, a0 as MathUtils, a1 as Uniform, a2 as WebGLRenderTarget, a3 as DepthTexture, a4 as BackSide, a5 as ClampToEdgeWrapping, a6 as PlaneGeometry, a7 as UVMapping, a8 as DataTexture, a9 as Texture, aa as MeshBasicMaterial, ab as IntType, ac as ShortType, ad as ByteType, ae as UnsignedIntType, af as Loader, ag as LoadingManager, ah as LinearMipMapLinearFilter, ai as FileLoader, aj as NoBlending, ak as CubeReflectionMapping, al as EquirectangularReflectionMapping, am as CubeTextureLoader, an as WebGLCubeRenderTarget, ao as ConstraintSketch, ap as setSketchPlacement3D, aq as Sketch, ar as PROFILE_BACKEND_MARKER, as as FrozenShape, at as setShapeCompilePlan, au as hasAnyPorts, av as setShapePortsInternal, aw as markShapePortsUsed, ax as setParamOverrides, ay as DEFAULT_ACTIVE_BACKEND, az as isConstraintSketch, aA as updateConstraintValue, aB as getShapeCompilePlan, aC as resolveForgeRenderStyle, aD as publishSolverWasmRunDebug, aE as resolveForgeQualityPreset, aF as resolveImportPath, aG as BufferGeometry, aH as LineBasicMaterial, aI as Line$1, aJ as LineDashedMaterial, aK as DepthStencilFormat, aL as UnsignedInt248Type, aM as MeshNormalMaterial, aN as NearestFilter, aO as BasicDepthPacking, aP as EventDispatcher$1, aQ as NoColorSpace, aR as FrontSide, aS as Material, aT as AlwaysDepth, aU as BufferAttribute, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, a_ as HemisphereLight, a$ as SpotLight, b0 as PointLight, b1 as DirectionalLight, b2 as buildShapeFromCompilePlan, b3 as shapeToGeometry, b4 as sketchToSvg, b5 as sketchToDxf, b6 as runScript, b7 as MeshPhysicalMaterial, b8 as LineSegments, b9 as getRenderStylePreset, ba as AdditiveBlending, bb as CatmullRomCurve3, bc as TubeGeometry, bd as MeshStandardMaterial, be as compileSdfNode3, bf as buildSdfRaymarchFragmentShader, bg as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bh as Shape, bi as ShapeGeometry, bj as ShaderLib, bk as CylinderGeometry, bl as parseViewportCameraState, bm as createResolvedExplodeConfig, bn as explodeBoundsCenter, bo as explodeMergeBounds, bp as resolveExplodeDirective, bq as computeExplodeMotion, br as getSketchWorldMatrix, bs as explodeAdd, bt as hasExplodeOverride, bu as resolveExplodeLocalFanDirection, bv as explodeMul, bw as explodeLeafFanStage, bx as normalizeCutPlane, by as toClippingPlane, bz as findJointAnimationClip, bA as resolveJointAnimation, bB as resolveJointViewValues, bC as getShapePorts, bD as getShapeUsedPorts, bE as DEFAULT_VIEW_CONFIG, bF as getKernelFaceNameForTriangle, bG as initKernel, bH as initSolverWasm } from "./sectionPlaneMath-CykEnkvQ.js";
+import { c as create, j as jsxRuntimeExports, r as reactExports, a as createWithEqualityFn, R as React, T as Tb, s as schedulerExports, b as clientExports, d as reactDomExports, u as useParams, e as useSearchParams, f as useNavigate, L as Link, B as BrowserRouter, g as Routes, h as Route, N as Navigate } from "./vendor-react-Da3A2QmU.js";
+import { _ as __vitePreload, z as zipSync, s as strToU8, W as WebGLRenderer, R as Raycaster, O as OrthographicCamera$1, P as PerspectiveCamera$1, S as Scene, a as PCFSoftShadowMap, V as VSMShadowMap, b as PCFShadowMap, B as BasicShadowMap, C as ColorManagement, L as LinearSRGBColorSpace, c as SRGBColorSpace, N as NoToneMapping, A as ACESFilmicToneMapping, d as Layers, e as Color, f as RGBAFormat, U as UnsignedByteType, g as Vector3, h as Vector2, i as Clock, T as THREE, D as DoubleSide, j as REVISION, M as Mesh, I as IcosahedronGeometry, k as ShaderMaterial, l as Spherical, Q as Quaternion, m as MOUSE, n as TOUCH, o as Ray, p as Plane, q as DataTextureLoader, H as HalfFloatType, F as FloatType, r as DataUtils, t as LinearFilter, u as RedFormat, v as InstancedBufferGeometry, w as Float32BufferAttribute, x as InstancedInterleavedBuffer, y as InterleavedBufferAttribute, E as WireframeGeometry, G as Box3, J as Sphere, K as UniformsUtils, X as UniformsLib, Y as Vector4, Z as Line3, $ as Matrix4, a0 as MathUtils, a1 as Uniform, a2 as WebGLRenderTarget, a3 as DepthTexture, a4 as BackSide, a5 as ClampToEdgeWrapping, a6 as PlaneGeometry, a7 as UVMapping, a8 as DataTexture, a9 as Texture, aa as MeshBasicMaterial, ab as IntType, ac as ShortType, ad as ByteType, ae as UnsignedIntType, af as Loader, ag as LoadingManager, ah as LinearMipMapLinearFilter, ai as FileLoader, aj as NoBlending, ak as CubeReflectionMapping, al as EquirectangularReflectionMapping, am as CubeTextureLoader, an as WebGLCubeRenderTarget, ao as ConstraintSketch, ap as setSketchPlacement3D, aq as Sketch, ar as PROFILE_BACKEND_MARKER, as as FrozenShape, at as setShapeCompilePlan, au as hasAnyPorts, av as setShapePortsInternal, aw as markShapePortsUsed, ax as setParamOverrides, ay as DEFAULT_ACTIVE_BACKEND, az as isConstraintSketch, aA as updateConstraintValue, aB as getShapeCompilePlan, aC as resolveForgeRenderStyle, aD as publishSolverWasmRunDebug, aE as resolveForgeQualityPreset, aF as resolveImportPath, aG as BufferGeometry, aH as LineBasicMaterial, aI as Line$1, aJ as LineDashedMaterial, aK as DepthStencilFormat, aL as UnsignedInt248Type, aM as MeshNormalMaterial, aN as NearestFilter, aO as BasicDepthPacking, aP as EventDispatcher$1, aQ as NoColorSpace, aR as FrontSide, aS as Material, aT as AlwaysDepth, aU as BufferAttribute, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, a_ as HemisphereLight, a$ as SpotLight, b0 as PointLight, b1 as DirectionalLight, b2 as analyzeCollisionIntersections, b3 as shapeToGeometry, b4 as buildShapeFromCompilePlan, b5 as sketchToSvg, b6 as sketchToDxf, b7 as runScript, b8 as MeshPhysicalMaterial, b9 as LineSegments, ba as getRenderStylePreset, bb as AdditiveBlending, bc as CatmullRomCurve3, bd as TubeGeometry, be as MeshStandardMaterial, bf as compileSdfNode3, bg as buildSdfRaymarchFragmentShader, bh as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bi as Shape, bj as ShapeGeometry, bk as ShaderLib, bl as CylinderGeometry, bm as parseViewportCameraState, bn as createResolvedExplodeConfig, bo as explodeBoundsCenter, bp as explodeMergeBounds, bq as resolveExplodeDirective, br as computeExplodeMotion, bs as getSketchWorldMatrix, bt as explodeAdd, bu as hasExplodeOverride, bv as resolveExplodeLocalFanDirection, bw as explodeMul, bx as explodeLeafFanStage, by as normalizeCutPlane, bz as toClippingPlane, bA as findJointAnimationClip, bB as resolveJointAnimation, bC as resolveJointViewValues, bD as getShapePorts, bE as getShapeUsedPorts, bF as DEFAULT_VIEW_CONFIG, bG as getKernelFaceNameForTriangle, bH as initKernel, bI as initSolverWasm } from "./sectionPlaneMath-BdTjyVfs.js";
 function getCsrfToken() {
   const match = document.cookie.match(/(?:^|;\s*)fc-csrf-token=([^;]+)/);
   return match == null ? void 0 : match[1];
@@ -71,6 +71,9 @@ const authApi = {
   logout() {
     return authFetch("/api/auth/logout", { method: "POST" });
   },
+  deleteAccount() {
+    return authFetch("/api/users/me", { method: "DELETE" });
+  },
   providers() {
     return authFetch("/api/auth/providers");
   },
@@ -516,6 +519,17 @@ function applyAuthenticatedUser(set, user) {
   set({ user, loading: false, error: null, backendAvailable: true });
   startRefreshTimer();
 }
+function clearAuthenticatedState(set) {
+  stopRefreshTimer();
+  clearUserCache();
+  setCurrentUserId(void 0);
+  set({ user: void 0, loading: false, error: null });
+  useProjectStore.setState({ projects: [], activeProjectId: null, error: null });
+  try {
+    localStorage.removeItem("fc-active-project-id");
+  } catch {
+  }
+}
 const useAuthStore = create((set) => ({
   user: null,
   loading: true,
@@ -569,21 +583,58 @@ const useAuthStore = create((set) => ({
     }
   },
   async logout() {
-    stopRefreshTimer();
     try {
       await authApi.logout();
     } finally {
-      clearUserCache();
-      setCurrentUserId(void 0);
-      set({ user: void 0, loading: false, error: null });
-      useProjectStore.setState({ projects: [], activeProjectId: null, error: null });
-      try {
-        localStorage.removeItem("fc-active-project-id");
-      } catch {
-      }
+      clearAuthenticatedState(set);
+    }
+  },
+  async deleteAccount() {
+    set({ loading: true, error: null });
+    try {
+      await authApi.deleteAccount();
+      clearAuthenticatedState(set);
+    } catch (err) {
+      set({ loading: false, error: err.message || "Account deletion failed" });
+      throw err;
     }
   }
 }));
+const BRAND_MARK_SRC = "/brand/logo-mark-128.png";
+const BRAND_MARK_SRC_SET = [
+  "/brand/logo-mark-64.png 64w",
+  "/brand/logo-mark-128.png 128w",
+  "/brand/logo-mark-256.png 256w",
+  "/brand/logo-mark.png 512w"
+].join(", ");
+function BrandMark({
+  size = 24,
+  alt = "ForgeCAD logo",
+  decorative = false,
+  style
+}) {
+  const logicalSize = Math.max(1, Math.ceil(size));
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "img",
+    {
+      src: BRAND_MARK_SRC,
+      srcSet: BRAND_MARK_SRC_SET,
+      sizes: `${logicalSize}px`,
+      alt: decorative ? "" : alt,
+      "aria-hidden": decorative ? "true" : void 0,
+      width: size,
+      height: size,
+      style: {
+        width: size,
+        height: size,
+        display: "block",
+        flex: "0 0 auto",
+        objectFit: "contain",
+        ...style
+      }
+    }
+  );
+}
 let nextId = 0;
 let toasts = [];
 const listeners$1 = /* @__PURE__ */ new Set();
@@ -779,41 +830,6 @@ const styles = {
     opacity: 0.65
   }
 };
-const BRAND_MARK_SRC = "/brand/logo-mark-128.png";
-const BRAND_MARK_SRC_SET = [
-  "/brand/logo-mark-64.png 64w",
-  "/brand/logo-mark-128.png 128w",
-  "/brand/logo-mark-256.png 256w",
-  "/brand/logo-mark.png 512w"
-].join(", ");
-function BrandMark({
-  size = 24,
-  alt = "ForgeCAD logo",
-  decorative = false,
-  style
-}) {
-  const logicalSize = Math.max(1, Math.ceil(size));
-  return /* @__PURE__ */ jsxRuntimeExports.jsx(
-    "img",
-    {
-      src: BRAND_MARK_SRC,
-      srcSet: BRAND_MARK_SRC_SET,
-      sizes: `${logicalSize}px`,
-      alt: decorative ? "" : alt,
-      "aria-hidden": decorative ? "true" : void 0,
-      width: size,
-      height: size,
-      style: {
-        width: size,
-        height: size,
-        display: "block",
-        flex: "0 0 auto",
-        objectFit: "contain",
-        ...style
-      }
-    }
-  );
-}
 function getQueryParam(name) {
   return new URLSearchParams(window.location.search).get(name);
 }
@@ -856,7 +872,7 @@ function toRGB555(colorHex) {
   if (!rgb) return 0;
   return 32768 | rgb.r >> 3 << 10 | rgb.g >> 3 << 5 | rgb.b >> 3;
 }
-function rgbToHex(r2, g2, b2) {
+function rgbToHex$1(r2, g2, b2) {
   const toHex = (v) => v.toString(16).padStart(2, "0").toUpperCase();
   return `#${toHex(r2)}${toHex(g2)}${toHex(b2)}`;
 }
@@ -871,7 +887,7 @@ function buildPure3mfBuffer(objects, options = {}) {
     if (obj.color) {
       const rgb = parseHexColor(obj.color);
       if (rgb) {
-        const hex = rgbToHex(rgb.r, rgb.g, rgb.b);
+        const hex = rgbToHex$1(rgb.r, rgb.g, rgb.b);
         if (!colorMap.has(hex)) {
           colorMap.set(hex, colors.length);
           colors.push({ hex, objectIndices: [] });
@@ -908,7 +924,7 @@ function buildPure3mfBuffer(objects, options = {}) {
     if (obj.color && hasColors) {
       const rgb = parseHexColor(obj.color);
       if (rgb) {
-        const hex = rgbToHex(rgb.r, rgb.g, rgb.b);
+        const hex = rgbToHex$1(rgb.r, rgb.g, rgb.b);
         const colorIdx = colorMap.get(hex);
         if (colorIdx !== void 0) {
           pidAttr = ` pid="${colorgroupId}" pindex="${colorIdx}"`;
@@ -14920,7 +14936,7 @@ function planLabel(plan) {
     case "boolean":
       return plan.op === "union" ? "Union" : plan.op === "difference" ? "Subtract" : "Intersect";
     case "transform":
-      return planLabel(plan.base);
+      return formatTransformLabel(plan.steps);
     case "queryOwner":
       return planLabel(plan.base);
     case "fillet":
@@ -14969,12 +14985,53 @@ function planLabel(plan) {
       return `STEP Import (${plan.filePath})`;
   }
 }
+function formatTransformLabel(steps) {
+  if (steps.length === 0) return "Transform";
+  const kinds = [...new Set(steps.map((step) => step.kind))];
+  return `Transform (${kinds.join(", ")})`;
+}
 function resolvePlan(plan) {
   return plan.kind === "queryOwner" ? resolvePlan(plan.base) : plan;
 }
 function wrapWithTransforms(plan, transformStacks) {
   return transformStacks.reduceRight((inner, steps) => ({ kind: "transform", base: inner, steps }), plan);
 }
+const SHAPE_COMPILE_PLAN_CACHE_KEY_VERSION = "shape-plan-v1";
+function stableJsonEncode(value, arrayMember) {
+  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
+    return arrayMember ? "null" : void 0;
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableJsonEncode(item, true) ?? "null").join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+  const encodedEntries = [];
+  for (const [key, item] of entries) {
+    const encoded = stableJsonEncode(item, false);
+    if (encoded !== void 0) encodedEntries.push(`${JSON.stringify(key)}:${encoded}`);
+  }
+  return `{${encodedEntries.join(",")}}`;
+}
+function stableJsonStringify(value) {
+  return stableJsonEncode(value, false) ?? "null";
+}
+function shapeCompilePlanCacheKey(plan) {
+  return `${SHAPE_COMPILE_PLAN_CACHE_KEY_VERSION}:${stableJsonStringify(plan)}`;
+}
+function constructionStepGeometryCacheKey(step) {
+  return step.cumulativePlanCacheKey;
+}
+function makeConstructionStep(step) {
+  const planCacheKey = shapeCompilePlanCacheKey(step.plan);
+  return {
+    ...step,
+    planCacheKey,
+    cumulativePlanCacheKey: step.cumulativePlan === step.plan ? planCacheKey : shapeCompilePlanCacheKey(step.cumulativePlan)
+  };
+}
 function linearizeConstructionSteps(rootPlan, objectId) {
   const steps = [];
   const ancestorTransforms = [];
@@ -15004,16 +15061,18 @@ function linearizeConstructionSteps(rootPlan, objectId) {
           shapes: childCumulatives
         };
         const worldPlan = wrapWithTransforms(cumulativePlan, ancestorTransforms);
-        steps.push({
-          index: steps.length,
-          label: planLabel(resolved),
-          role: "operation",
-          displayAsTool,
-          stackPopCount: childCumulatives.length,
-          plan: worldPlan,
-          cumulativePlan: worldPlan,
-          objectId
-        });
+        steps.push(
+          makeConstructionStep({
+            index: steps.length,
+            label: planLabel(resolved),
+            role: "operation",
+            displayAsTool,
+            stackPopCount: childCumulatives.length,
+            plan: worldPlan,
+            cumulativePlan: worldPlan,
+            objectId
+          })
+        );
         return cumulativePlan;
       }
       // ── Modifications: visit base, then add modification step ──
@@ -15031,16 +15090,18 @@ function linearizeConstructionSteps(rootPlan, objectId) {
         const baseCumulative = visit(resolved.base, options);
         const modPlan = { ...resolved, base: baseCumulative };
         const worldPlan = wrapWithTransforms(modPlan, ancestorTransforms);
-        steps.push({
-          index: steps.length,
-          label: planLabel(resolved),
-          role: "modification",
-          displayAsTool,
-          stackPopCount: 1,
-          plan: worldPlan,
-          cumulativePlan: worldPlan,
-          objectId
-        });
+        steps.push(
+          makeConstructionStep({
+            index: steps.length,
+            label: planLabel(resolved),
+            role: "modification",
+            displayAsTool,
+            stackPopCount: 1,
+            plan: worldPlan,
+            cumulativePlan: worldPlan,
+            objectId
+          })
+        );
         return modPlan;
       }
       case "surfaceExtend":
@@ -15048,16 +15109,18 @@ function linearizeConstructionSteps(rootPlan, objectId) {
         const baseCumulative = visit(resolved.base, options);
         const modPlan = { ...resolved, base: baseCumulative };
         const worldPlan = wrapWithTransforms(modPlan, ancestorTransforms);
-        steps.push({
-          index: steps.length,
-          label: planLabel(resolved),
-          role: "modification",
-          displayAsTool,
-          stackPopCount: 1,
-          plan: worldPlan,
-          cumulativePlan: worldPlan,
-          objectId
-        });
+        steps.push(
+          makeConstructionStep({
+            index: steps.length,
+            label: planLabel(resolved),
+            role: "modification",
+            displayAsTool,
+            stackPopCount: 1,
+            plan: worldPlan,
+            cumulativePlan: worldPlan,
+            objectId
+          })
+        );
         return modPlan;
       }
       case "surfaceSew": {
@@ -15071,31 +15134,35 @@ function linearizeConstructionSteps(rootPlan, objectId) {
           tolerance: resolved.tolerance
         };
         const worldPlan = wrapWithTransforms(cumulativePlan, ancestorTransforms);
-        steps.push({
-          index: steps.length,
-          label: planLabel(resolved),
-          role: "operation",
-          displayAsTool,
-          stackPopCount: childCumulatives.length,
-          plan: worldPlan,
-          cumulativePlan: worldPlan,
-          objectId
-        });
+        steps.push(
+          makeConstructionStep({
+            index: steps.length,
+            label: planLabel(resolved),
+            role: "operation",
+            displayAsTool,
+            stackPopCount: childCumulatives.length,
+            plan: worldPlan,
+            cumulativePlan: worldPlan,
+            objectId
+          })
+        );
         return cumulativePlan;
       }
       // ── Leaf primitives: add directly as a step ──
       default: {
         const worldPlan = wrapWithTransforms(resolved, ancestorTransforms);
-        steps.push({
-          index: steps.length,
-          label: planLabel(resolved),
-          role: "primitive",
-          displayAsTool,
-          stackPopCount: 0,
-          plan: worldPlan,
-          cumulativePlan: worldPlan,
-          objectId
-        });
+        steps.push(
+          makeConstructionStep({
+            index: steps.length,
+            label: planLabel(resolved),
+            role: "primitive",
+            displayAsTool,
+            stackPopCount: 0,
+            plan: worldPlan,
+            cumulativePlan: worldPlan,
+            objectId
+          })
+        );
         return resolved;
       }
     }
@@ -15788,7 +15855,7 @@ const CRASH_COOLDOWN_MS = 2e3;
 class EvalWorkerClient {
   constructor(workerFactory = () => new Worker(new URL(
     /* @vite-ignore */
-    "/assets/evalWorker-c_SB9gg3.js",
+    "/assets/evalWorker-Ds5U4xtN.js",
     import.meta.url
   ), { type: "module" })) {
     __publicField(this, "worker", null);
@@ -17253,6 +17320,14 @@ function buildRunState(previewFile, runResult, state2) {
   };
 }
 const VIEW_PREFERENCES_KEY = "fc-view-preferences-v1";
+const INSPECT_POINT_SAMPLE_COUNT_MIN = 100;
+const INSPECT_POINT_SAMPLE_COUNT_MAX = 1e4;
+const DEFAULT_INSPECT_POINT_SAMPLE_COUNT = 2e3;
+const resolveInspectPointSampleCount = (value) => {
+  const numeric = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(numeric)) return DEFAULT_INSPECT_POINT_SAMPLE_COUNT;
+  return Math.max(INSPECT_POINT_SAMPLE_COUNT_MIN, Math.min(INSPECT_POINT_SAMPLE_COUNT_MAX, Math.round(numeric)));
+};
 const readViewPreferences = () => {
   if (typeof window === "undefined") return {};
   try {
@@ -17361,6 +17436,22 @@ const initialActive = (() => {
   return fallback;
 })();
 const INITIAL_SAVED = {};
+const VIEW_INSPECT_CHANNELS = /* @__PURE__ */ new Set([
+  "none",
+  "mask",
+  "connectivity",
+  "distance",
+  "collisions",
+  "thickness",
+  "roughness"
+]);
+const INSPECT_DISPLAY_MODES = /* @__PURE__ */ new Set(["heatmap", "points", "both"]);
+function resolveViewInspectChannel(value) {
+  return typeof value === "string" && VIEW_INSPECT_CHANNELS.has(value) ? value : "none";
+}
+function resolveInspectDisplayMode(value) {
+  return typeof value === "string" && INSPECT_DISPLAY_MODES.has(value) ? value : "heatmap";
+}
 const initialViewPreferences = readViewPreferences();
 const initialPreviewFile = resolvePreviewFile(initialActive, INITIAL_FILES);
 const initialObjectSettingsByFile = (() => {
@@ -18119,6 +18210,24 @@ Switch to LOCAL mode or wait for the server to recover.`,
     writeViewPreferences({ renderMode: mode });
     set({ renderMode: mode });
   },
+  inspectChannel: resolveViewInspectChannel(initialViewPreferences.inspectChannel),
+  setInspectChannel: (channel) => {
+    const next = resolveViewInspectChannel(channel);
+    writeViewPreferences({ inspectChannel: next });
+    set({ inspectChannel: next });
+  },
+  inspectDisplayMode: resolveInspectDisplayMode(initialViewPreferences.inspectDisplayMode),
+  setInspectDisplayMode: (mode) => {
+    const next = resolveInspectDisplayMode(mode);
+    writeViewPreferences({ inspectDisplayMode: next });
+    set({ inspectDisplayMode: next });
+  },
+  inspectPointSampleCount: resolveInspectPointSampleCount(initialViewPreferences.inspectPointSampleCount),
+  setInspectPointSampleCount: (count) => {
+    const next = resolveInspectPointSampleCount(count);
+    writeViewPreferences({ inspectPointSampleCount: next });
+    set({ inspectPointSampleCount: next });
+  },
   projectionMode: initialViewPreferences.projectionMode ?? "perspective",
   setProjectionMode: (mode) => {
     writeViewPreferences({ projectionMode: mode });
@@ -26690,6 +26799,129 @@ function ClippingManager({ active }) {
   }, [gl, active]);
   return null;
 }
+const COLLISION_SOURCE_OPACITY = 0.22;
+const COLLISION_SOURCE_COLOR = [180, 200, 220];
+const COLLISION_HIGHLIGHT_COLOR = [255, 68, 16];
+const COLLISION_PALETTE = [
+  COLLISION_HIGHLIGHT_COLOR,
+  [0, 204, 255],
+  [255, 214, 0],
+  [66, 220, 120],
+  [255, 76, 196],
+  [142, 106, 255],
+  [255, 145, 48],
+  [86, 232, 202],
+  [210, 245, 60],
+  [255, 120, 120],
+  [80, 150, 255],
+  [190, 110, 60]
+];
+const MASK_PALETTE = [
+  [230, 25, 75],
+  [60, 180, 75],
+  [255, 225, 25],
+  [0, 130, 200],
+  [245, 130, 48],
+  [145, 30, 180],
+  [70, 240, 240],
+  [240, 50, 230],
+  [210, 245, 60],
+  [250, 190, 190],
+  [0, 128, 128],
+  [230, 190, 255],
+  [170, 110, 40],
+  [255, 250, 200],
+  [128, 0, 0],
+  [170, 255, 195],
+  [128, 128, 0],
+  [255, 215, 180],
+  [0, 0, 128],
+  [128, 128, 128]
+];
+function rgbToHex(color2) {
+  return `#${color2.map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+function maskRgbForIndex(index) {
+  return MASK_PALETTE[index % MASK_PALETTE.length];
+}
+function maskColorForIndex(index) {
+  return rgbToHex(maskRgbForIndex(index));
+}
+function collisionColorForIndex(index) {
+  return rgbToHex(COLLISION_PALETTE[(index - 1) % COLLISION_PALETTE.length]);
+}
+const MAX_VIEWPORT_COLLISION_CANDIDATES = 200;
+const MAX_VIEWPORT_COLLISION_MS = 1e3;
+function matrixToCollisionMat4(matrix) {
+  if (!matrix) return void 0;
+  const e2 = matrix.elements;
+  return [e2[0], e2[1], e2[2], e2[3], e2[4], e2[5], e2[6], e2[7], e2[8], e2[9], e2[10], e2[11], e2[12], e2[13], e2[14], e2[15]];
+}
+function buildCollisionEntries(objects, objectSettings, objectMatrices) {
+  const entries = [];
+  objects.forEach((obj) => {
+    var _a3;
+    if (!obj.shape) return;
+    if (((_a3 = objectSettings[obj.id]) == null ? void 0 : _a3.visible) === false) return;
+    try {
+      const bb = obj.shape.boundingBox();
+      entries.push({
+        id: obj.id,
+        name: obj.name,
+        shape: obj.shape,
+        min: [bb.min[0], bb.min[1], bb.min[2]],
+        max: [bb.max[0], bb.max[1], bb.max[2]],
+        transform: matrixToCollisionMat4(objectMatrices[obj.id]),
+        groupName: obj.groupName,
+        treePath: obj.treePath,
+        mock: obj.mock
+      });
+    } catch {
+    }
+  });
+  return entries;
+}
+function CollisionInspectionOverlay({
+  objects,
+  objectSettings,
+  objectMatrices
+}) {
+  const collisionGeometries = reactExports.useMemo(() => {
+    const report = analyzeCollisionIntersections(buildCollisionEntries(objects, objectSettings, objectMatrices), {
+      maxCandidatePairs: MAX_VIEWPORT_COLLISION_CANDIDATES,
+      maxElapsedMs: MAX_VIEWPORT_COLLISION_MS,
+      includeBBoxCandidates: false
+    });
+    return report.collisions.flatMap((collision) => {
+      try {
+        const geometry = shapeToGeometry(collision.shape);
+        return [
+          {
+            id: collision.id,
+            color: collisionColorForIndex(collision.index),
+            solid: geometry.solid,
+            edges: geometry.edges
+          }
+        ];
+      } catch {
+        return [];
+      }
+    });
+  }, [objectMatrices, objectSettings, objects]);
+  reactExports.useEffect(() => {
+    return () => {
+      collisionGeometries.forEach((geometry) => {
+        var _a3;
+        geometry.solid.dispose();
+        (_a3 = geometry.edges) == null ? void 0 : _a3.dispose();
+      });
+    };
+  }, [collisionGeometries]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("group", { children: collisionGeometries.map((geometry) => /* @__PURE__ */ jsxRuntimeExports.jsxs("group", { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: geometry.solid, renderOrder: 20, raycast: () => null, children: /* @__PURE__ */ jsxRuntimeExports.jsx("meshBasicMaterial", { color: geometry.color, depthTest: true, depthWrite: true, toneMapped: false }) }),
+    geometry.edges && /* @__PURE__ */ jsxRuntimeExports.jsx("lineSegments", { geometry: geometry.edges, renderOrder: 21, raycast: () => null, children: /* @__PURE__ */ jsxRuntimeExports.jsx("lineBasicMaterial", { color: "#ffffff", transparent: true, opacity: 0.65, depthTest: false, toneMapped: false }) })
+  ] }, geometry.id)) });
+}
 function ConstructionGhostOverlay({ matrix }) {
   const ghost = useForgeStore((s) => s.constructionGhost);
   const { solidGeo, edgesGeo } = reactExports.useMemo(() => {
@@ -26712,7 +26944,8 @@ function ConstructionGhostOverlay({ matrix }) {
 const MAX_CACHE_SIZE = 40;
 const geometryCache = /* @__PURE__ */ new Map();
 function getCachedGeometry(step) {
-  const cached = geometryCache.get(step.index);
+  const cacheKey = constructionStepGeometryCacheKey(step);
+  const cached = geometryCache.get(cacheKey);
   if (cached) return cached;
   try {
     const shape = buildShapeFromCompilePlan(step.cumulativePlan);
@@ -26728,7 +26961,7 @@ function getCachedGeometry(step) {
         geometryCache.delete(firstKey);
       }
     }
-    geometryCache.set(step.index, entry);
+    geometryCache.set(cacheKey, entry);
     return entry;
   } catch {
     return null;
@@ -28914,7 +29147,7 @@ function generateReportInWorker(options) {
   return new Promise((resolve2, reject) => {
     const worker = new Worker(new URL(
       /* @vite-ignore */
-      "/assets/reportWorker-BLkuIoS8.js",
+      "/assets/reportWorker-CU8RZ4O0.js",
       import.meta.url
     ), { type: "module" });
     const cleanup = () => {
@@ -32118,16 +32351,44 @@ const PHASE_CONFIG = {
   evaluating: { color: "#4a9eff", label: "Evaluating model" },
   serializing: { color: "#7c4dff", label: "Preparing display" },
   exporting: { color: "#4caf50", label: "Exporting geometry" },
+  inspecting: { color: "#14b8a6", label: "Generating inspect view" },
   idle: { color: "#888", label: "" }
 };
 const PHASE_ORDER = ["kernel-init", "evaluating", "serializing"];
-function EvaluationIndicator({ phase }) {
+function formatEvaluationBackendLabel(activeBackend, computeTarget) {
+  const backend = activeBackend === "occt" ? "OCCT" : activeBackend === "manifold" ? "Manifold" : activeBackend === "truck" ? "Truck" : "kernel";
+  return computeTarget === "server" ? `Server ${backend}` : `Local ${backend}`;
+}
+function constructionStepRoleSymbol(role) {
+  if (role === "primitive") return "+";
+  if (role === "operation") return "->";
+  return "~";
+}
+function constructionStepPreview(constructionSteps, previewStepIndex) {
+  const stepCount = constructionSteps.length;
+  const displayStepIndex = stepCount > 0 ? (previewStepIndex % stepCount + stepCount) % stepCount : 0;
+  return {
+    displayStepIndex,
+    previewStep: stepCount > 0 ? constructionSteps[displayStepIndex] : null,
+    progress: stepCount > 1 ? (displayStepIndex + 1) / stepCount : 1
+  };
+}
+function EvaluationIndicator({
+  phase,
+  label,
+  constructionSteps = [],
+  activeBackend,
+  computeTarget
+}) {
   const [frame2, setFrame] = reactExports.useState(0);
   const [elapsed, setElapsed] = reactExports.useState(0);
+  const [previewStepIndex, setPreviewStepIndex] = reactExports.useState(0);
   const startRef = reactExports.useRef(Date.now());
+  const stepCount = constructionSteps.length;
   reactExports.useEffect(() => {
     startRef.current = Date.now();
     setElapsed(0);
+    setPreviewStepIndex(0);
   }, [phase]);
   reactExports.useEffect(() => {
     const spinnerInterval = setInterval(() => setFrame((f2) => (f2 + 1) % BRAILLE_FRAMES.length), 80);
@@ -32137,9 +32398,17 @@ function EvaluationIndicator({ phase }) {
       clearInterval(timerInterval);
     };
   }, []);
+  reactExports.useEffect(() => {
+    setPreviewStepIndex(0);
+    if (stepCount <= 1) return;
+    const interval = setInterval(() => setPreviewStepIndex((i) => (i + 1) % stepCount), 700);
+    return () => clearInterval(interval);
+  }, [stepCount]);
   const config = PHASE_CONFIG[phase] ?? PHASE_CONFIG["evaluating"];
   const elapsedSec = (elapsed / 1e3).toFixed(1);
-  const phaseIdx = PHASE_ORDER.indexOf(phase);
+  const phaseOrder = PHASE_ORDER.includes(phase) ? PHASE_ORDER : [phase];
+  const phaseIdx = phaseOrder.indexOf(phase);
+  const { displayStepIndex, previewStep, progress } = constructionStepPreview(constructionSteps, previewStepIndex);
   return /* @__PURE__ */ jsxRuntimeExports.jsxs(
     "div",
     {
@@ -32147,51 +32416,368 @@ function EvaluationIndicator({ phase }) {
         position: "absolute",
         bottom: 16,
         right: 16,
+        width: previewStep ? "min(360px, calc(100vw - 32px))" : void 0,
         background: "var(--fc-bgPanel)",
         border: "1px solid var(--fc-border)",
         borderRadius: 8,
-        padding: "8px 14px",
+        padding: previewStep ? "10px 12px" : "8px 14px",
         pointerEvents: "none",
-        display: "flex",
-        alignItems: "center",
-        gap: 10,
+        display: "grid",
+        gap: previewStep ? 8 : 0,
         fontSize: 12,
         animation: "fc-fadein 0.2s ease-out",
         boxShadow: "0 4px 16px rgba(0,0,0,0.25)"
       },
       children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: config.color, fontSize: 16, fontWeight: 700, width: 16, textAlign: "center" }, children: BRAILLE_FRAMES[frame2] }),
-        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: "var(--fc-text)", fontWeight: 500 }, children: config.label }),
-        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { display: "flex", gap: 4, alignItems: "center", marginLeft: 2 }, children: PHASE_ORDER.map((p2, i) => {
-          var _a3;
-          return /* @__PURE__ */ jsxRuntimeExports.jsx(
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", alignItems: "center", gap: 10, minWidth: 0 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: config.color, fontSize: 16, fontWeight: 700, width: 16, textAlign: "center", flex: "0 0 auto" }, children: BRAILLE_FRAMES[frame2] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
             "span",
             {
               style: {
-                width: 6,
-                height: 6,
-                borderRadius: "50%",
-                background: i <= phaseIdx ? ((_a3 = PHASE_CONFIG[p2]) == null ? void 0 : _a3.color) ?? "var(--fc-border)" : "var(--fc-border)",
-                transition: "background 0.3s ease",
-                animation: i === phaseIdx ? "fc-pulse 1.2s ease-in-out infinite" : void 0
+                color: "var(--fc-text)",
+                fontWeight: 500,
+                minWidth: 0,
+                overflow: "hidden",
+                textOverflow: "ellipsis",
+                whiteSpace: "nowrap"
+              },
+              children: label ?? config.label
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { display: "flex", gap: 4, alignItems: "center", marginLeft: "auto", flex: "0 0 auto" }, children: phaseOrder.map((p2, i) => {
+            var _a3;
+            return /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "span",
+              {
+                style: {
+                  width: 6,
+                  height: 6,
+                  borderRadius: "50%",
+                  background: i <= phaseIdx ? ((_a3 = PHASE_CONFIG[p2]) == null ? void 0 : _a3.color) ?? "var(--fc-border)" : "var(--fc-border)",
+                  transition: "background 0.3s ease",
+                  animation: i === phaseIdx ? "fc-pulse 1.2s ease-in-out infinite" : void 0
+                }
+              },
+              p2
+            );
+          }) }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { style: { color: "var(--fc-textDim)", fontVariantNumeric: "tabular-nums", fontSize: 11, flex: "0 0 auto" }, children: [
+            elapsedSec,
+            "s"
+          ] })
+        ] }),
+        previewStep && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "grid", gap: 6, minWidth: 0 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", alignItems: "center", gap: 8, minWidth: 0 }, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "span",
+              {
+                style: {
+                  color: "var(--fc-textDim)",
+                  fontSize: 10,
+                  textTransform: "uppercase",
+                  fontWeight: 700,
+                  letterSpacing: 0,
+                  flex: "0 0 auto"
+                },
+                children: "Cached build path"
               }
-            },
-            p2
-          );
-        }) }),
-        /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { style: { color: "var(--fc-textDim)", fontVariantNumeric: "tabular-nums", fontSize: 11 }, children: [
-          elapsedSec,
-          "s"
+            ),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "span",
+              {
+                style: {
+                  color: "var(--fc-textMuted)",
+                  fontSize: 11,
+                  minWidth: 0,
+                  overflow: "hidden",
+                  textOverflow: "ellipsis",
+                  whiteSpace: "nowrap"
+                },
+                children: formatEvaluationBackendLabel(activeBackend, computeTarget)
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", alignItems: "center", gap: 8, minWidth: 0 }, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsxs(
+              "span",
+              {
+                style: {
+                  color: config.color,
+                  fontVariantNumeric: "tabular-nums",
+                  fontSize: 11,
+                  fontWeight: 700,
+                  flex: "0 0 auto",
+                  width: 46
+                },
+                children: [
+                  displayStepIndex + 1,
+                  "/",
+                  stepCount
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxRuntimeExports.jsxs(
+              "span",
+              {
+                style: {
+                  color: "var(--fc-text)",
+                  minWidth: 0,
+                  overflow: "hidden",
+                  textOverflow: "ellipsis",
+                  whiteSpace: "nowrap"
+                },
+                children: [
+                  constructionStepRoleSymbol(previewStep.role),
+                  " ",
+                  previewStep.label
+                ]
+              }
+            ),
+            previewStep.displayAsTool && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: config.color, fontSize: 11, flex: "0 0 auto" }, children: "tool" })
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { height: 3, borderRadius: 999, background: "var(--fc-borderLight)", overflow: "hidden" }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "div",
+            {
+              style: {
+                width: `${Math.round(progress * 100)}%`,
+                height: "100%",
+                borderRadius: 999,
+                background: config.color,
+                transition: "width 0.2s ease-out"
+              }
+            }
+          ) })
         ] })
       ]
     }
   );
 }
+const MIN_FIELD_GRID_SIZE = 18;
+const MAX_FIELD_GRID_SIZE = 32;
+const MAX_BLEND_SAMPLES = 12;
+const MAX_SEARCH_RADIUS = 5;
+const SAMPLE_RING_OFFSETS = [];
+for (let radius = 0; radius <= MAX_SEARCH_RADIUS; radius += 1) {
+  const ring = [];
+  for (let x = -radius; x <= radius; x += 1) {
+    for (let y = -radius; y <= radius; y += 1) {
+      for (let z = -radius; z <= radius; z += 1) {
+        if (Math.max(Math.abs(x), Math.abs(y), Math.abs(z)) === radius) ring.push([x, y, z]);
+      }
+    }
+  }
+  SAMPLE_RING_OFFSETS.push(ring);
+}
+const INSPECT_HEATMAP_VERTEX_SHADER = `
+  varying vec3 vLocalPosition;
+  varying vec3 vViewDirection;
+  varying vec3 vViewNormal;
+  #include <clipping_planes_pars_vertex>
+
+  void main() {
+    vLocalPosition = position;
+    vViewNormal = normalize(normalMatrix * normal);
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    vViewDirection = normalize(-mvPosition.xyz);
+    gl_Position = projectionMatrix * mvPosition;
+    #include <clipping_planes_vertex>
+  }
+`;
+const INSPECT_HEATMAP_FRAGMENT_SHADER = `
+  uniform sampler2D uField;
+  uniform float uGridSize;
+  uniform vec3 uBoundsMin;
+  uniform vec3 uBoundsSize;
+  varying vec3 vLocalPosition;
+  varying vec3 vViewDirection;
+  varying vec3 vViewNormal;
+  #include <clipping_planes_pars_fragment>
+
+  vec2 fieldUv(vec3 index) {
+    vec2 atlasSize = vec2(uGridSize * uGridSize, uGridSize);
+    float atlasX = index.x + index.z * uGridSize;
+    return (vec2(atlasX, index.y) + 0.5) / atlasSize;
+  }
+
+  vec3 fetchField(vec3 index) {
+    vec3 bounded = clamp(index, vec3(0.0), vec3(uGridSize - 1.0));
+    return texture2D(uField, fieldUv(bounded)).rgb;
+  }
+
+  vec3 sampleField(vec3 position) {
+    vec3 normalized = clamp((position - uBoundsMin) / max(uBoundsSize, vec3(0.000001)), vec3(0.0), vec3(1.0));
+    vec3 coord = normalized * (uGridSize - 1.0);
+    vec3 base = floor(coord);
+    vec3 f = fract(coord);
+
+    vec3 c000 = fetchField(base + vec3(0.0, 0.0, 0.0));
+    vec3 c100 = fetchField(base + vec3(1.0, 0.0, 0.0));
+    vec3 c010 = fetchField(base + vec3(0.0, 1.0, 0.0));
+    vec3 c110 = fetchField(base + vec3(1.0, 1.0, 0.0));
+    vec3 c001 = fetchField(base + vec3(0.0, 0.0, 1.0));
+    vec3 c101 = fetchField(base + vec3(1.0, 0.0, 1.0));
+    vec3 c011 = fetchField(base + vec3(0.0, 1.0, 1.0));
+    vec3 c111 = fetchField(base + vec3(1.0, 1.0, 1.0));
+
+    vec3 c00 = mix(c000, c100, f.x);
+    vec3 c10 = mix(c010, c110, f.x);
+    vec3 c01 = mix(c001, c101, f.x);
+    vec3 c11 = mix(c011, c111, f.x);
+    return mix(mix(c00, c10, f.y), mix(c01, c11, f.y), f.z);
+  }
+
+  void main() {
+    #include <clipping_planes_fragment>
+    vec3 heat = sampleField(vLocalPosition);
+    float rim = pow(1.0 - clamp(dot(normalize(vViewNormal), normalize(vViewDirection)), 0.0, 1.0), 2.0);
+    vec3 color = heat * (0.88 + rim * 0.2) + vec3(0.025, 0.04, 0.055) * rim;
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+function gridKey(x, y, z) {
+  return `${x},${y},${z}`;
+}
+function buildGeometryBounds(geometry) {
+  const position = geometry.getAttribute("position");
+  if (!position || position.count === 0) return null;
+  const bounds = new Box3().setFromBufferAttribute(position);
+  if (bounds.isEmpty()) return null;
+  const size = bounds.getSize(new Vector3());
+  const pad = Math.max(size.x, size.y, size.z, 1) * 1e-5;
+  bounds.expandByScalar(pad);
+  return bounds;
+}
+function buildSampleGrid(pointCloud) {
+  const sampleCount = Math.floor(pointCloud.positions.length / 3);
+  if (sampleCount <= 0) return null;
+  const bounds = new Box3();
+  const point = new Vector3();
+  for (let sample = 0; sample < sampleCount; sample += 1) {
+    const offset = sample * 3;
+    bounds.expandByPoint(point.set(pointCloud.positions[offset], pointCloud.positions[offset + 1], pointCloud.positions[offset + 2]));
+  }
+  const size = bounds.getSize(new Vector3());
+  const maxDim = Math.max(size.x, size.y, size.z);
+  const cellSize = maxDim > 0 ? Math.max(maxDim / Math.cbrt(sampleCount), 1e-6) : 1;
+  const cells = /* @__PURE__ */ new Map();
+  for (let sample = 0; sample < sampleCount; sample += 1) {
+    const offset = sample * 3;
+    const x = Math.floor((pointCloud.positions[offset] - bounds.min.x) / cellSize);
+    const y = Math.floor((pointCloud.positions[offset + 1] - bounds.min.y) / cellSize);
+    const z = Math.floor((pointCloud.positions[offset + 2] - bounds.min.z) / cellSize);
+    const key = gridKey(x, y, z);
+    const entries = cells.get(key);
+    if (entries) {
+      entries.push(sample);
+    } else {
+      cells.set(key, [sample]);
+    }
+  }
+  return { origin: bounds.min, cellSize, cells };
+}
+function fieldGridSizeForSampleCount(sampleCount) {
+  if (sampleCount <= 0) return MIN_FIELD_GRID_SIZE;
+  const scaled = Math.ceil(Math.cbrt(sampleCount) * 2.6);
+  return Math.max(MIN_FIELD_GRID_SIZE, Math.min(MAX_FIELD_GRID_SIZE, scaled));
+}
+function distanceSquaredToSample(pointCloud, sample, point) {
+  const offset = sample * 3;
+  return (pointCloud.positions[offset] - point.x) ** 2 + (pointCloud.positions[offset + 1] - point.y) ** 2 + (pointCloud.positions[offset + 2] - point.z) ** 2;
+}
+function nearestSamples(point, pointCloud, sampleGrid) {
+  const baseX = Math.floor((point.x - sampleGrid.origin.x) / sampleGrid.cellSize);
+  const baseY = Math.floor((point.y - sampleGrid.origin.y) / sampleGrid.cellSize);
+  const baseZ = Math.floor((point.z - sampleGrid.origin.z) / sampleGrid.cellSize);
+  const found = [];
+  for (const ring of SAMPLE_RING_OFFSETS) {
+    for (const [dx, dy, dz] of ring) {
+      const entries = sampleGrid.cells.get(gridKey(baseX + dx, baseY + dy, baseZ + dz));
+      if (!entries) continue;
+      for (const sample of entries) {
+        found.push({ sample, distSq: distanceSquaredToSample(pointCloud, sample, point) });
+      }
+    }
+    if (found.length >= MAX_BLEND_SAMPLES) break;
+  }
+  if (found.length === 0) {
+    const sampleCount = Math.floor(pointCloud.positions.length / 3);
+    for (let sample = 0; sample < sampleCount; sample += 1) {
+      found.push({ sample, distSq: distanceSquaredToSample(pointCloud, sample, point) });
+    }
+  }
+  found.sort((a2, b2) => a2.distSq - b2.distSq);
+  return found.slice(0, MAX_BLEND_SAMPLES);
+}
+function blendedColorAt(point, pointCloud, sampleGrid) {
+  const samples = nearestSamples(point, pointCloud, sampleGrid);
+  if (samples.length === 0) return [90, 90, 90];
+  const sigma = Math.max(sampleGrid.cellSize * 1.65, 1e-6);
+  const sigmaSq = sigma * sigma;
+  let weightSum = 0;
+  let r2 = 0;
+  let g2 = 0;
+  let b2 = 0;
+  for (const { sample, distSq } of samples) {
+    const colorOffset = sample * 3;
+    const weight = Math.exp(-distSq / (2 * sigmaSq)) + 1e-4 / Math.max(distSq, 1e-8);
+    weightSum += weight;
+    r2 += (pointCloud.colors[colorOffset] ?? 0.35) * 255 * weight;
+    g2 += (pointCloud.colors[colorOffset + 1] ?? 0.35) * 255 * weight;
+    b2 += (pointCloud.colors[colorOffset + 2] ?? 0.35) * 255 * weight;
+  }
+  if (weightSum <= 0) return [90, 90, 90];
+  return [r2 / weightSum, g2 / weightSum, b2 / weightSum];
+}
+function buildInspectHeatmapField(geometry, pointCloud) {
+  const bounds = buildGeometryBounds(geometry);
+  const sampleGrid = buildSampleGrid(pointCloud);
+  if (!bounds || !sampleGrid) return null;
+  const gridSize = fieldGridSizeForSampleCount(Math.floor(pointCloud.positions.length / 3));
+  const boundsSize = bounds.getSize(new Vector3());
+  const data = new Uint8Array(gridSize * gridSize * gridSize * 4);
+  const point = new Vector3();
+  let dataOffset = 0;
+  for (let y = 0; y < gridSize; y += 1) {
+    for (let z = 0; z < gridSize; z += 1) {
+      for (let x = 0; x < gridSize; x += 1) {
+        point.set(
+          bounds.min.x + boundsSize.x * x / (gridSize - 1),
+          bounds.min.y + boundsSize.y * y / (gridSize - 1),
+          bounds.min.z + boundsSize.z * z / (gridSize - 1)
+        );
+        const [r2, g2, b2] = blendedColorAt(point, pointCloud, sampleGrid);
+        data[dataOffset] = Math.max(0, Math.min(255, Math.round(r2)));
+        data[dataOffset + 1] = Math.max(0, Math.min(255, Math.round(g2)));
+        data[dataOffset + 2] = Math.max(0, Math.min(255, Math.round(b2)));
+        data[dataOffset + 3] = 255;
+        dataOffset += 4;
+      }
+    }
+  }
+  const texture = new DataTexture(data, gridSize * gridSize, gridSize, RGBAFormat, UnsignedByteType);
+  texture.minFilter = NearestFilter;
+  texture.magFilter = NearestFilter;
+  texture.generateMipmaps = false;
+  texture.unpackAlignment = 1;
+  texture.needsUpdate = true;
+  return {
+    texture,
+    boundsMin: bounds.min,
+    boundsSize,
+    gridSize
+  };
+}
 function ForgeObject({
   obj,
   settings,
   renderStyle,
   renderMode,
+  inspectChannel = "none",
+  inspectDisplayMode = "heatmap",
+  inspectColor,
+  inspectMeshColors,
+  inspectPointCloud,
   isInteracting,
   matrix,
   isHovered,
@@ -32228,14 +32814,56 @@ function ForgeObject({
       };
     }
   }, [obj.shape]);
+  const inspectPointGeo = reactExports.useMemo(() => {
+    if (!inspectPointCloud) return null;
+    const geometry = new BufferGeometry();
+    geometry.setAttribute("position", new BufferAttribute(inspectPointCloud.positions, 3));
+    geometry.setAttribute("color", new BufferAttribute(inspectPointCloud.colors, 3));
+    return geometry;
+  }, [inspectPointCloud]);
+  const inspectMeshColorGeo = reactExports.useMemo(() => {
+    if (!solidGeo || !inspectMeshColors) return null;
+    const position = solidGeo.getAttribute("position");
+    if (!position || inspectMeshColors.length !== position.count * 3) return null;
+    const geometry = solidGeo.clone();
+    geometry.setAttribute("color", new BufferAttribute(inspectMeshColors, 3));
+    return geometry;
+  }, [inspectMeshColors, solidGeo]);
+  const isScalarInspect = inspectChannel === "thickness" || inspectChannel === "roughness";
+  const inspectHeatmapField = reactExports.useMemo(() => {
+    if (!isScalarInspect || !solidGeo || !inspectPointCloud) return null;
+    return buildInspectHeatmapField(solidGeo, inspectPointCloud);
+  }, [inspectPointCloud, isScalarInspect, solidGeo]);
   reactExports.useEffect(() => {
     return () => {
       solidGeo == null ? void 0 : solidGeo.dispose();
       edgesGeo == null ? void 0 : edgesGeo.dispose();
     };
   }, [edgesGeo, solidGeo]);
+  reactExports.useEffect(() => {
+    return () => {
+      inspectPointGeo == null ? void 0 : inspectPointGeo.dispose();
+    };
+  }, [inspectPointGeo]);
+  reactExports.useEffect(() => {
+    return () => {
+      inspectMeshColorGeo == null ? void 0 : inspectMeshColorGeo.dispose();
+    };
+  }, [inspectMeshColorGeo]);
+  reactExports.useEffect(() => {
+    return () => {
+      inspectHeatmapField == null ? void 0 : inspectHeatmapField.texture.dispose();
+    };
+  }, [inspectHeatmapField]);
   if (!solidGeo || !settings.visible) return null;
   const effectiveRenderMode = isInteracting && renderMode === "overlay" ? "solid" : renderMode;
+  const isInspecting = inspectChannel !== "none";
+  const showInspectHeatmap = Boolean(
+    isScalarInspect && inspectHeatmapField && (inspectDisplayMode === "heatmap" || inspectDisplayMode === "both")
+  );
+  const showInspectPoints = Boolean(
+    isScalarInspect && inspectPointGeo && (inspectDisplayMode === "points" || inspectDisplayMode === "both")
+  );
   const renderStylePreset = getRenderStylePreset(renderStyle);
   const materialDefaults = renderStylePreset.material;
   const authoredMaterialOpacity = (_a3 = obj.materialProps) == null ? void 0 : _a3.opacity;
@@ -32247,10 +32875,12 @@ function ForgeObject({
   const materialOpacity = Math.min(meshOpacity, styleOpacity);
   const transmission = authoredMaterialTransmission ?? transparentDefaults.transmission;
   const isTransparent = materialOpacity < 1 || transmission > 0;
-  const showSolid = effectiveRenderMode !== "wireframe";
-  const showEdges = effectiveRenderMode === "overlay";
-  const showWire = effectiveRenderMode === "wireframe";
+  const showSolid = isInspecting || effectiveRenderMode !== "wireframe";
+  const showEdges = !isInspecting && effectiveRenderMode === "overlay";
+  const showWire = !isInspecting && effectiveRenderMode === "wireframe";
   const effectiveClippingPlanes = clippingPlanes ?? [];
+  const inspectSolidGeo = inspectMeshColorGeo ?? solidGeo;
+  const hasInspectMeshColors = inspectMeshColorGeo !== null;
   return /* @__PURE__ */ jsxRuntimeExports.jsxs(
     "group",
     {
@@ -32263,7 +32893,70 @@ function ForgeObject({
       onDoubleClick,
       onContextMenu,
       children: [
-        showSolid && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: solidGeo, userData: { forgeMesh: true }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+        showSolid && (inspectChannel === "mask" || inspectChannel === "connectivity" || inspectChannel === "distance") && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: inspectSolidGeo, userData: { forgeMesh: true }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "meshBasicMaterial",
+          {
+            color: hasInspectMeshColors ? "#ffffff" : inspectColor ?? settings.color,
+            vertexColors: hasInspectMeshColors,
+            side: DoubleSide,
+            toneMapped: false,
+            clippingPlanes: effectiveClippingPlanes
+          }
+        ) }),
+        showSolid && isScalarInspect && !showInspectHeatmap && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: solidGeo, userData: { forgeMesh: true }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "meshBasicMaterial",
+          {
+            color: "#26313a",
+            transparent: true,
+            opacity: 0.24,
+            side: DoubleSide,
+            depthWrite: true,
+            toneMapped: false,
+            clippingPlanes: effectiveClippingPlanes
+          }
+        ) }),
+        showSolid && showInspectHeatmap && inspectHeatmapField && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: solidGeo, userData: { forgeMesh: true }, renderOrder: 4, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "shaderMaterial",
+          {
+            vertexShader: INSPECT_HEATMAP_VERTEX_SHADER,
+            fragmentShader: INSPECT_HEATMAP_FRAGMENT_SHADER,
+            uniforms: {
+              uField: { value: inspectHeatmapField.texture },
+              uGridSize: { value: inspectHeatmapField.gridSize },
+              uBoundsMin: { value: inspectHeatmapField.boundsMin },
+              uBoundsSize: { value: inspectHeatmapField.boundsSize }
+            },
+            side: DoubleSide,
+            toneMapped: false,
+            clippingPlanes: effectiveClippingPlanes
+          }
+        ) }),
+        showSolid && showInspectPoints && inspectPointGeo && /* @__PURE__ */ jsxRuntimeExports.jsx("points", { geometry: inspectPointGeo, raycast: () => null, renderOrder: 5, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "pointsMaterial",
+          {
+            size: 3,
+            sizeAttenuation: false,
+            vertexColors: true,
+            depthTest: true,
+            depthWrite: false,
+            toneMapped: false,
+            clippingPlanes: effectiveClippingPlanes
+          }
+        ) }),
+        showSolid && inspectChannel === "collisions" && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: solidGeo, userData: { forgeMesh: true }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "meshPhysicalMaterial",
+          {
+            color: rgbToHex(COLLISION_SOURCE_COLOR),
+            roughness: 0.75,
+            metalness: 0,
+            side: DoubleSide,
+            transparent: true,
+            opacity: COLLISION_SOURCE_OPACITY,
+            depthWrite: false,
+            clippingPlanes: effectiveClippingPlanes
+          }
+        ) }),
+        showSolid && inspectChannel === "none" && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: solidGeo, userData: { forgeMesh: true }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
           "meshPhysicalMaterial",
           {
             color: settings.color,
@@ -32288,7 +32981,7 @@ function ForgeObject({
             clippingPlanes: effectiveClippingPlanes
           }
         ) }),
-        showSolid && hasAuthoredTransparency && renderStylePreset.glassShell.enabled && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: solidGeo, scale: renderStylePreset.glassShell.scale, raycast: () => null, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+        showSolid && inspectChannel === "none" && hasAuthoredTransparency && renderStylePreset.glassShell.enabled && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: solidGeo, scale: renderStylePreset.glassShell.scale, raycast: () => null, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
           "meshBasicMaterial",
           {
             color: renderStylePreset.glassShell.color,
@@ -37855,6 +38548,9 @@ function useViewportState() {
   const files = useForgeStore((s) => s.files);
   const renderMode = useForgeStore((s) => s.renderMode);
   const renderStyle = useForgeStore((s) => s.renderStyle);
+  const inspectChannel = useForgeStore((s) => s.inspectChannel);
+  const inspectDisplayMode = useForgeStore((s) => s.inspectDisplayMode);
+  const inspectPointSampleCount = useForgeStore((s) => s.inspectPointSampleCount);
   const projectionMode = useForgeStore((s) => s.projectionMode);
   const gridEnabled = useForgeStore((s) => s.gridEnabled);
   const gridSize = useForgeStore((s) => s.gridSize);
@@ -38181,6 +38877,9 @@ function useViewportState() {
     files,
     renderMode,
     renderStyle,
+    inspectChannel,
+    inspectDisplayMode,
+    inspectPointSampleCount,
     projectionMode,
     gridEnabled,
     gridSize,
@@ -39557,6 +40256,276 @@ function RenderLabelsOverlay({ labels }) {
   if (labels.length === 0) return null;
   return /* @__PURE__ */ jsxRuntimeExports.jsx("group", { renderOrder: 12, children: labels.map((label) => /* @__PURE__ */ jsxRuntimeExports.jsx(RenderLabelItem, { label }, label.id)) });
 }
+class InspectWorkerClient {
+  constructor(workerFactory = () => new Worker(new URL(
+    /* @vite-ignore */
+    "/assets/inspectWorker-Dll4eVyD.js",
+    import.meta.url
+  ), { type: "module" })) {
+    __publicField(this, "worker", null);
+    __publicField(this, "reqId", 0);
+    __publicField(this, "pending", null);
+    this.workerFactory = workerFactory;
+  }
+  getWorker() {
+    if (this.worker) return this.worker;
+    this.worker = this.workerFactory();
+    this.worker.onmessage = (event) => {
+      const data = event.data;
+      const pending = this.pending;
+      if (!pending) return;
+      this.pending = null;
+      if (data.type === "inspect-error") {
+        pending.reject(new Error(data.payload.message));
+      } else {
+        pending.resolve(data.payload.result);
+      }
+    };
+    this.worker.onerror = (event) => {
+      var _a3, _b2;
+      const error = new Error(event.message || "Inspect worker failed unexpectedly.");
+      (_a3 = this.pending) == null ? void 0 : _a3.reject(error);
+      this.pending = null;
+      (_b2 = this.worker) == null ? void 0 : _b2.terminate();
+      this.worker = null;
+    };
+    return this.worker;
+  }
+  replaceActiveWorker() {
+    var _a3, _b2;
+    (_a3 = this.pending) == null ? void 0 : _a3.reject(new Error("cancelled"));
+    this.pending = null;
+    (_b2 = this.worker) == null ? void 0 : _b2.terminate();
+    this.worker = null;
+  }
+  analyze(payload) {
+    if (this.pending) this.replaceActiveWorker();
+    const reqId = ++this.reqId;
+    const request = {
+      type: "analyze",
+      payload: {
+        reqId,
+        ...payload
+      }
+    };
+    const transfers = payload.objects.flatMap((object) => object.positions ? [object.positions.buffer] : []);
+    return new Promise((resolve2, reject) => {
+      this.pending = { resolve: resolve2, reject };
+      this.getWorker().postMessage(request, transfers);
+    });
+  }
+  dispose() {
+    this.replaceActiveWorker();
+  }
+}
+const inspectWorkerClient = new InspectWorkerClient();
+const WORKER_CHANNELS = /* @__PURE__ */ new Set(["thickness", "roughness", "connectivity", "distance"]);
+const SCALAR_WORKER_CHANNELS = /* @__PURE__ */ new Set(["thickness", "roughness"]);
+const MESH_COMPONENT_WORKER_CHANNELS = /* @__PURE__ */ new Set(["connectivity", "distance"]);
+const VIEWPORT_SCALAR_SCENE_BUDGET_OBJECTS = 15;
+class InspectBuildCancelledError extends Error {
+  constructor() {
+    super("cancelled");
+  }
+}
+function isScalarWorkerChannel(channel) {
+  return SCALAR_WORKER_CHANNELS.has(channel);
+}
+function needsMeshComponents(channel) {
+  return MESH_COMPONENT_WORKER_CHANNELS.has(channel);
+}
+function viewportScalarSamplesPerObject(objectCount, inspectPointSampleCount) {
+  const perObjectCap = resolveInspectPointSampleCount(inspectPointSampleCount);
+  if (objectCount <= 0) return perObjectCap;
+  const sceneBudget = perObjectCap * VIEWPORT_SCALAR_SCENE_BUDGET_OBJECTS;
+  const budgeted = Math.floor(sceneBudget / objectCount);
+  return Math.max(INSPECT_POINT_SAMPLE_COUNT_MIN, Math.min(perObjectCap, budgeted));
+}
+function yieldToBrowser() {
+  if (typeof window === "undefined") return Promise.resolve();
+  return new Promise((resolve2) => {
+    const maybeIdleWindow = window;
+    if (typeof maybeIdleWindow.requestIdleCallback === "function") {
+      maybeIdleWindow.requestIdleCallback(() => resolve2(), { timeout: 50 });
+      return;
+    }
+    window.setTimeout(resolve2, 0);
+  });
+}
+function transformedBounds(obj, matrix) {
+  if (!obj.shape) return null;
+  try {
+    const bbox = obj.shape.boundingBox();
+    const bounds = new Box3();
+    if (!expandBoundsByTransformedAabb(bounds, bbox.min, bbox.max, matrix)) return null;
+    if (!isFiniteBox3(bounds)) return null;
+    return {
+      min: [bounds.min.x, bounds.min.y, bounds.min.z],
+      max: [bounds.max.x, bounds.max.y, bounds.max.z]
+    };
+  } catch {
+    return null;
+  }
+}
+function clonePositions(obj, matrix) {
+  var _a3;
+  if (!obj.shape) return void 0;
+  const geometry = obj.shape instanceof FrozenShape ? null : shapeToGeometry(obj.shape);
+  try {
+    const source = obj.shape instanceof FrozenShape ? obj.shape.getPrecomputedGeometry().positions : (_a3 = geometry == null ? void 0 : geometry.solid.getAttribute("position")) == null ? void 0 : _a3.array;
+    if (!source) return void 0;
+    const positions = new Float32Array(source);
+    if (matrix) {
+      const point = new Vector3();
+      for (let index = 0; index < positions.length; index += 3) {
+        point.set(positions[index], positions[index + 1], positions[index + 2]).applyMatrix4(matrix);
+        positions[index] = point.x;
+        positions[index + 1] = point.y;
+        positions[index + 2] = point.z;
+      }
+    }
+    return positions;
+  } finally {
+    geometry == null ? void 0 : geometry.solid.dispose();
+    geometry == null ? void 0 : geometry.edges.dispose();
+  }
+}
+async function buildWorkerObjects(args) {
+  var _a3;
+  const needsMesh = isScalarWorkerChannel(args.inspectChannel) || needsMeshComponents(args.inspectChannel);
+  const out = [];
+  for (const obj of args.objects) {
+    if (args.isCancelled()) throw new InspectBuildCancelledError();
+    if (!obj.shape) continue;
+    if (((_a3 = args.objectSettings[obj.id]) == null ? void 0 : _a3.visible) === false) continue;
+    await yieldToBrowser();
+    if (args.isCancelled()) throw new InspectBuildCancelledError();
+    const matrix = args.objectMatrices[obj.id] ?? new Matrix4();
+    const bbox = transformedBounds(obj, matrix);
+    if (!bbox) continue;
+    if (args.isCancelled()) throw new InspectBuildCancelledError();
+    out.push({
+      id: obj.id,
+      name: obj.name,
+      groupName: obj.groupName,
+      treePath: obj.treePath,
+      mock: obj.mock,
+      bbox,
+      ...needsMesh ? { positions: clonePositions(obj, needsMeshComponents(args.inspectChannel) ? matrix : void 0) } : {}
+    });
+    await yieldToBrowser();
+  }
+  return out;
+}
+function analyzePayloadFor(channel, objects, inspectPointSampleCount) {
+  const maxSamplesPerObject = viewportScalarSamplesPerObject(objects.length, inspectPointSampleCount);
+  if (channel === "thickness") {
+    return {
+      channel,
+      objects,
+      thickness: {
+        maxSamplesPerObject
+      }
+    };
+  }
+  if (channel === "roughness") {
+    return {
+      channel,
+      objects,
+      roughness: {
+        maxSamplesPerObject
+      }
+    };
+  }
+  return { channel, objects };
+}
+function resultToState(channel, result) {
+  return {
+    status: "ready",
+    channel,
+    objectColors: result.objectColors,
+    meshColors: Object.fromEntries(result.meshColorObjects.map((object) => [object.objectId, object.colors])),
+    pointClouds: Object.fromEntries(
+      result.pointObjects.map((object) => [
+        object.objectId,
+        {
+          sampleCount: object.sampleCount,
+          positions: object.positions,
+          colors: object.colors
+        }
+      ])
+    ),
+    warnings: result.warnings,
+    error: null
+  };
+}
+function useInspectWorkerAnalysis(args) {
+  const [state2, setState] = reactExports.useState({
+    status: "idle",
+    channel: "none",
+    objectColors: {},
+    meshColors: {},
+    pointClouds: {},
+    warnings: [],
+    error: null
+  });
+  reactExports.useEffect(() => {
+    if (!WORKER_CHANNELS.has(args.inspectChannel)) {
+      inspectWorkerClient.dispose();
+      setState({
+        status: "idle",
+        channel: args.inspectChannel,
+        objectColors: {},
+        meshColors: {},
+        pointClouds: {},
+        warnings: [],
+        error: null
+      });
+      return;
+    }
+    let cancelled = false;
+    const channel = args.inspectChannel;
+    setState({
+      status: "loading",
+      channel: args.inspectChannel,
+      objectColors: {},
+      meshColors: {},
+      pointClouds: {},
+      warnings: [],
+      error: null
+    });
+    void (async () => {
+      try {
+        const objects = await buildWorkerObjects({
+          ...args,
+          isCancelled: () => cancelled
+        });
+        if (cancelled) return;
+        const result = await inspectWorkerClient.analyze(analyzePayloadFor(channel, objects, args.inspectPointSampleCount));
+        if (cancelled) return;
+        setState(resultToState(args.inspectChannel, result));
+      } catch (error) {
+        if (cancelled || error instanceof InspectBuildCancelledError || error instanceof Error && error.message === "cancelled") {
+          return;
+        }
+        setState({
+          status: "error",
+          channel: args.inspectChannel,
+          objectColors: {},
+          meshColors: {},
+          pointClouds: {},
+          warnings: [],
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    })();
+    return () => {
+      cancelled = true;
+      inspectWorkerClient.dispose();
+    };
+  }, [args.inspectChannel, args.inspectPointSampleCount, args.sceneVersion, args.objects, args.objectSettings, args.objectMatrices]);
+  return state2;
+}
 function panelNumber(value) {
   if (!Number.isFinite(value)) return String(value);
   if (Number.isInteger(value)) return String(value);
@@ -39582,6 +40551,20 @@ function edgeCurveLabel(edge) {
       return "segment";
   }
 }
+function inspectChannelLabel(channel) {
+  switch (channel) {
+    case "connectivity":
+      return "Connect";
+    case "distance":
+      return "Distance";
+    case "thickness":
+      return "Thickness";
+    case "roughness":
+      return "Roughness";
+    default:
+      return "Inspect";
+  }
+}
 function edgeBelongsToFace(edge, faceName) {
   var _a3;
   return edge.faceName === faceName || ((_a3 = edge.curve) == null ? void 0 : _a3.faceName) === faceName || edge.name.startsWith(`${faceName}:`);
@@ -39669,6 +40652,8 @@ function RenderStyleExposure({ exposure }) {
 function Viewport() {
   var _a3, _b2, _c;
   const activeFile = useForgeStore((s) => s.activeFile);
+  const activeBackend = useForgeStore((s) => s.activeBackend);
+  const computeTarget = useForgeStore((s) => s.computeTarget);
   const isSvgActive = !!activeFile && activeFile.toLowerCase().endsWith(".svg");
   const state2 = useViewportState();
   const {
@@ -39677,6 +40662,9 @@ function Viewport() {
     evaluationPhase,
     renderMode,
     renderStyle,
+    inspectChannel,
+    inspectDisplayMode,
+    inspectPointSampleCount,
     projectionMode,
     gridEnabled,
     gridSize,
@@ -39760,6 +40748,7 @@ function Viewport() {
   const contextMenuRef = reactExports.useRef(null);
   const t2 = themes[themeName];
   const renderStylePreset = reactExports.useMemo(() => getRenderStylePreset(renderStyle), [renderStyle]);
+  const inspectChannelActive = inspectChannel !== "none";
   const hasVisibleSdfObjects = objects.some((obj) => {
     var _a4;
     return obj.sdf && (((_a4 = objectSettings[obj.id]) == null ? void 0 : _a4.visible) ?? true);
@@ -39776,6 +40765,27 @@ function Viewport() {
     }
     return next;
   }, [constructionGhost, focusedObjectIdSet, objectSettings, objects]);
+  const inspectAnalysis = useInspectWorkerAnalysis({
+    inspectChannel,
+    inspectPointSampleCount,
+    sceneVersion,
+    objects,
+    objectSettings,
+    objectMatrices
+  });
+  const inspectLoading = inspectChannelActive && inspectAnalysis.status === "loading";
+  const viewportBusyPhase = isEvaluating || evaluationPhase === "exporting" ? evaluationPhase : inspectLoading ? "inspecting" : null;
+  const viewportBusyLabel = inspectLoading ? `Generating ${inspectChannelLabel(inspectChannel)} inspect view` : void 0;
+  const rebuildHistorySteps = reactExports.useMemo(() => {
+    if (!isEvaluating || historyMode) return [];
+    const historyObjects = [];
+    for (const obj of objects) {
+      if (!obj.shape) continue;
+      const plan = getShapeCompilePlan(obj.shape);
+      if (plan) historyObjects.push({ id: obj.id, plan });
+    }
+    return historyObjects.length > 0 ? linearizeMultiObjectSteps(historyObjects) : [];
+  }, [historyMode, isEvaluating, objects]);
   const handlers = useViewportHandlers({
     containerRef,
     contextMenuRef,
@@ -39839,7 +40849,7 @@ function Viewport() {
           Canvas,
           {
             style: {
-              background: renderStyle === "classic" ? t2.viewportBg : renderStylePreset.background,
+              background: inspectChannelActive ? "#000000" : renderStyle === "classic" ? t2.viewportBg : renderStylePreset.background,
               cursor: measureMode ? "crosshair" : "default"
             },
             dpr: canvasDpr,
@@ -39907,8 +40917,8 @@ function Viewport() {
                   )
                 ] }),
                 /* @__PURE__ */ jsxRuntimeExports.jsx(ClippingManager, { active: hasAnyObjectCutPlanes }),
-                sectionExplorerEnabled && /* @__PURE__ */ jsxRuntimeExports.jsx(SectionExplorerGizmo, { size: sectionGuideSize }),
-                sectionPlaneGuidesEnabled && activeCutPlaneDefs.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsx(
+                !inspectChannelActive && sectionExplorerEnabled && /* @__PURE__ */ jsxRuntimeExports.jsx(SectionExplorerGizmo, { size: sectionGuideSize }),
+                !inspectChannelActive && sectionPlaneGuidesEnabled && activeCutPlaneDefs.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsx(
                   SectionPlaneGuides,
                   {
                     cutPlanes: scriptCutPlaneDefs,
@@ -39940,6 +40950,11 @@ function Viewport() {
                         settings: effectiveSettings,
                         renderStyle,
                         renderMode,
+                        inspectChannel,
+                        inspectDisplayMode,
+                        inspectColor: inspectAnalysis.objectColors[obj.id] ?? maskColorForIndex(objIndex),
+                        inspectMeshColors: inspectAnalysis.meshColors[obj.id],
+                        inspectPointCloud: inspectAnalysis.pointClouds[obj.id],
                         isInteracting: isViewportInteracting,
                         matrix,
                         isHovered,
@@ -40004,7 +41019,8 @@ function Viewport() {
                   }
                   return null;
                 }),
-                /* @__PURE__ */ jsxRuntimeExports.jsx(
+                inspectChannel === "collisions" && /* @__PURE__ */ jsxRuntimeExports.jsx(CollisionInspectionOverlay, { objects, objectSettings, objectMatrices }),
+                !inspectChannelActive && /* @__PURE__ */ jsxRuntimeExports.jsx(
                   SectionCaps,
                   {
                     sceneVersion,
@@ -40016,17 +41032,17 @@ function Viewport() {
                     isInteracting: isViewportInteracting
                   }
                 ),
-                constructionGhost && /* @__PURE__ */ jsxRuntimeExports.jsx(ConstructionGhostOverlay, { matrix: constructionGhostMatrix }),
-                historyMode && /* @__PURE__ */ jsxRuntimeExports.jsx(ConstructionHistoryOverlay, { objectMatrices, objectSettings }),
-                hoveredJointOverlay && /* @__PURE__ */ jsxRuntimeExports.jsx(HoveredJointOverlay, { state: hoveredJointOverlay, config: jointOverlayConfig }),
-                dimensionsVisible && dimensions.map((d) => /* @__PURE__ */ jsxRuntimeExports.jsx(DimensionAnnotation, { def: d, lengthUnit }, d.id)),
-                /* @__PURE__ */ jsxRuntimeExports.jsx(RenderLabelsOverlay, { labels: renderLabels }),
-                attachmentsVisible !== "none" && attachmentPoints.map((ap) => {
+                !inspectChannelActive && constructionGhost && /* @__PURE__ */ jsxRuntimeExports.jsx(ConstructionGhostOverlay, { matrix: constructionGhostMatrix }),
+                !inspectChannelActive && historyMode && /* @__PURE__ */ jsxRuntimeExports.jsx(ConstructionHistoryOverlay, { objectMatrices, objectSettings }),
+                !inspectChannelActive && hoveredJointOverlay && /* @__PURE__ */ jsxRuntimeExports.jsx(HoveredJointOverlay, { state: hoveredJointOverlay, config: jointOverlayConfig }),
+                !inspectChannelActive && dimensionsVisible && dimensions.map((d) => /* @__PURE__ */ jsxRuntimeExports.jsx(DimensionAnnotation, { def: d, lengthUnit }, d.id)),
+                !inspectChannelActive && /* @__PURE__ */ jsxRuntimeExports.jsx(RenderLabelsOverlay, { labels: renderLabels }),
+                !inspectChannelActive && attachmentsVisible !== "none" && attachmentPoints.map((ap) => {
                   const matrix = objectMatrices[ap.objectId];
                   return matrix ? /* @__PURE__ */ jsxRuntimeExports.jsx("group", { matrixAutoUpdate: false, matrix, children: /* @__PURE__ */ jsxRuntimeExports.jsx(ConnectorAttachmentAnnotation, { def: ap }) }, `${ap.objectId}:${ap.name}`) : /* @__PURE__ */ jsxRuntimeExports.jsx(ConnectorAttachmentAnnotation, { def: ap }, `${ap.objectId}:${ap.name}`);
                 }),
                 /* @__PURE__ */ jsxRuntimeExports.jsx(MeasureTool, {}),
-                debugHighlights3D.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsx(DebugHighlightsOverlay, { highlights: debugHighlights3D }),
+                !inspectChannelActive && debugHighlights3D.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsx(DebugHighlightsOverlay, { highlights: debugHighlights3D }),
                 drawFlagEnabled && /* @__PURE__ */ jsxRuntimeExports.jsx(DrawCanvas, {}),
                 /* @__PURE__ */ jsxRuntimeExports.jsx(
                   PerformanceInfoSampler,
@@ -40039,7 +41055,7 @@ function Viewport() {
                   }
                 ),
                 /* @__PURE__ */ jsxRuntimeExports.jsx(ZoomSampler, { onZoomChange: setZoomMmPerPx }),
-                gridEnabled && !isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(
+                !inspectChannelActive && gridEnabled && !isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(
                   Grid,
                   {
                     args: [500, 500],
@@ -40054,7 +41070,7 @@ function Viewport() {
                     infiniteGrid: true
                   }
                 ),
-                !isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(
+                !inspectChannelActive && !isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(
                   SdfRaymarchLayer,
                   {
                     objects,
@@ -40069,11 +41085,11 @@ function Viewport() {
                     onContextMenu: (obj, event) => handleObjectContextMenu(obj, event)
                   }
                 ),
-                !isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(LabeledAxes, {}),
-                isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(SketchAxes, {}),
+                !inspectChannelActive && !isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(LabeledAxes, {}),
+                !inspectChannelActive && isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(SketchAxes, {}),
                 isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(CursorTracker, { onMove: (x, y) => setCursorPos({ x, y }) }),
                 isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(SketchRulersUpdater, { hCanvasRef: hRulerRef, vCanvasRef: vRulerRef }),
-                gridEnabled && isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(
+                !inspectChannelActive && gridEnabled && isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(
                   Grid,
                   {
                     args: [500, 500],
@@ -40195,7 +41211,7 @@ function Viewport() {
           }
         ),
         /* @__PURE__ */ jsxRuntimeExports.jsx(PerformanceInfoPanel, { enabled: showPerformanceInfo, stats: performanceInfo }),
-        !(isEvaluating || evaluationPhase === "exporting") && /* @__PURE__ */ jsxRuntimeExports.jsx(ZoomIndicatorPanel, { mmPerPx: zoomMmPerPx }),
+        !viewportBusyPhase && /* @__PURE__ */ jsxRuntimeExports.jsx(ZoomIndicatorPanel, { mmPerPx: zoomMmPerPx }),
         isSketchOnly && /* @__PURE__ */ jsxRuntimeExports.jsx(
           SketchRulersOverlay,
           {
@@ -40226,7 +41242,44 @@ function Viewport() {
           }
         ),
         measureMode && /* @__PURE__ */ jsxRuntimeExports.jsx(MeasureInfoPanel, {}),
-        (isEvaluating || evaluationPhase === "exporting") && /* @__PURE__ */ jsxRuntimeExports.jsx(EvaluationIndicator, { phase: evaluationPhase }),
+        viewportBusyPhase && /* @__PURE__ */ jsxRuntimeExports.jsx(
+          EvaluationIndicator,
+          {
+            phase: viewportBusyPhase,
+            label: viewportBusyLabel,
+            constructionSteps: rebuildHistorySteps,
+            activeBackend,
+            computeTarget
+          }
+        ),
+        inspectChannelActive && inspectAnalysis.status === "error" && inspectAnalysis.error && /* @__PURE__ */ jsxRuntimeExports.jsxs(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: 12,
+              left: "50%",
+              transform: "translateX(-50%)",
+              background: "rgba(127, 29, 29, 0.92)",
+              color: "#fee2e2",
+              border: "1px solid rgba(254, 202, 202, 0.4)",
+              borderRadius: 6,
+              padding: "7px 12px",
+              fontSize: 12,
+              fontWeight: 600,
+              pointerEvents: "none",
+              zIndex: 12,
+              maxWidth: "min(520px, calc(100% - 32px))",
+              whiteSpace: "nowrap",
+              overflow: "hidden",
+              textOverflow: "ellipsis"
+            },
+            children: [
+              "Inspect failed: ",
+              inspectAnalysis.error
+            ]
+          }
+        ),
         /* @__PURE__ */ jsxRuntimeExports.jsx(HoverTooltipLayer, { ref: hoverTooltipRef, enabled: objectPickSyncEnabled && !measureMode }),
         objectContextMenu && /* @__PURE__ */ jsxRuntimeExports.jsxs(
           "div",
@@ -40684,7 +41737,7 @@ function Viewport() {
     }
   );
 }
-const EditorApp$1 = reactExports.lazy(() => __vitePreload(() => import("./EditorApp-DNH1TEz1.js"), true ? __vite__mapDeps([0]) : void 0).then((m2) => ({ default: m2.EditorApp })));
+const EditorApp$1 = reactExports.lazy(() => __vitePreload(() => import("./EditorApp-BujZvuwX.js"), true ? __vite__mapDeps([0]) : void 0).then((m2) => ({ default: m2.EditorApp })));
 const PENDING_SHARE_COPY_KEY = "fc-pending-share-copy";
 function storePendingShareCopy(shareId) {
   sessionStorage.setItem(PENDING_SHARE_COPY_KEY, shareId);
@@ -40871,15 +41924,15 @@ const PublishedModelPage$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Objec
   consumePendingShareCopy,
   storePendingShareCopy
 }, Symbol.toStringTag, { value: "Module" }));
-reactExports.lazy(() => __vitePreload(() => import("./LandingPageProofDriven-CAu2OZFn.js"), true ? __vite__mapDeps([1]) : void 0).then((m2) => ({ default: m2.LandingPageProofDriven })));
-const DocsPage = reactExports.lazy(() => __vitePreload(() => import("./DocsPage-C58f0K5v.js"), true ? [] : void 0).then((m2) => ({ default: m2.DocsPage })));
-reactExports.lazy(() => __vitePreload(() => import("./BlogPage-DYJMjWx3.js"), true ? [] : void 0).then((m2) => ({ default: m2.BlogPage })));
-reactExports.lazy(() => __vitePreload(() => import("./AdminPage-uTtcSXtn.js"), true ? [] : void 0).then((m2) => ({ default: m2.AdminPage })));
+reactExports.lazy(() => __vitePreload(() => import("./LandingPageProofDriven-O_yMtAri.js"), true ? __vite__mapDeps([1]) : void 0).then((m2) => ({ default: m2.LandingPageProofDriven })));
+const DocsPage = reactExports.lazy(() => __vitePreload(() => import("./DocsPage-DLhIIZyJ.js"), true ? [] : void 0).then((m2) => ({ default: m2.DocsPage })));
+reactExports.lazy(() => __vitePreload(() => import("./BlogPage-CI_P0_Pf.js"), true ? [] : void 0).then((m2) => ({ default: m2.BlogPage })));
+reactExports.lazy(() => __vitePreload(() => import("./AdminPage-DX0mpSZT.js"), true ? [] : void 0).then((m2) => ({ default: m2.AdminPage })));
 reactExports.lazy(() => __vitePreload(() => Promise.resolve().then(() => PublishedModelPage$1), true ? void 0 : void 0).then((m2) => ({ default: m2.PublishedModelPage })));
-reactExports.lazy(() => __vitePreload(() => import("./SettingsPage-N1l1tMXO.js"), true ? [] : void 0).then((m2) => ({ default: m2.SettingsPage })));
-reactExports.lazy(() => __vitePreload(() => import("./PricingPage-BIgW7m3X.js"), true ? __vite__mapDeps([2,1]) : void 0).then((m2) => ({ default: m2.PricingPage })));
-const EditorApp = reactExports.lazy(() => __vitePreload(() => import("./EditorApp-DNH1TEz1.js"), true ? __vite__mapDeps([0]) : void 0).then((m2) => ({ default: m2.EditorApp })));
-const EmbedViewer = reactExports.lazy(() => __vitePreload(() => import("./EmbedViewer-CMXWA2LX.js"), true ? [] : void 0).then((m2) => ({ default: m2.EmbedViewer })));
+reactExports.lazy(() => __vitePreload(() => import("./SettingsPage-DBsqTB_y.js"), true ? [] : void 0).then((m2) => ({ default: m2.SettingsPage })));
+reactExports.lazy(() => __vitePreload(() => import("./PricingPage-DGkX3Ahr.js"), true ? __vite__mapDeps([2,1]) : void 0).then((m2) => ({ default: m2.PricingPage })));
+const EditorApp = reactExports.lazy(() => __vitePreload(() => import("./EditorApp-BujZvuwX.js"), true ? __vite__mapDeps([0]) : void 0).then((m2) => ({ default: m2.EditorApp })));
+const EmbedViewer = reactExports.lazy(() => __vitePreload(() => import("./EmbedViewer-0S0qXKog.js"), true ? [] : void 0).then((m2) => ({ default: m2.EmbedViewer })));
 const embedMode = isEmbedMode() && !window.location.pathname.startsWith("/m/");
 const EDITABLE_CRASH_FILE = /\.(?:forge\.js|[cm]?[jt]sx?|json|md|txt|svg)$/i;
 function firstMeaningfulLine(text) {
@@ -41096,7 +42149,7 @@ function App() {
 applyTheme(localStorage.getItem("fc-theme") || "dark");
 clientExports.createRoot(document.getElementById("root")).render(/* @__PURE__ */ jsxRuntimeExports.jsx(App, {}));
 export {
-  LocalStudioEnvironment as $,
+  ViewController as $,
   AuthApiError as A,
   BrandMark as B,
   exportExactFromStore as C,
@@ -41118,36 +42171,38 @@ export {
   resolveJointRange as S,
   useJointsConfig as T,
   useJointAnimationValues as U,
-  expandBoundsByTransformedAabb as V,
-  Canvas as W,
-  PerspectiveCamera as X,
-  ControlsInteractionBridge as Y,
-  ViewController as Z,
-  SceneConfigurator as _,
+  INSPECT_POINT_SAMPLE_COUNT_MAX as V,
+  INSPECT_POINT_SAMPLE_COUNT_MIN as W,
+  expandBoundsByTransformedAabb as X,
+  Canvas as Y,
+  PerspectiveCamera as Z,
+  ControlsInteractionBridge as _,
   applyTheme as a,
-  RenderLabelsOverlay as a0,
-  Grid as a1,
-  OrbitControls2 as a2,
-  TOUCH_GESTURES_3D as a3,
-  MOUSE_BUTTONS_3D as a4,
-  ModelJourneyBar as a5,
-  FOCUS_MODE_DIM_OPACITY as a6,
-  useJointAnimationLoop as a7,
-  computeJointNodeMatrices as a8,
-  computeObjectJointMatrices as a9,
-  readLastActiveFileForUser as aa,
-  ToastContainer as ab,
-  isMobile as ac,
-  useFeatureFlag as ad,
-  decodeSharedHash as ae,
-  decodeSharedBundle as af,
-  getExternalUrl as ag,
-  getGistId as ah,
-  Viewport as ai,
-  shouldBlockBrowserShortcut as aj,
-  useDrawStore as ak,
-  storePendingShareCopy as al,
-  share as am,
+  SceneConfigurator as a0,
+  LocalStudioEnvironment as a1,
+  RenderLabelsOverlay as a2,
+  Grid as a3,
+  OrbitControls2 as a4,
+  TOUCH_GESTURES_3D as a5,
+  MOUSE_BUTTONS_3D as a6,
+  ModelJourneyBar as a7,
+  FOCUS_MODE_DIM_OPACITY as a8,
+  useJointAnimationLoop as a9,
+  computeJointNodeMatrices as aa,
+  computeObjectJointMatrices as ab,
+  readLastActiveFileForUser as ac,
+  ToastContainer as ad,
+  isMobile as ae,
+  useFeatureFlag as af,
+  decodeSharedHash as ag,
+  decodeSharedBundle as ah,
+  getExternalUrl as ai,
+  getGistId as aj,
+  Viewport as ak,
+  shouldBlockBrowserShortcut as al,
+  useDrawStore as am,
+  storePendingShareCopy as an,
+  share as ao,
   authFetch as b,
   authApi as c,
   showToast as d,