@toolpath/viewer 1.5.0 → 2.1.0

package/dist/index.js

@@ -152,6 +152,7 @@ import {
   trackDoubleTaps,
   trackTaps,
   useContentBox,
+  usePartContext,
   useRetarget,
   useSectionStore,
   useTapGuard,
@@ -161,7 +162,50 @@ import {
   viewUp,
   viewVector,
   visualSurfaces
-} from "./chunk-4TBLMR4Z.js";
+} from "./chunk-WTTOUG4P.js";
+
+// src/render/feature-triangles.ts
+var EMPTY = { positions: new Float32Array(), normals: new Float32Array() };
+function featureTriangles(model, geometry, tag) {
+  const position = geometry.getAttribute("position");
+  if (!position) return EMPTY;
+  const normal = geometry.getAttribute("normal");
+  const index = geometry.getIndex();
+  const vertex = (corner) => index ? index.getX(corner) : corner;
+  const triangleCount = Math.floor((index ? index.count : position.count) / 3);
+  const positions = [];
+  const normals = [];
+  for (const region of new Set(model.regionIndex.regionsForFeature(tag))) {
+    const range = model.regionIndex.rangeForRegion(region);
+    if (!range) continue;
+    for (let triangle = range.start; triangle < Math.min(range.end, triangleCount); triangle++) {
+      const corners = [vertex(triangle * 3), vertex(triangle * 3 + 1), vertex(triangle * 3 + 2)];
+      const at = corners.map((corner) => [
+        position.getX(corner),
+        position.getY(corner),
+        position.getZ(corner)
+      ]);
+      const out = normal ? corners.reduce(
+        (sum, corner) => [
+          sum[0] + normal.getX(corner),
+          sum[1] + normal.getY(corner),
+          sum[2] + normal.getZ(corner)
+        ],
+        [0, 0, 0]
+      ) : winding(at);
+      const length = Math.hypot(out[0], out[1], out[2]);
+      if (length === 0) continue;
+      positions.push(...at[0], ...at[1], ...at[2]);
+      normals.push(out[0] / length, out[1] / length, out[2] / length);
+    }
+  }
+  return { positions: new Float32Array(positions), normals: new Float32Array(normals) };
+}
+var winding = ([a, b, c]) => {
+  const u = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const v = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+  return [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
+};
 
 // src/hover-card.tsx
 import { useEffect, useState } from "react";
@@ -222,6 +266,7 @@ var StockIcon = () => /* @__PURE__ */ jsx2(SvgIcon, { children: /* @__PURE__ */
 var AxesIcon = () => /* @__PURE__ */ jsx2(SvgIcon, { children: /* @__PURE__ */ jsx2("path", { d: "M5 19V3m0 16h16M5 19l10-10M2 6l3-3 3 3m10 10 3 3-3 3M11 9h4v4" }) });
 var GridIcon = () => /* @__PURE__ */ jsx2(SvgIcon, { children: /* @__PURE__ */ jsx2("path", { d: "M3 8l9-5 9 5-9 5zM3 8v8l9 5 9-5V8M12 13v8M7.5 5.5v8M16.5 5.5v8" }) });
 var BananaIcon = () => /* @__PURE__ */ jsx2(SvgIcon, { viewBox: "0 0 576 512", fill: "currentColor", children: /* @__PURE__ */ jsx2("path", { d: "M284.2 245.6c12.99 6.929 25.35 15.14 36.08 25.8L334.5 285.6l65.75-23.47c14.75-5.265 30.18-7.849 45.81-8.389c1.154-10.73 1.764-21.38 1.764-31.87c0-118.5-81.33-221.9-119.7-221.9c-21.01 0-40.91 17.04-40.91 39.25c0 16.18 16.74 41.9 16.74 103C303.1 170.1 300.6 203.1 284.2 245.6zM575.1 389.6c0-3.687-.8637-7.429-2.687-10.93l-15.12-29.11c-21.05-40.53-63.08-64.51-106.9-64.51c-13.43 0-27.02 2.252-40.22 6.969l-84.84 30.27l-28.59-28.41C274.4 270.9 243.7 258.1 212.8 258.1c-23.72 0-47.57 6.97-68.29 21.2L106.3 306.4c-6.732 4.631-10.35 12.07-10.35 19.63c0 14.93 12.7 23.87 24.04 23.87c4.695 0 9.443-1.376 13.61-4.26l38.13-26.23c12.43-8.525 26.71-12.69 40.91-12.69c10.64 0 21.24 2.339 30.97 6.934c-50.62 62.23-128.3 99.85-211.4 99.85C14.42 413.5 0 427.8 0 445.5v31.38c0 17.68 14.66 32.02 32.46 32.02l28.98.0009c14.15 0 34.69 1.098 59.07 1.098c93.51 0 243.4-16.15 304.8-172.4c9.021-3.22 17.95-4.712 26.53-4.712c27.65 0 51.7 15.49 63.7 38.55l15.12 29.11c3.484 6.723 11.74 12.98 21.41 12.98C564.1 413.6 575.1 403.8 575.1 389.6z" }) });
+var ToolsIcon = () => /* @__PURE__ */ jsx2(SvgIcon, { children: /* @__PURE__ */ jsx2("path", { d: "M9 2h6v7H9zM9.5 9v9.5l2.5 3.5 2.5-3.5V9M9.5 12l5 2.5M9.5 15.5l5 2.5" }) });
 var DirectionsIcon = () => /* @__PURE__ */ jsx2(SvgIcon, { children: /* @__PURE__ */ jsx2("path", { d: "M7 3v18m-4-4 4 4 4-4M17 21V3m-4 4 4-4 4 4" }) });
 var HoverIcon = () => /* @__PURE__ */ jsx2(SvgIcon, { children: /* @__PURE__ */ jsx2("path", { d: "M4 4h16v12H9l-5 4zm4 5h8m-8 3h5" }) });
 var FocusIcon = () => /* @__PURE__ */ jsx2(SvgIcon, { children: /* @__PURE__ */ jsx2("path", { d: "M4 4h16v16H4zM8 8h8v8H8zM2 12h4m12 0h4M12 2v4m0 12v4" }) });
@@ -236,6 +281,7 @@ var ICONS = {
   axes: AxesIcon,
   grid: GridIcon,
   banana: BananaIcon,
+  tools: ToolsIcon,
   directions: DirectionsIcon,
   hover: HoverIcon,
   focus: FocusIcon,
@@ -315,6 +361,14 @@ var BananaButton = () => /* @__PURE__ */ jsx3(
     label: (pressed) => pressed ? "Banana for scale (on)" : "Banana for scale"
   }
 );
+var ToolsButton = () => /* @__PURE__ */ jsx3(
+  ToolbarButton,
+  {
+    action: "tools",
+    icon: "tools",
+    label: (pressed) => pressed ? "Hide tools on the part" : "Show tools on the part"
+  }
+);
 var DirectionsButton = () => /* @__PURE__ */ jsx3(
   ToolbarButton,
   {
@@ -376,7 +430,8 @@ var DefaultControls = () => {
     controls.stock ? /* @__PURE__ */ jsx3(StockButton, {}, "stock") : null,
     controls.axes ? /* @__PURE__ */ jsx3(AxesButton, {}, "axes") : null,
     controls.grid ? /* @__PURE__ */ jsx3(GridButton, {}, "grid") : null,
-    controls.banana ? /* @__PURE__ */ jsx3(BananaButton, {}, "banana") : null
+    controls.banana ? /* @__PURE__ */ jsx3(BananaButton, {}, "banana") : null,
+    controls.tools ? /* @__PURE__ */ jsx3(ToolsButton, {}, "tools") : null
   ].filter(Boolean);
   const analysis = [
     controls.directions ? /* @__PURE__ */ jsx3(DirectionsButton, {}, "directions") : null,
@@ -417,6 +472,7 @@ var ViewerToolbar = Object.assign(ViewerToolbarRoot, {
   AxesButton,
   GridButton,
   BananaButton,
+  ToolsButton,
   DirectionsButton,
   HoverButton,
   FocusButton,
@@ -430,20 +486,105 @@ var ViewerToolbar = Object.assign(ViewerToolbarRoot, {
 
 // src/stock.tsx
 import { useThree } from "@react-three/fiber";
-import { useEffect as useEffect2, useLayoutEffect, useMemo } from "react";
-import { BoxGeometry, Vector3 as Vector32 } from "three";
+import { useEffect as useEffect2, useLayoutEffect, useMemo, useState as useState2 } from "react";
+
+// src/render/stock-mesh.ts
+import { Mesh } from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+async function parseStockGlb(data) {
+  const { scene } = await new GLTFLoader().parseAsync(data, "");
+  try {
+    return stockMeshGeometries(scene);
+  } finally {
+    scene.traverse((object) => {
+      if (!(object instanceof Mesh)) return;
+      object.geometry.dispose();
+      for (const material of Array.isArray(object.material) ? object.material : [object.material]) {
+        material.dispose();
+      }
+    });
+  }
+}
+function stockMeshGeometries(scene) {
+  const geometries = [];
+  scene.updateWorldMatrix(true, true);
+  scene.traverse((object) => {
+    if (!(object instanceof Mesh)) return;
+    const geometry = object.geometry.clone().applyMatrix4(object.matrixWorld);
+    if (!geometry.hasAttribute("normal")) geometry.computeVertexNormals();
+    geometries.push(geometry);
+  });
+  if (geometries.length === 0) throw new Error("The stock GLB contains no mesh.");
+  return geometries;
+}
+
+// src/render/stock-mesh-buffer.ts
+function createStockMeshBuffer() {
+  const owned = /* @__PURE__ */ new Set();
+  let disposed = false;
+  return {
+    request(decode, ready, failed) {
+      disposed = false;
+      let active = true;
+      void decode().then(
+        (geometries) => {
+          if (!active || disposed) {
+            geometries.forEach((geometry) => geometry.dispose());
+            return;
+          }
+          geometries.forEach((geometry) => owned.add(geometry));
+          ready(geometries);
+        },
+        (cause) => {
+          if (active && !disposed) {
+            failed(cause);
+          }
+        }
+      );
+      return () => {
+        active = false;
+      };
+    },
+    commit(geometries) {
+      const visible = new Set(geometries);
+      for (const geometry of owned) {
+        if (!visible.has(geometry)) {
+          owned.delete(geometry);
+          geometry.dispose();
+        }
+      }
+    },
+    dispose() {
+      disposed = true;
+      owned.forEach((geometry) => geometry.dispose());
+      owned.clear();
+    }
+  };
+}
 
 // src/render/stock.ts
 import {
   Box3,
+  BoxGeometry,
+  CylinderGeometry,
   EdgesGeometry,
   Group,
   LineBasicMaterial,
   LineSegments,
-  Mesh,
+  Matrix4,
+  Mesh as Mesh2,
   MeshLambertMaterial,
+  Quaternion,
   Vector3
 } from "three";
+function boxFigure(bounds) {
+  return {
+    lower: { x: bounds.min.x, y: bounds.min.y, z: bounds.min.z },
+    upper: { x: bounds.max.x, y: bounds.max.y, z: bounds.max.z }
+  };
+}
+var CYLINDER_SEGMENTS = 64;
+var CYLINDER_AXIS = new Vector3(0, 1, 0);
 function fixedBoxStockBounds(geometry, dimensions, position = "model_centered", positionOffset = 0, offset = { x: 0, y: 0, z: 0 }) {
   if (![dimensions.x, dimensions.y, dimensions.z].every(Number.isFinite) || [dimensions.x, dimensions.y, dimensions.z].some((value) => value <= 0)) {
     throw new RangeError("Fixed stock dimensions must be finite and positive.");
@@ -456,13 +597,97 @@ function fixedBoxStockBounds(geometry, dimensions, position = "model_centered",
   }
   const part = partBounds(geometry);
   const center = part.getCenter(new Vector3());
-  const z = position === "offset_from_top" ? part.max.z + positionOffset - dimensions.z / 2 : position === "offset_from_bottom" ? part.min.z - positionOffset + dimensions.z / 2 : center.z;
-  const half = new Vector3(dimensions.x / 2, dimensions.y / 2, dimensions.z / 2);
+  const z = fixedStockLowerZ(part, dimensions.z, position, positionOffset);
   return new Box3(
-    new Vector3(center.x, center.y, z).sub(half),
-    new Vector3(center.x, center.y, z).add(half)
+    new Vector3(center.x - dimensions.x / 2, center.y - dimensions.y / 2, z),
+    new Vector3(center.x + dimensions.x / 2, center.y + dimensions.y / 2, z + dimensions.z)
   ).translate(new Vector3(offset.x, offset.y, offset.z));
 }
+function fixedCylinderStock(geometry, size, position = "model_centered", positionOffset = 0) {
+  if (![size.diameter, size.length].every((value) => Number.isFinite(value) && value > 0)) {
+    throw new RangeError("Fixed stock diameter and length must be finite and positive.");
+  }
+  if (!Number.isFinite(positionOffset)) {
+    throw new RangeError("Fixed stock position offset must be finite.");
+  }
+  const part = partBounds(geometry);
+  const center = part.getCenter(new Vector3());
+  return {
+    origin: {
+      x: center.x,
+      y: center.y,
+      z: fixedStockLowerZ(part, size.length, position, positionOffset)
+    },
+    axis: { x: 0, y: 0, z: 1 },
+    diameter: size.diameter,
+    length: size.length
+  };
+}
+function fixedStockLowerZ(part, length, position, positionOffset) {
+  if (position === "offset_from_top") return part.max.z + positionOffset - length;
+  if (position === "offset_from_bottom") return part.min.z - positionOffset;
+  return (part.min.z + part.max.z - length) / 2;
+}
+function cylinderStockGeometry(input) {
+  const figure = input.partGeometry ? fixedCylinderStock(input.partGeometry, input, input.position, input.positionOffset) : input;
+  const { origin, diameter, length } = figure;
+  if (![origin.x, origin.y, origin.z].every(Number.isFinite)) {
+    throw new RangeError("Cylinder stock origin must be finite.");
+  }
+  if (![diameter, length].every((value) => Number.isFinite(value) && value > 0)) {
+    throw new RangeError("Cylinder stock diameter and length must be finite and positive.");
+  }
+  const axis = new Vector3(figure.axis.x, figure.axis.y, figure.axis.z);
+  const norm = axis.length();
+  if (!Number.isFinite(norm) || norm === 0) {
+    throw new RangeError("Cylinder stock axis must be finite and non-zero.");
+  }
+  axis.divideScalar(norm);
+  const center = axis.clone().multiplyScalar(length / 2).add(new Vector3(origin.x, origin.y, origin.z));
+  return new CylinderGeometry(diameter / 2, diameter / 2, length, CYLINDER_SEGMENTS).applyQuaternion(new Quaternion().setFromUnitVectors(CYLINDER_AXIS, axis)).translate(center.x, center.y, center.z);
+}
+function boxStockGeometry(input) {
+  const figure = input.partGeometry ? boxFigure(
+    input.dimensions ? fixedBoxStockBounds(
+      input.partGeometry,
+      input.dimensions,
+      input.position,
+      input.positionOffset,
+      input.offset
+    ) : boxStockBounds(input.partGeometry, input.allowance, input.offset)
+  ) : input;
+  return orientedBoxStockGeometry(figure);
+}
+function orientedBoxStockGeometry(figure) {
+  const { lower, upper } = figure;
+  const frame = figure.frame ?? {
+    location: { x: 0, y: 0, z: 0 },
+    axis: { x: 0, y: 0, z: 1 },
+    refDirection: { x: 1, y: 0, z: 0 }
+  };
+  const { location, axis, refDirection } = frame;
+  if (![location, axis, refDirection, lower, upper].every(
+    (vector) => [vector.x, vector.y, vector.z].every(Number.isFinite)
+  )) {
+    throw new RangeError("Box stock frame and corners must be finite.");
+  }
+  const size = new Vector3(upper.x - lower.x, upper.y - lower.y, upper.z - lower.z);
+  if (size.toArray().some((value) => !(value > 0))) {
+    throw new RangeError("Box stock upper corner must be above its lower corner on every axis.");
+  }
+  const z = new Vector3(axis.x, axis.y, axis.z).normalize();
+  const x = new Vector3(refDirection.x, refDirection.y, refDirection.z);
+  const reference = x.length();
+  x.addScaledVector(z, -x.dot(z));
+  if (!(z.lengthSq() > 0 && x.length() > 1e-9 * reference)) {
+    throw new RangeError(
+      "Box stock frame axis and reference direction must be non-zero and not parallel."
+    );
+  }
+  x.normalize();
+  const y = new Vector3().crossVectors(z, x);
+  return new BoxGeometry(size.x, size.y, size.z).translate((lower.x + upper.x) / 2, (lower.y + upper.y) / 2, (lower.z + upper.z) / 2).applyMatrix4(new Matrix4().makeBasis(x, y, z).setPosition(location.x, location.y, location.z));
+}
 function boxStockBounds(geometry, allowance = 0, offset = { x: 0, y: 0, z: 0 }) {
   const padding = typeof allowance === "number" ? new Vector3(allowance, allowance, allowance) : "wall" in allowance ? new Vector3(allowance.wall, allowance.wall, allowance.floor) : new Vector3(allowance.x, allowance.y, allowance.z);
   if (padding.toArray().some((value) => !Number.isFinite(value) || value < 0)) {
@@ -494,81 +719,167 @@ function partBounds(geometry) {
   }
   return box;
 }
-function createStock(geometry) {
+function createStock(geometry, legacyWorkpiece = false) {
   const material = new MeshLambertMaterial({ transparent: true, depthWrite: false });
   const edgeMaterial = new LineBasicMaterial({ transparent: true, depthWrite: false });
-  const mesh = new Mesh(geometry, material);
-  const edgeGeometry = new EdgesGeometry(geometry, 15);
-  const edges = new LineSegments(edgeGeometry, edgeMaterial);
+  const mesh = new Mesh2(geometry, material);
   const object = new Group();
   object.userData[STOCK_OBJECT] = true;
-  mesh.renderOrder = 5;
-  edges.renderOrder = 6;
+  mesh.renderOrder = legacyWorkpiece ? 2 : 5;
   mesh.raycast = () => {
   };
-  edges.raycast = () => {
-  };
-  object.add(mesh, edges);
+  object.add(mesh);
+  if (legacyWorkpiece) {
+    const shadow = mesh.clone();
+    shadow.raycast = () => {
+    };
+    object.add(shadow);
+    edgeMaterial.depthWrite = true;
+  }
+  let edges = null;
   return {
     object,
     material,
     edgeMaterial,
-    edges,
+    /**
+     * Shows or hides the outline, building it the first time it is shown: the
+     * edge pass reads every triangle, and stock cut by a toolpath has a great
+     * many of them.
+     */
+    showEdges(show) {
+      if (show && !edges) {
+        edges = new LineSegments(new EdgesGeometry(geometry, 15), edgeMaterial);
+        edges.renderOrder = legacyWorkpiece ? 1 : 6;
+        edges.raycast = () => {
+        };
+        object.add(edges);
+      }
+      if (edges) edges.visible = show;
+    },
     dispose() {
       material.dispose();
       edgeMaterial.dispose();
-      edgeGeometry.dispose();
+      edges?.geometry.dispose();
     }
   };
 }
 
 // src/stock.tsx
 import { jsx as jsx4 } from "react/jsx-runtime";
-var Stock = ({
+var Stock = ({ geometry, glb, box, cylinder, ...appearance }) => geometry ? /* @__PURE__ */ jsx4(GeometryStock, { geometry, ...appearance }) : glb ? /* @__PURE__ */ jsx4(GlbStock, { glb, ...appearance }) : /* @__PURE__ */ jsx4(ShapeStock, { box, cylinder, ...appearance });
+var GeometryStock = ({
   geometry,
-  color = 12176354,
+  renderStyle = "overlay",
+  color = renderStyle === "legacy-workpiece" ? 16777215 : 12176354,
+  emissive = renderStyle === "legacy-workpiece" ? 3948625 : 0,
+  flatShading = renderStyle === "legacy-workpiece",
   opacity = 0.2,
-  edgeColor = 11058648,
-  edgeOpacity = 0.75,
+  edgeColor = renderStyle === "legacy-workpiece" ? 0 : 11058648,
+  edgeOpacity = renderStyle === "legacy-workpiece" ? 0.5 : 0.75,
   showEdges = true
 }) => {
   const invalidate = useThree((state) => state.invalidate);
-  const stock = useMemo(() => createStock(geometry), [geometry]);
+  const stock = useMemo(
+    () => createStock(geometry, renderStyle === "legacy-workpiece"),
+    [geometry, renderStyle]
+  );
   useEffect2(() => () => stock.dispose(), [stock]);
   useLayoutEffect(() => {
     stock.material.color.setHex(color);
+    stock.material.emissive.setHex(emissive);
+    if (stock.material.flatShading !== flatShading) {
+      stock.material.flatShading = flatShading;
+      stock.material.needsUpdate = true;
+    }
     stock.material.opacity = opacity;
+    stock.material.depthWrite = renderStyle === "legacy-workpiece" && opacity === 1;
+    stock.material.polygonOffset = renderStyle === "legacy-workpiece" && opacity === 1;
+    stock.material.polygonOffsetFactor = 1;
+    stock.material.polygonOffsetUnits = 1;
     stock.edgeMaterial.color.setHex(edgeColor);
     stock.edgeMaterial.opacity = edgeOpacity;
-    stock.edges.visible = showEdges;
+    stock.showEdges(showEdges);
     invalidate();
-  }, [color, edgeColor, edgeOpacity, invalidate, opacity, showEdges, stock]);
+  }, [
+    color,
+    emissive,
+    flatShading,
+    edgeColor,
+    edgeOpacity,
+    invalidate,
+    opacity,
+    renderStyle,
+    showEdges,
+    stock
+  ]);
   return /* @__PURE__ */ jsx4("primitive", { object: stock.object, dispose: null });
 };
-var BoxStock = ({
-  partGeometry,
-  dimensions,
-  position = "model_centered",
-  positionOffset = 0,
-  allowance = 0,
-  offset,
-  ...props
+var GlbStock = ({
+  glb,
+  retainPrevious = false,
+  ...appearance
+}) => {
+  const buffer = useMemo(() => createStockMeshBuffer(), []);
+  const [decoded, setDecoded] = useState2(null);
+  useEffect2(() => () => buffer.dispose(), [buffer]);
+  useLayoutEffect(() => {
+    buffer.commit(decoded?.geometries ?? []);
+  }, [buffer, decoded]);
+  useEffect2(
+    () => buffer.request(
+      () => parseStockGlb(glb),
+      (geometries) => {
+        setDecoded({ source: glb, geometries });
+      },
+      (cause) => {
+        setDecoded({
+          source: glb,
+          error: cause instanceof Error ? cause : new Error(String(cause))
+        });
+      }
+    ),
+    [buffer, glb]
+  );
+  if (!decoded || !retainPrevious && decoded.source !== glb) return null;
+  if (decoded.error) throw decoded.error;
+  return decoded.geometries?.map((geometry) => /* @__PURE__ */ jsx4(GeometryStock, { geometry, ...appearance }, geometry.uuid));
+};
+var keepNonFinite = (_key, value) => typeof value === "number" && !Number.isFinite(value) ? String(value) : value;
+var restoreNonFinite = (_key, value) => value === "NaN" || value === "Infinity" || value === "-Infinity" ? Number(value) : value;
+var ShapeStock = ({
+  box,
+  cylinder,
+  ...appearance
 }) => {
-  const ox = offset?.x ?? 0;
-  const oy = offset?.y ?? 0;
-  const oz = offset?.z ?? 0;
+  const isBox = box !== void 0;
+  const partGeometry = box?.partGeometry ?? cylinder?.partGeometry;
+  const figure = JSON.stringify(
+    box ? box.partGeometry ? {
+      dimensions: box.dimensions,
+      allowance: box.allowance,
+      offset: box.offset,
+      position: box.position,
+      positionOffset: box.positionOffset
+    } : { frame: box.frame, lower: box.lower, upper: box.upper } : cylinder.partGeometry ? {
+      diameter: cylinder.diameter,
+      length: cylinder.length,
+      position: cylinder.position,
+      positionOffset: cylinder.positionOffset
+    } : {
+      origin: cylinder.origin,
+      axis: cylinder.axis,
+      diameter: cylinder.diameter,
+      length: cylinder.length
+    },
+    keepNonFinite
+  );
   const geometry = useMemo(() => {
-    const box = dimensions ? fixedBoxStockBounds(partGeometry, dimensions, position, positionOffset, {
-      x: ox,
-      y: oy,
-      z: oz
-    }) : boxStockBounds(partGeometry, allowance, { x: ox, y: oy, z: oz });
-    const size = box.getSize(new Vector32());
-    const center = box.getCenter(new Vector32());
-    return new BoxGeometry(size.x, size.y, size.z).translate(center.x, center.y, center.z);
-  }, [allowance, dimensions, ox, oy, oz, partGeometry, position, positionOffset]);
+    const options = JSON.parse(figure, restoreNonFinite);
+    const input = partGeometry ? { ...options, partGeometry } : options;
+    return isBox ? boxStockGeometry(input) : cylinderStockGeometry(input);
+  }, [figure, isBox, partGeometry]);
   useEffect2(() => () => geometry.dispose(), [geometry]);
-  return /* @__PURE__ */ jsx4(Stock, { geometry, ...props });
+  return /* @__PURE__ */ jsx4(GeometryStock, { geometry, ...appearance });
 };
 
 // src/banana.tsx
@@ -577,13 +888,13 @@ import { useThree as useThree2 } from "@react-three/fiber";
 import { useLayoutEffect as useLayoutEffect2, useMemo as useMemo2, useRef } from "react";
 
 // src/render/banana.ts
-import { Vector3 as Vector33 } from "three";
+import { Vector3 as Vector32 } from "three";
 var BANANA_GAP = 0.1;
 function bananaPosition(part, banana) {
-  const size = part.getSize(new Vector33());
+  const size = part.getSize(new Vector32());
   const reach = Math.max(size.x, size.y, size.z);
-  const centre = part.getCenter(new Vector33());
-  return new Vector33(
+  const centre = part.getCenter(new Vector32());
+  return new Vector32(
     part.max.x + reach * BANANA_GAP - banana.min.x,
     centre.y - (banana.min.y + banana.max.y) / 2,
     part.min.z - banana.min.z
@@ -650,16 +961,16 @@ function directionHighlights(model, activeDirection = null) {
 // src/primitives.tsx
 import { GizmoHelper } from "@react-three/drei";
 import { useThree as useThree3 } from "@react-three/fiber";
-import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2, useState as useState2 } from "react";
+import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2, useState as useState3 } from "react";
 
 // src/render/grid.ts
-import { BufferGeometry, Float32BufferAttribute, Vector3 as Vector34 } from "three";
+import { BufferGeometry, Float32BufferAttribute, Vector3 as Vector33 } from "three";
 var STEPS = [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1e3];
 var TARGET_CELLS = 10;
 var OVERHANG = 1.6;
 function gridSpec(box) {
-  const size = box.getSize(new Vector34());
-  const center = box.getCenter(new Vector34());
+  const size = box.getSize(new Vector33());
+  const center = box.getCenter(new Vector33());
   const largest = Math.max(size.x, size.y, 1e-6);
   const ideal = largest / TARGET_CELLS;
   const step = [...STEPS].reverse().find((candidate) => candidate <= ideal) ?? STEPS[0];
@@ -732,7 +1043,7 @@ var CubePanels = ({
   const controls = useViewerControls();
   const invalidate = useThree3((state) => state.invalidate);
   const groupRef = useRef2(null);
-  const [hovered, setHovered] = useState2(null);
+  const [hovered, setHovered] = useState3(null);
   const panels = useMemo3(
     () => zones.map((zone) => ({ zone, geometry: panelGeometry(zone) })),
     [zones]
@@ -801,7 +1112,7 @@ var CubePanels = ({
 // src/direction-arrows.tsx
 import { useThree as useThree4 } from "@react-three/fiber";
 import { useMemo as useMemo4 } from "react";
-import { Quaternion, Vector3 as Vector35 } from "three";
+import { Quaternion as Quaternion2, Vector3 as Vector34 } from "three";
 import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
 var FURNITURE3 = { [EXCLUDE_FROM_FRAME]: true };
 var DirectionArrows = ({
@@ -861,9 +1172,9 @@ var Arrow = ({ direction, box, color, opacity, onPick, onTop = false }) => {
   const invalidate = useThree4((state) => state.invalidate);
   const { tip, length, quaternion } = useMemo4(() => {
     const placement = arrowPlacement(direction, box);
-    const aim = new Quaternion().setFromUnitVectors(
+    const aim = new Quaternion2().setFromUnitVectors(
       CONE_AXIS,
-      new Vector35(direction.x, direction.y, direction.z).normalize()
+      new Vector34(direction.x, direction.y, direction.z).normalize()
     );
     return { tip: placement.tip, length: placement.length, quaternion: aim };
   }, [box, direction]);
@@ -890,18 +1201,18 @@ var Arrow = ({ direction, box, color, opacity, onPick, onTop = false }) => {
 
 // src/section-tool.tsx
 import { useFrame, useThree as useThree5 } from "@react-three/fiber";
-import { useEffect as useEffect4, useMemo as useMemo5, useRef as useRef3, useState as useState3, useSyncExternalStore } from "react";
+import { useEffect as useEffect4, useMemo as useMemo5, useRef as useRef3, useState as useState4, useSyncExternalStore } from "react";
 import {
   BufferGeometry as BufferGeometry2,
   DoubleSide,
-  Quaternion as Quaternion2,
+  Quaternion as Quaternion3,
   Raycaster,
   Vector2,
-  Vector3 as Vector36
+  Vector3 as Vector35
 } from "three";
 import { Fragment, jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
 var FURNITURE4 = { [EXCLUDE_FROM_FRAME]: true };
-var Z = new Vector36(0, 0, 1);
+var Z = new Vector35(0, 0, 1);
 var AXIS_ROTATIONS = {
   x: [0, Math.PI / 2, 0],
   y: [Math.PI / 2, 0, 0],
@@ -932,10 +1243,10 @@ var SectionTool = ({ theme }) => {
 var useSquare = () => {
   const square = useMemo5(
     () => new BufferGeometry2().setFromPoints([
-      new Vector36(-1, 1, 0),
-      new Vector36(1, 1, 0),
-      new Vector36(1, -1, 0),
-      new Vector36(-1, -1, 0)
+      new Vector35(-1, 1, 0),
+      new Vector35(1, 1, 0),
+      new Vector35(1, -1, 0),
+      new Vector35(-1, -1, 0)
     ]),
     []
   );
@@ -952,9 +1263,9 @@ var Picker = ({ box, theme }) => {
   const square = useSquare();
   const previewRef = useRef3(null);
   const hover = useRef3(null);
-  const [hoveredPlane, setHoveredPlane] = useState3(null);
-  const span = useMemo5(() => box.getSize(new Vector36()).length(), [box]);
-  const centre = useMemo5(() => box.getCenter(new Vector36()), [box]);
+  const [hoveredPlane, setHoveredPlane] = useState4(null);
+  const span = useMemo5(() => box.getSize(new Vector35()).length(), [box]);
+  const centre = useMemo5(() => box.getCenter(new Vector35()), [box]);
   const previewSize = span * PREVIEW_SCALE;
   useEffect4(() => {
     store.setPicking(true);
@@ -963,7 +1274,7 @@ var Picker = ({ box, theme }) => {
   useEffect4(() => {
     const raycaster = new Raycaster();
     const pointer = new Vector2();
-    const aim = new Vector36();
+    const aim = new Vector35();
     const hide = () => {
       if (!hover.current) return;
       hover.current = null;
@@ -1008,7 +1319,7 @@ var Picker = ({ box, theme }) => {
       domElement.removeEventListener("pointerup", up);
     };
   }, [box, camera, domElement, invalidate, isTap, scene, span, store]);
-  const [planes, setPlanes] = useState3(() => axesPlanes(box, camera.position));
+  const [planes, setPlanes] = useState4(() => axesPlanes(box, camera.position));
   const key = planes.map((plane) => plane.sign).join();
   useFrame(() => {
     const next = [camera.position.x, camera.position.y, camera.position.z].map((eye, axis) => eye - [centre.x, centre.y, centre.z][axis] < 0 ? -1 : 1).join();
@@ -1107,14 +1418,14 @@ var Picker = ({ box, theme }) => {
 var CutSheet = ({ box, section, theme }) => {
   const square = useSquare();
   const cut = useMemo5(() => resolveSectionPlane(section, box), [box, section]);
-  const span = useMemo5(() => box.getSize(new Vector36()).length(), [box]);
+  const span = useMemo5(() => box.getSize(new Vector35()).length(), [box]);
   const placement = useMemo5(() => {
     if (!cut) return null;
     const position = sectionAnchor(box, cut.plane).addScaledVector(
       cut.plane.normal,
       -span * SHEET_SETBACK
     );
-    return { position, quaternion: new Quaternion2().setFromUnitVectors(Z, cut.plane.normal) };
+    return { position, quaternion: new Quaternion3().setFromUnitVectors(Z, cut.plane.normal) };
   }, [box, cut, span]);
   if (!placement) return null;
   const size = span * OUTLINE_SCALE;
@@ -1162,26 +1473,26 @@ import {
   useLayoutEffect as useLayoutEffect3,
   useMemo as useMemo6,
   useRef as useRef4,
-  useState as useState4,
+  useState as useState5,
   useSyncExternalStore as useSyncExternalStore2
 } from "react";
 import {
-  Matrix4,
+  Matrix4 as Matrix42,
   Raycaster as Raycaster2,
   SphereGeometry,
   Vector2 as Vector22,
-  Vector3 as Vector38
+  Vector3 as Vector37
 } from "three";
 
 // src/render/resample.ts
-import { Vector3 as Vector37 } from "three";
+import { Vector3 as Vector36 } from "three";
 var ON_PLANE = 1e-7;
 var STITCH = 1e-5;
 var COLLINEAR = 1e-6;
 function clipSegments(positions, plane) {
   const out = [];
-  const a = new Vector37();
-  const b = new Vector37();
+  const a = new Vector36();
+  const b = new Vector36();
   const count = Math.floor(positions.length / 6);
   for (let i = 0; i < count; i += 1) {
     a.set(positions[i * 6], positions[i * 6 + 1], positions[i * 6 + 2]);
@@ -1196,11 +1507,11 @@ function clipSegments(positions, plane) {
   return Float32Array.from(out);
 }
 function sectionContour(positions, regionOf, plane) {
-  const a = new Vector37();
-  const b = new Vector37();
-  const c = new Vector37();
-  const p = new Vector37();
-  const q = new Vector37();
+  const a = new Vector36();
+  const b = new Vector36();
+  const c = new Vector36();
+  const p = new Vector36();
+  const q = new Vector36();
   const byRegion = /* @__PURE__ */ new Map();
   const triangleCount = Math.floor(positions.length / 9);
   for (let t = 0; t < triangleCount; t += 1) {
@@ -1258,17 +1569,17 @@ function stitch(segments, out) {
     return into.set(segments[o], segments[o + 1], segments[o + 2]);
   };
   const direction = (i, into) => {
-    const s = new Vector37();
-    const e = new Vector37();
+    const s = new Vector36();
+    const e = new Vector36();
     point(i, 0, s);
     point(i, 1, e);
     return into.subVectors(e, s).normalize();
   };
   const consumed = new Uint8Array(count);
-  const d = new Vector37();
-  const n = new Vector37();
+  const d = new Vector36();
+  const n = new Vector36();
   const next = (i, end) => {
-    const at = point(i, end, new Vector37());
+    const at = point(i, end, new Vector36());
     const list = ends.get(key(at.x, at.y, at.z)) ?? [];
     if (list.length !== 2) return null;
     const other = list.find((entry) => entry >> 1 !== i);
@@ -1297,8 +1608,8 @@ function stitch(segments, out) {
     };
     const back = walk(0);
     const forward = walk(1);
-    const s = point(back.index, back.end, new Vector37());
-    const e = point(forward.index, forward.end, new Vector37());
+    const s = point(back.index, back.end, new Vector36());
+    const e = point(forward.index, forward.end, new Vector36());
     out.push(s.x, s.y, s.z, e.x, e.y, e.z);
   }
 }
@@ -1306,8 +1617,8 @@ function pointInContour(point, plane, contour) {
   const [u, v] = planeAxes(plane);
   const px = point.dot(u);
   const py = point.dot(v);
-  const a = new Vector37();
-  const b = new Vector37();
+  const a = new Vector36();
+  const b = new Vector36();
   let inside = false;
   const count = Math.floor(contour.length / 6);
   for (let i = 0; i < count; i += 1) {
@@ -1324,15 +1635,15 @@ function pointInContour(point, plane, contour) {
   return inside;
 }
 function capHit(ray, plane, contour) {
-  const point = ray.intersectPlane(plane, new Vector37());
+  const point = ray.intersectPlane(plane, new Vector36());
   if (!point) return null;
   return pointInContour(point, plane, contour) ? point : null;
 }
 function planeAxes(plane) {
   const n = plane.normal;
-  const seed = Math.abs(n.x) < 0.9 ? new Vector37(1, 0, 0) : new Vector37(0, 1, 0);
-  const u = new Vector37().crossVectors(n, seed).normalize();
-  const v = new Vector37().crossVectors(n, u).normalize();
+  const seed = Math.abs(n.x) < 0.9 ? new Vector36(1, 0, 0) : new Vector36(0, 1, 0);
+  const u = new Vector36().crossVectors(n, seed).normalize();
+  const v = new Vector36().crossVectors(n, u).normalize();
   return [u, v];
 }
 function sampleSection(meshPositions, regionOf, edgePositions, plane) {
@@ -1361,10 +1672,10 @@ var MeasureTool = ({
   const box = useContentBox();
   const resolved = useMemo6(() => resolveTheme(theme), [theme]);
   const picking = useSyncExternalStore2(store.subscribe, store.isPicking, store.isPicking);
-  const [held, setHeld] = useState4([]);
+  const [held, setHeld] = useState5([]);
   const controlled = measurements !== void 0;
   const list = controlled ? measurements : held;
-  const [draft, setDraft] = useState4([]);
+  const [draft, setDraft] = useState5([]);
   useEffect5(() => {
     store.setEngaged(true);
     return () => store.setEngaged(false);
@@ -1442,7 +1753,7 @@ var MeasureTool = ({
   ] });
 };
 var NO_POINTER = { pointerEvents: "none" };
-var NOWHERE = [new Vector38(), new Vector38()];
+var NOWHERE = [new Vector37(), new Vector37()];
 var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
   const camera = useThree6((state) => state.camera);
   const scene = useThree6((state) => state.scene);
@@ -1495,7 +1806,7 @@ var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
       const snapped = snapAt(target, target.edges, camera, viewport);
       const from = placed[placed.length - 1];
       const lock = shift && from ? lockToAxis(from, snapped.point) : null;
-      const found = lock ? { ...snapped, point: new Vector38(lock.point.x, lock.point.y, lock.point.z), edge: null } : snapped;
+      const found = lock ? { ...snapped, point: new Vector37(lock.point.x, lock.point.y, lock.point.z), edge: null } : snapped;
       snap.current = found;
       const node = marker.current;
       if (node) {
@@ -1657,7 +1968,7 @@ function targetUnderRay(raycaster, scene, samples) {
       edges: samples.edgesFor(hit.object)
     };
   }
-  const local = new Matrix4();
+  const local = new Matrix42();
   for (const mesh of cutMeshes(scene)) {
     const planes = clippingPlanesOf(mesh);
     const sample = samples.for(mesh, planes);
@@ -1720,7 +2031,7 @@ var SampleCache = class {
     const key = planes.map((plane) => `${plane.normal.x},${plane.normal.y},${plane.normal.z},${plane.constant}`).join("|");
     const cached = this.held.get(mesh);
     if (cached && cached.key === key) return cached;
-    const local = new Matrix4().copy(mesh.matrixWorld).invert();
+    const local = new Matrix42().copy(mesh.matrixWorld).invert();
     const localPlanes = planes.map((plane) => plane.clone().applyMatrix4(local));
     const positions = mesh.geometry.getAttribute("position")?.array ?? [];
     const regionOf = this.regionsOf(mesh.geometry);
@@ -1803,7 +2114,7 @@ var DeltaLegs = ({ a, b, id, format, label }) => {
   const lines = useRef4([]);
   const centre = useMemo6(() => {
     const at = midpoint(a, b);
-    return new Vector38(at.x, at.y, at.z);
+    return new Vector37(at.x, at.y, at.z);
   }, [a, b]);
   useFrame2(() => {
     const dash = screenLength(camera, centre, size, DELTA_DASH_PIXELS);
@@ -1825,8 +2136,8 @@ var DeltaLegs = ({ a, b, id, format, label }) => {
           lines.current[index] = line;
         },
         points: [
-          new Vector38(leg.from.x, leg.from.y, leg.from.z),
-          new Vector38(leg.to.x, leg.to.y, leg.to.z)
+          new Vector37(leg.from.x, leg.from.y, leg.from.z),
+          new Vector37(leg.to.x, leg.to.y, leg.to.z)
         ],
         color: AXIS_COLORS[leg.axis],
         lineWidth: MEASURE_LINE_PIXELS.leg,
@@ -1862,7 +2173,7 @@ var ScreenDot = ({ point, pixels, color }) => {
   const invalidate = useThree6((state) => state.invalidate);
   const node = useRef4(null);
   const dot = useDot();
-  const position = useMemo6(() => new Vector38(point.x, point.y, point.z), [point]);
+  const position = useMemo6(() => new Vector37(point.x, point.y, point.z), [point]);
   useFrame2(() => {
     const group = node.current;
     if (!group) return;
@@ -1877,7 +2188,7 @@ var ScreenDot = ({ point, pixels, color }) => {
 var Segment = ({ points, color }) => {
   const [a, b] = points;
   const ends = useMemo6(
-    () => [new Vector38(a.x, a.y, a.z), new Vector38(b.x, b.y, b.z)],
+    () => [new Vector37(a.x, a.y, a.z), new Vector37(b.x, b.y, b.z)],
     // Keyed on the numbers: a draft's tuple is a fresh array on every render,
     // and a rebuilt array would rebuild the line's geometry with it.
     [a.x, a.y, a.z, b.x, b.y, b.z]
@@ -1913,6 +2224,145 @@ function className(extra) {
   return extra ? `${MEASURE_LABEL_CLASS} ${extra}` : MEASURE_LABEL_CLASS;
 }
 
+// src/tool-marks.tsx
+import { Html as Html2, Line as Line2 } from "@react-three/drei";
+import { useMemo as useMemo7 } from "react";
+import { DoubleSide as DoubleSide2 } from "three";
+
+// src/render/tool-marks.ts
+import { Quaternion as Quaternion4, Vector2 as Vector23, Vector3 as Vector38 } from "three";
+var TOOL_CORNER_STEPS = 12;
+var TOOL_ROUND = 64;
+function toolProfile(radius, corner, height) {
+  const rounded = Math.min(Math.max(corner, 0), radius);
+  const flat = radius - rounded;
+  const points = [new Vector23(0, 0)];
+  if (rounded <= 0) {
+    points.push(new Vector23(radius, 0));
+  } else {
+    for (let step = 0; step <= TOOL_CORNER_STEPS; step++) {
+      const angle = step / TOOL_CORNER_STEPS * (Math.PI / 2);
+      points.push(
+        new Vector23(flat + Math.sin(angle) * rounded, rounded - Math.cos(angle) * rounded)
+      );
+    }
+  }
+  points.push(new Vector23(radius, Math.max(height, rounded)));
+  return points;
+}
+var UP = new Vector38(0, 1, 0);
+var AXES = [new Vector38(1, 0, 0), new Vector38(0, 1, 0), new Vector38(0, 0, 1)];
+var toVector = ({ x, y, z }) => new Vector38(x, y, z);
+var squareTo = (w, along) => {
+  const wanted = along ? toVector(along) : null;
+  const flat = wanted?.clone().addScaledVector(w, -wanted.dot(w));
+  if (flat && flat.lengthSq() > 1e-12) return flat.normalize();
+  const least = AXES.reduce(
+    (best, axis) => Math.abs(axis.dot(w)) < Math.abs(best.dot(w)) ? axis : best
+  );
+  return least.clone().addScaledVector(w, -least.dot(w)).normalize();
+};
+var circle = (centre, u, v, radius) => Array.from({ length: TOOL_ROUND + 1 }, (_, step) => {
+  const angle = step / TOOL_ROUND * Math.PI * 2;
+  return centre.clone().addScaledVector(u, Math.cos(angle) * radius).addScaledVector(v, Math.sin(angle) * radius);
+});
+var tickLength = (diameter) => Math.min(Math.max(diameter * 0.15, 0.3), 3);
+function toolMarkShape(mark) {
+  const axis = toVector(mark.axis);
+  if (!(mark.diameter > 0) || axis.lengthSq() === 0) return null;
+  const w = axis.normalize();
+  const u = squareTo(w, mark.across);
+  const v = new Vector38().crossVectors(w, u);
+  const radius = mark.diameter / 2;
+  const corner = Math.min(Math.max(mark.cornerRadius ?? 0, 0), radius);
+  const height = Math.max(mark.height, corner);
+  const base = toVector(mark.base);
+  const top = base.clone().addScaledVector(w, height);
+  const dimension = [
+    top.clone().addScaledVector(u, radius),
+    top.clone().addScaledVector(u, -radius)
+  ];
+  const half = tickLength(mark.diameter) / 2;
+  const tick = (end) => [
+    end.clone().addScaledVector(w, -half),
+    end.clone().addScaledVector(w, half)
+  ];
+  return {
+    base,
+    turn: new Quaternion4().setFromUnitVectors(UP, w),
+    profile: mark.profile ? mark.profile.map(({ r, z }) => new Vector23(r, z)) : toolProfile(radius, corner, height),
+    rims: [
+      ...radius - corner > 1e-9 ? [circle(base, u, v, radius - corner)] : [],
+      circle(top, u, v, radius)
+    ],
+    dimension,
+    ticks: [tick(dimension[0]), tick(dimension[1])],
+    labelAt: top
+  };
+}
+
+// src/tool-marks.tsx
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var BODY = { color: 16317180, opacity: 0.32 };
+var NO_POINTER2 = { pointerEvents: "none" };
+var ignoreRay = () => void 0;
+var ToolMarks = ({ marks, visible = true, labelClassName, theme }) => {
+  const color = resolveTheme(theme).measure;
+  const shapes = useMemo7(
+    () => marks.flatMap((mark) => {
+      const shape = toolMarkShape(mark);
+      return shape ? [{ mark, shape }] : [];
+    }),
+    [marks]
+  );
+  const label = labelClassName ? `${MEASURE_LABEL_CLASS} ${labelClassName}` : MEASURE_LABEL_CLASS;
+  return /* @__PURE__ */ jsx10("group", { visible, userData: { [EXCLUDE_FROM_FRAME]: true }, children: shapes.map(({ mark, shape }, index) => /* @__PURE__ */ jsxs6("group", { children: [
+    /* @__PURE__ */ jsx10(ToolBody, { shape }),
+    [...shape.rims, shape.dimension, ...shape.ticks].map((points, line) => /* @__PURE__ */ jsx10(
+      Line2,
+      {
+        points,
+        color,
+        lineWidth: MEASURE_LINE_PIXELS.line,
+        depthTest: false,
+        depthWrite: false,
+        renderOrder: MEASURE_RENDER_ORDER,
+        raycast: ignoreRay
+      },
+      line
+    )),
+    mark.label && visible ? /* @__PURE__ */ jsx10(Html2, { position: shape.labelAt, center: true, zIndexRange: [0, 0], style: NO_POINTER2, children: /* @__PURE__ */ jsxs6("div", { className: label, "data-measure-label": "tool", children: [
+      /* @__PURE__ */ jsx10("span", { "data-measure-value": true, children: mark.label }),
+      mark.note ? /* @__PURE__ */ jsxs6("span", { "data-measure-note": true, children: [
+        " ",
+        mark.note
+      ] }) : null
+    ] }) }) : null
+  ] }, index)) });
+};
+var ToolBody = ({ shape }) => /* @__PURE__ */ jsxs6(
+  "mesh",
+  {
+    position: shape.base,
+    quaternion: shape.turn,
+    raycast: ignoreRay,
+    renderOrder: MEASURE_RENDER_ORDER - 1,
+    children: [
+      /* @__PURE__ */ jsx10("latheGeometry", { args: [shape.profile, 64] }),
+      /* @__PURE__ */ jsx10(
+        "meshBasicMaterial",
+        {
+          color: BODY.color,
+          transparent: true,
+          opacity: BODY.opacity,
+          depthWrite: false,
+          side: DoubleSide2
+        }
+      )
+    ]
+  }
+);
+
 // src/model/normals.ts
 function regionNormals(geometry, regions) {
   const position = geometry.getAttribute("position");
@@ -1956,7 +2406,6 @@ export {
   BANANA_GAP,
   BANANA_MODEL_URL,
   Banana,
-  BoxStock,
   CAD_CAMERA_UP,
   CANDIDATE_WEIGHT,
   CAP_HATCH,
@@ -2013,6 +2462,7 @@ export {
   SectionView,
   Stock,
   TAP_SLOP,
+  ToolMarks,
   UnsupportedKernelVersionError,
   VIEW_NAMES,
   VIEW_SIGNS,
@@ -2064,6 +2514,7 @@ export {
   distanceBetween,
   dragPlane,
   excludedFromFrame,
+  featureTriangles,
   featureTypeRank,
   fitDistance,
   fixedBoxStockBounds,
@@ -2123,6 +2574,7 @@ export {
   trackDoubleTaps,
   trackTaps,
   useContentBox,
+  usePartContext,
   useRetarget,
   useSectionStore,
   useTapGuard,