3D view of the part

const pos = new Float32Array(nt * 9);
for (let t = 0; t < nt; t++) for (let k = 0; k < 3; k++) for (let c = 0; c < 3; c++) pos[t * 9 + k * 3 + c] = P[I[t * 3 + k] * 3 + c];
const geo = new THREE.BufferGeometry();
geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));

/** Colour the part (a result plot): RGB 0…1 per mesh vertex (length = mesh.positions.length) or per triangle corner
 *  (length = 9 × triangles); null = the plain body colour. setMesh (every rebuild) clears it. */
setFaceColors(c) {
  if (!this.mesh) return;
  const geo = this.mesh.geometry, mat = this.mesh.material;
  if (!c) {
    if (geo.getAttribute('color')) geo.deleteAttribute('color');
    mat.vertexColors = false; mat.color.copy(this.bodyColor); mat.needsUpdate = true; this.render(); return;
  }
  const I = this.data.indices, nt = I.length / 3;
  let col;
  if (c.length === nt * 9) col = Float32Array.from(c);
  else if (c.length === this.data.positions.length) {
    col = new Float32Array(nt * 9);
    for (let t = 0; t < nt; t++) for (let k = 0; k < 3; k++) for (let j = 0; j < 3; j++) col[t * 9 + k * 3 + j] = c[I[t * 3 + k] * 3 + j];
  } else throw new Error(`setFaceColors: ${c.length} values for ${this.data.positions.length / 3} vertices / ${nt} triangles.`);   // i18n-ignore: a programming error (wrong colour array), never shown to a person
  geo.setAttribute('color', new THREE.BufferAttribute(col, 3));
  mat.vertexColors = true; mat.color.set(0xffffff); mat.needsUpdate = true;
  this.render();
}

pickAt(clientX, clientY, { planes = this.planes.visible, edges = true } = {}) {
  const ray = this.ray(clientX, clientY);
  const hits = [];
  if (this.mesh && this.partVisible) {
    const h = this.keptHit(ray.intersectObject(this.mesh, false));
    if (h) {
      const tri = this.visTri ? this.visTri[h.faceIndex] : h.faceIndex;   // hidden bodies: drawn index → mesh triangle
      const n = h.face.normal.clone();
      const fi = this.data.triFeature[tri];
      const grp = this.planarGroups();
      const g = grp.faceOf[tri];
      const group = grp.groups[g];
      const planar = group.tris.length > 1 || true;
      const face = this.data.triFace ? this.data.triFace[tri] : undefined;
      if (face !== undefined) n.copy(triNormal3(this.data, tri));
      hits.push({ d: h.distance, hit: { kind: 'face', tri, point: h.point.toArray(), normal: n.toArray(), featureIndex: fi, feature: fi >= 0 ? this.data.featIds[fi] : null, tris: group.tris, group: g, planar, face } });
    }
  }
  if (this.instances?.length) {
    const h = this.keptHit(ray.intersectObjects(this.instances.map((o) => o.mesh), false));
    if (h) {
      const it = this.instances.find((o) => o.mesh === h.object);
      const tri = h.faceIndex;
      const inv = new THREE.Matrix4().fromArray(it.matrix).invert();
      const local = h.point.clone().applyMatrix4(inv);
      const g = it.groups.faceOf[tri];
      const fi = it.data.triFeature[tri];
      hits.push({ d: h.distance, hit: { kind: 'face', inst: it.id, tri, point: local.toArray(), normal: h.face.normal.toArray(), worldPoint: h.point.toArray(), featureIndex: fi, feature: fi >= 0 ? it.data.featIds[fi] : null, tris: it.groups.groups[g].tris, group: g, data: it.data, matrix: it.matrix, face: it.data.triFace ? it.data.triFace[tri] : undefined } });
    }
  }
  if (edges && this.edges && this.partVisible) {
    const h = this.keptHit(ray.intersectObject(this.edges, false));
    if (h) {
      const a = h.object.geometry.attributes.position;
      const i = h.index;
      const A = [a.getX(i), a.getY(i), a.getZ(i)], B = [a.getX(i + 1), a.getY(i + 1), a.getZ(i + 1)];
      const edge = this.edgeOfSeg ? this.edgeOfSeg[i / 2] : undefined;
      // an edge wins over the face it bounds when the pointer is right on it
      hits.push({ d: h.distance - (this.camera.far * 1e-4), hit: { kind: 'edge', a: A, b: B, edge } });
    }
  }
  if (this.refs.children.length && !this.sketchFrame) {
    const lines = this.refs.children.filter((o) => o.isLine);
    const hl = ray.intersectObjects(lines, false)[0];
    if (hl) hits.push({ d: hl.distance - (this.camera.far * 2e-4), hit: { kind: 'ref', id: hl.object.userData.ref } });
    const fills = this.refs.children.filter((o) => o.isMesh);
    const hf = ray.intersectObjects(fills, false)[0];
    if (hf) hits.push({ d: hf.distance + (this.mesh ? 1e9 : 0), hit: { kind: 'ref', id: hf.object.userData.ref } });
  }
  if (planes && this.planes.visible && !this.planesFaint) {
    const fills = this.planes.children.filter((g) => g.userData.plane).map((g) => g.children[0]);
    const h = ray.intersectObjects(fills, false)[0];
    if (h) hits.push({ d: h.distance + (this.mesh ? 1e9 : 0), hit: { kind: 'plane', name: h.object.userData.plane } });
  }
  hits.sort((p, q) => p.d - q.d);
  return hits.length ? hits[0].hit : null;
}