@toolpath/viewer 2.3.0 → 2.3.1

package/dist/index.js

@@ -173,13 +173,13 @@ function featureTriangles(model, geometry, tag) {
   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 triangleCount2 = 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++) {
+    for (let triangle = range.start; triangle < Math.min(range.end, triangleCount2); triangle++) {
       const corners = [vertex(triangle * 3), vertex(triangle * 3 + 1), vertex(triangle * 3 + 2)];
       const at = corners.map((corner) => [
         position.getX(corner),
@@ -594,8 +594,9 @@ function createStockMeshBuffer() {
 import {
   Box3,
   BoxGeometry,
+  BufferGeometry,
   CylinderGeometry,
-  EdgesGeometry,
+  Float32BufferAttribute,
   Group,
   LineBasicMaterial,
   LineSegments,
@@ -603,8 +604,134 @@ import {
   Mesh as Mesh2,
   MeshLambertMaterial,
   Quaternion,
-  Vector3
+  Vector3 as Vector32
 } from "three";
+
+// src/render/stock-edges.ts
+import { MathUtils, Triangle, Vector3 } from "three";
+var STOCK_EDGE_ANGLE = 15;
+var SYNC_EDGE_TRIANGLES = 2e4;
+var SLICE_MS = 4;
+var CHECK_EVERY = 256;
+var _v0 = new Vector3();
+var _v1 = new Vector3();
+var _normal = new Vector3();
+var _triangle = new Triangle();
+function* edgeWork(geometry, thresholdAngle) {
+  const precision = Math.pow(10, 4);
+  const thresholdDot = Math.cos(MathUtils.DEG2RAD * thresholdAngle);
+  const indexAttr = geometry.getIndex();
+  const positionAttr = geometry.getAttribute("position");
+  const indexCount = indexAttr ? indexAttr.count : positionAttr.count;
+  const indexArr = [0, 0, 0];
+  const corners = [_triangle.a, _triangle.b, _triangle.c];
+  const hashes = ["", "", ""];
+  const edgeData = /* @__PURE__ */ new Map();
+  const vertices = [];
+  const key = (v) => `${Math.round(v.x * precision)},${Math.round(v.y * precision)},${Math.round(v.z * precision)}`;
+  for (let i = 0, step2 = 0; i < indexCount; i += 3, step2 += 1) {
+    if (step2 % CHECK_EVERY === 0 && step2 > 0) yield;
+    if (indexAttr) {
+      indexArr[0] = indexAttr.getX(i);
+      indexArr[1] = indexAttr.getX(i + 1);
+      indexArr[2] = indexAttr.getX(i + 2);
+    } else {
+      indexArr[0] = i;
+      indexArr[1] = i + 1;
+      indexArr[2] = i + 2;
+    }
+    _triangle.a.fromBufferAttribute(positionAttr, indexArr[0]);
+    _triangle.b.fromBufferAttribute(positionAttr, indexArr[1]);
+    _triangle.c.fromBufferAttribute(positionAttr, indexArr[2]);
+    _triangle.getNormal(_normal);
+    hashes[0] = key(_triangle.a);
+    hashes[1] = key(_triangle.b);
+    hashes[2] = key(_triangle.c);
+    if (hashes[0] === hashes[1] || hashes[1] === hashes[2] || hashes[2] === hashes[0]) continue;
+    for (let j = 0; j < 3; j += 1) {
+      const jNext = (j + 1) % 3;
+      const v0 = corners[j];
+      const v1 = corners[jNext];
+      const hash = `${hashes[j]}_${hashes[jNext]}`;
+      const reverse = edgeData.get(`${hashes[jNext]}_${hashes[j]}`);
+      if (reverse) {
+        if (_normal.dot(reverse.normal) <= thresholdDot) {
+          vertices.push(v0.x, v0.y, v0.z, v1.x, v1.y, v1.z);
+        }
+        edgeData.set(`${hashes[jNext]}_${hashes[j]}`, null);
+      } else if (!edgeData.has(hash)) {
+        edgeData.set(hash, {
+          index0: indexArr[j],
+          index1: indexArr[jNext],
+          normal: _normal.clone()
+        });
+      }
+    }
+  }
+  let step = 0;
+  for (const edge of edgeData.values()) {
+    step += 1;
+    if (step % CHECK_EVERY === 0) yield;
+    if (!edge) continue;
+    _v0.fromBufferAttribute(positionAttr, edge.index0);
+    _v1.fromBufferAttribute(positionAttr, edge.index1);
+    vertices.push(_v0.x, _v0.y, _v0.z, _v1.x, _v1.y, _v1.z);
+  }
+  return new Float32Array(vertices);
+}
+function stockEdgePositions(geometry, thresholdAngle = STOCK_EDGE_ANGLE) {
+  const work = edgeWork(geometry, thresholdAngle);
+  for (; ; ) {
+    const next = work.next();
+    if (next.done) return next.value;
+  }
+}
+function triangleCount(geometry) {
+  const index = geometry.getIndex();
+  return Math.floor((index ? index.count : geometry.getAttribute("position")?.count ?? 0) / 3);
+}
+var nextTurn = (run) => {
+  if (typeof MessageChannel === "undefined") {
+    const timer = setTimeout(run, 0);
+    return () => clearTimeout(timer);
+  }
+  const channel = new MessageChannel();
+  let live = true;
+  channel.port1.onmessage = () => {
+    channel.port1.close();
+    if (live) run();
+  };
+  channel.port2.postMessage(null);
+  return () => {
+    live = false;
+    channel.port1.close();
+  };
+};
+function buildStockEdges(geometry, onDone, thresholdAngle = STOCK_EDGE_ANGLE) {
+  const work = edgeWork(geometry, thresholdAngle);
+  let cancelTurn = () => {
+  };
+  let cancelled = false;
+  const slice = () => {
+    const until = performance.now() + SLICE_MS;
+    for (; ; ) {
+      const next = work.next();
+      if (next.done) {
+        onDone(next.value);
+        return;
+      }
+      if (performance.now() >= until) break;
+    }
+    if (!cancelled) cancelTurn = nextTurn(slice);
+  };
+  cancelTurn = nextTurn(slice);
+  return () => {
+    cancelled = true;
+    cancelTurn();
+  };
+}
+
+// src/render/stock.ts
 function boxFigure(bounds) {
   return {
     lower: { x: bounds.min.x, y: bounds.min.y, z: bounds.min.z },
@@ -612,7 +739,7 @@ function boxFigure(bounds) {
   };
 }
 var CYLINDER_SEGMENTS = 64;
-var CYLINDER_AXIS = new Vector3(0, 1, 0);
+var CYLINDER_AXIS = new Vector32(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.");
@@ -624,12 +751,12 @@ function fixedBoxStockBounds(geometry, dimensions, position = "model_centered",
     throw new RangeError("Fixed stock offset must be finite.");
   }
   const part = partBounds(geometry);
-  const center = part.getCenter(new Vector3());
+  const center = part.getCenter(new Vector32());
   const z = fixedStockLowerZ(part, dimensions.z, position, positionOffset);
   return new Box3(
-    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));
+    new Vector32(center.x - dimensions.x / 2, center.y - dimensions.y / 2, z),
+    new Vector32(center.x + dimensions.x / 2, center.y + dimensions.y / 2, z + dimensions.z)
+  ).translate(new Vector32(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)) {
@@ -639,7 +766,7 @@ function fixedCylinderStock(geometry, size, position = "model_centered", positio
     throw new RangeError("Fixed stock position offset must be finite.");
   }
   const part = partBounds(geometry);
-  const center = part.getCenter(new Vector3());
+  const center = part.getCenter(new Vector32());
   return {
     origin: {
       x: center.x,
@@ -665,13 +792,13 @@ function cylinderStockGeometry(input) {
   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 axis = new Vector32(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));
+  const center = axis.clone().multiplyScalar(length / 2).add(new Vector32(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) {
@@ -699,12 +826,12 @@ function orientedBoxStockGeometry(figure) {
   )) {
     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);
+  const size = new Vector32(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 z = new Vector32(axis.x, axis.y, axis.z).normalize();
+  const x = new Vector32(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)) {
@@ -713,11 +840,11 @@ function orientedBoxStockGeometry(figure) {
     );
   }
   x.normalize();
-  const y = new Vector3().crossVectors(z, x);
+  const y = new Vector32().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);
+  const padding = typeof allowance === "number" ? new Vector32(allowance, allowance, allowance) : "wall" in allowance ? new Vector32(allowance.wall, allowance.wall, allowance.floor) : new Vector32(allowance.x, allowance.y, allowance.z);
   if (padding.toArray().some((value) => !Number.isFinite(value) || value < 0)) {
     throw new RangeError("Stock allowance must be finite and non-negative.");
   }
@@ -725,8 +852,8 @@ function boxStockBounds(geometry, allowance = 0, offset = { x: 0, y: 0, z: 0 })
     throw new RangeError("Stock offset must be finite.");
   }
   const box = partBounds(geometry);
-  box.expandByVector(padding).translate(new Vector3(offset.x, offset.y, offset.z));
-  const size = box.getSize(new Vector3());
+  box.expandByVector(padding).translate(new Vector32(offset.x, offset.y, offset.z));
+  const size = box.getSize(new Vector32());
   if (size.toArray().some((value) => !Number.isFinite(value) || value <= 0)) {
     throw new RangeError("Stock dimensions must be finite and positive.");
   }
@@ -737,7 +864,7 @@ function partBounds(geometry) {
   if (!position || position.count === 0)
     throw new RangeError("Stock needs non-empty part geometry.");
   const box = new Box3();
-  const point = new Vector3();
+  const point = new Vector32();
   for (let index = 0; index < position.count; index += 1) {
     point.fromBufferAttribute(position, index);
     if (!Number.isFinite(point.x) || !Number.isFinite(point.y) || !Number.isFinite(point.z)) {
@@ -747,7 +874,7 @@ function partBounds(geometry) {
   }
   return box;
 }
-function createStock(geometry, legacyWorkpiece = false) {
+function createStock(geometry, legacyWorkpiece = false, onEdges) {
   const material = new MeshLambertMaterial({ transparent: true, depthWrite: false });
   const edgeMaterial = new LineBasicMaterial({ transparent: true, depthWrite: false });
   const mesh = new Mesh2(geometry, material);
@@ -765,6 +892,18 @@ function createStock(geometry, legacyWorkpiece = false) {
     edgeMaterial.depthWrite = true;
   }
   let edges = null;
+  let building = null;
+  let shown = false;
+  const attach = (positions) => {
+    const outline = new BufferGeometry();
+    outline.setAttribute("position", new Float32BufferAttribute(positions, 3));
+    edges = new LineSegments(outline, edgeMaterial);
+    edges.renderOrder = legacyWorkpiece ? 1 : 6;
+    edges.raycast = () => {
+    };
+    edges.visible = shown;
+    object.add(edges);
+  };
   return {
     object,
     material,
@@ -772,19 +911,28 @@ function createStock(geometry, legacyWorkpiece = false) {
     /**
      * 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.
+     * many of them. A small mesh's outline is built at once; a large one's in
+     * slices between frames, so the stock shows first and its outline joins it
+     * a moment later, the same lines `EdgesGeometry` would have drawn.
      */
     showEdges(show) {
-      if (show && !edges) {
-        edges = new LineSegments(new EdgesGeometry(geometry, 15), edgeMaterial);
-        edges.renderOrder = legacyWorkpiece ? 1 : 6;
-        edges.raycast = () => {
-        };
-        object.add(edges);
+      shown = show;
+      if (show && !edges && !building) {
+        if (triangleCount(geometry) <= SYNC_EDGE_TRIANGLES) {
+          attach(stockEdgePositions(geometry));
+        } else {
+          building = buildStockEdges(geometry, (positions) => {
+            building = null;
+            attach(positions);
+            onEdges?.();
+          });
+        }
       }
       if (edges) edges.visible = show;
     },
     dispose() {
+      building?.();
+      building = null;
       material.dispose();
       edgeMaterial.dispose();
       edges?.geometry.dispose();
@@ -808,8 +956,8 @@ var GeometryStock = ({
 }) => {
   const invalidate = useThree((state) => state.invalidate);
   const stock = useMemo(
-    () => createStock(geometry, renderStyle === "legacy-workpiece"),
-    [geometry, renderStyle]
+    () => createStock(geometry, renderStyle === "legacy-workpiece", invalidate),
+    [geometry, renderStyle, invalidate]
   );
   useEffect2(() => () => stock.dispose(), [stock]);
   useLayoutEffect(() => {
@@ -916,13 +1064,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 Vector32 } from "three";
+import { Vector3 as Vector33 } from "three";
 var BANANA_GAP = 0.1;
 function bananaPosition(part, banana) {
-  const size = part.getSize(new Vector32());
+  const size = part.getSize(new Vector33());
   const reach = Math.max(size.x, size.y, size.z);
-  const centre = part.getCenter(new Vector32());
-  return new Vector32(
+  const centre = part.getCenter(new Vector33());
+  return new Vector33(
     part.max.x + reach * BANANA_GAP - banana.min.x,
     centre.y - (banana.min.y + banana.max.y) / 2,
     part.min.z - banana.min.z
@@ -992,13 +1140,13 @@ import { useThree as useThree3 } from "@react-three/fiber";
 import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2, useState as useState3 } from "react";
 
 // src/render/grid.ts
-import { BufferGeometry, Float32BufferAttribute, Vector3 as Vector33 } from "three";
+import { BufferGeometry as BufferGeometry2, Float32BufferAttribute as Float32BufferAttribute2, Vector3 as Vector34 } 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 Vector33());
-  const center = box.getCenter(new Vector33());
+  const size = box.getSize(new Vector34());
+  const center = box.getCenter(new Vector34());
   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];
@@ -1024,8 +1172,8 @@ function gridGeometry(spec) {
       z
     );
   }
-  const geometry = new BufferGeometry();
-  geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+  const geometry = new BufferGeometry2();
+  geometry.setAttribute("position", new Float32BufferAttribute2(positions, 3));
   return geometry;
 }
 function gridFor(box, options = {}) {
@@ -1140,17 +1288,17 @@ var CubePanels = ({
 // src/direction-arrows.tsx
 import { useThree as useThree4 } from "@react-three/fiber";
 import { useEffect as useEffect4, useMemo as useMemo4 } from "react";
-import { Quaternion as Quaternion2, Vector3 as Vector35 } from "three";
+import { Quaternion as Quaternion2, Vector3 as Vector36 } from "three";
 
 // src/render/directions.ts
-import { Vector3 as Vector34 } from "three";
+import { Vector3 as Vector35 } from "three";
 var LENGTH = 0.33;
 var GAP = 0.2;
 function arrowPlacement(direction, box) {
-  const center = box.getCenter(new Vector34());
-  const half = box.getSize(new Vector34()).multiplyScalar(0.5);
+  const center = box.getCenter(new Vector35());
+  const half = box.getSize(new Vector35()).multiplyScalar(0.5);
   const radius = half.length() || 1;
-  const axis = new Vector34(direction.x, direction.y, direction.z);
+  const axis = new Vector35(direction.x, direction.y, direction.z);
   if (axis.lengthSq() === 0) axis.set(0, 0, 1);
   axis.normalize();
   let exit = Number.POSITIVE_INFINITY;
@@ -1241,7 +1389,7 @@ var Arrow = ({ direction, box, geometry, color, opacity, onPick, onTop = false }
     const placement = arrowPlacement(direction, box);
     const aim = new Quaternion2().setFromUnitVectors(
       ARROW_AXIS,
-      new Vector35(direction.x, direction.y, direction.z).normalize()
+      new Vector36(direction.x, direction.y, direction.z).normalize()
     );
     return { tip: placement.tip, length: placement.length, quaternion: aim };
   }, [box, direction]);
@@ -1259,16 +1407,16 @@ var Arrow = ({ direction, box, geometry, color, opacity, onPick, onTop = false }
 import { useFrame, useThree as useThree5 } from "@react-three/fiber";
 import { useEffect as useEffect5, useMemo as useMemo5, useRef as useRef3, useState as useState4, useSyncExternalStore } from "react";
 import {
-  BufferGeometry as BufferGeometry2,
+  BufferGeometry as BufferGeometry3,
   DoubleSide,
   Quaternion as Quaternion3,
   Raycaster,
   Vector2,
-  Vector3 as Vector36
+  Vector3 as Vector37
 } from "three";
 import { Fragment, jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
 var FURNITURE4 = { [EXCLUDE_FROM_FRAME]: true };
-var Z = new Vector36(0, 0, 1);
+var Z = new Vector37(0, 0, 1);
 var AXIS_ROTATIONS = {
   x: [0, Math.PI / 2, 0],
   y: [Math.PI / 2, 0, 0],
@@ -1298,11 +1446,11 @@ 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 BufferGeometry3().setFromPoints([
+      new Vector37(-1, 1, 0),
+      new Vector37(1, 1, 0),
+      new Vector37(1, -1, 0),
+      new Vector37(-1, -1, 0)
     ]),
     []
   );
@@ -1320,8 +1468,8 @@ var Picker = ({ box, theme }) => {
   const previewRef = useRef3(null);
   const hover = useRef3(null);
   const [hoveredPlane, setHoveredPlane] = useState4(null);
-  const span = useMemo5(() => box.getSize(new Vector36()).length(), [box]);
-  const centre = useMemo5(() => box.getCenter(new Vector36()), [box]);
+  const span = useMemo5(() => box.getSize(new Vector37()).length(), [box]);
+  const centre = useMemo5(() => box.getCenter(new Vector37()), [box]);
   const previewSize = span * PREVIEW_SCALE;
   useEffect5(() => {
     store.setPicking(true);
@@ -1330,7 +1478,7 @@ var Picker = ({ box, theme }) => {
   useEffect5(() => {
     const raycaster = new Raycaster();
     const pointer = new Vector2();
-    const aim = new Vector36();
+    const aim = new Vector37();
     const hide = () => {
       if (!hover.current) return;
       hover.current = null;
@@ -1474,7 +1622,7 @@ 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 Vector37()).length(), [box]);
   const placement = useMemo5(() => {
     if (!cut) return null;
     const position = sectionAnchor(box, cut.plane).addScaledVector(
@@ -1537,18 +1685,18 @@ import {
   Raycaster as Raycaster2,
   SphereGeometry,
   Vector2 as Vector22,
-  Vector3 as Vector38
+  Vector3 as Vector39
 } from "three";
 
 // src/render/resample.ts
-import { Vector3 as Vector37 } from "three";
+import { Vector3 as Vector38 } 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 Vector38();
+  const b = new Vector38();
   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]);
@@ -1563,14 +1711,14 @@ 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 Vector38();
+  const b = new Vector38();
+  const c = new Vector38();
+  const p = new Vector38();
+  const q = new Vector38();
   const byRegion = /* @__PURE__ */ new Map();
-  const triangleCount = Math.floor(positions.length / 9);
-  for (let t = 0; t < triangleCount; t += 1) {
+  const triangleCount2 = Math.floor(positions.length / 9);
+  for (let t = 0; t < triangleCount2; t += 1) {
     a.set(positions[t * 9], positions[t * 9 + 1], positions[t * 9 + 2]);
     b.set(positions[t * 9 + 3], positions[t * 9 + 4], positions[t * 9 + 5]);
     c.set(positions[t * 9 + 6], positions[t * 9 + 7], positions[t * 9 + 8]);
@@ -1625,17 +1773,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 Vector38();
+    const e = new Vector38();
     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 Vector38();
+  const n = new Vector38();
   const next = (i, end) => {
-    const at = point(i, end, new Vector37());
+    const at = point(i, end, new Vector38());
     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);
@@ -1664,8 +1812,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 Vector38());
+    const e = point(forward.index, forward.end, new Vector38());
     out.push(s.x, s.y, s.z, e.x, e.y, e.z);
   }
 }
@@ -1673,8 +1821,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 Vector38();
+  const b = new Vector38();
   let inside = false;
   const count = Math.floor(contour.length / 6);
   for (let i = 0; i < count; i += 1) {
@@ -1691,15 +1839,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 Vector38());
   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 Vector38(1, 0, 0) : new Vector38(0, 1, 0);
+  const u = new Vector38().crossVectors(n, seed).normalize();
+  const v = new Vector38().crossVectors(n, u).normalize();
   return [u, v];
 }
 function sampleSection(meshPositions, regionOf, edgePositions, plane) {
@@ -1809,7 +1957,7 @@ var MeasureTool = ({
   ] });
 };
 var NO_POINTER = { pointerEvents: "none" };
-var NOWHERE = [new Vector38(), new Vector38()];
+var NOWHERE = [new Vector39(), new Vector39()];
 var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
   const camera = useThree6((state) => state.camera);
   const scene = useThree6((state) => state.scene);
@@ -1862,7 +2010,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 Vector39(lock.point.x, lock.point.y, lock.point.z), edge: null } : snapped;
       snap.current = found;
       const node = marker.current;
       if (node) {
@@ -2170,7 +2318,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 Vector39(at.x, at.y, at.z);
   }, [a, b]);
   useFrame2(() => {
     const dash = screenLength(camera, centre, size, DELTA_DASH_PIXELS);
@@ -2192,8 +2340,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 Vector39(leg.from.x, leg.from.y, leg.from.z),
+          new Vector39(leg.to.x, leg.to.y, leg.to.z)
         ],
         color: AXIS_COLORS[leg.axis],
         lineWidth: MEASURE_LINE_PIXELS.leg,
@@ -2229,7 +2377,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 Vector39(point.x, point.y, point.z), [point]);
   useFrame2(() => {
     const group = node.current;
     if (!group) return;
@@ -2244,7 +2392,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 Vector39(a.x, a.y, a.z), new Vector39(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]
@@ -2286,7 +2434,7 @@ 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 Vector39 } from "three";
+import { Quaternion as Quaternion4, Vector2 as Vector23, Vector3 as Vector310 } from "three";
 var TOOL_CORNER_STEPS = 12;
 var TOOL_ROUND = 64;
 function toolProfile(radius, corner, height) {
@@ -2306,9 +2454,9 @@ function toolProfile(radius, corner, height) {
   points.push(new Vector23(radius, Math.max(height, rounded)));
   return points;
 }
-var UP = new Vector39(0, 1, 0);
-var AXES = [new Vector39(1, 0, 0), new Vector39(0, 1, 0), new Vector39(0, 0, 1)];
-var toVector = ({ x, y, z }) => new Vector39(x, y, z);
+var UP = new Vector310(0, 1, 0);
+var AXES = [new Vector310(1, 0, 0), new Vector310(0, 1, 0), new Vector310(0, 0, 1)];
+var toVector = ({ x, y, z }) => new Vector310(x, y, z);
 var squareTo = (w, along) => {
   const wanted = along ? toVector(along) : null;
   const flat = wanted?.clone().addScaledVector(w, -wanted.dot(w));
@@ -2328,7 +2476,7 @@ function toolMarkShape(mark) {
   if (!(mark.diameter > 0) || axis.lengthSq() === 0) return null;
   const w = axis.normalize();
   const u = squareTo(w, mark.across);
-  const v = new Vector39().crossVectors(w, u);
+  const v = new Vector310().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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolpath/viewer",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "React Three Fiber viewer for Toolpath Engine part reports",
   "license": "MIT",
   "engines": {