@toolpath/viewer 1.2.0 → 1.4.0

package/README.md

@@ -594,6 +594,16 @@ convert, so pass `format` to show anything else:
 <MeasureTool format={(mm) => `${(mm / MM_PER_INCH).toFixed(3)} in`} />
 ```
 
+**Measuring a cut part.** Mount the measure tool with a section cut in place, or beside
+`<SectionTool>`, and it measures what is on screen: the half a cut has removed is not there to snap
+to, the part's edges stop at the plane, the outline where the plane passes through solid material
+is an edge with corners of its own, and the capped face is a surface a point can land on. The
+sample follows the cut — drag the handle or set a depth and the next pointer move sees the new cut.
+It reads the plane off the part's own material, so a controlled `section` prop works the same way.
+Beside a `<SectionTool>` that has no cut yet, the measure tool waits: it offers no snap and places
+no point until a cut is chosen or the section tool is unmounted, so the click that picks the cut is
+not also the first point of a measurement. Measurements already made stay up meanwhile.
+
 Hold Shift to hold the next point to the X, Y or Z line through the last one — whichever axis the
 pointer is furthest along — so a length along an edge is measured square rather than slightly across
 it. The line wears that axis's colour while it is held, and the finished distance has no legs to

package/dist/{chunk-HWAEUJ4H.js → chunk-HH3W5T42.js}

@@ -1328,11 +1328,12 @@ function retargetPose(cameraPosition, currentTarget, hitPoint) {
 // src/render/section-store.ts
 function createSectionStore() {
   let current = null;
-  let engaged = 0;
   const listeners = /* @__PURE__ */ new Set();
   const notify = () => {
     for (const listener of listeners) listener();
   };
+  const engaged = counted(notify);
+  const picking = counted(notify);
   return {
     get: () => current,
     set: (next) => {
@@ -1340,12 +1341,10 @@ function createSectionStore() {
       current = next;
       notify();
     },
-    isEngaged: () => engaged > 0,
-    setEngaged: (next) => {
-      const was = engaged > 0;
-      engaged = Math.max(0, engaged + (next ? 1 : -1));
-      if (engaged > 0 !== was) notify();
-    },
+    isEngaged: engaged.is,
+    setEngaged: engaged.set,
+    isPicking: picking.is,
+    setPicking: picking.set,
     subscribe: (listener) => {
       listeners.add(listener);
       return () => {
@@ -1354,6 +1353,17 @@ function createSectionStore() {
     }
   };
 }
+function counted(notify) {
+  let held = 0;
+  return {
+    is: () => held > 0,
+    set: (next) => {
+      const was = held > 0;
+      held = Math.max(0, held + (next ? 1 : -1));
+      if (held > 0 !== was) notify();
+    }
+  };
+}
 
 // src/target-marker.tsx
 import { useFrame as useFrame2, useThree as useThree3 } from "@react-three/fiber";

package/dist/engine/index.js

@@ -12,7 +12,7 @@ import {
   parsePartGeometry,
   partMeshAssets,
   smoothRegionNormals
-} from "../chunk-HWAEUJ4H.js";
+} from "../chunk-HH3W5T42.js";
 export {
   EnginePart,
   MIN_KERNEL_VERSION,

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { P as PartModel, V as Vec3, d as ViewerTheme, S as SectionOptions, e as SectionState, f as PartModelRegion, T as TriangleRange, F as FeatureTag, R as RegionIndex, g as PartModelFeature, h as FeatureType } from './normalize-DHOSNiuO.js';
 export { A as AXES_PLANE_OFFSET, i as AXES_PLANE_SCALE, j as AxesPlane, B as BuildPickInput, C as CANDIDATE_WEIGHT, k as CAP_HATCH, D as DEFAULT_SECTION_NORMAL, l as DEFAULT_THEME, m as DIRECTION_COLORS, o as DISABLED_SECTION, E as EnginePart, p as FeatureHighlight, H as HANDLE_PIXELS, q as HIGHLIGHT_COLORS, r as HIGHLIGHT_WEIGHT, t as HOVER_WEIGHT, u as HighlightLayers, K as KnownFeatureType, v as KnownShapeKind, N as NO_MODIFIERS, O as OUTLINE_SCALE, w as PICKED_SURFACE_LABEL, x as PREVIEW_SCALE, y as PartMesh, z as PartMeshProps, a as PartMeshRefs, G as PartObject, I as PartPick, J as PickModifiers, L as REGION_ATTRIBUTE, Q as RegionHighlight, U as RegionPaint, W as SECTION_RENDER_ORDER, X as SectionAnchor, Y as SectionBounds, Z as SectionPlacement, _ as ShapeKind, $ as SurfaceHit, a0 as applyHighlightLayers, a1 as axesPlanes, a2 as buildPick, a3 as buildRegionAttribute, a4 as buildRegionTexels, a5 as createPart, a6 as directionColor, a7 as dragPlane, a8 as focusForPick, a9 as hitUnderRay, n as normalizePartReport, aa as pickedStartDepth, ab as resolveTheme, ac as sectionAnchor, ad as sectionBounds, ae as sectionConstant, af as sectionDepth, ag as sectionDepthConstant, ah as sectionDepthRange, ai as sectionFromPick, aj as sectionOffset, ak as sectionOptionsFromState, al as sectionPlane, s as smoothRegionNormals, am as surfaceUnderRay, an as themesEqual, ao as viewDirection } from './normalize-DHOSNiuO.js';
-import { BufferGeometry, CanvasTexture, Box3, Plane, Vector3, OrthographicCamera, PerspectiveCamera, Object3D, Matrix4, Vector2, ShaderMaterial, Texture, Color, MeshBasicMaterial, WebGLRenderTarget } from 'three';
+import { BufferGeometry, CanvasTexture, Box3, Plane, Vector3, OrthographicCamera, PerspectiveCamera, Object3D, Matrix4, Vector2, Ray, ShaderMaterial, Texture, Color, MeshBasicMaterial, WebGLRenderTarget } from 'three';
 import * as react from 'react';
 import { RefObject, ReactNode, CSSProperties } from 'react';
 import CameraControls from 'camera-controls';
@@ -245,7 +245,9 @@ interface SectionToolProps {
  * the way to set or clear it from outside the canvas. While this is mounted
  * the part reports no hovers or picks: a click on a face cuts through it
  * without also selecting it, and a cut part is looked at rather than picked
- * at. Unmounting it hands the pointer back.
+ * at. Unmounting it hands the pointer back. While it is offering a cut — up,
+ * with none placed yet — a `<MeasureTool>` beside it waits too, so the click
+ * that chooses the cut does not also place a measurement point.
  */
 declare const SectionTool: ({ theme }: SectionToolProps) => react.JSX.Element | null;
 
@@ -687,7 +689,12 @@ interface MeasureToolProps {
  *
  * Nothing needs wiring. While it is mounted the part reports no hovers or
  * picks — a click that places a point is not a click that selects a face — and
- * unmounting it hands the pointer back. It snaps to the edges the part draws,
+ * unmounting it hands the pointer back. Beside a `<SectionTool>` that has no
+ * cut yet it waits: no snap is offered and no click places a point until the
+ * cut is chosen or the section tool is unmounted, and the click that chooses
+ * the cut — the one it wakes on — places nothing either: a click counts only
+ * when it was pressed as well as released while the tool was taking points.
+ * Measurements already made stay up meanwhile. It snaps to the edges the part draws,
  * which are the boundaries between analytic surfaces rather than the mesh's
  * triangles, so a corner is a corner of the part and not of a facet.
  *
@@ -723,6 +730,12 @@ declare const MeasureTool: ({ mode, measurements, onChange, showDeltas, format,
  * on a face is not a request to select the face — which is why the flag is a
  * count rather than a boolean: two tools up at once let go one at a time.
  *
+ * And whether a tool is **picking** — `<SectionTool>` is up with no cut in
+ * place, so the next click on the part chooses where the cut goes. That click
+ * is the section tool's alone: `<MeasureTool>` beside it offers no snap and
+ * places no point until the cut is chosen or the section tool is unmounted.
+ * Counted for the same reason as `engaged`.
+ *
  * A subscription rather than React state, so a drag re-renders the two
  * subscribers and not everything under the canvas.
  */
@@ -733,11 +746,80 @@ interface SectionStore {
     isEngaged(): boolean;
     /** Counted: a tool engages on mount and disengages on unmount, and the part waits for the last. */
     setEngaged(engaged: boolean): void;
-    /** Notified on every change to either the cut or the engaged flag. */
+    /** Whether a section tool is waiting for a click to say where the cut goes. */
+    isPicking(): boolean;
+    /** Counted, as `setEngaged` is: raised while a section tool offers a cut, dropped once one is placed. */
+    setPicking(picking: boolean): void;
+    /** Notified on every change to the cut, the engaged flag, or the picking flag. */
     subscribe(listener: () => void): () => void;
 }
 declare function createSectionStore(): SectionStore;
 
+/**
+ * A cut part, re-sampled for measuring.
+ *
+ * A clipping plane hides half of a part without changing a triangle, so the
+ * mesh and its edges still describe the whole thing — and a tool that snaps
+ * to them would offer corners nobody can see, and nothing at all on the cut.
+ * This is what the measure tool works against instead: the part's edges
+ * trimmed to the half that is left, the outline where the plane passes
+ * through solid material, and a test for whether a point on the plane is on
+ * the capped face. It is rebuilt whenever the plane moves; see
+ * `measure-tool.tsx`.
+ *
+ * Everything here is in one space — the mesh's own — and the plane is
+ * expected in it too. Six floats per segment throughout, the layout
+ * `regionEdgesGeometry` uses.
+ */
+interface SectionSample {
+    /** The edges of the part on the kept side, plus the cut's outline. */
+    readonly edges: Float32Array;
+    /** The cut's outline alone: where the plane crosses solid material. */
+    readonly contour: Float32Array;
+}
+/**
+ * Trims segments to the half-space a plane keeps.
+ *
+ * A segment wholly on the removed side goes; one that crosses is cut at the
+ * plane and its kept part stays. `Plane` keeps the side its normal points
+ * into — where the signed distance is positive — as the part's own clipping
+ * does.
+ */
+declare function clipSegments(positions: ArrayLike<number>, plane: Plane): Float32Array;
+/**
+ * Where a plane passes through a mesh: one segment per triangle it crosses,
+ * then straight runs inside one region stitched into one segment each.
+ *
+ * The stitching is what makes the outline snappable. A flat face is two
+ * triangles or two hundred, and the plane crosses each of them separately,
+ * so before stitching every triangle boundary on the face was a corner the
+ * pointer would snap to. After it, a corner is where the outline turns —
+ * where the plane leaves one surface for the next — and on a curved surface
+ * the facets stay, as they do in the part's own edges.
+ *
+ * `regionOf` says which surface each triangle belongs to, indexed by
+ * triangle; without it every triangle is one surface, which stitches a
+ * straight run across a fold only if the fold is perfectly flat, which it is
+ * not.
+ */
+declare function sectionContour(positions: ArrayLike<number>, regionOf: ArrayLike<number> | null, plane: Plane): Float32Array;
+/**
+ * Whether a point on the plane lies inside the cut's outline — on the capped
+ * face rather than in the air beside it.
+ *
+ * Even-odd against every outline segment, in the plane's own two axes, so a
+ * part cut through a bore is inside the outer loop and outside the hole's.
+ */
+declare function pointInContour(point: Vector3, plane: Plane, contour: ArrayLike<number>): boolean;
+/**
+ * Where a ray meets the capped face, or `null` when it misses the cap — a
+ * ray through the open half that lands beside the part, or one that reaches
+ * the plane from behind.
+ */
+declare function capHit(ray: Ray, plane: Plane, contour: ArrayLike<number>): Vector3 | null;
+/** The edges and outline of a part cut by `plane`, everything in the mesh's own space. */
+declare function sampleSection(meshPositions: ArrayLike<number>, regionOf: ArrayLike<number> | null, edgePositions: ArrayLike<number> | null, plane: Plane): SectionSample;
+
 type CapUniforms = {
     uMask: {
         value: Texture | null;
@@ -1510,4 +1592,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, CAD_CAMERA_UP, CHAMFER, CadCameraControls, type CadCameraControlsProps, type CameraLimits, type CapMaterial, type CapUniforms, type ControlScheme, 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, 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, PartReportFormatError, type Projection, type RankingContext, RegionIndex, type Retarget, type RetargetPose, SNAP_MARKER_PIXELS, SNAP_PIXELS, type SceneBounds, SectionOptions, SectionState, type SectionStore, SectionTool, type SectionToolProps, SectionView, type Snap, type SnapEdges, type SnapHit, type SnapKind, 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, type ViewerView, type ViewportSize, adaptedUp, angleArc, angleArcRadius, angleAt, applyCapTheme, applyProjection, arrowPlacement, aspectRatio, bestOwner, boundsFromBox, buildRegionIndex, cadViewDirections, cameraLimits, contentBounds, createCapMaterial, createMaskMaterial, createMaskTarget, createSectionStore, createStencilMaterials, cubeOutlineGeometry, cubeZones, currentViewDirection, cycleOwner, defaultBounds, deltaBetween, deltaLegs, directionIndexOf, directionLabel, distanceBetween, excludedFromFrame, featureTypeRank, fitDistance, formatDegrees, formatMillimetres, gridGeometry, gridSpec, groupByDirection, labelGeometry, labelTexture, lockToAxis, measurementFromPoints, measurementLabel, measurementLabelAnchor, midpoint, movedFar, nextMeasurementId, orbitTargetOpacity, orthographicHalfHeight, panelGeometry, perspectiveFitDistance, rankOwners, regionAdjacency, regionEdgesGeometry, regionNormals, resolveSectionPlane, retargetPose, sameDirection, screenLength, screenPoint, snapAt, squaredUp, startPosition, targetBoundary, trackDoubleTaps, trackTaps, useContentBox, useRetarget, useSectionStore, useTapGuard, useViewerControls, viewKind, viewUp, viewVector, visualSurfaces };
+export { ANGLE_ARC_FRACTION, ANGLE_ARC_SEGMENTS, AXIS_COLORS, type AngleMeasurement, type ArrowPlacement, Axes, type AxesProps, type Axis, type AxisLock, CAD_CAMERA_UP, CHAMFER, CadCameraControls, type CadCameraControlsProps, type CameraLimits, type CapMaterial, type CapUniforms, type ControlScheme, 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, 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, PartReportFormatError, type Projection, type RankingContext, 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, 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, type ViewerView, type ViewportSize, adaptedUp, angleArc, angleArcRadius, angleAt, applyCapTheme, applyProjection, arrowPlacement, aspectRatio, bestOwner, boundsFromBox, buildRegionIndex, cadViewDirections, cameraLimits, capHit, clipSegments, contentBounds, createCapMaterial, createMaskMaterial, createMaskTarget, createSectionStore, createStencilMaterials, cubeOutlineGeometry, cubeZones, currentViewDirection, cycleOwner, defaultBounds, deltaBetween, deltaLegs, directionIndexOf, directionLabel, distanceBetween, excludedFromFrame, featureTypeRank, fitDistance, 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, viewKind, viewUp, viewVector, visualSurfaces };

package/dist/index.js

@@ -131,7 +131,7 @@ import {
   viewUp,
   viewVector,
   visualSurfaces
-} from "./chunk-HWAEUJ4H.js";
+} from "./chunk-HH3W5T42.js";
 
 // src/primitives.tsx
 import { GizmoHelper } from "@react-three/drei";
@@ -644,6 +644,10 @@ var Picker = ({ box, theme }) => {
   const span = useMemo3(() => box.getSize(new Vector34()).length(), [box]);
   const centre = useMemo3(() => box.getCenter(new Vector34()), [box]);
   const previewSize = span * PREVIEW_SCALE;
+  useEffect2(() => {
+    store.setPicking(true);
+    return () => store.setPicking(false);
+  }, [store]);
   useEffect2(() => {
     const raycaster = new Raycaster();
     const pointer = new Vector22();
@@ -840,13 +844,194 @@ var CutSheet = ({ box, section, theme }) => {
 // src/measure-tool.tsx
 import { Html, Line } from "@react-three/drei";
 import { useFrame as useFrame2, useThree as useThree4 } from "@react-three/fiber";
-import { useEffect as useEffect3, useLayoutEffect, useMemo as useMemo4, useRef as useRef3, useState as useState3 } from "react";
 import {
+  useEffect as useEffect3,
+  useLayoutEffect,
+  useMemo as useMemo4,
+  useRef as useRef3,
+  useState as useState3,
+  useSyncExternalStore as useSyncExternalStore2
+} from "react";
+import {
+  Matrix4,
   Raycaster as Raycaster2,
   SphereGeometry,
   Vector2 as Vector23,
-  Vector3 as Vector35
+  Vector3 as Vector36
 } from "three";
+
+// src/render/resample.ts
+import { Vector3 as Vector35 } from "three";
+var ON_PLANE = 1e-7;
+var STITCH = 1e-5;
+var COLLINEAR = 1e-6;
+function clipSegments(positions, plane) {
+  const out = [];
+  const a = new Vector35();
+  const b = new Vector35();
+  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]);
+    b.set(positions[i * 6 + 3], positions[i * 6 + 4], positions[i * 6 + 5]);
+    const da = plane.distanceToPoint(a);
+    const db = plane.distanceToPoint(b);
+    if (da < -ON_PLANE && db < -ON_PLANE) continue;
+    if (da < -ON_PLANE) a.lerp(b, da / (da - db));
+    else if (db < -ON_PLANE) b.lerp(a, db / (db - da));
+    out.push(a.x, a.y, a.z, b.x, b.y, b.z);
+  }
+  return Float32Array.from(out);
+}
+function sectionContour(positions, regionOf, plane) {
+  const a = new Vector35();
+  const b = new Vector35();
+  const c = new Vector35();
+  const p = new Vector35();
+  const q = new Vector35();
+  const byRegion = /* @__PURE__ */ new Map();
+  const triangleCount = Math.floor(positions.length / 9);
+  for (let t = 0; t < triangleCount; 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]);
+    const crossings = triangleCrossings(a, b, c, plane, p, q);
+    if (!crossings) continue;
+    const region = regionOf ? regionOf[t] ?? 0 : 0;
+    const list = byRegion.get(region);
+    const entry = [p.x, p.y, p.z, q.x, q.y, q.z];
+    if (list) list.push(...entry);
+    else byRegion.set(region, entry);
+  }
+  const out = [];
+  for (const segments of byRegion.values()) stitch(segments, out);
+  return Float32Array.from(out);
+}
+function triangleCrossings(a, b, c, plane, p, q) {
+  const da = plane.distanceToPoint(a);
+  const db = plane.distanceToPoint(b);
+  const dc = plane.distanceToPoint(c);
+  const sa = da < -ON_PLANE;
+  const sb = db < -ON_PLANE;
+  const sc = dc < -ON_PLANE;
+  if (sa === sb && sb === sc) return false;
+  const found = [];
+  const edge = (u, v, du, dv, su, sv) => {
+    if (su === sv) return;
+    found.push(u.clone().lerp(v, du / (du - dv)));
+  };
+  edge(a, b, da, db, sa, sb);
+  edge(b, c, db, dc, sb, sc);
+  edge(c, a, dc, da, sc, sa);
+  if (found.length < 2) return false;
+  p.copy(found[0]);
+  q.copy(found[1]);
+  return p.distanceToSquared(q) > ON_PLANE * ON_PLANE;
+}
+function stitch(segments, out) {
+  const count = segments.length / 6;
+  const key = (x, y, z) => `${Math.round(x / STITCH)},${Math.round(y / STITCH)},${Math.round(z / STITCH)}`;
+  const ends = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i += 1) {
+    for (const end of [0, 1]) {
+      const o = i * 6 + end * 3;
+      const k = key(segments[o], segments[o + 1], segments[o + 2]);
+      const list = ends.get(k);
+      if (list) list.push(i * 2 + end);
+      else ends.set(k, [i * 2 + end]);
+    }
+  }
+  const point = (i, end, into) => {
+    const o = i * 6 + end * 3;
+    return into.set(segments[o], segments[o + 1], segments[o + 2]);
+  };
+  const direction = (i, into) => {
+    const s = new Vector35();
+    const e = new Vector35();
+    point(i, 0, s);
+    point(i, 1, e);
+    return into.subVectors(e, s).normalize();
+  };
+  const consumed = new Uint8Array(count);
+  const d = new Vector35();
+  const n = new Vector35();
+  const next = (i, end) => {
+    const at = point(i, end, new Vector35());
+    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);
+    if (other === void 0) return null;
+    const j = other >> 1;
+    if (consumed[j]) return null;
+    direction(i, d);
+    direction(j, n);
+    if (Math.abs(Math.abs(d.dot(n)) - 1) > COLLINEAR) return null;
+    return { index: j, end: other & 1 };
+  };
+  for (let i = 0; i < count; i += 1) {
+    if (consumed[i]) continue;
+    consumed[i] = 1;
+    const walk = (end) => {
+      let at = { index: i, end };
+      let steps = 0;
+      for (; ; ) {
+        const step = next(at.index, at.end);
+        if (!step || steps > count) break;
+        consumed[step.index] = 1;
+        at = { index: step.index, end: 1 - step.end };
+        steps += 1;
+      }
+      return at;
+    };
+    const back = walk(0);
+    const forward = walk(1);
+    const s = point(back.index, back.end, new Vector35());
+    const e = point(forward.index, forward.end, new Vector35());
+    out.push(s.x, s.y, s.z, e.x, e.y, e.z);
+  }
+}
+function pointInContour(point, plane, contour) {
+  const [u, v] = planeAxes(plane);
+  const px = point.dot(u);
+  const py = point.dot(v);
+  const a = new Vector35();
+  const b = new Vector35();
+  let inside = false;
+  const count = Math.floor(contour.length / 6);
+  for (let i = 0; i < count; i += 1) {
+    a.set(contour[i * 6], contour[i * 6 + 1], contour[i * 6 + 2]);
+    b.set(contour[i * 6 + 3], contour[i * 6 + 4], contour[i * 6 + 5]);
+    const ax = a.dot(u);
+    const ay = a.dot(v);
+    const bx = b.dot(u);
+    const by = b.dot(v);
+    if (ay > py === by > py) continue;
+    const x = ax + (py - ay) / (by - ay) * (bx - ax);
+    if (px < x) inside = !inside;
+  }
+  return inside;
+}
+function capHit(ray, plane, contour) {
+  const point = ray.intersectPlane(plane, new Vector35());
+  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 Vector35(1, 0, 0) : new Vector35(0, 1, 0);
+  const u = new Vector35().crossVectors(n, seed).normalize();
+  const v = new Vector35().crossVectors(n, u).normalize();
+  return [u, v];
+}
+function sampleSection(meshPositions, regionOf, edgePositions, plane) {
+  const contour = sectionContour(meshPositions, regionOf, plane);
+  const kept = edgePositions ? clipSegments(edgePositions, plane) : new Float32Array();
+  const edges = new Float32Array(kept.length + contour.length);
+  edges.set(kept, 0);
+  edges.set(contour, kept.length);
+  return { edges, contour };
+}
+
+// src/measure-tool.tsx
 import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var FURNITURE4 = { [EXCLUDE_FROM_FRAME]: true };
 var MEASURE_LABEL_CLASS = "toolpath-measure-label";
@@ -862,6 +1047,7 @@ var MeasureTool = ({
   const store = useSectionStore();
   const box = useContentBox();
   const resolved = useMemo4(() => resolveTheme(theme), [theme]);
+  const picking = useSyncExternalStore2(store.subscribe, store.isPicking, store.isPicking);
   const [held, setHeld] = useState3([]);
   const controlled = measurements !== void 0;
   const list = controlled ? measurements : held;
@@ -908,7 +1094,7 @@ var MeasureTool = ({
   if (box.isEmpty()) return null;
   const label = className(labelClassName);
   return /* @__PURE__ */ jsxs4("group", { userData: FURNITURE4, children: [
-    /* @__PURE__ */ jsx4(
+    picking ? null : /* @__PURE__ */ jsx4(
       Snapper,
       {
         mode,
@@ -943,7 +1129,7 @@ var MeasureTool = ({
   ] });
 };
 var NO_POINTER = { pointerEvents: "none" };
-var NOWHERE = [new Vector35(), new Vector35()];
+var NOWHERE = [new Vector36(), new Vector36()];
 var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
   const camera = useThree4((state) => state.camera);
   const scene = useThree4((state) => state.scene);
@@ -967,6 +1153,7 @@ var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
   useEffect3(() => {
     const raycaster = new Raycaster2();
     const pointer = new Vector23();
+    const samples = new SampleCache();
     const hide = () => {
       if (!snap.current) return;
       snap.current = null;
@@ -986,22 +1173,16 @@ var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
         -((clientY - rect.top) / rect.height) * 2 + 1
       );
       raycaster.setFromCamera(pointer, camera);
-      const hit = hitUnderRay(raycaster, scene);
-      if (!hit?.face) {
+      const target = targetUnderRay(raycaster, scene, samples);
+      if (!target) {
         hide();
         return;
       }
-      const normal = hit.face.normal.clone().transformDirection(hit.object.matrixWorld);
       const { size: viewport, draft: placed, mode: kind, format: write } = current.current;
-      const snapped = snapAt(
-        { point: hit.point, normal },
-        edgesBeside(hit.object),
-        camera,
-        viewport
-      );
+      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 Vector35(lock.point.x, lock.point.y, lock.point.z), edge: null } : snapped;
+      const found = lock ? { ...snapped, point: new Vector36(lock.point.x, lock.point.y, lock.point.z), edge: null } : snapped;
       snap.current = found;
       const node = marker.current;
       if (node) {
@@ -1043,8 +1224,14 @@ var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
       if (event.key !== "Shift" || !last || !snap.current) return;
       update(last.x, last.y, event.type === "keydown");
     };
+    let pressed = false;
+    const down = () => {
+      pressed = true;
+    };
     const up = (event) => {
-      if (event.button !== 0 || !isTap(event)) return;
+      const seen = pressed;
+      pressed = false;
+      if (!seen || event.button !== 0 || !isTap(event)) return;
       update(event.clientX, event.clientY, event.shiftKey);
       const found = snap.current;
       if (!found) return;
@@ -1056,12 +1243,14 @@ var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
     };
     domElement.addEventListener("pointermove", move);
     domElement.addEventListener("pointerleave", leave);
+    domElement.addEventListener("pointerdown", down);
     domElement.addEventListener("pointerup", up);
     window.addEventListener("keydown", key);
     window.addEventListener("keyup", key);
     return () => {
       domElement.removeEventListener("pointermove", move);
       domElement.removeEventListener("pointerleave", leave);
+      domElement.removeEventListener("pointerdown", down);
       domElement.removeEventListener("pointerup", up);
       window.removeEventListener("keydown", key);
       window.removeEventListener("keyup", key);
@@ -1144,17 +1333,124 @@ function liveLabel(mode, placed, at, format) {
   }
   return null;
 }
+function targetUnderRay(raycaster, scene, samples) {
+  let best = null;
+  const hit = hitUnderRay(raycaster, scene);
+  if (hit?.face) {
+    best = {
+      point: hit.point,
+      normal: hit.face.normal.clone().transformDirection(hit.object.matrixWorld),
+      distance: hit.distance,
+      edges: samples.edgesFor(hit.object)
+    };
+  }
+  const local = new Matrix4();
+  for (const mesh of cutMeshes(scene)) {
+    const planes = clippingPlanesOf(mesh);
+    const sample = samples.for(mesh, planes);
+    local.copy(mesh.matrixWorld).invert();
+    const ray = raycaster.ray.clone().applyMatrix4(local);
+    for (const [index, plane] of planes.entries()) {
+      const contour = sample.contours[index];
+      if (!contour) continue;
+      const point = capHit(ray, plane.clone().applyMatrix4(local), contour);
+      if (!point) continue;
+      const world = point.applyMatrix4(mesh.matrixWorld);
+      if (planes.some((other, i) => i !== index && other.distanceToPoint(world) < -1e-7)) continue;
+      const distance = world.distanceTo(raycaster.ray.origin);
+      if (best && distance >= best.distance) continue;
+      best = {
+        point: world,
+        // The cap faces the half that was taken away.
+        normal: plane.normal.clone().negate(),
+        distance,
+        edges: { positions: sample.edges, matrixWorld: mesh.matrixWorld }
+      };
+    }
+  }
+  return best;
+}
+function cutMeshes(scene) {
+  const found = [];
+  scene.traverse((object) => {
+    if (!("isMesh" in object) || !object.visible || excludedFromFrame(object, scene)) return;
+    if (clippingPlanesOf(object).length) found.push(object);
+  });
+  return found;
+}
+function clippingPlanesOf(mesh) {
+  const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+  return material?.clippingPlanes ?? [];
+}
 function edgesBeside(object) {
   const siblings = object.parent?.children ?? [];
   for (const sibling of siblings) {
     if (!("isLineSegments" in sibling)) continue;
-    const geometry = sibling.geometry;
-    const positions = geometry.getAttribute("position");
-    if (!positions) continue;
-    return { positions: positions.array, matrixWorld: sibling.matrixWorld };
+    const positions = sibling.geometry.getAttribute("position");
+    if (positions) return positions.array;
   }
   return null;
 }
+var SampleCache = class {
+  held = /* @__PURE__ */ new Map();
+  regions = /* @__PURE__ */ new Map();
+  /** The edges to snap to on `mesh`: its own, or the trimmed set with the cut's outline. */
+  edgesFor(mesh) {
+    const planes = clippingPlanesOf(mesh);
+    if (planes.length === 0) {
+      const positions = edgesBeside(mesh);
+      return positions ? { positions, matrixWorld: mesh.matrixWorld } : null;
+    }
+    return { positions: this.for(mesh, planes).edges, matrixWorld: mesh.matrixWorld };
+  }
+  for(mesh, planes) {
+    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 localPlanes = planes.map((plane) => plane.clone().applyMatrix4(local));
+    const positions = mesh.geometry.getAttribute("position")?.array ?? [];
+    const regionOf = this.regionsOf(mesh.geometry);
+    const contours = localPlanes.map(
+      (plane, index) => localPlanes.reduce(
+        (outline, other, i) => i === index ? outline : clipSegments(outline, other),
+        sectionContour(positions, regionOf, plane)
+      )
+    );
+    const own = edgesBeside(mesh) ?? [];
+    const trimmed = localPlanes.reduce(
+      (kept, plane) => clipSegments(kept, plane),
+      own
+    );
+    const total = contours.reduce((sum, contour) => sum + contour.length, trimmed.length);
+    const edges = new Float32Array(total);
+    edges.set(trimmed, 0);
+    let offset = trimmed.length;
+    for (const contour of contours) {
+      edges.set(contour, offset);
+      offset += contour.length;
+    }
+    const sample = { key, contours, edges };
+    this.held.set(mesh, sample);
+    return sample;
+  }
+  /**
+   * Which surface each triangle belongs to, read off the region attribute
+   * `createPart` gives the mesh. A mesh without one is sampled as a single
+   * surface, which still stitches a flat face's outline into one run.
+   */
+  regionsOf(geometry) {
+    if (this.regions.has(geometry)) return this.regions.get(geometry) ?? null;
+    const attribute = geometry.getAttribute(REGION_ATTRIBUTE);
+    let regions = null;
+    if (attribute && !geometry.index) {
+      regions = new Int32Array(Math.floor(attribute.count / 3));
+      for (let t = 0; t < regions.length; t += 1) regions[t] = attribute.getX(t * 3);
+    }
+    this.regions.set(geometry, regions);
+    return regions;
+  }
+};
 var MeasurementView = ({
   measurement,
   theme,
@@ -1194,7 +1490,7 @@ var DeltaLegs = ({ a, b, id, format, label }) => {
   const lines = useRef3([]);
   const centre = useMemo4(() => {
     const at = midpoint(a, b);
-    return new Vector35(at.x, at.y, at.z);
+    return new Vector36(at.x, at.y, at.z);
   }, [a, b]);
   useFrame2(() => {
     const dash = screenLength(camera, centre, size, DELTA_DASH_PIXELS);
@@ -1216,8 +1512,8 @@ var DeltaLegs = ({ a, b, id, format, label }) => {
           lines.current[index] = line;
         },
         points: [
-          new Vector35(leg.from.x, leg.from.y, leg.from.z),
-          new Vector35(leg.to.x, leg.to.y, leg.to.z)
+          new Vector36(leg.from.x, leg.from.y, leg.from.z),
+          new Vector36(leg.to.x, leg.to.y, leg.to.z)
         ],
         color: AXIS_COLORS[leg.axis],
         lineWidth: MEASURE_LINE_PIXELS.leg,
@@ -1253,7 +1549,7 @@ var ScreenDot = ({ point, pixels, color }) => {
   const invalidate = useThree4((state) => state.invalidate);
   const node = useRef3(null);
   const dot = useDot();
-  const position = useMemo4(() => new Vector35(point.x, point.y, point.z), [point]);
+  const position = useMemo4(() => new Vector36(point.x, point.y, point.z), [point]);
   useFrame2(() => {
     const group = node.current;
     if (!group) return;
@@ -1268,7 +1564,7 @@ var ScreenDot = ({ point, pixels, color }) => {
 var Segment = ({ points, color }) => {
   const [a, b] = points;
   const ends = useMemo4(
-    () => [new Vector35(a.x, a.y, a.z), new Vector35(b.x, b.y, b.z)],
+    () => [new Vector36(a.x, a.y, a.z), new Vector36(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]
@@ -1419,6 +1715,8 @@ export {
   buildRegionTexels,
   cadViewDirections,
   cameraLimits,
+  capHit,
+  clipSegments,
   contentBounds,
   createCapMaterial,
   createMaskMaterial,
@@ -1463,6 +1761,7 @@ export {
   panelGeometry,
   perspectiveFitDistance,
   pickedStartDepth,
+  pointInContour,
   rankOwners,
   regionAdjacency,
   regionEdgesGeometry,
@@ -1471,11 +1770,13 @@ export {
   resolveTheme,
   retargetPose,
   sameDirection,
+  sampleSection,
   screenLength,
   screenPoint,
   sectionAnchor,
   sectionBounds,
   sectionConstant,
+  sectionContour,
   sectionDepth,
   sectionDepthConstant,
   sectionDepthRange,

package/package.json

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