@toolpath/viewer 1.5.0 → 2.0.0

package/README.md

@@ -76,7 +76,7 @@ What each wrapper is for:
  ├─ <EnginePart>          validates the report, loads the mesh, then renders <PartMesh>
  │   └─ <PartMesh>        draws the part and handles hover, click, colours, section cuts
  ├─ <DirectionArrows>     arrows for the directions the part can be machined from
- ├─ <Stock> <BoxStock>    translucent stock, included when fitting the camera
+ ├─ <Stock>               translucent geometry, GLB, box or cylinder stock, included in Fit
  ├─ <SectionTool>         optional: click a face or a plane to cut the part open
  ├─ <MeasureTool>         optional: click two points for a distance, three for an angle
  ├─ <Grid> <Axes>         reference geometry, sized to the part
@@ -146,9 +146,8 @@ context rather than a fact of the part surface.
 
 ### Stock and display controls
 
-Use `<BoxStock>` for an axis-aligned blank around a part, or `<Stock geometry={stockGeometry} />`
-for an actual stock mesh, including cylindrical or irregular blanks. Stock and part coordinates
-must use the same millimetre, Z-up frame. Both components include stock in Fit and Reset while
+Use `<Stock>` for a box, cylinder, prepared geometry or GLB bytes. Stock and part coordinates
+must use the same millimetre, Z-up frame. Stock is included in Fit and Reset while
 keeping section tools, measurements, the grid, and direction arrows sized to the finished part.
 Stock does not intercept clicks or get clipped by the part's section plane.
 
