forgecad 0.9.14 → 0.9.15

package/dist-cli/forgecad.js

@@ -29,6 +29,7 @@ import {
   buildDesignTraceNeighborhood,
   buildEdgeSvg,
   buildObjString,
+  buildSketchFromCompileProfilePlan,
   chamferTrackedEdge,
   circle2d,
   collectProjectFiles,
@@ -72,6 +73,8 @@ import {
   getSketchPlacementModel,
   getSketchWorkplane,
   getSolverStats,
+  getTruckGeometryWasm,
+  getTruckShapeBackendHandle,
   group,
   init,
   initKernel,
@@ -82,6 +85,7 @@ import {
   intersection,
   intersection2d,
   isCompiledBinary,
+  isConstraintSketch,
   isDirectCliRun,
   isOCCTShapeBackend,
   jointsView,
@@ -121,7 +125,7 @@ import {
   union2d,
   updateConstraintValue,
   wrapOCCTShapeBackend
-} from "./chunk-EXWGNL6K.js";
+} from "./chunk-N4O47JLF.js";
 
 // cli/forgecad.ts
 import { Command, Flags, Help, flush as flushOclif, handle as handleOclif, run as runOclif } from "@oclif/core";
@@ -3469,7 +3473,7 @@ function testCaseLayoutWindingOrder() {
   assertConverged(result, "caseLayoutWinding");
   const def = result.definition;
   const ptMap = new Map(def.points.map((p) => [p.id, p]));
-  function signedArea(vertices) {
+  function signedArea2(vertices) {
     const pts = vertices.map((id) => ptMap.get(id)).filter(Boolean);
     let area = 0;
     for (let i = 0; i < pts.length; i++) {
@@ -3492,7 +3496,7 @@ function testCaseLayoutWindingOrder() {
     { name: "wrapper", v: wrapper.vertices }
   ];
   for (const { name, v } of rects) {
-    const area = signedArea(v);
+    const area = signedArea2(v);
     assert3(area > 0, `caseLayoutWinding: ${name} has CW winding (signed area=${area.toFixed(2)})`);
   }
 }
@@ -4112,6 +4116,11 @@ var API_EXACT_PART_PATHS = [
   "examples/api/drive-wheel-regions.forge.js"
 ];
 var API_FACETED_PARTS = [
+  {
+    path: "examples/api/route3d-elbow.forge.js",
+    blocker: "The Route3D elbow still uses segmented circle profiles and segmented cylinders in its swept tube and flange cuts, so exact CadQuery/OCCT export remains blocked while runtime backends validate the route primitive.",
+    note: "Route3D itself preserves line/arc route intent; this contract fences the surrounding faceted profile and flange geometry."
+  },
   {
     path: "examples/api/profile-2020-b-slot6.forge.js",
     blocker: "The direct 3D profile helper still lowers through segmented profile geometry, so the extrusion must stay on the faceted route for now.",
@@ -5029,8 +5038,8 @@ function applyNonPartExpectations(entryPath, result, expectations) {
   assertMinimum(entryPath, uniqueGroups, expectations.minUniqueGroups, "named group(s)");
   assertMinimum(entryPath, result.bom.length, expectations.minBomEntries, "BOM entrie(s)");
   assertMinimum(entryPath, result.cutPlanes.length, expectations.minCutPlanes, "cut plane(s)");
-  assertMinimum(entryPath, jointCount, expectations.minJoints, "jointsView joint(s)");
-  assertMinimum(entryPath, animationCount, expectations.minAnimations, "jointsView animation(s)");
+  assertMinimum(entryPath, jointCount, expectations.minJoints, "joint control(s)");
+  assertMinimum(entryPath, animationCount, expectations.minAnimations, "joint animation(s)");
   if (expectations.requireRobotExport || expectations.minRobotParts != null || expectations.minRobotJoints != null) {
     assert4(result.robotExport, `${entryPath}: expected robotExport(...) data to stay available to the example gate`);
     if (!result.robotExport) return;
@@ -5510,9 +5519,10 @@ function replaceCliInputExtension(path3, newExt) {
 }
 function buildDirectCadImportScript(fileName, kind) {
   const importFn = kind === "step" ? "importStep" : "importMesh";
+  const importOptions = kind === "mesh" && extname(fileName).toLowerCase() === ".3mf" ? ", { separateObjects: true }" : "";
   const objectName = basename3(fileName);
   return [
-    `const imported = ${importFn}(${JSON.stringify(fileName)});`,
+    `const imported = ${importFn}(${JSON.stringify(fileName)}${importOptions});`,
     `return [{ name: ${JSON.stringify(objectName)}, shape: imported }];`
   ].join("\n");
 }
@@ -7042,8 +7052,9 @@ var CHROME_PATHS = [
   "/Applications/Chromium.app/Contents/MacOS/Chromium",
   "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
 ];
-var DEFAULT_PORT = parseInt(process.env.FORGE_PORT || "5173", 10);
+var DEFAULT_PORT = process.env.FORGE_PORT ? parseInt(process.env.FORGE_PORT, 10) : null;
 var DEFAULT_SIZE = parseInt(process.env.FORGE_SIZE || "1024", 10);
+var RENDERER_PORT_HELP = "Renderer port (default: private ephemeral; FORGE_PORT sets a reusable port)";
 var INSPECT_VIEWS = ["front", "right", "top", "iso"];
 var INSPECT_EVIDENCE_DEFINITIONS = [
   {
@@ -7070,6 +7081,12 @@ var INSPECT_EVIDENCE_DEFINITIONS = [
     summary: "Capture surface normal evidence.",
     description: "Writes view-space normal maps for spotting orientation changes, faceting, and surface direction problems."
   },
+  {
+    name: "rig",
+    channel: "rig",
+    summary: "Capture kinematic rig skeleton evidence.",
+    description: "Writes bright joint, axis, ring, and link overlays with source geometry reduced to a translucent shadow."
+  },
   {
     name: "zebra",
     channel: "zebra",
@@ -7138,7 +7155,8 @@ var INSPECT_EVIDENCE_BY_NAME = new Map(
   INSPECT_EVIDENCE_DEFINITIONS.flatMap((entry) => [[entry.name, entry], ...(entry.aliases ?? []).map((alias) => [alias, entry])])
 );
 var INSPECT_EVIDENCE_BY_CHANNEL = new Map(INSPECT_EVIDENCE_DEFINITIONS.map((entry) => [entry.channel, entry]));
-var RENDER_STYLE_NAMES = ["classic", "studio", "fast", "glass", "inspection", "precision", "hybrid", "scan"];
+var RENDER_STYLE_NAMES = ["classic", "studio", "fast", "glass", "inspection", "contour", "scan"];
+var LEGACY_RENDER_STYLE_ALIASES = /* @__PURE__ */ new Map([["precision", "contour"]]);
 var RENDER_STYLES = new Set(RENDER_STYLE_NAMES);
 var RENDER_STYLE_LABEL = RENDER_STYLE_NAMES.join("|");
 var SCAN_GRANULARITY_MIN = 12;
@@ -7180,14 +7198,14 @@ Options:
   --render-mode <solid|wireframe> Render as shaded solid (default) or wireframe only
   --edges <off|thin|bold>         Edge overlay preset for solid mode (default: off)
   --backend <manifold|occt|truck> Geometry backend (auto-selects OCCT for direct STEP inputs)
-  --port <n>                      Vite dev server port (default: ${DEFAULT_PORT})
-  --fresh-server                  Start a fresh renderer instead of reusing an existing one
+  --port <n>                      ${RENDERER_PORT_HELP}
+  --fresh-server                  Start an isolated renderer instead of reusing the requested port
   --chrome-path <path>            Chrome executable path
   -h, --help                      Show this help
 
 Environment variables:
   FORGE_SIZE=1024
-  FORGE_PORT=5173
+  FORGE_PORT=<n>
   CHROME_PATH=/path/to/chrome
 
 Examples:
@@ -7213,6 +7231,7 @@ function splitCsv(value) {
 }
 function parseRenderStyle(value) {
   if (RENDER_STYLES.has(value)) return value;
+  if (LEGACY_RENDER_STYLE_ALIASES.has(value)) return LEGACY_RENDER_STYLE_ALIASES.get(value);
   throw new Error(`--render-style must be one of ${RENDER_STYLE_NAMES.map((entry) => `'${entry}'`).join(", ")} (got '${value}')`);
 }
 function parseEdgesPreset(value) {
@@ -7332,8 +7351,8 @@ function inspectSectionModeUsage(mode) {
   --quality <default|live|high>   Mesh/render quality (default: default)
   --backend <manifold|occt|truck> Geometry backend (auto-selects OCCT for direct STEP inputs)
   --force                         Replace the requested output directory instead of allocating a sibling
-  --port <n>                      Vite dev server port (default: ${DEFAULT_PORT})
-  --fresh-server                  Start a fresh renderer instead of reusing an existing one
+  --port <n>                      ${RENDERER_PORT_HELP}
+  --fresh-server                  Start an isolated renderer instead of reusing the requested port
   --chrome-path <path>            Chrome executable path
   -h, --help                      Show this help`;
   const output = `Output:
@@ -7452,6 +7471,7 @@ function parseRenderCliOptions(argv) {
   const cameras = [];
   let size = DEFAULT_SIZE;
   let port = DEFAULT_PORT;
+  let portRequested = DEFAULT_PORT != null;
   let chromePath = process.env.CHROME_PATH;
   let cameraSpec;
   let viewName;
@@ -7525,6 +7545,7 @@ function parseRenderCliOptions(argv) {
     }
     if (arg === "--port") {
       port = parseInt(readValue2(argv, i, arg), 10);
+      portRequested = true;
       i += 1;
       continue;
     }
@@ -7598,7 +7619,7 @@ function parseRenderCliOptions(argv) {
   if (!Number.isFinite(size) || size < 128 || size > 4096) {
     throw new Error(`--size must be between 128 and 4096 (got ${size})`);
   }
-  if (!Number.isFinite(port) || port < 1 || port > 65535) {
+  if (port != null && (!Number.isFinite(port) || port < 1 || port > 65535)) {
     throw new Error(`--port must be between 1 and 65535 (got ${port})`);
   }
   if (cameraSpec && cameras.length > 0) {
@@ -7628,6 +7649,7 @@ function parseRenderCliOptions(argv) {
     cameras,
     size,
     port,
+    portRequested,
     chromePath: resolveChromePath(chromePath),
     cameraSpec,
     viewName,
@@ -7677,8 +7699,8 @@ Common options:
   --edges <off|thin|bold>         Edge overlay preset for solid visual evidence (default: thin)
   --backend <manifold|occt|truck> Geometry backend (auto-selects OCCT for direct STEP inputs)
   --force                         Replace the requested output directory instead of allocating a sibling
-  --port <n>                      Vite dev server port (default: ${DEFAULT_PORT})
-  --fresh-server                  Start a fresh renderer instead of reusing an existing one
+  --port <n>                      ${RENDERER_PORT_HELP}
+  --fresh-server                  Start an isolated renderer instead of reusing the requested port
   --chrome-path <path>            Chrome executable path
   -h, --help                      Show this help
 
@@ -7692,6 +7714,7 @@ Examples:
     cutaway: "visual cutaway",
     depth: "visual depth",
     normals: "visual normals",
+    rig: "visual rig",
     zebra: "surface zebra",
     roughness: "surface roughness",
     objects: "visual objects",
@@ -7734,8 +7757,8 @@ Options:
   --edges <off|thin|bold>         Edge overlay preset for solid visual evidence (default: thin)
   --backend <manifold|occt|truck> Geometry backend (auto-selects OCCT for direct STEP inputs)
   --force                         Replace the requested output directory instead of allocating a sibling
-  --port <n>                      Vite dev server port (default: ${DEFAULT_PORT})
-  --fresh-server                  Start a fresh renderer instead of reusing an existing one
+  --port <n>                      ${RENDERER_PORT_HELP}
+  --fresh-server                  Start an isolated renderer instead of reusing the requested port
   --chrome-path <path>            Chrome executable path
   -h, --help                      Show this help
 
@@ -7776,6 +7799,7 @@ function parseInspectCli(argv, config = {}) {
   const cameras = [];
   let size = DEFAULT_SIZE;
   let port = DEFAULT_PORT;
+  let portRequested = DEFAULT_PORT != null;
   let chromePath = process.env.CHROME_PATH;
   let quality = "default";
   let backend;
@@ -8042,6 +8066,7 @@ function parseInspectCli(argv, config = {}) {
     }
     if (arg === "--port") {
       port = parseInt(readValue2(argv, i, arg), 10);
+      portRequested = true;
       i += 1;
       continue;
     }
@@ -8077,7 +8102,7 @@ function parseInspectCli(argv, config = {}) {
   if (!Number.isFinite(size) || size < 128 || size > 4096) {
     throw new Error(`--size must be between 128 and 4096 (got ${size})`);
   }
-  if (!Number.isFinite(port) || port < 1 || port > 65535) {
+  if (port != null && (!Number.isFinite(port) || port < 1 || port > 65535)) {
     throw new Error(`--port must be between 1 and 65535 (got ${port})`);
   }
   if (cameraSpec && cameras.length > 0) {
@@ -8159,6 +8184,7 @@ function parseInspectCli(argv, config = {}) {
     edges,
     size,
     port,
+    portRequested,
     chromePath: resolveChromePath(chromePath),
     quality,
     backend,
@@ -8436,6 +8462,7 @@ function collectInspectViewNames(emittedPaths) {
   add2(emittedPaths.cutaway);
   add2(emittedPaths.depth);
   add2(emittedPaths.normals);
+  add2(emittedPaths.rig);
   add2(emittedPaths.zebra);
   add2(emittedPaths.roughness);
   add2(emittedPaths.mask);
@@ -8576,6 +8603,23 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
       views: buildViewPathEntries(emittedPaths.zebra)
     };
   }
+  if (emittedPaths.rig) {
+    evidence.rig = {
+      format: "png",
+      encoding: "rgba-over-dark-shadow-rig-skeleton",
+      coordinateSpace: "world",
+      decode: "source geometry is rendered as a translucent shadow; bright cylinders show hierarchy and part links; oriented rings and axes show joint pivots and motion directions",
+      method: result.rig?.method ?? "rig-skeleton-shadow-v1",
+      objectCount: result.rig?.objectCount ?? 0,
+      jointCount: result.rig?.jointCount ?? 0,
+      linkCount: result.rig?.linkCount ?? 0,
+      hiddenJointCount: result.rig?.hiddenJointCount ?? 0,
+      palette: result.rig?.palette,
+      joints: result.rig?.joints ?? [],
+      links: result.rig?.links ?? [],
+      views: buildViewPathEntries(emittedPaths.rig)
+    };
+  }
   if (emittedPaths.roughness) {
     evidence.roughness = {
       format: "png",
@@ -8854,23 +8898,6 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
     evidence
   };
 }
-async function isPortFree(port) {
-  return new Promise((resolve40) => {
-    const server = createNetServer();
-    server.once("error", () => resolve40(false));
-    server.once("listening", () => {
-      server.close();
-      resolve40(true);
-    });
-    server.listen(port, "127.0.0.1");
-  });
-}
-async function findFreePort(startPort) {
-  for (let port = startPort; port <= 65535; port += 1) {
-    if (await isPortFree(port)) return port;
-  }
-  return null;
-}
 var viteProcess = null;
 var staticServer = null;
 var STATIC_MIME = {
@@ -8887,6 +8914,29 @@ var STATIC_MIME = {
 };
 var PUPPETEER_PROTOCOL_TIMEOUT_MS = 10 * 60 * 1e3;
 var RENDER_READY_TIMEOUT_MS = 30 * 1e3;
+var VITE_STARTUP_TIMEOUT_MS = 30 * 1e3;
+var PRIVATE_RENDER_SERVER_ATTEMPTS = 5;
+var STARTUP_OUTPUT_LIMIT = 4e3;
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+async function reserveEphemeralPort() {
+  return new Promise((resolvePort, reject) => {
+    const server = createNetServer();
+    server.once("error", reject);
+    server.once("listening", () => {
+      const address = server.address();
+      server.close(() => {
+        if (address && typeof address === "object") {
+          resolvePort(address.port);
+        } else {
+          reject(new Error("Failed to reserve a private renderer port."));
+        }
+      });
+    });
+    server.listen(0, "127.0.0.1");
+  });
+}
 async function fetchRenderHtml(port) {
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), 1200);
@@ -8901,6 +8951,18 @@ async function fetchRenderHtml(port) {
     clearTimeout(timer);
   }
 }
+async function waitForRenderHtml(port, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await fetchRenderHtml(port)) return true;
+    await sleep(250);
+  }
+  return false;
+}
+function isAddressInUse(value) {
+  const message = value instanceof Error ? `${value.message} ${value.code ?? ""}` : String(value ?? "");
+  return /EADDRINUSE|address already in use|port \d+ is already in use/i.test(message);
+}
 function serveStaticFile(distDir, req, res) {
   const root = resolve8(distDir);
   const requestUrl = new URL(req.url || "/", "http://localhost");
@@ -8930,58 +8992,147 @@ async function startStaticRenderServer(port) {
   const server = createHttpServer((req, res) => serveStaticFile(distDir, req, res));
   await new Promise((resolveListen, reject) => {
     server.once("error", reject);
-    server.listen(port, "127.0.0.1", resolveListen);
+    server.listen(port ?? 0, "127.0.0.1", resolveListen);
   });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new Error("Packaged render server started without a TCP port.");
+  }
   staticServer = server;
+  return address.port;
 }
-async function ensureDevServer(port, { fresh = false } = {}) {
-  let activePort = port;
-  if (!fresh && await fetchRenderHtml(activePort)) {
-    console.log(`Reusing existing ForgeCAD render server on :${activePort}.`);
-    return activePort;
+async function startViteRenderServer(port, { allowReuseAfterConflict = false } = {}) {
+  const packageRoot = packageRootFrom(import.meta.url);
+  const proc = spawnPackageVite(import.meta.url, ["--host", "127.0.0.1", "--port", String(port), "--strictPort"], {
+    cwd: packageRoot,
+    stdio: "pipe",
+    detached: false
+  });
+  let startupOutput = "";
+  let exitedEarly = false;
+  let exitCode = null;
+  let exitSignal = null;
+  let spawnError = null;
+  const captureOutput = (chunk) => {
+    startupOutput += String(chunk);
+    if (startupOutput.length > STARTUP_OUTPUT_LIMIT) {
+      startupOutput = startupOutput.slice(-STARTUP_OUTPUT_LIMIT);
+    }
+  };
+  proc.stdout?.on("data", captureOutput);
+  proc.stderr?.on("data", captureOutput);
+  proc.once("error", (error) => {
+    spawnError = error;
+    captureOutput(`
+${error.message}`);
+  });
+  proc.once("exit", (code, signal) => {
+    exitedEarly = true;
+    exitCode = code;
+    exitSignal = signal;
+  });
+  const deadline = Date.now() + VITE_STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await fetchRenderHtml(port)) {
+      return { ok: true, proc, startupOutput };
+    }
+    if (spawnError || exitedEarly) {
+      if (allowReuseAfterConflict && isAddressInUse(startupOutput) && await waitForRenderHtml(port, 5e3)) {
+        return { ok: true, proc: null, startupOutput, reusedAfterConflict: true };
+      }
+      return { ok: false, proc: null, startupOutput, spawnError, exitedEarly: true, exitCode, exitSignal };
+    }
+    await sleep(250);
+  }
+  proc.kill();
+  return { ok: false, proc: null, startupOutput, timedOut: true };
+}
+function viteStartupError(port, result) {
+  const detail = result.startupOutput.trim();
+  const suffix = detail ? `
+${detail}` : "";
+  if (result.spawnError) {
+    return new Error(`Failed to start Vite render server on :${port}: ${result.spawnError.message}${suffix}`);
+  }
+  if (result.timedOut) {
+    return new Error(`Timed out waiting for ForgeCAD render server on :${port}.${suffix}`);
+  }
+  if (result.exitedEarly) {
+    const code = result.exitCode != null ? `code ${result.exitCode}` : result.exitSignal ? `signal ${result.exitSignal}` : "unknown exit";
+    return new Error(`Vite render server on :${port} exited before becoming ready (${code}).${suffix}`);
+  }
+  return new Error(`Failed to start ForgeCAD render server on :${port}.${suffix}`);
+}
+async function startPrivateViteRenderServer() {
+  let lastError = null;
+  for (let attempt = 1; attempt <= PRIVATE_RENDER_SERVER_ATTEMPTS; attempt += 1) {
+    const port = await reserveEphemeralPort();
+    console.log(`Starting private ForgeCAD render server on :${port} ...`);
+    const result = await startViteRenderServer(port);
+    if (result.ok) {
+      viteProcess = result.proc;
+      return port;
+    }
+    const error = viteStartupError(port, result);
+    if (isAddressInUse(error)) {
+      lastError = error;
+      continue;
+    }
+    throw error;
+  }
+  throw lastError ?? new Error("Failed to start a private ForgeCAD render server.");
+}
+async function startConfiguredViteRenderServer(port, { fresh = false, allowReuse = false } = {}) {
+  if (allowReuse && !fresh && await fetchRenderHtml(port)) {
+    console.log(`Reusing existing ForgeCAD render server on :${port}.`);
+    return port;
   }
-  const portFree = await isPortFree(activePort);
-  if (!portFree) {
-    if (!fresh) {
-      throw new Error(`Port ${activePort} is already in use, but it is not serving the ForgeCAD renderer.`);
+  console.log(`${fresh ? "Starting fresh" : "Starting"} ForgeCAD render server on :${port} ...`);
+  const result = await startViteRenderServer(port, { allowReuseAfterConflict: allowReuse && !fresh });
+  if (result.ok) {
+    if (result.reusedAfterConflict) {
+      console.log(`Reusing ForgeCAD render server that became ready on :${port}.`);
     }
-    const fallbackPort = await findFreePort(activePort + 1);
-    if (fallbackPort == null) {
-      throw new Error(`Port ${activePort} is occupied and no free fallback port was found.`);
+    viteProcess = result.proc;
+    return port;
+  }
+  if (fresh && isAddressInUse(result.startupOutput)) {
+    console.log(`Port ${port} is occupied; starting a private ForgeCAD render server instead.`);
+    return startPrivateViteRenderServer();
+  }
+  throw viteStartupError(port, result);
+}
+async function startPackagedRenderServer(port, { fresh = false, allowReuse = false } = {}) {
+  if (port != null && allowReuse && !fresh && await fetchRenderHtml(port)) {
+    console.log(`Reusing existing ForgeCAD render server on :${port}.`);
+    return port;
+  }
+  try {
+    const activePort = await startStaticRenderServer(port);
+    console.log(`Starting packaged ForgeCAD render server on :${activePort}.`);
+    return activePort;
+  } catch (error) {
+    if (port != null && fresh && isAddressInUse(error)) {
+      console.log(`Port ${port} is occupied; starting a private packaged ForgeCAD render server instead.`);
+      const activePort = await startStaticRenderServer(null);
+      console.log(`Starting packaged ForgeCAD render server on :${activePort}.`);
+      return activePort;
     }
-    console.log(`Port ${activePort} is occupied; starting fresh ForgeCAD render server on :${fallbackPort}.`);
-    activePort = fallbackPort;
-  } else if (fresh) {
-    console.log(`Starting fresh ForgeCAD render server on :${activePort}.`);
+    throw error;
   }
+}
+async function ensureDevServer(port, { fresh = false, allowReuse = false } = {}) {
   const packageRoot = packageRootFrom(import.meta.url);
   const sourceRenderHtml = join4(packageRoot, "cli", "render.html");
   const packagedRenderHtml = join4(packageRoot, "dist", "cli", "render.html");
   if (!existsSync3(sourceRenderHtml) && existsSync3(packagedRenderHtml)) {
-    console.log("Starting packaged render server...");
-    await startStaticRenderServer(activePort);
-    return activePort;
+    return startPackagedRenderServer(port, { fresh, allowReuse });
   }
-  console.log("Starting Vite dev server...");
-  viteProcess = spawnPackageVite(import.meta.url, ["--host", "127.0.0.1", "--port", String(activePort), "--strictPort"], {
-    cwd: packageRoot,
-    stdio: "pipe",
-    detached: false
-  });
-  await new Promise((resolve40, reject) => {
-    const timeout = setTimeout(() => reject(new Error("Vite startup timeout")), 15e3);
-    viteProcess.stdout.on("data", (data) => {
-      if (data.toString().includes("ready")) {
-        clearTimeout(timeout);
-        resolve40();
-      }
-    });
-    viteProcess.on("error", (e) => {
-      clearTimeout(timeout);
-      reject(e);
-    });
-  });
-  return activePort;
+  if (port == null) {
+    return startPrivateViteRenderServer();
+  }
+  return startConfiguredViteRenderServer(port, { fresh, allowReuse });
 }
 function stopDevServer() {
   if (viteProcess) {
@@ -9014,7 +9165,10 @@ async function runRenderCli(argv = process.argv.slice(2)) {
     const binaryFiles = collectBrowserBinaryFiles(input);
     const needsBinaryFileReader = Object.keys(binaryFiles).length > 0;
     const activeBackend = resolveCliBackend(options.backend, input) ?? CLI_DEFAULT_BACKEND;
-    const activePort = await ensureDevServer(options.port, { fresh: options.freshServer || needsBinaryFileReader });
+    const activePort = await ensureDevServer(options.port, {
+      fresh: options.freshServer || needsBinaryFileReader,
+      allowReuse: options.portRequested && !needsBinaryFileReader
+    });
     const browser = await puppeteer.launch({
       headless: true,
       protocolTimeout: PUPPETEER_PROTOCOL_TIMEOUT_MS,
@@ -9149,7 +9303,10 @@ async function runInspectBundleCli(argv, config) {
     console.log(`[inspect] Preparing bundle directory: ${resolve8(options.outputDir)}`);
     const bundleDirs = await prepareInspectBundleDir(options.outputDir, options.force, options.channels);
     tempDir = bundleDirs.tempDir;
-    const activePort = await ensureDevServer(options.port, { fresh: options.freshServer || needsBinaryFileReader });
+    const activePort = await ensureDevServer(options.port, {
+      fresh: options.freshServer || needsBinaryFileReader,
+      allowReuse: options.portRequested && !needsBinaryFileReader
+    });
     const browser = await puppeteer.launch({
       headless: true,
       protocolTimeout: PUPPETEER_PROTOCOL_TIMEOUT_MS,
@@ -9316,6 +9473,9 @@ async function runInspectBundleCli(argv, config) {
       if (requested.has("zebra")) {
         await writeViewChannel("zebra", result.zebra);
       }
+      if (requested.has("rig")) {
+        await writeViewChannel("rig", result.rig?.views);
+      }
       if (requested.has("roughness")) {
         await writeViewChannel("roughness", result.roughness?.views);
         emittedPaths.roughnessPointCloud = await writeChannelJson("roughness", "point-cloud.json", result.roughness?.pointCloud, {
@@ -9898,11 +10058,15 @@ function parseTraceQueryFlags(argv) {
     consumed.add(i);
     const raw = argv[i + 1];
     if (!raw || raw.startsWith("-")) {
-      console.error("Missing value for --query. Expected a trace lens such as feature:hole, source:main.forge.js:42, trace:<id>, or cache:hits.");
+      console.error(
+        "Missing value for --query. Expected a trace lens such as feature:hole, source:main.forge.js:42, trace:<id>, or cache:hits."
+      );
       process.exit(1);
     }
     consumed.add(i + 1);
-    queries.push(...raw.split(",").map((query) => query.trim()).filter(Boolean));
+    queries.push(
+      ...raw.split(",").map((query) => query.trim()).filter(Boolean)
+    );
     i += 1;
   }
   return { queries, consumed };
@@ -9918,7 +10082,7 @@ async function runInspectDesignTraceCli(argv = process.argv.slice(2)) {
   argv.forEach((arg, index) => {
     if (arg === "--anchor" || arg === "--full") consumed.add(index);
   });
-  const positional = argv.filter((arg, index) => !consumed.has(index));
+  const positional = argv.filter((_arg, index) => !consumed.has(index));
   const scriptPath = positional[0];
   if (!scriptPath) usage3();
   if (positional.length > 1) {
@@ -9965,7 +10129,8 @@ function cacheNote(node) {
   if (node.liveCacheStatus === "rebuilt") return `cache rebuilt in ${node.liveCacheBuildMs ?? 0}ms`;
   if (node.liveCacheStatus === "miss") return "cache miss";
   if (node.cacheRole === "reuseCandidate") return `structural reuse candidate, saved estimate ${node.cacheOpportunitySavedMs}ms`;
-  if (node.cacheRole === "seed" && node.duplicateGeometryCount > 1) return `repeated geometry seed, ${node.duplicateGeometryCount} equivalent nodes`;
+  if (node.cacheRole === "seed" && node.duplicateGeometryCount > 1)
+    return `repeated geometry seed, ${node.duplicateGeometryCount} equivalent nodes`;
   return void 0;
 }
 function toHistoryStep(trace, node) {
@@ -10002,7 +10167,9 @@ function repeatedGeometryGroups(nodes) {
 function projectDesignHistory(trace, options = {}) {
   const objectQueries = (options.objectQueries ?? []).map(normalize).filter(Boolean);
   const nodeQueries = (options.nodeQueries ?? []).map(normalize).filter(Boolean);
-  const matchingNodeIds = new Set((nodeQueries.length > 0 ? filterDesignTraceNodes(trace, nodeQueries) : trace.nodes).map((node) => node.id));
+  const matchingNodeIds = new Set(
+    (nodeQueries.length > 0 ? filterDesignTraceNodes(trace, nodeQueries) : trace.nodes).map((node) => node.id)
+  );
   const nodesByObjectId = /* @__PURE__ */ new Map();
   for (const node of trace.nodes) {
     const objectNodes = nodesByObjectId.get(node.objectId) ?? [];
@@ -10075,7 +10242,9 @@ function printStep(step, detailed, options) {
     if (summary) console.log(`      uses: ${summary}`);
     return;
   }
-  console.log(`      inputs: ${step.inputRefs.length > 0 ? step.inputRefs.map((ref) => formatStepRef(ref, Boolean(options.printTraceIds))).join("; ") : "none"}`);
+  console.log(
+    `      inputs: ${step.inputRefs.length > 0 ? step.inputRefs.map((ref) => formatStepRef(ref, Boolean(options.printTraceIds))).join("; ") : "none"}`
+  );
   console.log(
     `      used by: ${step.usedByRefs.length > 0 ? step.usedByRefs.map((ref) => formatStepRef(ref, Boolean(options.printTraceIds))).join("; ") : "none"}`
   );
@@ -10131,8 +10300,10 @@ Object recipe: ${pathLabel(object.path, object.name)}`);
   } else if (selectedTraceIds.length === 0) {
     console.log("\nHistory feedback anchor: no matching feature step.");
   } else {
-    console.log(`
-History feedback anchor: ${selectedTraceIds.length} feature steps matched; narrow --query to one feature/source/trace node.`);
+    console.log(
+      `
+History feedback anchor: ${selectedTraceIds.length} feature steps matched; narrow --query to one feature/source/trace node.`
+    );
   }
 }
 
@@ -10155,7 +10326,9 @@ function parseListFlag(argv, flag, missingHelp) {
       process.exit(1);
     }
     consumed.add(i + 1);
-    values.push(...raw.split(",").map((value) => value.trim()).filter(Boolean));
+    values.push(
+      ...raw.split(",").map((value) => value.trim()).filter(Boolean)
+    );
     i += 1;
   }
   return { values, consumed };
@@ -10184,7 +10357,14 @@ async function runInspectHistoryCli(argv = process.argv.slice(2)) {
     "--query",
     "Missing value for --query. Expected feature:hole, source:main.forge.js:42, trace:<id>, cache:hits, or text."
   );
-  const consumed = /* @__PURE__ */ new Set([...paramConsumed, ...backendConsumed, ...qualityConsumed, ...levelConsumed, ...objectConsumed, ...queryConsumed]);
+  const consumed = /* @__PURE__ */ new Set([
+    ...paramConsumed,
+    ...backendConsumed,
+    ...qualityConsumed,
+    ...levelConsumed,
+    ...objectConsumed,
+    ...queryConsumed
+  ]);
   const printAnchor = argv.includes("--anchor");
   const printSource = argv.includes("--source");
   const printTraceIds = argv.includes("--trace-ids");
@@ -10192,7 +10372,7 @@ async function runInspectHistoryCli(argv = process.argv.slice(2)) {
   argv.forEach((arg, index) => {
     if (arg === "--anchor" || arg === "--source" || arg === "--trace-ids" || arg === "--params") consumed.add(index);
   });
-  const positional = argv.filter((arg, index) => !consumed.has(index));
+  const positional = argv.filter((_arg, index) => !consumed.has(index));
   const scriptPath = positional[0];
   if (!scriptPath) usage4();
   if (positional.length > 1) {
@@ -10772,7 +10952,7 @@ function auditAssembly(assembly2, rawOptions = {}) {
         continue;
       }
       try {
-        const frames = assembly2.sweepJoint(joint2.name, joint2.min, joint2.max, options.sweepSteps, options.state, {
+        const frames = assembly2._sweepJointForDiagnostics(joint2.name, joint2.min, joint2.max, options.sweepSteps, options.state, {
           minOverlapVolume: options.minOverlapVolume
         });
         for (const frame of frames) {
@@ -13452,6 +13632,733 @@ async function runInspectReplayCli(argv = process.argv.slice(2)) {
   printSectionSummary(result);
 }
 
+// src/forge/inspection/sketch.ts
+var EPS5 = 1e-9;
+var BOUNDARY_EPS = 1e-7;
+function inspectSketches(objects, options = {}) {
+  const targets = [];
+  const diagnostics = [];
+  for (const object of objects) {
+    if (options.objectIds && !options.objectIds.has(object.id)) continue;
+    const objectPath = object.treePath && object.treePath.length > 0 ? object.treePath.join("/") : object.name;
+    if (object.sketch) {
+      targets.push(
+        inspectSketchTarget(object.sketch, {
+          id: `${object.id}:sketch`,
+          object,
+          objectPath,
+          sourceKind: "returned-sketch",
+          options
+        })
+      );
+    }
+    if (object.shape) {
+      const shapePlan = getShapeCompilePlan(object.shape);
+      const profileUses = collectProfileUses(shapePlan);
+      profileUses.forEach((use, index) => {
+        targets.push(
+          inspectProfileTarget(use.profile, {
+            id: `${object.id}:profile:${index}`,
+            object,
+            objectPath,
+            operation: use.operation,
+            profilePath: use.path,
+            options
+          })
+        );
+      });
+    }
+  }
+  if (targets.length === 0) {
+    diagnostics.push({
+      level: "info",
+      code: "no-sketch-targets",
+      message: "No returned sketches or supported profile-bearing shape operations were found."
+    });
+  }
+  return { targets, diagnostics };
+}
+function inspectSketchTarget(sketch, args) {
+  const diagnostics = [];
+  const regions = extractRegionsForSketch(sketch, diagnostics);
+  const bounds2 = readSketchBounds(sketch, diagnostics);
+  const area = readSketchArea(sketch, diagnostics);
+  addSketchHealthDiagnostics(sketch, regions, diagnostics);
+  const target = {
+    id: args.id,
+    objectId: args.object.id,
+    objectName: args.object.name,
+    objectPath: args.objectPath,
+    sourceKind: args.sourceKind,
+    bounds: bounds2,
+    area,
+    isEmpty: area === null ? regions.length === 0 : Math.abs(area) <= EPS5,
+    regions,
+    diagnostics
+  };
+  if (isConstraintSketch(sketch)) {
+    target.constraintStatus = sketch.constraintMeta.status;
+    target.constraintDof = sketch.constraintMeta.dof;
+    target.constraintMaxError = sketch.constraintMeta.maxError;
+  }
+  if (args.options.seed) {
+    target.selection = selectRegion(regions, args.options.seed, args.options.operation);
+  }
+  return target;
+}
+function inspectProfileTarget(plan, args) {
+  const diagnostics = [];
+  const targetBase = {
+    id: args.id,
+    objectId: args.object.id,
+    objectName: args.object.name,
+    objectPath: args.objectPath,
+    sourceKind: "shape-profile",
+    operation: args.operation,
+    profilePath: args.profilePath,
+    profileTree: summarizeProfilePlan(plan, "$")
+  };
+  try {
+    const sketch = buildSketchFromCompileProfilePlan(plan);
+    const target = inspectSketchTarget(sketch, {
+      id: args.id,
+      object: args.object,
+      objectPath: args.objectPath,
+      sourceKind: "shape-profile",
+      options: args.options
+    });
+    return {
+      ...target,
+      ...targetBase,
+      diagnostics: [...target.diagnostics, ...diagnostics]
+    };
+  } catch (error) {
+    diagnostics.push({
+      level: "error",
+      code: "profile-lowering-failed",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return {
+      ...targetBase,
+      bounds: null,
+      area: null,
+      isEmpty: true,
+      regions: [],
+      diagnostics,
+      ...args.options.seed ? { selection: selectRegion([], args.options.seed, args.options.operation) } : {}
+    };
+  }
+}
+function addSketchHealthDiagnostics(sketch, regions, diagnostics) {
+  if (regions.length === 0) {
+    diagnostics.push({
+      level: "warning",
+      code: "no-regions",
+      message: "No filled sketch regions were detected."
+    });
+  }
+  if (!isConstraintSketch(sketch)) return;
+  const meta = sketch.constraintMeta;
+  if (meta.status === "under") {
+    diagnostics.push({
+      level: "warning",
+      code: "under-constrained",
+      message: `Constraint sketch is under-constrained with ${meta.dof} degree(s) of freedom.`
+    });
+  } else if (meta.status === "over" || meta.status === "over-redundant") {
+    diagnostics.push({
+      level: "warning",
+      code: meta.status === "over" ? "over-constrained" : "over-redundant",
+      message: `Constraint sketch status is ${meta.status}.`
+    });
+  }
+  if (meta.maxError > 1e-6) {
+    diagnostics.push({
+      level: "warning",
+      code: "constraint-residual",
+      message: `Constraint max error is ${meta.maxError}.`
+    });
+  }
+}
+function extractRegionsForSketch(sketch, diagnostics) {
+  if (isConstraintSketch(sketch) && sketch.constraintMeta.surfaces.length > 0) {
+    return sketch.constraintMeta.surfaces.map((surface, index) => ({
+      id: `R${index}`,
+      area: surface.area,
+      bounds: { min: [...surface.bounds.min], max: [...surface.bounds.max] },
+      centroid: [...surface.centroid],
+      seed: [...surface.seed],
+      outer: surface.polygon.map(cloneVec2),
+      holes: [],
+      compatibleOperations: { extrude: surface.area > EPS5 }
+    }));
+  }
+  try {
+    return extractFilledRegions(sketch.toPolygons()).map((region, index) => ({
+      id: `R${index}`,
+      ...region,
+      compatibleOperations: { extrude: region.area > EPS5 }
+    }));
+  } catch (error) {
+    diagnostics.push({
+      level: "error",
+      code: "polygon-extraction-failed",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return [];
+  }
+}
+function extractFilledRegions(rawLoops) {
+  const loops = rawLoops.map((loop) => loop.map(([x, y]) => [x, y])).map(removeDuplicateClose).filter((points) => points.length >= 3).map((points) => {
+    const area = signedArea(points);
+    return { points, area, absArea: Math.abs(area), sample: polygonCentroid(points) };
+  }).filter((loop) => loop.absArea > EPS5);
+  if (loops.length === 0) return [];
+  const outers = loops.filter((loop) => loop.area > 0);
+  const holes = loops.filter((loop) => loop.area < 0);
+  const effectiveOuters = outers.length > 0 ? outers : [loops.slice().sort((a, b) => b.absArea - a.absArea)[0]];
+  const regions = effectiveOuters.map((outer) => ({ outer, holes: [] }));
+  for (const hole of holes) {
+    const containers = regions.filter((region) => pointInPolygon(hole.sample, region.outer.points)).sort((a, b) => a.outer.absArea - b.outer.absArea);
+    if (containers[0]) containers[0].holes.push(hole);
+  }
+  return regions.map((region) => {
+    const holePoints = region.holes.map((hole) => hole.points);
+    const area = Math.max(0, region.outer.absArea - region.holes.reduce((sum2, hole) => sum2 + hole.absArea, 0));
+    return {
+      area,
+      bounds: boundsForLoops([region.outer.points, ...holePoints]),
+      centroid: polygonCentroid(region.outer.points),
+      seed: findRegionSeed(region.outer.points, holePoints),
+      outer: region.outer.points.map(cloneVec2),
+      holes: holePoints.map((hole) => hole.map(cloneVec2))
+    };
+  }).filter((region) => region.area > EPS5).sort((a, b) => b.area - a.area);
+}
+function selectRegion(regions, seed, operation) {
+  for (const region of regions) {
+    if (pointOnLoopBoundary(seed, region.outer) || region.holes.some((hole) => pointOnLoopBoundary(seed, hole))) {
+      return {
+        seed,
+        ok: false,
+        regionId: null,
+        code: "seed-on-boundary",
+        message: `Seed [${seed[0]}, ${seed[1]}] lies on a region boundary.`,
+        operation,
+        operationCompatible: false
+      };
+    }
+  }
+  const outerMatches = regions.filter((region) => pointInPolygon(seed, region.outer));
+  const holeMatches = outerMatches.filter((region) => region.holes.some((hole) => pointInPolygon(seed, hole)));
+  const matches = outerMatches.filter((region) => !region.holes.some((hole) => pointInPolygon(seed, hole)));
+  if (matches.length === 1) {
+    const compatible = operation ? matches[0].compatibleOperations[operation] === true : void 0;
+    return {
+      seed,
+      ok: operation ? compatible === true : true,
+      regionId: matches[0].id,
+      code: operation && !compatible ? "operation-incompatible" : "matched",
+      message: operation && !compatible ? `Region ${matches[0].id} is not compatible with ${operation}.` : `Seed matched region ${matches[0].id}.`,
+      operation,
+      operationCompatible: compatible
+    };
+  }
+  if (matches.length > 1) {
+    return {
+      seed,
+      ok: false,
+      regionId: null,
+      code: "seed-ambiguous",
+      message: `Seed [${seed[0]}, ${seed[1]}] matched ${matches.length} regions.`,
+      operation,
+      operationCompatible: false
+    };
+  }
+  if (holeMatches.length > 0) {
+    return {
+      seed,
+      ok: false,
+      regionId: null,
+      code: "seed-inside-hole",
+      message: `Seed [${seed[0]}, ${seed[1]}] is inside a region hole.`,
+      operation,
+      operationCompatible: false
+    };
+  }
+  return {
+    seed,
+    ok: false,
+    regionId: null,
+    code: regions.length === 0 ? "no-regions" : "seed-outside-regions",
+    message: regions.length === 0 ? "No regions are available for seed selection." : `Seed [${seed[0]}, ${seed[1]}] is outside all detected regions.`,
+    operation,
+    operationCompatible: false
+  };
+}
+function collectProfileUses(plan, path3 = "$") {
+  switch (plan.kind) {
+    case "extrude":
+      return [{ operation: "extrude", profile: plan.profile, path: `${path3}.profile` }];
+    case "cut":
+      return [...collectProfileUses(plan.base, `${path3}.base`), { operation: "cut", profile: plan.profile, path: `${path3}.profile` }];
+    case "revolve":
+      return [{ operation: "revolve", profile: plan.profile, path: `${path3}.profile` }];
+    case "queryOwner":
+      return collectProfileUses(plan.base, `${path3}.base`);
+    case "transform":
+      return collectProfileUses(plan.base, `${path3}.base`);
+    case "boolean":
+      return plan.shapes.flatMap((shape, index) => collectProfileUses(shape, `${path3}.shapes[${index}]`));
+    case "shell":
+    case "hole":
+    case "trimByPlane":
+    case "fillet":
+    case "chamfer":
+    case "filletEdges":
+    case "cornerYBlend":
+    case "surfaceExtend":
+    case "surfaceThicken":
+    case "surfaceSolid":
+      return collectProfileUses(plan.base, `${path3}.base`);
+    case "surfaceSew":
+      return plan.shapes.flatMap((shape, index) => collectProfileUses(shape, `${path3}.shapes[${index}]`));
+    default:
+      return [];
+  }
+}
+function summarizeProfilePlan(plan, path3) {
+  switch (plan.kind) {
+    case "boolean":
+      return {
+        path: path3,
+        kind: plan.kind,
+        op: plan.op,
+        children: plan.profiles.map((profile, index) => summarizeProfilePlan(profile, `${path3}.profiles[${index}]`))
+      };
+    case "offset":
+      return { path: path3, kind: plan.kind, children: [summarizeProfilePlan(plan.base, `${path3}.base`)] };
+    case "project":
+      return {
+        path: path3,
+        kind: plan.kind,
+        children: plan.replayProfile ? [summarizeProfilePlan(plan.replayProfile, `${path3}.replayProfile`)] : []
+      };
+    default:
+      return { path: path3, kind: plan.kind, children: [] };
+  }
+}
+function readSketchBounds(sketch, diagnostics) {
+  try {
+    const bounds2 = sketch.bounds();
+    return { min: [bounds2.min[0], bounds2.min[1]], max: [bounds2.max[0], bounds2.max[1]] };
+  } catch (error) {
+    diagnostics.push({
+      level: "error",
+      code: "bounds-failed",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function readSketchArea(sketch, diagnostics) {
+  try {
+    return sketch.area();
+  } catch (error) {
+    diagnostics.push({
+      level: "error",
+      code: "area-failed",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function findRegionSeed(outer, holes) {
+  const candidates = [polygonCentroid(outer)];
+  for (let i = 0; i < outer.length; i += 1) {
+    const a = outer[i];
+    const b = outer[(i + 1) % outer.length];
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const length3 = Math.hypot(dx, dy);
+    if (length3 <= EPS5) continue;
+    const nudge = Math.min(1, length3 * 0.01);
+    candidates.push([(a[0] + b[0]) / 2 - dy / length3 * nudge, (a[1] + b[1]) / 2 + dx / length3 * nudge]);
+  }
+  return candidates.find((candidate) => pointInFilledRegion(candidate, outer, holes)) ?? candidates[0] ?? [0, 0];
+}
+function pointInFilledRegion(point, outer, holes) {
+  return pointInPolygon(point, outer) && !holes.some((hole) => pointInPolygon(point, hole));
+}
+function boundsForLoops(loops) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const loop of loops) {
+    for (const [x, y] of loop) {
+      if (x < minX) minX = x;
+      if (y < minY) minY = y;
+      if (x > maxX) maxX = x;
+      if (y > maxY) maxY = y;
+    }
+  }
+  return { min: [minX, minY], max: [maxX, maxY] };
+}
+function removeDuplicateClose(points) {
+  if (points.length <= 1) return points;
+  return Math.hypot(points[0][0] - points[points.length - 1][0], points[0][1] - points[points.length - 1][1]) <= BOUNDARY_EPS ? points.slice(0, -1) : points;
+}
+function signedArea(points) {
+  let area = 0;
+  for (let i = 0; i < points.length; i += 1) {
+    const [x1, y1] = points[i];
+    const [x2, y2] = points[(i + 1) % points.length];
+    area += x1 * y2 - x2 * y1;
+  }
+  return area * 0.5;
+}
+function polygonCentroid(points) {
+  let cx = 0;
+  let cy = 0;
+  let a2 = 0;
+  for (let i = 0; i < points.length; i += 1) {
+    const [x1, y1] = points[i];
+    const [x2, y2] = points[(i + 1) % points.length];
+    const cross6 = x1 * y2 - x2 * y1;
+    a2 += cross6;
+    cx += (x1 + x2) * cross6;
+    cy += (y1 + y2) * cross6;
+  }
+  if (Math.abs(a2) < EPS5) {
+    return points.length > 0 ? [points.reduce((sum2, p) => sum2 + p[0], 0) / points.length, points.reduce((sum2, p) => sum2 + p[1], 0) / points.length] : [0, 0];
+  }
+  const f2 = 1 / (3 * a2);
+  return [cx * f2, cy * f2];
+}
+function pointInPolygon(point, polygon) {
+  const [px, py] = point;
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const [xi, yi] = polygon[i];
+    const [xj, yj] = polygon[j];
+    if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi || 1e-20) + xi) inside = !inside;
+  }
+  return inside;
+}
+function pointOnLoopBoundary(point, loop) {
+  for (let i = 0; i < loop.length; i += 1) {
+    if (distToSegment(point, loop[i], loop[(i + 1) % loop.length]) <= BOUNDARY_EPS) return true;
+  }
+  return false;
+}
+function distToSegment(point, a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const len2 = dx * dx + dy * dy;
+  if (len2 <= EPS5) return Math.hypot(point[0] - a[0], point[1] - a[1]);
+  const t = Math.max(0, Math.min(1, ((point[0] - a[0]) * dx + (point[1] - a[1]) * dy) / len2));
+  return Math.hypot(point[0] - (a[0] + t * dx), point[1] - (a[1] + t * dy));
+}
+function cloneVec2(point) {
+  return [point[0], point[1]];
+}
+
+// src/forge/targets.ts
+var cleanSceneTargetPathSegments = (segments) => (segments ?? []).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+function getSceneObjectTreePath(object) {
+  const explicitTreePath = cleanSceneTargetPathSegments(object.treePath);
+  if (explicitTreePath.length > 0) return explicitTreePath;
+  const name = object.name.trim() || object.id;
+  const groupName = object.groupName?.trim();
+  if (!groupName) return [name];
+  const groupPath = groupName.split(".").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+  const prefixedLeaf = `${groupName}.`;
+  if (name.startsWith(prefixedLeaf)) {
+    const leafName = name.slice(prefixedLeaf.length).trim();
+    return [...groupPath, leafName || name];
+  }
+  return [...groupPath, name];
+}
+function getSceneObjectKind(object) {
+  if (object.mock) return "mock";
+  if (object.sketch) return "sketch";
+  if (object.toolpath) return "toolpath";
+  if (object.sdf) return "sdf";
+  if (object.shape) return "shape";
+  return "object";
+}
+function buildSceneTargetEntries(objects) {
+  return objects.map((object) => {
+    const pathSegments = getSceneObjectTreePath(object);
+    return {
+      id: object.id,
+      name: object.name,
+      kind: getSceneObjectKind(object),
+      pathSegments,
+      path: pathSegments.join("/"),
+      dottedPath: pathSegments.join("."),
+      group: object.groupName?.trim() || void 0,
+      tags: object.tags ?? [],
+      mock: object.mock === true,
+      object
+    };
+  });
+}
+function formatSceneTargetPath(entry) {
+  return entry.path || entry.name;
+}
+function resolveSceneTargets(entries, selector) {
+  const needle = normalizeTargetText(selector);
+  if (!needle) throw new Error("Target selector must not be empty.");
+  const hasGlob = /[*?]/.test(selector);
+  if (hasGlob) {
+    const pattern = globToRegExp(needle);
+    const matches = entries.filter((entry) => targetCandidateTexts(entry).some((candidate) => pattern.test(candidate)));
+    if (matches.length > 0) return matches;
+    throw targetNotFound(selector, entries);
+  }
+  const idMatches = entries.filter((entry) => normalizeTargetText(entry.id) === needle);
+  if (idMatches.length > 0) return idMatches;
+  const exactPathMatches = entries.filter(
+    (entry) => normalizeTargetText(entry.path) === needle || normalizeTargetText(entry.dottedPath) === needle
+  );
+  if (exactPathMatches.length > 0) return exactPathMatches;
+  const groupMatches = entries.filter((entry) => {
+    const groupPath = entry.pathSegments.slice(0, -1);
+    return normalizeTargetText(groupPath.join("/")) === needle || normalizeTargetText(groupPath.join(".")) === needle;
+  });
+  if (groupMatches.length > 0) return groupMatches;
+  const nameMatches2 = entries.filter(
+    (entry) => normalizeTargetText(entry.name) === needle || normalizeTargetText(entry.pathSegments[entry.pathSegments.length - 1] ?? "") === needle
+  );
+  if (nameMatches2.length === 1) return nameMatches2;
+  if (nameMatches2.length > 1) throw ambiguousTarget(selector, nameMatches2);
+  throw targetNotFound(selector, entries);
+}
+function suggestSceneTargets(selector, entries, limit = 8) {
+  const needle = normalizeTargetText(selector);
+  if (!needle) return entries.slice(0, limit);
+  return entries.map((entry) => ({ entry, score: scoreTarget(entry, needle) })).filter((ranked) => ranked.score > 0).sort((a, b) => b.score - a.score || a.entry.path.localeCompare(b.entry.path)).slice(0, limit).map((ranked) => ranked.entry);
+}
+function targetCandidateTexts(entry) {
+  return [
+    entry.id,
+    entry.name,
+    entry.path,
+    entry.dottedPath,
+    entry.group ?? "",
+    entry.pathSegments[entry.pathSegments.length - 1] ?? ""
+  ].map(normalizeTargetText);
+}
+function normalizeTargetText(value) {
+  return value.trim().replace(/\\/g, "/").replace(/\s*\/\s*/g, "/").replace(/\s*\.\s*/g, ".").toLowerCase();
+}
+function globToRegExp(value) {
+  const escaped = value.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function scoreTarget(entry, needle) {
+  const candidates = targetCandidateTexts(entry);
+  if (candidates.some((candidate) => candidate === needle)) return 100;
+  if (candidates.some((candidate) => candidate.startsWith(needle))) return 60;
+  if (candidates.some((candidate) => candidate.includes(needle))) return 30;
+  const tokens = needle.split(/[\s/._-]+/).filter(Boolean);
+  if (tokens.length > 0 && tokens.every((token) => candidates.some((candidate) => candidate.includes(token)))) return 15;
+  return 0;
+}
+function targetSummary(entry) {
+  return `${formatSceneTargetPath(entry)} (${entry.kind}, ${entry.id})`;
+}
+function targetNotFound(selector, entries) {
+  const suggestions = suggestSceneTargets(selector, entries);
+  const detail = suggestions.length > 0 ? `
+Did you mean:
+${suggestions.map((entry) => `  ${targetSummary(entry)}`).join("\n")}` : "";
+  return new Error(`Target "${selector}" matched no scene objects.${detail}`);
+}
+function ambiguousTarget(selector, matches) {
+  return new Error(
+    `Target "${selector}" is ambiguous.
+Use a full path:
+${matches.map((entry) => `  ${targetSummary(entry)}`).join("\n")}`
+  );
+}
+
+// cli/inspect-sketch.ts
+function usage7() {
+  return [
+    "Usage: forgecad inspect sketch <model.forge.js> [--json] [--object <name-or-path>] [--seed <x,y>] [--operation extrude] [--param Key=Value] [--backend manifold|occt|truck] [--quality live|default|high]"
+  ].join("\n");
+}
+function parseSeed(raw) {
+  const parts = raw.split(",").map((part) => Number(part.trim()));
+  if (parts.length !== 2 || !Number.isFinite(parts[0]) || !Number.isFinite(parts[1])) {
+    throw new Error(`--seed must be two finite numbers as x,y (got "${raw}")`);
+  }
+  return [parts[0], parts[1]];
+}
+function parseOperation(raw) {
+  if (raw === "extrude") return raw;
+  throw new Error(`--operation must be extrude (got "${raw}")`);
+}
+function readFlagValue(argv, index, flag) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value.`);
+  return value;
+}
+function parseOptions(argv) {
+  if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
+    console.log(usage7());
+    process.exit(0);
+  }
+  const { consumed: paramConsumed } = parseParamFlags(argv);
+  const { backend, consumed: backendConsumed } = parseBackendArg(argv);
+  const { quality, consumed: qualityConsumed } = parseQualityArg(argv);
+  const consumed = /* @__PURE__ */ new Set([...paramConsumed, ...backendConsumed, ...qualityConsumed]);
+  let json = false;
+  let compact = false;
+  let objectSelector;
+  let seed;
+  let operation;
+  for (let i = 0; i < argv.length; i += 1) {
+    if (consumed.has(i)) continue;
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+      consumed.add(i);
+    } else if (arg === "--compact") {
+      compact = true;
+      consumed.add(i);
+    } else if (arg === "--object") {
+      objectSelector = readFlagValue(argv, i, arg);
+      consumed.add(i);
+      consumed.add(i + 1);
+      i += 1;
+    } else if (arg === "--seed") {
+      seed = parseSeed(readFlagValue(argv, i, arg));
+      consumed.add(i);
+      consumed.add(i + 1);
+      i += 1;
+    } else if (arg === "--operation") {
+      operation = parseOperation(readFlagValue(argv, i, arg));
+      consumed.add(i);
+      consumed.add(i + 1);
+      i += 1;
+    } else if (arg.startsWith("--")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  const positionals = argv.filter((_, index) => !consumed.has(index));
+  if (!positionals[0]) throw new Error("Missing input path.");
+  if (positionals.length > 1) throw new Error(`Unexpected argument: ${positionals[1]}`);
+  return { scriptPath: positionals[0], json, compact, objectSelector, seed, operation, backend, quality };
+}
+function formatNumber(value, digits = 3) {
+  if (value == null || !Number.isFinite(value)) return String(value);
+  return value.toFixed(digits).replace(/\.?0+$/, "");
+}
+function formatPoint(point) {
+  return `(${formatNumber(point[0])}, ${formatNumber(point[1])})`;
+}
+function formatBounds(target) {
+  if (!target.bounds) return "unknown";
+  return `${formatPoint(target.bounds.min)}..${formatPoint(target.bounds.max)}`;
+}
+function printHuman2(result, scriptPath) {
+  console.log(`Sketch inspection for ${scriptPath}`);
+  console.log(`${result.targets.length} target(s)`);
+  for (const diagnostic of result.diagnostics) {
+    console.log(`${diagnostic.level}: ${diagnostic.code}: ${diagnostic.message}`);
+  }
+  for (const target of result.targets) {
+    const source = target.sourceKind === "shape-profile" ? `${target.sourceKind}:${target.operation} ${target.profilePath}` : target.sourceKind;
+    console.log("");
+    console.log(`${target.id}  ${target.objectPath}  ${source}`);
+    console.log(
+      `  area=${formatNumber(target.area)} bounds=${formatBounds(target)} empty=${target.isEmpty} regions=${target.regions.length}`
+    );
+    if (target.constraintStatus) {
+      console.log(
+        `  constraints=${target.constraintStatus} dof=${target.constraintDof ?? "?"} maxError=${formatNumber(target.constraintMaxError, 6)}`
+      );
+    }
+    for (const region of target.regions) {
+      console.log(
+        `  ${region.id} area=${formatNumber(region.area)} seed=${formatPoint(region.seed)} bounds=${formatPoint(region.bounds.min)}..${formatPoint(region.bounds.max)} holes=${region.holes.length}`
+      );
+    }
+    if (target.selection) {
+      const status = target.selection.ok ? "ok" : "failed";
+      const region = target.selection.regionId ? ` ${target.selection.regionId}` : "";
+      const op = target.selection.operation && target.selection.operationCompatible != null ? ` ${target.selection.operation}=${target.selection.operationCompatible ? "yes" : "no"}` : "";
+      console.log(`  selection ${status}${region}${op}: ${target.selection.message}`);
+    }
+    for (const diagnostic of target.diagnostics) {
+      console.log(`  ${diagnostic.level}: ${diagnostic.code}: ${diagnostic.message}`);
+    }
+  }
+}
+async function captureConsoleWarnings(fn) {
+  const originalWarn = console.warn;
+  const warnings = [];
+  console.warn = (...args) => {
+    warnings.push(args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg)).join(" "));
+  };
+  try {
+    return { result: await fn(), warnings };
+  } finally {
+    console.warn = originalWarn;
+  }
+}
+async function runInspectSketchCli(argv = process.argv.slice(2)) {
+  let options;
+  try {
+    options = parseOptions(argv);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(usage7());
+    process.exit(1);
+  }
+  const { overrides } = parseParamFlags(argv);
+  const run = () => runModelForInspect(options.scriptPath, options.backend, options.quality, overrides);
+  const { result: runResult, warnings: engineWarnings } = options.json ? await captureConsoleWarnings(run) : { result: await run(), warnings: [] };
+  if (runResult.error) {
+    console.error("ERROR:", runResult.error);
+    process.exit(1);
+  }
+  let objectIds;
+  if (options.objectSelector) {
+    try {
+      const entries = resolveSceneTargets(buildSceneTargetEntries(runResult.objects), options.objectSelector);
+      objectIds = new Set(entries.map((entry) => entry.id));
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+  const inspection = inspectSketches(runResult.objects, {
+    objectIds,
+    seed: options.seed,
+    operation: options.operation
+  });
+  for (const warning of engineWarnings) {
+    inspection.diagnostics.push({
+      level: "warning",
+      code: "engine-warning",
+      message: warning
+    });
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ script: options.scriptPath, ...inspection }, null, options.compact ? 0 : 2));
+  } else {
+    printHuman2(inspection, options.scriptPath);
+  }
+  if (options.seed && inspection.targets.length > 0 && !inspection.targets.some((target) => target.selection?.ok)) {
+    process.exit(1);
+  }
+}
+
 // cli/check-occt-lower.ts
 import assert5 from "assert/strict";
 function approx3(a, b, eps = 0.01) {
@@ -15485,9 +16392,13 @@ var ESTABLISHED_LOWERCASE_PUBLIC_API_GLOBALS = /* @__PURE__ */ new Set([
   "kerfCompensateTabs",
   "require"
 ]);
+function readText(relativePath) {
+  const path3 = resolvePackagePath(import.meta.url, relativePath);
+  return readFileSync9(path3, "utf8");
+}
 function readSource(relativePath) {
   const path3 = resolvePackagePath(import.meta.url, relativePath);
-  return ts.createSourceFile(path3, readFileSync9(path3, "utf8"), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  return ts.createSourceFile(path3, readText(relativePath), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
 }
 function propertyNameText(name) {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
@@ -15570,6 +16481,29 @@ function uniqueSorted2(values) {
 function isLowercaseGlobal(name) {
   return /^[a-z]/u.test(name);
 }
+function renderRuntimeNameList(names) {
+  const lines = [];
+  for (let i = 0; i < names.length; i += 8) {
+    lines.push(names.slice(i, i + 8).join(", "));
+  }
+  return lines.join("\n");
+}
+function checkRuntimeNamesDoc(runtimeNames) {
+  const collisionReservedNames = runtimeNames.filter((name) => name !== "showLabels");
+  const expectedList = renderRuntimeNameList(collisionReservedNames);
+  let doc;
+  try {
+    doc = readText("docs/permanent/generated/runtime-names.md");
+  } catch {
+    return "Generated runtime names doc is missing. Run npm run gen:docs.";
+  }
+  if (!doc.includes(`\`\`\`text
+${expectedList}
+\`\`\``)) {
+    return "Generated runtime names doc is stale. Run npm run gen:docs.";
+  }
+  return null;
+}
 async function runCheckRuntimeGlobalsCli() {
   const errors = [];
   const runtime = collectRuntimeBindingNames(readSource("src/forge/script-runtime/runScript.ts"));
@@ -15577,6 +16511,8 @@ async function runCheckRuntimeGlobalsCli() {
   if (runtime.unsupported.length > 0) {
     errors.push(`runtimeBindings must use explicit property names; unsupported object entries at lines ${runtime.unsupported.join(", ")}.`);
   }
+  const runtimeNamesDocError = checkRuntimeNamesDoc(runtimeNames);
+  if (runtimeNamesDocError) errors.push(runtimeNamesDocError);
   const newLowercaseGlobals = runtimeNames.filter((name) => isLowercaseGlobal(name) && !ESTABLISHED_LOWERCASE_RUNTIME_GLOBALS.has(name));
   if (newLowercaseGlobals.length > 0) {
     errors.push(
@@ -15631,11 +16567,11 @@ runDirectCliMain(import.meta.url, "cli/check-runtime-globals.ts", () => runCheck
 
 // cli/check-text.ts
 import assert6 from "assert/strict";
-var EPS5 = 1e-3;
-function approx4(a, b, eps = EPS5) {
+var EPS6 = 1e-3;
+function approx4(a, b, eps = EPS6) {
   return Math.abs(a - b) <= eps;
 }
-function expectClose3(actual, expected, label, eps = EPS5) {
+function expectClose3(actual, expected, label, eps = EPS6) {
   assert6(approx4(actual, expected, eps), `${label}: expected ${expected}, got ${actual}`);
 }
 function bounds(sk) {
@@ -15690,7 +16626,7 @@ function checkTextWidth() {
     Math.abs(reported - w) < tolerance,
     `textWidth ${reported.toFixed(3)} should be close to sketch width ${w.toFixed(3)} within ${tolerance.toFixed(3)}`
   );
-  assert6(reported >= w - EPS5, `textWidth ${reported.toFixed(3)} should be >= sketch width ${w.toFixed(3)}`);
+  assert6(reported >= w - EPS6, `textWidth ${reported.toFixed(3)} should be >= sketch width ${w.toFixed(3)}`);
 }
 function checkHorizontalAlignment() {
   const left = text2d("CAD", { size: 10, align: "left" });
@@ -15753,8 +16689,8 @@ runDirectCliMain(import.meta.url, "cli/check-text.ts", () => runCheckTextCli());
 
 // cli/check-transforms.ts
 import assert7 from "assert/strict";
-var EPS6 = 1e-6;
-function approx5(a, b, eps = EPS6) {
+var EPS7 = 1e-6;
+function approx5(a, b, eps = EPS7) {
   return Math.abs(a - b) <= eps;
 }
 function assertVec(actual, expected, label) {
@@ -15893,53 +16829,16 @@ function testAssemblyNamedGroupLabels() {
     `Expected flattened objects to retain groupName Base Assembly, got ${JSON.stringify(result.objects.map((obj) => obj.groupName))}`
   );
 }
-function testAssemblyJointCouplings() {
-  const mech = assembly("CoupledJointsInvariant").addFrame("Base").addFrame("A").addFrame("B").addFrame("C").addRevolute("A", "Base", "A", { axis: [0, 0, 1] }).addRevolute("B", "A", "B", { axis: [0, 0, 1], min: -30, max: 30 }).addRevolute("C", "B", "C", { axis: [0, 0, 1] }).addJointCoupling("B", { terms: [{ joint: "A", ratio: 2 }], offset: 10 }).addJointCoupling("C", {
-    terms: [
-      { joint: "A", ratio: -1 },
-      { joint: "B", ratio: 0.5 }
-    ],
-    offset: 5
-  });
-  const solved = mech.solve({ A: 20, B: 999 });
-  const state = solved.getJointState();
-  assert7(approx5(state.A ?? Number.NaN, 20), `Expected A=20, got ${state.A}`);
-  assert7(approx5(state.B ?? Number.NaN, 30), `Expected B=30 after clamp, got ${state.B}`);
-  assert7(approx5(state.C ?? Number.NaN, 0), `Expected C=0 from coupled joints, got ${state.C}`);
-  const warnings = solved.warnings().join("\n");
-  assert7(
-    warnings.includes('Joint "B" state override ignored because it is coupled'),
-    `Expected ignored-override warning for B, got:
-${warnings}`
-  );
-}
-function testAssemblyGearCouplings() {
-  const mech = assembly("GearCouplingsInvariant").addFrame("Base").addFrame("DriverPart").addFrame("DrivenPart").addFrame("FollowerPart").addRevolute("Driver", "Base", "DriverPart", { axis: [0, 0, 1] }).addRevolute("Driven", "Base", "DrivenPart", { axis: [0, 0, 1], min: -20, max: 20 }).addRevolute("Follower", "Base", "FollowerPart", { axis: [0, 0, 1] }).addGearCoupling("Driven", "Driver", { driverTeeth: 14, drivenTeeth: 28 }).addGearCoupling("Follower", "Driven", { pair: { jointRatio: -2 }, offset: 5 });
-  const solved = mech.solve({ Driver: 30, Driven: 999, Follower: 999 });
-  const state = solved.getJointState();
-  assert7(approx5(state.Driver ?? Number.NaN, 30), `Expected Driver=30, got ${state.Driver}`);
-  assert7(approx5(state.Driven ?? Number.NaN, -15), `Expected Driven=-15 from teeth ratio, got ${state.Driven}`);
-  assert7(approx5(state.Follower ?? Number.NaN, 35), `Expected Follower=35 from pair ratio, got ${state.Follower}`);
-  const warnings = solved.warnings().join("\n");
-  assert7(
-    warnings.includes('Joint "Driven" state override ignored because it is coupled'),
-    `Expected ignored-override warning for Driven, got:
-${warnings}`
+function testRetiredAssemblyCouplingStubs() {
+  const mech = assembly("RetiredCouplingInvariant").addFrame("Base").addFrame("DriverPart").addFrame("DrivenPart").addRevolute("Driver", "Base", "DriverPart", { axis: [0, 0, 1] }).addRevolute("Driven", "Base", "DrivenPart", { axis: [0, 0, 1] });
+  assert7.throws(
+    () => mech.addJointCoupling("Driven", { terms: [{ joint: "Driver", ratio: 1 }] }),
+    /addJointCoupling\(\) has been removed from the modeling API/
+  );
+  assert7.throws(
+    () => mech.addGearCoupling("Driven", "Driver", { ratio: -1 }),
+    /addGearCoupling\(\) has been removed from the modeling API/
   );
-  assert7(
-    warnings.includes('Joint "Follower" state override ignored because it is coupled'),
-    `Expected ignored-override warning for Follower, got:
-${warnings}`
-  );
-  const internal = assembly("InternalMeshSignInvariant").addFrame("Base").addFrame("A").addFrame("B").addRevolute("A", "Base", "A", { axis: [0, 0, 1] }).addRevolute("B", "Base", "B", { axis: [0, 0, 1] }).addGearCoupling("B", "A", { driverTeeth: 20, drivenTeeth: 40, mesh: "internal" });
-  const internalState = internal.solve({ A: 12 }).getJointState();
-  assert7(approx5(internalState.B ?? Number.NaN, 6), `Expected internal mesh B=6, got ${internalState.B}`);
-  const bevel = assembly("BevelMeshSignInvariant").addFrame("Base").addFrame("A").addFrame("B").addRevolute("A", "Base", "A", { axis: [0, 0, 1] }).addRevolute("B", "Base", "B", { axis: [1, 0, 0] }).addGearCoupling("B", "A", { driverTeeth: 24, drivenTeeth: 48, mesh: "bevel" });
-  const bevelState = bevel.solve({ A: 12 }).getJointState();
-  assert7(approx5(bevelState.B ?? Number.NaN, -6), `Expected bevel mesh B=-6, got ${bevelState.B}`);
-  const face = assembly("FaceMeshSignInvariant").addFrame("Base").addFrame("A").addFrame("B").addRevolute("A", "Base", "A", { axis: [0, 0, 1] }).addRevolute("B", "Base", "B", { axis: [1, 0, 0] }).addGearCoupling("B", "A", { driverTeeth: 24, drivenTeeth: 48, mesh: "face" });
-  const faceState = face.solve({ A: 12 }).getJointState();
-  assert7(approx5(faceState.B ?? Number.NaN, -6), `Expected face mesh B=-6, got ${faceState.B}`);
 }
 function testRuntimeJointCouplingResolution() {
   const joints = [
@@ -16180,7 +17079,7 @@ function testBevelGearTopSectionCircularity() {
   const topSlice = gear.slice(bb.max[2] - 1e-4).bounds();
   const spanX = topSlice.max[0] - topSlice.min[0];
   const spanY = topSlice.max[1] - topSlice.min[1];
-  assert7(spanX > EPS6 && spanY > EPS6, `Expected non-degenerate top slice, got spanX=${spanX}, spanY=${spanY}`);
+  assert7(spanX > EPS7 && spanY > EPS7, `Expected non-degenerate top slice, got spanX=${spanX}, spanY=${spanY}`);
   const aspect = spanY / spanX;
   assert7(aspect > 0.85 && aspect < 1.15, `Expected near-circular top slice, got spanX=${spanX}, spanY=${spanY}, aspect=${aspect}`);
 }
@@ -16193,8 +17092,7 @@ async function runCheckTransformsCli() {
   testShapeRotateAroundTo();
   testShapeGroupRotateAroundToSugar();
   testAssemblyNamedGroupLabels();
-  testAssemblyJointCouplings();
-  testAssemblyGearCouplings();
+  testRetiredAssemblyCouplingStubs();
   testRuntimeJointCouplingResolution();
   testContinuousRuntimeJointAnimation();
   testTickBasedKeyframes();
@@ -16258,13 +17156,13 @@ function enforceCommandConfig(commandPath) {
 }
 
 // cli/debug-compiler.ts
-function usage7() {
+function usage8() {
   console.error("Usage: forgecad debug compiler <script.forge.js> [--compact]");
   process.exit(1);
 }
 async function runDebugCompilerCli(argv = process.argv.slice(2)) {
   const scriptPath = argv.find((arg) => !arg.startsWith("--"));
-  if (!scriptPath) usage7();
+  if (!scriptPath) usage8();
   const compact = argv.includes("--compact");
   await init();
   const inspection = inspectCompilerScene(loadCompilerInspectionInput(scriptPath));
@@ -16274,7 +17172,7 @@ async function runDebugCompilerCli(argv = process.argv.slice(2)) {
 // cli/debug-assembly.ts
 import { readFileSync as readFileSync11 } from "fs";
 import { resolve as resolve12 } from "path";
-function usage8() {
+function usage9() {
   console.error(
     "Usage: forgecad debug assembly <script.forge.js> [--json] [--compact] [--all] [--exact-geometry] [--fail-on error|warning] [--backend manifold|occt|truck] [--sweep-steps <n>]"
   );
@@ -16334,7 +17232,7 @@ async function runDebugAssemblyCli(argv = process.argv.slice(2)) {
   const consumed = consumedIndexes(argv);
   const positional = argv.filter((arg, index) => !consumed.has(index) && !arg.startsWith("--"));
   const scriptPath = positional[0];
-  if (!scriptPath) usage8();
+  if (!scriptPath) usage9();
   const asJson = argv.includes("--json");
   const compact = argv.includes("--compact");
   const all = argv.includes("--all");
@@ -16456,13 +17354,13 @@ function mapDimensionsToOwners(dimensions, objects) {
   });
   return { combinedCount, byDimensionId };
 }
-function usage9() {
+function usage10() {
   console.error("Usage: forgecad debug dimensions <script.forge.js> [--all] [--dim-angle-tol 12]");
   process.exit(1);
 }
 async function runDebugDimensionsCli(argv = process.argv.slice(2)) {
   const scriptPath = argv[0];
-  if (!scriptPath) usage9();
+  if (!scriptPath) usage10();
   const showAll = argv.includes("--all");
   const tolFlagIndex = argv.indexOf("--dim-angle-tol");
   const tolValue = tolFlagIndex >= 0 ? Number(argv[tolFlagIndex + 1]) : NaN;
@@ -16712,6 +17610,7 @@ async function buildStepBlob(objects) {
 // cli/forge-brep.ts
 function parseArgs4(argv) {
   let format = "step";
+  let backend = "occt";
   let outputPath;
   let scriptPath;
   for (let i = 0; i < argv.length; i += 1) {
@@ -16725,6 +17624,15 @@ function parseArgs4(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--backend") {
+      const value = argv[i + 1];
+      if (value !== "occt" && value !== "truck") {
+        throw new Error(`--backend must be "occt" or "truck" (got ${value ?? "missing"})`);
+      }
+      backend = value;
+      i += 1;
+      continue;
+    }
     if (arg === "--output") {
       outputPath = argv[i + 1];
       if (!outputPath) throw new Error("--output requires a path");
@@ -16749,9 +17657,14 @@ function parseArgs4(argv) {
     scriptPath = arg;
   }
   if (!scriptPath) {
-    throw new Error("Usage: npx tsx cli/forge-brep.ts [--format step|brep] [--output path] <model.forge.js|asset.step|asset.stp>");
+    throw new Error(
+      "Usage: npx tsx cli/forge-brep.ts [--format step|brep] [--backend occt|truck] [--output path] <model.forge.js|asset.step|asset.stp>"
+    );
+  }
+  if (backend === "truck" && format !== "step") {
+    throw new Error("The native Truck BREP exporter currently supports STEP only (use --format step).");
   }
-  return { format, outputPath, scriptPath };
+  return { format, backend, outputPath, scriptPath };
 }
 function defaultOutputPath(scriptPath, sourcePath, format) {
   const abs = resolve15(scriptPath);
@@ -16790,12 +17703,25 @@ async function buildRuntimeExactExportBlob(format, code, fileName, allFiles, rea
     objectCount: exactObjects.length
   };
 }
+async function buildTruckStepBlob(code, fileName, allFiles, readBinaryFile) {
+  await activateBackend("truck");
+  const result = runScript(code, fileName, allFiles, { readBinaryFile });
+  if (result.error) {
+    throw new Error(result.error);
+  }
+  const handles = result.objects.filter((obj) => obj.shape).map((obj) => getTruckShapeBackendHandle(getShapeRuntimeBackend(obj.shape)));
+  if (handles.length === 0) {
+    throw new Error("No 3D shapes found in the script output.");
+  }
+  const step = getTruckGeometryWasm().geometry_export_step_multi(JSON.stringify(handles));
+  return { blob: new Blob([step], { type: "application/step" }), objectCount: handles.length };
+}
 async function runBrepCli(argv = process.argv.slice(2)) {
-  const { format, outputPath, scriptPath } = parseArgs4(argv);
+  const { format, backend, outputPath, scriptPath } = parseArgs4(argv);
   const input = loadCliScriptInput(scriptPath);
   await init();
   try {
-    const exactExport = await buildRuntimeExactExportBlob(format, input.code, input.fileName, input.allFiles, input.readBinaryFile);
+    const exactExport = backend === "truck" ? await buildTruckStepBlob(input.code, input.fileName, input.allFiles, input.readBinaryFile) : await buildRuntimeExactExportBlob(format, input.code, input.fileName, input.allFiles, input.readBinaryFile);
     if (outputPath && resolve15(outputPath) === input.sourcePath) {
       console.error("Output path would overwrite the input file. Pass a different --output path.");
       process.exit(1);
@@ -17123,7 +18049,7 @@ function parseSweepEaseEnv(raw) {
   if (raw === "linear" || raw === "smoothstep") return raw;
   return null;
 }
-function usage10(config) {
+function usage11(config) {
   const defaultPitch = DEFAULTS.pitchDeg == null ? "copied camera pitch or 18" : String(DEFAULTS.pitchDeg);
   return `ForgeCAD Capture Renderer
 
@@ -17134,7 +18060,7 @@ Options:
   --format <gif|mp4>           Output format (default: ${config.defaultFormat})
   --capture <orbit|animation|section-sweep>
                                Capture preset (default: orbit)
-  --animation <name>           Select a jointsView animation clip
+  --animation <name>           Select a named joint animation clip
   --animation-loops <n>        Repeat the selected clip this many times (default: ${DEFAULTS.animationLoops})
   --cut-plane <name>           Enable a named cut plane (repeatable)
   --sweep-plane <XY|XZ|YZ>     Plane to move for --capture section-sweep (default: ${DEFAULTS.sweepPlane})
@@ -17179,7 +18105,7 @@ Options:
 
 Examples:
   forgecad capture gif examples/products/cup.forge.js
-  forgecad capture mp4 examples/api/runtime-joints-view.forge.js out/step.mp4 --capture animation --animation Step
+  forgecad capture mp4 examples/api/assembly-kinematics-four-bar.forge.js out/four-bar.mp4 --view iso
   forgecad capture mp4 model.forge.js out/raw.mp4 --param "Output=raw-sdf"
   forgecad capture gif examples/3d-printer.forge.js out/section.gif --cut-plane "Front Section"
   forgecad capture mp4 examples/3d-printer.forge.js out/sweep.mp4 --capture section-sweep --sweep-plane YZ --sweep-frames 180
@@ -17255,7 +18181,7 @@ function defaultOutputPath2(scriptPath, format, capture) {
 }
 function parseCli(argv, config) {
   if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
-    console.log(usage10(config));
+    console.log(usage11(config));
     process.exit(0);
   }
   let scriptPath;
@@ -17744,7 +18670,7 @@ async function fetchRenderHtml2(port) {
     clearTimeout(timer);
   }
 }
-async function waitForRenderHtml(port, timeoutMs) {
+async function waitForRenderHtml2(port, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await fetchRenderHtml2(port)) return true;
@@ -17784,7 +18710,7 @@ async function ensureDevServer2(port) {
   proc.once("exit", () => {
     exitedEarly = true;
   });
-  const ready = await waitForRenderHtml(port, 3e4);
+  const ready = await waitForRenderHtml2(port, 3e4);
   if (!ready) {
     proc.kill();
     const detail = startupOutput.trim();
@@ -17807,7 +18733,7 @@ async function stopDevServer2(proc) {
     proc.kill("SIGKILL");
   }
 }
-async function isPortFree2(port) {
+async function isPortFree(port) {
   const probe = (host) => new Promise((resolvePort) => {
     const server = createServer();
     server.once("error", (err) => {
@@ -17826,10 +18752,10 @@ async function isPortFree2(port) {
   const ipv6Free = await probe("::1");
   return ipv4Free && ipv6Free;
 }
-async function findFreePort2(startPort, maxAttempts = 30) {
+async function findFreePort(startPort, maxAttempts = 30) {
   let candidate = Math.max(1024, startPort);
   for (let i = 0; i < maxAttempts; i += 1) {
-    if (await isPortFree2(candidate)) return candidate;
+    if (await isPortFree(candidate)) return candidate;
     candidate += 1;
   }
   return null;
@@ -18280,7 +19206,7 @@ async function runCaptureCli(config, argv = process.argv.slice(2)) {
   } catch (err) {
     console.error(String(err));
     console.error("");
-    console.error(usage10(config));
+    console.error(usage11(config));
     process.exit(1);
   }
   const chromePath = findChromePath2(options.chromePath);
@@ -18301,8 +19227,8 @@ async function runCaptureCli(config, argv = process.argv.slice(2)) {
   if (forgeAlreadyRunning) {
     console.log(`Reusing existing ForgeCAD render server on :${activePort}.`);
   }
-  if (!forgeAlreadyRunning && !await isPortFree2(activePort)) {
-    const fallbackPort = await findFreePort2(activePort + 1);
+  if (!forgeAlreadyRunning && !await isPortFree(activePort)) {
+    const fallbackPort = await findFreePort(activePort + 1);
     if (fallbackPort == null) {
       throw new Error(`Port ${activePort} is occupied and no free fallback port was found.`);
     }
@@ -18322,7 +19248,7 @@ async function runCaptureCli(config, argv = process.argv.slice(2)) {
         const message = String(err);
         const isPortConflict = message.includes("already in use") || message.includes("EADDRINUSE");
         if (!isPortConflict) throw err;
-        const fallbackPort = await findFreePort2(activePort + 1);
+        const fallbackPort = await findFreePort(activePort + 1);
         if (fallbackPort == null) throw err;
         console.log(`Port ${activePort} failed to start due to a port conflict. Retrying on ${fallbackPort} ...`);
         activePort = fallbackPort;
@@ -18357,7 +19283,7 @@ async function runCaptureCli(config, argv = process.argv.slice(2)) {
     debugLog(`loading capture runtime on :${activePort}`);
     let captureRuntimeReady = await loadCaptureRuntime(page, activePort, options.capture);
     if (!captureRuntimeReady && !viteProc) {
-      const fallbackPort = await findFreePort2(activePort + 1);
+      const fallbackPort = await findFreePort(activePort + 1);
       if (fallbackPort != null) {
         console.log(`Existing server on :${activePort} is missing required capture APIs. Starting a fresh server on :${fallbackPort} ...`);
         activePort = fallbackPort;
@@ -18906,11 +19832,10 @@ function runHiddenCompletionCli(argv, commands2) {
 }
 
 // cli/forge-dev.ts
-import { fork } from "child_process";
 import path from "path";
 import { resolve as resolve18, dirname as dirname4, basename as basename7 } from "path";
-import { existsSync as existsSync9, statSync as statSync7 } from "fs";
-function usage11() {
+import { statSync as statSync7 } from "fs";
+function usage12() {
   console.error(`ForgeCAD Dev Server
 
 Usage:
@@ -18938,7 +19863,7 @@ function parseDevArgs(argv) {
   if (argv.length === 0) {
     throw new Error("Missing project path. Use `forgecad dev <project-path> [project-path ...]`.");
   }
-  if (argv.includes("-h") || argv.includes("--help")) usage11();
+  if (argv.includes("-h") || argv.includes("--help")) usage12();
   const options = { open: false, strictPort: false, projectPaths: [] };
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -18998,35 +19923,10 @@ function waitForExit(child) {
     child.once("exit", (code) => resolve40(code ?? 0));
   });
 }
-function spawnBackendServer(packageRoot) {
-  const backendEntry = resolve18(packageRoot, "dist-backend", "server.js");
-  if (!existsSync9(backendEntry)) return null;
-  const child = fork(backendEntry, {
-    stdio: ["ignore", "pipe", "pipe", "ipc"],
-    env: { ...process.env, FORGE_BACKEND_PORT: "4510" }
-  });
-  child.stdout?.on("data", (data) => {
-    for (const line of data.toString().trim().split("\n")) {
-      console.log(`  [backend] ${line}`);
-    }
-  });
-  child.stderr?.on("data", (data) => {
-    for (const line of data.toString().trim().split("\n")) {
-      console.error(`  [backend] ${line}`);
-    }
-  });
-  child.on("exit", (code) => {
-    if (code !== null && code !== 0) {
-      console.error(`  [backend] Compute server exited with code ${code}`);
-    }
-  });
-  return child;
-}
 async function runDevCli(argv = process.argv.slice(2)) {
   const options = parseDevArgs(argv);
   const projectDirs = options.projectPaths;
   const packageRoot = packageRootFrom(import.meta.url);
-  const backendChild = spawnBackendServer(packageRoot);
   const child = spawnPackageVite(import.meta.url, toViteArgs(options), {
     cwd: packageRoot,
     stdio: "inherit",
@@ -19040,7 +19940,6 @@ async function runDevCli(argv = process.argv.slice(2)) {
     }
   });
   const code = await waitForExit(child);
-  if (backendChild && !backendChild.killed) backendChild.kill();
   if (code !== 0) process.exit(code);
 }
 
@@ -19108,130 +20007,9 @@ async function runGcodeExportCli(argv) {
   console.log(`  Bounds: [${tp.bounds.min.map((v) => v.toFixed(1)).join(", ")}] \u2192 [${tp.bounds.max.map((v) => v.toFixed(1)).join(", ")}]`);
 }
 
-// src/forge/targets.ts
-var cleanSceneTargetPathSegments = (segments) => (segments ?? []).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
-function getSceneObjectTreePath(object) {
-  const explicitTreePath = cleanSceneTargetPathSegments(object.treePath);
-  if (explicitTreePath.length > 0) return explicitTreePath;
-  const name = object.name.trim() || object.id;
-  const groupName = object.groupName?.trim();
-  if (!groupName) return [name];
-  const groupPath = groupName.split(".").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
-  const prefixedLeaf = `${groupName}.`;
-  if (name.startsWith(prefixedLeaf)) {
-    const leafName = name.slice(prefixedLeaf.length).trim();
-    return [...groupPath, leafName || name];
-  }
-  return [...groupPath, name];
-}
-function getSceneObjectKind(object) {
-  if (object.mock) return "mock";
-  if (object.sketch) return "sketch";
-  if (object.toolpath) return "toolpath";
-  if (object.sdf) return "sdf";
-  if (object.shape) return "shape";
-  return "object";
-}
-function buildSceneTargetEntries(objects) {
-  return objects.map((object) => {
-    const pathSegments = getSceneObjectTreePath(object);
-    return {
-      id: object.id,
-      name: object.name,
-      kind: getSceneObjectKind(object),
-      pathSegments,
-      path: pathSegments.join("/"),
-      dottedPath: pathSegments.join("."),
-      group: object.groupName?.trim() || void 0,
-      tags: object.tags ?? [],
-      mock: object.mock === true,
-      object
-    };
-  });
-}
-function formatSceneTargetPath(entry) {
-  return entry.path || entry.name;
-}
-function resolveSceneTargets(entries, selector) {
-  const needle = normalizeTargetText(selector);
-  if (!needle) throw new Error("Target selector must not be empty.");
-  const hasGlob = /[*?]/.test(selector);
-  if (hasGlob) {
-    const pattern = globToRegExp(needle);
-    const matches = entries.filter((entry) => targetCandidateTexts(entry).some((candidate) => pattern.test(candidate)));
-    if (matches.length > 0) return matches;
-    throw targetNotFound(selector, entries);
-  }
-  const idMatches = entries.filter((entry) => normalizeTargetText(entry.id) === needle);
-  if (idMatches.length > 0) return idMatches;
-  const exactPathMatches = entries.filter(
-    (entry) => normalizeTargetText(entry.path) === needle || normalizeTargetText(entry.dottedPath) === needle
-  );
-  if (exactPathMatches.length > 0) return exactPathMatches;
-  const groupMatches = entries.filter((entry) => {
-    const groupPath = entry.pathSegments.slice(0, -1);
-    return normalizeTargetText(groupPath.join("/")) === needle || normalizeTargetText(groupPath.join(".")) === needle;
-  });
-  if (groupMatches.length > 0) return groupMatches;
-  const nameMatches2 = entries.filter(
-    (entry) => normalizeTargetText(entry.name) === needle || normalizeTargetText(entry.pathSegments[entry.pathSegments.length - 1] ?? "") === needle
-  );
-  if (nameMatches2.length === 1) return nameMatches2;
-  if (nameMatches2.length > 1) throw ambiguousTarget(selector, nameMatches2);
-  throw targetNotFound(selector, entries);
-}
-function suggestSceneTargets(selector, entries, limit = 8) {
-  const needle = normalizeTargetText(selector);
-  if (!needle) return entries.slice(0, limit);
-  return entries.map((entry) => ({ entry, score: scoreTarget(entry, needle) })).filter((ranked) => ranked.score > 0).sort((a, b) => b.score - a.score || a.entry.path.localeCompare(b.entry.path)).slice(0, limit).map((ranked) => ranked.entry);
-}
-function targetCandidateTexts(entry) {
-  return [
-    entry.id,
-    entry.name,
-    entry.path,
-    entry.dottedPath,
-    entry.group ?? "",
-    entry.pathSegments[entry.pathSegments.length - 1] ?? ""
-  ].map(normalizeTargetText);
-}
-function normalizeTargetText(value) {
-  return value.trim().replace(/\\/g, "/").replace(/\s*\/\s*/g, "/").replace(/\s*\.\s*/g, ".").toLowerCase();
-}
-function globToRegExp(value) {
-  const escaped = value.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${escaped}$`, "i");
-}
-function scoreTarget(entry, needle) {
-  const candidates = targetCandidateTexts(entry);
-  if (candidates.some((candidate) => candidate === needle)) return 100;
-  if (candidates.some((candidate) => candidate.startsWith(needle))) return 60;
-  if (candidates.some((candidate) => candidate.includes(needle))) return 30;
-  const tokens = needle.split(/[\s/._-]+/).filter(Boolean);
-  if (tokens.length > 0 && tokens.every((token) => candidates.some((candidate) => candidate.includes(token)))) return 15;
-  return 0;
-}
-function targetSummary(entry) {
-  return `${formatSceneTargetPath(entry)} (${entry.kind}, ${entry.id})`;
-}
-function targetNotFound(selector, entries) {
-  const suggestions = suggestSceneTargets(selector, entries);
-  const detail = suggestions.length > 0 ? `
-Did you mean:
-${suggestions.map((entry) => `  ${targetSummary(entry)}`).join("\n")}` : "";
-  return new Error(`Target "${selector}" matched no scene objects.${detail}`);
-}
-function ambiguousTarget(selector, matches) {
-  return new Error(
-    `Target "${selector}" is ambiguous.
-Use a full path:
-${matches.map((entry) => `  ${targetSummary(entry)}`).join("\n")}`
-  );
-}
-
 // cli/forge-ls.ts
 var TARGET_KINDS = ["shape", "sketch", "sdf", "toolpath", "mock", "object"];
-function usage12() {
+function usage13() {
   return [
     "Usage: forgecad ls <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [target] [--tree] [--long] [--json] [--kind shape,sketch,mock] [--param Key=Value] [--backend manifold|occt|truck] [--quality live|default|high]"
   ].join("\n");
@@ -19250,7 +20028,7 @@ function parseKindFilter(raw) {
 }
 function parseLsOptions(argv) {
   if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
-    console.log(usage12());
+    console.log(usage13());
     process.exit(0);
   }
   const { overrides: _paramOverrides, consumed: paramConsumed } = parseParamFlags(argv);
@@ -19298,12 +20076,12 @@ function filteredTargets(entries, options) {
   if (options.kinds) targets = targets.filter((entry) => options.kinds?.has(entry.kind));
   return targets;
 }
-function formatNumber(value, digits = 1) {
+function formatNumber2(value, digits = 1) {
   if (!Number.isFinite(value)) return String(value);
   return value.toFixed(digits).replace(/\.0$/, "");
 }
-function formatBounds(min, max) {
-  return `[${min.map((v) => formatNumber(v)).join(",")}]..[${max.map((v) => formatNumber(v)).join(",")}]`;
+function formatBounds2(min, max) {
+  return `[${min.map((v) => formatNumber2(v)).join(",")}]..[${max.map((v) => formatNumber2(v)).join(",")}]`;
 }
 function targetMetrics(entry) {
   const object = entry.object;
@@ -19340,7 +20118,7 @@ function printLineList(entries, long) {
       continue;
     }
     const metrics = targetMetrics(entry);
-    const detail = metrics && "volume" in metrics ? ` id=${entry.id} vol=${formatNumber(metrics.volume)} tris=${metrics.triangles.toLocaleString()} bodies=${metrics.bodies} bbox=${formatBounds(metrics.bounds.min, metrics.bounds.max)}` : metrics && "area" in metrics ? ` id=${entry.id} area=${formatNumber(metrics.area)} regions=${metrics.regions}` : ` id=${entry.id}`;
+    const detail = metrics && "volume" in metrics ? ` id=${entry.id} vol=${formatNumber2(metrics.volume)} tris=${metrics.triangles.toLocaleString()} bodies=${metrics.bodies} bbox=${formatBounds2(metrics.bounds.min, metrics.bounds.max)}` : metrics && "area" in metrics ? ` id=${entry.id} area=${formatNumber2(metrics.area)} regions=${metrics.regions}` : ` id=${entry.id}`;
     console.log(`${base}${detail}`);
   }
 }
@@ -19364,7 +20142,7 @@ async function runLsCli(argv = process.argv.slice(2)) {
     options = parseLsOptions(argv);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
-    console.error(usage12());
+    console.error(usage13());
     process.exit(1);
   }
   const { overrides } = parseParamFlags(argv);
@@ -19635,6 +20413,11 @@ async function runInspectEvidenceListCli(argv) {
     process.exit(1);
   }
   const commands2 = [
+    {
+      command: "inspect sketch",
+      evidence: "sketch",
+      description: "Inspect returned sketch/profile regions and seed selector dry-runs."
+    },
     {
       command: "inspect visual image",
       evidence: "image",
@@ -19643,6 +20426,7 @@ async function runInspectEvidenceListCli(argv) {
     { command: "inspect visual cutaway", evidence: "cutaway", description: "Capture a clipped 3D viewport from the cut side." },
     { command: "inspect visual depth", evidence: "depth", description: "Capture visible surface depth evidence." },
     { command: "inspect visual normals", evidence: "normals", description: "Capture camera-view surface normal evidence." },
+    { command: "inspect visual rig", evidence: "rig", description: "Capture kinematic rig skeleton evidence." },
     { command: "inspect visual objects", evidence: "objects", description: "Capture object identity evidence." },
     { command: "inspect surface zebra", evidence: "zebra", description: "Capture Zebra stripe surface-continuity evidence." },
     { command: "inspect surface roughness", evidence: "roughness", description: "Capture mesh roughness and sharp-feature evidence." },
@@ -19680,7 +20464,7 @@ async function runInspectEvidenceListCli(argv) {
 }
 
 // cli/forge-render-hq.ts
-import { writeFileSync as writeFileSync8, mkdtempSync as mkdtempSync2, rmSync as rmSync2, existsSync as existsSync10 } from "fs";
+import { writeFileSync as writeFileSync8, mkdtempSync as mkdtempSync2, rmSync as rmSync2, existsSync as existsSync9 } from "fs";
 import { resolve as resolve22, dirname as dirname5, join as join7, extname as extname7 } from "path";
 import { execSync as execSync2, spawnSync } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
@@ -19897,7 +20681,7 @@ function parseArgs7(argv) {
       i += 1;
     } else if (arg === "--hdri") {
       hdriPath = resolve22(next);
-      if (!existsSync10(hdriPath)) throw new Error(`HDRI file not found: ${hdriPath}`);
+      if (!existsSync9(hdriPath)) throw new Error(`HDRI file not found: ${hdriPath}`);
       i += 1;
     } else if (arg === "--camera") {
       const value = readArgValue(argv, i, arg);
@@ -20002,11 +20786,11 @@ function findBlender() {
     `${process.env.HOME}/Applications/Blender.app/Contents/MacOS/Blender`
   ];
   for (const p of macPaths) {
-    if (existsSync10(p)) return p;
+    if (existsSync9(p)) return p;
   }
   const linuxPaths = ["/usr/bin/blender", "/snap/bin/blender", "/usr/local/bin/blender"];
   for (const p of linuxPaths) {
-    if (existsSync10(p)) return p;
+    if (existsSync9(p)) return p;
   }
   throw new Error(
     "Blender not found. Install it:\n  macOS:  brew install --cask blender\n  Linux:  sudo apt install blender  (or snap install blender)\n  All:    https://www.blender.org/download/"
@@ -20021,7 +20805,7 @@ function defaultOutputPath5(scriptPath, video) {
 function resolveBlenderRenderScript() {
   const cliDir = dirname5(fileURLToPath2(import.meta.url));
   const renderScript = join7(cliDir, "blender", "render.py");
-  if (!existsSync10(renderScript)) {
+  if (!existsSync9(renderScript)) {
     throw new Error(
       `Blender render script missing at ${renderScript}. Rebuild the CLI with \`npm run build:cli\`; packaged installs should include dist-cli/blender/render.py.`
     );
@@ -20199,7 +20983,7 @@ async function runRenderHqCli(argv) {
       rmSync2(tmpDir, { recursive: true, force: true });
     } catch {
     }
-    if (existsSync10(outputPath)) {
+    if (existsSync9(outputPath)) {
       const stats = (await import("fs")).statSync(outputPath);
       const sizeMb = (stats.size / 1024 / 1024).toFixed(1);
       console.log(`
@@ -20225,12 +21009,12 @@ import { basename as basename9, resolve as resolve23 } from "path";
 function defaultPngOutput(scriptPath) {
   return scriptPath.replace(/\.(forge|sketch)\.js$/, ".png").replace(/\.js$/, ".png");
 }
-function usage13() {
+function usage14() {
   console.error("Usage: forgecad render sketch <script.forge.js> [output.png] [--size <px>] [--chrome-path <path>]");
   process.exit(1);
 }
 function parseCli2(argv) {
-  if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) usage13();
+  if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) usage14();
   let scriptPath;
   let outputPath;
   let size = 1024;
@@ -20255,7 +21039,7 @@ function parseCli2(argv) {
     else if (!outputPath) outputPath = arg;
     else throw new Error(`Unexpected argument: ${arg}`);
   }
-  if (!scriptPath) usage13();
+  if (!scriptPath) usage14();
   if (!Number.isFinite(size) || size < 128 || size > 4096) throw new Error(`--size must be between 128 and 4096 (got ${size})`);
   return {
     scriptPath,
@@ -20271,7 +21055,7 @@ async function runRender2dCli(argv = process.argv.slice(2)) {
     options = parseCli2(argv);
   } catch (err) {
     console.error(String(err));
-    usage13();
+    usage14();
   }
   const chromePath = findChromePath(options.chromePath);
   if (!chromePath) {
@@ -20390,13 +21174,13 @@ function formatSheetCutList(input) {
 }
 
 // cli/forge-cut-list.ts
-function usage14() {
+function usage15() {
   console.error("Usage: forgecad cut-list <script.forge.js>");
   process.exit(1);
 }
 async function runCutListCli(argv = process.argv.slice(2)) {
   const scriptPath = argv[0];
-  if (!scriptPath) usage14();
+  if (!scriptPath) usage15();
   const source = await readFile2(resolve24(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
@@ -20429,7 +21213,7 @@ function hasFlag(argv, name) {
   const prefix = `${name}=`;
   return argv.some((arg) => arg === name || arg.startsWith(prefix));
 }
-function usage15() {
+function usage16() {
   console.error(
     "Usage: forgecad export cutting-layout <script.forge.js> [output.pdf|output.dxf]\n         [--format pdf|dxf] [--sheet-width <mm>] [--sheet-height <mm>] [--kerf <mm>]"
   );
@@ -20493,7 +21277,7 @@ function smartDefaults(entries) {
 }
 async function runCuttingLayoutCli(argv = process.argv.slice(2)) {
   const scriptPath = argv[0];
-  if (!scriptPath) usage15();
+  if (!scriptPath) usage16();
   const explicitOutputPath = outputPathArg(argv);
   const formatArg = argValue(argv, "--format");
   if (hasFlag(argv, "--format") && formatArg == null) {
@@ -20556,7 +21340,7 @@ function argValue2(argv, name) {
   if (idx === -1) return void 0;
   return argv[idx + 1];
 }
-function usage16() {
+function usage17() {
   console.error(
     "Usage: forgecad export report <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [output.pdf] [--dim-angle-tol <deg>]"
   );
@@ -20564,7 +21348,7 @@ function usage16() {
 }
 async function runReportCli(argv = process.argv.slice(2)) {
   const scriptPath = argv[0];
-  if (!scriptPath) usage16();
+  if (!scriptPath) usage17();
   const defaultOut = replaceCliInputExtension(scriptPath, ".report.pdf");
   const outputPath = argv[1] && !argv[1].startsWith("--") ? argv[1] : defaultOut;
   const toleranceArg = argValue2(argv, "--dim-angle-tol");
@@ -20628,16 +21412,16 @@ function mmToM(valueMm) {
 function degToRad(valueDeg) {
   return valueDeg * Math.PI / 180;
 }
-function formatNumber2(value, digits = 6) {
+function formatNumber3(value, digits = 6) {
   if (!Number.isFinite(value)) return "0";
   const normalized = Math.abs(value) < 1e-12 ? 0 : value;
   return normalized.toFixed(digits).replace(/\.?0+$/, "");
 }
 function formatPose(parts) {
-  return [...parts.xyzM.map((value) => formatNumber2(value, 6)), ...parts.rpyRad.map((value) => formatNumber2(value, 6))].join(" ");
+  return [...parts.xyzM.map((value) => formatNumber3(value, 6)), ...parts.rpyRad.map((value) => formatNumber3(value, 6))].join(" ");
 }
 function axisToText(axis) {
-  return axis.map((value) => formatNumber2(value, 6)).join(" ");
+  return axis.map((value) => formatNumber3(value, 6)).join(" ");
 }
 function transformToPose(transform) {
   const m = transform.toArray();
@@ -20783,15 +21567,15 @@ function inertiaFromBounds(geometry, massKg) {
 }
 function jointTypeLimitUnits(joint2, value) {
   if (value === void 0) return null;
-  if (joint2.type === "revolute") return formatNumber2(degToRad(value), 6);
-  if (joint2.type === "prismatic") return formatNumber2(mmToM(value), 6);
+  if (joint2.type === "revolute") return formatNumber3(degToRad(value), 6);
+  if (joint2.type === "prismatic") return formatNumber3(mmToM(value), 6);
   return null;
 }
 function jointVelocityUnits(joint2, value) {
   if (value === void 0) return null;
-  if (joint2.type === "revolute") return formatNumber2(degToRad(value), 6);
-  if (joint2.type === "prismatic") return formatNumber2(mmToM(value), 6);
-  return formatNumber2(value, 6);
+  if (joint2.type === "revolute") return formatNumber3(degToRad(value), 6);
+  if (joint2.type === "prismatic") return formatNumber3(mmToM(value), 6);
+  return formatNumber3(value, 6);
 }
 function sRgbFloat(hex) {
   if (!hex || !/^#([0-9a-f]{6})$/i.test(hex)) return null;
@@ -20820,14 +21604,14 @@ function demoWorldName(world, modelName) {
 }
 function keyboardPluginXml(cmdVelTopic, linearStep, angularStep) {
   const bindings = [
-    { key: 87, twist: `linear: {x: ${formatNumber2(linearStep, 3)}}, angular: {z: 0.0}` },
-    { key: 88, twist: `linear: {x: ${formatNumber2(-linearStep, 3)}}, angular: {z: 0.0}` },
-    { key: 65, twist: `linear: {x: 0.0}, angular: {z: ${formatNumber2(angularStep, 3)}}` },
-    { key: 68, twist: `linear: {x: 0.0}, angular: {z: ${formatNumber2(-angularStep, 3)}}` },
-    { key: 81, twist: `linear: {x: ${formatNumber2(linearStep, 3)}}, angular: {z: ${formatNumber2(angularStep, 3)}}` },
-    { key: 69, twist: `linear: {x: ${formatNumber2(linearStep, 3)}}, angular: {z: ${formatNumber2(-angularStep, 3)}}` },
-    { key: 90, twist: `linear: {x: ${formatNumber2(-linearStep, 3)}}, angular: {z: ${formatNumber2(angularStep, 3)}}` },
-    { key: 67, twist: `linear: {x: ${formatNumber2(-linearStep, 3)}}, angular: {z: ${formatNumber2(-angularStep, 3)}}` },
+    { key: 87, twist: `linear: {x: ${formatNumber3(linearStep, 3)}}, angular: {z: 0.0}` },
+    { key: 88, twist: `linear: {x: ${formatNumber3(-linearStep, 3)}}, angular: {z: 0.0}` },
+    { key: 65, twist: `linear: {x: 0.0}, angular: {z: ${formatNumber3(angularStep, 3)}}` },
+    { key: 68, twist: `linear: {x: 0.0}, angular: {z: ${formatNumber3(-angularStep, 3)}}` },
+    { key: 81, twist: `linear: {x: ${formatNumber3(linearStep, 3)}}, angular: {z: ${formatNumber3(angularStep, 3)}}` },
+    { key: 69, twist: `linear: {x: ${formatNumber3(linearStep, 3)}}, angular: {z: ${formatNumber3(-angularStep, 3)}}` },
+    { key: 90, twist: `linear: {x: ${formatNumber3(-linearStep, 3)}}, angular: {z: ${formatNumber3(angularStep, 3)}}` },
+    { key: 67, twist: `linear: {x: ${formatNumber3(-linearStep, 3)}}, angular: {z: ${formatNumber3(-angularStep, 3)}}` },
     { key: 83, twist: "linear: {x: 0.0}, angular: {z: 0.0}" },
     { key: 32, twist: "linear: {x: 0.0}, angular: {z: 0.0}" }
   ];
@@ -20987,12 +21771,12 @@ ${keyboardGuiPluginXml()}` : "";
 function demoWorldXml(worldName, modelName, cmdVelTopic, world) {
   const spawnPose = world?.spawnPose ?? [0, 0, 120, 0, 0, 0];
   const spawnPoseText = [
-    formatNumber2(mmToM(spawnPose[0]), 6),
-    formatNumber2(mmToM(spawnPose[1]), 6),
-    formatNumber2(mmToM(spawnPose[2]), 6),
-    formatNumber2(degToRad(spawnPose[3]), 6),
-    formatNumber2(degToRad(spawnPose[4]), 6),
-    formatNumber2(degToRad(spawnPose[5]), 6)
+    formatNumber3(mmToM(spawnPose[0]), 6),
+    formatNumber3(mmToM(spawnPose[1]), 6),
+    formatNumber3(mmToM(spawnPose[2]), 6),
+    formatNumber3(degToRad(spawnPose[3]), 6),
+    formatNumber3(degToRad(spawnPose[4]), 6),
+    formatNumber3(degToRad(spawnPose[5]), 6)
   ].join(" ");
   const keyboardEnabled = world?.keyboardTeleop?.enabled ?? true;
   const linearStep = world?.keyboardTeleop?.linearStep ?? 0.9;
@@ -21162,28 +21946,28 @@ function modelXml(spec, modelName, linkNameMap, jointNameMap, geometries, linkWo
     const color = sRgbFloat(geometry.shapes[0]?.colorHex);
     const materialXml = color ? `
         <material>
-          <ambient>${formatNumber2(color[0], 3)} ${formatNumber2(color[1], 3)} ${formatNumber2(color[2], 3)} 1</ambient>
-          <diffuse>${formatNumber2(color[0], 3)} ${formatNumber2(color[1], 3)} ${formatNumber2(color[2], 3)} 1</diffuse>
+          <ambient>${formatNumber3(color[0], 3)} ${formatNumber3(color[1], 3)} ${formatNumber3(color[2], 3)} 1</ambient>
+          <diffuse>${formatNumber3(color[0], 3)} ${formatNumber3(color[1], 3)} ${formatNumber3(color[2], 3)} 1</diffuse>
         </material>` : "";
     return `    <link name="${escapeXml(sdfLinkName)}">
       <pose relative_to="__model__">${formatPose(worldPose)}</pose>
       <inertial>
         <pose>${formatPose(inertia.pose)}</pose>
-        <mass>${formatNumber2(massKg, 6)}</mass>
+        <mass>${formatNumber3(massKg, 6)}</mass>
         <inertia>
-          <ixx>${formatNumber2(inertia.ixx, 8)}</ixx>
-          <ixy>${formatNumber2(inertia.ixy, 8)}</ixy>
-          <ixz>${formatNumber2(inertia.ixz, 8)}</ixz>
-          <iyy>${formatNumber2(inertia.iyy, 8)}</iyy>
-          <iyz>${formatNumber2(inertia.iyz, 8)}</iyz>
-          <izz>${formatNumber2(inertia.izz, 8)}</izz>
+          <ixx>${formatNumber3(inertia.ixx, 8)}</ixx>
+          <ixy>${formatNumber3(inertia.ixy, 8)}</ixy>
+          <ixz>${formatNumber3(inertia.ixz, 8)}</ixz>
+          <iyy>${formatNumber3(inertia.iyy, 8)}</iyy>
+          <iyz>${formatNumber3(inertia.iyz, 8)}</iyz>
+          <izz>${formatNumber3(inertia.izz, 8)}</izz>
         </inertia>
       </inertial>
       <visual name="${escapeXml(sdfLinkName)}_visual">
         <geometry>
           <mesh>
             <uri>${escapeXml(meshPath)}</uri>
-            <scale>${formatNumber2(STL_SCALE_METERS, 6)} ${formatNumber2(STL_SCALE_METERS, 6)} ${formatNumber2(STL_SCALE_METERS, 6)}</scale>
+            <scale>${formatNumber3(STL_SCALE_METERS, 6)} ${formatNumber3(STL_SCALE_METERS, 6)} ${formatNumber3(STL_SCALE_METERS, 6)}</scale>
           </mesh>
         </geometry>${materialXml}
       </visual>${(() => {
@@ -21193,7 +21977,7 @@ function modelXml(spec, modelName, linkNameMap, jointNameMap, geometries, linkWo
         <geometry>
           <mesh>
             <uri>${escapeXml(meshPath)}</uri>
-            <scale>${formatNumber2(STL_SCALE_METERS, 6)} ${formatNumber2(STL_SCALE_METERS, 6)} ${formatNumber2(STL_SCALE_METERS, 6)}</scale>
+            <scale>${formatNumber3(STL_SCALE_METERS, 6)} ${formatNumber3(STL_SCALE_METERS, 6)} ${formatNumber3(STL_SCALE_METERS, 6)}</scale>
           </mesh>
         </geometry>
       </collision>`;
@@ -21205,7 +21989,7 @@ function modelXml(spec, modelName, linkNameMap, jointNameMap, geometries, linkWo
         <geometry>
           <mesh>
             <uri>${escapeXml(collisionMeshPath)}</uri>
-            <scale>${formatNumber2(STL_SCALE_METERS, 6)} ${formatNumber2(STL_SCALE_METERS, 6)} ${formatNumber2(STL_SCALE_METERS, 6)}</scale>
+            <scale>${formatNumber3(STL_SCALE_METERS, 6)} ${formatNumber3(STL_SCALE_METERS, 6)} ${formatNumber3(STL_SCALE_METERS, 6)}</scale>
           </mesh>
         </geometry>
       </collision>`;
@@ -21219,9 +22003,9 @@ function modelXml(spec, modelName, linkNameMap, jointNameMap, geometries, linkWo
         const bCz = mmToM((geometry.bboxMin[2] + geometry.bboxMax[2]) * 0.5);
         return `
       <collision name="${escapeXml(sdfLinkName)}_collision">
-        <pose>${formatNumber2(bCx, 6)} ${formatNumber2(bCy, 6)} ${formatNumber2(bCz, 6)} 0 0 0</pose>
+        <pose>${formatNumber3(bCx, 6)} ${formatNumber3(bCy, 6)} ${formatNumber3(bCz, 6)} 0 0 0</pose>
         <geometry>
-          <box><size>${formatNumber2(bDx, 6)} ${formatNumber2(bDy, 6)} ${formatNumber2(bDz, 6)}</size></box>
+          <box><size>${formatNumber3(bDx, 6)} ${formatNumber3(bDy, 6)} ${formatNumber3(bDz, 6)}</size></box>
         </geometry>
       </collision>`;
       }
@@ -21248,8 +22032,8 @@ function modelXml(spec, modelName, linkNameMap, jointNameMap, geometries, linkWo
       const leaderSdfName = jointNameMap.get(`${primary.joint}_joint`);
       mimicXml = `
         <mimic joint="${escapeXml(leaderSdfName)}">
-          <multiplier>${formatNumber2(primary.ratio, 6)}</multiplier>
-          <offset>${formatNumber2(coupling.offset, 6)}</offset>
+          <multiplier>${formatNumber3(primary.ratio, 6)}</multiplier>
+          <offset>${formatNumber3(coupling.offset, 6)}</offset>
         </mimic>`;
       if (coupling.terms.length > 1) {
         warnings.push(
@@ -21266,12 +22050,12 @@ function modelXml(spec, modelName, linkNameMap, jointNameMap, geometries, linkWo
         <limit>${limitLower !== null ? `
           <lower>${limitLower}</lower>` : ""}${limitUpper !== null ? `
           <upper>${limitUpper}</upper>` : ""}${effort !== void 0 ? `
-          <effort>${formatNumber2(effort, 6)}</effort>` : ""}${velocity !== null ? `
+          <effort>${formatNumber3(effort, 6)}</effort>` : ""}${velocity !== null ? `
           <velocity>${velocity}</velocity>` : ""}
         </limit>` : ""}${damping !== void 0 || friction !== void 0 ? `
         <dynamics>${damping !== void 0 ? `
-          <damping>${formatNumber2(damping, 6)}</damping>` : ""}${friction !== void 0 ? `
-          <friction>${formatNumber2(friction, 6)}</friction>` : ""}
+          <damping>${formatNumber3(damping, 6)}</damping>` : ""}${friction !== void 0 ? `
+          <friction>${formatNumber3(friction, 6)}</friction>` : ""}
         </dynamics>` : ""}
       </axis>` : ""}
     </joint>`;
@@ -21281,17 +22065,17 @@ function modelXml(spec, modelName, linkNameMap, jointNameMap, geometries, linkWo
     plugins.push(`    <plugin filename="gz-sim-diff-drive-system" name="gz::sim::systems::DiffDrive">
       ${spec.plugins.diffDrive.leftJoints.map((jointName) => `<left_joint>${escapeXml(jointNameMap.get(`${jointName}_joint`))}</left_joint>`).join("\n      ")}
       ${spec.plugins.diffDrive.rightJoints.map((jointName) => `<right_joint>${escapeXml(jointNameMap.get(`${jointName}_joint`))}</right_joint>`).join("\n      ")}
-      <wheel_separation>${formatNumber2(mmToM(spec.plugins.diffDrive.wheelSeparationMm), 6)}</wheel_separation>
-      <wheel_radius>${formatNumber2(mmToM(spec.plugins.diffDrive.wheelRadiusMm), 6)}</wheel_radius>
+      <wheel_separation>${formatNumber3(mmToM(spec.plugins.diffDrive.wheelSeparationMm), 6)}</wheel_separation>
+      <wheel_radius>${formatNumber3(mmToM(spec.plugins.diffDrive.wheelRadiusMm), 6)}</wheel_radius>
       <topic>${escapeXml(cmdVelTopic)}</topic>${spec.plugins.diffDrive.odomTopic ? `
       <odom_topic>${escapeXml(spec.plugins.diffDrive.odomTopic)}</odom_topic>` : ""}${spec.plugins.diffDrive.tfTopic ? `
       <tf_topic>${escapeXml(spec.plugins.diffDrive.tfTopic)}</tf_topic>` : ""}${spec.plugins.diffDrive.frameId ? `
       <frame_id>${escapeXml(spec.plugins.diffDrive.frameId)}</frame_id>` : ""}${spec.plugins.diffDrive.odomFrameId ? `
       <odom_frame>${escapeXml(spec.plugins.diffDrive.odomFrameId)}</odom_frame>` : ""}${spec.plugins.diffDrive.maxLinearVelocity !== void 0 ? `
-      <max_linear_velocity>${formatNumber2(spec.plugins.diffDrive.maxLinearVelocity, 6)}</max_linear_velocity>` : ""}${spec.plugins.diffDrive.maxAngularVelocity !== void 0 ? `
-      <max_angular_velocity>${formatNumber2(spec.plugins.diffDrive.maxAngularVelocity, 6)}</max_angular_velocity>` : ""}${spec.plugins.diffDrive.linearAcceleration !== void 0 ? `
-      <linear_acceleration>${formatNumber2(spec.plugins.diffDrive.linearAcceleration, 6)}</linear_acceleration>` : ""}${spec.plugins.diffDrive.angularAcceleration !== void 0 ? `
-      <angular_acceleration>${formatNumber2(spec.plugins.diffDrive.angularAcceleration, 6)}</angular_acceleration>` : ""}
+      <max_linear_velocity>${formatNumber3(spec.plugins.diffDrive.maxLinearVelocity, 6)}</max_linear_velocity>` : ""}${spec.plugins.diffDrive.maxAngularVelocity !== void 0 ? `
+      <max_angular_velocity>${formatNumber3(spec.plugins.diffDrive.maxAngularVelocity, 6)}</max_angular_velocity>` : ""}${spec.plugins.diffDrive.linearAcceleration !== void 0 ? `
+      <linear_acceleration>${formatNumber3(spec.plugins.diffDrive.linearAcceleration, 6)}</linear_acceleration>` : ""}${spec.plugins.diffDrive.angularAcceleration !== void 0 ? `
+      <angular_acceleration>${formatNumber3(spec.plugins.diffDrive.angularAcceleration, 6)}</angular_acceleration>` : ""}
     </plugin>`);
   }
   const jointState = spec.plugins.jointStatePublisher;
@@ -21301,7 +22085,7 @@ function modelXml(spec, modelName, linkNameMap, jointNameMap, geometries, linkWo
       (jointName) => `
       <joint_name>${escapeXml(jointNameMap.get(`${jointName}_joint`))}</joint_name>`
     ).join("")}${jointState?.updateRate !== void 0 ? `
-      <update_rate>${formatNumber2(jointState.updateRate, 6)}</update_rate>` : ""}
+      <update_rate>${formatNumber3(jointState.updateRate, 6)}</update_rate>` : ""}
     </plugin>`);
   }
   const rootNames = spec.assembly.parts.filter((part) => !spec.assembly.joints.some((joint2) => joint2.child === part.name)).map((part) => linkNameMap.get(part.name));
@@ -21513,7 +22297,7 @@ var FORWARDED_VALUE_OPTIONS = /* @__PURE__ */ new Set([
 ]);
 var FORWARDED_FLAG_OPTIONS = /* @__PURE__ */ new Set(["--fresh-server"]);
 var CAMERA_SOURCE_OPTIONS = /* @__PURE__ */ new Set(["--camera", "--camera-json", "--view", "--scene"]);
-function usage17() {
+function usage18() {
   return [
     "Usage: forgecad show <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [target] [output.png] [--from front|back|side|right|top|iso|az:el|az:el:dist] [--out output.png] [--param Key=Value] [--backend manifold|occt|truck] [render options]"
   ].join("\n");
@@ -21528,7 +22312,7 @@ function readValue6(argv, index, flag) {
 }
 function parseShowOptions(argv) {
   if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
-    console.log(usage17());
+    console.log(usage18());
     process.exit(0);
   }
   const consumed = /* @__PURE__ */ new Set();
@@ -21594,7 +22378,7 @@ async function runShowCli(argv = process.argv.slice(2)) {
     options = parseShowOptions(argv);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
-    console.error(usage17());
+    console.error(usage18());
     process.exit(1);
   }
   const renderArgs = [options.scriptPath];
@@ -22175,7 +22959,7 @@ function generateSketchPdf(meta, options) {
 }
 
 // cli/forge-sketch-pdf.ts
-function usage18() {
+function usage19() {
   console.error("Usage: forgecad export sketch-pdf <script.forge.js> [output.pdf]");
   process.exit(1);
 }
@@ -22184,7 +22968,7 @@ function defaultPdfOutput(scriptPath) {
 }
 async function runSketchPdfCli(argv = process.argv.slice(2)) {
   const scriptPath = argv[0];
-  if (!scriptPath) usage18();
+  if (!scriptPath) usage19();
   const outputPath = argv[1] || defaultPdfOutput(scriptPath);
   if (resolve28(outputPath) === resolve28(scriptPath)) {
     console.error(`ERROR: output path would overwrite the input script. Specify an explicit output path.`);
@@ -22217,7 +23001,7 @@ async function runSketchPdfCli(argv = process.argv.slice(2)) {
 }
 
 // cli/forge-skill.ts
-import { cpSync, existsSync as existsSync11, mkdirSync as mkdirSync4, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync3, writeFileSync as writeFileSync10 } from "fs";
+import { cpSync, existsSync as existsSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync3, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir6 } from "os";
 import { extname as extname9, join as join8, relative as relative5, resolve as resolve29 } from "path";
 var INSTALL_TARGETS = {
@@ -22230,7 +23014,7 @@ var ALL_INSTALL_TARGETS = Object.keys(INSTALL_TARGETS);
 var DEFAULT_INSTALL_TARGET = "agents";
 function installUsage() {
   return [
-    "Usage: forgecad skill install [--target agents|claude|codex|opencode|all] [--core-only] [--dev]",
+    "Usage: forgecad skill install [--target agents|claude|codex|opencode|all] [--core-only]",
     "Examples:",
     "  forgecad skill install",
     "  forgecad skill install --target claude",
@@ -22261,15 +23045,12 @@ function uniqueTargets(targets) {
   return [...new Set(targets)];
 }
 function parseInstallArgs(argv) {
-  let isDev = false;
   let coreOnly = false;
   let sawLibraryAlias = false;
   let targets = [DEFAULT_INSTALL_TARGET];
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
-    if (arg === "--dev") {
-      isDev = true;
-    } else if (arg === "--library" || arg === "--all") {
+    if (arg === "--library" || arg === "--all") {
       sawLibraryAlias = true;
     } else if (arg === "--core-only") {
       coreOnly = true;
@@ -22297,13 +23078,12 @@ ${installUsage()}`);
   if (coreOnly && sawLibraryAlias) {
     throw new Error("`--core-only` cannot be combined with `--library` or `--all`.");
   }
-  return { isDev, includeLibrary: !coreOnly, targets: uniqueTargets(targets) };
+  return { includeLibrary: !coreOnly, targets: uniqueTargets(targets) };
 }
-function installCoreSkill(isDev, targetRoot) {
-  const skillFile = isDev ? "SKILL-dev.md" : "SKILL.md";
-  const srcSkill = resolvePackagePath(import.meta.url, "dist-skill", skillFile);
-  const srcDocs = resolvePackagePath(import.meta.url, "dist-skill", isDev ? "docs-dev" : "docs");
-  if (!existsSync11(srcSkill)) {
+function installCoreSkill(targetRoot) {
+  const srcSkill = resolvePackagePath(import.meta.url, "dist-skill", "SKILL.md");
+  const srcDocs = resolvePackagePath(import.meta.url, "dist-skill", "docs");
+  if (!existsSync10(srcSkill)) {
     throw new Error(
       `Built skill file not found at ${srcSkill}.
 If you are running from a source checkout, run: npm run build:skill:forgecad`
@@ -22314,18 +23094,17 @@ If you are running from a source checkout, run: npm run build:skill:forgecad`
   mkdirSync4(destDir, { recursive: true });
   const skillContent = readFileSync15(srcSkill, "utf-8").replaceAll("{{SKILL_DIR}}", destDir);
   writeFileSync10(dest, skillContent);
-  if (existsSync11(srcDocs)) {
+  if (existsSync10(srcDocs)) {
     const destDocs = join8(destDir, "docs");
-    if (existsSync11(destDocs)) rmSync3(destDocs, { recursive: true });
+    if (existsSync10(destDocs)) rmSync3(destDocs, { recursive: true });
     cpSync(srcDocs, destDocs, { recursive: true });
   }
-  const mode = isDev ? "dev (includes internals, conventions, skill maintenance)" : "standard (model authoring)";
-  console.log(`ForgeCAD skill installed to ${dest} [${mode}]`);
+  console.log(`ForgeCAD skill installed to ${dest} [standard model authoring]`);
   return dest;
 }
 function installCompanionLibrary(targetRoot) {
   const srcLibrary = resolvePackagePath(import.meta.url, "dist-skill", "library");
-  if (!existsSync11(srcLibrary)) {
+  if (!existsSync10(srcLibrary)) {
     throw new Error(
       `Built companion skill library not found at ${srcLibrary}.
 If you are running from a source checkout, run: npm run build:skill:forgecad`
@@ -22353,7 +23132,7 @@ async function runSkillInstallCli(argv = []) {
   for (const target of options.targets) {
     const config = INSTALL_TARGETS[target];
     console.log(`Installing ForgeCAD skills for ${config.label} at ${config.root}`);
-    installCoreSkill(options.isDev, config.root);
+    installCoreSkill(config.root);
     if (options.includeLibrary) installCompanionLibrary(config.root);
   }
   console.log(`Reload your agent (Claude Code, Codex, OpenCode, \u2026) to activate.`);
@@ -22365,7 +23144,7 @@ async function runSkillOneFileCli(argv = []) {
 Example: forgecad skill one-file ~/Desktop/forgecad-context.md`);
   }
   const src = resolvePackagePath(import.meta.url, "dist-skill", "CONTEXT.md");
-  if (!existsSync11(src)) {
+  if (!existsSync10(src)) {
     throw new Error(
       `Built context file not found at ${src}.
 If you are running from a source checkout, run: npm run build:skill:forgecad`
@@ -22429,7 +23208,7 @@ function discoverFlattenedSkillSources() {
   const coreSkill = resolvePackagePath(import.meta.url, "dist-skill", "SKILL.md");
   const coreDocs = resolvePackagePath(import.meta.url, "dist-skill", "docs");
   const libraryRoot = resolvePackagePath(import.meta.url, "dist-skill", "library");
-  if (!existsSync11(coreSkill) || !existsSync11(coreDocs)) {
+  if (!existsSync10(coreSkill) || !existsSync10(coreDocs)) {
     throw new Error(
       `Built skill artifacts not found in ${resolvePackagePath(import.meta.url, "dist-skill")}.
 If you are running from a source checkout, run: npm run build:skill:forgecad`
@@ -22444,12 +23223,12 @@ If you are running from a source checkout, run: npm run build:skill:forgecad`
       ]
     }
   ];
-  if (existsSync11(libraryRoot)) {
+  if (existsSync10(libraryRoot)) {
     for (const entry of readdirSync6(libraryRoot, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       const root = join8(libraryRoot, entry.name);
       const skillFile = join8(root, "SKILL.md");
-      if (!existsSync11(skillFile)) continue;
+      if (!existsSync10(skillFile)) continue;
       sources.push({ name: entry.name, files: findSkillFiles(root) });
     }
   }
@@ -22485,19 +23264,113 @@ import { existsSync as existsSync14 } from "fs";
 import { resolve as resolve30 } from "path";
 
 // cli/forge-studio-server.ts
-import { fork as fork2 } from "child_process";
 import chokidar from "chokidar";
 import fs from "fs";
 import http from "http";
 import path2 from "path";
 
+// server/importAnalysis.ts
+var FORGE_IMPORT_RE2 = /\b(?:importMesh|importStep|importSvgSketch|Import\.dxfSketch)\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
+var REQUIRE_RE2 = /\brequire\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
+var ES_IMPORT_RE2 = /\bfrom\s+(?:"([^"]+)"|'([^']+)')/g;
+var VIRTUAL_MODULES2 = /* @__PURE__ */ new Set(["forgecad", "@forge/runtime", "@forgecad/runtime"]);
+function extractImports2(code) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add2 = (raw, kind) => {
+    if (!seen.has(raw) && !VIRTUAL_MODULES2.has(raw)) {
+      seen.add(raw);
+      refs.push({ raw, kind });
+    }
+  };
+  const kindMap = {
+    importMesh: "forgeMesh",
+    importStep: "forgeMesh",
+    importSvgSketch: "forgeSvg",
+    "Import.dxfSketch": "forgeDxf"
+  };
+  let m;
+  const forgeRe = new RegExp(FORGE_IMPORT_RE2.source, FORGE_IMPORT_RE2.flags);
+  while ((m = forgeRe.exec(code)) !== null) {
+    const path3 = m[1] ?? m[2];
+    const fn = m[0].match(/\b(importMesh|importStep|importSvgSketch|Import\.dxfSketch)/)?.[1];
+    add2(path3, kindMap[fn] ?? "forgeMesh");
+  }
+  const reqRe = new RegExp(REQUIRE_RE2.source, REQUIRE_RE2.flags);
+  while ((m = reqRe.exec(code)) !== null) {
+    const path3 = m[1] ?? m[2];
+    add2(path3, "require");
+  }
+  const esRe = new RegExp(ES_IMPORT_RE2.source, ES_IMPORT_RE2.flags);
+  while ((m = esRe.exec(code)) !== null) {
+    const path3 = m[1] ?? m[2];
+    add2(path3, "esImport");
+  }
+  return refs;
+}
+function resolveRelative2(fromFile, importPath) {
+  if (!importPath.startsWith("./") && !importPath.startsWith("../")) {
+    return importPath;
+  }
+  const fromDir = fromFile.includes("/") ? fromFile.slice(0, fromFile.lastIndexOf("/")) : "";
+  const combined = fromDir ? `${fromDir}/${importPath}` : importPath;
+  const parts = combined.split("/");
+  const resolved = [];
+  for (const part of parts) {
+    if (part === "." || part === "") continue;
+    if (part === "..") {
+      if (resolved.length > 0 && resolved[resolved.length - 1] !== "..") {
+        resolved.pop();
+      } else {
+        resolved.push("..");
+      }
+    } else {
+      resolved.push(part);
+    }
+  }
+  return resolved.join("/");
+}
+function collectDependencyFiles(entryFile, allFiles) {
+  const result = {};
+  const visited = /* @__PURE__ */ new Set();
+  function visit(fileName) {
+    if (visited.has(fileName)) return;
+    visited.add(fileName);
+    const code = allFiles[fileName];
+    if (code == null) return;
+    result[fileName] = code;
+    const imports = extractImports2(code);
+    for (const imp of imports) {
+      const resolved = resolveRelative2(fileName, imp.raw);
+      if (imp.kind === "forgeMesh") continue;
+      if (imp.kind === "forgeSvg") {
+        if (allFiles[resolved] != null) {
+          result[resolved] = allFiles[resolved];
+        }
+        continue;
+      }
+      if (imp.kind === "forgeDxf") {
+        if (allFiles[resolved] != null) {
+          result[resolved] = allFiles[resolved];
+        }
+        continue;
+      }
+      if (allFiles[resolved] != null) {
+        visit(resolved);
+      }
+    }
+  }
+  visit(entryFile);
+  return result;
+}
+
 // cli/project.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync17, readdirSync as readdirSync7, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync17, readdirSync as readdirSync7, writeFileSync as writeFileSync12 } from "fs";
 import { join as join10 } from "path";
 
 // cli/auth.ts
-import { chmodSync, existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync16, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
+import { chmodSync, existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync16, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join9 } from "path";
 import { createInterface } from "readline";
@@ -22584,7 +23457,7 @@ function forgecadDir() {
 }
 function ensureDir() {
   const dir = forgecadDir();
-  if (!existsSync12(dir)) mkdirSync5(dir, { recursive: true, mode: 448 });
+  if (!existsSync11(dir)) mkdirSync5(dir, { recursive: true, mode: 448 });
   try {
     chmodSync(dir, 448);
   } catch {
@@ -22595,7 +23468,7 @@ function authFilePath() {
 }
 function readStoredAuth() {
   const p = authFilePath();
-  if (!existsSync12(p)) return null;
+  if (!existsSync11(p)) return null;
   try {
     const auth = JSON.parse(readFileSync16(p, "utf-8"));
     return { ...auth, server: normalizeServerUrl(auth.server, "Stored ForgeCAD server URL") };
@@ -22614,7 +23487,7 @@ function writeStoredAuth(auth) {
 }
 function clearStoredAuth() {
   const p = authFilePath();
-  if (existsSync12(p)) unlinkSync(p);
+  if (existsSync11(p)) unlinkSync(p);
 }
 function getServerUrl() {
   if (process.env.FORGECAD_TOKEN) {
@@ -22918,7 +23791,7 @@ function manifestPath(projectDir) {
 }
 function readManifest(projectDir) {
   const p = manifestPath(projectDir);
-  if (!existsSync13(p)) return null;
+  if (!existsSync12(p)) return null;
   try {
     return JSON.parse(readFileSync17(p, "utf-8"));
   } catch {
@@ -23164,99 +24037,164 @@ async function deleteShare(shareId) {
   }
 }
 
-// server/importAnalysis.ts
-var FORGE_IMPORT_RE2 = /\b(?:importMesh|importStep|importSvgSketch|Import\.dxfSketch)\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
-var REQUIRE_RE2 = /\brequire\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
-var ES_IMPORT_RE2 = /\bfrom\s+(?:"([^"]+)"|'([^']+)')/g;
-var VIRTUAL_MODULES2 = /* @__PURE__ */ new Set(["forgecad", "@forge/runtime", "@forgecad/runtime"]);
-function extractImports2(code) {
-  const refs = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add2 = (raw, kind) => {
-    if (!seen.has(raw) && !VIRTUAL_MODULES2.has(raw)) {
-      seen.add(raw);
-      refs.push({ raw, kind });
-    }
-  };
-  const kindMap = {
-    importMesh: "forgeMesh",
-    importStep: "forgeMesh",
-    importSvgSketch: "forgeSvg",
-    "Import.dxfSketch": "forgeDxf"
-  };
-  let m;
-  const forgeRe = new RegExp(FORGE_IMPORT_RE2.source, FORGE_IMPORT_RE2.flags);
-  while ((m = forgeRe.exec(code)) !== null) {
-    const path3 = m[1] ?? m[2];
-    const fn = m[0].match(/\b(importMesh|importStep|importSvgSketch|Import\.dxfSketch)/)?.[1];
-    add2(path3, kindMap[fn] ?? "forgeMesh");
-  }
-  const reqRe = new RegExp(REQUIRE_RE2.source, REQUIRE_RE2.flags);
-  while ((m = reqRe.exec(code)) !== null) {
-    const path3 = m[1] ?? m[2];
-    add2(path3, "require");
-  }
-  const esRe = new RegExp(ES_IMPORT_RE2.source, ES_IMPORT_RE2.flags);
-  while ((m = esRe.exec(code)) !== null) {
-    const path3 = m[1] ?? m[2];
-    add2(path3, "esImport");
+// cli/local-native-compute.ts
+import { spawn as spawn3, execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync13, readdirSync as readdirSync8, statSync as statSync8 } from "fs";
+import { createServer as createServer2 } from "net";
+import { join as join11 } from "path";
+var startedComputeServer = null;
+var REQUIRED_ENGINE_VERSION = "native-occt-node-api-0.2.0";
+var REQUIRED_PLAN_KINDS = [
+  "box",
+  "cylinder",
+  "sphere",
+  "torus",
+  "extrude",
+  "boolean",
+  "transform",
+  "queryOwner",
+  "revolve",
+  "loft",
+  "sweep",
+  "nurbsSurface",
+  "filletEdges",
+  "chamferEdges"
+];
+function npmCommand() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function isLocalComputeUrl(url) {
+  return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+}
+async function isHealthy(computeUrl) {
+  try {
+    const response = await fetch(`${computeUrl}/health`, { signal: AbortSignal.timeout(1e3) });
+    if (!response.ok) return false;
+    const body = await response.json().catch(() => null);
+    if (body?.status !== "ok" || body?.nativeOcctAvailable !== true || body?.engineVersion !== REQUIRED_ENGINE_VERSION) return false;
+    const capabilitiesResponse = await fetch(`${computeUrl}/capabilities`, { signal: AbortSignal.timeout(1e3) });
+    if (!capabilitiesResponse.ok) return false;
+    const capabilities = await capabilitiesResponse.json().catch(() => null);
+    const supportedKinds = capabilities?.nativeOcct?.supportedPlanKinds;
+    return Array.isArray(supportedKinds) && REQUIRED_PLAN_KINDS.every((kind) => supportedKinds.includes(kind));
+  } catch {
+    return false;
   }
-  return refs;
 }
-function resolveRelative2(fromFile, importPath) {
-  if (!importPath.startsWith("./") && !importPath.startsWith("../")) {
-    return importPath;
+async function waitForHealthy(computeUrl, child) {
+  for (let attempt = 0; attempt < 120; attempt += 1) {
+    if (await isHealthy(computeUrl)) return;
+    if (child.exitCode != null) break;
+    await new Promise((resolve40) => setTimeout(resolve40, 50));
   }
-  const fromDir = fromFile.includes("/") ? fromFile.slice(0, fromFile.lastIndexOf("/")) : "";
-  const combined = fromDir ? `${fromDir}/${importPath}` : importPath;
-  const parts = combined.split("/");
-  const resolved = [];
-  for (const part of parts) {
-    if (part === "." || part === "") continue;
-    if (part === "..") {
-      if (resolved.length > 0 && resolved[resolved.length - 1] !== "..") {
-        resolved.pop();
-      } else {
-        resolved.push("..");
-      }
-    } else {
-      resolved.push(part);
+  throw new Error(`Native OCCT compute backend did not become healthy at ${computeUrl}.`);
+}
+function closeChild(child) {
+  return new Promise((resolve40) => {
+    if (child.exitCode != null || child.killed) {
+      resolve40();
+      return;
     }
-  }
-  return resolved.join("/");
+    child.once("exit", () => resolve40());
+    child.kill();
+  });
 }
-function collectDependencyFiles(entryFile, allFiles) {
-  const result = {};
-  const visited = /* @__PURE__ */ new Set();
-  function visit(fileName) {
-    if (visited.has(fileName)) return;
-    visited.add(fileName);
-    const code = allFiles[fileName];
-    if (code == null) return;
-    result[fileName] = code;
-    const imports = extractImports2(code);
-    for (const imp of imports) {
-      const resolved = resolveRelative2(fileName, imp.raw);
-      if (imp.kind === "forgeMesh") continue;
-      if (imp.kind === "forgeSvg") {
-        if (allFiles[resolved] != null) {
-          result[resolved] = allFiles[resolved];
-        }
-        continue;
-      }
-      if (imp.kind === "forgeDxf") {
-        if (allFiles[resolved] != null) {
-          result[resolved] = allFiles[resolved];
-        }
-        continue;
-      }
-      if (allFiles[resolved] != null) {
-        visit(resolved);
-      }
+function hasLocalNativeComputeSource(packageRoot) {
+  return existsSync13(join11(packageRoot, "apps/backend/src/server.ts")) && existsSync13(join11(packageRoot, "scripts/build-native-occt.mjs"));
+}
+function newestMtimeMs(path3) {
+  if (!existsSync13(path3)) return 0;
+  const stat = statSync8(path3);
+  if (!stat.isDirectory()) return stat.mtimeMs;
+  let newest = stat.mtimeMs;
+  for (const entry of readdirSync8(path3, { withFileTypes: true })) {
+    newest = Math.max(newest, newestMtimeMs(join11(path3, entry.name)));
+  }
+  return newest;
+}
+function isNativeAddonStale(packageRoot, addonPath) {
+  if (!existsSync13(addonPath)) return true;
+  const addonMtime = statSync8(addonPath).mtimeMs;
+  const sourceMtime = Math.max(
+    newestMtimeMs(join11(packageRoot, "native/occt-ir/src")),
+    newestMtimeMs(join11(packageRoot, "native/occt-ir/CMakeLists.txt")),
+    newestMtimeMs(join11(packageRoot, "scripts/build-native-occt.mjs"))
+  );
+  return sourceMtime > addonMtime;
+}
+function computeUrlWithPort(url, port) {
+  const next = new URL(url.toString());
+  next.port = String(port);
+  return next.toString().replace(/\/$/, "");
+}
+async function pickComputeUrl(preferred) {
+  const preferredPort = Number.parseInt(preferred.port || (preferred.protocol === "https:" ? "443" : "80"), 10);
+  for (let port = preferredPort; port < preferredPort + 10; port += 1) {
+    const candidate = computeUrlWithPort(preferred, port);
+    if (await isHealthy(candidate)) return candidate;
+    try {
+      const server = await new Promise((resolve40, reject) => {
+        const probe = createServer2();
+        probe.once("error", reject);
+        probe.listen(port, preferred.hostname, () => resolve40(probe));
+      });
+      await new Promise((resolve40) => server.close(() => resolve40()));
+      return candidate;
+    } catch {
     }
   }
-  visit(entryFile);
-  return result;
+  throw new Error(`No local port available for native OCCT compute near ${preferred.href}.`);
+}
+function startLocalNativeComputeServer(options) {
+  if (startedComputeServer) return startedComputeServer;
+  const startPromise = (async () => {
+    const requestedComputeUrl = options.computeUrl ?? "http://127.0.0.1:4510";
+    if (options.enabled === false) {
+      return { url: requestedComputeUrl, spawned: false, close: async () => {
+      } };
+    }
+    const parsed = new URL(requestedComputeUrl);
+    if (!isLocalComputeUrl(parsed)) {
+      return { url: requestedComputeUrl, spawned: false, close: async () => {
+      } };
+    }
+    if (!hasLocalNativeComputeSource(options.packageRoot)) {
+      return { url: requestedComputeUrl, spawned: false, close: async () => {
+      } };
+    }
+    if (await isHealthy(requestedComputeUrl)) {
+      return { url: requestedComputeUrl, spawned: false, close: async () => {
+      } };
+    }
+    const addonPath = join11(options.packageRoot, "native/occt-ir/build/forgecad_occt.node");
+    if (isNativeAddonStale(options.packageRoot, addonPath)) {
+      console.log("[compute] Native OCCT addon missing or stale; building...");
+      execFileSync2(npmCommand(), ["run", "build:native-occt"], {
+        cwd: options.packageRoot,
+        stdio: "inherit"
+      });
+    }
+    const computeUrl = await pickComputeUrl(parsed);
+    const selected = new URL(computeUrl);
+    const port = selected.port || (selected.protocol === "https:" ? "443" : "80");
+    console.log(`[compute] Starting native OCCT backend at ${computeUrl}`);
+    const child = spawn3("npx", ["tsx", "apps/backend/src/server.ts"], {
+      cwd: options.packageRoot,
+      env: { ...process.env, FORGE_BACKEND_PORT: port },
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    await waitForHealthy(computeUrl, child);
+    return {
+      url: computeUrl,
+      spawned: true,
+      close: () => closeChild(child)
+    };
+  })();
+  startedComputeServer = startPromise.catch((error) => {
+    startedComputeServer = null;
+    throw error;
+  });
+  return startedComputeServer;
 }
 
 // cli/forge-studio-server.ts
@@ -23396,6 +24334,28 @@ function resolveProjectFile(projectDir, filename, opts = {}) {
   }
   return { filePath, filename: rel.replace(/\\/g, "/") };
 }
+function resolveProjectDirectory(projectDir, dirPath) {
+  if (!projectDir) throw new Error("No project directory");
+  if (!dirPath) throw new Error("Invalid directory path");
+  const abs = path2.resolve(projectDir);
+  const resolved = path2.resolve(abs, dirPath);
+  const rel = path2.relative(abs, resolved);
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+    throw new Error(`Path "${dirPath}" is outside the project root`);
+  }
+  return { dirPath: resolved, dirname: rel.replace(/\\/g, "/") };
+}
+function directoryTreeContainsFile(dirPath) {
+  for (const item of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const childPath2 = path2.join(dirPath, item.name);
+    if (item.isDirectory()) {
+      if (directoryTreeContainsFile(childPath2)) return true;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
 function serveStatic(distDir, req, res) {
   const absDistDir = path2.resolve(distDir);
   const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
@@ -23419,67 +24379,6 @@ function serveStatic(distDir, req, res) {
   res.end(content);
   return true;
 }
-var BACKEND_PORT = 4510;
-var BACKEND_URL = `http://127.0.0.1:${BACKEND_PORT}`;
-function spawnBackendServer2(packageRoot) {
-  const backendEntry = path2.join(packageRoot, "dist-backend", "server.js");
-  if (!fs.existsSync(backendEntry)) {
-    console.log("  Backend compute server not found (dist-backend/server.js) \u2014 server rendering disabled");
-    return null;
-  }
-  const child = fork2(backendEntry, {
-    stdio: ["ignore", "pipe", "pipe", "ipc"],
-    env: { ...process.env, FORGE_BACKEND_PORT: String(BACKEND_PORT) }
-  });
-  child.stdout?.on("data", (data) => {
-    for (const line of data.toString().trim().split("\n")) {
-      console.log(`  [backend] ${line}`);
-    }
-  });
-  child.stderr?.on("data", (data) => {
-    for (const line of data.toString().trim().split("\n")) {
-      console.error(`  [backend] ${line}`);
-    }
-  });
-  child.on("exit", (code) => {
-    if (code !== null && code !== 0) {
-      console.error(`  [backend] Compute server exited with code ${code}`);
-    }
-  });
-  return child;
-}
-async function proxyToBackend(req, res, backendPath, method) {
-  const abortController = new AbortController();
-  res.on("close", () => abortController.abort());
-  try {
-    const body = method === "POST" ? await readRawBody(req) : void 0;
-    const backendRes = await fetch(`${BACKEND_URL}${backendPath}`, {
-      method,
-      headers: body ? { "Content-Type": "application/json" } : void 0,
-      body,
-      signal: abortController.signal
-    });
-    if (abortController.signal.aborted) return false;
-    res.writeHead(backendRes.status, {
-      "Content-Type": backendRes.headers.get("Content-Type") ?? "application/octet-stream"
-    });
-    const buffer = Buffer.from(await backendRes.arrayBuffer());
-    res.end(buffer);
-    return true;
-  } catch {
-    if (abortController.signal.aborted) return false;
-    sendJson(res, 503, { status: "unavailable" });
-    return false;
-  }
-}
-function readRawBody(req) {
-  return new Promise((resolve40, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve40(Buffer.concat(chunks).toString("utf-8")));
-    req.on("error", reject);
-  });
-}
 function isPortAvailable(port, host) {
   return new Promise((resolve40) => {
     const s = http.createServer();
@@ -23528,9 +24427,19 @@ function matchSSERoute(url, suffix) {
 }
 async function startStudioServer(options) {
   const { projectDirs, distDir, packageRoot, open, strictPort } = options;
-  const backendProcess = spawnBackendServer2(packageRoot);
   const host = options.host || "127.0.0.1";
   const port = await pickPort(options.port || 5173, host, strictPort);
+  const computeUrl = process.env.FORGE_COMPUTE_URL ?? "http://127.0.0.1:4510";
+  const computeServer = await startLocalNativeComputeServer({
+    packageRoot,
+    computeUrl,
+    enabled: process.env.FORGE_AUTO_START_COMPUTE !== "false"
+  }).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[compute] Native OCCT backend unavailable: ${message}`);
+    return null;
+  });
+  const activeComputeUrl = computeServer?.url ?? computeUrl;
   const projects = buildProjectRegistry(projectDirs);
   const projectById = new Map(projects.map((p) => [p.id, p]));
   function lookupProject(projectId) {
@@ -23553,6 +24462,18 @@ data: ${JSON.stringify(data)}
     }
   }
   const watchers = [];
+  const snapshotTimers = /* @__PURE__ */ new Map();
+  function broadcastProjectSnapshot(project) {
+    const existing = snapshotTimers.get(project.id);
+    if (existing) clearTimeout(existing);
+    snapshotTimers.set(
+      project.id,
+      setTimeout(() => {
+        snapshotTimers.delete(project.id);
+        broadcastToProject(project.id, "snapshot", {});
+      }, 50)
+    );
+  }
   for (const proj of projects) {
     const abs = path2.resolve(proj.dir);
     const watcher = chokidar.watch(abs, { ignoreInitial: true, ignored: /(^|[/\\])\../ });
@@ -23581,7 +24502,10 @@ data: ${JSON.stringify(data)}
     watcher.on("unlink", (f2) => {
       if (!isProjectFile(f2) && !isBinaryProjectFile(f2)) return;
       broadcastToProject(proj.id, "delete", { filename: path2.relative(abs, f2).replace(/\\/g, "/") });
+      broadcastProjectSnapshot(proj);
     });
+    watcher.on("addDir", () => broadcastProjectSnapshot(proj));
+    watcher.on("unlinkDir", () => broadcastProjectSnapshot(proj));
     watchers.push(watcher);
   }
   const server = http.createServer(async (req, res) => {
@@ -23591,6 +24515,79 @@ data: ${JSON.stringify(data)}
       sendJson(res, 200, { status: "ok", mode: "local", uptime: process.uptime() });
       return;
     }
+    if (method === "GET" && url2 === "/api/compute/health") {
+      try {
+        const response = await fetch(`${activeComputeUrl}/health`, { signal: AbortSignal.timeout(2e3) });
+        if (!response.ok) {
+          sendJson(res, 200, { status: "unavailable" });
+          return;
+        }
+        const body = await response.json();
+        sendJson(res, 200, { status: body?.status === "ok" ? "ok" : "unavailable" });
+      } catch {
+        sendJson(res, 200, { status: "unavailable" });
+      }
+      return;
+    }
+    if (method === "GET" && url2 === "/api/compute/capabilities") {
+      try {
+        const response = await fetch(`${activeComputeUrl}/capabilities`, { signal: AbortSignal.timeout(5e3) });
+        const body = await response.json().catch(() => ({ error: `Compute server returned ${response.status}` }));
+        sendJson(res, response.status, body);
+      } catch {
+        sendJson(res, 502, { error: "Backend compute server unreachable" });
+      }
+      return;
+    }
+    if (method === "GET" && url2.startsWith("/api/compute/jobs")) {
+      try {
+        const response = await fetch(`${activeComputeUrl}${url2.replace("/api", "")}`, { signal: AbortSignal.timeout(5e3) });
+        const body = await response.json().catch(() => ({ error: `Compute server returned ${response.status}` }));
+        sendJson(res, response.status, body);
+      } catch {
+        sendJson(res, 502, { error: "Backend compute server unreachable" });
+      }
+      return;
+    }
+    if (method === "POST" && /^\/api\/compute\/jobs\/[^/]+\/cancel$/.test(url2)) {
+      try {
+        const response = await fetch(`${activeComputeUrl}${url2.replace("/api", "")}`, {
+          method: "POST",
+          signal: AbortSignal.timeout(5e3)
+        });
+        const body = await response.json().catch(() => ({ error: `Compute server returned ${response.status}` }));
+        sendJson(res, response.status, body);
+      } catch {
+        sendJson(res, 502, { error: "Backend compute server unreachable" });
+      }
+      return;
+    }
+    if (method === "POST" && url2 === "/api/compute/ir") {
+      const abortController = new AbortController();
+      res.on("close", () => abortController.abort());
+      try {
+        const body = await readJsonBody(req);
+        const response = await fetch(`${activeComputeUrl}/compute/ir`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: abortController.signal
+        });
+        if (abortController.signal.aborted) return;
+        if (!response.ok) {
+          const errBody = await response.json().catch(() => ({ error: `Compute server returned ${response.status}` }));
+          sendJson(res, response.status, errBody);
+          return;
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        res.writeHead(200, { "Content-Type": "application/octet-stream", "Content-Length": buffer.byteLength });
+        res.end(buffer);
+      } catch {
+        if (abortController.signal.aborted) return;
+        sendJson(res, 502, { error: "Backend compute server unreachable" });
+      }
+      return;
+    }
     if (method === "GET" && url2.split("?")[0] === "/api/projects") {
       sendJson(res, 200, {
         projects: projects.map((p) => ({
@@ -23823,6 +24820,49 @@ data: ${JSON.stringify(data)}
         return;
       }
     }
+    {
+      const m = matchProjectRoute(url2, method, "POST", "/rmdir");
+      if (m) {
+        const proj = lookupProject(m.projectId);
+        if (!proj) {
+          sendJson(res, 404, { error: "Project not found" });
+          return;
+        }
+        readJsonBody(req).then((body) => {
+          const { dirPath } = body;
+          if (!dirPath || typeof dirPath !== "string") {
+            sendJson(res, 400, { error: "Invalid request" });
+            return;
+          }
+          let resolved;
+          try {
+            resolved = resolveProjectDirectory(proj.dir, dirPath);
+          } catch (e) {
+            sendJson(res, 400, { error: e.message });
+            return;
+          }
+          if (!resolved.dirname) {
+            sendJson(res, 400, { error: "Cannot delete project root" });
+            return;
+          }
+          if (!fs.existsSync(resolved.dirPath)) {
+            sendJson(res, 200, { success: true });
+            return;
+          }
+          if (!fs.statSync(resolved.dirPath).isDirectory()) {
+            sendJson(res, 400, { error: "Path is not a directory" });
+            return;
+          }
+          if (directoryTreeContainsFile(resolved.dirPath)) {
+            sendJson(res, 409, { error: "Directory is not empty" });
+            return;
+          }
+          fs.rmSync(resolved.dirPath, { recursive: true, force: true });
+          sendJson(res, 200, { success: true });
+        }).catch((e) => sendJson(res, 500, { error: e.message }));
+        return;
+      }
+    }
     {
       const m = matchProjectRoute(url2, method, "POST", "/move");
       if (m) {
@@ -23975,14 +25015,6 @@ data: ${JSON.stringify(data)}
       }
       return;
     }
-    if (method === "GET" && url2 === "/api/compute/health") {
-      await proxyToBackend(req, res, "/health", "GET");
-      return;
-    }
-    if (method === "POST" && url2 === "/api/compute") {
-      await proxyToBackend(req, res, "/compute", "POST");
-      return;
-    }
     if (!serveStatic(distDir, req, res)) {
       res.statusCode = 404;
       res.end("Not found");
@@ -23992,27 +25024,29 @@ data: ${JSON.stringify(data)}
   const displayHost = host === "0.0.0.0" ? "localhost" : host;
   const url = `http://${displayHost}:${port}`;
   if (open) openBrowser(url);
-  const close4 = () => new Promise((resolve40) => {
-    for (const w of watchers) w.close();
-    if (backendProcess && !backendProcess.killed) {
-      backendProcess.kill();
-    }
-    for (const clients of sseClients.values()) {
-      for (const c of clients) {
-        try {
-          c.end();
-        } catch {
+  const close4 = async () => {
+    await new Promise((resolve40) => {
+      for (const timer of snapshotTimers.values()) clearTimeout(timer);
+      snapshotTimers.clear();
+      for (const w of watchers) w.close();
+      for (const clients of sseClients.values()) {
+        for (const c of clients) {
+          try {
+            c.end();
+          } catch {
+          }
         }
       }
-    }
-    sseClients.clear();
-    server.close(() => resolve40());
-  });
+      sseClients.clear();
+      server.close(() => resolve40());
+    });
+    await computeServer?.close();
+  };
   return { url, close: close4 };
 }
 
 // cli/forge-studio.ts
-function usage19() {
+function usage20() {
   console.error(`ForgeCAD Studio
 
 Usage:
@@ -24042,7 +25076,7 @@ function parseStudioArgs(argv) {
   if (argv.length === 0) {
     throw new Error("Missing project path. Use `forgecad studio <project-path> [project-path ...]`.");
   }
-  if (argv.includes("-h") || argv.includes("--help")) usage19();
+  if (argv.includes("-h") || argv.includes("--help")) usage20();
   const options = { open: false, strictPort: false, projectPaths: [] };
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -24117,7 +25151,7 @@ async function runStudioCli(argv = process.argv.slice(2)) {
 // cli/forge-svg.ts
 import { readFile as readFile5, writeFile as writeFile8 } from "fs/promises";
 import { basename as basename13, resolve as resolve31 } from "path";
-function usage20() {
+function usage21() {
   console.error("Usage: forgecad export svg <script.forge.js> [output.svg]");
   process.exit(1);
 }
@@ -24126,7 +25160,7 @@ function defaultSvgOutput(scriptPath) {
 }
 async function runSvgCli(argv = process.argv.slice(2)) {
   const scriptPath = argv[0];
-  if (!scriptPath) usage20();
+  if (!scriptPath) usage21();
   const outputPath = argv[1] || defaultSvgOutput(scriptPath);
   if (resolve31(outputPath) === resolve31(scriptPath)) {
     console.error(`ERROR: output path would overwrite the input script. Specify an explicit output path.`);
@@ -24194,7 +25228,7 @@ function mmToM2(valueMm) {
 function degToRad2(valueDeg) {
   return valueDeg * Math.PI / 180;
 }
-function formatNumber3(value, digits = 6) {
+function formatNumber4(value, digits = 6) {
   if (!Number.isFinite(value)) return "0";
   const normalized = Math.abs(value) < 1e-12 ? 0 : value;
   return normalized.toFixed(digits).replace(/\.?0+$/, "");
@@ -24317,7 +25351,7 @@ function transformToOrigin(transform) {
     yaw = Math.atan2(r10, r00);
   }
   const x = mmToM2(m[12]), y = mmToM2(m[13]), z = mmToM2(m[14]);
-  return `xyz="${formatNumber3(x)} ${formatNumber3(y)} ${formatNumber3(z)}" rpy="${formatNumber3(roll)} ${formatNumber3(pitch)} ${formatNumber3(yaw)}"`;
+  return `xyz="${formatNumber4(x)} ${formatNumber4(y)} ${formatNumber4(z)}" rpy="${formatNumber4(roll)} ${formatNumber4(pitch)} ${formatNumber4(yaw)}"`;
 }
 function sRgbFloat2(hex) {
   if (!hex || !/^#([0-9a-f]{6})$/i.test(hex)) return null;
@@ -24378,7 +25412,7 @@ function urdfXml(spec, modelName, linkNameMap, jointNameMap, geometries, _linkWo
     const color = sRgbFloat2(geometry.shapes[0]?.colorHex);
     const materialXml = color ? `
         <material name="${escapeXml2(urdfLinkName)}_material">
-          <color rgba="${formatNumber3(color[0], 3)} ${formatNumber3(color[1], 3)} ${formatNumber3(color[2], 3)} 1"/>
+          <color rgba="${formatNumber4(color[0], 3)} ${formatNumber4(color[1], 3)} ${formatNumber4(color[2], 3)} 1"/>
         </material>` : "";
     let collisionXml = "";
     if (collisionMode === "visual") {
@@ -24407,17 +25441,17 @@ function urdfXml(spec, modelName, linkNameMap, jointNameMap, geometries, _linkWo
       const bCz = mmToM2((geometry.bboxMin[2] + geometry.bboxMax[2]) * 0.5);
       collisionXml = `
     <collision>
-      <origin xyz="${formatNumber3(bCx)} ${formatNumber3(bCy)} ${formatNumber3(bCz)}" rpy="0 0 0"/>
+      <origin xyz="${formatNumber4(bCx)} ${formatNumber4(bCy)} ${formatNumber4(bCz)}" rpy="0 0 0"/>
       <geometry>
-        <box size="${formatNumber3(bDx)} ${formatNumber3(bDy)} ${formatNumber3(bDz)}"/>
+        <box size="${formatNumber4(bDx)} ${formatNumber4(bDy)} ${formatNumber4(bDz)}"/>
       </geometry>
     </collision>`;
     }
     return `  <link name="${escapeXml2(urdfLinkName)}">
     <inertial>
-      <origin xyz="${formatNumber3(comX)} ${formatNumber3(comY)} ${formatNumber3(comZ)}" rpy="0 0 0"/>
-      <mass value="${formatNumber3(massKg, 6)}"/>
-      <inertia ixx="${formatNumber3(ixx, 8)}" ixy="${formatNumber3(ixy, 8)}" ixz="${formatNumber3(ixz, 8)}" iyy="${formatNumber3(iyy, 8)}" iyz="${formatNumber3(iyz, 8)}" izz="${formatNumber3(izz, 8)}"/>
+      <origin xyz="${formatNumber4(comX)} ${formatNumber4(comY)} ${formatNumber4(comZ)}" rpy="0 0 0"/>
+      <mass value="${formatNumber4(massKg, 6)}"/>
+      <inertia ixx="${formatNumber4(ixx, 8)}" ixy="${formatNumber4(ixy, 8)}" ixz="${formatNumber4(ixz, 8)}" iyy="${formatNumber4(iyy, 8)}" iyz="${formatNumber4(iyz, 8)}" izz="${formatNumber4(izz, 8)}"/>
     </inertial>
     <visual>
       <geometry>
@@ -24434,7 +25468,7 @@ function urdfXml(spec, modelName, linkNameMap, jointNameMap, geometries, _linkWo
     const jType = urdfJointHasContinuous(joint2) ? "continuous" : urdfJointType(joint2.type);
     const originAttr = transformToOrigin(joint2.frame);
     const axisXml = joint2.type !== "fixed" ? `
-    <axis xyz="${joint2.axis.map((v) => formatNumber3(v)).join(" ")}"/>` : "";
+    <axis xyz="${joint2.axis.map((v) => formatNumber4(v)).join(" ")}"/>` : "";
     let limitXml = "";
     if (joint2.type !== "fixed" && jType !== "continuous") {
       const lower2 = joint2.min !== void 0 ? joint2.type === "revolute" ? degToRad2(joint2.min) : mmToM2(joint2.min) : void 0;
@@ -24443,20 +25477,20 @@ function urdfXml(spec, modelName, linkNameMap, jointNameMap, geometries, _linkWo
       const velocity = sourceOverrides?.velocity ?? joint2.velocity;
       const vel = velocity !== void 0 ? joint2.type === "revolute" ? degToRad2(velocity) : mmToM2(velocity) : 10;
       limitXml = `
-    <limit${lower2 !== void 0 ? ` lower="${formatNumber3(lower2)}"` : ""}${upper !== void 0 ? ` upper="${formatNumber3(upper)}"` : ""} effort="${formatNumber3(effort)}" velocity="${formatNumber3(vel)}"/>`;
+    <limit${lower2 !== void 0 ? ` lower="${formatNumber4(lower2)}"` : ""}${upper !== void 0 ? ` upper="${formatNumber4(upper)}"` : ""} effort="${formatNumber4(effort)}" velocity="${formatNumber4(vel)}"/>`;
     } else if (jType === "continuous") {
       const effort = sourceOverrides?.effort ?? joint2.effort ?? 100;
       const velocity = sourceOverrides?.velocity ?? joint2.velocity;
       const vel = velocity !== void 0 ? degToRad2(velocity) : 10;
       limitXml = `
-    <limit effort="${formatNumber3(effort)}" velocity="${formatNumber3(vel)}"/>`;
+    <limit effort="${formatNumber4(effort)}" velocity="${formatNumber4(vel)}"/>`;
     }
     let dynamicsXml = "";
     const damping = sourceOverrides?.damping ?? joint2.damping;
     const friction = sourceOverrides?.friction ?? joint2.friction;
     if (damping !== void 0 || friction !== void 0) {
       dynamicsXml = `
-    <dynamics${damping !== void 0 ? ` damping="${formatNumber3(damping)}"` : ""}${friction !== void 0 ? ` friction="${formatNumber3(friction)}"` : ""}/>`;
+    <dynamics${damping !== void 0 ? ` damping="${formatNumber4(damping)}"` : ""}${friction !== void 0 ? ` friction="${formatNumber4(friction)}"` : ""}/>`;
     }
     let mimicXml = "";
     const coupling = couplingByJoint.get(joint2.name);
@@ -24464,7 +25498,7 @@ function urdfXml(spec, modelName, linkNameMap, jointNameMap, geometries, _linkWo
       const primary = coupling.terms.reduce((a, b) => Math.abs(a.ratio) >= Math.abs(b.ratio) ? a : b);
       const leaderUrdfName = jointNameMap.get(`${primary.joint}_joint`);
       mimicXml = `
-    <mimic joint="${escapeXml2(leaderUrdfName)}" multiplier="${formatNumber3(primary.ratio)}" offset="${formatNumber3(coupling.offset)}"/>`;
+    <mimic joint="${escapeXml2(leaderUrdfName)}" multiplier="${formatNumber4(primary.ratio)}" offset="${formatNumber4(coupling.offset)}"/>`;
       if (coupling.terms.length > 1) {
         warnings.push(
           `Joint "${joint2.name}" coupling has ${coupling.terms.length} terms but URDF mimic only supports 1. Using primary term (ratio=${primary.ratio} from "${primary.joint}").`
@@ -25017,12 +26051,12 @@ async function recordCliCommandEvent(input) {
 // cli/forge-project.ts
 import { existsSync as existsSync18, mkdirSync as mkdirSync8, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "fs";
 import { createInterface as createInterface2 } from "readline";
-import { basename as basename14, join as join12, resolve as resolve34 } from "path";
+import { basename as basename14, join as join13, resolve as resolve34 } from "path";
 
 // cli/license.ts
 import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync19, unlinkSync as unlinkSync2, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 var VALID_TIERS = /* @__PURE__ */ new Set(["free", "pro", "team"]);
 var PRO_COMMANDS = /* @__PURE__ */ new Set([
   // Advanced rendering
@@ -25063,14 +26097,14 @@ function tierSatisfies(userTier, required) {
   return userTier === "pro" || userTier === "team";
 }
 function licenseDir() {
-  return join11(homedir8(), ".forgecad");
+  return join12(homedir8(), ".forgecad");
 }
 function ensureLicenseDir() {
   const dir = licenseDir();
   if (!existsSync17(dir)) mkdirSync7(dir, { recursive: true });
 }
 function licenseFilePath() {
-  return join11(licenseDir(), "license.json");
+  return join12(licenseDir(), "license.json");
 }
 function readStoredLicense() {
   const path3 = licenseFilePath();
@@ -25430,8 +26464,8 @@ async function runProjectCloneCli(args) {
     const remoteFiles = await fetchRemoteFiles(project.id);
     for (const file of remoteFiles) {
       if (!file.content) continue;
-      const filePath = join12(targetDir, file.path);
-      mkdirSync8(join12(filePath, ".."), { recursive: true });
+      const filePath = join13(targetDir, file.path);
+      mkdirSync8(join13(filePath, ".."), { recursive: true });
       writeFileSync15(filePath, file.content, "utf-8");
       console.log(`  ${file.path}`);
     }
@@ -25499,8 +26533,8 @@ async function runProjectPullCli(args) {
     for (const diff of incoming) {
       const remote = remoteFiles.find((f2) => f2.path === diff.path);
       if (remote?.content) {
-        const filePath = join12(cwd, remote.path);
-        mkdirSync8(join12(filePath, ".."), { recursive: true });
+        const filePath = join13(cwd, remote.path);
+        mkdirSync8(join13(filePath, ".."), { recursive: true });
         writeFileSync15(filePath, remote.content, "utf-8");
         written++;
       }
@@ -25975,7 +27009,7 @@ async function runFileSaveCli(args) {
       }
       content = Buffer.concat(chunks).toString("utf-8");
     } else if (!content) {
-      const localPath = join12(cwd, filePath);
+      const localPath = join13(cwd, filePath);
       if (!existsSync18(localPath)) {
         console.error(`Local file not found: ${filePath}`);
         console.error("Use --content or --stdin to provide content directly.");
@@ -26399,13 +27433,13 @@ function findCollisions(entries) {
   }
   return collisions;
 }
-function usage21() {
+function usage22() {
   console.error("Usage: forgecad check params <script.forge.js> [--samples N]");
   process.exit(1);
 }
 async function runParamCheckCli(argv = process.argv.slice(2)) {
   const scriptPath = argv[0];
-  if (!scriptPath) usage21();
+  if (!scriptPath) usage22();
   const samplesArg = argv.indexOf("--samples");
   const numSamples = samplesArg >= 0 ? parseInt(argv[samplesArg + 1], 10) : 8;
   const code = readFileSync21(resolve35(scriptPath), "utf-8");
@@ -26965,7 +27999,9 @@ function buildPrintCheckReport(objects, verifications, options) {
   if (entries.length === 0) {
     checks.push(check("print.scene.objects", "Printable objects", "fail", "error", "No visible shape objects were found."));
   } else {
-    checks.push(check("print.scene.objects", "Printable objects", "pass", "info", `${entries.length} shape object(s) ready for print checks.`));
+    checks.push(
+      check("print.scene.objects", "Printable objects", "pass", "info", `${entries.length} shape object(s) ready for print checks.`)
+    );
   }
   const sceneBox = entries.length > 0 ? { min: sceneBBox.min, max: sceneBBox.max, size: bboxSize(sceneBBox.min, sceneBBox.max) } : null;
   const failedVerifications = verifications.filter((verification) => verification.status === "fail");
@@ -27017,7 +28053,9 @@ function buildPrintCheckReport(objects, verifications, options) {
     )
   );
   const thinObjects = objectReports.filter((object) => (object.thickness?.criticalAreaPercent ?? 0) > options.profile.maxThinAreaPercent);
-  const warningThinObjects = objectReports.filter((object) => (object.thickness?.warningAreaPercent ?? 0) > options.profile.maxThinAreaPercent);
+  const warningThinObjects = objectReports.filter(
+    (object) => (object.thickness?.warningAreaPercent ?? 0) > options.profile.maxThinAreaPercent
+  );
   checks.push(
     check(
       "print.fdm.wall-thickness",
@@ -27085,7 +28123,7 @@ function buildPrintCheckReport(objects, verifications, options) {
 }
 
 // cli/print-check.ts
-function usage22() {
+function usage23() {
   console.error(
     "Usage: forgecad check print <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [--json] [--output report.json] [--profile fdm-pla-0.4mm] [--param Key=Value]"
   );
@@ -27212,7 +28250,7 @@ function parseArgs10(argv) {
   }
   const positional = argv.filter((arg, index) => !consumed.has(index) && !arg.startsWith("-"));
   const scriptPath = positional[0];
-  if (!scriptPath) usage22();
+  if (!scriptPath) usage23();
   return {
     scriptPath,
     json,
@@ -27348,7 +28386,7 @@ import { resolve as resolve38 } from "path";
 
 // cli/solver-debug-artifacts.ts
 import { mkdir as mkdir4, writeFile as writeFile9 } from "fs/promises";
-import { basename as basename15, join as join13, resolve as resolve37 } from "path";
+import { basename as basename15, join as join14, resolve as resolve37 } from "path";
 
 // cli/solver-debug-html.ts
 function escapeHtml(s) {
@@ -28063,14 +29101,14 @@ async function writeSolverDebugArtifacts(outputRoot, scriptPath, objects) {
     const seen = usedNames.get(baseName) ?? 0;
     usedNames.set(baseName, seen + 1);
     const dirName = seen === 0 ? baseName : `${baseName}-${seen + 1}`;
-    const dir = join13(root, dirName);
-    const svgDir = join13(dir, "svg");
+    const dir = join14(root, dirName);
+    const svgDir = join14(dir, "svg");
     await mkdir4(svgDir, { recursive: true });
-    const transcriptPath = join13(dir, "constructive-transcript.md");
+    const transcriptPath = join14(dir, "constructive-transcript.md");
     await writeFile9(transcriptPath, buildConstructiveTranscriptMarkdown(object.name || dirName, meta), "utf8");
     const snapshotPaths = [];
     for (const snapshot of debug.svgSnapshots) {
-      const snapshotPath = join13(svgDir, `${snapshot.label}.svg`);
+      const snapshotPath = join14(svgDir, `${snapshot.label}.svg`);
       await writeFile9(snapshotPath, snapshot.svg, "utf8");
       snapshotPaths.push(snapshotPath);
     }
@@ -28095,7 +29133,7 @@ async function writeSolverDebugArtifacts(outputRoot, scriptPath, objects) {
   for (const [index, html] of htmlMap) {
     const bundle = bundles[index] ?? bundles[bundles.length - 1];
     if (bundle) {
-      const htmlPath = join13(bundle.dir, "dashboard.html");
+      const htmlPath = join14(bundle.dir, "dashboard.html");
       await writeFile9(htmlPath, html, "utf8");
     }
   }
@@ -28114,7 +29152,7 @@ async function writeSolverDebugIndex(root, scriptPath, bundles) {
       lines.push(`  svg_snapshots: ${bundle.snapshotPaths.length}`);
     }
   }
-  await writeFile9(join13(root, "README.md"), lines.join("\n") + "\n", "utf8");
+  await writeFile9(join14(root, "README.md"), lines.join("\n") + "\n", "utf8");
 }
 
 // cli/test-run.ts
@@ -28274,7 +29312,7 @@ function parseParamFlags2(argv) {
   }
   return { overrides, consumed };
 }
-function usage23() {
+function usage24() {
   console.error(
     "Usage: forgecad run <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [--details] [--history] [--features] [--connectivity] [--connectivity-tolerance <mm>] [--param Key=Value] [--debug-imports] [--verbose|-v] [--backend manifold|occt|truck] [--quality live|default|high] [--solver-profile] [--solver-debug-out <dir>]"
   );
@@ -28418,9 +29456,14 @@ function formatThreeMfStructure(analysis) {
 function objectDisplayName(obj) {
   return obj.groupName ? `${obj.name} [${obj.groupName}]` : obj.name;
 }
-function printCompactObjectSummary(objects, focusSummary) {
+function printCompactObjectSummary(objects, focusSummary, assemblyKinematics) {
   const focusTag = focusSummary ? ` (focused, ${focusSummary})` : "";
   console.log(`\u2713 Objects: ${objects.length}${focusTag}`);
+  if (objects.length === 0 && assemblyKinematics) {
+    console.log(
+      `  Rig only: ${assemblyKinematics.links.length} link(s), ${assemblyKinematics.edges.length} edge(s), ${assemblyKinematics.angles.length} angle constraint(s)`
+    );
+  }
   const names = objects.map(objectDisplayName);
   const shown = names.slice(0, MAX_COMPACT_OBJECT_NAMES);
   for (let i = 0; i < shown.length; i += 4) {
@@ -28439,7 +29482,9 @@ async function runScriptCli(argv = process.argv.slice(2)) {
   const removedSpatialFlag = argv.find((arg) => arg === "--spatial" || arg.startsWith("--spatial="));
   if (removedSpatialFlag) {
     console.error("`forgecad run --spatial` has been removed.");
-    console.error("Use `forgecad inspect fit interference <model>` for collision evidence or `forgecad inspect physical gaps <model>` for spatial gap evidence.");
+    console.error(
+      "Use `forgecad inspect fit interference <model>` for collision evidence or `forgecad inspect physical gaps <model>` for spatial gap evidence."
+    );
     process.exit(1);
   }
   const { overrides: paramCliOverrides, consumed: paramConsumed } = parseParamFlags2(argv);
@@ -28470,7 +29515,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
     (arg, i) => !paramConsumed.has(i) && !focusConsumed.has(i) && !connectivityConsumed.has(i) && arg !== "--details" && arg !== "--history" && arg !== "--features" && arg !== "--solver-profile" && arg !== "--debug-imports" && arg !== "--journeys" && arg !== "--journeys-json" && arg !== "--verbose" && arg !== "-v" && arg !== "--backend" && argv[i - 1] !== "--backend" && arg !== "--quality" && argv[i - 1] !== "--quality" && arg !== "-q" && argv[i - 1] !== "-q" && arg !== "--solver-debug-out" && argv[i - 1] !== "--solver-debug-out"
   );
   const scriptPath = positional[0];
-  if (!scriptPath) usage23();
+  if (!scriptPath) usage24();
   let activeBackend = CLI_DEFAULT_BACKEND;
   try {
     if (solverDebugOut) {
@@ -28564,7 +29609,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
         }
       }
     } else {
-      printCompactObjectSummary(visibleObjects, focusSummary);
+      printCompactObjectSummary(visibleObjects, focusSummary, result.assemblyKinematics);
     }
     if (detailedObjects && input.directThreeMfAnalysis) {
       console.log(`
@@ -28822,7 +29867,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
 // cli/forge-render-section.ts
 import { writeFile as writeFile10 } from "fs/promises";
 import { basename as basename16, extname as extname11, resolve as resolve39 } from "path";
-function usage24() {
+function usage25() {
   console.error(
     "Usage: forgecad render section <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [output.svg|.png] [--param Key=Value] [--plane XY|XZ|YZ] [--offset <number>] [--size <px>] [--edges <off|thin|bold>] [--chrome-path <path>] [--background <color>]"
   );
@@ -28883,12 +29928,12 @@ async function runRenderSectionCli(argv = process.argv.slice(2)) {
       background = argv[++i];
     } else if (argv[i].startsWith("-")) {
       console.error(`Unknown option: ${argv[i]}`);
-      usage24();
+      usage25();
     } else {
       args.push(argv[i]);
     }
   }
-  if (args.length === 0) usage24();
+  if (args.length === 0) usage25();
   scriptPath = args[0];
   const wantsPng = args[1] ? extname11(args[1]).toLowerCase() === ".png" : false;
   outputPath = args[1] || defaultOutput(scriptPath, wantsPng ? "png" : "svg");
@@ -28946,17 +29991,17 @@ async function runRenderSectionCli(argv = process.argv.slice(2)) {
 }
 
 // cli/update-check.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync22, writeFileSync as writeFileSync17 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname10, join as join14 } from "path";
+import { dirname as dirname10, join as join15 } from "path";
 var PACKAGE_NAME = "forgecad";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 var WORKER_FLAG = "--__update-check-worker";
 function cachePath() {
-  return join14(homedir9(), ".forgecad", "update-check.json");
+  return join15(homedir9(), ".forgecad", "update-check.json");
 }
 function readCache() {
   try {
@@ -29025,7 +30070,7 @@ function scheduleUpdateCheck(currentVersion) {
   const scriptPath = process.argv[1];
   if (!scriptPath) return;
   try {
-    const child = spawn3(process.execPath, [scriptPath, WORKER_FLAG], {
+    const child = spawn4(process.execPath, [scriptPath, WORKER_FLAG], {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -29073,7 +30118,7 @@ var RENDER_ANGLE_VALUES = [
 ];
 var CAPTURE_TYPE_VALUES = [
   { value: "orbit", description: "Orbit the camera around the model" },
-  { value: "animation", description: "Play a jointsView clip with a fixed camera" },
+  { value: "animation", description: "Play a named joint clip with a fixed camera" },
   { value: "section-sweep", description: "Move a clipping plane through the model" }
 ];
 var OUTPUT_FORMAT_VALUES = [
@@ -29162,8 +30207,7 @@ var RENDER_STYLE_VALUES = [
   { value: "fast", description: "Low-cost attractive live preview shading" },
   { value: "glass", description: "Transparent inspection view with rim shell and readable edges" },
   { value: "inspection", description: "Light technical evidence style with matte shading and dark edges" },
-  { value: "precision", description: "Dense technical surface-field contours" },
-  { value: "hybrid", description: "Topo-led surface contours with a quiet orthogonal field" },
+  { value: "contour", description: "Dense technical surface-field contours" },
   { value: "scan", description: "Dark spatial-report style with object-colored scene-grid cells" }
 ];
 var PARAM_OPTIONS = [
@@ -29226,11 +30270,11 @@ var RENDER_OPTIONS = [
     name: "--render-style",
     description: "Visual render style (render default: classic; inspect default: inspection)",
     argument: "required",
-    valueLabel: "<classic|studio|fast|glass|inspection|precision|hybrid|scan>",
+    valueLabel: "<classic|studio|fast|glass|inspection|contour|scan>",
     values: RENDER_STYLE_VALUES
   },
   { name: "--scan-granularity", description: "Scan cells across the scene longest axis", argument: "required", valueLabel: "<12-144>" },
-  { name: "--port", description: "Vite dev server port", argument: "required", valueLabel: "<n>" },
+  { name: "--port", description: "Renderer server port", argument: "required", valueLabel: "<n>" },
   { name: "--fresh-server", description: "Start a fresh renderer instead of reusing an existing one" },
   {
     name: "--chrome-path",
@@ -29323,7 +30367,7 @@ var INSPECT_EVIDENCE_OPTIONS = [
     name: "--render-style",
     description: "Visual render style (default: inspection)",
     argument: "required",
-    valueLabel: "<classic|studio|fast|glass|inspection|precision|hybrid|scan>",
+    valueLabel: "<classic|studio|fast|glass|inspection|contour|scan>",
     values: RENDER_STYLE_VALUES
   },
   {
@@ -29437,7 +30481,7 @@ var INSPECT_EVIDENCE_OPTIONS = [
       { value: "clean", description: "Solid cap faces" }
     ]
   },
-  { name: "--port", description: "Vite dev server port", argument: "required", valueLabel: "<n>" },
+  { name: "--port", description: "Renderer server port", argument: "required", valueLabel: "<n>" },
   { name: "--fresh-server", description: "Start a fresh renderer instead of reusing an existing one" },
   {
     name: "--chrome-path",
@@ -29523,7 +30567,7 @@ var INSPECT_SECTIONS_COMMON_OPTIONS = [
     values: BACKEND_VALUES
   },
   { name: "--force", description: "Replace the requested output directory instead of allocating a sibling" },
-  { name: "--port", description: "Vite dev server port", argument: "required", valueLabel: "<n>" },
+  { name: "--port", description: "Renderer server port", argument: "required", valueLabel: "<n>" },
   { name: "--fresh-server", description: "Start a fresh renderer instead of reusing an existing one" },
   {
     name: "--chrome-path",
@@ -29703,6 +30747,14 @@ var INSPECT_CANONICAL_SPECS = [
     description: "Use this to inspect orientation changes, flipped surfaces, and faceting next to image or Zebra evidence.",
     examples: ["forgecad inspect visual normals examples/api/static-assembly-connectors.forge.js --camera iso"]
   },
+  {
+    path: ["inspect", "visual", "rig"],
+    evidenceName: "rig",
+    label: "visual rig",
+    summary: "Capture kinematic rig skeleton evidence.",
+    description: "Use this to inspect joint pivots, axes, angle arcs, hierarchy links, and child-part links with geometry reduced to a shadow.",
+    examples: ["forgecad inspect visual rig model.forge.js --camera iso"]
+  },
   {
     path: ["inspect", "visual", "objects"],
     evidenceName: "objects",
@@ -29820,7 +30872,7 @@ Cutaway options:
 
 Visual options:
   --background <color>            Canvas background override
-  --render-style <classic|studio|fast|glass|inspection|precision|hybrid|scan>
+  --render-style <classic|studio|fast|glass|inspection|contour|scan>
                                   Visual render style (default: inspection)
   --edges <off|thin|bold>         Edge overlay preset for solid visual evidence (default: thin)
 
@@ -29873,18 +30925,19 @@ var INSPECT_TOPIC_COMMANDS = [
   {
     group: "Inspect",
     path: ["inspect", "visual"],
-    summary: "Inspect visual context, cutaways, depth, normals, or object identity.",
-    description: "Choose `image`, `cutaway`, `depth`, `normals`, or `objects` visual evidence.",
+    summary: "Inspect visual context, cutaways, depth, normals, rig skeletons, or object identity.",
+    description: "Choose `image`, `cutaway`, `depth`, `normals`, `rig`, or `objects` visual evidence.",
     usage: [
-      "forgecad inspect visual <image|cutaway|depth|normals|objects> <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [options]"
+      "forgecad inspect visual <image|cutaway|depth|normals|rig|objects> <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [options]"
     ],
     examples: [
       "forgecad inspect visual image model.forge.js --camera iso",
       "forgecad inspect visual cutaway model.forge.js --plane yz",
+      "forgecad inspect visual rig model.forge.js --camera iso",
       "forgecad inspect visual objects model.forge.js --camera front --camera right"
     ],
     run: async () => {
-      console.error("`forgecad inspect visual` needs a mode: image, cutaway, depth, normals, or objects.");
+      console.error("`forgecad inspect visual` needs a mode: image, cutaway, depth, normals, rig, or objects.");
       process.exit(1);
     }
   },
@@ -29958,11 +31011,12 @@ var INSPECT_TOPIC_COMMANDS = [
   }
 ];
 var INSPECT_COMMAND_OVERVIEW = [
+  "- `inspect sketch` \u2014 returned sketch/profile regions, selector dry-runs, and extrusion compatibility",
   "- `inspect history` \u2014 final-object feature recipes and feedback anchors",
   "- `inspect design-trace` \u2014 raw construction DAG, source spans, and cache diagnostics",
   "- `inspect section` \u2014 agent-native one-off section probe with optional ray rulers and replay JSON",
   "- `inspect replay` \u2014 rerun a saved section probe on the same or another source",
-  "- `inspect visual image|cutaway|depth|normals|objects` \u2014 visual context, clipped 3D cutaways, depth, normals, and identity evidence",
+  "- `inspect visual image|cutaway|depth|normals|rig|objects` \u2014 visual context, clipped 3D cutaways, depth, normals, rig skeletons, and identity evidence",
   "- `inspect surface zebra|roughness` \u2014 surface continuity and roughness evidence",
   "- `inspect physical components|floating|gaps` \u2014 physical component graph evidence",
   "- `inspect fit interference` \u2014 positive-volume overlap evidence",
@@ -30102,7 +31156,7 @@ var CAPTURE_COMMON_OPTIONS = [
     valueLabel: "<orbit|animation|section-sweep>",
     values: CAPTURE_TYPE_VALUES
   },
-  { name: "--animation", description: "Named jointsView animation clip", argument: "required", valueLabel: "<name>" },
+  { name: "--animation", description: "Named joint animation clip", argument: "required", valueLabel: "<name>" },
   { name: "--animation-loops", description: "Repeat the selected animation clip", argument: "required", valueLabel: "<n>" },
   { name: "--cut-plane", description: "Enable a named cut plane", argument: "required", valueLabel: "<name>", repeatable: true },
   {
@@ -30262,15 +31316,14 @@ var commands = [
     group: "Shell",
     path: ["skill", "install"],
     summary: "Install ForgeCAD agent skills into the default global agent skill directory.",
-    usage: ["forgecad skill install [--target agents|claude|codex|opencode|all] [--core-only] [--dev]"],
+    usage: ["forgecad skill install [--target agents|claude|codex|opencode|all] [--core-only]"],
     examples: [
       "forgecad skill install",
       "forgecad skill install --target claude",
       "forgecad skill install --target codex",
       "forgecad skill install --target opencode",
       "forgecad skill install --target all",
-      "forgecad skill install --core-only",
-      "forgecad skill install --dev"
+      "forgecad skill install --core-only"
     ],
     completion: {
       options: [
@@ -30289,7 +31342,6 @@ var commands = [
         },
         { name: "--all-agents", description: "Alias for `--target all`" },
         { name: "--core-only", description: "Install only the core forgecad skill, without companion workflow skills" },
-        { name: "--dev", description: "Install the internal ForgeCAD developer variant of the core skill" },
         { name: "--library", description: "Deprecated no-op; the public skill library is installed by default" },
         { name: "--all", description: "Deprecated no-op; the public skill library is installed by default" }
       ]
@@ -30504,7 +31556,7 @@ var commands = [
     group: "Modeling",
     path: ["render", "3d"],
     summary: "Render a Forge scene to PNG using the real viewport renderer.",
-    description: "Launches a headless Chrome instance, renders the scene with the same WebGL viewport as the editor, and saves a PNG. The output path defaults to `<script-name>.png` next to the input file.\n\nThe input can be a `.forge.js` script or a direct `.stl`, `.obj`, `.3mf`, `.step`, or `.stp` asset. Direct STEP/STP rendering auto-selects OCCT unless you pass `--backend`.\n\nUse `--focus` to isolate specific parts (hides everything else) or `--hide` to remove clutter like mock objects. The `--view` flag selects a named camera declared in `scene({ views })`. The `--camera` flag accepts built-in views (`front`, `top`, `iso`), `azimuth:elevation` angles, or an exact `proj/pos/target/up/fov` camera spec \u2014 pass `--camera` multiple times to render several viewpoints in one run. Use `--camera-json <file>` or `--scene <file>` for exact reproducible viewport cameras without shell escaping. Filtered renders report any visible objects whose bounding boxes are partially or fully outside the camera frame; exact cameras fail when they frame none of the visible objects.\n\nUse `--edges=<off|thin|bold>` to control the edge overlay. For a pure wireframe look, use `render wireframe` instead.\n\nThis is the standard way to visually verify geometry from the CLI or in agent workflows. For higher quality (path-traced, materials, HDRI lighting), use `render hq` instead.",
+    description: "Launches a headless Chrome instance, renders the scene with the same WebGL viewport as the editor, and saves a PNG. The output path defaults to `<script-name>.png` next to the input file. Each render uses a private renderer server by default, so parallel renders do not compete for the same Vite port.\n\nThe input can be a `.forge.js` script or a direct `.stl`, `.obj`, `.3mf`, `.step`, or `.stp` asset. Direct STEP/STP rendering auto-selects OCCT unless you pass `--backend`.\n\nUse `--focus` to isolate specific parts (hides everything else) or `--hide` to remove clutter like mock objects. The `--view` flag selects a named camera declared in `scene({ views })`. The `--camera` flag accepts built-in views (`front`, `top`, `iso`), `azimuth:elevation` angles, or an exact `proj/pos/target/up/fov` camera spec \u2014 pass `--camera` multiple times to render several viewpoints in one run. Use `--camera-json <file>` or `--scene <file>` for exact reproducible viewport cameras without shell escaping. Filtered renders report any visible objects whose bounding boxes are partially or fully outside the camera frame; exact cameras fail when they frame none of the visible objects.\n\nUse `--edges=<off|thin|bold>` to control the edge overlay. For a pure wireframe look, use `render wireframe` instead.\n\nThis is the standard way to visually verify geometry from the CLI or in agent workflows. For higher quality (path-traced, materials, HDRI lighting), use `render hq` instead.",
     usage: [
       "forgecad render 3d <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [output.png] [--param Key=Value] [--focus [names]] [--hide names] [--edges off|thin|bold] [options]"
     ],
@@ -30706,8 +31758,8 @@ var commands = [
   {
     group: "Modeling",
     path: ["capture", "gif"],
-    summary: "Capture an animated GIF from a script via orbit, jointsView playback, or section sweep.",
-    description: "Renders an animated sequence by either orbiting the camera around the model or playing back a `jointsView` animation. Use `--capture orbit` (default) for a turntable rotation, `--capture animation --animation <name>` to play a named joints clip, or `--capture section-sweep` to move a clipping plane through the model. Supports `--cut-plane` to animate with a static cross-section visible. Use `--view`, `--camera`, `--camera-json`, or `--scene <file>` to choose the orbit base camera or the fixed camera for animations and section sweeps.",
+    summary: "Capture an animated GIF from a script via orbit, named joint playback, or section sweep.",
+    description: "Renders an animated sequence by either orbiting the camera around the model or playing back a named joint animation. Use `--capture orbit` (default) for a turntable rotation, `--capture animation --animation <name>` to play a named joint clip, or `--capture section-sweep` to move a clipping plane through the model. Supports `--cut-plane` to animate with a static cross-section visible. Use `--view`, `--camera`, `--camera-json`, or `--scene <file>` to choose the orbit base camera or the fixed camera for animations and section sweeps.",
     usage: [
       "forgecad capture gif <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [output.gif] [options] [--param Key=Value]"
     ],
@@ -30731,14 +31783,14 @@ var commands = [
   {
     group: "Modeling",
     path: ["capture", "mp4"],
-    summary: "Capture an MP4 from a script via orbit, jointsView playback, or section sweep.",
+    summary: "Capture an MP4 from a script via orbit, named joint playback, or section sweep.",
     description: "Same as `capture gif` but outputs H.264 MP4. Prefers ffmpeg when available for better compression; falls back to a pure-JS encoder. MP4 is better for longer animations, section sweeps, or higher resolutions where GIF file sizes become unwieldy. The camera flags match `capture gif`.",
     usage: [
       "forgecad capture mp4 <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [output.mp4] [options] [--param Key=Value]"
     ],
     examples: [
       "forgecad capture mp4 examples/products/cup.forge.js",
-      "forgecad capture mp4 examples/api/runtime-joints-view.forge.js out/step.mp4 --capture animation --animation Step",
+      "forgecad capture mp4 examples/api/assembly-kinematics-four-bar.forge.js out/four-bar.mp4 --view iso",
       'forgecad capture mp4 model.forge.js out/raw.mp4 --param "Output=raw-sdf"',
       "forgecad capture mp4 model.forge.js out/front.mp4 --camera front",
       "forgecad capture mp4 model.forge.js out/hero.mp4 --view hero",
@@ -30866,14 +31918,23 @@ var commands = [
   {
     group: "Export",
     path: ["export", "step"],
-    summary: "Export exact STEP through the native OCCT runtime exporter.",
-    usage: ["forgecad export step <model.forge.js|asset.step|asset.stp> [--output path]"],
+    summary: "Export exact STEP through the native OCCT or Truck runtime exporter.",
+    usage: ["forgecad export step <model.forge.js|asset.step|asset.stp> [--output path] [--backend occt|truck]"],
     examples: [
       "forgecad export step examples/api/boolean-operations.forge.js",
-      "forgecad export step housing.step --output housing-copy.step"
+      "forgecad export step housing.step --output housing-copy.step",
+      "forgecad export step examples/api/mixed-edge-finishes-proof.forge.js --backend truck"
     ],
     completion: {
-      options: [{ name: "--output", description: "Output STEP path", argument: "required", valueLabel: "<path>", valueKind: "path" }],
+      options: [
+        { name: "--output", description: "Output STEP path", argument: "required", valueLabel: "<path>", valueKind: "path" },
+        {
+          name: "--backend",
+          description: "Exact BREP exporter: occt (default) or truck (native analytic kernel)",
+          argument: "required",
+          valueLabel: "<occt|truck>"
+        }
+      ],
       positionals: [{ description: "Forge script or STEP file", valueKind: "exact-cad-input" }]
     },
     run: (args) => runBrepCli(["--format", "step", ...args])
@@ -31805,6 +32866,51 @@ var commands = [
     examples: ["forgecad inspect evidence", "forgecad inspect evidence --json"],
     run: runInspectEvidenceListCli
   },
+  {
+    group: "Inspect",
+    path: ["inspect", "sketch"],
+    summary: "Inspect returned sketches and profile regions used by returned shapes.",
+    description: "Runs a model and reports inspectable 2D sketch/profile regions without requiring model code to register inspection hooks. The command inspects returned Sketch objects and profile-bearing shape compile plans such as extrude, cut, and revolve. Use `--seed x,y` to dry-run which region a point selector would consume, and `--operation extrude` to check extrusion compatibility.",
+    usage: [
+      "forgecad inspect sketch <model.forge.js> [--json] [--object <name-or-path>] [--seed <x,y>] [--operation extrude] [--param Key=Value] [--backend manifold|occt|truck] [--quality live|default|high]"
+    ],
+    examples: [
+      "forgecad inspect sketch examples/api/sketch-regions.forge.js",
+      'forgecad inspect sketch model.forge.js --object "Profile" --seed 45,15',
+      'forgecad inspect sketch model.forge.js --json --object "Body" --seed 45,15 --operation extrude'
+    ],
+    completion: {
+      options: [
+        { name: "--json", description: "Emit machine-readable JSON" },
+        { name: "--compact", description: "Minify JSON output" },
+        { name: "--object", description: "Inspect one scene object by name, id, or tree path", argument: "required", valueLabel: "<name>" },
+        {
+          name: "--seed",
+          description: "Dry-run a region selector point in sketch-local coordinates",
+          argument: "required",
+          valueLabel: "<x,y>"
+        },
+        { name: "--operation", description: "Operation compatibility to preview", argument: "required", valueLabel: "<extrude>" },
+        ...PARAM_OPTIONS,
+        {
+          name: "--quality",
+          description: "Geometry quality",
+          argument: "required",
+          valueLabel: "<default|live|high>",
+          values: QUALITY_VALUES
+        },
+        {
+          name: "--backend",
+          description: "Geometry backend",
+          argument: "required",
+          valueLabel: "<manifold|occt|truck>",
+          values: BACKEND_VALUES
+        }
+      ],
+      positionals: [{ description: "Forge script or CAD asset", valueKind: "renderable" }]
+    },
+    run: runInspectSketchCli
+  },
   {
     group: "Inspect",
     path: ["inspect", "section"],
@@ -32068,7 +33174,7 @@ var commands = [
         { name: "--update", description: "Regenerate compiler snapshots" }
       ]
     },
-    run: async (args) => (await import("./check-compiler-U5SOPN7X.js")).runCheckCompilerCli(args)
+    run: async (args) => (await import("./check-compiler-SDX5QIXI.js")).runCheckCompilerCli(args)
   },
   {
     group: "Checks",
@@ -32091,7 +33197,7 @@ var commands = [
         { name: "--update", description: "Regenerate query-propagation snapshots" }
       ]
     },
-    run: async (args) => (await import("./check-query-propagation-XOKNSSYU.js")).runCheckQueryPropagationCli(args)
+    run: async (args) => (await import("./check-query-propagation-EAYEFT77.js")).runCheckQueryPropagationCli(args)
   },
   {
     group: "Checks",
@@ -32881,7 +33987,9 @@ function printRemovedRunFullFlagMessage() {
 }
 function printRemovedRunSpatialFlagMessage() {
   console.error("`forgecad run --spatial` has been removed.");
-  console.error("Use `forgecad inspect fit interference <model>` for collision evidence or `forgecad inspect physical gaps <model>` for spatial gap evidence.");
+  console.error(
+    "Use `forgecad inspect fit interference <model>` for collision evidence or `forgecad inspect physical gaps <model>` for spatial gap evidence."
+  );
 }
 function printInternalCheckCommandMessage(commandName) {
   if (commandName === "params") {
@@ -33034,4 +34142,3 @@ export {
   runForgeCadCli,
   runForgeCommandDefinition
 };
-//# sourceMappingURL=forgecad.js.map