Section caps: which elements are closed solids

/** Element ids (triIds[t] for triangle t of `indices`) whose triangles do not make a closed surface. */
export function openElements(positions, indices, triIds) {
  const nV = positions.length / 3;
  // One id per distinct position, so split vertices meet again.
  const canon = new Int32Array(nV);
  const seen = new Map();
  for (let v = 0; v < nV; v++) {
    const k = Math.round(positions[v * 3] * Q) + ',' + Math.round(positions[v * 3 + 1] * Q) + ',' + Math.round(positions[v * 3 + 2] * Q);
    let id = seen.get(k);
    if (id === undefined) { id = seen.size; seen.set(k, id); }
    canon[v] = id;
  }
  const nP = seen.size;
  // Triangles by element.
  const byEl = new Map();
  const nT = indices.length / 3;
  for (let t = 0; t < nT; t++) {
    const e = triIds[t];
    let l = byEl.get(e);
    if (!l) { l = []; byEl.set(e, l); }
    l.push(t);
  }
  const open = new Set();
  const edges = new Map();
  for (const [e, tris] of byEl) {
    edges.clear();
    for (const t of tris) {
      const a = canon[indices[t * 3]], b = canon[indices[t * 3 + 1]], c = canon[indices[t * 3 + 2]];
      for (const [p, q] of [[a, b], [b, c], [c, a]]) {
        if (p === q) continue;   // a degenerate edge adds nothing
        const key = p < q ? p * nP + q : q * nP + p;
        edges.set(key, (edges.get(key) || 0) + 1);
      }
    }
    for (const n of edges.values()) if (n % 2) { open.add(e); break; }
  }
  return open;
}

/** Element ids open over every batch they are in (the stencil passes count all batches into one buffer). */
export function openAcross(batches) {
  const open = new Set(), seen = new Map();   // element id → number of batches it is in
  const idsOf = (b) => (b.elems ? b.elems.ids : new Set(b.triIds));
  for (const b of batches) {
    for (const e of openElements(b.positions, b.indices, b.triIds)) open.add(e);
    for (const e of new Set(idsOf(b))) seen.set(e, (seen.get(e) || 0) + 1);
  }
  const again = new Set([...open].filter((e) => seen.get(e) > 1));
  if (!again.size) return open;
  // their triangles from every batch, unindexed (openElements meets the corners again by position)
  const pos = [], ids = [];
  for (const b of batches) {
    const P = b.positions, I = b.indices, T = b.triIds;
    for (let t = 0; t < T.length; t++) {
      if (!again.has(T[t])) continue;
      for (let k = 0; k < 3; k++) { const v = I[t * 3 + k] * 3; pos.push(P[v], P[v + 1], P[v + 2]); }
      ids.push(T[t]);
    }
  }
  const still = openElements(Float32Array.from(pos), Uint32Array.from({ length: pos.length / 3 }, (_, i) => i), ids);
  for (const e of again) if (!still.has(e)) open.delete(e);
  return open;
}