Fillet, chamfer, draft, thread and mesh bodies on the mesh kernel

/** The named faces and edges of the body as it is now (K.2b): its mesh, each triangle's tool, meshfaces.js. */
function bodyFaces(ctx) {
  const gm = ctx.body.getMesh();
  const np = gm.numProp, nv = gm.vertProperties.length / np;
  const positions = new Float32Array(nv * 3);
  for (let i = 0; i < nv; i++) for (let k = 0; k < 3; k++) positions[i * 3 + k] = gm.vertProperties[i * np + k];
  const indices = new Uint32Array(gm.triVerts);
  const runs = gm.runIndex, ids = gm.runOriginalID;
  const lists = [], listOf = new Map(), triTool = new Int32Array(indices.length / 3).fill(-1);
  for (let r = 0; r + 1 < runs.length; r++) {
    const sf = ctx.toolSurfs.get(ids[r]);
    if (!sf) continue;
    let k = listOf.get(ids[r]);
    if (k === undefined) { k = lists.length; listOf.set(ids[r], k); lists.push(sf); }
    for (let ti = runs[r] / 3; ti < runs[r + 1] / 3; ti++) triTool[ti] = k;
  }
  const mesh = { positions, indices };
  return { mesh, ...MF.namedFaces(mesh, triTool, lists, { segments: ctx.part.resolution || 64, triHint: faceHintsOf(gm, ctx.faceHints) }) };
}

const k1 = 1 - V.dot(nA, nB), sA = (s * size * k1) / V.dot(uA, nB), sB = (s * size * k1) / V.dot(uB, nA);
if (!(sA > 0 && sB > 0) || sA > L * 1e3) fail(t('model.brep.round_no_fit', { size: size }));
tA = V.add(O, V.mul(uA, sA)); tB = V.add(O, V.mul(uB, sB));
const c = V.add(V.add(O, V.mul(uA, sA)), V.mul(nA, s * size));
// the arc from tA to tB the short way, on the side facing the corner
const v0 = V.sub(tA, c), v1 = V.sub(tB, c), ax = V.norm(V.cross(v0, v1));
const ang = Math.acos(Math.max(-1, Math.min(1, V.dot(v0, v1) / (size * size))));
const n = Math.max(2, Math.ceil(ang / (2 * Math.PI) * seg));
for (let i = 1; i < n; i++) arc.push(V.add(c, V.applyMat(V.rotationAbout([0, 0, 0], ax, (ang * i / n) * 180 / Math.PI), v0)));

const theta = Math.acos(Math.max(-1, Math.min(1, V.dot(ua, ub))));
let da = size, db = size;
if (f.mode === 'two') db = f.d2;
else if (f.mode === 'angle') { const al = f.angle * Math.PI / 180; db = size * Math.sin(al) / Math.sin(Math.PI - al - theta); }
if (!(db > 0)) fail(t('model.brep.chamfer_no_fit', { size }));
const pa = V.add(O, V.mul(ua, da)), pb = V.add(O, V.mul(ub, db));

const eps = 0.01 * size, out = V.mul(V.add(nA, nB), -s * eps);
const poly = [V.add(O, out), V.sub(tA, V.mul(nA, s * eps)), tA, ...arc, tB, V.sub(tB, V.mul(nB, s * eps))];
const X = V.norm(V.sub(tA, O)), Y = V.cross(d, X);
let loop = poly.map((p) => [V.dot(V.sub(p, O), X), V.dot(V.sub(p, O), Y)]);
let ar = 0; for (let i = 0; i < loop.length; i++) { const q = loop[i], r = loop[(i + 1) % loop.length]; ar += q[0] * r[1] - r[0] * q[1]; }
if (ar < 0) loop = loop.reverse();
const cs = ctx.T(new ctx.M.CrossSection([loop], 'Positive'));
const prism = ctx.T(ctx.T(cs.extrude(L)).transform(V.basisMatrix(X, Y, d, O)));

  for (let v = st, g = 0; v !== undefined && !used.has(v) && g < next.size + 1; v = next.get(v), g++) { used.add(v); const w = V.sub([P[v * 3], P[v * 3 + 1], P[v * 3 + 2]], fc.o); loop.push([V.dot(w, X), V.dot(w, Y)]); }
  if (loop.length >= 3) loops.push(loop);
}
if (!loops.length) fail(t('model.brep_design.draft_failed'));
const L = size * 2;
const prism = ctx.T(ctx.T(ctx.T(new ctx.M.CrossSection(loops, 'EvenOdd')).extrude(2 * L)).transform(V.basisMatrix(X, Y, n, V.sub(fc.o, V.mul(n, L)))));

