forgecad 0.9.15 → 0.9.16

package/dist/assets/{inspectWorker-COyp8XXA.js → inspectWorker-BuTJDVX6.js}

@@ -12589,6 +12589,7 @@ class Transform {
     return this.rotateAxis([0, 0, 1], angleDeg, pivot);
   }
   /** Scale after the current transform. */
+  // biome-ignore lint/suspicious/useAdjacentOverloadSignatures: Static Transform.scale() and chainable instance scale() intentionally share the CAD API name.
   scale(v) {
     return this.mul(Transform.scale(v));
   }
@@ -30024,18 +30025,18 @@ function faceAxes(face) {
   }
   return {};
 }
-function edgeKey$1(start, end) {
+function edgeKey$2(start, end) {
   const encode = (p2) => p2.map((value) => value.toFixed(9)).join(",");
   const a2 = encode(start);
   const b = encode(end);
   return a2 < b ? `${a2}|${b}` : `${b}|${a2}`;
 }
 function faceEdgeIndex(face, start, end) {
-  const target = edgeKey$1(start, end);
+  const target = edgeKey$2(start, end);
   for (let i = 0; i < face.vertices.length; i++) {
     const faceStart = face.vertices[i];
     const faceEnd = face.vertices[(i + 1) % face.vertices.length];
-    if (faceStart && faceEnd && edgeKey$1(faceStart, faceEnd) === target) return i;
+    if (faceStart && faceEnd && edgeKey$2(faceStart, faceEnd) === target) return i;
   }
   return null;
 }
@@ -30236,7 +30237,7 @@ function topologyPayloadToTopology(payload) {
     const start = explicitVertices[explicitEdge.vertices[0]];
     const end = explicitVertices[explicitEdge.vertices[1]];
     if (!isVec3(start) || !isVec3(end)) continue;
-    const key = edgeKey$1(start, end);
+    const key = edgeKey$2(start, end);
     if (seenEdges.has(key)) continue;
     seenEdges.set(key, edges.size);
     const display = explicitEdgeDisplayName(payload, explicitEdge, explicitEdgeIndex, start, end);
@@ -30256,7 +30257,7 @@ function topologyPayloadToTopology(payload) {
         const start = face.vertices[i];
         const end = face.vertices[(i + 1) % face.vertices.length];
         if (!start || !end) continue;
-        const key = edgeKey$1(start, end);
+        const key = edgeKey$2(start, end);
         if (seenEdges.has(key)) continue;
         seenEdges.set(key, edges.size);
         edges.set(`${face.id}:edge-${i}`, {
@@ -48788,6 +48789,92 @@ function percentile(sorted, q) {
   const index2 = MathUtils.clamp(Math.floor(sorted.length * q), 0, sorted.length - 1);
   return Number(sorted[index2].toFixed(2));
 }
+class DisjointSet {
+  constructor(size) {
+    __publicField(this, "parent");
+    __publicField(this, "rank");
+    this.parent = Array.from({ length: size }, (_2, index2) => index2);
+    this.rank = Array.from({ length: size }, () => 0);
+  }
+  find(index2) {
+    const parent = this.parent[index2];
+    if (parent === index2) return index2;
+    const root = this.find(parent);
+    this.parent[index2] = root;
+    return root;
+  }
+  union(a2, b) {
+    const rootA = this.find(a2);
+    const rootB = this.find(b);
+    if (rootA === rootB) return;
+    if (this.rank[rootA] < this.rank[rootB]) {
+      this.parent[rootA] = rootB;
+    } else if (this.rank[rootA] > this.rank[rootB]) {
+      this.parent[rootB] = rootA;
+    } else {
+      this.parent[rootB] = rootA;
+      this.rank[rootA] += 1;
+    }
+  }
+}
+function connectedCoplanarSurfacePatches(triangles) {
+  const snap = surfacePatchSnap(triangles);
+  const planeKeys = triangles.map((triangle) => planeKey(triangle, snap));
+  const edgeOwners = /* @__PURE__ */ new Map();
+  const sets = new DisjointSet(triangles.length);
+  triangles.forEach((triangle, index2) => {
+    for (const key of triangleEdgeKeys(triangle, snap)) {
+      const owners = edgeOwners.get(key);
+      if (owners) {
+        for (const owner of owners) {
+          if (planeKeys[owner] === planeKeys[index2]) sets.union(owner, index2);
+        }
+        owners.push(index2);
+      } else {
+        edgeOwners.set(key, [index2]);
+      }
+    }
+  });
+  const patchByRoot = /* @__PURE__ */ new Map();
+  triangles.forEach((triangle, index2) => {
+    const root = sets.find(index2);
+    const patch = patchByRoot.get(root) ?? { triangleIndexes: [], area: 0 };
+    patch.triangleIndexes.push(index2);
+    patch.area += triangle.area;
+    patchByRoot.set(root, patch);
+  });
+  return [...patchByRoot.values()];
+}
+function surfacePatchSnap(triangles) {
+  const bounds = new Box3();
+  for (const triangle of triangles) {
+    bounds.expandByPoint(triangle.a);
+    bounds.expandByPoint(triangle.b);
+    bounds.expandByPoint(triangle.c);
+  }
+  const size = bounds.getSize(new Vector3());
+  return Math.max(1e-6, size.length() * 1e-8);
+}
+function planeKey(triangle, snap) {
+  const normalSnap = 1e-6;
+  const distance = triangle.normal.dot(triangle.a);
+  return [
+    Math.round(triangle.normal.x / normalSnap),
+    Math.round(triangle.normal.y / normalSnap),
+    Math.round(triangle.normal.z / normalSnap),
+    Math.round(distance / snap)
+  ].join(",");
+}
+function triangleEdgeKeys(triangle, snap) {
+  const vertices = [vertexKey$2(triangle.a, snap), vertexKey$2(triangle.b, snap), vertexKey$2(triangle.c, snap)];
+  return [edgeKey$1(vertices[0], vertices[1]), edgeKey$1(vertices[1], vertices[2]), edgeKey$1(vertices[2], vertices[0])];
+}
+function vertexKey$2(point, snap) {
+  return `${Math.round(point.x / snap)},${Math.round(point.y / snap)},${Math.round(point.z / snap)}`;
+}
+function edgeKey$1(a2, b) {
+  return a2 < b ? `${a2}|${b}` : `${b}|${a2}`;
+}
 const MIN_TRIANGLE_AREA = 1e-12;
 const R2_ALPHA = 0.7548776662466927;
 const R2_BETA = 0.5698402909980532;
@@ -48840,7 +48927,7 @@ function allocateAreaSampleCounts(triangles, maxSamples) {
   return counts;
 }
 function sampleSurfaceTriangles(triangles, maxSamples) {
-  const counts = allocateAreaSampleCounts(triangles, maxSamples);
+  const counts = allocateSurfacePatchSampleCounts(triangles, maxSamples);
   const samples = [];
   const position = new Vector3();
   let sampleIndex = 0;
@@ -48865,6 +48952,35 @@ function sampleSurfaceTriangles(triangles, maxSamples) {
   });
   return samples;
 }
+function allocateSurfacePatchSampleCounts(triangles, maxSamples) {
+  const counts = new Array(triangles.length).fill(0);
+  if (triangles.length === 0) return counts;
+  const patches = connectedCoplanarSurfacePatches(triangles);
+  const patchCounts = allocateAreaSampleCounts(
+    patches.map((patch, index2) => {
+      var _a3, _b3, _c2, _d2;
+      return {
+        index: index2,
+        a: ((_a3 = triangles[patch.triangleIndexes[0]]) == null ? void 0 : _a3.a) ?? new Vector3(),
+        b: ((_b3 = triangles[patch.triangleIndexes[0]]) == null ? void 0 : _b3.b) ?? new Vector3(),
+        c: ((_c2 = triangles[patch.triangleIndexes[0]]) == null ? void 0 : _c2.c) ?? new Vector3(),
+        normal: ((_d2 = triangles[patch.triangleIndexes[0]]) == null ? void 0 : _d2.normal) ?? new Vector3(0, 0, 1),
+        area: patch.area
+      };
+    }),
+    maxSamples
+  );
+  patches.forEach((patch, patchIndex) => {
+    const patchBudget = patchCounts[patchIndex] ?? 0;
+    if (patchBudget <= 0) return;
+    const patchTriangles = patch.triangleIndexes.map((index2) => triangles[index2]);
+    const localCounts = allocateAreaSampleCounts(patchTriangles, patchBudget);
+    patch.triangleIndexes.forEach((triangleIndex, localIndex) => {
+      counts[triangleIndex] += localCounts[localIndex] ?? 0;
+    });
+  });
+  return counts;
+}
 function totalSurfaceArea(triangles) {
   return triangles.reduce((sum2, triangle) => sum2 + triangle.area, 0);
 }
@@ -49045,16 +49161,23 @@ const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
   minThickness: 1.2,
   warnThickness: 2,
   maxThickness: 6,
+  colorMinThickness: 0,
+  colorMaxThickness: 6,
   maxSamplesPerObject: 5e3,
   contactTolerance: DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance
 };
 const THICKNESS_COLORS = {
   critical: [255, 28, 28],
-  warning: [255, 150, 0],
   ok: [60, 220, 90],
   thick: [70, 145, 255],
   unknown: [90, 90, 90]
 };
+const THICKNESS_GRADIENT_COLORS = [
+  THICKNESS_COLORS.critical,
+  [255, 222, 0],
+  THICKNESS_COLORS.ok,
+  THICKNESS_COLORS.thick
+];
 function finitePositive(value, fallback, label) {
   if (value === void 0) return fallback;
   if (!Number.isFinite(value) || value <= 0) {
@@ -49073,6 +49196,16 @@ function resolveThicknessInspectionOptions(raw = {}) {
   const minThickness = finitePositive(raw.minThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.minThickness, "minThickness");
   const warnThickness = finitePositive(raw.warnThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.warnThickness, "warnThickness");
   const maxThickness = finitePositive(raw.maxThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxThickness, "maxThickness");
+  const colorMinThickness = finiteNonNegative(
+    raw.colorMinThickness,
+    DEFAULT_THICKNESS_INSPECTION_OPTIONS.colorMinThickness,
+    "colorMinThickness"
+  );
+  const colorMaxThickness = finitePositive(
+    raw.colorMaxThickness,
+    DEFAULT_THICKNESS_INSPECTION_OPTIONS.colorMaxThickness,
+    "colorMaxThickness"
+  );
   const maxSamplesPerObject = finitePositive(
     raw.maxSamplesPerObject,
     DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxSamplesPerObject,
@@ -49089,10 +49222,15 @@ function resolveThicknessInspectionOptions(raw = {}) {
   if (warnThickness > maxThickness) {
     throw new Error("warnThickness must be less than or equal to maxThickness.");
   }
+  if (colorMinThickness >= colorMaxThickness) {
+    throw new Error("colorMinThickness must be less than colorMaxThickness.");
+  }
   return {
     minThickness,
     warnThickness,
     maxThickness,
+    colorMinThickness,
+    colorMaxThickness,
     maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject)),
     contactTolerance
   };
@@ -49103,6 +49241,16 @@ function lerp$1(a2, b, t) {
 function lerpColor(a2, b, t) {
   return [Math.round(lerp$1(a2[0], b[0], t)), Math.round(lerp$1(a2[1], b[1], t)), Math.round(lerp$1(a2[2], b[2], t))];
 }
+function gradientColor(stops, t) {
+  if (stops.length === 0) return THICKNESS_COLORS.unknown;
+  if (stops.length === 1) return stops[0] ?? THICKNESS_COLORS.unknown;
+  const clamped = Math.max(0, Math.min(1, t));
+  const scaled = clamped * (stops.length - 1);
+  const leftIndex = Math.min(stops.length - 2, Math.floor(scaled));
+  const left = stops[leftIndex] ?? THICKNESS_COLORS.unknown;
+  const right = stops[leftIndex + 1] ?? left;
+  return lerpColor(left, right, scaled - leftIndex);
+}
 function thicknessClass(thickness, options) {
   if (thickness == null || !Number.isFinite(thickness) || thickness <= 0) return "unknown";
   if (thickness <= options.minThickness) return "critical";
@@ -49111,18 +49259,9 @@ function thicknessClass(thickness, options) {
   return "thick";
 }
 function thicknessColor(thickness, options) {
-  const cls = thicknessClass(thickness, options);
-  if (cls === "unknown") return THICKNESS_COLORS.unknown;
-  if (cls === "critical") return THICKNESS_COLORS.critical;
-  if (cls === "warning") {
-    const span = Math.max(1e-9, options.warnThickness - options.minThickness);
-    return lerpColor(THICKNESS_COLORS.critical, THICKNESS_COLORS.warning, ((thickness ?? 0) - options.minThickness) / span);
-  }
-  if (cls === "ok") {
-    const span = Math.max(1e-9, options.maxThickness - options.warnThickness);
-    return lerpColor(THICKNESS_COLORS.ok, THICKNESS_COLORS.thick, ((thickness ?? 0) - options.warnThickness) / span);
-  }
-  return THICKNESS_COLORS.thick;
+  if (thickness == null || !Number.isFinite(thickness) || thickness <= 0) return THICKNESS_COLORS.unknown;
+  const span = Math.max(1e-9, options.colorMaxThickness - options.colorMinThickness);
+  return gradientColor(THICKNESS_GRADIENT_COLORS, (thickness - options.colorMinThickness) / span);
 }
 function cloneGeometryForFaceColors(geometry) {
   return geometry.index ? geometry.toNonIndexed() : geometry.clone();
@@ -49986,7 +50125,7 @@ for (let radius = 0; radius <= MAX_SEARCH_RADIUS; radius += 1) {
 function gridKey(x2, y2, z2) {
   return `${x2},${y2},${z2}`;
 }
-function buildGeometryBounds(geometry) {
+function buildInspectHeatmapFieldBounds(geometry) {
   const position = geometry.getAttribute("position");
   if (!position || position.count === 0) return null;
   const bounds = new Box3().setFromBufferAttribute(position);
@@ -49994,7 +50133,11 @@ function buildGeometryBounds(geometry) {
   const size = bounds.getSize(new Vector3());
   const pad = Math.max(size.x, size.y, size.z, 1) * 1e-5;
   bounds.expandByScalar(pad);
-  return bounds;
+  const boundsSize = bounds.getSize(new Vector3());
+  return {
+    boundsMin: [bounds.min.x, bounds.min.y, bounds.min.z],
+    boundsSize: [boundsSize.x, boundsSize.y, boundsSize.z]
+  };
 }
 function buildSampleGrid(pointCloud) {
   const sampleCount = Math.floor(pointCloud.positions.length / 3);
@@ -50078,11 +50221,15 @@ function blendedColorAt(point, pointCloud, sampleGrid) {
   return [r / weightSum, g2 / weightSum, b / weightSum];
 }
 function buildInspectHeatmapFieldData(geometry, pointCloud) {
-  const bounds = buildGeometryBounds(geometry);
+  const bounds = buildInspectHeatmapFieldBounds(geometry);
+  return bounds ? buildInspectHeatmapFieldDataFromBounds(bounds, pointCloud) : null;
+}
+function buildInspectHeatmapFieldDataFromBounds(bounds, pointCloud) {
   const sampleGrid = buildSampleGrid(pointCloud);
   if (!bounds || !sampleGrid) return null;
   const gridSize = fieldGridSizeForSampleCount(Math.floor(pointCloud.positions.length / 3));
-  const boundsSize = bounds.getSize(new Vector3());
+  const boundsMin = new Vector3(...bounds.boundsMin);
+  const boundsSize = new Vector3(...bounds.boundsSize);
   const data = new Uint8Array(gridSize * gridSize * gridSize * 4);
   const point = new Vector3();
   let dataOffset = 0;
@@ -50090,9 +50237,9 @@ function buildInspectHeatmapFieldData(geometry, pointCloud) {
     for (let z2 = 0; z2 < gridSize; z2 += 1) {
       for (let x2 = 0; x2 < gridSize; x2 += 1) {
         point.set(
-          bounds.min.x + boundsSize.x * x2 / (gridSize - 1),
-          bounds.min.y + boundsSize.y * y2 / (gridSize - 1),
-          bounds.min.z + boundsSize.z * z2 / (gridSize - 1)
+          boundsMin.x + boundsSize.x * x2 / (gridSize - 1),
+          boundsMin.y + boundsSize.y * y2 / (gridSize - 1),
+          boundsMin.z + boundsSize.z * z2 / (gridSize - 1)
         );
         const [r, g2, b] = blendedColorAt(point, pointCloud, sampleGrid);
         data[dataOffset] = Math.max(0, Math.min(255, Math.round(r)));
@@ -50105,13 +50252,14 @@ function buildInspectHeatmapFieldData(geometry, pointCloud) {
   }
   return {
     data,
-    boundsMin: [bounds.min.x, bounds.min.y, bounds.min.z],
+    boundsMin: bounds.boundsMin,
     boundsSize: [boundsSize.x, boundsSize.y, boundsSize.z],
     gridSize
   };
 }
 const workerScope = self;
 let manifoldReadyPromise = null;
+let cachedThicknessColorizeAnalysis = null;
 function ensureManifoldReady() {
   if (!manifoldReadyPromise) manifoldReadyPromise = initKernelManifoldOnly();
   return manifoldReadyPromise;
@@ -50157,6 +50305,7 @@ function geometryFromPositions(positions) {
 function pointBuffers(samples) {
   const positions = new Float32Array(samples.length * 3);
   const colors = new Float32Array(samples.length * 3);
+  const values = new Float32Array(samples.length);
   samples.forEach((sample, index2) => {
     const base = index2 * 3;
     positions[base] = sample.position[0] + sample.normal[0] * 0.025;
@@ -50165,8 +50314,9 @@ function pointBuffers(samples) {
     colors[base] = sample.color[0] / 255;
     colors[base + 1] = sample.color[1] / 255;
     colors[base + 2] = sample.color[2] / 255;
+    values[index2] = sample.value ?? Number.NaN;
   });
-  return { positions, colors };
+  return { positions, colors, values };
 }
 function rgbFloatsForHex(hex) {
   const color = new Color(hex);
@@ -50191,6 +50341,7 @@ function analyzeScalarChannel(request) {
   const pointObjects = [];
   const heatmapFieldObjects = [];
   const warnings = [];
+  const thicknessCacheObjects = [];
   for (const object of request.objects) {
     if (!object.positions || object.positions.length < 9) continue;
     const geometry = geometryFromPositions(object.positions);
@@ -50198,13 +50349,22 @@ function analyzeScalarChannel(request) {
       const analysis = request.channel === "thickness" ? analyzeThicknessGeometry(geometry, request.thickness) : analyzeRoughnessGeometry(geometry, request.roughness);
       analysis.warnings.forEach((warning) => warnings.push(`${object.name}: ${warning}`));
       const buffers = pointBuffers(analysis.pointSamples);
-      const field = buildInspectHeatmapFieldData(analysis.geometry, buffers);
+      const heatmapBounds = buildInspectHeatmapFieldBounds(analysis.geometry);
+      const field = heatmapBounds ? buildInspectHeatmapFieldDataFromBounds(heatmapBounds, buffers) : buildInspectHeatmapFieldData(analysis.geometry, buffers);
       if (field) {
         heatmapFieldObjects.push({
           objectId: object.id,
           ...field
         });
       }
+      if (request.channel === "thickness" && buffers.values) {
+        thicknessCacheObjects.push({
+          objectId: object.id,
+          positions: new Float32Array(buffers.positions),
+          values: new Float32Array(buffers.values),
+          heatmapBounds
+        });
+      }
       pointObjects.push({
         objectId: object.id,
         sampleCount: analysis.pointSamples.length,
@@ -50215,7 +50375,9 @@ function analyzeScalarChannel(request) {
       geometry.dispose();
     }
   }
+  cachedThicknessColorizeAnalysis = request.channel === "thickness" ? { analysisId: request.reqId, objects: thicknessCacheObjects } : null;
   return {
+    analysisId: request.reqId,
     channel: request.channel,
     objectColors: {},
     pointObjects,
@@ -50225,6 +50387,47 @@ function analyzeScalarChannel(request) {
     warnings
   };
 }
+function thicknessColorsForValues(values, colorMinThickness, colorMaxThickness) {
+  const options = resolveThicknessInspectionOptions({ colorMinThickness, colorMaxThickness });
+  const colors = new Float32Array(values.length * 3);
+  for (let index2 = 0; index2 < values.length; index2 += 1) {
+    const color = thicknessColor(values[index2], options);
+    const offset = index2 * 3;
+    colors[offset] = color[0] / 255;
+    colors[offset + 1] = color[1] / 255;
+    colors[offset + 2] = color[2] / 255;
+  }
+  return colors;
+}
+function colorizeThicknessAnalysis(request) {
+  const cached = cachedThicknessColorizeAnalysis;
+  if (!cached || cached.analysisId !== request.analysisId) {
+    throw new Error("Thickness colorize cache is no longer available.");
+  }
+  const pointObjects = [];
+  const heatmapFieldObjects = [];
+  for (const object of cached.objects) {
+    const colors = thicknessColorsForValues(object.values, request.colorMinThickness, request.colorMaxThickness);
+    pointObjects.push({ objectId: object.objectId, colors });
+    if (object.heatmapBounds) {
+      const field = buildInspectHeatmapFieldDataFromBounds(object.heatmapBounds, {
+        positions: object.positions,
+        colors
+      });
+      if (field) {
+        heatmapFieldObjects.push({
+          objectId: object.objectId,
+          ...field
+        });
+      }
+    }
+  }
+  return {
+    analysisId: cached.analysisId,
+    pointObjects,
+    heatmapFieldObjects
+  };
+}
 function analyzeConnectivityChannel(request) {
   const bodyInput = buildMeshBodyConnectivityInput(
     request.objects.map((object) => ({
@@ -50391,7 +50594,11 @@ function analyzeCollisionChannel(request) {
 }
 function transferFor(result) {
   return [
-    ...result.pointObjects.flatMap((object) => [object.positions.buffer, object.colors.buffer]),
+    ...result.pointObjects.flatMap((object) => [
+      object.positions.buffer,
+      object.colors.buffer,
+      ...object.values ? [object.values.buffer] : []
+    ]),
     ...result.meshColorObjects.map((object) => object.colors.buffer),
     ...result.heatmapFieldObjects.map((object) => object.data.buffer),
     ...result.collisionGeometryObjects.flatMap((object) => [object.positions.buffer, object.normals.buffer, object.edgePositions.buffer])
@@ -50399,6 +50606,21 @@ function transferFor(result) {
 }
 async function handleRequest(request) {
   try {
+    if (request.type === "colorize-thickness") {
+      const result2 = colorizeThicknessAnalysis(request.payload);
+      const response2 = {
+        type: "inspect-colorize-success",
+        payload: {
+          reqId: request.payload.reqId,
+          result: result2
+        }
+      };
+      workerScope.postMessage(response2, [
+        ...result2.pointObjects.map((object) => object.colors.buffer),
+        ...result2.heatmapFieldObjects.map((object) => object.data.buffer)
+      ]);
+      return;
+    }
     if (request.payload.channel === "collisions") await ensureManifoldReady();
     const result = request.payload.channel === "thickness" || request.payload.channel === "roughness" ? analyzeScalarChannel(request.payload) : request.payload.channel === "collisions" ? analyzeCollisionChannel(request.payload) : analyzeConnectivityChannel(request.payload);
     const response = {

package/dist/assets/{targets-B9sGB5nB.js → jointPose-B_Cgedn9.js}

@@ -1,4 +1,4 @@
-import { c2 as parseViewportCameraState } from "./scalar-sampling-budget-wJF98aY9.js";
+import { c1 as parseViewportCameraState } from "./scalar-sampling-budget-J5cuzxT1.js";
 const roundNumber = (value, digits) => {
   const scale = 10 ** digits;
   return Math.round(value * scale) / scale;
@@ -148,10 +148,78 @@ function getSceneObjectKind(object) {
   if (object.shape) return "shape";
   return "object";
 }
+function hasJointOverrides(overrides) {
+  return Boolean(overrides && Object.keys(overrides).length > 0);
+}
+function resolveJointSliderRange(joint) {
+  return {
+    min: joint.min ?? (joint.type === "prismatic" ? -100 : 0),
+    max: joint.max ?? (joint.type === "prismatic" ? 100 : 360)
+  };
+}
+function editableJointNames(view) {
+  const coupledTargets = new Set(view.couplings.map((coupling) => coupling.joint));
+  return view.joints.filter((joint) => !joint.hidden && !coupledTargets.has(joint.name)).map((joint) => joint.name);
+}
+function availableText(names) {
+  return names.length > 0 ? names.join(", ") : "(none)";
+}
+function validateJointOverrides(view, overrides, flag = "--joint") {
+  var _a;
+  if (!hasJointOverrides(overrides)) return;
+  if (!view || view.enabled === false || view.joints.length === 0) {
+    throw new Error(`${flag} requires a Forge script that exposes Motion tab joints. Available joints: (none).`);
+  }
+  const jointsByName = new Map(view.joints.map((joint) => [joint.name, joint]));
+  const coupledTargets = new Set(view.couplings.map((coupling) => coupling.joint));
+  const available = editableJointNames(view);
+  for (const [name, value] of Object.entries(overrides)) {
+    const joint = jointsByName.get(name);
+    if (!joint) {
+      throw new Error(`Unknown joint "${name}" for ${flag}. Available editable joints: ${availableText(available)}.`);
+    }
+    if (joint.hidden) {
+      throw new Error(`Joint "${name}" is hidden and cannot be set with ${flag}. Available editable joints: ${availableText(available)}.`);
+    }
+    if (coupledTargets.has(name)) {
+      const drivers = (_a = view.couplings.find((coupling) => coupling.joint === name)) == null ? void 0 : _a.terms.map((term) => term.joint).join(", ");
+      throw new Error(
+        `Joint "${name}" is driven by a coupling and cannot be set with ${flag}.` + (drivers ? ` Set driver joint(s): ${drivers}.` : ` Available editable joints: ${availableText(available)}.`)
+      );
+    }
+    const { min, max } = resolveJointSliderRange(joint);
+    if (value < min || value > max) {
+      throw new Error(`Joint "${name}" value ${value} is outside Motion tab range [${min}, ${max}].`);
+    }
+  }
+}
+function buildBaseJointValues(joints, overrides = {}) {
+  const values = {};
+  joints.forEach((joint) => {
+    values[joint.name] = overrides[joint.name] ?? joint.defaultValue;
+  });
+  return values;
+}
+function formatJointNumber(value) {
+  const rounded = Number(value.toFixed(6));
+  return Object.is(rounded, -0) ? "0" : String(rounded);
+}
+function quoteForCli(value) {
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function formatCliJointPoseFlags(joints, displayedValues, coupledJointNames) {
+  return joints.filter((joint) => !joint.hidden && !coupledJointNames.has(joint.name)).map((joint) => {
+    const value = displayedValues[joint.name] ?? joint.defaultValue;
+    return `--joint ${quoteForCli(`${joint.name}=${formatJointNumber(value)}`)}`;
+  }).join(" ");
+}
 export {
   getSceneObjectKind as a,
-  formatRenderSceneCliSpec as f,
+  buildBaseJointValues as b,
+  formatRenderSceneCliSpec as c,
+  formatCliJointPoseFlags as f,
   getSceneObjectTreePath as g,
   mergeViewportRenderSceneStates as m,
-  parseRenderSceneCliSpec as p
+  parseRenderSceneCliSpec as p,
+  validateJointOverrides as v
 };

package/dist/assets/{manifold-DNkrUWpA.js → manifold-BWgsjmAM.js}

@@ -12,7 +12,7 @@ var Module = (() => {
     var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
     var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
     if (ENVIRONMENT_IS_NODE) {
-      const { createRequire } = await import("./evalWorker-CU0Ke6DP.js").then(function(n) {
+      const { createRequire } = await import("./evalWorker-vkx310U2.js").then(function(n) {
         return n._;
       });
       var require2 = createRequire(import.meta.url);

package/dist/assets/{manifold-C-3h2M7p.js → manifold-D6IFSkhH.js}

@@ -1,4 +1,4 @@
-import { _ as __vitePreload } from "./scalar-sampling-budget-wJF98aY9.js";
+import { _ as __vitePreload } from "./scalar-sampling-budget-J5cuzxT1.js";
 var Module = (() => {
   var _scriptName = import.meta.url;
   return (async function(moduleArg = {}) {
@@ -14,7 +14,7 @@ var Module = (() => {
     var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
     if (ENVIRONMENT_IS_NODE) {
       const { createRequire } = await __vitePreload(async () => {
-        const { createRequire: createRequire2 } = await import("./scalar-sampling-budget-wJF98aY9.js").then((n) => n.df);
+        const { createRequire: createRequire2 } = await import("./scalar-sampling-budget-J5cuzxT1.js").then((n) => n.dg);
         return { createRequire: createRequire2 };
       }, true ? [] : void 0);
       var require2 = createRequire(import.meta.url);

package/dist/assets/{manifold-BRI5prcH.js → manifold-rZexZI0G.js}

@@ -12,7 +12,7 @@ var Module = (() => {
     var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
     var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
     if (ENVIRONMENT_IS_NODE) {
-      const { createRequire } = await import("./reportWorker-CdBz5bNg.js").then(function(n) {
+      const { createRequire } = await import("./reportWorker-0AGij1Ru.js").then(function(n) {
         return n._;
       });
       var require2 = createRequire(import.meta.url);