@@ -156,7 +155,7 @@ Stock does not intercept clicks or get clipped by the part's section plane.
 import { useMemo, useRef, useState } from 'react'
 import {
   Axes,
-  BoxStock,
+  Stock,
   DirectionArrows,
   PartMesh,
   Viewer,
@@ -187,7 +186,7 @@ export function StockPreview({ model, geometry }: { model: PartModel; geometry:
           regionHighlights={colors}
           activeDirection={directions ? direction : null}
         />
-        {stock && <BoxStock partGeometry={geometry} allowance={{ wall: 3, floor: 3 }} />}
+        {stock && <Stock box={{ partGeometry: geometry, allowance: { wall: 3, floor: 3 } }} />}
         {axes && <Axes />}
         <DirectionArrows
           directions={model.candidateDirections}
@@ -214,25 +213,103 @@ export function StockPreview({ model, geometry }: { model: PartModel; geometry:
 }
 ```
 
-`BoxStock.allowance` is padding **per side**, in millimetres. The preferred form is
+For a box preview, pass `box={{ partGeometry, allowance, offset }}`. Allowance is padding
+**per side**, in millimetres. The preferred form is
 `{ wall, floor }`: wall stock expands X/Y and floor stock expands Z, matching the wall/floor
 roughing-stock distinction used by machining settings. A number or `{ x, y, z }` remains accepted
 for uniform or axis-specific padding. It defaults to zero. `offset` translates the stock from the
 part's bounding-box centre. `boxStockBounds(geometry, allowance, offset)` returns the same `Box3`
 for displaying dimensions.
 
-For fixed-box stock, pass `dimensions={{ x, y, z }}` instead. `position` accepts
+For fixed-box previews, pass `box={{ partGeometry, dimensions, position, positionOffset, offset }}`
+instead, where `dimensions` is `{ x, y, z }`. Dimensions and allowance are alternative sizing
+modes, not simultaneous options. `position` accepts
 `model_centered`, `offset_from_top`, or `offset_from_bottom`, and `positionOffset` is the distance
 from the selected top or bottom bound. All fixed-box values use millimetres and the part's Z-up
 coordinate frame.
 Negative/non-finite allowances, non-finite coordinates, and empty or non-positive stock dimensions
 throw `RangeError`. The 3 mm allowance above is an example, not an automatic stock recommendation.
 
-`Stock` accepts `color`, `opacity` (default `0.2`), `edgeColor`, `edgeOpacity`, and `showEdges`.
-`BoxStock` accepts the same appearance props. Caller-provided geometry is never disposed; the
+`<Stock cylinder={{ origin, axis, diameter, length }} />` draws round stock along any axis:
+`origin` is the centre of its base and `axis` points from the base toward its far end, in part
+coordinates. For a preview, pass
+`cylinder={{ partGeometry, diameter, length, position, positionOffset }}` instead. It stands along
+the part's Z, is centred on the part's bounding box, and is placed along Z by the same `position`
+rule as fixed-box stock. The kernel centres fixed round stock on the part's
+smallest enclosing circle about the first setup's cutting direction, so render the resolved stock
+once a job is planned.
+
+`<Stock box={{ frame, lower, upper }} />` draws a block whose corners are given in a frame
+of `location`, `axis` and `refDirection`: a point `(x, y, z)` sits at
+`location + x·refDirection + y·(axis × refDirection) + z·axis`, with `axis` normalised and
+`refDirection` projected square to it and normalised. That is the shape of an Engine plan's
+`stock.resolved` box, which is squared to the setup rather than to the part. Omit `frame` when
+`lower` and `upper` are already in part coordinates. Resolved placement and `partGeometry`
+preview options are mutually exclusive for both shapes.
+
+Box and cylinder sources rebuild their mesh only when their figures/options change (or the
+preview's `partGeometry` reference changes). Inline option objects do not trigger repeated part
+scans on ordinary renders. Figures that cannot make a
+solid — a zero axis, a non-positive size, a frame whose axis and reference direction are parallel —
+throw `RangeError`.
+
+`Stock` accepts exactly one of `geometry`, `glb`, `box` or `cylinder`:
+
+```tsx
+<Stock geometry={geometry} showEdges={false} />
+// Or:
+<Stock glb={glbBytes} showEdges={false} />
+<Stock box={resolvedBox} />
+<Stock cylinder={resolvedCylinder} />
+<Stock box={{ partGeometry, dimensions, position, positionOffset }} />
+<Stock cylinder={{ partGeometry, diameter, length, position, positionOffset }} />
+```
+
+All four inputs are mutually exclusive in `StockProps`. With `geometry`, the caller owns its
+lifetime and disposal. With `box` or `cylinder`, `Stock` owns the generated geometry. With `glb`,
+`Stock` decodes the bytes internally and disposes decoded
+geometry when the bytes change or the component unmounts. Keep the same `ArrayBuffer` reference
+while displaying the same artifact to avoid decoding it again on ordinary renders.
+It renders nothing while decoding and throws decoding failures to the nearest error boundary.
+Changing the source immediately hides the previous stock; late results from an earlier decode
+are discarded and cleaned up.
+
+The component does not fetch, cache or store artifacts. The caller supplies the bytes.
+GLB node transforms are applied without centering, rescaling or changing axes:
+Engine stock artifacts are already in part coordinates, millimetres and Z-up. Indexed geometry
+stays indexed; missing normals are computed without requiring a part report. The parser cleans up
+its temporary scene after preparing the returned geometry.
+
+Engine stock files are plain GLB served with HTTP gzip, which the browser handles automatically;
+no meshopt decoder is needed. Authentication, durable artifact copies, action selection and
+missing-artifact fallback and artifact caching belong to the application. The example's
+**Stock source → GLB fixture** option exercises synthetic blanks encoded by the services stock
+writer. **Shape preview** exposes the separate box/cylinder shape controls.
+
+`Stock` accepts `color`, `emissive` (default black), `flatShading` (default `false`),
+`opacity` (default `0.2`), `edgeColor`, `edgeOpacity`, and `showEdges`. Emissive shading
+and flat shading change only the material, not the source's vertices, indices or normals.
+`renderStyle="legacy-workpiece"` reproduces legacy Workpiece rendering: white with dark emissive
+shading, per-face shading, 20% opacity, two shared-geometry surface passes and black 50%-opacity
+edges drawn before surfaces (rather than over them). The default `overlay` style is unchanged.
+
+For action-to-action playback, `retainPrevious` keeps the current decoded GLB visible until
+the next GLB is ready, then swaps meshes without a blank frame. Key the stock's parent by
+part/calculation identity (not action) to prevent retaining geometry across unrelated runs.
+The default still hides the previous source during decoding. Geometry is disposed after a
+replacement commits; cancelled/late results are discarded.
+The outline is built the first time it is shown, so a large stock mesh with `showEdges={false}`
+costs no edge pass. All source types accept the same appearance props. Caller-provided geometry is never disposed; the
 components dispose their own materials and outlines. Conditionally mount stock to toggle it.
 Toggling stock preserves the camera; Fit/Reset then frames the visible stock together with the part.
 
+**Migration from 1.x:** `BoxStock` and `BoxStockProps` have been removed. Use
+`<Stock box={{ partGeometry, allowance, offset }} />` for allowance-based previews, or
+`<Stock box={{ partGeometry, dimensions, position, positionOffset, offset }} />` for fixed
+dimensions. No preview-builder helper is required. `Stock geometry={geometry}` remains supported.
+`StockProps` is now a union type alias, so `interface X extends StockProps` becomes
+`type X = StockProps & { … }`; `StockAppearanceProps` names the shared appearance props alone.
+
 `directionHighlights(model, activeDirection?)` returns region colors in the same palette as
 `DirectionArrows`. For a face with several owners, the most specific feature wins, followed by
 candidate-direction order and feature tag. Unmatched directions are left unpainted. Hover and

package/dist/index.d.ts

@@ -106,8 +106,82 @@ type StockAllowance = number | Vec3 | {
     wall: number;
     floor: number;
 };
-/** How an explicit box is positioned relative to the part's Z bounds. */
+/** How explicit fixed stock is positioned relative to the part's Z bounds. */
 type StockPosition = 'model_centered' | 'offset_from_top' | 'offset_from_bottom';
+/**
+ * Round stock in part coordinates, in millimetres: the centre of its base, the
+ * direction from the base toward its far end, and its size. The Engine's
+ * resolved `StockCylinder` carries the same four figures.
+ */
+interface CylinderStockFigure {
+    origin: Vec3;
+    axis: Vec3;
+    diameter: number;
+    length: number;
+}
+/**
+ * A block squared to a frame of its own rather than to the part, in
+ * millimetres. `lower` and `upper` are corners in `frame`, whose point
+ * `(x, y, z)` sits at `location + x·refDirection + y·(axis × refDirection) + z·axis`
+ * in part coordinates, with `axis` normalised and `refDirection` projected
+ * square to it and normalised. This is the shape of the Engine's plan
+ * `StockBox`, which is squared to the setup.
+ */
+interface BoxStockFigure {
+    /** Omit for a box whose corners are already in part coordinates. */
+    frame?: {
+        location: Vec3;
+        axis: Vec3;
+        refDirection: Vec3;
+    };
+    lower: Vec3;
+    upper: Vec3;
+}
+/** Box preview around the part: explicit dimensions or per-side allowance. */
+type BoxStockPreview = {
+    partGeometry: BufferGeometry;
+    offset?: Vec3;
+} & ({
+    dimensions: Vec3;
+    position?: StockPosition;
+    positionOffset?: number;
+    allowance?: never;
+} | {
+    allowance?: StockAllowance;
+    dimensions?: never;
+    position?: never;
+    positionOffset?: never;
+});
+/** Resolved corners or part-relative preview options, never both. */
+type BoxStockInput = (BoxStockFigure & {
+    partGeometry?: never;
+    offset?: never;
+    allowance?: never;
+    dimensions?: never;
+    position?: never;
+    positionOffset?: never;
+}) | (BoxStockPreview & {
+    lower?: never;
+    upper?: never;
+    frame?: never;
+});
+/** Upright cylinder preview centered on the part's bounding box. */
+interface CylinderStockPreview {
+    partGeometry: BufferGeometry;
+    diameter: number;
+    length: number;
+    position?: StockPosition;
+    positionOffset?: number;
+}
+/** Resolved cylinder placement or part-relative preview options, never both. */
+type CylinderStockInput = (CylinderStockFigure & {
+    partGeometry?: never;
+    position?: never;
+    positionOffset?: never;
+}) | (CylinderStockPreview & {
+    origin?: never;
+    axis?: never;
+});
 /**
  * Bounds for an explicit fixed box. X/Y are centered on the part's bounding
  * box; Z is centered, offset from the top, or offset from the bottom. `offset`
@@ -117,36 +191,38 @@ declare function fixedBoxStockBounds(geometry: BufferGeometry, dimensions: Vec3,
 /** Per-side allowance and centre offset in millimetres, in the part's coordinates. */
 declare function boxStockBounds(geometry: BufferGeometry, allowance?: StockAllowance, offset?: Vec3): Box3;
 
-interface StockProps {
-    /** Caller-owned stock mesh in the same millimetre, Z-up coordinates as the part. */
-    geometry: BufferGeometry;
+interface StockAppearanceProps {
+    /** Keep the preceding decoded GLB visible until its replacement is ready. Key by part/run to reset. */
+    retainPrevious?: boolean;
+    /** Reproduce the legacy Workpiece's materials, duplicate surface pass and edge ordering. */
+    renderStyle?: 'overlay' | 'legacy-workpiece';
     color?: number;
+    /** Unlit surface contribution, useful for readable workpiece shading beside the CAD model. */
+    emissive?: number;
+    /** Shade each triangle independently without changing the source's vertices or normals. */
+    flatShading?: boolean;
     opacity?: number;
     edgeColor?: number;
     edgeOpacity?: number;
     showEdges?: boolean;
 }
-/** Translucent stock, included in Fit but ignored by picking, sections and measurements. */
-declare const Stock: ({ geometry, color, opacity, edgeColor, edgeOpacity, showEdges, }: StockProps) => react.JSX.Element;
-interface BoxStockProps extends Omit<StockProps, 'geometry'> {
-    partGeometry: BufferGeometry;
-    /** Explicit X/Y/Z dimensions, in millimetres, for fixed-box stock. */
-    dimensions?: Vec3;
-    /** Position mode for explicit fixed-box stock. Defaults to model-centered. */
-    position?: StockPosition;
-    /** Distance from the selected top/bottom part bound, in millimetres. */
-    positionOffset?: number;
-    /**
-     * Stock left around the part, in millimetres. In the `{ wall, floor }` form,
-     * wall applies to X/Y and floor applies to Z. Number and `{ x, y, z }` forms
-     * are retained for compatibility. Defaults to zero.
-     */
-    allowance?: StockAllowance;
-    /** Translation from the part's bounding-box centre, in millimetres. */
-    offset?: Vec3;
+interface StockSources {
+    /** Caller-owned geometry; Stock never disposes it. */
+    geometry: BufferGeometry;
+    /** Caller-provided GLB bytes; Stock owns and cleans up the decoded geometry. */
+    glb: ArrayBuffer;
+    /** Resolved box corners/frame, or part-relative box preview options. */
+    box: BoxStockInput;
+    /** Resolved cylinder placement, or part-relative cylinder preview options. */
+    cylinder: CylinderStockInput;
 }
-/** An axis-aligned blank around the part. Use Stock for an arbitrary stock mesh. */
-declare const BoxStock: ({ partGeometry, dimensions, position, positionOffset, allowance, offset, ...props }: BoxStockProps) => react.JSX.Element;
+/** Exactly one source, in the same millimetre, Z-up coordinates as the part. */
+type StockSource = {
+    [K in keyof StockSources]: Pick<StockSources, K> & Partial<Record<Exclude<keyof StockSources, K>, never>>;
+}[keyof StockSources];
+type StockProps = StockAppearanceProps & StockSource;
+/** Translucent stock, included in Fit but ignored by picking, sections and measurements. */
+declare const Stock: ({ geometry, glb, box, cylinder, ...appearance }: StockProps) => react.JSX.Element;
 
 /** The six-inch (154 mm) reference model bundled with `@toolpath/viewer`. */
 declare const BANANA_MODEL_URL: string;
@@ -1778,4 +1854,4 @@ declare const ORBIT_TARGET_FADE_MS = 1000;
  */
 declare function orbitTargetOpacity(sinceHold: number, fade?: number): number;
 
-export { ANGLE_ARC_FRACTION, ANGLE_ARC_SEGMENTS, AXIS_COLORS, type AngleMeasurement, type ArrowPlacement, Axes, type AxesProps, type Axis, type AxisLock, BANANA_GAP, BANANA_MODEL_URL, Banana, type BananaProps, BoxStock, type BoxStockProps, CAD_CAMERA_UP, CHAMFER, CONTROL_SCHEME_OPTIONS, CadCameraControls, type CadCameraControlsProps, type CameraLimits, type CapMaterial, type CapUniforms, type ControlScheme, type ControlSchemeOption, type CubeZone, DEFAULT_FIT_MARGIN, DELTA_DASH_PIXELS, DOUBLE_TAP_MS, type DeltaLeg, DirectionArrows, type DirectionArrowsProps, type DirectionGroup, type DistanceMeasurement, type DoubleTapPoint, type DoubleTapTracker, EXCLUDE_FROM_FRAME, ExtendedCameraControls, type ExtendedCameraControlsOptions, FEATURE_TYPE_RANKS, FeatureTag, FeatureType, Grid, type GridProps, type GridSpec, HoverCard, type HoverCardProps, MAX_FRAME_RATIO, MEASURE_LABEL_CLASS, MEASURE_LINE_PIXELS, MEASURE_MARKER_PIXELS, MEASURE_RENDER_ORDER, MIN_FRAME_RATIO, type MeasureLabelKind, type MeasureMode, MeasureTool, type MeasureToolProps, type Measurement, type NamedDirection, ORBIT_TARGET_COLOR, ORBIT_TARGET_FADE_MS, ORBIT_TARGET_FLASH_MS, ORBIT_TARGET_PIXELS, ORBIT_TARGET_RING_COLOR, ORBIT_TARGET_RING_OPACITY, ORBIT_TARGET_RING_PIXELS, ORBIT_TARGET_RING_WIDTH, PERSPECTIVE_FOV, POINTS_PER_MEASUREMENT, PartModel, PartModelFeature, PartModelRegion, PartPick, PartReportFormatError, type Projection, type RankingContext, RegionHighlight, RegionIndex, type Retarget, type RetargetPose, SNAP_MARKER_PIXELS, SNAP_PIXELS, type SceneBounds, SectionOptions, type SectionSample, SectionState, type SectionStore, SectionTool, type SectionToolProps, SectionView, type Snap, type SnapEdges, type SnapHit, type SnapKind, Stock, type StockAllowance, type StockPosition, type StockProps, type SurfaceOf, TAP_SLOP, type TapPoint, type TapTracker, TriangleRange, UnsupportedKernelVersionError, VIEW_NAMES, VIEW_SIGNS, Vec3, ViewCube, type ViewCubeProps, type ViewKind, type ViewName, Viewer, type ViewerCamera, type ViewerControls, type ViewerHandle, type ViewerProps, ViewerTheme, ViewerToolbar, type ViewerToolbarControl, type ViewerToolbarControls, type ViewerToolbarControlsProps, type ViewerToolbarProps, ViewerToolbarProvider, type ViewerView, type ViewportSize, adaptedUp, angleArc, angleArcRadius, angleAt, applyCapTheme, applyProjection, arrowPlacement, aspectRatio, bananaFrameBounds, bananaPosition, bestOwner, boundsFromBox, boxStockBounds, buildRegionIndex, cadViewDirections, cameraLimits, capHit, clipSegments, contentBounds, createCapMaterial, createMaskMaterial, createMaskTarget, createSectionStore, createStencilMaterials, cubeOutlineGeometry, cubeZones, currentViewDirection, cycleOwner, defaultBounds, deltaBetween, deltaLegs, directionHighlights, directionIndexOf, directionLabel, distanceBetween, excludedFromFrame, featureTypeRank, fitDistance, fixedBoxStockBounds, formatDegrees, formatMillimetres, gridGeometry, gridSpec, groupByDirection, labelGeometry, labelTexture, lockToAxis, measurementFromPoints, measurementLabel, measurementLabelAnchor, midpoint, movedFar, nextMeasurementId, orbitTargetOpacity, orthographicHalfHeight, panelGeometry, perspectiveFitDistance, pointInContour, rankOwners, regionAdjacency, regionEdgesGeometry, regionNormals, resolveSectionPlane, retargetPose, sameDirection, sampleSection, screenLength, screenPoint, sectionContour, snapAt, squaredUp, startPosition, targetBoundary, trackDoubleTaps, trackTaps, useContentBox, useRetarget, useSectionStore, useTapGuard, useViewerControls, useViewerToolbar, viewKind, viewUp, viewVector, visualSurfaces };
+export { ANGLE_ARC_FRACTION, ANGLE_ARC_SEGMENTS, AXIS_COLORS, type AngleMeasurement, type ArrowPlacement, Axes, type AxesProps, type Axis, type AxisLock, BANANA_GAP, BANANA_MODEL_URL, Banana, type BananaProps, type BoxStockFigure, type BoxStockInput, type BoxStockPreview, CAD_CAMERA_UP, CHAMFER, CONTROL_SCHEME_OPTIONS, CadCameraControls, type CadCameraControlsProps, type CameraLimits, type CapMaterial, type CapUniforms, type ControlScheme, type ControlSchemeOption, type CubeZone, type CylinderStockFigure, type CylinderStockInput, type CylinderStockPreview, DEFAULT_FIT_MARGIN, DELTA_DASH_PIXELS, DOUBLE_TAP_MS, type DeltaLeg, DirectionArrows, type DirectionArrowsProps, type DirectionGroup, type DistanceMeasurement, type DoubleTapPoint, type DoubleTapTracker, EXCLUDE_FROM_FRAME, ExtendedCameraControls, type ExtendedCameraControlsOptions, FEATURE_TYPE_RANKS, FeatureTag, FeatureType, Grid, type GridProps, type GridSpec, HoverCard, type HoverCardProps, MAX_FRAME_RATIO, MEASURE_LABEL_CLASS, MEASURE_LINE_PIXELS, MEASURE_MARKER_PIXELS, MEASURE_RENDER_ORDER, MIN_FRAME_RATIO, type MeasureLabelKind, type MeasureMode, MeasureTool, type MeasureToolProps, type Measurement, type NamedDirection, ORBIT_TARGET_COLOR, ORBIT_TARGET_FADE_MS, ORBIT_TARGET_FLASH_MS, ORBIT_TARGET_PIXELS, ORBIT_TARGET_RING_COLOR, ORBIT_TARGET_RING_OPACITY, ORBIT_TARGET_RING_PIXELS, ORBIT_TARGET_RING_WIDTH, PERSPECTIVE_FOV, POINTS_PER_MEASUREMENT, PartModel, PartModelFeature, PartModelRegion, PartPick, PartReportFormatError, type Projection, type RankingContext, RegionHighlight, RegionIndex, type Retarget, type RetargetPose, SNAP_MARKER_PIXELS, SNAP_PIXELS, type SceneBounds, SectionOptions, type SectionSample, SectionState, type SectionStore, SectionTool, type SectionToolProps, SectionView, type Snap, type SnapEdges, type SnapHit, type SnapKind, Stock, type StockAllowance, type StockAppearanceProps, type StockPosition, type StockProps, type StockSource, type SurfaceOf, TAP_SLOP, type TapPoint, type TapTracker, TriangleRange, UnsupportedKernelVersionError, VIEW_NAMES, VIEW_SIGNS, Vec3, ViewCube, type ViewCubeProps, type ViewKind, type ViewName, Viewer, type ViewerCamera, type ViewerControls, type ViewerHandle, type ViewerProps, ViewerTheme, ViewerToolbar, type ViewerToolbarControl, type ViewerToolbarControls, type ViewerToolbarControlsProps, type ViewerToolbarProps, ViewerToolbarProvider, type ViewerView, type ViewportSize, adaptedUp, angleArc, angleArcRadius, angleAt, applyCapTheme, applyProjection, arrowPlacement, aspectRatio, bananaFrameBounds, bananaPosition, bestOwner, boundsFromBox, boxStockBounds, buildRegionIndex, cadViewDirections, cameraLimits, capHit, clipSegments, contentBounds, createCapMaterial, createMaskMaterial, createMaskTarget, createSectionStore, createStencilMaterials, cubeOutlineGeometry, cubeZones, currentViewDirection, cycleOwner, defaultBounds, deltaBetween, deltaLegs, directionHighlights, directionIndexOf, directionLabel, distanceBetween, excludedFromFrame, featureTypeRank, fitDistance, fixedBoxStockBounds, formatDegrees, formatMillimetres, gridGeometry, gridSpec, groupByDirection, labelGeometry, labelTexture, lockToAxis, measurementFromPoints, measurementLabel, measurementLabelAnchor, midpoint, movedFar, nextMeasurementId, orbitTargetOpacity, orthographicHalfHeight, panelGeometry, perspectiveFitDistance, pointInContour, rankOwners, regionAdjacency, regionEdgesGeometry, regionNormals, resolveSectionPlane, retargetPose, sameDirection, sampleSection, screenLength, screenPoint, sectionContour, snapAt, squaredUp, startPosition, targetBoundary, trackDoubleTaps, trackTaps, useContentBox, useRetarget, useSectionStore, useTapGuard, useViewerControls, useViewerToolbar, viewKind, viewUp, viewVector, visualSurfaces };

package/dist/index.js

@@ -430,20 +430,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 +541,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 +663,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 +832,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 +905,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 +987,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 +1056,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 +1116,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 +1145,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 +1187,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 +1207,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 +1218,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 +1263,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 +1362,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 +1417,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 +1451,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 +1513,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 +1552,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 +1561,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 +1579,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 +1616,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 +1697,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 +1750,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 +1912,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 +1975,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 +2058,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 +2080,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 +2117,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 +2132,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]
@@ -1956,7 +2211,6 @@ export {
   BANANA_GAP,
   BANANA_MODEL_URL,
   Banana,
-  BoxStock,
   CAD_CAMERA_UP,
   CANDIDATE_WEIGHT,
   CAP_HATCH,

package/package.json

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