let t0 = Infinity, t1 = -Infinity, out = 0;
for (let ti = 0; ti < I.length / 3; ti++) {
  if (B.triFace[ti] !== fi) continue;
  const q = [0, 1, 2].map((k) => [P[I[ti * 3 + k] * 3], P[I[ti * 3 + k] * 3 + 1], P[I[ti * 3 + k] * 3 + 2]]);
  for (const p of q) { const h = V.dot(V.sub(p, o), d); t0 = Math.min(t0, h); t1 = Math.max(t1, h); }
  const c = V.mul(V.add(V.add(q[0], q[1]), q[2]), 1 / 3), n = V.cross(V.sub(q[1], q[0]), V.sub(q[2], q[0]));
  const v = V.sub(c, o), rad = V.sub(v, V.mul(d, V.dot(v, d)));
  out += V.dot(n, rad) / Math.max(1e-30, V.len(rad));
}
if (!(t1 > t0)) fail(t('thread.err.round'));
const external = out > 0;

/**
 * A body from a mesh (0.7 D7.49): the repaired mesh the file keeps (meshimport.js), scaled to mm and turned Y up, made a manifold
 * with a reserved original id and each triangle's flat face as its faceID, so after any boolean every triangle still says which
 * flat face it lies on (faceHintsOf). Flat faces are named `<feature>.flat:<k>` and offered to sketches as candidates.
 */
function meshImport(f, ctx) {
  if (!f.mesh) fail(t('kernel.feature.not_built', { label: FEATURE_LABELS.import }));
  let src;
  try { src = meshOf(f.mesh); } catch { fail(t('kernel.mesh.import_bad')); }
  const s = UNITS[f.units] ?? 1, zup = f.up !== 'y';
  const at = (x, y, z) => (zup ? [x * s, z * s, -y * s] : [x * s, y * s, z * s]);
  const dir = (x, y, z) => (zup ? [x, z, -y] : [x, y, z]);
  const P = src.positions, vp = new Float32Array(P.length);
  for (let i = 0; i < P.length; i += 3) { const q = at(P[i], P[i + 1], P[i + 2]); vp[i] = q[0]; vp[i + 1] = q[1]; vp[i + 2] = q[2]; }
  const { triPlane, planes } = src.flats;
  const K = planes.length, nt = src.indices.length / 3;
  const faceID = new Uint32Array(nt);
  for (let ti = 0; ti < nt; ti++) faceID[ti] = triPlane[ti] >= 0 ? triPlane[ti] : K + ti;
  const oid = ctx.M.Manifold.reserveIDs(1);
  let m;
  try {
    m = ctx.T(new ctx.M.Manifold(new ctx.M.Mesh({ numProp: 3, vertProperties: vp, triVerts: src.indices, faceID, runIndex: new Uint32Array([0, nt * 3]), runOriginalID: new Uint32Array([oid]) })));
  } catch {
    const r = f.report || {};
    fail(r.openEdges || r.nonManifold ? t('kernel.mesh.import_open', { n: r.openEdges || 0, m: r.nonManifold || 0 }) : t('kernel.mesh.import_not_solid'));
  }
  if (m.status() !== 'NoError' || m.isEmpty()) fail(t('kernel.mesh.import_not_solid'));
  const op = f.op || 'add', out = op === 'cut' ? -1 : 1;   // a cut's faces point back into the tool
  const surfs = [], cands = [];
  planes.forEach((p, k) => {
    const n = dir(...p.n), o = at(...p.o);
    surfs.push({ ...MF.plane(`${f.id}.flat:${k}`, n, o), noSpread: true });   // i18n-ignore: a face name (identifier)
    cands.push({ ref: { face: 'flat', entity: String(k) }, frame: V.frameFor(V.mul(n, out), o) });
  });
  ctx.candidates.set(f.id, cands);
  return { tools: [{ m, op, surfs, oid, faceHint: K }] };
}