@toolpath/viewer 1.1.1 → 1.3.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { P as PartModel, V as Vec3, d as ViewerTheme, e as PartModelRegion, T as TriangleRange, F as FeatureTag, R as RegionIndex, f as PartModelFeature, g as FeatureType } from './normalize-OULo7e0F.js';
-export { B as BuildPickInput, C as CANDIDATE_WEIGHT, D as DEFAULT_THEME, h as DIRECTION_COLORS, E as EnginePart, i as FeatureHighlight, H as HANDLE_PIXELS, j as HIGHLIGHT_COLORS, k as HIGHLIGHT_WEIGHT, l as HOVER_WEIGHT, m as HighlightLayers, K as KnownFeatureType, o as KnownShapeKind, N as NO_MODIFIERS, p as PICKED_SURFACE_LABEL, q as PartMesh, r as PartMeshProps, a as PartMeshRefs, t as PartObject, u as PartPick, v as PickModifiers, w as REGION_ATTRIBUTE, x as RegionHighlight, y as RegionPaint, S as SECTION_RENDER_ORDER, z as SectionAnchor, A as SectionBounds, G as SectionOptions, I as SectionPlacement, J as SectionState, L as SectionView, O as ShapeKind, Q as applyHighlightLayers, U as buildPick, W as buildRegionAttribute, X as buildRegionTexels, Y as createPart, Z as directionColor, _ as dragPlane, $ as focusForPick, n as normalizePartReport, a0 as pickedStartDepth, a1 as resolveSectionPlane, a2 as resolveTheme, a3 as sectionBounds, a4 as sectionConstant, a5 as sectionDepth, a6 as sectionDepthConstant, a7 as sectionDepthRange, a8 as sectionFromPick, a9 as sectionOffset, aa as sectionPlane, s as smoothRegionNormals, ab as themesEqual, ac as viewDirection } from './normalize-OULo7e0F.js';
-import { BufferGeometry, CanvasTexture, Vector3, Box3, OrthographicCamera, PerspectiveCamera, Object3D } from 'three';
+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, Ray, ShaderMaterial, Texture, Color, MeshBasicMaterial, WebGLRenderTarget } from 'three';
 import * as react from 'react';
 import { RefObject, ReactNode, CSSProperties } from 'react';
 import CameraControls from 'camera-controls';
