forgecad 0.9.7 → 0.9.8

package/dist-cli/forgecad.js

@@ -58033,6 +58033,16 @@ var RENDER_STYLE_OPTIONS = [
     id: "glass",
     label: "Glass",
     description: "Showcase lighting for authored transparent materials."
+  },
+  {
+    id: "precision",
+    label: "Precision",
+    description: "Dense, thin surface-field contours for technical inspection."
+  },
+  {
+    id: "hybrid",
+    label: "Hybrid",
+    description: "Topo-led surface contours with a quiet orthogonal field."
   }
 ];
 var RENDER_STYLE_IDS = new Set(RENDER_STYLE_OPTIONS.map((option) => option.id));
@@ -82694,6 +82704,16 @@ function createForgeRuntimeModule(bindings) {
   return runtime;
 }
 
+// src/forge/script-runtime/importFinalizer.ts
+function finalizeForgeJsImport(moduleExports, importedDims) {
+  if (moduleExports instanceof Assembly) {
+    return new ImportedAssembly(moduleExports, moduleExports.getReferences());
+  }
+  if (!(moduleExports instanceof Shape)) return moduleExports;
+  if (importedDims.length === 0) return moduleExports;
+  return setShapeDimensions(moduleExports, [...getShapeDimensions(moduleExports), ...importedDims]);
+}
+
 // src/forge/sdf/sdfShader.ts
 function classifySdfPreviewNode(node) {
   switch (node.kind) {
@@ -82871,7 +82891,7 @@ function isRenderableEntryResult(value) {
   return containsRenderableLeaf(value, /* @__PURE__ */ new WeakSet());
 }
 function containsRenderableLeaf(value, seen) {
-  if (value instanceof Shape || value instanceof Sketch || value instanceof SdfShape || value instanceof ShapeGroup || value instanceof GCodeBuilder || value instanceof Assembly || value instanceof SolvedAssembly) {
+  if (value instanceof Shape || value instanceof Sketch || value instanceof SdfShape || value instanceof ShapeGroup || value instanceof GCodeBuilder || value instanceof Assembly || value instanceof ImportedAssembly || value instanceof SolvedAssembly) {
     return true;
   }
   if (!value || typeof value !== "object") return false;
@@ -82893,11 +82913,6 @@ function hasExplicitModuleExports(exportsValue, initialExportsRef) {
   const keys = Object.keys(exportsValue);
   return keys.some((key) => key !== "__esModule");
 }
-function finalizeForgeJsImport(moduleExports, importedDims) {
-  if (!(moduleExports instanceof Shape)) return moduleExports;
-  if (importedDims.length === 0) return moduleExports;
-  return setShapeDimensions(moduleExports, [...getShapeDimensions(moduleExports), ...importedDims]);
-}
 function mapScriptResultToScene(args) {
   const objects = [];
   const shapeDimensions = [];
@@ -83024,6 +83039,19 @@ function mapScriptResultToScene(args) {
       value.solve().toSceneObjects().forEach((item, index) => processNamedItem(item, `${name}.${index + 1}`, `${index + 1}`, name, treePath, inheritedTags));
       return;
     }
+    if (value instanceof ImportedAssembly) {
+      const group2 = value.toGroup();
+      group2.children.forEach((child, index) => {
+        flattenGroupChild(
+          child,
+          groupChildLabel(group2, name, index),
+          name,
+          [...treePath, shapeGroupChildSegment(group2, index)],
+          mergeSceneTags(inheritedTags, group2.tagsForChild(index))
+        );
+      });
+      return;
+    }
     if (value instanceof SolvedAssembly) {
       value.toSceneObjects().forEach((item, index) => processNamedItem(item, `${name}.${index + 1}`, `${index + 1}`, name, treePath, inheritedTags));
       return;
@@ -83178,6 +83206,12 @@ function mapScriptResultToScene(args) {
       const label = `Object ${index + 1}`;
       processNamedItem(item, label, label);
     });
+  } else if (result instanceof ImportedAssembly) {
+    const group2 = result.toGroup();
+    group2.children.forEach((child, index) => {
+      const label = rootGroupChildLabel(group2, index);
+      flattenGroupChild(child, label, void 0, [label], group2.tagsForChild(index));
+    });
   } else if (result instanceof ShapeGroup) {
     result.children.forEach((child, i) => {
       const label = rootGroupChildLabel(result, i);
@@ -83216,7 +83250,7 @@ function mapScriptResultToScene(args) {
       }
       processRenderableTree(item, label, label);
     });
-  } else if (result !== null && typeof result === "object" && !Array.isArray(result) && !(result instanceof Shape) && !(result instanceof Sketch) && !(result instanceof SdfShape) && !(result instanceof ShapeGroup) && !(result instanceof GCodeBuilder) && !(result instanceof Assembly) && !(result instanceof SolvedAssembly)) {
+  } else if (result !== null && typeof result === "object" && !Array.isArray(result) && !(result instanceof Shape) && !(result instanceof Sketch) && !(result instanceof SdfShape) && !(result instanceof ShapeGroup) && !(result instanceof GCodeBuilder) && !(result instanceof Assembly) && !(result instanceof ImportedAssembly) && !(result instanceof SolvedAssembly)) {
     const obj = result;
     const defaultValue = obj.default;
     if (defaultValue && isRenderableEntryResult(defaultValue)) {
@@ -83301,7 +83335,7 @@ Fix one:
     sketch: objects.length === 1 ? objects[0].sketch : null,
     objects,
     extraDimensions: shapeDimensions,
-    error: objects.length > 0 || args.allowEmptyResult ? null : "No renderable objects found. Return a Shape, Sketch, SdfShape, array, or object tree containing renderable values."
+    error: objects.length > 0 || args.allowEmptyResult ? null : "No renderable objects found. Return a Shape, Sketch, SdfShape, Assembly, ImportedAssembly, array, or object tree containing renderable values."
   };
 }
 
@@ -83593,6 +83627,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       composeChain,
       assembly,
       Assembly,
+      ImportedAssembly,
       port: () => {
         throw new Error("port() has been renamed to connector(). Update your script.");
       },
@@ -84003,6 +84038,11 @@ import { execSync, spawn } from "child_process";
 import { existsSync, realpathSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
+
+// cli/default-backend.ts
+var CLI_DEFAULT_BACKEND = "manifold";
+
+// cli/package-runtime.ts
 function isCompiledBinary() {
   return import.meta.url.includes("$bunfs");
 }
@@ -84040,7 +84080,10 @@ function isDirectSourceCliRun(metaUrl, sourceEntryPath) {
 }
 function runDirectCliMain(metaUrl, sourceEntryPath, run) {
   if (!isDirectSourceCliRun(metaUrl, sourceEntryPath)) return;
-  Promise.resolve().then(run).catch((error) => {
+  Promise.resolve().then(() => {
+    setActiveBackend(CLI_DEFAULT_BACKEND);
+    return run();
+  }).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(message);
     process.exit(1);
@@ -86273,7 +86316,15 @@ return [
 ];
 `
   };
-  const result = runScript(files["main.forge.js"], "main.forge.js", files);
+  const previousBackend = getActiveBackend();
+  setActiveBackend("truck");
+  let result = null;
+  try {
+    result = runScript(files["main.forge.js"], "main.forge.js", files);
+  } finally {
+    setActiveBackend(previousBackend);
+  }
+  assert2(result, "runScript did not return a result");
   assert2.equal(result.error, null, `runScript failed: ${result.error ?? "unknown error"}`);
   const exactManifest = buildBrepExportManifest(result.objects);
   assert2.equal(exactManifest.objects.length, 0, "Broad native edge finishes must not export as their unfinished base shape");
@@ -89390,14 +89441,36 @@ function listExampleArtifacts() {
 }
 
 // cli/sketch-svg.ts
-function edgesStrokeAttrs(preset) {
+function paletteForTheme(theme) {
+  if (theme === "cad-section") {
+    return {
+      background: "#f7f7f4",
+      fill: "#e6e8eb",
+      stroke: "#20262e",
+      hatchStroke: "#a8afb7",
+      strokeThin: 0.22,
+      strokeBold: 0.55,
+      useHatch: true
+    };
+  }
+  return {
+    background: "#2a2a2a",
+    fill: "#4488cc",
+    stroke: "#224466",
+    hatchStroke: "#224466",
+    strokeThin: 0.3,
+    strokeBold: 0.8,
+    useHatch: false
+  };
+}
+function edgesStrokeAttrs(preset, palette) {
   switch (preset) {
     case "off":
       return 'stroke="none"';
     case "bold":
-      return 'stroke="#224466" stroke-width="0.8"';
+      return `stroke="${palette.stroke}" stroke-width="${palette.strokeBold}"`;
     default:
-      return 'stroke="#224466" stroke-width="0.3"';
+      return `stroke="${palette.stroke}" stroke-width="${palette.strokeThin}"`;
   }
 }
 function combineBounds(left, right) {
@@ -89412,6 +89485,19 @@ function escapeAttribute(value) {
 function polygonPath(poly) {
   return `${poly.map((point2, index) => `${index === 0 ? "M" : "L"}${point2[0].toFixed(3)},${(-point2[1]).toFixed(3)}`).join(" ")} Z`;
 }
+function compoundPolygonPath(polygons) {
+  return polygons.map(polygonPath).join(" ");
+}
+function hatchDefs(palette) {
+  if (!palette.useHatch) return "";
+  return `  <defs>
+    <pattern id="forge-section-hatch" patternUnits="userSpaceOnUse" width="4" height="4" patternTransform="rotate(45)">
+      <rect width="4" height="4" fill="${palette.fill}"/>
+      <line x1="0" y1="0" x2="0" y2="4" stroke="${palette.hatchStroke}" stroke-width="0.28"/>
+    </pattern>
+  </defs>
+`;
+}
 function prepareEntry(entry) {
   const polygons = entry.sketch.toPolygons();
   if (polygons.length === 0) {
@@ -89433,7 +89519,9 @@ function buildSketchSvgDocument(entries, options = {}) {
     throw new Error("Sketch SVG export requires at least one sketch payload.");
   }
   const edges = options.edges ?? "thin";
-  const strokeAttrs = edgesStrokeAttrs(edges);
+  const palette = paletteForTheme(options.theme ?? "debug");
+  const strokeAttrs = edgesStrokeAttrs(edges, palette);
+  const fill = palette.useHatch ? "url(#forge-section-hatch)" : palette.fill;
   const prepared = entries.map(prepareEntry);
   const combinedBounds = prepared.reduce((acc, entry) => combineBounds(acc, entry.bounds), prepared[0].bounds);
   const margin = 2;
@@ -89446,17 +89534,15 @@ function buildSketchSvgDocument(entries, options = {}) {
   let pathCount = 0;
   const body = prepared.map((entry) => {
     const label = entry.name ? ` data-name="${escapeAttribute(entry.name)}"` : "";
-    const paths = entry.polygons.map((poly) => {
-      pathCount += 1;
-      return `    <path d="${polygonPath(poly)}" fill="#4488cc" ${strokeAttrs}/>`;
-    }).join("\n");
+    pathCount += entry.polygons.length;
     return `  <g${label}>
-${paths}
+    <path d="${compoundPolygonPath(entry.polygons)}" fill="${fill}" fill-rule="evenodd" ${strokeAttrs}/>
   </g>`;
   }).join("\n");
   return {
     svg: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${minX.toFixed(1)} ${(-maxY).toFixed(1)} ${width.toFixed(1)} ${height.toFixed(1)}" width="${Math.max(width * 4, 400)}" height="${Math.max(height * 4, 400)}">
-  <rect x="${minX.toFixed(1)}" y="${(-maxY).toFixed(1)}" width="${width.toFixed(1)}" height="${height.toFixed(1)}" fill="#2a2a2a"/>
+  <rect x="${minX.toFixed(1)}" y="${(-maxY).toFixed(1)}" width="${width.toFixed(1)}" height="${height.toFixed(1)}" fill="${palette.background}"/>
+${hatchDefs(palette)}
 ${body}
 </svg>`,
     width,
@@ -90257,9 +90343,11 @@ var INSPECT_CHANNEL_DESCRIPTIONS = {
   rgb: "Canonical viewport RGB renders.",
   depth: "Packed linear view-depth maps.",
   normals: "View-space normal maps.",
+  zebra: "Reflective zebra stripes for surface-continuity inspection.",
   roughness: "Surface roughness and sharp-feature heatmap.",
   mask: "Object identity masks.",
   connectivity: "Physical connected-component masks.",
+  floating: "Disconnected floating body highlights.",
   distance: "Rooted physical-component distance heatmap.",
   collisions: "Ghosted source objects with highlighted intersection volumes.",
   thickness: "Local wall-thickness heatmap.",
@@ -90269,16 +90357,18 @@ var ALL_INSPECT_CHANNELS = [
   "rgb",
   "depth",
   "normals",
+  "zebra",
   "roughness",
   "mask",
   "connectivity",
+  "floating",
   "distance",
   "collisions",
   "thickness",
   "section"
 ];
 var SUPPORTED_INSPECT_CHANNELS = new Set(ALL_INSPECT_CHANNELS);
-var RENDER_STYLES = /* @__PURE__ */ new Set(["classic", "studio", "fast", "glass"]);
+var RENDER_STYLES = /* @__PURE__ */ new Set(["classic", "studio", "fast", "glass", "precision", "hybrid"]);
 function resolveChromePath(explicitPath) {
   if (explicitPath && existsSync5(explicitPath)) return explicitPath;
   return CHROME_PATHS.find((p2) => existsSync5(p2)) || null;
@@ -90303,7 +90393,7 @@ Options:
   --focus [names]                  Focus: no arg hides mocks; comma-separated names/globs show only those
   --hide <names>                   Hide comma-separated object names/globs, show everything else
   --background <color>            Canvas background override
-  --render-style <classic|studio|fast|glass>
+  --render-style <classic|studio|fast|glass|precision|hybrid>
                                   Visual render style (default: classic)
   --render-mode <solid|wireframe> Render as shaded solid (default) or wireframe only
   --edges <off|thin|bold>         Edge overlay preset for solid mode (default: off)
@@ -90340,14 +90430,16 @@ function splitCsv(value) {
 }
 function parseRenderStyle(value) {
   if (RENDER_STYLES.has(value)) return value;
-  throw new Error(`--render-style must be 'classic', 'studio', 'fast', or 'glass' (got '${value}')`);
+  throw new Error(`--render-style must be 'classic', 'studio', 'fast', 'glass', 'precision', or 'hybrid' (got '${value}')`);
 }
 function sceneSpecHasCamera(sceneSpec) {
   let parsed;
   try {
     parsed = JSON.parse(sceneSpec);
   } catch (err2) {
-    throw new Error(`--scene must be valid JSON when combined with --camera or --view: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    throw new Error(
+      `--scene must be valid JSON when combined with --camera or --view: ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
   }
   return parsed && typeof parsed === "object" && !Array.isArray(parsed) && Object.prototype.hasOwnProperty.call(parsed, "camera");
 }
@@ -90530,7 +90622,9 @@ function parseRenderCliOptions(argv) {
     throw new Error("Cannot use --view with --scene JSON that includes camera. Remove the camera field from --scene or use --camera.");
   }
   if ((cameraSpec || cameras.length > 0) && sceneHasCamera) {
-    throw new Error("Cannot use --camera with --scene JSON that includes camera. Remove the camera field from --scene or use --scene by itself.");
+    throw new Error(
+      "Cannot use --camera with --scene JSON that includes camera. Remove the camera field from --scene or use --scene by itself."
+    );
   }
   if (cameras.length === 0 && !cameraSpec && !sceneSpec && !viewName) {
     cameras.push("iso");
@@ -90572,8 +90666,8 @@ Options:
   --min-thickness <mm>            Critical thickness threshold (default: 1.2)
   --warn-thickness <mm>           Warning thickness threshold (default: 2.0)
   --max-thickness <mm>            Thick/blue heatmap threshold (default: 6.0)
-  --thickness-samples <n>         Max thickness point samples per object (default: 5000)
-  --roughness-samples <n>         Max roughness point samples per object (default: 5000)
+  --thickness-samples <n>         Max thickness point samples per object (overrides the default scene budget)
+  --roughness-samples <n>         Max roughness point samples per object (overrides the default scene budget)
   --size <px>                     Image size in pixels (default: ${DEFAULT_SIZE})
   --quality <default|live|high>   Mesh/render quality (default: default)
   --force                         Replace an existing bundle directory
@@ -91014,6 +91108,16 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
       views: buildViewPathEntries(emittedPaths.normals)
     };
   }
+  if (emittedPaths.zebra) {
+    channels.zebra = {
+      format: "png",
+      encoding: "rgb8-reflected-zebra-stripes",
+      coordinateSpace: "camera-view",
+      background: { rgb: [0, 0, 0], stripe: null },
+      decode: "procedural reflected stripe visualization from camera-view normals; use visually to spot surface-continuity breaks",
+      views: buildViewPathEntries(emittedPaths.zebra)
+    };
+  }
   if (emittedPaths.roughness) {
     channels.roughness = {
       format: "png",
@@ -91023,6 +91127,7 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
       decode: "smooth and moderate triangles render as a translucent shadow; colored regions mark triangles adjacent to sharp, harsh, boundary, or non-manifold mesh edges",
       method: result.roughness?.method,
       options: result.roughness?.options,
+      sampleBudget: result.roughness?.sampleBudget,
       style: result.roughness?.style,
       objectCount: result.roughness?.objectCount ?? 0,
       objects: result.roughness?.objects ?? [],
@@ -91066,6 +91171,28 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
       views: buildViewPathEntries(emittedPaths.connectivity)
     };
   }
+  if (emittedPaths.floating) {
+    channels.floating = {
+      format: "png",
+      encoding: "rgb8-floating-body-highlight",
+      backgroundColor: [0, 0, 0],
+      decode: "only bodies without a mesh-contact path to the ground plane render in the highlight color; black means background or ground-reachable geometry",
+      method: result.floating?.method,
+      options: result.floating?.options,
+      rootComponentIndex: result.floating?.rootComponentIndex ?? null,
+      style: result.floating?.style,
+      objectCount: result.floating?.objectCount ?? 0,
+      componentCount: result.floating?.componentCount ?? 0,
+      floatingComponentCount: result.floating?.floatingComponentCount ?? 0,
+      floatingObjectCount: result.floating?.floatingObjectCount ?? 0,
+      floatingBodyCount: result.floating?.floatingBodyCount ?? 0,
+      components: result.floating?.components ?? [],
+      objects: result.floating?.objects ?? [],
+      contacts: result.floating?.contacts ?? [],
+      warnings: result.floating?.warnings ?? [],
+      views: buildViewPathEntries(emittedPaths.floating)
+    };
+  }
   if (emittedPaths.distance) {
     channels.distance = {
       format: "png",
@@ -91099,6 +91226,13 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
       method: result.collisions?.method,
       options: result.collisions?.options,
       broadphase: result.collisions?.broadphase,
+      candidatePairCount: result.collisions?.candidatePairCount ?? 0,
+      bboxVolumePrunedPairCount: result.collisions?.bboxVolumePrunedPairCount ?? 0,
+      testedPairCount: result.collisions?.testedPairCount ?? 0,
+      skippedPairCount: result.collisions?.skippedPairCount ?? 0,
+      pairLimitSkippedPairCount: result.collisions?.pairLimitSkippedPairCount ?? 0,
+      timeBudgetSkippedPairCount: result.collisions?.timeBudgetSkippedPairCount ?? 0,
+      exactCheckMs: result.collisions?.exactCheckMs ?? 0,
       style: result.collisions?.style,
       objectCount: result.collisions?.objectCount ?? 0,
       collisionCount: result.collisions?.collisionCount ?? 0,
@@ -91114,9 +91248,10 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
       encoding: "rgb8-thickness-heatmap",
       units: "model",
       backgroundColor: [0, 0, 0],
-      decode: "surface heatmap from mesh-normal raycast thickness; red <= minThickness, orange <= warnThickness, green-to-blue through maxThickness, gray unresolved",
+      decode: "surface heatmap from contact-aware mesh-normal raycast thickness; red <= minThickness, orange <= warnThickness, green-to-blue through maxThickness, gray unresolved",
       method: result.thickness?.method,
       options: result.thickness?.options,
+      sampleBudget: result.thickness?.sampleBudget,
       style: result.thickness?.style,
       objectCount: result.thickness?.objectCount ?? 0,
       objects: result.thickness?.objects ?? [],
@@ -91536,10 +91671,10 @@ async function runRenderInspectCli(argv = process.argv.slice(2)) {
         }
         console.log(`[inspect] Wrote ${channel} channel files.`);
       };
-      const writeChannelJson = async (channel, filename, source) => {
+      const writeChannelJson = async (channel, filename, source, { pretty = true } = {}) => {
         if (!source) return null;
         const relPath = toPortablePath(join5("channels", channel, filename));
-        await writeFile(join5(tempDir, relPath), `${JSON.stringify(source, null, 2)}
+        await writeFile(join5(tempDir, relPath), `${pretty ? JSON.stringify(source, null, 2) : JSON.stringify(source)}
 `, "utf-8");
         return relPath;
       };
@@ -91552,9 +91687,14 @@ async function runRenderInspectCli(argv = process.argv.slice(2)) {
       if (requested.has("normals")) {
         await writeViewChannel("normals", result.normals);
       }
+      if (requested.has("zebra")) {
+        await writeViewChannel("zebra", result.zebra);
+      }
       if (requested.has("roughness")) {
         await writeViewChannel("roughness", result.roughness?.views);
-        emittedPaths.roughnessPointCloud = await writeChannelJson("roughness", "point-cloud.json", result.roughness?.pointCloud);
+        emittedPaths.roughnessPointCloud = await writeChannelJson("roughness", "point-cloud.json", result.roughness?.pointCloud, {
+          pretty: false
+        });
       }
       if (requested.has("mask")) {
         await writeViewChannel("mask", result.mask?.views);
@@ -91562,6 +91702,9 @@ async function runRenderInspectCli(argv = process.argv.slice(2)) {
       if (requested.has("connectivity")) {
         await writeViewChannel("connectivity", result.connectivity?.views);
       }
+      if (requested.has("floating")) {
+        await writeViewChannel("floating", result.floating?.views);
+      }
       if (requested.has("distance")) {
         await writeViewChannel("distance", result.distance?.views);
       }
@@ -91570,7 +91713,9 @@ async function runRenderInspectCli(argv = process.argv.slice(2)) {
       }
       if (requested.has("thickness")) {
         await writeViewChannel("thickness", result.thickness?.views);
-        emittedPaths.thicknessPointCloud = await writeChannelJson("thickness", "point-cloud.json", result.thickness?.pointCloud);
+        emittedPaths.thicknessPointCloud = await writeChannelJson("thickness", "point-cloud.json", result.thickness?.pointCloud, {
+          pretty: false
+        });
       }
       if (requested.has("section")) {
         console.log("[inspect] Writing section channel files...");
@@ -92783,10 +92928,16 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   const collisions = [];
   const preparedEntries = entries.map((entry) => prepareEntry2(entry));
   const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs(preparedEntries, options);
-  const limitedCandidatePairs = options.maxCandidatePairs === null ? candidatePairs : candidatePairs.slice(0, options.maxCandidatePairs);
-  const pairLimitSkippedPairCount = candidatePairs.length - limitedCandidatePairs.length;
+  const exactCandidatePairs = candidatePairs.filter((pair) => pair.bboxOverlapVolume > options.minOverlapVolume);
+  const bboxVolumePrunedPairCount = candidatePairs.length - exactCandidatePairs.length;
+  const limitedCandidatePairs = options.maxCandidatePairs === null ? exactCandidatePairs : exactCandidatePairs.slice(0, options.maxCandidatePairs);
+  const pairLimitSkippedPairCount = exactCandidatePairs.length - limitedCandidatePairs.length;
   let testedPairCount = 0;
   let timeBudgetStopped = false;
+  const exactCheckedKeys = /* @__PURE__ */ new Set();
+  const pairKey2 = (pair) => `${pair.sourceIndex}:${pair.targetIndex}`;
+  const exactCandidateKeys = new Set(exactCandidatePairs.map(pairKey2));
+  const limitedCandidateKeys = new Set(limitedCandidatePairs.map(pairKey2));
   const exactStarted = performance.now();
   for (const pair of limitedCandidatePairs) {
     if (options.maxElapsedMs !== null && (options.maxElapsedMs <= 0 || performance.now() - exactStarted >= options.maxElapsedMs)) {
@@ -92794,6 +92945,7 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
       break;
     }
     testedPairCount += 1;
+    exactCheckedKeys.add(pairKey2(pair));
     const a = preparedEntries[pair.sourceIndex];
     const b = preparedEntries[pair.targetIndex];
     try {
@@ -92824,10 +92976,11 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   const bboxCandidates = options.includeBBoxCandidates ? candidatePairs.map((pair, index) => {
     const source = preparedEntries[pair.sourceIndex];
     const target = preparedEntries[pair.targetIndex];
-    const exactChecked = index < testedPairCount;
+    const exactChecked = exactCheckedKeys.has(pairKey2(pair));
     let skippedBy;
     if (!exactChecked) {
-      skippedBy = index >= limitedCandidatePairs.length ? "pair-limit" : "time-budget";
+      const key = pairKey2(pair);
+      skippedBy = !exactCandidateKeys.has(key) ? "bbox-volume-threshold" : limitedCandidateKeys.has(key) ? "time-budget" : "pair-limit";
     }
     return {
       index: index + 1,
@@ -92871,10 +93024,12 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
       method: "aabb-bvh",
       allPairCount: preparedEntries.length * (preparedEntries.length - 1) / 2,
       bboxPairChecks,
+      bboxVolumePrunedPairCount,
       booleanPairChecks: testedPairCount
     },
     objectCount: objects.length,
     candidatePairCount: candidatePairs.length,
+    bboxVolumePrunedPairCount,
     testedPairCount,
     skippedPairCount,
     pairLimitSkippedPairCount,
@@ -92888,13 +93043,335 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   };
 }
 
+// src/forge/inspection/contact.ts
+var AXIS_NAMES = ["x", "y", "z"];
+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 hasPositiveGap(gaps) {
+  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
+}
+function contactFromBBoxes(a, b, tolerance) {
+  const gaps = aabbGaps(a, b);
+  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
+  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 isFiniteTriangle(positions, offset2) {
+  for (let index = 0; index < 9; index += 1) {
+    if (!Number.isFinite(positions[offset2 + index])) return false;
+  }
+  return true;
+}
+function triangleRef(positions, offset2) {
+  if (!isFiniteTriangle(positions, offset2)) return null;
+  const ax = positions[offset2];
+  const ay = positions[offset2 + 1];
+  const az = positions[offset2 + 2];
+  const bx = positions[offset2 + 3];
+  const by = positions[offset2 + 4];
+  const bz = positions[offset2 + 5];
+  const cx = positions[offset2 + 6];
+  const cy = positions[offset2 + 7];
+  const cz = positions[offset2 + 8];
+  return {
+    offset: offset2,
+    min: [Math.min(ax, bx, cx), Math.min(ay, by, cy), Math.min(az, bz, cz)],
+    max: [Math.max(ax, bx, cx), Math.max(ay, by, cy), Math.max(az, bz, cz)]
+  };
+}
+function meshContactDataFor(entry) {
+  const positions = entry.positions;
+  if (!positions || positions.length < 9) return null;
+  const triangleCount = Math.floor(positions.length / 9);
+  const triangles = [];
+  for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex += 1) {
+    const triangle = triangleRef(positions, triangleIndex * 9);
+    if (triangle) triangles.push(triangle);
+  }
+  if (triangles.length === 0) return null;
+  return {
+    positions,
+    vertexCount: triangleCount * 3,
+    triangles
+  };
+}
+function distSq2(px, py, pz, qx, qy, qz) {
+  const dx = px - qx;
+  const dy = py - qy;
+  const dz = pz - qz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function pointSegmentDistanceSq(point2, start, end) {
+  const dx = end[0] - start[0];
+  const dy = end[1] - start[1];
+  const dz = end[2] - start[2];
+  const lengthSq = dx * dx + dy * dy + dz * dz;
+  if (lengthSq <= 1e-20) return distSq2(point2[0], point2[1], point2[2], start[0], start[1], start[2]);
+  const t = Math.max(0, Math.min(1, ((point2[0] - start[0]) * dx + (point2[1] - start[1]) * dy + (point2[2] - start[2]) * dz) / lengthSq));
+  return distSq2(point2[0], point2[1], point2[2], start[0] + t * dx, start[1] + t * dy, start[2] + t * dz);
+}
+function pointTriangleDistanceSq(px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz) {
+  const abx = bx - ax;
+  const aby = by - ay;
+  const abz = bz - az;
+  const acx = cx - ax;
+  const acy = cy - ay;
+  const acz = cz - az;
+  const apx = px - ax;
+  const apy = py - ay;
+  const apz = pz - az;
+  const d1 = abx * apx + aby * apy + abz * apz;
+  const d2 = acx * apx + acy * apy + acz * apz;
+  if (d1 <= 0 && d2 <= 0) return distSq2(px, py, pz, ax, ay, az);
+  const bpx = px - bx;
+  const bpy = py - by;
+  const bpz = pz - bz;
+  const d3 = abx * bpx + aby * bpy + abz * bpz;
+  const d4 = acx * bpx + acy * bpy + acz * bpz;
+  if (d3 >= 0 && d4 <= d3) return distSq2(px, py, pz, bx, by, bz);
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+    const v2 = d1 / (d1 - d3);
+    return distSq2(px, py, pz, ax + v2 * abx, ay + v2 * aby, az + v2 * abz);
+  }
+  const cpx = px - cx;
+  const cpy = py - cy;
+  const cpz = pz - cz;
+  const d5 = abx * cpx + aby * cpy + abz * cpz;
+  const d6 = acx * cpx + acy * cpy + acz * cpz;
+  if (d6 >= 0 && d5 <= d6) return distSq2(px, py, pz, cx, cy, cz);
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+    const w2 = d2 / (d2 - d6);
+    return distSq2(px, py, pz, ax + w2 * acx, ay + w2 * acy, az + w2 * acz);
+  }
+  const va = d3 * d6 - d5 * d4;
+  if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
+    const bcx = cx - bx;
+    const bcy = cy - by;
+    const bcz = cz - bz;
+    const w2 = (d4 - d3) / (d4 - d3 + d5 - d6);
+    return distSq2(px, py, pz, bx + w2 * bcx, by + w2 * bcy, bz + w2 * bcz);
+  }
+  const barycentricTotal = va + vb + vc;
+  if (!Number.isFinite(barycentricTotal) || Math.abs(barycentricTotal) < 1e-20) {
+    return Math.min(distSq2(px, py, pz, ax, ay, az), distSq2(px, py, pz, bx, by, bz), distSq2(px, py, pz, cx, cy, cz));
+  }
+  const denom = 1 / barycentricTotal;
+  const v = vb * denom;
+  const w = vc * denom;
+  return distSq2(px, py, pz, ax + abx * v + acx * w, ay + aby * v + acy * w, az + abz * v + acz * w);
+}
+function segmentSegmentDistanceSq(a0, a1, b0, b1) {
+  const ux = a1[0] - a0[0];
+  const uy = a1[1] - a0[1];
+  const uz = a1[2] - a0[2];
+  const vx = b1[0] - b0[0];
+  const vy = b1[1] - b0[1];
+  const vz = b1[2] - b0[2];
+  const wx = a0[0] - b0[0];
+  const wy = a0[1] - b0[1];
+  const wz = a0[2] - b0[2];
+  const a = ux * ux + uy * uy + uz * uz;
+  const b = ux * vx + uy * vy + uz * vz;
+  const c = vx * vx + vy * vy + vz * vz;
+  const d = ux * wx + uy * wy + uz * wz;
+  const e = vx * wx + vy * wy + vz * wz;
+  const denom = a * c - b * b;
+  let sNumerator = denom;
+  let sDenominator = denom;
+  let tNumerator = denom;
+  let tDenominator = denom;
+  if (a <= 1e-20) return pointSegmentDistanceSq(a0, b0, b1);
+  if (c <= 1e-20) return pointSegmentDistanceSq(b0, a0, a1);
+  if (denom < 1e-20) {
+    sNumerator = 0;
+    sDenominator = 1;
+    tNumerator = e;
+    tDenominator = c;
+  } else {
+    sNumerator = b * e - c * d;
+    tNumerator = a * e - b * d;
+    if (sNumerator < 0) {
+      sNumerator = 0;
+      tNumerator = e;
+      tDenominator = c;
+    } else if (sNumerator > sDenominator) {
+      sNumerator = sDenominator;
+      tNumerator = e + b;
+      tDenominator = c;
+    }
+  }
+  if (tNumerator < 0) {
+    tNumerator = 0;
+    if (-d < 0) {
+      sNumerator = 0;
+    } else if (-d > a) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d;
+      sDenominator = a;
+    }
+  } else if (tNumerator > tDenominator) {
+    tNumerator = tDenominator;
+    if (-d + b < 0) {
+      sNumerator = 0;
+    } else if (-d + b > a) {
+      sNumerator = sDenominator;
+    } else {
+      sNumerator = -d + b;
+      sDenominator = a;
+    }
+  }
+  const s = Math.abs(sNumerator) < 1e-20 ? 0 : sNumerator / sDenominator;
+  const t = Math.abs(tNumerator) < 1e-20 ? 0 : tNumerator / tDenominator;
+  const dx = wx + s * ux - t * vx;
+  const dy = wy + s * uy - t * vy;
+  const dz = wz + s * uz - t * vz;
+  return dx * dx + dy * dy + dz * dz;
+}
+function trianglePoint(positions, triangle, corner) {
+  const offset2 = triangle.offset + corner * 3;
+  return [positions[offset2], positions[offset2 + 1], positions[offset2 + 2]];
+}
+function bboxDistanceSq(a, b) {
+  let total = 0;
+  for (let axis = 0; axis < 3; axis += 1) {
+    const gap = Math.max(0, a.min[axis] - b.max[axis], b.min[axis] - a.max[axis]);
+    total += gap * gap;
+  }
+  return total;
+}
+function triangleDistanceSq(aPositions, a, bPositions, b) {
+  const a0 = trianglePoint(aPositions, a, 0);
+  const a1 = trianglePoint(aPositions, a, 1);
+  const a2 = trianglePoint(aPositions, a, 2);
+  const b0 = trianglePoint(bPositions, b, 0);
+  const b1 = trianglePoint(bPositions, b, 1);
+  const b22 = trianglePoint(bPositions, b, 2);
+  return Math.min(
+    pointTriangleDistanceSq(a0[0], a0[1], a0[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(a1[0], a1[1], a1[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(a2[0], a2[1], a2[2], b0[0], b0[1], b0[2], b1[0], b1[1], b1[2], b22[0], b22[1], b22[2]),
+    pointTriangleDistanceSq(b0[0], b0[1], b0[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    pointTriangleDistanceSq(b1[0], b1[1], b1[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    pointTriangleDistanceSq(b22[0], b22[1], b22[2], a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]),
+    segmentSegmentDistanceSq(a0, a1, b0, b1),
+    segmentSegmentDistanceSq(a0, a1, b1, b22),
+    segmentSegmentDistanceSq(a0, a1, b22, b0),
+    segmentSegmentDistanceSq(a1, a2, b0, b1),
+    segmentSegmentDistanceSq(a1, a2, b1, b22),
+    segmentSegmentDistanceSq(a1, a2, b22, b0),
+    segmentSegmentDistanceSq(a2, a0, b0, b1),
+    segmentSegmentDistanceSq(a2, a0, b1, b22),
+    segmentSegmentDistanceSq(a2, a0, b22, b0)
+  );
+}
+function meshEntriesContactDistance(a, b, tolerance) {
+  const toleranceSq = tolerance * tolerance;
+  let bestDistanceSq = Infinity;
+  for (const aTriangle of a.triangles) {
+    for (const bTriangle of b.triangles) {
+      if (bboxDistanceSq(aTriangle, bTriangle) > toleranceSq) continue;
+      const distanceSq = triangleDistanceSq(a.positions, aTriangle, b.positions, bTriangle);
+      if (distanceSq > toleranceSq) continue;
+      if (distanceSq <= 1e-20) return 0;
+      bestDistanceSq = Math.min(bestDistanceSq, distanceSq);
+    }
+  }
+  return Number.isFinite(bestDistanceSq) ? Math.sqrt(bestDistanceSq) : null;
+}
+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 (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return { volume: null, warning: `Could not boolean-test ${a.name} against ${b.name}: ${message}` };
+  }
+}
+function detectPhysicalContact(a, b, options, meshCache = {}) {
+  const gaps = aabbGaps(a, b);
+  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
+  if (largestGap > options.contactTolerance) return { contact: null };
+  const sourceMesh = meshCache.sourceMesh !== void 0 ? meshCache.sourceMesh : meshContactDataFor(a);
+  const targetMesh = meshCache.targetMesh !== void 0 ? meshCache.targetMesh : meshContactDataFor(b);
+  if (sourceMesh && targetMesh) {
+    const distance5 = meshEntriesContactDistance(sourceMesh, targetMesh, options.contactTolerance);
+    if (distance5 != null) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "mesh-surface-distance",
+          gap: distance5
+        }
+      };
+    }
+  }
+  const bboxOverlaps = !hasPositiveGap(gaps) && aabbInteriorOverlaps(a, b);
+  if (options.exactGeometry && bboxOverlaps) {
+    if (aabbOverlapVolume(a, b) <= options.minOverlapVolume) return { contact: null };
+    const overlap = intersectionVolume(a, b);
+    if (overlap.volume != null && overlap.volume > options.minOverlapVolume) {
+      return {
+        contact: {
+          kind: "overlap",
+          method: "boolean-intersection",
+          gap: 0,
+          overlapVolume: overlap.volume
+        },
+        warning: overlap.warning
+      };
+    }
+    return { contact: null, warning: overlap.warning };
+  }
+  if (bboxOverlaps && options.mergeOverlappingBBoxes) {
+    return {
+      contact: {
+        kind: "overlap",
+        method: "bbox-overlap",
+        gap: 0,
+        overlapVolume: aabbOverlapVolume(a, b)
+      }
+    };
+  }
+  if (options.mergeTouchingBBoxes) {
+    const contact = contactFromBBoxes(a, b, options.contactTolerance);
+    if (contact.touching) {
+      return {
+        contact: {
+          kind: "touching",
+          method: "bbox-contact",
+          gap: contact.gap,
+          axis: contact.axis
+        }
+      };
+    }
+  }
+  return { contact: null };
+}
+
 // src/forge/inspection/physical-connectivity.ts
 var DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
   contactTolerance: 0.05,
   minOverlapVolume: 0.1,
   exactGeometry: true
 };
-var AXIS_NAMES = ["x", "y", "z"];
 var UnionFind2 = class {
   parent;
   rank;
@@ -92940,12 +93417,6 @@ function expandBBox(target, min2, max4) {
     target.max[axis] = Math.max(target.max[axis], max4[axis]);
   }
 }
-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 hasPositiveGap(gaps) {
-  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
-}
 function collectCandidatePairs2(entries, tolerance) {
   if (entries.length < 2) return [];
   const index = new AabbSpatialIndex(entries);
@@ -92957,35 +93428,6 @@ function collectCandidatePairs2(entries, tolerance) {
   pairs.sort((a, b) => a.sourceIndex - b.sourceIndex || a.targetIndex - b.targetIndex);
   return pairs;
 }
-function contactFromBBoxes(a, b, tolerance) {
-  const gaps = aabbGaps(a, b);
-  const largestGap = Math.max(gaps[0], gaps[1], gaps[2]);
-  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 (err2) {
-    const message = err2 instanceof Error ? err2.message : String(err2);
-    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));
@@ -93017,52 +93459,22 @@ function analyzePhysicalConnectivity2(entries, rawOptions = {}) {
   const warnings = [];
   const edges = [];
   const unionFind = new UnionFind2(entries.length);
+  const meshDataByIndex = /* @__PURE__ */ new Map();
+  entries.forEach((entry, index) => {
+    const meshData = meshContactDataFor(entry);
+    if (meshData) meshDataByIndex.set(index, meshData);
+  });
   for (const pair of collectCandidatePairs2(entries, options.contactTolerance)) {
     const i = pair.sourceIndex;
     const j = pair.targetIndex;
-    const a = entries[i];
-    const b = entries[j];
-    const bboxOverlaps = !hasPositiveGap(pair.gaps) && aabbInteriorOverlaps(a, b);
-    if (options.exactGeometry && bboxOverlaps) {
-      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(
-          makeEdge2(entries, i, j, {
-            kind: "overlap",
-            method: "boolean-intersection",
-            gap: 0,
-            overlapVolume: overlap.volume
-          })
-        );
-        continue;
-      }
-      continue;
-    }
-    if (bboxOverlaps && options.mergeOverlappingBBoxes) {
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge2(entries, i, j, {
-          kind: "overlap",
-          method: "bbox-overlap",
-          gap: 0,
-          overlapVolume: aabbOverlapVolume(a, b)
-        })
-      );
-    } else {
-      const contact = contactFromBBoxes(a, b, options.contactTolerance);
-      if (!contact.touching || !options.mergeTouchingBBoxes) continue;
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge2(entries, i, j, {
-          kind: "touching",
-          method: "bbox-contact",
-          gap: contact.gap,
-          axis: contact.axis
-        })
-      );
-    }
+    const detection = detectPhysicalContact(entries[i], entries[j], options, {
+      sourceMesh: meshDataByIndex.get(i) ?? null,
+      targetMesh: meshDataByIndex.get(j) ?? null
+    });
+    if (detection.warning) warnings.push(detection.warning);
+    if (!detection.contact) continue;
+    unionFind.union(i, j);
+    edges.push(makeEdge2(entries, i, j, detection.contact));
   }
   const objects = entries.map((entry, index) => ({
     index,
@@ -93107,7 +93519,7 @@ function analyzePhysicalConnectivity2(entries, rawOptions = {}) {
   }
   const components = [...componentByRoot.values()];
   return {
-    method: options.exactGeometry ? "boolean-overlap-plus-bbox-contact" : "bbox-neighborhood",
+    method: options.exactGeometry ? "mesh-contact-plus-boolean-overlap" : "bbox-neighborhood",
     options,
     objectCount: objects.length,
     componentCount: components.length,
@@ -96661,9 +97073,6 @@ ${errors.join("\n\n")}`);
 }
 runDirectCliMain(import.meta.url, "cli/check-runtime-globals.ts", () => runCheckRuntimeGlobalsCli());
 
-// cli/check-suite.ts
-import { execSync as execSync2 } from "child_process";
-
 // cli/check-text.ts
 import assert8 from "assert/strict";
 var EPS17 = 1e-3;
@@ -97238,181 +97647,6 @@ async function runCheckTransformsCli() {
 }
 runDirectCliMain(import.meta.url, "cli/check-transforms.ts", () => runCheckTransformsCli());
 
-// cli/check-suite.ts
-var BRAILLE_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var ANSI = {
-  dim: "\x1B[2m",
-  bold: "\x1B[1m",
-  green: "\x1B[32m",
-  cyan: "\x1B[36m",
-  yellow: "\x1B[33m",
-  red: "\x1B[31m",
-  reset: "\x1B[0m",
-  clearLine: "\x1B[2K",
-  cursorUp: "\x1B[1A",
-  hideCursor: "\x1B[?25l",
-  showCursor: "\x1B[?25h"
-};
-function createSmokeStages() {
-  return [
-    { label: "Constraints", insight: "solver convergence & snapshot fidelity", run: () => runCheckConstraintsCli([]) },
-    { label: "Transforms", insight: "matrix composition & assembly trees", run: () => runCheckTransformsCli() },
-    { label: "Dimensions", insight: "parametric dimension propagation", run: () => runCheckDimensionsCli() },
-    { label: "JS modules", insight: "import graph & bundle hygiene", run: () => runCheckJsModulesCli() },
-    { label: "Runtime globals", insight: "sandbox namespace allowlist", run: () => runCheckRuntimeGlobalsCli() },
-    { label: "Text", insight: "text2d rendering contracts", run: () => runCheckTextCli() },
-    {
-      label: "Examples",
-      insight: "maintained example smoke surface",
-      run: () => runCheckExamplesCli(["--profile", "smoke"])
-    }
-  ];
-}
-function createStages(profile) {
-  const smokeStages = createSmokeStages();
-  if (profile === "smoke") return smokeStages;
-  return [
-    ...smokeStages,
-    {
-      label: "Unit tests",
-      insight: "vitest \u2014 pure geometry and integration contracts",
-      run: async () => {
-        execSync2("npx vitest run", { stdio: "pipe" });
-      }
-    },
-    { label: "Placement refs", insight: "reference stability across edits", run: () => runCheckPlacementReferencesCli() },
-    { label: "BREP export", insight: "solid topology & face-history integrity", run: () => runCheckBrepExportCli() },
-    { label: "Compiler", insight: "AST snapshots & code-gen correctness", run: () => runCheckCompilerCli([]) },
-    { label: "Query propagation", insight: "reactive data-flow graph consistency", run: () => runCheckQueryPropagationCli([]) },
-    { label: "API contracts", insight: "public script API surface stability", run: () => runCheckApiContractsCli() },
-    { label: "OCCT lowerer", insight: "compile-plan \u2192 OCCT geometry invariants", run: () => runCheckOcctLowerCli() },
-    {
-      label: "Lint & format",
-      insight: "Biome lint + formatting consistency",
-      run: async () => {
-        execSync2("npx biome check .", { stdio: "pipe" });
-      }
-    }
-  ];
-}
-function parseProfile(argv) {
-  let profile = "full";
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === "--profile") {
-      const value = argv[i + 1];
-      if (value !== "full" && value !== "smoke" && value !== "local") {
-        throw new Error(`Unknown suite profile "${value ?? ""}". Expected "smoke" or "full" (legacy alias: "local").`);
-      }
-      profile = value === "local" ? "smoke" : value;
-      i += 1;
-      continue;
-    }
-    throw new Error(`Unknown flag: ${arg}`);
-  }
-  return profile;
-}
-function progressBar(done, total, width) {
-  const filled = Math.round(done / total * width);
-  const empty = width - filled;
-  const bar = "\x1B[32m" + "\u2501".repeat(filled) + "\x1B[2m" + "\u2500".repeat(empty) + "\x1B[0m";
-  return bar;
-}
-function formatDuration2(ms) {
-  if (ms < 1e3) return `${ms}ms`;
-  return `${(ms / 1e3).toFixed(1)}s`;
-}
-function startSpinner(stage, index, total) {
-  const isTTY = process.stdout.isTTY;
-  if (!isTTY) {
-    process.stdout.write(`[${index + 1}/${total}] ${stage.label} ...
-`);
-    return () => {
-    };
-  }
-  let frame = 0;
-  const startMs = Date.now();
-  const render = () => {
-    const spinner = `${ANSI.cyan}${BRAILLE_FRAMES[frame % BRAILLE_FRAMES.length]}${ANSI.reset}`;
-    const bar = progressBar(index, total, 20);
-    const pct = `${Math.round(index / total * 100)}%`;
-    const elapsed = formatDuration2(Date.now() - startMs);
-    const line2 = `${ANSI.clearLine}\r  ${spinner} ${bar} ${ANSI.dim}${pct}${ANSI.reset}  ${ANSI.bold}${stage.label}${ANSI.reset} ${ANSI.dim}\u2014 ${stage.insight}${ANSI.reset} ${ANSI.dim}(${elapsed})${ANSI.reset}`;
-    process.stdout.write(line2);
-    frame++;
-  };
-  render();
-  const interval = setInterval(render, 80);
-  return () => {
-    clearInterval(interval);
-    process.stdout.write(`${ANSI.clearLine}\r`);
-  };
-}
-function printStageResult(result, index, total) {
-  const icon = result.ok ? `${ANSI.green}\u2713${ANSI.reset}` : `${ANSI.red}\u2717${ANSI.reset}`;
-  const dur = `${ANSI.dim}${formatDuration2(result.durationMs)}${ANSI.reset}`;
-  const counter = `${ANSI.dim}[${index + 1}/${total}]${ANSI.reset}`;
-  console.log(`  ${icon} ${counter} ${result.label} ${dur}`);
-}
-function printSummary(results, totalMs) {
-  const passed = results.filter((r) => r.ok).length;
-  const failed = results.filter((r) => !r.ok).length;
-  const slowest = results.reduce((a, b) => a.durationMs > b.durationMs ? a : b);
-  console.log("");
-  console.log(`  ${progressBar(results.length, results.length, 20)} ${ANSI.bold}100%${ANSI.reset}`);
-  console.log("");
-  if (failed === 0) {
-    console.log(
-      `  ${ANSI.green}${ANSI.bold}\u2713 Invariant suite passed${ANSI.reset} ${ANSI.dim}\u2014 ${passed} checks in ${formatDuration2(totalMs)}${ANSI.reset}`
-    );
-  } else {
-    console.log(
-      `  ${ANSI.red}${ANSI.bold}\u2717 Suite failed${ANSI.reset} ${ANSI.dim}\u2014 ${passed} passed, ${failed} failed in ${formatDuration2(totalMs)}${ANSI.reset}`
-    );
-  }
-  console.log(`  ${ANSI.dim}slowest: ${slowest.label} (${formatDuration2(slowest.durationMs)})${ANSI.reset}`);
-  console.log("");
-}
-async function runCheckSuiteCli(argv = process.argv.slice(2)) {
-  const profile = parseProfile(argv);
-  const stages = createStages(profile);
-  const isTTY = process.stdout.isTTY;
-  if (isTTY) process.stdout.write(ANSI.hideCursor);
-  console.log("");
-  console.log(`  ${ANSI.bold}ForgeCAD Invariant Suite${ANSI.reset} ${ANSI.dim}(${profile} profile, ${stages.length} checks)${ANSI.reset}`);
-  console.log("");
-  const results = [];
-  const suiteStart = Date.now();
-  for (let i = 0; i < stages.length; i++) {
-    const stage = stages[i];
-    const stopSpinner = startSpinner(stage, i, stages.length);
-    const t0 = Date.now();
-    let ok = true;
-    let error;
-    try {
-      await stage.run();
-    } catch (err2) {
-      ok = false;
-      error = err2.message;
-    }
-    stopSpinner();
-    const result = { label: stage.label, durationMs: Date.now() - t0, ok, error };
-    results.push(result);
-    printStageResult(result, i, stages.length);
-    if (!ok && error) {
-      console.error(`    ${ANSI.red}${error}${ANSI.reset}`);
-    }
-  }
-  const totalMs = Date.now() - suiteStart;
-  printSummary(results, totalMs);
-  if (isTTY) process.stdout.write(ANSI.showCursor);
-  const failed = results.filter((r) => !r.ok);
-  if (failed.length > 0) {
-    process.exit(1);
-  }
-}
-runDirectCliMain(import.meta.url, "cli/check-suite.ts", () => runCheckSuiteCli(process.argv.slice(2)));
-
 // cli/debug-compiler.ts
 function usage3() {
   console.error("Usage: forgecad debug compiler <script.forge.js> [--compact]");
@@ -97511,7 +97745,7 @@ async function runDebugAssemblyCli(argv = process.argv.slice(2)) {
   const code = readFileSync12(resolve12(scriptPath), "utf-8");
   const { allFiles, fileName, readBinaryFile } = collectProjectFiles(scriptPath);
   await init();
-  if (backend) await activateBackend(backend);
+  await activateBackend(backend ?? CLI_DEFAULT_BACKEND);
   const result = runScript(code, fileName, allFiles, { readBinaryFile, allowEmptyResult: true });
   if (result.error) {
     console.error("ERROR:", result.error);
@@ -97971,7 +98205,7 @@ async function runBrepCli(argv = process.argv.slice(2)) {
 }
 
 // cli/forge-capture.ts
-import { execSync as execSync3, spawn as spawn3 } from "child_process";
+import { execSync as execSync2, spawn as spawn3 } from "child_process";
 import { once } from "events";
 import { existsSync as existsSync7 } from "fs";
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
@@ -98823,7 +99057,7 @@ function findExecutablePath(explicitPath, staticCandidates, binCandidates) {
   for (const bin of binCandidates) {
     try {
       const cmd = process.platform === "win32" ? `where ${bin}` : `command -v ${bin}`;
-      const found = execSync3(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+      const found = execSync2(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
       if (found && existsSync7(found)) return found;
     } catch {
     }
@@ -99389,7 +99623,7 @@ function printList(scriptPath, init2) {
   );
   console.log(`  cut planes: ${cutPlanes.length === 0 ? "(none)" : cutPlanes.join(", ")}`);
 }
-function printSummary2(options, init2, encoderMode) {
+function printSummary(options, init2, encoderMode) {
   const lines = [
     `${options.format.toUpperCase()} capture: ${basename4(options.outputPath)}`,
     `  capture=${options.capture} render=${options.renderMode}${options.includeWireframePass && options.renderMode !== "wireframe" ? "+wireframe" : ""}`,
@@ -99581,7 +99815,7 @@ async function runCaptureCli(config, argv = process.argv.slice(2)) {
       return;
     }
     const framePlan = buildFramePlan(options, init2);
-    printSummary2(options, init2, encoderMode);
+    printSummary(options, init2, encoderMode);
     if (options.format === "gif" && encoderMode === "js" && options.encoder !== "js") {
       console.log("  ffmpeg not found; using the fallback 256-color JS GIF encoder.");
     }
@@ -100293,7 +100527,7 @@ async function runMeshExportCli(format, argv) {
   const code = (await import("fs")).readFileSync(resolve20(scriptPath), "utf-8");
   const { allFiles, fileName, readBinaryFile } = collectProjectFiles(scriptPath);
   await initKernel();
-  if (backend) await activateBackend(backend);
+  await activateBackend(backend ?? CLI_DEFAULT_BACKEND);
   const qualityPreset = quality && quality !== "default" ? quality : void 0;
   const result = runScript(code, fileName, allFiles, { ...qualityPreset ? { quality: qualityPreset } : {}, readBinaryFile });
   if (result.error) {
@@ -100429,7 +100663,7 @@ async function runRenderViewsCli(argv) {
   const code = readFileSync16(scriptPath, "utf-8");
   const { allFiles, fileName, readBinaryFile } = collectProjectFiles(scriptPath);
   await init();
-  if (args.backend) await activateBackend(args.backend);
+  await activateBackend(args.backend ?? CLI_DEFAULT_BACKEND);
   const result = runScript(code, fileName, allFiles, {
     ...args.quality && args.quality !== "default" ? { quality: args.quality } : {},
     allowEmptyResult: true,
@@ -100487,7 +100721,7 @@ async function runRenderInspectChannelsCli(argv) {
 // cli/forge-render-hq.ts
 import { writeFileSync as writeFileSync9, readFileSync as readFileSync17, mkdtempSync as mkdtempSync2, rmSync as rmSync2, existsSync as existsSync9 } from "fs";
 import { resolve as resolve22, dirname as dirname8, join as join6, extname as extname6 } from "path";
-import { execSync as execSync4, spawnSync } from "child_process";
+import { execSync as execSync3, spawnSync } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
@@ -100692,7 +100926,7 @@ function parseArgs8(argv) {
   }
   if (!scriptPath) {
     throw new Error(
-      "Usage: forgecad render hq <script.forge.js> [output.png] [options]\n  --preset <studio|outdoor|dramatic|clay|wireframe|glass|metallic>\n  --edges <off|thin|bold>  Edge overlay preset (default: off)\n  --size <px>          Square output (sets both width and height)\n  --width <px>         Output width (default: 1920)\n  --height <px>        Output height (default: 1080)\n  --samples <n>        Render samples (default: 256)\n  --engine <cycles|eevee>  Render engine (default: cycles)\n  --camera <front|back|side|right|top|iso|az:el|spec>  Camera preset, angle, or exact spec\n  --camera-json <file> Exact viewport camera JSON file\n  --view <name>        Named camera view from scene({ views })\n  --scene <json|file>  Viewport scene JSON or JSON file with camera/object overrides\n  --transparent        Transparent background\n  --hdri <path.hdr>    Custom HDRI environment map\n  --video              Render orbit turntable video (MP4)\n  --frames <n>         Video frames (default: 72)\n  --fps <n>            Video FPS (default: 24)\n  --pitch <deg>        Camera pitch angle (default: 25)\n  --quality <default|live|high>  Mesh tessellation quality\n  --backend <manifold|occt|truck>  Geometry backend"
+      "Usage: forgecad render hq <script.forge.js> [output.png] [options]\n  --preset <studio|outdoor|dramatic|clay|wireframe|glass|metallic>\n  --edges <off|thin|bold>  Edge overlay preset (default: off)\n  --size <px>          Square output (sets both width and height)\n  --width <px>         Output width (default: 1920)\n  --height <px>        Output height (default: 1080)\n  --samples <n>        Render samples (default: 256)\n  --engine <cycles|eevee>  Render engine (default: cycles)\n  --camera <front|back|side|right|top|iso|az:el|spec>  Camera preset, angle, or exact spec\n  --camera-json <file> Exact viewport camera JSON file\n  --view <name>        Named camera view from scene({ views })\n  --scene <json|file>  Viewport scene JSON or JSON file with camera/object overrides\n  --transparent        Transparent background\n  --hdri <path.hdr>    Custom HDRI environment map\n  --video              Render orbit turntable video (MP4)\n  --frames <n>         Video frames (default: 72)\n  --fps <n>            Video FPS (default: 24)\n  --pitch <deg>        Camera pitch angle (default: 25)\n  --quality <default|live|high>  Mesh tessellation quality\n  --backend <manifold|occt|truck>  Geometry backend (default: manifold)"
     );
   }
   if (viewName && (cameraToken || scene2?.camera)) {
@@ -100729,7 +100963,7 @@ function parseArgs8(argv) {
 }
 function findBlender() {
   try {
-    const which = execSync4("which blender 2>/dev/null", { encoding: "utf-8" }).trim();
+    const which = execSync3("which blender 2>/dev/null", { encoding: "utf-8" }).trim();
     if (which) return which;
   } catch {
   }
@@ -100836,7 +101070,7 @@ async function runRenderHqCli(argv) {
     const { allFiles, fileName, readBinaryFile } = collectProjectFiles(args.scriptPath);
     console.log("Evaluating ForgeCAD script...");
     await initKernel();
-    if (args.backend) await activateBackend(args.backend);
+    await activateBackend(args.backend ?? CLI_DEFAULT_BACKEND);
     const qualityPreset = args.quality && args.quality !== "default" ? args.quality : void 0;
     const result = runScript(code, fileName, allFiles, {
       ...qualityPreset ? { quality: qualityPreset } : {},
@@ -105347,7 +105581,7 @@ async function runWebCli(argv = process.argv.slice(2)) {
 }
 
 // cli/forge-link.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 var PROD_BASE = "https://forgecad.io/app";
 function extractGistId(input) {
   const match = input.match(/gist\.github\.com\/(?:[^/]+\/)?([a-f0-9]+)/i);
@@ -105363,7 +105597,7 @@ async function runLinkCli(args) {
   const gistId = extractGistId(input);
   const url = `${PROD_BASE}?gist=${encodeURIComponent(gistId)}`;
   try {
-    execSync5('printf %s "$URL" | pbcopy', { env: { ...process.env, URL: url }, stdio: "ignore" });
+    execSync4('printf %s "$URL" | pbcopy', { env: { ...process.env, URL: url }, stdio: "ignore" });
     console.log(`Copied to clipboard:
 ${url}`);
   } catch {
@@ -105372,7 +105606,7 @@ ${url}`);
 }
 
 // cli/forge-publish.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import { existsSync as existsSync15 } from "fs";
 import { dirname as dirname11, relative as relative7, resolve as resolve33 } from "path";
 function findProjectRoot3(dir) {
@@ -105389,14 +105623,14 @@ function findProjectRoot3(dir) {
 }
 function copyToClipboard(text) {
   try {
-    execSync6('printf %s "$TEXT" | pbcopy', {
+    execSync5('printf %s "$TEXT" | pbcopy', {
       env: { ...process.env, TEXT: text },
       stdio: "ignore"
     });
     return true;
   } catch {
     try {
-      execSync6('printf %s "$TEXT" | xclip -selection clipboard', {
+      execSync5('printf %s "$TEXT" | xclip -selection clipboard', {
         env: { ...process.env, TEXT: text },
         stdio: "ignore"
       });
@@ -105500,7 +105734,7 @@ async function runPublishCli(args) {
 }
 
 // cli/forge-doctor.ts
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import { existsSync as existsSync16 } from "fs";
 function findExecutablePath2(staticCandidates, binCandidates) {
   for (const candidate of staticCandidates) {
@@ -105509,7 +105743,7 @@ function findExecutablePath2(staticCandidates, binCandidates) {
   for (const bin of binCandidates) {
     try {
       const cmd = process.platform === "win32" ? `where ${bin}` : `command -v ${bin}`;
-      const found = execSync7(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+      const found = execSync6(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
       if (found && existsSync16(found)) return found;
     } catch {
     }
@@ -105565,7 +105799,7 @@ function findFfmpeg() {
 }
 function getVersion(cmd) {
   try {
-    return execSync7(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim().split("\n")[0];
+    return execSync6(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim().split("\n")[0];
   } catch {
     return null;
   }
@@ -107991,7 +108225,7 @@ async function runPrintCheckCli(argv = process.argv.slice(2)) {
     const code = readFileSync26(resolve36(args.scriptPath), "utf-8");
     const { allFiles, fileName, readBinaryFile } = collectProjectFiles(args.scriptPath);
     await init();
-    if (args.backend) await activateBackend(args.backend);
+    await activateBackend(args.backend ?? CLI_DEFAULT_BACKEND);
     if (Object.keys(args.paramOverrides).length > 0) setParamOverrides(args.paramOverrides);
     const result = runScript(code, fileName, allFiles, {
       debugImports: args.debugImports,
@@ -108947,7 +109181,6 @@ var DEFAULT_EXACT_SPATIAL_OBJECT_LIMIT = 250;
 var SPATIAL_BBOX_PADDING = 0.1;
 var MAX_SPATIAL_COLLISION_LINES = 50;
 var MAX_COMPACT_OBJECT_NAMES = 24;
-var RUN_DEFAULT_BACKEND = "manifold";
 function parseSpatialMode(argv, defaultMode) {
   const consumed = /* @__PURE__ */ new Set();
   const idx = argv.indexOf("--spatial");
@@ -109404,7 +109637,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
   const printConstructionHistory = fullReport || verbose || argv.includes("--history");
   const printFeatureSummary = fullReport || verbose || argv.includes("--features");
   const printSolverProfile = fullReport || verbose || argv.includes("--solver-profile");
-  const backend = parseBackendArg(argv) ?? RUN_DEFAULT_BACKEND;
+  const backend = parseBackendArg(argv) ?? CLI_DEFAULT_BACKEND;
   const quality = parseQualityArg(argv);
   const solverDebugOut = parseRequiredArg(argv, "--solver-debug-out");
   const {
@@ -109767,7 +110000,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
     if (solverDebugOut) {
       setSolveOptionOverrides(null);
     }
-    if (backend && backend !== DEFAULT_ACTIVE_BACKEND) await activateBackend(DEFAULT_ACTIVE_BACKEND);
+    if (backend !== CLI_DEFAULT_BACKEND) setActiveBackend(CLI_DEFAULT_BACKEND);
   }
 }
 
@@ -109796,7 +110029,7 @@ async function runRenderSectionCli(argv = process.argv.slice(2)) {
   let offset2 = 0;
   let size = 1024;
   let chromePath = process.env.CHROME_PATH;
-  let background = "#2a2a2a";
+  let background = "#f7f7f4";
   let edges = "thin";
   const args = [];
   for (let i = 0; i < argv.length; i++) {
@@ -109875,7 +110108,7 @@ async function runRenderSectionCli(argv = process.argv.slice(2)) {
     console.error("No intersection found.");
     process.exit(1);
   }
-  const svgDocument = buildSketchSvgDocument(sectionSketches, { edges });
+  const svgDocument = buildSketchSvgDocument(sectionSketches, { edges, theme: "cad-section" });
   if (wantsPng) {
     const png = await svgToPng(svgDocument.svg, { size, background, chromePath: resolvedChromePath });
     await writeFile9(resolve39(outputPath), png);
@@ -110038,9 +110271,11 @@ var INSPECT_CHANNEL_VALUES = [
   { value: "rgb", description: "Canonical RGB viewport renders" },
   { value: "depth", description: "Packed linear view-depth maps" },
   { value: "normals", description: "View-space normal maps" },
+  { value: "zebra", description: "Reflective zebra stripes for surface-continuity inspection" },
   { value: "roughness", description: "Surface roughness and sharp-feature heatmap" },
   { value: "mask", description: "Object identity masks" },
   { value: "connectivity", description: "Physical connected-component masks" },
+  { value: "floating", description: "Disconnected floating body highlights" },
   { value: "distance", description: "Rooted physical-component distance heatmap" },
   { value: "collisions", description: "Ghosted source objects with highlighted intersection volumes" },
   { value: "thickness", description: "Local wall-thickness heatmap" },
@@ -110079,7 +110314,9 @@ var RENDER_STYLE_VALUES = [
   { value: "classic", description: "Technical CAD shading with crisp overlay edges" },
   { value: "studio", description: "Polished product-preview lighting and reflections" },
   { value: "fast", description: "Low-cost attractive live preview shading" },
-  { value: "glass", description: "Transparent inspection view with rim shell and readable edges" }
+  { value: "glass", description: "Transparent inspection view with rim shell and readable edges" },
+  { value: "precision", description: "Dense technical surface-field contours" },
+  { value: "hybrid", description: "Topo-led surface contours with a quiet orthogonal field" }
 ];
 var RENDER_OPTIONS = [
   {
@@ -110124,7 +110361,7 @@ var RENDER_OPTIONS = [
     name: "--render-style",
     description: "Visual render style (default: classic)",
     argument: "required",
-    valueLabel: "<classic|studio|fast|glass>",
+    valueLabel: "<classic|studio|fast|glass|precision|hybrid>",
     values: RENDER_STYLE_VALUES
   },
   { name: "--port", description: "Vite dev server port", argument: "required", valueLabel: "<n>" },
@@ -110144,7 +110381,7 @@ var RENDER_INSPECT_OPTIONS = [
     name: "--channels",
     description: "Required inspection channels to emit; no default",
     argument: "required",
-    valueLabel: "<rgb,depth,normals,roughness,mask,connectivity,distance,collisions,thickness,section>",
+    valueLabel: "<rgb,depth,normals,zebra,roughness,mask,connectivity,floating,distance,collisions,thickness,section>",
     values: INSPECT_CHANNEL_VALUES
   },
   {
@@ -110166,8 +110403,18 @@ var RENDER_INSPECT_OPTIONS = [
   { name: "--min-thickness", description: "Critical thickness threshold in model units", argument: "required", valueLabel: "<mm>" },
   { name: "--warn-thickness", description: "Warning thickness threshold in model units", argument: "required", valueLabel: "<mm>" },
   { name: "--max-thickness", description: "Thick/blue heatmap threshold in model units", argument: "required", valueLabel: "<mm>" },
-  { name: "--thickness-samples", description: "Maximum thickness point samples per object", argument: "required", valueLabel: "<n>" },
-  { name: "--roughness-samples", description: "Maximum roughness point samples per object", argument: "required", valueLabel: "<n>" },
+  {
+    name: "--thickness-samples",
+    description: "Override default scene budget with max thickness point samples per object",
+    argument: "required",
+    valueLabel: "<n>"
+  },
+  {
+    name: "--roughness-samples",
+    description: "Override default scene budget with max roughness point samples per object",
+    argument: "required",
+    valueLabel: "<n>"
+  },
   { name: "--port", description: "Vite dev server port", argument: "required", valueLabel: "<n>" },
   { name: "--fresh-server", description: "Start a fresh renderer instead of reusing an existing one" },
   {
@@ -110497,13 +110744,13 @@ var commands = [
         },
         {
           name: "--backend",
-          description: "Geometry backend",
+          description: "Geometry backend (default: manifold)",
           argument: "required",
           valueLabel: "<manifold|occt|truck>",
           values: [
-            { value: "manifold", description: "Manifold backend" },
+            { value: "manifold", description: "Manifold backend (default)" },
             { value: "occt", description: "OCCT backend" },
-            { value: "truck", description: "Rust topology backend (default)" }
+            { value: "truck", description: "Rust topology backend" }
           ]
         },
         {
@@ -110636,7 +110883,7 @@ var commands = [
         },
         {
           name: "--backend",
-          description: "Geometry backend",
+          description: "Geometry backend (default: manifold)",
           argument: "required",
           valueLabel: "<manifold|occt|truck>",
           values: ["manifold", "occt", "truck"]
@@ -110661,12 +110908,13 @@ var commands = [
     group: "Modeling",
     path: ["render", "inspect"],
     summary: "Render a machine-readable inspection bundle with geometry channels and a manifest.",
-    description: "Launches the headless viewport renderer and writes a directory bundle for agent and automation workflows. Every channel is opt-in with `--channels`; there is no default bundle. Selected channels emit canonical `front`, `right`, `top`, and `iso` views for RGB, depth, normals, surface roughness, object masks, physical connectivity, rooted component distance, collisions, and wall thickness, or a principal-plane section atlas, plus a root `manifest.json` with scene metadata, filters, object visibility, and relative file paths.\n\nUse `--focus` to isolate specific parts or hide mocks, and `--hide` to remove named clutter. Output defaults to `<script-name>-inspect/` next to the input file.\n\nFor bundle layout, channel encodings, and manifest semantics, see [Inspection Bundles](guides/inspection-bundles.md).",
+    description: "Launches the headless viewport renderer and writes a directory bundle for agent and automation workflows. Every channel is opt-in with `--channels`; there is no default bundle. Selected channels emit canonical `front`, `right`, `top`, and `iso` views for RGB, depth, normals, Zebra surface-continuity stripes, surface roughness, object masks, physical connectivity, floating body highlights, rooted component distance, collisions, and wall thickness, or a principal-plane section atlas, plus a root `manifest.json` with scene metadata, filters, object visibility, and relative file paths.\n\nUse `--focus` to isolate specific parts or hide mocks, and `--hide` to remove named clutter. Output defaults to `<script-name>-inspect/` next to the input file.\n\nFor bundle layout, channel encodings, and manifest semantics, see [Inspection Bundles](guides/inspection-bundles.md).",
     usage: [
-      "forgecad render inspect <script.forge.js> [output-dir] --channels rgb,depth,normals,roughness,mask,connectivity,distance,collisions,thickness,section [--focus [names]] [--hide names] [--min-thickness <mm>] [--warn-thickness <mm>] [options]"
+      "forgecad render inspect <script.forge.js> [output-dir] --channels rgb,depth,normals,zebra,roughness,mask,connectivity,floating,distance,collisions,thickness,section [--focus [names]] [--hide names] [--min-thickness <mm>] [--warn-thickness <mm>] [options]"
     ],
     examples: [
       "forgecad render inspect examples/api/static-assembly-connectors.forge.js --channels rgb,mask",
+      "forgecad render inspect examples/api/static-assembly-connectors.forge.js --channels rgb,zebra,normals",
       'forgecad render inspect examples/api/static-assembly-connectors.forge.js out/bench-inspect --channels collisions --focus "Bench.*"',
       'forgecad render inspect examples/api/static-assembly-connectors.forge.js --channels rgb,mask,collisions --hide "Bench.Slat0" --force'
     ],
@@ -110751,7 +110999,7 @@ var commands = [
         },
         {
           name: "--backend",
-          description: "Geometry backend",
+          description: "Geometry backend (default: manifold)",
           argument: "required",
           valueLabel: "<manifold|occt|truck>",
           values: ["manifold", "occt", "truck"]
@@ -110989,13 +111237,13 @@ var commands = [
         },
         {
           name: "--backend",
-          description: "Geometry backend",
+          description: "Geometry backend (default: manifold)",
           argument: "required",
           valueLabel: "<manifold|occt|truck>",
           values: [
-            { value: "manifold", description: "Manifold backend" },
+            { value: "manifold", description: "Manifold backend (default)" },
             { value: "occt", description: "OCCT backend" },
-            { value: "truck", description: "Rust topology backend (default)" }
+            { value: "truck", description: "Rust topology backend" }
           ]
         }
       ],
@@ -111026,13 +111274,13 @@ var commands = [
         },
         {
           name: "--backend",
-          description: "Geometry backend",
+          description: "Geometry backend (default: manifold)",
           argument: "required",
           valueLabel: "<manifold|occt|truck>",
           values: [
-            { value: "manifold", description: "Manifold backend" },
+            { value: "manifold", description: "Manifold backend (default)" },
             { value: "occt", description: "OCCT backend" },
-            { value: "truck", description: "Rust topology backend (default)" }
+            { value: "truck", description: "Rust topology backend" }
           ]
         }
       ],
@@ -111663,11 +111911,11 @@ var commands = [
         { name: "--debug-imports", description: "Include import trace logs during script execution" },
         {
           name: "--backend",
-          description: "Geometry backend",
+          description: "Geometry backend (default: manifold)",
           argument: "required",
           valueLabel: "<manifold|occt|truck>",
           values: [
-            { value: "manifold", description: "Manifold backend" },
+            { value: "manifold", description: "Manifold backend (default)" },
             { value: "occt", description: "OCCT backend" },
             { value: "truck", description: "Rust topology backend" }
           ]
@@ -111773,11 +112021,11 @@ var commands = [
         { name: "--all-forge", description: "Scan every *.forge.js file instead of only main.forge.js files" },
         {
           name: "--backend",
-          description: "Geometry backend",
+          description: "Geometry backend (default: manifold)",
           argument: "required",
           valueLabel: "<manifold|occt|truck>",
           values: [
-            { value: "manifold", description: "Manifold backend" },
+            { value: "manifold", description: "Manifold backend (default)" },
             { value: "occt", description: "OCCT backend" },
             { value: "truck", description: "Rust topology backend" }
           ]
@@ -111787,17 +112035,6 @@ var commands = [
     },
     run: runInspectMechanicalIntegrityCli
   },
-  {
-    group: "Checks",
-    path: ["check", "suite"],
-    summary: "Run the repo invariant suite, with smoke and full profiles for the fast merge lane vs the broader regression sweep.",
-    usage: ["forgecad check suite", "forgecad check suite --profile smoke"],
-    examples: ["forgecad check suite", "forgecad check suite --profile smoke"],
-    completion: {
-      options: [{ name: "--profile", description: "Suite profile: smoke or full", argument: "required", valueLabel: "<profile>" }]
-    },
-    run: (args) => runCheckSuiteCli(args)
-  },
   {
     group: "Checks",
     path: ["check", "runtime-globals"],
@@ -111989,7 +112226,12 @@ var commands = [
           argument: "required",
           valueLabel: "<error|warning>"
         },
-        { name: "--backend", description: "Geometry backend to use", argument: "required", valueLabel: "<manifold|occt|truck>" },
+        {
+          name: "--backend",
+          description: "Geometry backend to use (default: manifold)",
+          argument: "required",
+          valueLabel: "<manifold|occt|truck>"
+        },
         {
           name: "--sweep-steps",
           description: "Samples per joint range sweep; enables exact geometry checks",
@@ -112154,7 +112396,6 @@ var AUTH_EXEMPT_COMMANDS = /* @__PURE__ */ new Set([
   "debug compiler",
   "debug dimensions",
   "debug faces",
-  "check suite",
   "check print",
   "inspect mechanical-integrity"
 ]);
@@ -112426,6 +112667,7 @@ async function runForgeCadCli(argv = process.argv.slice(2)) {
     return;
   }
   validateCommandArgs(match.command, match.args);
+  setActiveBackend(CLI_DEFAULT_BACKEND);
   const shouldRequireAuth = commandRequiresCliAuth(match.command.path);
   if (shouldRequireAuth) {
     requireCliAuth();