Inset, bevel and moves along normals

/** Each vertex's unit normal: the faces round it averaged by area (only `faces`, when given). */
export function vertexNormals(m, faces = null) {
  const N = new Float64Array(m.nv * 3), t = [0, 0, 0], cs = [];
  for (const f of faces ? liveFaces(m, faces) : Array.from({ length: m.nf }, (_, i) => i)) {
    if (m.faceDead(f)) continue;
    m.faceNormalRaw(f, t);
    for (const h of m.faceCorners(f, cs)) { const v = m.hV[h]; N[v * 3] += t[0]; N[v * 3 + 1] += t[1]; N[v * 3 + 2] += t[2]; }
  }
  for (let v = 0; v < m.nv; v++) { const l = Math.hypot(N[v * 3], N[v * 3 + 1], N[v * 3 + 2]); if (l > 0) { N[v * 3] /= l; N[v * 3 + 1] /= l; N[v * 3 + 2] /= l; } }
  return N;
}

/** Where corner p (between a before it and b after it, counter-clockwise about n) moves when its edges move in by d. */
function insetCorner(p, a, b, n, d) {
  const u1 = norm(sub(p, a)), u2 = norm(sub(b, p));
  const in1 = norm(cross(n, u1)), in2 = norm(cross(n, u2));   // inward, left of each edge
  const bis = norm(add(in1, in2));
  const c = dot(bis, in1);
  let k = c > 1e-6 ? d / c : d;
  const lim = 0.5 * Math.min(len(sub(p, a)), len(sub(b, p))) / Math.max(1e-9, Math.sqrt(Math.max(0, 1 - c * c)) || 1);
  if (k > lim * 4) k = lim * 4;
  return add(p, mul(bis, k));
}

// region: only border vertices move in; each border vertex's new place from its two border edges (in their faces' planes)
const inR = new Set(R), border = [];
for (const f of R) for (const h of m.faceCorners(f, cs)) { const t = m.hTw[h]; if (t < 0 || !inR.has(m.hF[t])) border.push(h); }
const inEdge = new Map(), outEdge = new Map();   // border vertex → the border half-edge ending at it / starting from it
for (const h of border) { outEdge.set(m.hV[h], h); inEdge.set(m.head(h), h); }
const map = new Map();
for (const [v, hOut] of outEdge) {
  const hIn = inEdge.get(v);
  if (hIn === undefined) continue;
  const p = P3(m, v), a = P3(m, m.hV[hIn]), b = P3(m, m.head(hOut));
  const nrm = norm(add(m.faceNormal(m.hF[hIn]), m.faceNormal(m.hF[hOut])));
  map.set(v, newVert(m, add(insetCorner(p, a, b, nrm, thickness), mul(nrm, depth)), v));
}

const sinBetween = (u1, u2) => len(cross(u1, u2));
const corners = new Map();   // v → its outgoing half-edges (the face corners at v), clockwise
for (const v of V) corners.set(v, m.outgoing(v));
for (const [v, cs] of corners) for (const c of cs) {
  const hin = m.hPv[c], ein = isB(hin), eout = isB(c);
  const uOut = dirOf(v, m.head(c)), uIn = dirOf(v, m.hV[hin]);
  const sn = sinBetween(uIn, uOut);
  if (ein && !eout) want(v, c, sn > 1e-6 ? width / sn : width);
  else if (eout && !ein) want(v, hin, sn > 1e-6 ? width / sn : width);
  else if (!ein && !eout) { want(v, hin, null); want(v, c, null); }
}
// make the slide points (clamped along their edge)
for (const s of slide.values()) {
  const v = s.v, h = s.h, far = m.hV[h] === v ? m.head(h) : m.hV[h];
  let d = s.n ? s.sum / s.n : width;
  const L = elen(h), cap = (V.has(far) ? 0.45 : 0.9) * L;
  if (d > cap) d = cap;
  s.vert = newVert(m, add(P3(m, v), mul(dirOf(v, far), d)), v);
}

// meet points of two bevelled edges in a face
for (const [v, cs] of corners) for (const c of cs) {
  const hin = m.hPv[c];
  if (!(isB(hin) && isB(c))) continue;
  const uOut = dirOf(v, m.head(c)), uIn = dirOf(v, m.hV[hin]);
  const sn = sinBetween(uIn, uOut);
  let k = sn > 1e-6 ? width / sn : width;
  const cap = 0.45 * Math.min(elen(c), elen(hin)) / Math.max(1e-9, len(add(uIn, uOut)) / 2 || 1);
  if (k > cap * 2) k = cap * 2;
  meets.set(c, newVert(m, add(P3(m, v), mul(add(uIn, uOut), k)), v));
}

const profilePts = (p0, p1, pc, from) => {
  const out = [];
  const M = lerp(p0, p1, 0.5), Q = add(M, mul(sub(pc, M), 2 * profile));
  for (let k = 1; k < segs; k++) {
    const t = k / segs, a = (1 - t) * (1 - t), b = 2 * t * (1 - t), c = t * t;
    out.push(newVert(m, add(add(mul(p0, a), mul(Q, b)), mul(p1, c)), from));
  }
  return out;
};

/** Shrink or fatten: every vertex along its normal (from the faces round it) by d. */
export function shrinkFatten(m, verts, d) {
  const N = vertexNormals(m);
  for (const v of verts) m.setPos(v, m.P[v * 3] + N[v * 3] * d, m.P[v * 3 + 1] + N[v * 3 + 1] * d, m.P[v * 3 + 2] + N[v * 3 + 2] * d);
}