@@ -192,6 +192,668 @@ interface DirectionArrowsProps {
  */
 declare const DirectionArrows: ({ directions, activeDirection, shownDirection, previewDirection, namedDirections, onPickDirection, theme, visible, }: DirectionArrowsProps) => react.JSX.Element | null;
 
+/** The cut's plane for a set of options, or `null` when there is no cut. */
+declare function resolveSectionPlane(options: SectionOptions | undefined, box: Box3): {
+    plane: Plane;
+    state: SectionState;
+} | null;
+interface SectionViewProps {
+    geometry: BufferGeometry;
+    box: Box3;
+    plane: Plane;
+    theme: ViewerTheme;
+    showHandle: boolean;
+    onDrag?: (constant: number) => void;
+}
+/**
+ * A clipping plane with a hatched cap over the cut, and an arrow that drags it.
+ *
+ * The cap is the standard two-pass stencil trick: draw the clipped geometry's
+ * back faces incrementing the stencil and its front faces decrementing it, so a
+ * non-zero stencil marks exactly where the plane passes through solid material,
+ * then fill that region with a quad. Without it a section shows the inside of
+ * the far wall and the part reads as hollow.
+ *
+ * The fill is hatched and outlined — see `render/section-cap.ts` — which takes
+ * a pre-pass: the same stencil trick is run once more into a render target on
+ * its own, so the cap's shader can find its edge by sampling that mask. That
+ * pass draws a scene of its own holding nothing but the stencil meshes and the
+ * mask quad, at a priority ahead of R3F's own render.
+ *
+ * **The renderer must be created with `stencil: true`.** three defaults it to
+ * false, and without it every one of those stencil operations is a silent
+ * no-op — the cut still happens and the part still looks hollow, which is a
+ * confusing way to find out.
+ */
+declare const SectionView: ({ geometry, box, plane, theme, showHandle, onDrag, }: SectionViewProps) => react.JSX.Element;
+
+interface SectionToolProps {
+    theme?: Partial<ViewerTheme>;
+}
+/**
+ * The interactive way to cut a part open. Mount it beside `<PartMesh>`.
+ *
+ * With no cut in place it offers two: hover a face and a small square previews
+ * a cut through it — click to make it — or click one of the three global
+ * planes standing behind the part to sweep along that axis. Once there is a
+ * cut it draws the cutting plane as a translucent sheet with an outline, and
+ * `Escape` clears it. The handle that drags the cut, and the hatched cap, are
+ * the part's own and appear whether or not this is mounted.
+ *
+ * Nothing needs wiring. The cut lives in the viewer, `<PartMesh>` follows it
+ * when it is given no `section` of its own, and `ViewerHandle.setSection` is
+ * 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.
+ */
+declare const SectionTool: ({ theme }: SectionToolProps) => react.JSX.Element | null;
+
+type Projection = 'orthographic' | 'perspective';
+type ViewerCamera = OrthographicCamera | PerspectiveCamera;
+interface ViewportSize {
+    readonly width: number;
+    readonly height: number;
+}
+/** Vertical field of view, in degrees, for the perspective camera. */
+declare const PERSPECTIVE_FOV = 30;
+/** Padding around the framed bounds, as a multiple of its radius. */
+declare const DEFAULT_FIT_MARGIN = 1.2;
+/** Marks scene furniture — grid, axes — that the camera should not frame. */
+declare const EXCLUDE_FROM_FRAME = "viewerExcludeFromFrame";
+/**
+ * What the camera frames: a bounding *sphere*, not a box.
+ *
+ * A sphere makes framing rotation-invariant — the part stays fully visible from
+ * every angle, and a resize never needs to know the current pose. Framing
+ * per-axis box dimensions instead means recomputing the camera distance on
+ * every resize, and still clipping on some orientations.
+ */
+interface SceneBounds {
+    readonly center: Vector3;
+    readonly radius: number;
+}
+/**
+ * Bounds for a scene with nothing in it. A viewer is mounted before it has a
+ * part, and a camera with a zero-size frustum renders nothing at all.
+ */
+declare function defaultBounds(): SceneBounds;
+/**
+ * A container can be laid out at zero size, and a degenerate aspect ratio
+ * produces a `NaN` projection matrix that never recovers. Fall back to square.
+ */
+declare function aspectRatio(size: ViewportSize): number;
+/**
+ * A world length that covers `pixels` on screen at `point`.
+ *
+ * Anything sized in world units is a thumbnail on a plate and a wall on an
+ * insert; the whole reason a control is measured this way is that it is a
+ * control rather than part of the model. The section handle and the orbit
+ * target marker both size themselves with it, which is why it lives here with
+ * the camera rather than beside either of them.
+ *
+ * The two projections answer differently on purpose. An orthographic frustum
+ * covers the same world height wherever the point is, so distance does not
+ * enter; a perspective one covers more the further away it looks, so it does.
+ */
+declare function screenLength(camera: ViewerCamera, point: Vector3, viewport: ViewportSize, pixels: number): number;
+declare function boundsFromBox(box: Box3): SceneBounds;
+/**
+ * The bounds of everything worth framing under `root`.
+ *
+ * Skips objects flagged with {@link EXCLUDE_FROM_FRAME} and their descendants:
+ * a 100 mm grid around a 6 mm part would otherwise frame the grid, and the part
+ * would be a speck.
+ */
+declare function contentBounds(root: Object3D, into: Box3): SceneBounds;
+/**
+ * Whether `object`, or anything between it and `root`, carries
+ * {@link EXCLUDE_FROM_FRAME}. The flag is set on an overlay's outermost group
+ * and means the whole subtree, so the walk goes up rather than reading the
+ * object alone.
+ */
+declare function excludedFromFrame(object: Object3D, root: Object3D): boolean;
+/**
+ * The distance at which a sphere of `radius` fits inside a perspective frustum.
+ * Uses the narrower of the two field-of-view angles, so a portrait viewport
+ * frames on width and a landscape one on height.
+ */
+declare function perspectiveFitDistance(fovDegrees: number, aspect: number, radius: number): number;
+/**
+ * Half-height of an orthographic frustum that fits a sphere of `radius`. A
+ * portrait viewport grows the height so the width still clears the sphere.
+ */
+declare function orthographicHalfHeight(aspect: number, radius: number): number;
+declare function fitDistance(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number): number;
+declare function startPosition(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number): Vector3;
+/**
+ * How far out the wheel may pull, as a fraction of the fitted framing: the part
+ * may shrink to a quarter of the view and no further. Past that it is a speck
+ * with no cue that Fit is the way back.
+ */
+declare const MIN_FRAME_RATIO = 0.25;
+/**
+ * How far in the wheel may push, as a multiple of the fitted framing.
+ *
+ * Both ratios are the legacy viewer's `minZoom` 0.25 / `maxZoom` 10
+ * (`three-object.tsx:289-311`), which transfer almost exactly: legacy's
+ * orthographic frustum was `largestDimension * 2` tall and this one is the
+ * fitted bounding sphere, which for a cube agree within a few percent. So the
+ * numbers are the ones that shipped, and here they carry a meaning they did not
+ * have there — `zoom` 1 *is* the fitted framing, so 0.25 and 10 say exactly
+ * what a reader thinks they say.
+ */
+declare const MAX_FRAME_RATIO = 10;
+/** How far the camera may travel, in the two units the two cameras travel in. */
+interface CameraLimits {
+    readonly minZoom: number;
+    readonly maxZoom: number;
+    readonly minDistance: number;
+    readonly maxDistance: number;
+}
+/**
+ * The clamps for a scene, so the wheel cannot leave the viewport empty.
+ *
+ * Without them it can, from either end, and both cameras can do it: an
+ * orthographic `camera.zoom` reaches 1e30 in sixty notches, and a perspective
+ * camera dives inside the part in eight, because `minDistance` defaults to
+ * `Number.EPSILON`. Fit recovers from both — but Fit is a double middle click
+ * and nothing on screen says so, which makes it a way out rather than an
+ * answer.
+ *
+ * One rule for both cameras: the wheel may take the part from a quarter of its
+ * fitted size to ten times it. Under an orthographic camera that scale *is* the
+ * frustum, so the ratios land on `zoom`; under a perspective camera apparent
+ * size is the inverse of distance, so they land on `distance` — which is why
+ * they swap sides between the two.
+ *
+ * Pure, and derived from `bounds`, so it re-derives wherever the scene is
+ * re-measured rather than being sampled once at mount.
+ *
+ * `framed` is what the view has been framed *on*, when that is not the whole
+ * scene — `frameBox` on a single feature. The band is then taken about that
+ * framing as well as about the scene's, because a band centred on the part is
+ * the wrong band for a view of a 3 mm hole in it: ten times the *part's* fitted
+ * size can be less than once the hole's, so the framing the caller asked for sat
+ * outside the clamps meant to keep it in view. Under an orthographic camera
+ * `zoom` is measured against a frustum still sized to the scene, so the framing
+ * enters as the zoom ratio it takes to reach; under a perspective one it enters
+ * as its own fitted distance.
+ *
+ * Widened to the union of the two rather than moved onto `framed`, and that is
+ * the whole of why this takes both. A band that simply followed the last framing
+ * would take the part away: framing a hole would put "far enough out to see what
+ * the hole is in" past `maxDistance`, so the wheel could no longer get back to
+ * the part it had just been looking at, and Fit — a gesture with nothing on
+ * screen to say so — would be the only way. Reaching further in must not cost
+ * the reach back out, so each end takes whichever bound is looser. With no
+ * `framed`, or one the size of the scene, both ends collapse to the scene's own
+ * and this is the function it was before.
+ */
+declare function cameraLimits(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number, framed?: SceneBounds): CameraLimits;
+/**
+ * The box the orbit target is confined to — the fitted framing, several frames
+ * over. Written into `into` so the per-frame path allocates nothing.
+ */
+declare function targetBoundary(bounds: SceneBounds, into: Box3, margin?: number): Box3;
+/**
+ * Points an existing camera's frustum at `bounds` for the current viewport.
+ * Pose is untouched — that belongs to the controls.
+ */
+declare function applyProjection(camera: ViewerCamera, size: ViewportSize, bounds: SceneBounds, margin?: number): void;
+/**
+ * The world-up convention. The part data is Z-up (millimetres, no conversion) —
+ * not the glTF-conventional Y-up — so the camera has to say so explicitly.
+ */
+declare const CAD_CAMERA_UP: Vector3;
+/**
+ * `up` re-squared against a view direction: the part of it perpendicular to
+ * `view`, written into `into`.
+ *
+ * This is what keeps the horizon level while a free orbit carries the camera
+ * over a pole — the up vector follows the view instead of flipping. The
+ * controls run it on every update, which is what makes the next sentence the
+ * important one.
+ *
+ * **It is path-dependent.** It is a projection, so it discards the component it
+ * removes and cannot put it back: running it at one view and then another does
+ * not give what running it once at the second view would. So a camera carries
+ * the roll of every pose it has passed through, and any pose that is meant to
+ * be canonical — the opening frame, a reset, a named view — has to say what
+ * `up` is rather than inherit it. `viewer.tsx` does, at `resetContent`. The
+ * test beside this pins both halves.
+ *
+ * `into` may be `view` or `up` — three.js `crossVectors` reads all six
+ * components before it writes any, and the intermediate is this module's own
+ * scratch, so writing the result over an input is safe. Said here because this
+ * is exported and an out-parameter invites the question; the test beside this
+ * pins it, so a three.js change cannot quietly turn the answer around.
+ *
+ * `view` and `up` being parallel is the one degenerate case: their cross is
+ * zero, `normalize` leaves it zero, and the result is a zero vector rather than
+ * an error. A caller with a free-orbiting camera reaches that at the pole,
+ * which is what `freeOrbit` and a squared `up` at every canonical pose exist to
+ * keep it away from.
+ */
+declare function adaptedUp(view: Vector3, up: Vector3, into: Vector3): Vector3;
+/** Named viewing directions, as unit vectors from the part toward the camera. */
+declare const cadViewDirections: {
+    readonly front: Vector3;
+    readonly back: Vector3;
+    readonly left: Vector3;
+    readonly right: Vector3;
+    readonly top: Vector3;
+    readonly bottom: Vector3;
+    readonly isometric: Vector3;
+};
+type ViewerView = keyof typeof cadViewDirections;
+/** The current orbit direction, so Fit can retain the direction being looked from. */
+declare function currentViewDirection(camera: ViewerCamera, target: Vector3, into: Vector3): Vector3;
+
+/**
+ * Measuring, without a canvas: where a pointer snaps to, what two or three
+ * points measure, and how that is written down. `measure-tool.tsx` is the
+ * React surface over this.
+ */
+/** Draws over the part and the section cap, under nothing. */
+declare const MEASURE_RENDER_ORDER = 7;
+/**
+ * One colour per world axis, the hue `<Axes>` draws that axis in — lightened,
+ * because a pure primary through 30% on a dark page is mud, and the blue one
+ * was not there at all. The section tool's three global planes and a
+ * distance's X, Y, Z legs both wear them, so an axis is one colour everywhere.
+ */
+declare const AXIS_COLORS: Record<Axis, number>;
+/**
+ * How close, in CSS pixels, the pointer has to be for a snap to take.
+ *
+ * A vertex or a midpoint is a point, so it gets the wider reach; an edge is a
+ * line the pointer can sit on, so it needs less. The pointer snaps to the
+ * strongest kind it is within reach of — a corner over the edge it ends, the
+ * edge over the face it bounds — which is what makes clicking the corner of a
+ * part produce the corner rather than a point a pixel off it.
+ */
+declare const SNAP_PIXELS: {
+    readonly vertex: 14;
+    readonly midpoint: 12;
+    readonly edge: 9;
+};
+/** The snap indicator's radius on screen, by what it is on, in CSS pixels. */
+declare const SNAP_MARKER_PIXELS: {
+    readonly vertex: 6;
+    readonly midpoint: 5;
+    readonly edge: 4;
+    readonly face: 3.5;
+};
+/** A measurement's end marker, in CSS pixels. */
+declare const MEASURE_MARKER_PIXELS = 3.5;
+/**
+ * Line widths in CSS pixels: a measurement's own line, a delta leg, and the
+ * edge the pointer is snapped to.
+ */
+declare const MEASURE_LINE_PIXELS: {
+    readonly line: 2;
+    readonly leg: 1.5;
+    readonly edge: 3;
+};
+/** Dash and gap of a delta leg, in CSS pixels. */
+declare const DELTA_DASH_PIXELS = 6;
+/** How much of the shorter arm an angle's arc is drawn at. */
+declare const ANGLE_ARC_FRACTION = 0.3;
+/** Segments in an angle's arc. */
+declare const ANGLE_ARC_SEGMENTS = 24;
+type SnapKind = 'vertex' | 'midpoint' | 'edge' | 'face';
+/** Where the pointer landed after snapping, and what it landed on. */
+interface Snap {
+    readonly kind: SnapKind;
+    readonly point: Vector3;
+    /** The outward normal of the surface under the pointer, in world space. */
+    readonly normal: Vector3;
+    /** For an edge or midpoint snap, the edge in world space. */
+    readonly edge: readonly [Vector3, Vector3] | null;
+}
+/**
+ * The edges a pointer can snap to: segment endpoints, six floats per segment,
+ * in the space `matrixWorld` maps to the world.
+ *
+ * In practice this is the part's own edge overlay — `regionEdgesGeometry` —
+ * which draws a line only where two analytic surfaces meet. Those are the edges
+ * a machinist would put a caliper on; the diagonal a tessellator drew across a
+ * flat face is not, and snapping to it would measure the mesh rather than the
+ * part.
+ */
+interface SnapEdges {
+    readonly positions: ArrayLike<number>;
+    readonly matrixWorld: Matrix4;
+}
+/** What the ray hit, before snapping. */
+interface SnapHit {
+    readonly point: Vector3;
+    readonly normal: Vector3;
+}
+/**
+ * Where a hit on the part snaps to.
+ *
+ * Nearness is judged on screen, in pixels, because that is where the pointer
+ * is: a corner three pixels away is a corner however far the camera is. The
+ * search is bounded in world space first — a segment further from the hit than
+ * the widest reach could ever cover is skipped without being projected — and
+ * held to the surface the hit is on: an edge that is within reach of the point
+ * but well off its tangent plane is on the far side of a wall, and snapping to
+ * it would put a measurement on something the eye cannot see.
+ */
+declare function snapAt(hit: SnapHit, edges: SnapEdges | null, camera: ViewerCamera, viewport: ViewportSize): Snap;
+/** Where a world point lands on the canvas, in CSS pixels from the top left. */
+declare function screenPoint(camera: ViewerCamera, point: Vector3, viewport: ViewportSize, into?: Vector2): Vector2;
+type MeasureMode = 'distance' | 'angle';
+/** How many clicks each kind of measurement takes. */
+declare const POINTS_PER_MEASUREMENT: Record<MeasureMode, number>;
+interface DistanceMeasurement {
+    readonly id: number;
+    readonly kind: 'distance';
+    readonly points: readonly [Vec3, Vec3];
+}
+/** Three points: the two arms' ends, with the vertex between them. */
+interface AngleMeasurement {
+    readonly id: number;
+    readonly kind: 'angle';
+    readonly points: readonly [Vec3, Vec3, Vec3];
+}
+type Measurement = DistanceMeasurement | AngleMeasurement;
+/**
+ * A measurement from the points clicked so far, or `null` while there are not
+ * enough of them yet.
+ */
+declare function measurementFromPoints(kind: MeasureMode, points: readonly Vec3[], id: number): Measurement | null;
+/** An id no measurement in `held` has. */
+declare function nextMeasurementId(held: readonly Measurement[]): number;
+declare function distanceBetween(a: Vec3, b: Vec3): number;
+/** `b − a`, per axis. */
+declare function deltaBetween(a: Vec3, b: Vec3): Vec3;
+declare function midpoint(a: Vec3, b: Vec3): Vec3;
+/**
+ * The angle at `vertex` between the arms to `a` and `b`, in degrees, from 0 to
+ * 180. An arm with no length has no direction, and the angle is 0.
+ */
+declare function angleAt(vertex: Vec3, a: Vec3, b: Vec3): number;
+type Axis = 'x' | 'y' | 'z';
+/** One leg of a distance's X, Y, Z breakdown. */
+interface DeltaLeg {
+    readonly axis: Axis;
+    readonly from: Vec3;
+    readonly to: Vec3;
+    readonly length: number;
+}
+/** Where a point lands when it is held to one axis from `from`. */
+interface AxisLock {
+    readonly axis: Axis;
+    readonly point: Vec3;
+}
+/**
+ * `to`, held to the one axis it has moved furthest along from `from`.
+ *
+ * The ortho lock a CAD user reaches for with Shift: the next point is dropped
+ * onto the X, Y or Z line through the last one, so a distance meant to be "how
+ * long is this" is not "how long is this, and a little sideways". Which axis is
+ * whichever the pointer is furthest along, and a pointer that has not moved
+ * stays put on X.
+ */
+declare function lockToAxis(from: Vec3, to: Vec3): AxisLock;
+/**
+ * A distance broken into its X, Y and Z parts, as a path from `a` to `b` that
+ * runs along one axis at a time.
+ *
+ * Only the legs with length are returned, and none at all when the distance
+ * already runs along an axis: a single leg would lie on top of the line it
+ * explains and say nothing the line does not.
+ */
+declare function deltaLegs(a: Vec3, b: Vec3): readonly DeltaLeg[];
+/**
+ * Points along the arc an angle is drawn with, from the arm to `a` round to
+ * the arm to `b`, at `radius` from the vertex.
+ *
+ * Interpolated on the sphere rather than along the chord, so the arc is an
+ * arc. Two arms that point the same way, or opposite ways, have no plane to
+ * draw in, and get their two ends and nothing between.
+ */
+declare function angleArc(vertex: Vec3, a: Vec3, b: Vec3, radius: number, segments?: number): Vector3[];
+/** The radius an angle's arc is drawn at: a fraction of the shorter arm. */
+declare function angleArcRadius(vertex: Vec3, a: Vec3, b: Vec3): number;
+/** A length in millimetres, as the tool writes it when told nothing else. */
+declare function formatMillimetres(mm: number, digits?: number): string;
+declare function formatDegrees(degrees: number, digits?: number): string;
+/** What a measurement's label says. `format` writes a length; angles write themselves. */
+declare function measurementLabel(measurement: Measurement, format?: (mm: number) => string): string;
+/** Where a measurement's label sits: the middle of a distance, the vertex of an angle. */
+declare function measurementLabelAnchor(measurement: Measurement): Vec3;
+
+/**
+ * The class every label carries, for a stylesheet to find.
+ *
+ * The labels ship with no styling at all. Each one is a `<div>` with this
+ * class, `data-measure-label` naming what it is — `distance`, `angle`, `delta`
+ * for one leg of a distance's breakdown, or `live` for the readout that
+ * follows the pointer — `data-axis` on a leg, and `data-measurement-id` on
+ * anything belonging to a finished measurement. The README shows a stylesheet
+ * to start from.
+ */
+declare const MEASURE_LABEL_CLASS = "toolpath-measure-label";
+/** What a label is, for a stylesheet to tell them apart. */
+type MeasureLabelKind = 'distance' | 'angle' | 'delta' | 'live';
+interface MeasureToolProps {
+    /**
+     * What a click sequence measures. `distance` takes two points; `angle` takes
+     * three — one arm's end, the vertex, the other arm's end. Changing it drops
+     * any points already placed.
+     */
+    mode?: MeasureMode;
+    /**
+     * The measurements on screen. Pass it to own them; omit it and the tool keeps
+     * its own list, which `onChange` still reports.
+     */
+    measurements?: readonly Measurement[];
+    /** The list changed: a measurement finished, or Delete removed the last one. */
+    onChange?: (measurements: readonly Measurement[]) => void;
+    /**
+     * Whether a distance also shows its X, Y and Z parts, as dashed legs in the
+     * axis colours with their own labels. On by default; a distance that already
+     * runs along an axis shows none either way.
+     */
+    showDeltas?: boolean;
+    /**
+     * Writes a length. Millimetres to two places unless told otherwise — the part
+     * is in millimetres, and converting is the consumer's call.
+     */
+    format?: (mm: number) => string;
+    /**
+     * Added to every label's `className`, beside {@link MEASURE_LABEL_CLASS} —
+     * a Tailwind utility list, or a CSS module's class.
+     */
+    labelClassName?: string;
+    theme?: Partial<ViewerTheme>;
+}
+/**
+ * Measure the part from inside the viewport. Mount it beside `<PartMesh>`.
+ *
+ * The pointer snaps to what is under it — a corner first, then an edge's
+ * midpoint, then the edge, then the face — and a marker shows where the click
+ * will land. A distance is two clicks and an angle three; the line follows the
+ * pointer between them with a live readout. Finished measurements stay up,
+ * drawn over the part with a label each, until Delete removes the last one or
+ * the tool is unmounted. Escape drops the points of one in progress. Holding
+ * Shift holds the next point to the X, Y or Z line through the last one — the
+ * axis the pointer is furthest along — so a length along an edge is measured
+ * along the edge and not a little across it.
+ *
+ * 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,
+ * 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.
+ *
+ * Lines are drawn at a width in pixels, through drei's `Line`, because a
+ * WebGL line is one pixel wide whatever is asked of it and one pixel of blue
+ * over a white face is not a measurement anybody can see.
+ *
+ * Labels are DOM elements laid over the canvas, so they are text a test can
+ * read — and they are **unstyled**. This is a headless component: what a
+ * label looks like is the consumer's stylesheet's, through
+ * {@link MEASURE_LABEL_CLASS} and the data attributes on each one. The one
+ * thing set here is that the element each label is wrapped in takes no
+ * pointer events, because a label over the part that took the click meant
+ * for the face under it would be a bug rather than a look.
+ */
+declare const MeasureTool: ({ mode, measurements, onChange, showDeltas, format, labelClassName, theme, }: MeasureToolProps) => react.JSX.Element | null;
+
+/**
+ * The cut a viewer holds for itself, when nobody else is holding it.
+ *
+ * `<PartMesh section>` is the controlled path and is untouched by this. The
+ * store exists for the other one: `<SectionTool>` mounted beside the part with
+ * no wiring at all. The two are siblings and cannot see each other, so the
+ * viewer keeps one of these and each reads or writes it — the tool sets the
+ * cut, the part clips to it and moves it when the handle is dragged.
+ *
+ * It also carries whether a tool is **engaged** — mounted at all. While one
+ * is, the pointer over the part belongs to it: the part reports no hovers or
+ * picks, so clicking a face to cut through it does not also select it, the
+ * hover paint does not sit under the tool's own preview, and a cut part is
+ * read as a cut rather than picked at. Unmounting the tool hands the pointer
+ * back. `<MeasureTool>` engages it too — a click that puts a measurement point
+ * 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.
+ *
+ * A subscription rather than React state, so a drag re-renders the two
+ * subscribers and not everything under the canvas.
+ */
+interface SectionStore {
+    get(): SectionOptions | null;
+    set(next: SectionOptions | null): void;
+    /** Whether a tool is mounted, and the part should stay out of the way. */
+    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. */
+    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;
+    };
+    uResolution: {
+        value: Vector2;
+    };
+    uFill: {
+        value: Color;
+    };
+    uHatch: {
+        value: Color;
+    };
+    uOutline: {
+        value: Color;
+    };
+    uPitch: {
+        value: number;
+    };
+    uLine: {
+        value: number;
+    };
+    uThickness: {
+        value: number;
+    };
+};
+type CapMaterial = ShaderMaterial & {
+    uniforms: CapUniforms;
+};
+/**
+ * The render target the mask is drawn into. Sized later, to the drawing
+ * buffer, because that is what `gl_FragCoord` is measured in and a mask at
+ * any other size would put the outline beside the edge rather than on it.
+ */
+declare function createMaskTarget(): WebGLRenderTarget;
+/**
+ * The cap's own material, filled only where the main pass's stencil says the
+ * plane is inside material. Unthemed until {@link applyCapTheme} is called.
+ */
+declare function createCapMaterial(mask: Texture): CapMaterial;
+/** Re-themes a cap in place, and re-scales its hatch for the device pixel ratio. */
+declare function applyCapTheme(material: CapMaterial, theme: ViewerTheme, dpr: number): void;
+/**
+ * The two materials of the stencil pass: back faces count up, front faces
+ * count down, and what is left non-zero is where the plane is inside solid
+ * material. Nothing is written but the stencil.
+ */
+declare function createStencilMaterials(clip: Plane[]): [MeshBasicMaterial, MeshBasicMaterial];
+/** The quad the mask pass draws where the stencil is set — white on black. */
+declare function createMaskMaterial(): MeshBasicMaterial;
+
 interface ArrowPlacement {
     /** Where the arrow's tip sits: outside the box, on the direction's ray. */
     readonly tip: Vector3;
@@ -398,200 +1060,6 @@ type SurfaceOf = ReadonlyMap<number, number>;
  */
 declare function visualSurfaces(regions: readonly PartModelRegion[]): SurfaceOf;
 
-type Projection = 'orthographic' | 'perspective';
-type ViewerCamera = OrthographicCamera | PerspectiveCamera;
-interface ViewportSize {
-    readonly width: number;
-    readonly height: number;
-}
-/** Vertical field of view, in degrees, for the perspective camera. */
-declare const PERSPECTIVE_FOV = 30;
-/** Padding around the framed bounds, as a multiple of its radius. */
-declare const DEFAULT_FIT_MARGIN = 1.2;
-/** Marks scene furniture — grid, axes — that the camera should not frame. */
-declare const EXCLUDE_FROM_FRAME = "viewerExcludeFromFrame";
-/**
- * What the camera frames: a bounding *sphere*, not a box.
- *
- * A sphere makes framing rotation-invariant — the part stays fully visible from
- * every angle, and a resize never needs to know the current pose. Framing
- * per-axis box dimensions instead means recomputing the camera distance on
- * every resize, and still clipping on some orientations.
- */
-interface SceneBounds {
-    readonly center: Vector3;
-    readonly radius: number;
-}
-/**
- * Bounds for a scene with nothing in it. A viewer is mounted before it has a
- * part, and a camera with a zero-size frustum renders nothing at all.
- */
-declare function defaultBounds(): SceneBounds;
-/**
- * A container can be laid out at zero size, and a degenerate aspect ratio
- * produces a `NaN` projection matrix that never recovers. Fall back to square.
- */
-declare function aspectRatio(size: ViewportSize): number;
-/**
- * A world length that covers `pixels` on screen at `point`.
- *
- * Anything sized in world units is a thumbnail on a plate and a wall on an
- * insert; the whole reason a control is measured this way is that it is a
- * control rather than part of the model. The section handle and the orbit
- * target marker both size themselves with it, which is why it lives here with
- * the camera rather than beside either of them.
- *
- * The two projections answer differently on purpose. An orthographic frustum
- * covers the same world height wherever the point is, so distance does not
- * enter; a perspective one covers more the further away it looks, so it does.
- */
-declare function screenLength(camera: ViewerCamera, point: Vector3, viewport: ViewportSize, pixels: number): number;
-declare function boundsFromBox(box: Box3): SceneBounds;
-/**
- * The bounds of everything worth framing under `root`.
- *
- * Skips objects flagged with {@link EXCLUDE_FROM_FRAME} and their descendants:
- * a 100 mm grid around a 6 mm part would otherwise frame the grid, and the part
- * would be a speck.
- */
-declare function contentBounds(root: Object3D, into: Box3): SceneBounds;
-/**
- * The distance at which a sphere of `radius` fits inside a perspective frustum.
- * Uses the narrower of the two field-of-view angles, so a portrait viewport
- * frames on width and a landscape one on height.
- */
-declare function perspectiveFitDistance(fovDegrees: number, aspect: number, radius: number): number;
-/**
- * Half-height of an orthographic frustum that fits a sphere of `radius`. A
- * portrait viewport grows the height so the width still clears the sphere.
- */
-declare function orthographicHalfHeight(aspect: number, radius: number): number;
-declare function fitDistance(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number): number;
-declare function startPosition(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number): Vector3;
-/**
- * How far out the wheel may pull, as a fraction of the fitted framing: the part
- * may shrink to a quarter of the view and no further. Past that it is a speck
- * with no cue that Fit is the way back.
- */
-declare const MIN_FRAME_RATIO = 0.25;
-/**
- * How far in the wheel may push, as a multiple of the fitted framing.
- *
- * Both ratios are the legacy viewer's `minZoom` 0.25 / `maxZoom` 10
- * (`three-object.tsx:289-311`), which transfer almost exactly: legacy's
- * orthographic frustum was `largestDimension * 2` tall and this one is the
- * fitted bounding sphere, which for a cube agree within a few percent. So the
- * numbers are the ones that shipped, and here they carry a meaning they did not
- * have there — `zoom` 1 *is* the fitted framing, so 0.25 and 10 say exactly
- * what a reader thinks they say.
- */
-declare const MAX_FRAME_RATIO = 10;
-/** How far the camera may travel, in the two units the two cameras travel in. */
-interface CameraLimits {
-    readonly minZoom: number;
-    readonly maxZoom: number;
-    readonly minDistance: number;
-    readonly maxDistance: number;
-}
-/**
- * The clamps for a scene, so the wheel cannot leave the viewport empty.
- *
- * Without them it can, from either end, and both cameras can do it: an
- * orthographic `camera.zoom` reaches 1e30 in sixty notches, and a perspective
- * camera dives inside the part in eight, because `minDistance` defaults to
- * `Number.EPSILON`. Fit recovers from both — but Fit is a double middle click
- * and nothing on screen says so, which makes it a way out rather than an
- * answer.
- *
- * One rule for both cameras: the wheel may take the part from a quarter of its
- * fitted size to ten times it. Under an orthographic camera that scale *is* the
- * frustum, so the ratios land on `zoom`; under a perspective camera apparent
- * size is the inverse of distance, so they land on `distance` — which is why
- * they swap sides between the two.
- *
- * Pure, and derived from `bounds`, so it re-derives wherever the scene is
- * re-measured rather than being sampled once at mount.
- *
- * `framed` is what the view has been framed *on*, when that is not the whole
- * scene — `frameBox` on a single feature. The band is then taken about that
- * framing as well as about the scene's, because a band centred on the part is
- * the wrong band for a view of a 3 mm hole in it: ten times the *part's* fitted
- * size can be less than once the hole's, so the framing the caller asked for sat
- * outside the clamps meant to keep it in view. Under an orthographic camera
- * `zoom` is measured against a frustum still sized to the scene, so the framing
- * enters as the zoom ratio it takes to reach; under a perspective one it enters
- * as its own fitted distance.
- *
- * Widened to the union of the two rather than moved onto `framed`, and that is
- * the whole of why this takes both. A band that simply followed the last framing
- * would take the part away: framing a hole would put "far enough out to see what
- * the hole is in" past `maxDistance`, so the wheel could no longer get back to
- * the part it had just been looking at, and Fit — a gesture with nothing on
- * screen to say so — would be the only way. Reaching further in must not cost
- * the reach back out, so each end takes whichever bound is looser. With no
- * `framed`, or one the size of the scene, both ends collapse to the scene's own
- * and this is the function it was before.
- */
-declare function cameraLimits(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number, framed?: SceneBounds): CameraLimits;
-/**
- * The box the orbit target is confined to — the fitted framing, several frames
- * over. Written into `into` so the per-frame path allocates nothing.
- */
-declare function targetBoundary(bounds: SceneBounds, into: Box3, margin?: number): Box3;
-/**
- * Points an existing camera's frustum at `bounds` for the current viewport.
- * Pose is untouched — that belongs to the controls.
- */
-declare function applyProjection(camera: ViewerCamera, size: ViewportSize, bounds: SceneBounds, margin?: number): void;
-/**
- * The world-up convention. The part data is Z-up (millimetres, no conversion) —
- * not the glTF-conventional Y-up — so the camera has to say so explicitly.
- */
-declare const CAD_CAMERA_UP: Vector3;
-/**
- * `up` re-squared against a view direction: the part of it perpendicular to
- * `view`, written into `into`.
- *
- * This is what keeps the horizon level while a free orbit carries the camera
- * over a pole — the up vector follows the view instead of flipping. The
- * controls run it on every update, which is what makes the next sentence the
- * important one.
- *
- * **It is path-dependent.** It is a projection, so it discards the component it
- * removes and cannot put it back: running it at one view and then another does
- * not give what running it once at the second view would. So a camera carries
- * the roll of every pose it has passed through, and any pose that is meant to
- * be canonical — the opening frame, a reset, a named view — has to say what
- * `up` is rather than inherit it. `viewer.tsx` does, at `resetContent`. The
- * test beside this pins both halves.
- *
- * `into` may be `view` or `up` — three.js `crossVectors` reads all six
- * components before it writes any, and the intermediate is this module's own
- * scratch, so writing the result over an input is safe. Said here because this
- * is exported and an out-parameter invites the question; the test beside this
- * pins it, so a three.js change cannot quietly turn the answer around.
- *
- * `view` and `up` being parallel is the one degenerate case: their cross is
- * zero, `normalize` leaves it zero, and the result is a zero vector rather than
- * an error. A caller with a free-orbiting camera reaches that at the pole,
- * which is what `freeOrbit` and a squared `up` at every canonical pose exist to
- * keep it away from.
- */
-declare function adaptedUp(view: Vector3, up: Vector3, into: Vector3): Vector3;
-/** Named viewing directions, as unit vectors from the part toward the camera. */
-declare const cadViewDirections: {
-    readonly front: Vector3;
-    readonly back: Vector3;
-    readonly left: Vector3;
-    readonly right: Vector3;
-    readonly top: Vector3;
-    readonly bottom: Vector3;
-    readonly isometric: Vector3;
-};
-type ViewerView = keyof typeof cadViewDirections;
-/** The current orbit direction, so Fit can retain the direction being looked from. */
-declare function currentViewDirection(camera: ViewerCamera, target: Vector3, into: Vector3): Vector3;
-
 /**
  * Mouse and trackpad presets.
  *
@@ -717,12 +1185,26 @@ interface ViewerControls {
      * see a wall and then asks to zoom to it wants it closer, not re-oriented.
      */
     frameBox(box: Box3): void;
+    /**
+     * Sets or clears the cut the viewer holds for itself — the one `<SectionTool>`
+     * places and `<PartMesh>` follows when it is given no `section` of its own.
+     *
+     * `null` clears it. A `<PartMesh section>` is not affected: that cut is the
+     * consumer's, and this one is the viewer's.
+     */
+    setSection(options: SectionOptions | null): void;
 }
 interface ViewerHandle extends ViewerControls {
 }
 type VectorLike = Pick<Vector3, 'x' | 'y' | 'z'>;
 
 declare const useViewerControls: () => ViewerControls;
