forgecad 0.10.3 → 0.10.4

package/dist-cli/forgecad.js

@@ -37,6 +37,8 @@ import {
   circle2d,
   collectProjectFiles,
   collectSimulationModel,
+  compileProjection,
+  computeGeometryArrays,
   constrainedSketch,
   cylinder,
   describeFaceQueryRef,
@@ -134,11 +136,12 @@ import {
   updateConstraintValue,
   validateSimulationModel,
   wrapOCCTShapeBackend
-} from "./chunk-WLUKAW3H.js";
+} from "./chunk-UHBRMYA6.js";
 
 // cli/forgecad.ts
 import { Command, Flags, Help, flush as flushOclif, handle as handleOclif, run as runOclif } from "@oclif/core";
-import { readFileSync as readFileSync28 } from "fs";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync22 } from "fs";
+import { extname as extname15, resolve as resolvePath } from "path";
 
 // cli/check-api-contracts.ts
 import assert from "assert/strict";
@@ -5667,7 +5670,7 @@ function computeMeshInertia(mesh, massKg) {
 }
 
 // src/studio/project-files/importGraph.ts
-var FORGE_IMPORT_RE = /\b(?:importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.svgSketch|Import\.dxfSketch|compareWith)\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
+var FORGE_IMPORT_RE = /\b(?:importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.image|Import\.svgSketch|Import\.dxfSketch|compareWith)\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
 var REQUIRE_RE = /\brequire\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
 var ES_IMPORT_RE = /\bfrom\s+(?:"([^"]+)"|'([^']+)')/g;
 var VIRTUAL_MODULES = /* @__PURE__ */ new Set(["forgecad", "@forge/runtime", "@forgecad/runtime"]);
