Named faces and edges from the body mesh

const sag = 1.5 * (1 - Math.cos(Math.PI / Math.max(8, segments)));   // segments: the part's facets per full turn
const P = mesh.positions, I = mesh.indices, nt = I.length / 3;
const pt = (i) => [P[i * 3], P[i * 3 + 1], P[i * 3 + 2]];
let lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
for (let i = 0; i < P.length; i += 3) for (let k = 0; k < 3; k++) { lo[k] = Math.min(lo[k], P[i + k]); hi[k] = Math.max(hi[k], P[i + k]); }
const size = Math.max(1e-9, Math.hypot(hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]));
const tol = 2e-6 * size + 1e-7;   // float32 positions round to ~1e-7 of their size

/** Does triangle (points P, unit normal nt) lie on surface s? tol: distance in model units; sag: the chord sag of a round
 *  surface as a fraction of its radius (a boolean puts new points on the facets, up to one sag inside the true surface). */
function onSurface(s, P, nt, tol, sag) {
  // bounds tell coincident surfaces apart (two counterbore floors in one plane, two collinear sketch lines): the triangle's
  // centre must lie within the hole's radius of its axis, or along its sketch line's extent
  if (s.within) { const c = V.mul(P.reduce((q, p) => V.add(q, p), [0, 0, 0]), 1 / 3); if (radial(c, s.within)[0] > s.within.r + tol) return false; }
  if (s.span) { const c = V.mul(P.reduce((q, p) => V.add(q, p), [0, 0, 0]), 1 / 3); const u = V.dot(sub(c, s.span.a), s.span.d); if (u < -tol || u > s.span.len + tol) return false; }
  // nt null: a needle triangle (a boolean leaves some with two points in one place) whose normal means nothing: points only
  if (s.type === 'plane') return (!nt || Math.abs(V.dot(nt, s.n)) > 0.9) && P.every((p) => Math.abs(V.dot(sub(p, s.o), s.n)) <= tol);
  if (s.type === 'cylinder') {
    if (nt && Math.abs(V.dot(nt, s.axis.d)) > 0.5) return false;   // a cap: its points can lie on the cylinder too
    return P.every((p) => { const d = radial(p, s.axis)[0] - s.r; return d <= tol + 1e-6 * s.r && d >= -(tol + sag * s.r); });
  }
  if (s.type === 'cone') {
    if (nt && Math.abs(V.dot(nt, s.axis.d)) > 0.999) return false;   // a flat cap, not the cone
    return P.every((p) => { const [rho, h] = radial(p, s.axis); const d = rho - h * s.k; return h >= -tol && d <= tol * (1 + s.k) && d >= -(tol * (1 + s.k) + sag * h * s.k); });
  }
  if (s.type === 'sphere') return P.every((p) => { const d = Math.hypot(...sub(p, s.c)) - s.r; return d <= tol && d >= -(tol + sag * s.r); });
  if (s.type === 'torus') {
    return P.every((p) => { const [rho, h] = radial(p, s.axis); const d = Math.hypot(rho - s.R, h) - s.r; return d <= tol && d >= -(tol + sag * (s.R + s.r)); });
  }
  if (s.type === 'thread') {
    if (nt && Math.abs(V.dot(nt, s.axis.d)) > 0.99) return false;   // a flat end, not the thread
    return P.every((p) => { const [rho, h] = radial(p, s.axis); return rho >= s.r0 - tol - sag * s.r0 && rho <= s.r1 + tol && h >= s.t0 - tol && h <= s.t1 + tol; });
  }
  return false;
}

/** The surfaces of a copied tool: moved by M4 (a rigid motion or a reflection) and renamed with the copy's suffix. */
export function moveSurfs(surfs, M, suffix) {
  if (!surfs) return null;
  return surfs.map((s0) => {
    let s = s0;
    const name = s.name ? s.name + suffix : s.name;
    const moved = {};
    if (s.within) moved.within = { ...s.within, o: V.applyMat(M, s.within.o), d: V.norm(dirOf(M, s.within.d)) };
    if (s.span) moved.span = { ...s.span, a: V.applyMat(M, s.span.a), d: V.norm(dirOf(M, s.span.d)) };
    s = { ...s, ...moved };
    if (s.type === 'plane') return { ...s, name, n: V.norm(dirOf(M, s.n)), o: V.applyMat(M, s.o) };
    if (s.type === 'cylinder' || s.type === 'cone' || s.type === 'torus' || s.type === 'thread') return { ...s, name, axis: { o: V.applyMat(M, s.axis.o), d: V.norm(dirOf(M, s.axis.d)) } };
    if (s.type === 'sphere') return { ...s, name, c: V.applyMat(M, s.c) };
    return { ...s, name };
  });
}