+/**
+ * The cut this viewer holds for itself. See `render/section-store.ts` for why
+ * it is a store: `<SectionTool>` writes it and `<PartMesh>` reads it, and the
+ * two are siblings.
+ */
+declare const useSectionStore: () => SectionStore;
 /** Re-aims the orbit, or `null` when this viewer has the gesture turned off. */
 type Retarget = ((point: VectorLike) => void) | null;
 /**
@@ -1093,4 +1575,4 @@ declare const ORBIT_TARGET_FADE_MS = 1000;
  */
 declare function orbitTargetOpacity(sinceHold: number, fade?: number): number;
 
-export { type ArrowPlacement, Axes, type AxesProps, CAD_CAMERA_UP, CHAMFER, CadCameraControls, type CadCameraControlsProps, type CameraLimits, type ControlScheme, type CubeZone, DEFAULT_FIT_MARGIN, DOUBLE_TAP_MS, DirectionArrows, type DirectionArrowsProps, type DirectionGroup, type DoubleTapPoint, type DoubleTapTracker, EXCLUDE_FROM_FRAME, ExtendedCameraControls, type ExtendedCameraControlsOptions, FEATURE_TYPE_RANKS, FeatureTag, FeatureType, Grid, type GridProps, type GridSpec, MAX_FRAME_RATIO, MIN_FRAME_RATIO, 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, PartModel, PartModelFeature, PartModelRegion, PartReportFormatError, type Projection, type RankingContext, RegionIndex, type Retarget, type RetargetPose, type SceneBounds, 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, applyProjection, arrowPlacement, aspectRatio, bestOwner, boundsFromBox, buildRegionIndex, cadViewDirections, cameraLimits, contentBounds, cubeOutlineGeometry, cubeZones, currentViewDirection, cycleOwner, defaultBounds, directionIndexOf, directionLabel, featureTypeRank, fitDistance, gridGeometry, gridSpec, groupByDirection, labelGeometry, labelTexture, movedFar, orbitTargetOpacity, orthographicHalfHeight, panelGeometry, perspectiveFitDistance, rankOwners, regionAdjacency, regionEdgesGeometry, regionNormals, retargetPose, sameDirection, screenLength, squaredUp, startPosition, targetBoundary, trackDoubleTaps, trackTaps, useContentBox, useRetarget, 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 };