@@ -5686,6 +5689,7 @@ function extractImports(code) {
     importSvgSketch: "forgeSvg",
     "Import.mesh": "forgeMesh",
     "Import.step": "forgeMesh",
+    "Import.image": "forgeMesh",
     "Import.svgSketch": "forgeSvg",
     "Import.dxfSketch": "forgeDxf",
     compareWith: "compareWith"
@@ -5695,7 +5699,7 @@ function extractImports(code) {
   while ((m = forgeRe.exec(code)) !== null) {
     const path5 = m[1] ?? m[2];
     const fn = m[0].match(
-      /\b(importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.svgSketch|Import\.dxfSketch|compareWith)/
+      /\b(importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.image|Import\.svgSketch|Import\.dxfSketch|compareWith)/
     )?.[1];
     add2(path5, kindMap[fn] ?? "forgeMesh");
   }
@@ -7563,6 +7567,13 @@ function parsePositiveInteger2(value, flag) {
   }
   return parsed;
 }
+function parseNonNegativeInteger(value, flag) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`${flag} must be a non-negative integer (got '${value}')`);
+  }
+  return parsed;
+}
 function parseScanGranularity(value) {
   const numeric = parsePositiveInteger2(value, "--scan-granularity");
   if (numeric < SCAN_GRANULARITY_MIN || numeric > SCAN_GRANULARITY_MAX) {
@@ -8133,6 +8144,7 @@ function parseInspectCli(argv, config = {}) {
   let compareToleranceMm;
   const thickness = {};
   const roughness = {};
+  const scalarFieldParams = {};
   const sectionPlan = { planes: [] };
   let sectionOptionsUsed = false;
   let sectionOffset;
@@ -8277,6 +8289,22 @@ function parseInspectCli(argv, config = {}) {
       i += 1;
       continue;
     }
+    if (arg === "--bands" || arg === "--iso" || arg === "--iso-width") {
+      const isScalarFieldChannel = channels?.includes("thickness") || channels?.includes("roughness");
+      if (!isScalarFieldChannel) {
+        throw new Error(`${arg} only works with \`forgecad inspect surface thickness\` or \`... roughness\`.`);
+      }
+      if (arg === "--bands") {
+        scalarFieldParams.quantizeBands = parseNonNegativeInteger(readValue2(argv, i, arg), arg);
+        i += 1;
+      } else if (arg === "--iso-width") {
+        scalarFieldParams.isoLineWidthPx = parsePositiveNumber(readValue2(argv, i, arg), arg);
+        i += 1;
+      } else {
+        scalarFieldParams.isoEnabled = true;
+      }
+      continue;
+    }
     if (arg === "--plane" && channels?.includes("section")) {
       addSectionPlaneRequests(sectionPlan, readValue2(argv, i, arg), arg);
       sectionOptionsUsed = true;
@@ -8524,6 +8552,10 @@ function parseInspectCli(argv, config = {}) {
     freshServer,
     thickness,
     roughness,
+    // Only forward heatmap overrides when a flag actually set one; an empty object
+    // would still merge to the viewport default, but undefined keeps the payload and
+    // the inspect bundle byte-identical to the pre-flag behavior.
+    scalarFieldParams: Object.keys(scalarFieldParams).length > 0 ? scalarFieldParams : void 0,
     sectionPlan: sectionOptionsUsed ? {
       ...sectionPlan.planes.length > 0 ? { planes: sectionPlan.planes } : {},
       ...sectionPlan.offsets != null ? { offsets: sectionPlan.offsets } : {},
@@ -9772,6 +9804,11 @@ async function runInspectBundleInput(options) {
     });
     try {
       const page = await browser.newPage();
+      if (process.env.FORGECAD_INSPECT_PROFILE === "1") {
+        page.on("console", (message) => {
+          console.log(`[browser:${message.type()}] ${message.text()}`);
+        });
+      }
       const url = `http://127.0.0.1:${activePort}/cli/render.html`;
       await page.goto(url, { waitUntil: "networkidle0", timeout: 15e3 });
       await page.waitForFunction("window.__forgeReady === true", { timeout: RENDER_READY_TIMEOUT_MS });
@@ -9780,6 +9817,7 @@ async function runInspectBundleInput(options) {
         cameras: options.cameras,
         size: options.size,
         quality: options.quality,
+        debug: process.env.FORGECAD_INSPECT_PROFILE === "1",
         binaryFiles,
         activeBackend,
         cameraSpec: options.cameraSpec || null,
@@ -9798,6 +9836,7 @@ async function runInspectBundleInput(options) {
             cameras: browserRenderOptions.cameras,
             size: browserRenderOptions.size,
             quality: browserRenderOptions.quality,
+            debug: browserRenderOptions.debug,
             channels: browserRenderOptions.channels,
             allFiles: files,
             fileName: scriptName,
@@ -9811,6 +9850,7 @@ async function runInspectBundleInput(options) {
             hide: browserRenderOptions.hide,
             thickness: browserRenderOptions.thickness,
             roughness: browserRenderOptions.roughness,
+            scalarFieldParams: browserRenderOptions.scalarFieldParams,
             sectionPlan: browserRenderOptions.sectionPlan,
             cutaway: browserRenderOptions.cutaway,
             comparison: browserRenderOptions.comparison,
@@ -9833,6 +9873,7 @@ async function runInspectBundleInput(options) {
         channels: options.channels,
         thickness: options.thickness,
         roughness: options.roughness,
+        scalarFieldParams: options.scalarFieldParams,
         sectionPlan: options.sectionPlan,
         cutaway: options.cutaway,
         jointOverrides: options.jointOverrides,
@@ -22284,6 +22325,361 @@ async function exportMeshInput(format, scriptPath, outputPath, quality, backend,
   stats.forEach((line) => console.log(line));
 }
 
+// src/forge/mesh/textureProjection.ts
+function bakeProjectedUv(positions, spec) {
+  if (!(positions instanceof Float32Array)) {
+    throw new TypeError("bakeProjectedUv: positions must be a Float32Array.");
+  }
+  if (positions.length % 3 !== 0) {
+    throw new RangeError(
+      `bakeProjectedUv: positions length must be a multiple of 3, got ${positions.length}.`
+    );
+  }
+  const project = compileProjection(spec);
+  const vertexCount = positions.length / 3;
+  const uvs = new Float32Array(vertexCount * 2);
+  for (let i = 0; i < vertexCount; i++) {
+    const x = positions[i * 3];
+    const y = positions[i * 3 + 1];
+    const z = positions[i * 3 + 2];
+    const [u, v] = project(x, y, z);
+    uvs[i * 2] = u;
+    uvs[i * 2 + 1] = v;
+  }
+  return uvs;
+}
+
+// src/forge/export/exportGltf.ts
+var GLTF_FLOAT = 5126;
+var GLTF_UNSIGNED_INT = 5125;
+var GLTF_ARRAY_BUFFER = 34962;
+var GLTF_ELEMENT_ARRAY_BUFFER = 34963;
+var GLTF_WRAP_REPEAT = 10497;
+var GLTF_FILTER_LINEAR = 9729;
+var GLTF_FILTER_LINEAR_MIPMAP_LINEAR = 9987;
+function parseHexColor01(hex) {
+  if (!hex) return null;
+  const value = hex.trim();
+  if (!value.startsWith("#")) return null;
+  let r;
+  let g;
+  let b;
+  if (value.length === 7) {
+    r = Number.parseInt(value.slice(1, 3), 16);
+    g = Number.parseInt(value.slice(3, 5), 16);
+    b = Number.parseInt(value.slice(5, 7), 16);
+  } else if (value.length === 4) {
+    r = Number.parseInt(value[1] + value[1], 16);
+    g = Number.parseInt(value[2] + value[2], 16);
+    b = Number.parseInt(value[3] + value[3], 16);
+  } else {
+    return null;
+  }
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) return null;
+  return { r: srgbToLinear(r / 255), g: srgbToLinear(g / 255), b: srgbToLinear(b / 255) };
+}
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function decodeDataUri(dataUri) {
+  const match = /^data:([^;,]+)(;base64)?,(.*)$/s.exec(dataUri);
+  if (!match) {
+    throw new Error(
+      "glTF export: texture image is not a data: URI. Expected the self-contained data URI produced by Import.image(...)."
+    );
+  }
+  const mimeType = match[1] || "application/octet-stream";
+  const isBase64 = match[2] === ";base64";
+  const payload = match[3];
+  if (!isBase64) {
+    throw new Error("glTF export: only base64-encoded texture data URIs are supported.");
+  }
+  let bytes;
+  if (typeof Buffer !== "undefined") {
+    bytes = new Uint8Array(Buffer.from(payload, "base64"));
+  } else {
+    const binary = atob(payload);
+    bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  }
+  return { mimeType, bytes };
+}
+function extractShapeGeometry(obj) {
+  const mesh = obj.shape.getMesh();
+  const geo = computeGeometryArrays(mesh, { skipEdges: true });
+  const positions = geo.positions;
+  const normals = geo.normals;
+  const materialProps = obj.shape.materialProps;
+  const textureDescriptor = materialProps?.texture;
+  let uvs = null;
+  let texture = null;
+  if (geo.uvs) {
+    uvs = geo.uvs;
+    if (textureDescriptor) {
+      texture = decodeDataUri(textureDescriptor.image);
+    }
+  } else if (textureDescriptor) {
+    uvs = bakeProjectedUv(positions, textureDescriptor.projection);
+    texture = decodeDataUri(textureDescriptor.image);
+  }
+  const numVerts = positions.length / 3;
+  const indices = new Uint32Array(numVerts);
+  for (let i = 0; i < numVerts; i++) indices[i] = i;
+  const metalness = typeof materialProps?.metalness === "number" ? materialProps.metalness : 0.05;
+  const roughness = typeof materialProps?.roughness === "number" ? materialProps.roughness : 0.35;
+  const opacity = typeof materialProps?.opacity === "number" ? materialProps.opacity : 1;
+  return {
+    positions,
+    normals,
+    uvs,
+    indices,
+    texture,
+    baseColor: parseHexColor01(obj.color),
+    metalness,
+    roughness,
+    opacity,
+    name: obj.name || "Object"
+  };
+}
+function align4(n) {
+  return n + 3 & ~3;
+}
+function vec3MinMax(arr) {
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < arr.length; i += 3) {
+    for (let c = 0; c < 3; c++) {
+      const val = arr[i + c];
+      if (val < min[c]) min[c] = val;
+      if (val > max[c]) max[c] = val;
+    }
+  }
+  return { min, max };
+}
+function buildGltf(objects) {
+  if (objects.length === 0) {
+    throw new Error("No shapes provided for glTF export.");
+  }
+  const geometries = objects.map(extractShapeGeometry);
+  const bufferViews = [];
+  const accessors = [];
+  const meshes = [];
+  const nodes = [];
+  const materials = [];
+  const textures = [];
+  const images = [];
+  const samplers = [];
+  const chunks = [];
+  let byteOffset = 0;
+  function pushBufferView(data, target) {
+    const padded = align4(data.byteLength);
+    const view = {
+      buffer: 0,
+      byteOffset,
+      byteLength: data.byteLength
+    };
+    if (target !== void 0) view.target = target;
+    bufferViews.push(view);
+    const chunk = new Uint8Array(padded);
+    chunk.set(data);
+    chunks.push(chunk);
+    byteOffset += padded;
+    return bufferViews.length - 1;
+  }
+  function typedArrayBytes(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+  }
+  const imageIndexByKey = /* @__PURE__ */ new Map();
+  const samplerIndexByKey = /* @__PURE__ */ new Map();
+  function ensureSampler() {
+    const key = "repeat-linear-mip";
+    const existing = samplerIndexByKey.get(key);
+    if (existing !== void 0) return existing;
+    samplers.push({
+      wrapS: GLTF_WRAP_REPEAT,
+      wrapT: GLTF_WRAP_REPEAT,
+      magFilter: GLTF_FILTER_LINEAR,
+      minFilter: GLTF_FILTER_LINEAR_MIPMAP_LINEAR
+    });
+    const idx = samplers.length - 1;
+    samplerIndexByKey.set(key, idx);
+    return idx;
+  }
+  function ensureTexture(image) {
+    const key = `${image.mimeType}|${image.bytes.byteLength}`;
+    const fpKey = `${key}|${fingerprint2(image.bytes)}`;
+    const existing = imageIndexByKey.get(fpKey);
+    let imageIdx;
+    if (existing !== void 0) {
+      imageIdx = existing;
+    } else {
+      const bufferViewIdx = pushBufferView(image.bytes);
+      images.push({ mimeType: image.mimeType, bufferView: bufferViewIdx });
+      imageIdx = images.length - 1;
+      imageIndexByKey.set(fpKey, imageIdx);
+    }
+    const samplerIdx = ensureSampler();
+    textures.push({ sampler: samplerIdx, source: imageIdx });
+    return textures.length - 1;
+  }
+  for (const geo of geometries) {
+    const attributes = {};
+    const posView = pushBufferView(typedArrayBytes(geo.positions), GLTF_ARRAY_BUFFER);
+    const { min, max } = vec3MinMax(geo.positions);
+    accessors.push({
+      bufferView: posView,
+      componentType: GLTF_FLOAT,
+      count: geo.positions.length / 3,
+      type: "VEC3",
+      min,
+      max
+    });
+    attributes.POSITION = accessors.length - 1;
+    const nView = pushBufferView(typedArrayBytes(geo.normals), GLTF_ARRAY_BUFFER);
+    accessors.push({
+      bufferView: nView,
+      componentType: GLTF_FLOAT,
+      count: geo.normals.length / 3,
+      type: "VEC3"
+    });
+    attributes.NORMAL = accessors.length - 1;
+    if (geo.uvs) {
+      const uvView = pushBufferView(typedArrayBytes(geo.uvs), GLTF_ARRAY_BUFFER);
+      accessors.push({
+        bufferView: uvView,
+        componentType: GLTF_FLOAT,
+        count: geo.uvs.length / 2,
+        type: "VEC2"
+      });
+      attributes.TEXCOORD_0 = accessors.length - 1;
+    }
+    const idxView = pushBufferView(typedArrayBytes(geo.indices), GLTF_ELEMENT_ARRAY_BUFFER);
+    accessors.push({
+      bufferView: idxView,
+      componentType: GLTF_UNSIGNED_INT,
+      count: geo.indices.length,
+      type: "SCALAR"
+    });
+    const indicesAccessor = accessors.length - 1;
+    const color = geo.baseColor;
+    const pbr = {
+      metallicFactor: geo.metalness,
+      roughnessFactor: geo.roughness
+    };
+    if (color) {
+      pbr.baseColorFactor = [color.r, color.g, color.b, geo.opacity];
+    } else if (geo.opacity !== 1) {
+      pbr.baseColorFactor = [1, 1, 1, geo.opacity];
+    }
+    if (geo.texture) {
+      const texIdx = ensureTexture(geo.texture);
+      pbr.baseColorTexture = { index: texIdx, texCoord: 0 };
+    }
+    const material = {
+      name: `${geo.name} material`,
+      pbrMetallicRoughness: pbr
+    };
+    if (geo.opacity !== 1) {
+      material.alphaMode = "BLEND";
+    }
+    materials.push(material);
+    const materialIdx = materials.length - 1;
+    meshes.push({
+      name: geo.name,
+      primitives: [
+        {
+          attributes,
+          indices: indicesAccessor,
+          material: materialIdx,
+          mode: 4
+          // TRIANGLES
+        }
+      ]
+    });
+    nodes.push({ name: geo.name, mesh: meshes.length - 1 });
+  }
+  const totalBytes = byteOffset;
+  const binary = new Uint8Array(totalBytes);
+  let cursor = 0;
+  for (const chunk of chunks) {
+    binary.set(chunk, cursor);
+    cursor += chunk.byteLength;
+  }
+  const json = {
+    asset: { version: "2.0", generator: "ForgeCAD glTF Export" },
+    scene: 0,
+    scenes: [{ nodes: nodes.map((_, i) => i) }],
+    nodes,
+    meshes,
+    accessors,
+    bufferViews,
+    materials,
+    buffers: [{ byteLength: totalBytes }]
+  };
+  if (samplers.length > 0) json.samplers = samplers;
+  if (textures.length > 0) json.textures = textures;
+  if (images.length > 0) json.images = images;
+  return { json, binary };
+}
+function fingerprint2(bytes) {
+  let h = 2166136261 >>> 0;
+  const step = Math.max(1, Math.floor(bytes.byteLength / 256));
+  for (let i = 0; i < bytes.byteLength; i += step) {
+    h ^= bytes[i];
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h ^ bytes.byteLength;
+}
+function buildGltfJson(objects) {
+  const { json, binary } = buildGltf(objects);
+  let base64;
+  if (typeof Buffer !== "undefined") {
+    base64 = Buffer.from(binary).toString("base64");
+  } else {
+    let binaryStr = "";
+    for (let i = 0; i < binary.length; i++) binaryStr += String.fromCharCode(binary[i]);
+    base64 = btoa(binaryStr);
+  }
+  json.buffers[0].uri = `data:application/octet-stream;base64,${base64}`;
+  return JSON.stringify(json);
+}
+function buildGlb(objects) {
+  const { json, binary } = buildGltf(objects);
+  const jsonStr = JSON.stringify(json);
+  const jsonBytes = utf8Encode(jsonStr);
+  const jsonPadded = align4(jsonBytes.byteLength);
+  const jsonChunk = new Uint8Array(jsonPadded);
+  jsonChunk.set(jsonBytes);
+  jsonChunk.fill(32, jsonBytes.byteLength);
+  const binPadded = align4(binary.byteLength);
+  const binChunk = new Uint8Array(binPadded);
+  binChunk.set(binary);
+  const GLB_HEADER = 12;
+  const CHUNK_HEADER = 8;
+  const totalLength = GLB_HEADER + CHUNK_HEADER + jsonChunk.byteLength + CHUNK_HEADER + binChunk.byteLength;
+  const out = new ArrayBuffer(totalLength);
+  const view = new DataView(out);
+  const bytes = new Uint8Array(out);
+  view.setUint32(0, 1179937895, true);
+  view.setUint32(4, 2, true);
+  view.setUint32(8, totalLength, true);
+  let offset = GLB_HEADER;
+  view.setUint32(offset, jsonChunk.byteLength, true);
+  view.setUint32(offset + 4, 1313821514, true);
+  bytes.set(jsonChunk, offset + CHUNK_HEADER);
+  offset += CHUNK_HEADER + jsonChunk.byteLength;
+  view.setUint32(offset, binChunk.byteLength, true);
+  view.setUint32(offset + 4, 5130562, true);
+  bytes.set(binChunk, offset + CHUNK_HEADER);
+  return out;
+}
+function utf8Encode(str) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(str);
+  }
+  return new Uint8Array(Buffer.from(str, "utf-8"));
+}
+
 // cli/forge-mjcf.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname6, extname as extname7, resolve as resolve23 } from "path";
@@ -27456,6 +27852,27 @@ var INSTALL_TARGETS = {
 };
 var ALL_INSTALL_TARGETS = Object.keys(INSTALL_TARGETS);
 var DEFAULT_INSTALL_TARGET = "agents";
+var RETIRED_COMPANION_SKILL_NAMES = [
+  "forgecad-3d-reconstruction",
+  "forgecad-assembly-contract",
+  "forgecad-benchmark-reconstruction",
+  "forgecad-blockout",
+  "forgecad-blockout-model",
+  "forgecad-component-model",
+  "forgecad-high-level-spec",
+  "forgecad-image-replicator",
+  "forgecad-lld",
+  "forgecad-make-a-model",
+  "forgecad-model-grader",
+  "forgecad-mujoco-verify",
+  "forgecad-prepare-prompt",
+  "forgecad-project",
+  "forgecad-reconstruction-benchmark",
+  "forgecad-render-inspect",
+  "forgecad-spec-by-walking-through-it",
+  "forgecad-visual-prompt",
+  "forgecad-visual-spec"
+];
 function installUsage() {
   return [
     "Usage: forgecad skill install [--target agents|claude|codex|opencode|all] [--core-only]",
@@ -27555,6 +27972,9 @@ If you are running from a source checkout, run: npm run build:skill:forgecad`
     );
   }
   mkdirSync6(targetRoot, { recursive: true });
+  for (const name of RETIRED_COMPANION_SKILL_NAMES) {
+    rmSync3(join9(targetRoot, name), { recursive: true, force: true });
+  }
   const installed = [];
   for (const entry of readdirSync6(srcLibrary, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
@@ -28386,15 +28806,27 @@ async function fetchRemoteFiles(projectId) {
   const entries = await res.json();
   return remoteFilesFromInit(entries);
 }
+var SAVE_BODY_LIMIT_BYTES = 10 * 1024 * 1024;
+var formatMiB = (bytes) => `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
 async function saveRemoteFile(projectId, filename, content) {
+  const body = JSON.stringify({ filename, content });
+  const bodyBytes = Buffer.byteLength(body, "utf-8");
+  if (bodyBytes > SAVE_BODY_LIMIT_BYTES) {
+    const contentBytes = Buffer.byteLength(content, "utf-8");
+    throw new Error(
+      `Cannot push "${filename}": its upload is ${formatMiB(bodyBytes)} (file content ${formatMiB(contentBytes)}), over the server's ${formatMiB(SAVE_BODY_LIMIT_BYTES)} per-file limit.
+  Each file is uploaded in its own request, so this is a single oversized file, not the total push size.
+  Fixes: split the file into smaller pieces, trim generated/embedded data (e.g. inline images in SVGs), or keep it out of the project (add it to .gitignore-style skips) if it doesn't need to live on the server.`
+    );
+  }
   const res = await authenticatedFetch(`/api/projects/${projectId}/save`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ filename, content })
+    body
   });
   if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    throw new Error(body.error ?? `Failed to save ${filename} (${res.status})`);
+    const body2 = await res.json().catch(() => ({}));
+    throw new Error(body2.error ?? `Failed to save ${filename} (${res.status})`);
   }
 }
 async function deleteRemoteFile(projectId, filename) {
@@ -37876,6 +38308,135 @@ var PARAM_OPTIONS = [
 var PARAM_OVERRIDE_OPTIONS = PARAM_OPTIONS.filter(
   (option) => option.name === "--param" || option.name === "-p"
 );
+function parseGltfExportArgs(format, argv) {
+  const inputPaths = [];
+  let outputPath;
+  let quality;
+  let backend;
+  const paramOverrides = {};
+  const jointOverrides = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--output" || arg === "-o") {
+      outputPath = argv[i + 1];
+      if (!outputPath) throw new Error("--output requires a file path");
+      i += 1;
+      continue;
+    }
+    if (arg === "--quality" || arg === "-q") {
+      const val = argv[i + 1];
+      if (val !== "default" && val !== "live" && val !== "high") {
+        throw new Error("--quality must be default, live, or high");
+      }
+      quality = val;
+      i += 1;
+      continue;
+    }
+    if (arg === "--backend") {
+      const val = argv[i + 1];
+      if (val !== "manifold" && val !== "occt" && val !== "truck" && val !== "sdf") {
+        throw new Error("--backend must be manifold, occt, truck, or sdf");
+      }
+      backend = val;
+      i += 1;
+      continue;
+    }
+    if (arg === "--joint") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error("--joint requires JointName=Value");
+      addCliJointOverride(value, jointOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      throw new Error(`Unknown flag: ${arg}`);
+    }
+    inputPaths.push(arg);
+  }
+  requireInputPaths(
+    inputPaths,
+    `Usage: forgecad export ${format} <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--param Key=Value] [--joint JointName=Value]`
+  );
+  requireRenderableInputPaths(inputPaths);
+  requireSingleInputForOutputPath(inputPaths, outputPath);
+  return { inputPaths, outputPath, quality, backend, paramOverrides, jointOverrides };
+}
+function defaultGltfOutputPath(scriptPath, sourcePath, format) {
+  const abs = resolvePath(scriptPath);
+  const base = abs.slice(0, abs.length - extname15(abs).length);
+  const stem = base.endsWith(".forge") ? base.slice(0, -6) : base;
+  const target = `${stem}.${format}`;
+  return resolvePath(target) === resolvePath(sourcePath) ? `${stem}.forgecad.${format}` : target;
+}
+function extractGltfMeshObjects(result) {
+  return result.objects.filter((obj) => obj.shape).map((obj) => ({
+    name: obj.name,
+    shape: obj.shape,
+    color: obj.color
+  }));
+}
+async function exportGltfInput(format, scriptPath, outputPath, quality, backend, paramOverrides, jointOverrides) {
+  const input = loadCliScriptInput(scriptPath);
+  await initCliBackend(resolveCliBackend(backend, input) ?? CLI_DEFAULT_BACKEND);
+  const qualityPreset = quality && quality !== "default" ? quality : void 0;
+  setParamOverrides(paramOverrides);
+  const runResult = runScript(input.code, input.fileName, input.allFiles, {
+    ...qualityPreset ? { quality: qualityPreset } : {},
+    readBinaryFile: input.readBinaryFile,
+    assemblyState: jointOverrides
+  });
+  const result = applyCliJointOverrides(runResult, jointOverrides);
+  if (result.error) {
+    throw new Error(`ERROR: ${result.error}`);
+  }
+  const meshObjects = extractGltfMeshObjects(result);
+  if (meshObjects.length === 0) {
+    throw new Error("No 3D shapes found in the script output.");
+  }
+  if (outputPath && resolvePath(outputPath) === input.sourcePath) {
+    throw new Error("Output path would overwrite the input file. Pass a different --output path.");
+  }
+  const target = resolvePath(outputPath ?? defaultGltfOutputPath(scriptPath, input.sourcePath, format));
+  if (format === "glb") {
+    const buffer = buildGlb(meshObjects);
+    writeFileSync22(target, Buffer.from(buffer));
+  } else {
+    const json = buildGltfJson(meshObjects);
+    writeFileSync22(target, json, "utf-8");
+  }
+  const stats = meshObjects.map((obj) => {
+    const mesh = obj.shape.getMesh();
+    const textured = mesh.numProp === 8 || Boolean(obj.shape.materialProps?.texture);
+    return `  ${obj.name}: ${mesh.numTri.toLocaleString()} triangles${textured ? " (textured)" : ""}`;
+  });
+  console.log(`\u2713 Exported ${format.toUpperCase()} to ${target}`);
+  console.log(`  ${meshObjects.length} object(s)${quality ? ` [quality: ${quality}]` : ""}`);
+  stats.forEach((line) => console.log(line));
+}
+async function runGltfExportCli(format, argv) {
+  const { inputPaths, outputPath, quality, backend, paramOverrides, jointOverrides } = parseGltfExportArgs(format, argv);
+  requireExistingInputPaths(inputPaths);
+  let failures = 0;
+  for (const [index, scriptPath] of inputPaths.entries()) {
+    printBatchHeader(scriptPath, index, inputPaths.length);
+    try {
+      await exportGltfInput(format, scriptPath, outputPath, quality, backend, paramOverrides, jointOverrides);
+    } catch (error) {
+      failures += 1;
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
 var RENDER_OPTIONS = [
   ...PARAM_OPTIONS,
   {
@@ -38097,6 +38658,19 @@ var INSPECT_EVIDENCE_OPTIONS = [
     argument: "required",
     valueLabel: "<n>"
   },
+  {
+    name: "--bands",
+    description: "Quantize the heatmap fill into N discrete contour bands (0 = smooth ramp)",
+    argument: "required",
+    valueLabel: "<n>"
+  },
+  { name: "--iso", description: "Draw anti-aliased isolines on the heatmap surface" },
+  {
+    name: "--iso-width",
+    description: "Isoline width in screen pixels (default 1.5)",
+    argument: "required",
+    valueLabel: "<px>"
+  },
   {
     name: "--with",
     description: "Reference model for comparison evidence",
@@ -38209,6 +38783,11 @@ function inspectEvidenceOptions(definition) {
   if (definition.channel === "roughness") {
     names.add("--roughness-samples");
   }
+  if (definition.channel === "thickness" || definition.channel === "roughness") {
+    for (const name of ["--bands", "--iso", "--iso-width"]) {
+      names.add(name);
+    }
+  }
   if (definition.channel === "collisions") {
     names.add("--joint-sweep");
   }
@@ -39701,6 +40280,78 @@ var commands = [
     },
     run: (args) => runMeshExportCli("stl", args)
   },
+  {
+    group: "Export",
+    path: ["export", "glb"],
+    summary: "Export a Forge script to binary glTF (.glb) with PBR materials and embedded textures.",
+    usage: [
+      "forgecad export glb <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--param Key=Value] [--joint JointName=Value]"
+    ],
+    examples: [
+      "forgecad export glb examples/products/cup.forge.js",
+      "forgecad export glb examples/products/cup.forge.js --output out/cup.glb",
+      "forgecad export glb examples/products/cup.forge.js examples/api/boolean-operations.forge.js",
+      "forgecad export glb examples/products/cup.forge.js --quality high"
+    ],
+    completion: {
+      options: [
+        ...PARAM_OPTIONS,
+        { name: "--output", description: "Output GLB path", argument: "required", valueLabel: "<path>", valueKind: "path" },
+        {
+          name: "--quality",
+          description: "Forge quality preset",
+          argument: "required",
+          valueLabel: "<default|live|high>",
+          values: QUALITY_VALUES
+        },
+        {
+          name: "--backend",
+          description: "Geometry backend (default: manifold)",
+          argument: "required",
+          valueLabel: "<manifold|occt|truck|sdf>",
+          values: BACKEND_VALUES
+        }
+      ],
+      positionals: [{ description: "Forge script or CAD asset", valueKind: "renderable", repeatable: true }]
+    },
+    run: (args) => runGltfExportCli("glb", args)
+  },
+  {
+    group: "Export",
+    path: ["export", "gltf"],
+    summary: "Export a Forge script to text glTF (.gltf) with PBR materials and embedded textures.",
+    usage: [
+      "forgecad export gltf <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--param Key=Value] [--joint JointName=Value]"
+    ],
+    examples: [
+      "forgecad export gltf examples/products/cup.forge.js",
+      "forgecad export gltf examples/products/cup.forge.js --output out/cup.gltf",
+      "forgecad export gltf examples/products/cup.forge.js examples/api/boolean-operations.forge.js",
+      "forgecad export gltf examples/products/cup.forge.js --quality high"
+    ],
+    completion: {
+      options: [
+        ...PARAM_OPTIONS,
+        { name: "--output", description: "Output glTF path", argument: "required", valueLabel: "<path>", valueKind: "path" },
+        {
+          name: "--quality",
+          description: "Forge quality preset",
+          argument: "required",
+          valueLabel: "<default|live|high>",
+          values: QUALITY_VALUES
+        },
+        {
+          name: "--backend",
+          description: "Geometry backend (default: manifold)",
+          argument: "required",
+          valueLabel: "<manifold|occt|truck|sdf>",
+          values: BACKEND_VALUES
+        }
+      ],
+      positionals: [{ description: "Forge script or CAD asset", valueKind: "renderable", repeatable: true }]
+    },
+    run: (args) => runGltfExportCli("gltf", args)
+  },
   {
     group: "Export",
     path: ["export", "gcode"],
@@ -41194,7 +41845,7 @@ var commands = [
         { name: "--update", description: "Regenerate compiler snapshots" }
       ]
     },
-    run: async (args) => (await import("./check-compiler-HPF2T2FS.js")).runCheckCompilerCli(args)
+    run: async (args) => (await import("./check-compiler-4RPB6SB5.js")).runCheckCompilerCli(args)
   },
   {
     group: "Checks",
@@ -41217,7 +41868,7 @@ var commands = [
         { name: "--update", description: "Regenerate query-propagation snapshots" }
       ]
     },
-    run: async (args) => (await import("./check-query-propagation-HYSLTXAB.js")).runCheckQueryPropagationCli(args)
+    run: async (args) => (await import("./check-query-propagation-KN3DFQTX.js")).runCheckQueryPropagationCli(args)
   },
   {
     group: "Checks",