@toolpath/viewer 0.2.0

package/dist/chunk-7NQBV7EQ.js

@@ -0,0 +1,2537 @@
+// src/engine/engine-part.tsx
+import { useEffect as useEffect5, useMemo as useMemo6 } from "react";
+
+// src/part-mesh.tsx
+import { useThree as useThree6 } from "@react-three/fiber";
+import { useCallback as useCallback3, useEffect as useEffect4, useLayoutEffect, useMemo as useMemo5, useRef as useRef5 } from "react";
+import { Vector3 as Vector38 } from "three";
+
+// src/model/directions.ts
+var EPSILON = 1e-6;
+function sameDirection(a, b) {
+  return Math.abs(a.x - b.x) < EPSILON && Math.abs(a.y - b.y) < EPSILON && Math.abs(a.z - b.z) < EPSILON;
+}
+function directionIndexOf(model, direction) {
+  return model.candidateDirections.findIndex((candidate) => sameDirection(candidate, direction));
+}
+function groupByDirection(model) {
+  const groups = model.candidateDirections.map((direction, index) => ({
+    index,
+    direction,
+    features: []
+  }));
+  const unmatched = [];
+  for (const feature of model.features) {
+    const index = directionIndexOf(model, feature.machiningDirection);
+    const group = index === -1 ? void 0 : groups[index];
+    if (group) group.features.push(feature);
+    else unmatched.push(feature);
+  }
+  if (unmatched.length === 0) return groups;
+  return [...groups, { index: -1, direction: { x: 0, y: 0, z: 0 }, features: unmatched }];
+}
+function directionLabel(direction) {
+  const axes = [
+    ["X", direction.x],
+    ["Y", direction.y],
+    ["Z", direction.z]
+  ];
+  const nonZero = axes.filter(([, value]) => Math.abs(value) > EPSILON);
+  const [axis] = nonZero;
+  if (nonZero.length === 1 && axis && Math.abs(Math.abs(axis[1]) - 1) < EPSILON) {
+    return `${axis[1] > 0 ? "+" : "\u2212"}${axis[0]}`;
+  }
+  return axes.map(([, value]) => trim(value)).join(", ");
+}
+function trim(value) {
+  return Number.parseFloat(value.toFixed(3)).toString();
+}
+
+// src/model/surfaces.ts
+var CONTINUES_WITHIN = Math.cos(1 * Math.PI / 180);
+var MERGEABLE = "Plane";
+var worked = /* @__PURE__ */ new WeakMap();
+function visualSurfaces(geometry, regions) {
+  const already = worked.get(geometry);
+  if (already && already.regions === regions) return already.of;
+  const found = computeSurfaces(geometry, regions);
+  worked.set(geometry, { regions, of: found });
+  return found;
+}
+function computeSurfaces(geometry, regions) {
+  const position = geometry.getAttribute("position");
+  const surfaces = /* @__PURE__ */ new Map();
+  for (const region of regions) surfaces.set(region.idx, region.idx);
+  if (!position || geometry.index) return surfaces;
+  const triangleCount = Math.floor(position.count / 3);
+  const regionOf = new Int32Array(triangleCount).fill(-1);
+  const kindOf = /* @__PURE__ */ new Map();
+  for (const region of regions) {
+    kindOf.set(region.idx, region.shapeKind);
+    const end = Math.min(region.triangles.end, triangleCount);
+    for (let triangle = region.triangles.start; triangle < end; triangle += 1) {
+      regionOf[triangle] = region.idx;
+    }
+  }
+  const normals = facetNormals(geometry, triangleCount);
+  const parent = new Map(surfaces);
+  const find = (idx) => {
+    let root = idx;
+    while (parent.get(root) !== root) root = parent.get(root) ?? root;
+    let walk = idx;
+    while (parent.get(walk) !== root) {
+      const next = parent.get(walk) ?? root;
+      parent.set(walk, root);
+      walk = next;
+    }
+    return root;
+  };
+  const union = (a, b) => {
+    const [rootA, rootB] = [find(a), find(b)];
+    if (rootA !== rootB) parent.set(rootB, rootA);
+  };
+  const seen = /* @__PURE__ */ new Map();
+  for (let triangle = 0; triangle < triangleCount; triangle += 1) {
+    for (let corner = 0; corner < 3; corner += 1) {
+      const a = triangle * 3 + corner;
+      const b = triangle * 3 + (corner + 1) % 3;
+      const id = edgeKey(position, a, b);
+      const met = seen.get(id);
+      if (met === void 0) {
+        seen.set(id, triangle);
+        continue;
+      }
+      const here = regionOf[triangle] ?? -1;
+      const there = regionOf[met] ?? -1;
+      if (here === -1 || there === -1 || here === there) continue;
+      if (kindOf.get(here) !== kindOf.get(there)) continue;
+      const facing = normals[triangle * 3] * normals[met * 3] + normals[triangle * 3 + 1] * normals[met * 3 + 1] + normals[triangle * 3 + 2] * normals[met * 3 + 2];
+      if (kindOf.get(here) !== MERGEABLE) continue;
+      if (facing >= CONTINUES_WITHIN) union(here, there);
+    }
+  }
+  for (const region of regions) surfaces.set(region.idx, find(region.idx));
+  return surfaces;
+}
+function facetNormals(geometry, triangleCount) {
+  const position = geometry.getAttribute("position");
+  const normals = new Float32Array(triangleCount * 3);
+  for (let triangle = 0; triangle < triangleCount; triangle += 1) {
+    const at = triangle * 3;
+    const ax = position.getX(at);
+    const ay = position.getY(at);
+    const az = position.getZ(at);
+    const bx = position.getX(at + 1) - ax;
+    const by = position.getY(at + 1) - ay;
+    const bz = position.getZ(at + 1) - az;
+    const cx = position.getX(at + 2) - ax;
+    const cy = position.getY(at + 2) - ay;
+    const cz = position.getZ(at + 2) - az;
+    const nx = by * cz - bz * cy;
+    const ny = bz * cx - bx * cz;
+    const nz = bx * cy - by * cx;
+    const length = Math.hypot(nx, ny, nz) || 1;
+    normals[at] = nx / length;
+    normals[at + 1] = ny / length;
+    normals[at + 2] = nz / length;
+  }
+  return normals;
+}
+function edgeKey(position, a, b) {
+  const ax = position.getX(a);
+  const ay = position.getY(a);
+  const az = position.getZ(a);
+  const bx = position.getX(b);
+  const by = position.getY(b);
+  const bz = position.getZ(b);
+  const first = ax < bx || ax === bx && (ay < by || ay === by && az <= bz);
+  return first ? `${ax},${ay},${az}|${bx},${by},${bz}` : `${bx},${by},${bz}|${ax},${ay},${az}`;
+}
+
+// src/render/theme.ts
+var HIGHLIGHT_COLORS = {
+  default: 16753434,
+  toolIssue: 9647082,
+  geometryIssue: 16711680
+};
+var DIRECTION_COLORS = [
+  3900150,
+  // blue
+  1357990,
+  // teal
+  14239471,
+  // fuchsia
+  440020,
+  // cyan
+  /*
+   * Olive, where a purple used to be.
+   *
+   * The purple sat one step from the violet a proposed feature is painted in,
+   * so an offer laid over work already assigned to this direction was a clash
+   * between "suggested" and "decided" — the two states the part is read for.
+   * Olive is the only hue with room: the warm ramp belongs to the difficulty
+   * bands, red to sharp corners, orange to faces being picked, and green to
+   * whatever is being looked at.
+   */
+  6660877,
+  // olive
+  15485081,
+  // pink
+  6583435,
+  // slate
+  1096065,
+  // emerald
+  6514417
+  // indigo
+];
+var DEFAULT_THEME = {
+  background: null,
+  hemisphereSky: 16777215,
+  hemisphereGround: 0,
+  hemisphereIntensity: 2.5,
+  ambient: 5067112,
+  ambientIntensity: 2,
+  part: 16777215,
+  partEmissive: 3948625,
+  /*
+   * A paler form of the selection orange it leads to.
+   *
+   * It was a teal, which sat between two of the nine direction colors — on a
+   * part painted by direction, "what the pointer is on" and "cut from way up
+   * number two" were the same answer. The warm end of the wheel belongs to this
+   * moment rather than to the plan: what is under the pointer, and what has
+   * been picked. Nothing in the direction cycle is warm.
+   */
+  hover: 16756838,
+  highlight: HIGHLIGHT_COLORS.default,
+  picked: 16347926,
+  edge: 0,
+  edgeOpacity: 0.5,
+  sectionCap: 13093848,
+  sectionOutline: 7057587,
+  sectionHandle: 15922167,
+  sectionHandleOutline: 3948625,
+  cube: 14080482,
+  cubeEdge: 7435917,
+  cubeLabel: 3948625
+};
+function resolveTheme(overrides) {
+  return { ...DEFAULT_THEME, ...overrides };
+}
+function themesEqual(a, b) {
+  return a.background === b.background && a.hemisphereSky === b.hemisphereSky && a.hemisphereGround === b.hemisphereGround && a.hemisphereIntensity === b.hemisphereIntensity && a.ambient === b.ambient && a.ambientIntensity === b.ambientIntensity && a.part === b.part && a.partEmissive === b.partEmissive && a.hover === b.hover && a.highlight === b.highlight && a.picked === b.picked && a.edge === b.edge && a.edgeOpacity === b.edgeOpacity && a.sectionCap === b.sectionCap && a.sectionOutline === b.sectionOutline && a.sectionHandle === b.sectionHandle && a.sectionHandleOutline === b.sectionHandleOutline && a.cube === b.cube && a.cubeEdge === b.cubeEdge && a.cubeLabel === b.cubeLabel;
+}
+function directionColor(index) {
+  const wrapped = index % DIRECTION_COLORS.length;
+  return DIRECTION_COLORS[wrapped] ?? HIGHLIGHT_COLORS.default;
+}
+
+// src/render/paint.ts
+var HIGHLIGHT_WEIGHT = 0.7;
+var CANDIDATE_WEIGHT = 0.4;
+var HOVER_WEIGHT = 0.85;
+function selectedRegions(part, layers) {
+  const regions = /* @__PURE__ */ new Set();
+  for (const tag of layers.selection ?? []) {
+    for (const region of part.model.regionIndex.regionsForFeature(tag)) regions.add(region);
+  }
+  return regions;
+}
+function applyHighlightLayers(part, layers, theme) {
+  part.clearPaint();
+  for (const highlight of layers.highlights ?? []) {
+    part.paintFeature(highlight.tag, highlight.color, highlight.weight ?? HIGHLIGHT_WEIGHT);
+  }
+  for (const highlight of layers.regionHighlights ?? []) {
+    part.paintRegion(highlight.region, highlight.color, highlight.weight ?? HIGHLIGHT_WEIGHT);
+  }
+  for (const tag of layers.candidates ?? []) {
+    const feature = part.model.features.find((candidate) => candidate.tag === tag);
+    const index = feature ? directionIndexOf(part.model, feature.machiningDirection) : -1;
+    part.paintFeature(tag, index === -1 ? theme.hover : directionColor(index), CANDIDATE_WEIGHT);
+  }
+  for (const tag of layers.selection ?? []) {
+    part.paintFeature(tag, theme.highlight, 1);
+  }
+  for (const region of layers.pickedRegions ?? []) {
+    part.paintRegion(region, theme.picked, 1);
+  }
+  for (const tag of layers.hoveredFeatures ?? []) {
+    part.paintFeature(tag, theme.hover, HOVER_WEIGHT);
+  }
+  if (layers.hoverRegion != null && !selectedRegions(part, layers).has(layers.hoverRegion)) {
+    part.paintRegion(layers.hoverRegion, theme.hover, HOVER_WEIGHT);
+  }
+  spreadAcrossSurfaces(part);
+}
+function spreadAcrossSurfaces(part) {
+  const surfaces = visualSurfaces(part.mesh.geometry, part.model.regions);
+  const claims = /* @__PURE__ */ new Map();
+  for (const region of part.model.regions) {
+    const paint = part.regionPaint(region.idx);
+    if (!paint || paint.weight === 0) continue;
+    const surface = surfaces.get(region.idx) ?? region.idx;
+    const claim = claims.get(surface);
+    if (!claim) {
+      claims.set(surface, { color: paint.color, weight: paint.weight });
+      continue;
+    }
+    if (claim === "contested") continue;
+    if (claim.color !== paint.color || claim.weight !== paint.weight) {
+      claims.set(surface, "contested");
+    }
+  }
+  for (const region of part.model.regions) {
+    const paint = part.regionPaint(region.idx);
+    if (paint && paint.weight > 0) continue;
+    const claim = claims.get(surfaces.get(region.idx) ?? region.idx);
+    if (claim && claim !== "contested") part.paintRegion(region.idx, claim.color, claim.weight);
+  }
+}
+
+// src/render/section.ts
+import { OrthographicCamera, Plane, Vector3 } from "three";
+var SECTION_RENDER_ORDER = {
+  stencil: 1,
+  cap: 2,
+  handle: 6
+};
+var START_DEPTH = 5e-3;
+var HANDLE_PIXELS = 78;
+var EPSILON2 = 1e-9;
+var ARROW_AXIS = new Vector3(0, 1, 0);
+var PICKED_SURFACE_LABEL = "Part surface";
+function unit(v) {
+  const vector = new Vector3(v.x, v.y, v.z);
+  return vector.lengthSq() === 0 ? vector.set(0, 0, 1) : vector.normalize();
+}
+function clamp01(value) {
+  return Math.min(1, Math.max(0, value));
+}
+function sectionBounds(box, normal) {
+  const axis = unit(normal);
+  const corner = new Vector3();
+  let low = Number.POSITIVE_INFINITY;
+  let high = Number.NEGATIVE_INFINITY;
+  for (let i = 0; i < 8; i += 1) {
+    corner.set(
+      i & 1 ? box.max.x : box.min.x,
+      i & 2 ? box.max.y : box.min.y,
+      i & 4 ? box.max.z : box.min.z
+    );
+    const distance = corner.dot(axis);
+    low = Math.min(low, distance);
+    high = Math.max(high, distance);
+  }
+  const margin = Math.max((high - low) * 5e-3, 1e-6);
+  return { min: -(high + margin), max: -(low - margin) };
+}
+function sectionConstant(bounds, t) {
+  return bounds.max + clamp01(t) * (bounds.min - bounds.max);
+}
+function sectionOffset(bounds, constant) {
+  const span = bounds.min - bounds.max;
+  return span === 0 ? 0 : clamp01((constant - bounds.max) / span);
+}
+function sectionDepth(normal, anchor, constant) {
+  return -unit(normal).dot(new Vector3(anchor.x, anchor.y, anchor.z)) - constant;
+}
+function sectionDepthConstant(normal, anchor, depth) {
+  return sectionDepth(normal, anchor, depth);
+}
+function sectionDepthRange(bounds, normal, anchor) {
+  return {
+    min: sectionDepth(normal, anchor, bounds.max),
+    max: sectionDepth(normal, anchor, bounds.min)
+  };
+}
+function sectionFromPick(surface, label = PICKED_SURFACE_LABEL) {
+  return {
+    normal: { x: -surface.normal.x, y: -surface.normal.y, z: -surface.normal.z },
+    point: { x: surface.point.x, y: surface.point.y, z: surface.point.z },
+    label
+  };
+}
+function pickedStartDepth(box) {
+  return box.getSize(new Vector3()).length() * START_DEPTH;
+}
+function sectionPlane(box, normal, offset, into = new Plane()) {
+  const axis = unit(normal);
+  return into.set(axis, sectionConstant(sectionBounds(box, normal), offset));
+}
+function screenLength(camera, point, viewport, pixels) {
+  const height = viewport.height > 0 ? viewport.height : 1;
+  const zoom = camera.zoom || 1;
+  const visible = camera instanceof OrthographicCamera ? (camera.top - camera.bottom) / zoom : 2 * Math.tan(camera.fov / 2 * Math.PI / 180) * Math.max(camera.position.distanceTo(point), EPSILON2) / zoom;
+  return visible / height * pixels;
+}
+function dragPlane(axis, view, point, into = new Plane()) {
+  const along = axis.lengthSq() === 0 ? ARROW_AXIS.clone() : axis.clone().normalize();
+  const side = new Vector3().crossVectors(view, along);
+  if (side.lengthSq() < EPSILON2) side.copy(perpendicular(along));
+  return into.setFromNormalAndCoplanarPoint(side.cross(along).normalize(), point);
+}
+function perpendicular(axis) {
+  const candidate = Math.abs(axis.x) < 0.9 ? new Vector3(1, 0, 0) : new Vector3(0, 1, 0);
+  return candidate.cross(axis).normalize();
+}
+
+// src/tap.tsx
+import { useThree } from "@react-three/fiber";
+import { useEffect, useMemo, useRef } from "react";
+
+// src/render/tap.ts
+var TAP_SLOP = 4;
+function movedFar(from, to, slop = TAP_SLOP) {
+  return Math.hypot(to.clientX - from.clientX, to.clientY - from.clientY) > slop;
+}
+function trackTaps(element) {
+  let start = null;
+  const down = (event) => {
+    start = { clientX: event.clientX, clientY: event.clientY };
+  };
+  element.addEventListener("pointerdown", down, { capture: true });
+  return {
+    // No recorded press means the gesture began somewhere else — over a panel,
+    // or before this element existed. Not a click on this element.
+    isTap: (event) => start !== null && !movedFar(start, event),
+    dispose: () => element.removeEventListener("pointerdown", down, { capture: true })
+  };
+}
+
+// src/tap.tsx
+function useTapGuard() {
+  const domElement = useThree((state) => state.gl.domElement);
+  const tracker = useRef(null);
+  useEffect(() => {
+    const tracked = trackTaps(domElement);
+    tracker.current = tracked;
+    return () => {
+      tracked.dispose();
+      if (tracker.current === tracked) tracker.current = null;
+    };
+  }, [domElement]);
+  return useMemo(() => (event) => tracker.current?.isTap(event) ?? true, []);
+}
+
+// src/render/part.ts
+import {
+  Box3,
+  Color,
+  DataTexture,
+  Float32BufferAttribute as Float32BufferAttribute2,
+  Group,
+  LineBasicMaterial,
+  LineSegments,
+  Mesh,
+  MeshLambertMaterial,
+  RGBAFormat,
+  UnsignedByteType,
+  Vector3 as Vector32
+} from "three";
+
+// src/render/edges.ts
+import { BufferGeometry as Buffer, Float32BufferAttribute } from "three";
+function regionEdgesGeometry(geometry, model) {
+  const position = geometry.getAttribute("position");
+  const edges = new Buffer();
+  edges.setAttribute("position", new Float32BufferAttribute([], 3));
+  if (!position || geometry.index) return edges;
+  const triangleCount = Math.floor(position.count / 3);
+  const surfaces = visualSurfaces(geometry, model.regions);
+  const regionOf = new Int32Array(triangleCount).fill(-1);
+  for (const region of model.regions) {
+    const end = Math.min(region.triangles.end, triangleCount);
+    for (let triangle = region.triangles.start; triangle < end; triangle += 1) {
+      regionOf[triangle] = surfaces.get(region.idx) ?? region.idx;
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  const key = (a, b) => {
+    const ax = position.getX(a);
+    const ay = position.getY(a);
+    const az = position.getZ(a);
+    const bx = position.getX(b);
+    const by = position.getY(b);
+    const bz = position.getZ(b);
+    const first = ax < bx || ax === bx && (ay < by || ay === by && az <= bz);
+    return first ? `${ax},${ay},${az}|${bx},${by},${bz}` : `${bx},${by},${bz}|${ax},${ay},${az}`;
+  };
+  for (let triangle = 0; triangle < triangleCount; triangle += 1) {
+    const region = regionOf[triangle] ?? -1;
+    const corners = [triangle * 3, triangle * 3 + 1, triangle * 3 + 2];
+    for (let i = 0; i < 3; i += 1) {
+      const a = corners[i];
+      const b = corners[(i + 1) % 3];
+      const id = key(a, b);
+      const found = seen.get(id);
+      if (!found) {
+        seen.set(id, { region, a, b, shared: false });
+        continue;
+      }
+      found.shared = found.region === region;
+    }
+  }
+  const points = [];
+  for (const edge of seen.values()) {
+    if (edge.shared) continue;
+    points.push(
+      position.getX(edge.a),
+      position.getY(edge.a),
+      position.getZ(edge.a),
+      position.getX(edge.b),
+      position.getY(edge.b),
+      position.getZ(edge.b)
+    );
+  }
+  edges.setAttribute("position", new Float32BufferAttribute(points, 3));
+  return edges;
+}
+
+// src/render/part.ts
+var REGION_ATTRIBUTE = "aRegion";
+var EMISSIVE_MIX = 0.4;
+function buildRegionTexels(model) {
+  return new Map(model.regions.map((region, column) => [region.idx, column]));
+}
+function buildRegionAttribute(model, texels, vertexCount) {
+  const values = new Float32Array(vertexCount).fill(model.regions.length);
+  for (const region of model.regions) {
+    const column = texels.get(region.idx);
+    if (column === void 0) continue;
+    values.fill(
+      column,
+      Math.min(region.triangles.start * 3, vertexCount),
+      Math.min(region.triangles.end * 3, vertexCount)
+    );
+  }
+  return values;
+}
+function createPart(model, geometry, theme) {
+  const position = geometry.getAttribute("position");
+  const texels = buildRegionTexels(model);
+  geometry.setAttribute(
+    REGION_ATTRIBUTE,
+    new Float32BufferAttribute2(buildRegionAttribute(model, texels, position.count), 1)
+  );
+  const width = model.regions.length + 1;
+  const state = new Uint8Array(width * 4);
+  const stateTexture = new DataTexture(state, width, 1, RGBAFormat, UnsignedByteType);
+  stateTexture.needsUpdate = true;
+  const material = new MeshLambertMaterial({
+    color: theme.part,
+    emissive: theme.partEmissive,
+    // Pushes the surface back so the edge lines below sit on top of it rather
+    // than z-fighting with it.
+    polygonOffset: true,
+    polygonOffsetFactor: 1,
+    polygonOffsetUnits: 1
+  });
+  material.onBeforeCompile = (shader) => {
+    shader.uniforms["uRegionState"] = { value: stateTexture };
+    shader.vertexShader = shader.vertexShader.replace(
+      "#include <common>",
+      `#include <common>
+        attribute float ${REGION_ATTRIBUTE};
+        varying float vRegion;`
+    ).replace(
+      "#include <begin_vertex>",
+      `#include <begin_vertex>
+        vRegion = ${REGION_ATTRIBUTE};`
+    );
+    shader.fragmentShader = shader.fragmentShader.replace(
+      "#include <common>",
+      `#include <common>
+        uniform sampler2D uRegionState;
+        varying float vRegion;
+        vec4 regionState;`
+    ).replace(
+      "#include <color_fragment>",
+      `#include <color_fragment>
+        regionState = texelFetch(uRegionState, ivec2(int(vRegion + 0.5), 0), 0);
+        diffuseColor.rgb = mix(diffuseColor.rgb, regionState.rgb, regionState.a);`
+    ).replace(
+      "#include <emissivemap_fragment>",
+      `#include <emissivemap_fragment>
+        totalEmissiveRadiance = mix(
+          totalEmissiveRadiance,
+          regionState.rgb * ${EMISSIVE_MIX.toFixed(2)},
+          regionState.a
+        );`
+    );
+  };
+  const mesh = new Mesh(geometry, material);
+  mesh.renderOrder = 3;
+  const edgeGeometry = regionEdgesGeometry(geometry, model);
+  const edgeMaterial = new LineBasicMaterial({
+    color: theme.edge,
+    opacity: theme.edgeOpacity,
+    transparent: true
+  });
+  const edges = new LineSegments(edgeGeometry, edgeMaterial);
+  edges.renderOrder = 4;
+  edges.raycast = () => {
+  };
+  const object = new Group();
+  object.add(mesh, edges);
+  const scratchColor = new Color();
+  const scratchVector = new Vector32();
+  const paintRegion = (region, color, weight) => {
+    const column = texels.get(region);
+    if (column === void 0) return;
+    scratchColor.setHex(color);
+    const offset = column * 4;
+    state[offset] = Math.round(scratchColor.r * 255);
+    state[offset + 1] = Math.round(scratchColor.g * 255);
+    state[offset + 2] = Math.round(scratchColor.b * 255);
+    state[offset + 3] = Math.round(Math.min(Math.max(weight, 0), 1) * 255);
+    stateTexture.needsUpdate = true;
+  };
+  return {
+    object,
+    mesh,
+    edges,
+    model,
+    paintRegion,
+    regionPaint(region) {
+      const column = texels.get(region);
+      if (column === void 0) return null;
+      const offset = column * 4;
+      scratchColor.setRGB(
+        (state[offset] ?? 0) / 255,
+        (state[offset + 1] ?? 0) / 255,
+        (state[offset + 2] ?? 0) / 255
+      );
+      return { color: scratchColor.getHex(), weight: (state[offset + 3] ?? 0) / 255 };
+    },
+    paintFeature(tag, color, weight) {
+      for (const region of model.regionIndex.regionsForFeature(tag)) {
+        paintRegion(region, color, weight);
+      }
+    },
+    clearPaint() {
+      state.fill(0);
+      stateTexture.needsUpdate = true;
+    },
+    boxForFeature(tag) {
+      const regions = model.regionIndex.regionsForFeature(tag);
+      if (regions.length === 0) return null;
+      const box = new Box3();
+      for (const region of regions) {
+        const range = model.regionIndex.rangeForRegion(region);
+        if (!range) continue;
+        for (let vertex = range.start * 3; vertex < range.end * 3 && vertex < position.count; vertex += 1) {
+          box.expandByPoint(scratchVector.fromBufferAttribute(position, vertex));
+        }
+      }
+      return box.isEmpty() ? null : box;
+    },
+    setClippingPlanes(planes) {
+      const value = planes === null ? null : [...planes];
+      material.clippingPlanes = value;
+      edgeMaterial.clippingPlanes = value;
+    },
+    setTheme(next) {
+      material.color.setHex(next.part);
+      material.emissive.setHex(next.partEmissive);
+      edgeMaterial.color.setHex(next.edge);
+      edgeMaterial.opacity = next.edgeOpacity;
+    },
+    dispose() {
+      object.clear();
+      geometry.deleteAttribute(REGION_ATTRIBUTE);
+      material.dispose();
+      edgeGeometry.dispose();
+      edgeMaterial.dispose();
+      stateTexture.dispose();
+    }
+  };
+}
+
+// src/render/selection.ts
+var FEATURE_TYPE_RANKS = [
+  ["blind_hole", "through_hole", "filleted_blind_hole"],
+  ["pocket", "open_pocket", "boss", "filleted_boss", "undercut_tslot", "undercut_dovetail", "sink"],
+  ["chamfer", "inner_fillet", "outer_fillet", "contour_surface", "slanted_face"],
+  // Unrecognized types sit here, ahead of the bulk surfaces: `featureType` is
+  // an open set, and a type a future kernel adds is far likelier to be a
+  // specific machined feature than a new kind of wall.
+  [],
+  ["wall", "face"],
+  ["profile"]
+];
+var RANK_BY_TYPE = new Map(
+  FEATURE_TYPE_RANKS.flatMap((types, rank) => types.map((type) => [type, rank]))
+);
+var UNKNOWN_RANK = FEATURE_TYPE_RANKS.findIndex((types) => types.length === 0);
+function featureTypeRank(type) {
+  return RANK_BY_TYPE.get(type) ?? UNKNOWN_RANK;
+}
+function dot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function rankOwners(model, owners, context = {}) {
+  const byTag = new Map(model.features.map((feature) => [feature.tag, feature]));
+  const features = [];
+  for (const tag of owners) {
+    const feature = byTag.get(tag);
+    if (!feature) continue;
+    if (context.activeDirection && !sameDirection(feature.machiningDirection, context.activeDirection)) {
+      continue;
+    }
+    features.push(feature);
+  }
+  const view = context.viewDirection;
+  return features.map((feature) => ({
+    tag: feature.tag,
+    rank: featureTypeRank(feature.featureType),
+    alignment: view ? dot(feature.machiningDirection, view) : 0
+  })).sort((a, b) => {
+    if (a.rank !== b.rank) return a.rank - b.rank;
+    if (a.alignment !== b.alignment) return b.alignment - a.alignment;
+    if (a.tag < b.tag) return -1;
+    if (a.tag > b.tag) return 1;
+    return 0;
+  }).map((entry) => entry.tag);
+}
+function bestOwner(model, owners, context = {}) {
+  return rankOwners(model, owners, context)[0] ?? null;
+}
+function cycleOwner(owners, current) {
+  if (owners.length === 0) return null;
+  const index = current === null ? -1 : owners.indexOf(current);
+  return owners[(index + 1) % owners.length] ?? null;
+}
+
+// src/render/picking.ts
+var NO_MODIFIERS = {
+  alt: false,
+  ctrl: false,
+  meta: false,
+  shift: false,
+  secondary: false
+};
+function viewDirection(camera, target) {
+  const { x, y, z } = camera.position;
+  const dx = x - target.x;
+  const dy = y - target.y;
+  const dz = z - target.z;
+  const length = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (length === 0) return { x: 0, y: 0, z: 1 };
+  return { x: dx / length, y: dy / length, z: dz / length };
+}
+function buildPick(input) {
+  const { model, region } = input;
+  const owners = model.regionIndex.featuresForRegion(region);
+  const context = {
+    activeDirection: input.activeDirection == null ? null : model.candidateDirections[input.activeDirection] ?? null,
+    viewDirection: input.viewDirection ?? null
+  };
+  return {
+    region,
+    owners,
+    ranked: rankOwners(model, owners, context),
+    best: bestOwner(model, owners, context),
+    triangleIndex: input.triangleIndex,
+    point: input.point,
+    normal: input.normal,
+    modifiers: input.modifiers ?? NO_MODIFIERS
+  };
+}
+function focusForPick(pick, previousRegion, previousFocus) {
+  if (pick.ranked.length === 0) return null;
+  if (previousRegion !== pick.region) return pick.best;
+  const index = previousFocus === null ? -1 : pick.ranked.indexOf(previousFocus);
+  return pick.ranked[(index + 1) % pick.ranked.length] ?? pick.best;
+}
+
+// src/viewer.tsx
+import { Canvas, useFrame as useFrame2, useThree as useThree3 } from "@react-three/fiber";
+import {
+  createContext,
+  forwardRef,
+  useCallback,
+  useContext,
+  useEffect as useEffect3,
+  useImperativeHandle,
+  useMemo as useMemo3,
+  useRef as useRef2
+} from "react";
+import { Box3 as Box33, Vector3 as Vector35 } from "three";
+
+// src/camera.tsx
+import { useFrame, useThree as useThree2 } from "@react-three/fiber";
+import { useEffect as useEffect2, useMemo as useMemo2 } from "react";
+
+// src/render/camera.ts
+import { OrthographicCamera as OrthographicCamera2, Vector3 as Vector33 } from "three";
+var PERSPECTIVE_FOV = 30;
+var DEFAULT_FIT_MARGIN = 1.2;
+var EXCLUDE_FROM_FRAME = "viewerExcludeFromFrame";
+function defaultBounds() {
+  return { center: new Vector33(0, 0, 0), radius: 1 };
+}
+function aspectRatio(size) {
+  return size.width > 0 && size.height > 0 ? size.width / size.height : 1;
+}
+function boundsFromBox(box) {
+  if (box.isEmpty()) return defaultBounds();
+  const center = box.getCenter(new Vector33());
+  const radius = box.getSize(new Vector33()).length() / 2;
+  return { center, radius: radius > 0 ? radius : 1 };
+}
+function contentBounds(root, into) {
+  into.makeEmpty();
+  root.updateWorldMatrix(true, true);
+  root.traverse((object) => {
+    if (object.userData[EXCLUDE_FROM_FRAME]) return;
+    let ancestor = object.parent;
+    while (ancestor && ancestor !== root) {
+      if (ancestor.userData[EXCLUDE_FROM_FRAME]) return;
+      ancestor = ancestor.parent;
+    }
+    if ("isMesh" in object || "isLine" in object || "isPoints" in object) {
+      into.expandByObject(object);
+    }
+  });
+  return boundsFromBox(into);
+}
+function perspectiveFitDistance(fovDegrees, aspect, radius) {
+  const verticalFov = fovDegrees * Math.PI / 180;
+  const horizontalFov = 2 * Math.atan(Math.tan(verticalFov / 2) * aspect);
+  return radius / Math.sin(Math.min(verticalFov, horizontalFov) / 2);
+}
+function orthographicHalfHeight(aspect, radius) {
+  return aspect >= 1 ? radius : radius / aspect;
+}
+function nearFar(projection, radius) {
+  if (projection === "orthographic") return { near: -radius * 100, far: radius * 100 };
+  return { near: radius / 100, far: radius * 100 };
+}
+var START_DIRECTION = {
+  orthographic: [1.2, -2.5, 3],
+  perspective: [2, 1.2, -2.5]
+};
+function fitDistance(projection, size, bounds, margin = DEFAULT_FIT_MARGIN) {
+  if (projection === "perspective") {
+    return perspectiveFitDistance(PERSPECTIVE_FOV, aspectRatio(size), bounds.radius * margin);
+  }
+  return bounds.radius * margin * 4;
+}
+function startPosition(projection, size, bounds, margin = DEFAULT_FIT_MARGIN) {
+  const [x, y, z] = START_DIRECTION[projection];
+  return new Vector33(x, y, z).normalize().multiplyScalar(fitDistance(projection, size, bounds, margin)).add(bounds.center);
+}
+function applyProjection(camera, size, bounds, margin = DEFAULT_FIT_MARGIN) {
+  const aspect = aspectRatio(size);
+  const radius = bounds.radius * margin;
+  if (camera instanceof OrthographicCamera2) {
+    const halfHeight = orthographicHalfHeight(aspect, radius);
+    const halfWidth = halfHeight * aspect;
+    camera.left = -halfWidth;
+    camera.right = halfWidth;
+    camera.top = halfHeight;
+    camera.bottom = -halfHeight;
+    const { near, far } = nearFar("orthographic", radius);
+    camera.near = near;
+    camera.far = far;
+  } else {
+    camera.fov = PERSPECTIVE_FOV;
+    camera.aspect = aspect;
+    const { near, far } = nearFar("perspective", radius);
+    camera.near = near;
+    camera.far = far;
+  }
+  camera.updateProjectionMatrix();
+}
+var CAD_CAMERA_UP = new Vector33(0, 0, 1);
+var cadViewDirections = {
+  front: new Vector33(0, -1, 0),
+  back: new Vector33(0, 1, 0),
+  left: new Vector33(-1, 0, 0),
+  right: new Vector33(1, 0, 0),
+  top: new Vector33(0, 0, 1),
+  bottom: new Vector33(0, 0, -1),
+  isometric: new Vector33(1, -1, 1).normalize()
+};
+function currentViewDirection(camera, target, into) {
+  into.subVectors(camera.position, target);
+  if (into.lengthSq() <= Number.EPSILON) return into.copy(cadViewDirections.isometric);
+  return into.normalize();
+}
+
+// src/render/controls.ts
+import CameraControls from "camera-controls";
+import {
+  Box3 as Box32,
+  Matrix4,
+  OrthographicCamera as OrthographicCamera3,
+  Quaternion,
+  Raycaster,
+  Sphere,
+  Spherical,
+  Vector2,
+  Vector3 as Vector34,
+  Vector4
+} from "three";
+CameraControls.install({
+  THREE: {
+    Box3: Box32,
+    Matrix4,
+    Quaternion,
+    Raycaster,
+    Sphere,
+    Spherical,
+    Vector2,
+    Vector3: Vector34,
+    Vector4
+  }
+});
+var EPSILON3 = 1e-6;
+var FUSION_PINCH_ZOOM_SCALE = 0.04;
+var FUSION_ROTATE_SCALE = 2.2;
+var FUSION_TRUCK_SCALE = 0.33;
+var DEFAULT_SMOOTH_TIME = 1e-3;
+var ExtendedCameraControls = class extends CameraControls {
+  #domElement;
+  #freeOrbit;
+  #scheme = "toolpath";
+  #attached = false;
+  #autoUpEnabled = false;
+  #shiftPressed = false;
+  #wheelHandler = null;
+  // Scratch objects — `#onPointerMove` and `#adaptUpVector` run at pointer and
+  // frame rate respectively, so neither may allocate.
+  #spherical = new Spherical();
+  #scratchA = new Vector34();
+  #scratchB = new Vector34();
+  #scratchC = new Vector34();
+  #scratchD = new Vector34();
+  constructor(camera, domElement, options = {}) {
+    super(camera, domElement);
+    this.#domElement = domElement;
+    this.#freeOrbit = options.freeOrbit ?? true;
+    this.azimuthRotateSpeed = 0;
+    this.polarRotateSpeed = 0;
+  }
+  get freeOrbit() {
+    return this.#freeOrbit;
+  }
+  get scheme() {
+    return this.#scheme;
+  }
+  /** Adds the listeners this subclass owns, on top of the base connection. */
+  attach() {
+    if (this.#attached) {
+      return;
+    }
+    this.#attached = true;
+    this.#domElement.ownerDocument.addEventListener("pointermove", this.#onPointerMove);
+    const view = this.#domElement.ownerDocument.defaultView;
+    view?.addEventListener("keydown", this.#onModifierChange);
+    view?.addEventListener("keyup", this.#onModifierChange);
+    view?.addEventListener("blur", this.#onWindowBlur);
+    if (this.#freeOrbit) {
+      this.#enableAutoUp();
+    }
+    this.applyScheme(this.#scheme);
+  }
+  detach() {
+    if (!this.#attached) {
+      return;
+    }
+    this.#attached = false;
+    this.#domElement.ownerDocument.removeEventListener("pointermove", this.#onPointerMove);
+    const view = this.#domElement.ownerDocument.defaultView;
+    view?.removeEventListener("keydown", this.#onModifierChange);
+    view?.removeEventListener("keyup", this.#onModifierChange);
+    view?.removeEventListener("blur", this.#onWindowBlur);
+    this.#disableAutoUp();
+    this.#disableFusionWheel();
+  }
+  dispose() {
+    this.detach();
+    super.dispose();
+  }
+  /**
+   * Reapplies the current preset. The Viewer calls this after a projection
+   * change too, because the correct wheel action differs between an
+   * orthographic and a perspective camera.
+   */
+  applyScheme(scheme) {
+    this.#scheme = scheme;
+    this.mouseButtons.left = CameraControls.ACTION.NONE;
+    this.mouseButtons.middle = CameraControls.ACTION.NONE;
+    this.mouseButtons.right = CameraControls.ACTION.NONE;
+    this.mouseButtons.wheel = CameraControls.ACTION.NONE;
+    this.touches.one = CameraControls.ACTION.TOUCH_ROTATE;
+    this.touches.two = CameraControls.ACTION.TOUCH_DOLLY_TRUCK;
+    this.touches.three = CameraControls.ACTION.TOUCH_TRUCK;
+    this.smoothTime = DEFAULT_SMOOTH_TIME;
+    this.draggingSmoothTime = DEFAULT_SMOOTH_TIME;
+    this.#disableFusionWheel();
+    if (scheme === "fusion") {
+      const rotating = this.#shiftPressed;
+      this.mouseButtons.middle = rotating ? CameraControls.ACTION.ROTATE : CameraControls.ACTION.TRUCK;
+      this.touches.two = rotating ? CameraControls.ACTION.TOUCH_ROTATE : CameraControls.ACTION.TOUCH_TRUCK;
+      this.smoothTime = 0;
+      this.draggingSmoothTime = 0;
+      this.#enableFusionWheel();
+      return;
+    }
+    this.mouseButtons.left = CameraControls.ACTION.ROTATE;
+    this.mouseButtons.right = CameraControls.ACTION.TRUCK;
+    this.mouseButtons.middle = CameraControls.ACTION.TRUCK;
+    this.mouseButtons.wheel = this.camera instanceof OrthographicCamera3 ? CameraControls.ACTION.ZOOM : CameraControls.ACTION.DOLLY;
+  }
+  setFreeOrbit(freeOrbit) {
+    if (this.#freeOrbit === freeOrbit) {
+      return;
+    }
+    this.#freeOrbit = freeOrbit;
+    if (!this.#attached) {
+      return;
+    }
+    if (freeOrbit) {
+      this.#enableAutoUp();
+    } else {
+      this.#disableAutoUp();
+      this.resetUpVector();
+    }
+  }
+  /** Returns the camera to Z-up, the orientation the part data is authored in. */
+  resetUpVector() {
+    this.camera.up.set(0, 0, 1);
+    this.updateCameraUp();
+    const position = this.getPosition(this.#scratchA);
+    void this.setPosition(position.x, position.y, position.z, false);
+  }
+  #enableAutoUp() {
+    if (this.#autoUpEnabled) {
+      return;
+    }
+    this.#autoUpEnabled = true;
+    this.addEventListener("update", this.#adaptUpVector);
+  }
+  #disableAutoUp() {
+    if (!this.#autoUpEnabled) {
+      return;
+    }
+    this.#autoUpEnabled = false;
+    this.removeEventListener("update", this.#adaptUpVector);
+  }
+  #enableFusionWheel() {
+    this.#wheelHandler = (event) => this.#onFusionWheel(event);
+    this.#domElement.addEventListener("wheel", this.#wheelHandler, {
+      passive: false
+    });
+  }
+  #disableFusionWheel() {
+    if (!this.#wheelHandler) {
+      return;
+    }
+    this.#domElement.removeEventListener("wheel", this.#wheelHandler);
+    this.#wheelHandler = null;
+  }
+  /**
+   * Re-derives the up vector from the current view each update, so orbiting
+   * over a pole keeps going instead of flipping the horizon.
+   */
+  #adaptUpVector = () => {
+    const target = this.getTarget(this.#scratchA);
+    const view = this.#scratchB.subVectors(target, this.camera.position).normalize();
+    const side = this.#scratchC.crossVectors(view, this.camera.up).normalize();
+    const up = this.#scratchD.crossVectors(side, view).normalize();
+    this.camera.up.copy(up);
+    const position = this.getPosition(this.#scratchA);
+    this.updateCameraUp();
+    void this.setPosition(position.x, position.y, position.z, false);
+  };
+  /**
+   * Rotation, done here rather than by the base class so a constrained orbit
+   * can bounce off a pole — flipping the up vector and inverting azimuth —
+   * instead of sticking there.
+   */
+  #onPointerMove = (event) => {
+    if (this.currentAction !== CameraControls.ACTION.ROTATE) {
+      return;
+    }
+    const scale = Math.PI / Math.max(1, Math.min(this.#domElement.clientWidth, this.#domElement.clientHeight));
+    const spherical = this.getSpherical(this.#spherical);
+    let azimuth = spherical.theta - event.movementX * scale;
+    let polar = spherical.phi - event.movementY * scale;
+    const exceededUpper = polar > Math.PI - EPSILON3;
+    const exceededLower = polar < EPSILON3;
+    if (!this.#freeOrbit && (exceededUpper || exceededLower)) {
+      polar = exceededUpper ? EPSILON3 : Math.PI - EPSILON3;
+      azimuth = -azimuth;
+      this.camera.up.negate();
+      this.updateCameraUp();
+    }
+    void this.rotateTo(azimuth, polar, false);
+    this.update(0);
+  };
+  #onFusionWheel = (event) => {
+    event.preventDefault();
+    if (event.ctrlKey) {
+      void this.zoom(-event.deltaY * FUSION_PINCH_ZOOM_SCALE, false);
+    } else if (this.#shiftPressed) {
+      const scale = Math.PI / Math.max(1, Math.min(this.#domElement.clientWidth, this.#domElement.clientHeight));
+      void this.rotate(
+        event.deltaX * scale * FUSION_ROTATE_SCALE,
+        event.deltaY * scale * FUSION_ROTATE_SCALE,
+        false
+      );
+    } else {
+      void this.truck(event.deltaX * FUSION_TRUCK_SCALE, event.deltaY * FUSION_TRUCK_SCALE, false);
+    }
+    this.update(0);
+    this.dispatchEvent({ type: "control" });
+  };
+  #onModifierChange = (event) => {
+    this.#setShiftPressed(event.shiftKey);
+  };
+  #onWindowBlur = () => {
+    this.#setShiftPressed(false);
+  };
+  #setShiftPressed(pressed) {
+    if (this.#shiftPressed === pressed) {
+      return;
+    }
+    this.#shiftPressed = pressed;
+    if (this.#scheme === "fusion") {
+      this.applyScheme(this.#scheme);
+    }
+  }
+};
+
+// src/camera.tsx
+var CadCameraControls = ({
+  controlsRef,
+  scheme = "toolpath",
+  freeOrbit = true
+}) => {
+  const camera = useThree2((state) => state.camera);
+  const domElement = useThree2((state) => state.gl.domElement);
+  const invalidate = useThree2((state) => state.invalidate);
+  const set = useThree2((state) => state.set);
+  const controls = useMemo2(
+    () => new ExtendedCameraControls(camera, domElement, { freeOrbit }),
+    // `freeOrbit` is the constructor's initial value only; the effect below
+    // owns it from then on, and rebuilding the controls would drop the pose.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [camera, domElement]
+  );
+  useEffect2(() => {
+    controlsRef.current = controls;
+    camera.up.copy(CAD_CAMERA_UP);
+    controls.updateCameraUp();
+    controls.attach();
+    const request = () => invalidate();
+    controls.addEventListener("control", request);
+    controls.addEventListener("update", request);
+    invalidate();
+    return () => {
+      controls.removeEventListener("control", request);
+      controls.removeEventListener("update", request);
+      controls.dispose();
+      if (controlsRef.current === controls) controlsRef.current = null;
+    };
+  }, [camera, controls, controlsRef, invalidate]);
+  useEffect2(() => {
+    set({ controls });
+    return () => set({ controls: null });
+  }, [controls, set]);
+  useEffect2(() => {
+    controls.applyScheme(scheme);
+  }, [controls, scheme]);
+  useEffect2(() => {
+    controls.setFreeOrbit(freeOrbit);
+  }, [controls, freeOrbit]);
+  useFrame((_, delta) => {
+    controls.update(delta);
+  });
+  return null;
+};
+
+// src/viewer.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var ViewerControlsContext = createContext(null);
+var useViewerControls = () => {
+  const controls = useContext(ViewerControlsContext);
+  if (!controls) throw new Error("useViewerControls must be used inside <Viewer>");
+  return controls;
+};
+var ViewerScene = ({
+  children,
+  setControls,
+  projection,
+  scheme,
+  freeOrbit,
+  theme
+}) => {
+  const camera = useThree3((state) => state.camera);
+  const size = useThree3((state) => state.size);
+  const invalidate = useThree3((state) => state.invalidate);
+  const controlsRef = useRef2(null);
+  const contentRef = useRef2(null);
+  const lightsRef = useRef2(null);
+  const initialFrameComplete = useRef2(false);
+  const boundsRef = useRef2(defaultBounds());
+  const scratchBox = useMemo3(() => new Box33(), []);
+  const scratchDirection = useMemo3(() => new Vector35(), []);
+  const scratchView = useMemo3(() => new Vector35(), []);
+  const measure = useCallback(() => {
+    const content = contentRef.current;
+    boundsRef.current = content ? contentBounds(content, scratchBox) : defaultBounds();
+    return boundsRef.current;
+  }, [scratchBox]);
+  const frame = useCallback(
+    (direction, transition = false) => {
+      const controls = controlsRef.current;
+      if (!controls) return false;
+      const bounds = measure();
+      applyProjection(camera, size, bounds, DEFAULT_FIT_MARGIN);
+      const distance = fitDistance(projection, size, bounds, DEFAULT_FIT_MARGIN);
+      const position = scratchDirection.copy(direction).normalize().multiplyScalar(distance);
+      position.add(bounds.center);
+      void controls.setLookAt(
+        position.x,
+        position.y,
+        position.z,
+        bounds.center.x,
+        bounds.center.y,
+        bounds.center.z,
+        transition
+      );
+      if (projection === "orthographic") void controls.zoomTo(1, transition);
+      invalidate();
+      return true;
+    },
+    [camera, invalidate, measure, projection, scratchDirection, size]
+  );
+  const frameBounds = useCallback(
+    (bounds) => {
+      const controls = controlsRef.current;
+      if (!controls) return false;
+      const target = controls.getTarget(new Vector35());
+      const direction = currentViewDirection(camera, target, new Vector35());
+      const distance = fitDistance(projection, size, bounds, DEFAULT_FIT_MARGIN);
+      const position = direction.multiplyScalar(distance).add(bounds.center);
+      void controls.setLookAt(
+        position.x,
+        position.y,
+        position.z,
+        bounds.center.x,
+        bounds.center.y,
+        bounds.center.z,
+        true
+      );
+      if (projection === "orthographic") {
+        void controls.zoomTo(boundsRef.current.radius / bounds.radius, true);
+      }
+      invalidate();
+      return true;
+    },
+    [camera, invalidate, projection, size]
+  );
+  const fitContent = useCallback(() => {
+    const controls = controlsRef.current;
+    if (!controls) return false;
+    const target = controls.getTarget(new Vector35());
+    return frame(currentViewDirection(camera, target, new Vector35()), true);
+  }, [camera, frame]);
+  const resetContent = useCallback(() => {
+    const bounds = measure();
+    const start = startPosition(projection, size, bounds).sub(bounds.center);
+    return frame(start, true);
+  }, [frame, measure, projection, size]);
+  useEffect3(() => {
+    setControls({
+      fit: () => {
+        fitContent();
+      },
+      reset: () => {
+        resetContent();
+      },
+      setView: (view) => {
+        frame(cadViewDirections[view], true);
+      },
+      setViewDirection: (direction) => {
+        frame(scratchView.set(direction.x, direction.y, direction.z), true);
+      },
+      frameBox: (box) => {
+        frameBounds(boundsFromBox(box));
+      }
+    });
+  }, [fitContent, frame, frameBounds, resetContent, scratchView, setControls]);
+  useEffect3(() => {
+    if (initialFrameComplete.current) resetContent();
+  }, [projection]);
+  useEffect3(() => {
+    applyProjection(camera, size, boundsRef.current, DEFAULT_FIT_MARGIN);
+    invalidate();
+  }, [camera, invalidate, size]);
+  useFrame2(() => {
+    const lights = lightsRef.current;
+    if (lights && !lights.quaternion.equals(camera.quaternion)) {
+      lights.quaternion.copy(camera.quaternion);
+      invalidate();
+    }
+  });
+  useFrame2(() => {
+    if (!initialFrameComplete.current && contentRef.current?.children.length) {
+      initialFrameComplete.current = resetContent();
+    }
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("group", { ref: lightsRef, children: [
+      /* @__PURE__ */ jsx("ambientLight", { color: theme.ambient, intensity: theme.ambientIntensity }),
+      /* @__PURE__ */ jsx(
+        "hemisphereLight",
+        {
+          args: [theme.hemisphereSky, theme.hemisphereGround, theme.hemisphereIntensity]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("group", { ref: contentRef, children }),
+    /* @__PURE__ */ jsx(CadCameraControls, { controlsRef, scheme, freeOrbit })
+  ] });
+};
+var Viewer = forwardRef(function Viewer2({
+  children,
+  className,
+  style,
+  projection = "perspective",
+  controls = "toolpath",
+  freeOrbit = true,
+  theme,
+  onPointerMissed
+}, ref) {
+  const actionsRef = useRef2(null);
+  const resolved = useMemo3(() => resolveTheme(theme), [theme]);
+  const proxy = useMemo3(
+    () => ({
+      fit: () => actionsRef.current?.fit(),
+      reset: () => actionsRef.current?.reset(),
+      setView: (view) => actionsRef.current?.setView(view),
+      setViewDirection: (direction) => actionsRef.current?.setViewDirection(direction),
+      frameBox: (box) => actionsRef.current?.frameBox(box)
+    }),
+    []
+  );
+  useImperativeHandle(ref, () => proxy, [proxy]);
+  const setControls = useCallback((next) => {
+    actionsRef.current = next;
+  }, []);
+  const tracker = useRef2(null);
+  const hold = useCallback((element) => {
+    tracker.current?.dispose();
+    tracker.current = element ? trackTaps(element) : null;
+  }, []);
+  return /* @__PURE__ */ jsx(ViewerControlsContext.Provider, { value: proxy, children: /* @__PURE__ */ jsx("div", { className, ref: hold, style: { height: "100%", width: "100%", ...style }, children: /* @__PURE__ */ jsx(
+    Canvas,
+    {
+      orthographic: projection === "orthographic",
+      camera: { fov: PERSPECTIVE_FOV, up: [0, 0, 1], position: [1, -1, 1] },
+      dpr: [1, 2],
+      frameloop: "demand",
+      gl: { antialias: true, alpha: true, stencil: true, localClippingEnabled: true },
+      onPointerMissed: (event) => {
+        if (event.button !== 0) return;
+        if (tracker.current?.isTap(event) ?? true) onPointerMissed?.();
+      },
+      children: /* @__PURE__ */ jsx(
+        ViewerScene,
+        {
+          setControls,
+          projection,
+          scheme: controls,
+          freeOrbit,
+          theme: resolved,
+          children
+        }
+      )
+    },
+    projection
+  ) }) });
+});
+
+// src/section-view.tsx
+import { useFrame as useFrame3, useThree as useThree4 } from "@react-three/fiber";
+import { useCallback as useCallback2, useMemo as useMemo4, useRef as useRef3, useState } from "react";
+import {
+  AlwaysStencilFunc,
+  BackSide,
+  DecrementWrapStencilOp,
+  DoubleSide,
+  FrontSide,
+  IncrementWrapStencilOp,
+  NotEqualStencilFunc,
+  Plane as Plane2,
+  Quaternion as Quaternion2,
+  Raycaster as Raycaster2,
+  ReplaceStencilOp,
+  Vector2 as Vector22,
+  Vector3 as Vector37
+} from "three";
+
+// src/render/directions.ts
+import { Vector3 as Vector36 } from "three";
+var CONE_AXIS = new Vector36(0, 1, 0);
+var LENGTH = 0.45;
+var HEAD = 0.45;
+var HEAD_RADIUS = 0.3;
+var SHAFT_RADIUS = 0.09;
+var GAP = 0.2;
+function arrowPlacement(direction, box) {
+  const center = box.getCenter(new Vector36());
+  const half = box.getSize(new Vector36()).multiplyScalar(0.5);
+  const radius = half.length() || 1;
+  const axis = new Vector36(direction.x, direction.y, direction.z);
+  if (axis.lengthSq() === 0) axis.set(0, 0, 1);
+  axis.normalize();
+  let exit = Number.POSITIVE_INFINITY;
+  for (const [component, extent] of [
+    [axis.x, half.x],
+    [axis.y, half.y],
+    [axis.z, half.z]
+  ]) {
+    if (Math.abs(component) > 1e-6) exit = Math.min(exit, extent / Math.abs(component));
+  }
+  if (!Number.isFinite(exit)) exit = radius;
+  return { tip: center.addScaledVector(axis, exit + radius * GAP), length: radius * LENGTH };
+}
+
+// src/section-view.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var DEFAULT_NORMAL = { x: 0, y: 0, z: 1 };
+var FURNITURE = { [EXCLUDE_FROM_FRAME]: true };
+function resolveSectionPlane(options, box) {
+  if (!options?.enabled || box.isEmpty()) return null;
+  const normal = options.plane?.normal ?? options.normal ?? DEFAULT_NORMAL;
+  const axis = new Vector37(normal.x, normal.y, normal.z);
+  if (axis.lengthSq() === 0) axis.set(0, 0, 1);
+  axis.normalize();
+  const bounds = sectionBounds(box, normal);
+  const anchor = options.plane?.point ?? null;
+  const depth = options.depth ?? null;
+  const constant = anchor === null ? sectionConstant(bounds, options.offset ?? 0) : sectionDepthConstant(normal, anchor, depth ?? 0);
+  return {
+    plane: new Plane2(axis, constant),
+    state: {
+      enabled: true,
+      normal: { x: axis.x, y: axis.y, z: axis.z },
+      offset: sectionOffset(bounds, constant),
+      constant,
+      plane: options.plane ?? null,
+      depth: anchor === null ? null : sectionDepth(normal, anchor, constant),
+      depthRange: anchor === null ? null : sectionDepthRange(bounds, normal, anchor)
+    }
+  };
+}
+var SectionView = ({
+  geometry,
+  box,
+  plane,
+  theme,
+  showHandle,
+  onDrag
+}) => {
+  const camera = useThree4((state) => state.camera);
+  const size = useThree4((state) => state.size);
+  const invalidate = useThree4((state) => state.invalidate);
+  const controls = useThree4((state) => state.controls);
+  const domElement = useThree4((state) => state.gl.domElement);
+  const capRef = useRef3(null);
+  const handleRef = useRef3(null);
+  const [hovered, setHovered] = useState(false);
+  const dragging = useRef3(null);
+  const centre = useMemo4(() => box.getCenter(new Vector37()), [box]);
+  const span = useMemo4(() => box.getSize(new Vector37()).length(), [box]);
+  const clip = useMemo4(() => [plane], [plane]);
+  const capPosition = useMemo4(() => {
+    const point = centre.clone();
+    return point.addScaledVector(plane.normal, -(plane.constant + plane.normal.dot(centre)));
+  }, [centre, plane]);
+  const capQuaternion = useMemo4(
+    () => new Quaternion2().setFromUnitVectors(new Vector37(0, 0, 1), plane.normal),
+    [plane]
+  );
+  const handleQuaternion = useMemo4(
+    () => new Quaternion2().setFromUnitVectors(CONE_AXIS, plane.normal.clone().negate()),
+    [plane]
+  );
+  useFrame3(() => {
+    const handle = handleRef.current;
+    if (!handle) return;
+    const length = screenLength(camera, capPosition, size, HANDLE_PIXELS);
+    if (Math.abs(handle.scale.x - length) > length * 1e-3) {
+      handle.scale.setScalar(length);
+      invalidate();
+    }
+  });
+  const setControlsEnabled = useCallback2(
+    (enabled) => {
+      const target = controls;
+      if (target && "enabled" in target) target.enabled = enabled;
+    },
+    [controls]
+  );
+  const beginDrag = (event) => {
+    if (!onDrag) return;
+    event.stopPropagation();
+    const view = camera.position.clone().sub(capPosition).normalize();
+    const surface = dragPlane(plane.normal.clone(), view, capPosition);
+    const hit = event.ray.intersectPlane(surface, new Vector37());
+    const start = {
+      plane: surface,
+      from: hit ? hit.dot(plane.normal) : 0,
+      constant: plane.constant
+    };
+    dragging.current = start;
+    setControlsEnabled(false);
+    const raycaster = new Raycaster2();
+    const pointer = new Vector22();
+    const move = (native) => {
+      const rect = domElement.getBoundingClientRect();
+      pointer.set(
+        (native.clientX - rect.left) / rect.width * 2 - 1,
+        -((native.clientY - rect.top) / rect.height) * 2 + 1
+      );
+      raycaster.setFromCamera(pointer, camera);
+      const point = raycaster.ray.intersectPlane(start.plane, new Vector37());
+      if (!point) return;
+      onDrag(start.constant - (point.dot(plane.normal) - start.from));
+      invalidate();
+    };
+    const end = () => {
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", end);
+      window.removeEventListener("pointercancel", end);
+      dragging.current = null;
+      setControlsEnabled(true);
+    };
+    window.addEventListener("pointermove", move);
+    window.addEventListener("pointerup", end);
+    window.addEventListener("pointercancel", end);
+  };
+  const grab = {
+    onPointerDown: beginDrag,
+    onPointerOver: (event) => {
+      event.stopPropagation();
+      setHovered(true);
+      invalidate();
+    },
+    onPointerOut: () => {
+      setHovered(false);
+      invalidate();
+    }
+  };
+  return (
+    // Excluded from framing, all of it. The cap is a quad half again as wide as
+    // the part's diagonal, so a Fit that measured it would frame the cut rather
+    // than the part and leave the part a speck in the middle of it.
+    /* @__PURE__ */ jsxs2("group", { userData: FURNITURE, children: [
+      /* @__PURE__ */ jsx2("mesh", { geometry, renderOrder: SECTION_RENDER_ORDER.stencil, raycast: () => null, children: /* @__PURE__ */ jsx2(
+        "meshBasicMaterial",
+        {
+          side: BackSide,
+          depthWrite: false,
+          depthTest: false,
+          colorWrite: false,
+          stencilWrite: true,
+          stencilFunc: AlwaysStencilFunc,
+          stencilFail: IncrementWrapStencilOp,
+          stencilZFail: IncrementWrapStencilOp,
+          stencilZPass: IncrementWrapStencilOp,
+          clippingPlanes: clip
+        }
+      ) }),
+      /* @__PURE__ */ jsx2("mesh", { geometry, renderOrder: SECTION_RENDER_ORDER.stencil, raycast: () => null, children: /* @__PURE__ */ jsx2(
+        "meshBasicMaterial",
+        {
+          side: FrontSide,
+          depthWrite: false,
+          depthTest: false,
+          colorWrite: false,
+          stencilWrite: true,
+          stencilFunc: AlwaysStencilFunc,
+          stencilFail: DecrementWrapStencilOp,
+          stencilZFail: DecrementWrapStencilOp,
+          stencilZPass: DecrementWrapStencilOp,
+          clippingPlanes: clip
+        }
+      ) }),
+      /* @__PURE__ */ jsx2("group", { ref: capRef, position: capPosition, quaternion: capQuaternion, children: /* @__PURE__ */ jsxs2("mesh", { renderOrder: SECTION_RENDER_ORDER.cap, raycast: () => null, children: [
+        /* @__PURE__ */ jsx2("planeGeometry", { args: [span * 1.5, span * 1.5] }),
+        /* @__PURE__ */ jsx2(
+          "meshBasicMaterial",
+          {
+            color: theme.sectionCap,
+            side: DoubleSide,
+            stencilWrite: true,
+            stencilRef: 0,
+            stencilFunc: NotEqualStencilFunc,
+            stencilFail: ReplaceStencilOp,
+            stencilZFail: ReplaceStencilOp,
+            stencilZPass: ReplaceStencilOp
+          }
+        )
+      ] }) }),
+      showHandle && onDrag ? /* @__PURE__ */ jsxs2(
+        "group",
+        {
+          ref: handleRef,
+          position: capPosition,
+          quaternion: handleQuaternion,
+          renderOrder: SECTION_RENDER_ORDER.handle,
+          children: [
+            /* @__PURE__ */ jsxs2("mesh", { position: [0, 0.28, 0], ...grab, children: [
+              /* @__PURE__ */ jsx2("coneGeometry", { args: [0.16, 0.34, 20] }),
+              /* @__PURE__ */ jsx2(
+                "meshBasicMaterial",
+                {
+                  color: hovered ? theme.hover : theme.sectionHandle,
+                  depthTest: false
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs2("mesh", { position: [0, 0.08, 0], ...grab, children: [
+              /* @__PURE__ */ jsx2("cylinderGeometry", { args: [0.045, 0.045, 0.4, 12] }),
+              /* @__PURE__ */ jsx2(
+                "meshBasicMaterial",
+                {
+                  color: hovered ? theme.hover : theme.sectionHandle,
+                  depthTest: false
+                }
+              )
+            ] })
+          ]
+        }
+      ) : null
+    ] })
+  );
+};
+
+// src/content-box.ts
+import { useFrame as useFrame4, useThree as useThree5 } from "@react-three/fiber";
+import { useRef as useRef4, useState as useState2 } from "react";
+import { Box3 as Box34 } from "three";
+function useContentBox() {
+  const scene = useThree5((state) => state.scene);
+  const [box, setBox] = useState2(() => new Box34());
+  const measured = useRef4(false);
+  useFrame4(() => {
+    if (measured.current) return;
+    const next = new Box34();
+    contentBounds(scene, next);
+    if (next.isEmpty()) return;
+    measured.current = true;
+    setBox(next);
+  });
+  return box;
+}
+
+// src/part-mesh.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var PartMesh = ({
+  model,
+  geometry,
+  selection = [],
+  candidates = [],
+  highlights = [],
+  regionHighlights = [],
+  pickedRegions = [],
+  hoveredFeatureIds = [],
+  activeDirection = null,
+  section,
+  onSectionChange,
+  focusFeature = null,
+  onHover,
+  onPick,
+  theme,
+  showEdges = true
+}) => {
+  const { camera, controls, invalidate } = useThree6();
+  const viewerControls = useViewerControls();
+  const resolved = useStableTheme(theme);
+  const currentTheme = useRef5(resolved);
+  currentTheme.current = resolved;
+  const part = useMemo5(() => createPart(model, geometry, currentTheme.current), [geometry, model]);
+  const hoverRegion = useRef5(null);
+  const box = useContentBox();
+  const cut = useMemo5(() => resolveSectionPlane(section, box), [box, section]);
+  const layers = useRef5({
+    selection,
+    candidates,
+    highlights,
+    regionHighlights,
+    pickedRegions,
+    hoveredFeatureIds
+  });
+  layers.current = {
+    selection,
+    candidates,
+    highlights,
+    regionHighlights,
+    pickedRegions,
+    hoveredFeatureIds
+  };
+  const repaint = useCallback3(() => {
+    const { hoveredFeatureIds: hoveredFeatures, ...rest } = layers.current;
+    applyHighlightLayers(
+      part,
+      { ...rest, hoveredFeatures, hoverRegion: hoverRegion.current },
+      currentTheme.current
+    );
+    invalidate();
+  }, [invalidate, part]);
+  useEffect4(() => () => part.dispose(), [part]);
+  const framed = useRef5(null);
+  useEffect4(() => {
+    if (focusFeature === null || focusFeature === framed.current) return;
+    framed.current = focusFeature;
+    const box2 = part.boxForFeature(focusFeature);
+    if (box2) viewerControls.frameBox(box2);
+  }, [focusFeature, part, viewerControls]);
+  useLayoutEffect(() => {
+    part.setTheme(resolved);
+    repaint();
+  }, [part, repaint, resolved]);
+  useLayoutEffect(() => {
+    part.edges.visible = showEdges;
+    invalidate();
+  }, [invalidate, part, showEdges]);
+  useLayoutEffect(() => {
+    part.setClippingPlanes(cut ? [cut.plane] : null);
+    invalidate();
+  }, [cut, invalidate, part]);
+  const reportedSection = useRef5("");
+  useLayoutEffect(() => {
+    const state = cut?.state ?? null;
+    const key = state ? `${state.constant}|${state.normal.x},${state.normal.y},${state.normal.z}` : "";
+    if (key === reportedSection.current) return;
+    reportedSection.current = key;
+    if (state) onSectionChange?.(state);
+  }, [cut, onSectionChange]);
+  const layerKey = [
+    selection.join(" "),
+    candidates.join(" "),
+    pickedRegions.join(" "),
+    hoveredFeatureIds.join(" "),
+    highlights.map((entry) => `${entry.tag}:${entry.color}:${entry.weight ?? ""}`).join(" "),
+    regionHighlights.map((entry) => `${entry.region}:${entry.color}:${entry.weight ?? ""}`).join(" ")
+  ].join("|");
+  useLayoutEffect(() => {
+    repaint();
+  }, [layerKey, repaint]);
+  const isTap = useTapGuard();
+  const pickFor = (event) => {
+    const triangleIndex = event.faceIndex;
+    if (triangleIndex == null) return null;
+    const region = model.regionIndex.regionForTriangle(triangleIndex);
+    if (region === null) return null;
+    const target = readTarget(controls);
+    const normal = event.face?.normal ?? UP;
+    const source = event.nativeEvent;
+    return buildPick({
+      model,
+      region,
+      triangleIndex,
+      point: [event.point.x, event.point.y, event.point.z],
+      normal: [normal.x, normal.y, normal.z],
+      activeDirection,
+      viewDirection: viewDirection(camera, target),
+      modifiers: {
+        alt: source.altKey,
+        ctrl: source.ctrlKey,
+        meta: source.metaKey,
+        shift: source.shiftKey,
+        secondary: "button" in source && source.button === 2
+      }
+    });
+  };
+  const emitHover = (next) => {
+    const region = next?.region ?? null;
+    if (hoverRegion.current === region) return;
+    hoverRegion.current = region;
+    repaint();
+    onHover?.(next);
+  };
+  const dragSection = useCallback3(
+    (constant) => {
+      if (!cut) return;
+      const anchor = section?.plane?.point;
+      onSectionChange?.({
+        ...cut.state,
+        constant,
+        offset: sectionOffset(sectionBounds(box, cut.state.normal), constant),
+        depth: anchor ? sectionDepth(cut.state.normal, anchor, constant) : null
+      });
+    },
+    [box, cut, onSectionChange, section]
+  );
+  return /* @__PURE__ */ jsxs3(Fragment2, { children: [
+    /* @__PURE__ */ jsx3(
+      "primitive",
+      {
+        object: part.object,
+        onPointerMove: (event) => emitHover(pickFor(event)),
+        onPointerOut: () => emitHover(null),
+        onClick: (event) => {
+          if (!isTap(event.nativeEvent)) return;
+          const pick = pickFor(event);
+          if (pick) onPick?.(pick);
+        }
+      }
+    ),
+    cut ? /* @__PURE__ */ jsx3(
+      SectionView,
+      {
+        geometry,
+        box,
+        plane: cut.plane,
+        theme: resolved,
+        showHandle: onSectionChange !== void 0,
+        onDrag: onSectionChange ? dragSection : void 0
+      }
+    ) : null
+  ] });
+};
+var ORIGIN = new Vector38();
+var UP = new Vector38(0, 0, 1);
+var TARGET = new Vector38();
+function readTarget(controls) {
+  if (controls && typeof controls.getTarget === "function") {
+    return controls.getTarget(TARGET);
+  }
+  const target = controls?.target;
+  return target ?? ORIGIN;
+}
+function useStableTheme(theme) {
+  const held = useRef5(null);
+  const next = resolveTheme(theme);
+  if (held.current === null || !themesEqual(held.current, next)) held.current = next;
+  return held.current;
+}
+
+// src/engine/geometry.ts
+import { Matrix4 as Matrix42, Mesh as Mesh2 } from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { STLLoader } from "three/examples/jsm/loaders/STLLoader.js";
+var PartMeshError = class extends Error {
+  name = "PartMeshError";
+};
+var IDENTITY = new Matrix42();
+function partMeshAssets(mesh) {
+  const assets = [];
+  if (mesh.glbUrl) assets.push({ format: "glb", url: mesh.glbUrl });
+  if (mesh.stlUrl) assets.push({ format: "stl", url: mesh.stlUrl });
+  return assets;
+}
+async function loadPartGeometry(url, mesh, options = {}) {
+  const request = options.fetch ?? globalThis.fetch;
+  const response = await request(url, options.signal ? { signal: options.signal } : void 0);
+  if (!response.ok) {
+    throw new PartMeshError(
+      `Fetching the part mesh failed with ${response.status} ${response.statusText}. A presigned mesh URL expires 15 minutes after the report that carried it.`
+    );
+  }
+  return parsePartGeometry(await response.arrayBuffer(), mesh, options.format ?? "glb");
+}
+async function loadPartMesh(mesh, options = {}) {
+  const assets = partMeshAssets(mesh);
+  if (assets.length === 0) {
+    throw new PartMeshError("The report carries neither a GLB nor an STL mesh URL.");
+  }
+  const failures = [];
+  for (const asset of assets) {
+    try {
+      return await loadPartGeometry(asset.url, mesh, { ...options, format: asset.format });
+    } catch (error) {
+      failures.push(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  throw new AggregateError(failures, "Could not load the part mesh.");
+}
+async function parsePartGeometry(data, mesh, format = "glb") {
+  if (format === "stl") return parseStl(data, mesh);
+  const loader = new GLTFLoader();
+  let scene;
+  try {
+    ;
+    ({ scene } = await loader.parseAsync(data, ""));
+  } catch (cause) {
+    throw new PartMeshError("The part mesh is not a readable GLB.", { cause });
+  }
+  const source = singleMesh(scene);
+  const geometry = source.geometry;
+  assertCounts(geometry, mesh);
+  source.updateWorldMatrix(true, false);
+  if (!source.matrixWorld.equals(IDENTITY)) {
+    geometry.applyMatrix4(source.matrixWorld);
+  }
+  const prepared = geometry.index ? geometry.toNonIndexed() : geometry;
+  if (prepared !== geometry) geometry.dispose();
+  if (!prepared.hasAttribute("normal")) prepared.computeVertexNormals();
+  disposeMaterials(scene);
+  return prepared;
+}
+function parseStl(data, mesh) {
+  let geometry;
+  try {
+    geometry = new STLLoader().parse(data);
+  } catch (cause) {
+    throw new PartMeshError("The part mesh is not a readable STL.", { cause });
+  }
+  assertCounts(geometry, mesh);
+  if (!geometry.hasAttribute("normal")) geometry.computeVertexNormals();
+  return geometry;
+}
+function singleMesh(scene) {
+  const meshes = [];
+  scene.traverse((object) => {
+    if (object instanceof Mesh2) meshes.push(object);
+  });
+  const [mesh] = meshes;
+  if (mesh === void 0 || meshes.length !== 1) {
+    throw new PartMeshError(
+      `The part mesh must be a single triangle mesh; this GLB has ${meshes.length}. Region triangle ranges index one buffer, so there is no order to apply them in.`
+    );
+  }
+  return mesh;
+}
+function assertCounts(geometry, expected) {
+  const position = geometry.getAttribute("position");
+  if (position === void 0) {
+    throw new PartMeshError("The part mesh has no POSITION attribute.");
+  }
+  const indices = geometry.index?.count ?? position.count;
+  if (indices % 3 !== 0) {
+    throw new PartMeshError(
+      `The part mesh has ${indices} vertex indices, which is not a whole number of triangles.`
+    );
+  }
+  const triangleCount = indices / 3;
+  if (triangleCount !== expected.triangleCount) {
+    throw new PartMeshError(
+      `The report describes ${expected.triangleCount} triangles but the mesh has ${triangleCount}. Region ranges index the mesh directly, so the two must be the same artifact.`
+    );
+  }
+  const points = geometry.index ? expected.pointCount : triangleCount * 3;
+  if (position.count !== points) {
+    throw new PartMeshError(
+      `The report describes ${expected.pointCount} points but the mesh has ${position.count}.`
+    );
+  }
+}
+function disposeMaterials(scene) {
+  scene.traverse((object) => {
+    if (!(object instanceof Mesh2)) return;
+    for (const material of Array.isArray(object.material) ? object.material : [object.material]) {
+      material.dispose();
+    }
+  });
+}
+
+// src/engine/normals.ts
+import { Float32BufferAttribute as Float32BufferAttribute3 } from "three";
+function smoothRegionNormals(geometry, regions) {
+  const position = geometry.getAttribute("position");
+  if (!position || geometry.index) return;
+  const vertexCount = position.count;
+  const triangleCount = Math.floor(vertexCount / 3);
+  const surfaces = visualSurfaces(geometry, regions);
+  const regionOf = new Int32Array(triangleCount).fill(-1);
+  for (const region of regions) {
+    const end = Math.min(region.triangles.end, triangleCount);
+    for (let triangle = region.triangles.start; triangle < end; triangle += 1) {
+      regionOf[triangle] = surfaces.get(region.idx) ?? region.idx;
+    }
+  }
+  const sums = /* @__PURE__ */ new Map();
+  const keys = new Array(vertexCount);
+  for (let triangle = 0; triangle < triangleCount; triangle += 1) {
+    const a = triangle * 3;
+    const ax = position.getX(a);
+    const ay = position.getY(a);
+    const az = position.getZ(a);
+    const bx = position.getX(a + 1);
+    const by = position.getY(a + 1);
+    const bz = position.getZ(a + 1);
+    const cx = position.getX(a + 2);
+    const cy = position.getY(a + 2);
+    const cz = position.getZ(a + 2);
+    const ux = bx - ax;
+    const uy = by - ay;
+    const uz = bz - az;
+    const vx = cx - ax;
+    const vy = cy - ay;
+    const vz = cz - az;
+    const nx = uy * vz - uz * vy;
+    const ny = uz * vx - ux * vz;
+    const nz = ux * vy - uy * vx;
+    const region = regionOf[triangle] ?? -1;
+    const corners = [
+      [a, ax, ay, az],
+      [a + 1, bx, by, bz],
+      [a + 2, cx, cy, cz]
+    ];
+    for (const [vertex, x, y, z] of corners) {
+      const key = `${region}|${x}|${y}|${z}`;
+      keys[vertex] = key;
+      const sum = sums.get(key);
+      if (sum) {
+        sum[0] += nx;
+        sum[1] += ny;
+        sum[2] += nz;
+      } else {
+        sums.set(key, [nx, ny, nz]);
+      }
+    }
+  }
+  const normals = new Float32Array(vertexCount * 3);
+  for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+    const sum = sums.get(keys[vertex] ?? "");
+    if (!sum) continue;
+    const [x, y, z] = sum;
+    const length = Math.hypot(x, y, z);
+    if (length <= 1e-12) continue;
+    normals[vertex * 3] = x / length;
+    normals[vertex * 3 + 1] = y / length;
+    normals[vertex * 3 + 2] = z / length;
+  }
+  geometry.setAttribute("normal", new Float32BufferAttribute3(normals, 3));
+}
+
+// src/engine/geometry-cache.ts
+function engineGeometryResourceKey(mesh) {
+  return [mesh.glbUrl, mesh.stlUrl].map((url) => url?.split("?")[0] ?? "").join("|");
+}
+function createEngineGeometryCache(loadGeometry = async (part) => {
+  const geometry = await loadPartMesh(part.mesh);
+  smoothRegionNormals(geometry, part.regions);
+  return geometry;
+}, maximumEntries = 8) {
+  const resources = /* @__PURE__ */ new Map();
+  let accessSequence = 0;
+  const touch = (resource) => {
+    resource.lastAccess = ++accessSequence;
+  };
+  const evictReleasedResources = () => {
+    while (resources.size > maximumEntries) {
+      let oldest;
+      for (const entry of resources) {
+        const [, resource] = entry;
+        if (resource.status !== "fulfilled" || resource.references > 0 || oldest && oldest[1].lastAccess <= resource.lastAccess) {
+          continue;
+        }
+        oldest = entry;
+      }
+      if (!oldest) return;
+      resources.delete(oldest[0]);
+      oldest[1].geometry?.dispose();
+    }
+  };
+  return {
+    get(part) {
+      const key = engineGeometryResourceKey(part.mesh);
+      const existing = resources.get(key);
+      if (existing) {
+        touch(existing);
+        return existing;
+      }
+      const resource = {
+        status: "pending",
+        promise: Promise.resolve(),
+        references: 0,
+        lastAccess: ++accessSequence
+      };
+      resource.promise = loadGeometry(part).then(
+        (geometry) => {
+          resource.status = "fulfilled";
+          resource.geometry = geometry;
+        },
+        (error) => {
+          resource.status = "rejected";
+          resource.error = error instanceof Error ? error : new Error(String(error));
+          if (resources.get(key) === resource) resources.delete(key);
+        }
+      );
+      resources.set(key, resource);
+      return resource;
+    },
+    retain(resource) {
+      resource.references += 1;
+      touch(resource);
+    },
+    release(resource) {
+      resource.references = Math.max(0, resource.references - 1);
+      touch(resource);
+      evictReleasedResources();
+    },
+    clear() {
+      for (const resource of resources.values()) resource.geometry?.dispose();
+      resources.clear();
+    }
+  };
+}
+var engineGeometryCache = createEngineGeometryCache();
+
+// src/model/errors.ts
+var PartReportFormatError = class extends Error {
+  name = "PartReportFormatError";
+  /** Every problem found, not just the first. */
+  issues;
+  constructor(issues) {
+    super(
+      issues.length === 1 ? `Malformed part report: ${issues[0]}` : `Malformed part report (${issues.length} problems):
+- ${issues.join("\n- ")}`
+    );
+    this.issues = issues;
+  }
+};
+var UnsupportedKernelVersionError = class extends Error {
+  name = "UnsupportedKernelVersionError";
+  kernelVersion;
+  minimumKernelVersion;
+  constructor(kernelVersion, minimumKernelVersion) {
+    super(
+      `Part report is from kernel ${kernelVersion}; @toolpath/viewer requires ${minimumKernelVersion} or newer, which is the first version to publish regions[] and featureTag. Re-analyze the part on a current engine.`
+    );
+    this.kernelVersion = kernelVersion;
+    this.minimumKernelVersion = minimumKernelVersion;
+  }
+};
+
+// src/model/region-index.ts
+function buildRegionIndex(input) {
+  const { regions, features, triangleCount } = input;
+  const issues = [];
+  if (!Number.isInteger(triangleCount) || triangleCount < 0) {
+    issues.push("meshTriangleCount must be a non-negative integer");
+  }
+  const byIdx = /* @__PURE__ */ new Map();
+  for (const region of regions) {
+    const { idx, triangles } = region;
+    if (!Number.isInteger(idx) || idx < 0) {
+      issues.push(`region idx ${idx} is not a non-negative integer`);
+      continue;
+    }
+    if (byIdx.has(idx)) {
+      issues.push(`region idx ${idx} appears more than once`);
+      continue;
+    }
+    if (!Number.isInteger(triangles.start) || !Number.isInteger(triangles.end) || triangles.start < 0 || triangles.end < triangles.start) {
+      issues.push(
+        `region ${idx} has an invalid triangle range [${triangles.start}, ${triangles.end})`
+      );
+      continue;
+    }
+    if (triangles.end > triangleCount) {
+      issues.push(
+        `region ${idx} ends at triangle ${triangles.end}, past meshTriangleCount ${triangleCount}`
+      );
+      continue;
+    }
+    byIdx.set(idx, region);
+  }
+  const sorted = [...byIdx.values()].sort((a, b) => a.triangles.start - b.triangles.start);
+  let expected = 0;
+  for (const region of sorted) {
+    if (region.triangles.start !== expected) {
+      issues.push(
+        region.triangles.start > expected ? `triangles [${expected}, ${region.triangles.start}) belong to no region` : `region ${region.idx} overlaps the region before it at triangle ${region.triangles.start}`
+      );
+    }
+    expected = Math.max(expected, region.triangles.end);
+  }
+  if (issues.length === 0 && expected !== triangleCount) {
+    issues.push(`regions cover ${expected} triangles but the mesh has ${triangleCount}`);
+  }
+  const regionsByFeature = /* @__PURE__ */ new Map();
+  const featuresByRegion = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    if (regionsByFeature.has(feature.tag)) {
+      issues.push(`featureTag ${feature.tag} appears more than once`);
+      continue;
+    }
+    for (const idx of feature.regionIdxs) {
+      if (!byIdx.has(idx)) {
+        issues.push(`feature ${feature.tag} references region ${idx}, which does not exist`);
+        continue;
+      }
+      const owners = featuresByRegion.get(idx);
+      if (owners) owners.push(feature.tag);
+      else featuresByRegion.set(idx, [feature.tag]);
+    }
+    regionsByFeature.set(feature.tag, [...feature.regionIdxs]);
+  }
+  if (issues.length > 0) throw new PartReportFormatError(issues);
+  const starts = new Int32Array(sorted.length);
+  const ends = new Int32Array(sorted.length);
+  const regionIds = new Int32Array(sorted.length);
+  for (const [i, region] of sorted.entries()) {
+    starts[i] = region.triangles.start;
+    ends[i] = region.triangles.end;
+    regionIds[i] = region.idx;
+  }
+  const noFeatures = Object.freeze([]);
+  const noRegions = Object.freeze([]);
+  return {
+    regionCount: sorted.length,
+    regionForTriangle(triangle) {
+      if (!Number.isInteger(triangle) || triangle < 0) return null;
+      const i = upperBound(starts, triangle) - 1;
+      if (i < 0) return null;
+      return triangle < ends[i] ? regionIds[i] : null;
+    },
+    featuresForRegion(region) {
+      return featuresByRegion.get(region) ?? noFeatures;
+    },
+    regionsForFeature(tag) {
+      return regionsByFeature.get(tag) ?? noRegions;
+    },
+    rangeForRegion(region) {
+      const found = byIdx.get(region);
+      return found ? found.triangles : null;
+    }
+  };
+}
+function upperBound(values, target) {
+  let low = 0;
+  let high = values.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if (values[mid] <= target) low = mid + 1;
+    else high = mid;
+  }
+  return low;
+}
+
+// src/engine/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNullableString(value) {
+  return value === null || typeof value === "string";
+}
+
+// src/engine/normalize.ts
+var MIN_KERNEL_VERSION = "0.3.0";
+function normalizePartReport(report) {
+  if (!isRecord(report)) {
+    throw new PartReportFormatError(["report is not an object"]);
+  }
+  const kernelVersion = report["kernelVersion"];
+  if (!isString(kernelVersion)) {
+    throw new PartReportFormatError(["kernelVersion is missing or not a string"]);
+  }
+  assertSupportedKernelVersion(kernelVersion);
+  const issues = [];
+  const warnings = [];
+  const partId = requireString(report["partId"], "partId", issues);
+  const meshPointCount = requireCount(report["meshPointCount"], "meshPointCount", issues);
+  const meshTriangleCount = requireCount(report["meshTriangleCount"], "meshTriangleCount", issues);
+  const regions = readRegions(report["regions"], issues);
+  const features = readFeatures(report["features"], issues, warnings);
+  const candidateDirections = readDirections(report["candidateDirections"], issues);
+  for (const [key, value] of [
+    ["meshGlbUrl", report["meshGlbUrl"]],
+    ["meshStlUrl", report["meshStlUrl"]],
+    ["thumbnailUrl", report["thumbnailUrl"]]
+  ]) {
+    if (value !== void 0 && !isNullableString(value)) {
+      issues.push(`${key} is neither a string nor null`);
+    }
+  }
+  if (issues.length > 0 || partId === null || meshPointCount === null || meshTriangleCount === null) {
+    throw new PartReportFormatError(issues);
+  }
+  const regionIndex = buildRegionIndex({
+    regions,
+    features,
+    triangleCount: meshTriangleCount
+  });
+  return {
+    partId,
+    kernelVersion,
+    features,
+    regions,
+    candidateDirections,
+    mesh: {
+      pointCount: meshPointCount,
+      triangleCount: meshTriangleCount,
+      glbUrl: readNullableString(report["meshGlbUrl"]),
+      stlUrl: readNullableString(report["meshStlUrl"]),
+      thumbnailUrl: readNullableString(report["thumbnailUrl"])
+    },
+    regionIndex,
+    warnings
+  };
+}
+function assertSupportedKernelVersion(kernelVersion) {
+  const parsed = parseVersion(kernelVersion);
+  if (parsed === null) {
+    throw new PartReportFormatError([
+      `kernelVersion "${kernelVersion}" is not a recognizable version`
+    ]);
+  }
+  const minimum = parseVersion(MIN_KERNEL_VERSION);
+  if (minimum === null || compareVersions(parsed, minimum) < 0) {
+    throw new UnsupportedKernelVersionError(kernelVersion, MIN_KERNEL_VERSION);
+  }
+}
+function readRegions(value, issues) {
+  if (!Array.isArray(value)) {
+    issues.push("regions is missing or not an array \u2014 a 0.3.0 report always has one");
+    return [];
+  }
+  const regions = [];
+  for (const [i, raw] of value.entries()) {
+    if (!isRecord(raw)) {
+      issues.push(`regions[${i}] is not an object`);
+      continue;
+    }
+    const idx = raw["idx"];
+    const start = raw["triangleStart"];
+    const end = raw["triangleEnd"];
+    const area = raw["area"];
+    const shapeKind = raw["shapeKind"];
+    if (!isNonNegativeInteger(idx) || !isNonNegativeInteger(start) || !isNonNegativeInteger(end) || !isFiniteNumber(area) || !isString(shapeKind)) {
+      issues.push(`regions[${i}] does not match the Region schema`);
+      continue;
+    }
+    regions.push({ idx, shapeKind, area, triangles: { start, end } });
+  }
+  return regions;
+}
+function readFeatures(value, issues, warnings) {
+  if (!Array.isArray(value)) {
+    issues.push("features is missing or not an array");
+    return [];
+  }
+  const features = [];
+  for (const [i, raw] of value.entries()) {
+    if (!isRecord(raw)) {
+      issues.push(`features[${i}] is not an object`);
+      continue;
+    }
+    const tag = raw["featureTag"];
+    const featureType = raw["featureType"];
+    const regionIdxs = raw["regionIdxs"];
+    const machiningDirection = readVec3(raw["machiningDirection"]);
+    if (!isString(tag)) {
+      issues.push(`features[${i}] has no featureTag`);
+      continue;
+    }
+    if (!isString(featureType)) {
+      issues.push(`feature ${tag} has no featureType`);
+      continue;
+    }
+    if (machiningDirection === null) {
+      issues.push(`feature ${tag} has no machiningDirection`);
+      continue;
+    }
+    if (!isRegionIdxArray(regionIdxs)) {
+      issues.push(`feature ${tag} has an invalid regionIdxs`);
+      continue;
+    }
+    features.push({
+      tag,
+      featureType,
+      machiningDirection,
+      // Absent and null are both normal — plenty of features have no natural
+      // axis. A value that is present but unreadable is a data problem worth
+      // saying out loud, and not one worth failing a load over: nothing is
+      // rendered from the axis.
+      axis: readAxis(raw["axis"], tag, warnings),
+      regionIdxs
+    });
+  }
+  return features;
+}
+function readDirections(value, issues) {
+  if (!Array.isArray(value)) {
+    issues.push("candidateDirections is missing or not an array");
+    return [];
+  }
+  const directions = [];
+  for (const [i, raw] of value.entries()) {
+    const vec = readVec3(raw);
+    if (vec === null) {
+      issues.push(`candidateDirections[${i}] is not a vector`);
+      continue;
+    }
+    directions.push(vec);
+  }
+  return directions;
+}
+function readAxis(value, tag, warnings) {
+  if (value === null || value === void 0) return null;
+  const axis = readVec3(value);
+  if (axis === null) {
+    warnings.push(`feature ${tag} has an axis this package cannot read; dropped`);
+  }
+  return axis;
+}
+function isRegionIdxArray(value) {
+  return Array.isArray(value) && value.every(isNonNegativeInteger);
+}
+function requireString(value, field, issues) {
+  if (isString(value)) return value;
+  issues.push(`${field} is missing or not a string`);
+  return null;
+}
+function requireCount(value, field, issues) {
+  if (isNonNegativeInteger(value)) return value;
+  issues.push(`${field} is missing or not a non-negative integer`);
+  return null;
+}
+function readVec3(value) {
+  if (!isRecord(value)) return null;
+  const { x, y, z } = value;
+  if (!isFiniteNumber(x) || !isFiniteNumber(y) || !isFiniteNumber(z)) return null;
+  return { x, y, z };
+}
+function readNullableString(value) {
+  return isString(value) ? value : null;
+}
+function parseVersion(value) {
+  const core = value.trim().split(/[-+]/, 1)[0] ?? "";
+  const parts = core.split(".");
+  if (parts.length < 2 || parts.length > 3) return null;
+  const numbers = parts.map((part) => /^\d+$/.test(part) ? Number(part) : NaN);
+  if (numbers.some(Number.isNaN)) return null;
+  return [numbers[0] ?? 0, numbers[1] ?? 0, numbers[2] ?? 0];
+}
+function compareVersions(a, b) {
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (a[i] ?? 0) - (b[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+// src/engine/engine-part.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var EnginePart = ({ report, ...props }) => {
+  const model = useMemo6(() => normalizePartReport(report), [report]);
+  const resource = useGeometryResource(model);
+  useEffect5(() => {
+    engineGeometryCache.retain(resource);
+    return () => engineGeometryCache.release(resource);
+  }, [resource]);
+  return /* @__PURE__ */ jsx4(PartMesh, { model, geometry: resource.geometry, ...props });
+};
+function useGeometryResource(part) {
+  const resource = engineGeometryCache.get(part);
+  if (resource.status === "pending") throw resource.promise;
+  if (resource.status === "rejected") throw resource.error;
+  return resource;
+}
+
+export {
+  sameDirection,
+  directionIndexOf,
+  groupByDirection,
+  directionLabel,
+  CONTINUES_WITHIN,
+  visualSurfaces,
+  HIGHLIGHT_COLORS,
+  DIRECTION_COLORS,
+  DEFAULT_THEME,
+  resolveTheme,
+  themesEqual,
+  directionColor,
+  HIGHLIGHT_WEIGHT,
+  CANDIDATE_WEIGHT,
+  HOVER_WEIGHT,
+  applyHighlightLayers,
+  SECTION_RENDER_ORDER,
+  HANDLE_PIXELS,
+  PICKED_SURFACE_LABEL,
+  sectionBounds,
+  sectionConstant,
+  sectionOffset,
+  sectionDepth,
+  sectionDepthConstant,
+  sectionDepthRange,
+  sectionFromPick,
+  pickedStartDepth,
+  sectionPlane,
+  screenLength,
+  dragPlane,
+  TAP_SLOP,
+  movedFar,
+  trackTaps,
+  useTapGuard,
+  regionEdgesGeometry,
+  REGION_ATTRIBUTE,
+  buildRegionTexels,
+  buildRegionAttribute,
+  createPart,
+  FEATURE_TYPE_RANKS,
+  featureTypeRank,
+  rankOwners,
+  bestOwner,
+  cycleOwner,
+  NO_MODIFIERS,
+  viewDirection,
+  buildPick,
+  focusForPick,
+  PERSPECTIVE_FOV,
+  DEFAULT_FIT_MARGIN,
+  EXCLUDE_FROM_FRAME,
+  defaultBounds,
+  aspectRatio,
+  boundsFromBox,
+  contentBounds,
+  perspectiveFitDistance,
+  orthographicHalfHeight,
+  fitDistance,
+  startPosition,
+  applyProjection,
+  CAD_CAMERA_UP,
+  cadViewDirections,
+  currentViewDirection,
+  ExtendedCameraControls,
+  CadCameraControls,
+  useViewerControls,
+  Viewer,
+  CONE_AXIS,
+  HEAD,
+  HEAD_RADIUS,
+  SHAFT_RADIUS,
+  arrowPlacement,
+  resolveSectionPlane,
+  SectionView,
+  useContentBox,
+  PartMesh,
+  PartMeshError,
+  partMeshAssets,
+  loadPartGeometry,
+  loadPartMesh,
+  parsePartGeometry,
+  smoothRegionNormals,
+  engineGeometryResourceKey,
+  createEngineGeometryCache,
+  engineGeometryCache,
+  PartReportFormatError,
+  UnsupportedKernelVersionError,
+  buildRegionIndex,
+  MIN_KERNEL_VERSION,
+  normalizePartReport,
+  assertSupportedKernelVersion,
+  EnginePart
+};