@woosh/meep-engine 3.30.0 → 3.32.0

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_improve_quality.js

@@ -14,18 +14,35 @@ import {
 import {
     tetrahedral_mesh_vertex_is_boundary
 } from "./tetrahedral_mesh_vertex_is_boundary.js";
+import {
+    TET_FACE_VERTICES_BY_OPPOSITE,
+    TET_FLIP_23_LAYOUTS,
+    TET_FLIP_32_LAYOUTS
+} from "./tetrahedral_flip_layouts.js";
 import { tetrahedron_compute_quality } from "./tetrahedron_compute_quality.js";
 import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
 
-// Face-vertex layout for a positively-oriented tet (identical to the
-// table inside tetrahedral_mesh_flip_23.js). Inlined here so we can score
-// a hypothetical 2-3 flip without doing-and-undoing it on the live mesh.
-const FACE_VERTICES_BY_OPPOSITE = [
-    [1, 3, 2],
-    [0, 2, 3],
-    [0, 3, 1],
-    [0, 1, 2],
-];
+/**
+ * Quality of the tet a flip layout would produce, without performing the flip.
+ *
+ * @param {Float64Array|number[]} points
+ * @param {number[]} operands the flip's operand vertices, in the order its layout table indexes
+ * @param {number[]} layout one row of TET_FLIP_23_LAYOUTS or TET_FLIP_32_LAYOUTS
+ * @returns {number}
+ */
+function tet_quality_of_layout(points, operands, layout) {
+    return tetrahedron_compute_quality(
+        points,
+        operands[layout[0]],
+        operands[layout[1]],
+        operands[layout[2]],
+        operands[layout[3]]
+    );
+}
+
+// Operands of the flip currently being scored, in the order its layout table indexes them.
+const scratch_flip_23_operands = new Array(5);
+const scratch_flip_32_operands = new Array(5);
 
 // Scratch for the 2-3 / 3-2 flip out-parameters. Module-level — the driver
 // is not re-entrant.
@@ -120,11 +137,20 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
         // delete and re-introduce tet IDs underneath us.
         const live = mesh.getLive();
 
-        // Build a vertex->tets cache once per pass. Used by the boundary
-        // check (flip-invariant — safe to use for the whole pass) and by
-        // the local quality eval (filtered through mesh.exists; may miss
-        // newly-flipped tets which is fine: the live-snapshot iteration
-        // already misses them too, and they'll be picked up next pass).
+        /*
+         Build a vertex->tets cache once per pass. Used by the boundary check and by the local
+         quality eval; both confirm that the vertex is still in a tet before reading it, so a slot
+         a flip re-used with a different vertex set is skipped rather than believed.
+
+         A 2-3 flip also ALLOCATES a tet — it reuses two slots and takes a third — and that id is in
+         no bucket of a map built before it. This used to be argued away on the grounds that the
+         live-snapshot iteration misses those tets too, so they are picked up next pass. That covers
+         which tets get PROCESSED. It does not cover the accept/reject test: a smoothing move is
+         kept when it raises the min quality around the vertex, and a tet the map has never heard of
+         is absent from both the before and the after score, so a move that improves everything the
+         map knows about and inverts that one is accepted. The map is therefore kept up to date as
+         flips commit — see {@link record_tet_in_vertex_map}.
+        */
         const vertex_to_tets = tetrahedral_mesh_build_vertex_to_tets_map(mesh);
 
         for (let li = 0; li < live.length; li++) {
@@ -199,21 +225,34 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
                     // order.
                     const d = mesh.getVertexIndex(tet,           face_slot);
                     const e = mesh.getVertexIndex(neighbour_tet, shared_i2);
-                    const face = FACE_VERTICES_BY_OPPOSITE[face_slot];
+                    const face = TET_FACE_VERTICES_BY_OPPOSITE[face_slot];
                     const p = mesh.getVertexIndex(tet, face[0]);
                     const q = mesh.getVertexIndex(tet, face[1]);
                     const r = mesh.getVertexIndex(tet, face[2]);
 
-                    // Canonical layouts: T_α = (r, q, d, e); T_β = (p, r, d, e);
-                    // T_γ = (q, p, d, e). Mirrors tetrahedral_mesh_flip_23.
-                    const q_alpha = tetrahedron_compute_quality(points, r, q, d, e);
-                    const q_beta  = tetrahedron_compute_quality(points, p, r, d, e);
-                    const q_gamma = tetrahedron_compute_quality(points, q, p, d, e);
+                    // Scored through the same table tetrahedral_mesh_flip_23 applies, so the score is
+                    // of the flip that would actually be performed.
+                    scratch_flip_23_operands[0] = p;
+                    scratch_flip_23_operands[1] = q;
+                    scratch_flip_23_operands[2] = r;
+                    scratch_flip_23_operands[3] = d;
+                    scratch_flip_23_operands[4] = e;
+
+                    const q_alpha = tet_quality_of_layout(points, scratch_flip_23_operands, TET_FLIP_23_LAYOUTS[0]);
+                    const q_beta = tet_quality_of_layout(points, scratch_flip_23_operands, TET_FLIP_23_LAYOUTS[1]);
+                    const q_gamma = tet_quality_of_layout(points, scratch_flip_23_operands, TET_FLIP_23_LAYOUTS[2]);
                     const q_after = Math.min(q_alpha, q_beta, q_gamma);
 
                     if (q_after > q_before) {
                         // Commit: actually perform the flip.
                         tetrahedral_mesh_flip_23(mesh, tet, neighbour_tet, scratch_out_23);
+
+                        // the third of these is new; the other two are slots being re-used, and
+                        // their vertex sets have changed
+                        for (let k = 0; k < scratch_out_23.length; k++) {
+                            record_tet_in_vertex_map(mesh, vertex_to_tets, scratch_out_23[k]);
+                        }
+
                         stats.flips_23_committed++;
                         any_improvement = true;
                         // `tet` may have been re-used and now represents a
@@ -277,7 +316,7 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
                     // — present in r1 or r2 but not r0.
                     const slot_a_r0 = find_slot(mesh, r0, v_a);
                     const slot_b_r0 = find_slot(mesh, r0, v_b);
-                    const face_opp_b = FACE_VERTICES_BY_OPPOSITE[slot_b_r0];
+                    const face_opp_b = TET_FACE_VERTICES_BY_OPPOSITE[slot_b_r0];
                     const f0 = mesh.getVertexIndex(r0, face_opp_b[0]);
                     const f1 = mesh.getVertexIndex(r0, face_opp_b[1]);
                     const f2 = mesh.getVertexIndex(r0, face_opp_b[2]);
@@ -302,11 +341,15 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
                     }
                     if (v_missing < 0) continue; // shouldn't happen, but guard
 
-                    // Canonical new layouts (mirrors flip_32):
-                    //   new_tet_a = (v_X, v_missing, v_Y, v_a)
-                    //   new_tet_b = (v_X, v_Y, v_missing, v_b)
-                    const q_new_a = tetrahedron_compute_quality(points, v_X, v_missing, v_Y, v_a);
-                    const q_new_b = tetrahedron_compute_quality(points, v_X, v_Y, v_missing, v_b);
+                    // Scored through the same table tetrahedral_mesh_flip_32 applies.
+                    scratch_flip_32_operands[0] = v_X;
+                    scratch_flip_32_operands[1] = v_Y;
+                    scratch_flip_32_operands[2] = v_missing;
+                    scratch_flip_32_operands[3] = v_a;
+                    scratch_flip_32_operands[4] = v_b;
+
+                    const q_new_a = tet_quality_of_layout(points, scratch_flip_32_operands, TET_FLIP_32_LAYOUTS[0]);
+                    const q_new_b = tet_quality_of_layout(points, scratch_flip_32_operands, TET_FLIP_32_LAYOUTS[1]);
                     const q_after_32 = Math.min(q_new_a, q_new_b);
 
                     if (q_after_32 > q_before_32) {
@@ -351,6 +394,33 @@ function scan_min_quality(mesh, points) {
     return min_q;
 }
 
+/**
+ * Add a tet to the buckets of the four vertices it contains, so that everything reading the
+ * pass-level vertex->tets map can see it.
+ *
+ * For a tet a flip created after the map was built this is the only way it is ever seen: the map is
+ * built once per pass and both readers walk buckets. For one whose slot a flip re-used, the id is
+ * already in the buckets of the vertices it USED to have — which both readers skip, because they
+ * confirm incidence — and this puts it in the buckets of the ones it has now.
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {Map<number, number[]>} vertex_to_tets
+ * @param {number} tet
+ */
+function record_tet_in_vertex_map(mesh, vertex_to_tets, tet) {
+    for (let i = 0; i < 4; i++) {
+        const v_id = mesh.getVertexIndex(tet, i);
+
+        const tets = vertex_to_tets.get(v_id);
+
+        if (tets === undefined) {
+            vertex_to_tets.set(v_id, [tet]);
+        } else if (!tets.includes(tet)) {
+            tets.push(tet);
+        }
+    }
+}
+
 /**
  * Min quality across all tets containing `v_id`. Used to score the local
  * effect of moving (or undoing the move of) a single vertex.

package/src/core/geom/3d/tetrahedra/tetrahedron_contains_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tetrahedron_contains_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_contains_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,mDARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CASnB"}
+{"version":3,"file":"tetrahedron_contains_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_contains_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,mDARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAoBnB"}

package/src/core/geom/3d/tetrahedra/tetrahedron_contains_point.js

@@ -17,10 +17,21 @@ import { orient3d_fast } from "../plane/orient3d_fast.js";
  * @returns {boolean}
  */
 export function tetrahedron_contains_point(points, a, b, c, d, e) {
-    return !(
-        orient3d_fast(points, b, d, c, e) > 0
-        || orient3d_fast(points, c, d, a, e) > 0
-        || orient3d_fast(points, d, b, a, e) > 0
-        || orient3d_fast(points, a, b, c, e) > 0
-    );
+    const v_a = orient3d_fast(points, b, d, c, e);
+    const v_b = orient3d_fast(points, c, d, a, e);
+    const v_c = orient3d_fast(points, d, b, a, e);
+    const v_d = orient3d_fast(points, a, b, c, e);
+
+    // Winding-agnostic: the point is interior when it lies on the same side of all four faces,
+    // whatever sign that side carries. Rejecting on `> 0` alone assumed a clockwise tet, which is
+    // the opposite of what every tet producer in this package emits and of the convention
+    // `TetrahedralMesh.walkToTetraContainingPoint` steps by - so for a positively-wound tet the
+    // answer was inverted. `MeshShape3D` already carries a private copy of this test for exactly
+    // that reason.
+    //
+    // A zero counts as inside under either sign, so a point on a face is contained.
+    const all_non_negative = v_a >= 0 && v_b >= 0 && v_c >= 0 && v_d >= 0;
+    const all_non_positive = v_a <= 0 && v_b <= 0 && v_c <= 0 && v_d <= 0;
+
+    return all_non_negative || all_non_positive;
 }

package/src/core/geom/3d/topology/struct/binary/io/bt_boundary_loop.d.ts

@@ -21,4 +21,31 @@
  * @copyright Company Named Limited (c) 2026
  */
 export function bt_boundary_loop_order_from(mesh: BinaryTopology, cycle: number[] | Uint32Array, start_vertex: number, out_vertices: number[] | Uint32Array, out_edges: number[] | Uint32Array): void;
+/**
+ * Close one boundary hole: order its cycle, allocate an n-gon face over it, and fan that face from the
+ * hole's centroid, which adds a Steiner vertex and replaces the n-gon with n triangles.
+ *
+ * ## The winding, and what it depends on
+ *
+ * Each new loop on a boundary edge must wind **opposite** the existing loop, so the shared edge ends up
+ * with consistent radial orientation. That is what the start-vertex choice below buys: the seed edge's
+ * existing loop names one of its two endpoints, and the fill starts at the *other* one.
+ *
+ * It works because {@link bt_boundary_loop_order_from} takes `start_vertex`'s first incident edge out of
+ * its bucket and walks from there, so the order it produces leaves `start_vertex` along an edge, in the
+ * direction opposite to the existing loop's traversal of the seed edge. Change how that walk picks its
+ * first edge and the fill face winds the wrong way — which is why the two live in one file.
+ *
+ * The face normal stays zero; downstream tetrahedralization is position-only.
+ *
+ * `bt_mesh_close_boundary_holes` and `bt_mesh_fill_small_holes` each carried a copy of this — forty
+ * lines, identical in every step — and only the ordering walk above had been lifted out of them.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number[]|Uint32Array} cycle unordered boundary edge ids forming one closed loop
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_boundary_loop_fan_fill(mesh: BinaryTopology, cycle: number[] | Uint32Array): void;
 //# sourceMappingURL=bt_boundary_loop.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_boundary_loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_boundary_loop.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_boundary_loop.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yEARW,MAAM,EAAE,GAAC,WAAW,gBACpB,MAAM,gBACN,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,EAAE,GAAC,WAAW,QAuD9B"}
+{"version":3,"file":"bt_boundary_loop.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_boundary_loop.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yEARW,MAAM,EAAE,GAAC,WAAW,gBACpB,MAAM,gBACN,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,EAAE,GAAC,WAAW,QAuD9B;AAeD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEALW,MAAM,EAAE,GAAC,WAAW,QA8D9B"}

package/src/core/geom/3d/topology/struct/binary/io/bt_boundary_loop.js

@@ -1,3 +1,6 @@
+import { bt_face_poke } from "./face/bt_face_poke.js";
+import { bt_radial_loop_add } from "./bt_radial_loop_add.js";
+
 /**
  * Walk an unordered set of boundary edges forming a single closed cycle into traversal order, starting at
  * `start_vertex`.
@@ -71,3 +74,101 @@ export function bt_boundary_loop_order_from(mesh, cycle, start_vertex, out_verti
         e_prev = e_next;
     }
 }
+
+/**
+ * Scratch for {@link bt_boundary_loop_fan_fill}. Module-static because the fill is called once per hole
+ * and nothing it calls re-enters it.
+ * @type {number[]}
+ */
+const scratch_coord = [0, 0, 0];
+
+/** @type {number[]} */
+const scratch_ordered_vertices = [];
+
+/** @type {number[]} */
+const scratch_ordered_edges = [];
+
+/**
+ * Close one boundary hole: order its cycle, allocate an n-gon face over it, and fan that face from the
+ * hole's centroid, which adds a Steiner vertex and replaces the n-gon with n triangles.
+ *
+ * ## The winding, and what it depends on
+ *
+ * Each new loop on a boundary edge must wind **opposite** the existing loop, so the shared edge ends up
+ * with consistent radial orientation. That is what the start-vertex choice below buys: the seed edge's
+ * existing loop names one of its two endpoints, and the fill starts at the *other* one.
+ *
+ * It works because {@link bt_boundary_loop_order_from} takes `start_vertex`'s first incident edge out of
+ * its bucket and walks from there, so the order it produces leaves `start_vertex` along an edge, in the
+ * direction opposite to the existing loop's traversal of the seed edge. Change how that walk picks its
+ * first edge and the fill face winds the wrong way — which is why the two live in one file.
+ *
+ * The face normal stays zero; downstream tetrahedralization is position-only.
+ *
+ * `bt_mesh_close_boundary_holes` and `bt_mesh_fill_small_holes` each carried a copy of this — forty
+ * lines, identical in every step — and only the ordering walk above had been lifted out of them.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number[]|Uint32Array} cycle unordered boundary edge ids forming one closed loop
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_boundary_loop_fan_fill(mesh, cycle) {
+    const n = cycle.length;
+
+    const seed_edge = cycle[0];
+    const seed_loop = mesh.edge_read_loop(seed_edge);
+    const existing_loop_vertex = mesh.loop_read_vertex(seed_loop);
+    const seed_v1 = mesh.edge_read_vertex1(seed_edge);
+    const seed_v2 = mesh.edge_read_vertex2(seed_edge);
+    const start_vertex = (existing_loop_vertex === seed_v1) ? seed_v2 : seed_v1;
+
+    const ordered_vertices = scratch_ordered_vertices;
+    const ordered_edges = scratch_ordered_edges;
+
+    ordered_vertices.length = n;
+    ordered_edges.length = n;
+
+    bt_boundary_loop_order_from(mesh, cycle, start_vertex, ordered_vertices, ordered_edges);
+
+    // Compute centroid of the hole's vertices.
+    let cx = 0, cy = 0, cz = 0;
+
+    for (let i = 0; i < n; i++) {
+        mesh.vertex_read_coordinate(scratch_coord, 0, ordered_vertices[i]);
+
+        cx += scratch_coord[0];
+        cy += scratch_coord[1];
+        cz += scratch_coord[2];
+    }
+
+    cx /= n;
+    cy /= n;
+    cz /= n;
+
+    // Allocate a new face plus n loops, wire them into the face cycle and each boundary edge's radial
+    // cycle.
+    const new_face = mesh.face_create();
+
+    const loops = new Array(n);
+
+    for (let i = 0; i < n; i++) {
+        loops[i] = mesh.loop_create();
+
+        mesh.loop_write_vertex(loops[i], ordered_vertices[i]);
+        mesh.loop_write_face(loops[i], new_face);
+
+        bt_radial_loop_add(mesh, loops[i], ordered_edges[i]);
+    }
+
+    for (let i = 0; i < n; i++) {
+        mesh.loop_write_next(loops[i], loops[(i + 1) % n]);
+        mesh.loop_write_prev(loops[i], loops[(i - 1 + n) % n]);
+    }
+
+    mesh.face_write_loop(new_face, loops[0]);
+
+    // Fan from centroid — adds the Steiner vertex and replaces the n-gon face with n triangles.
+    bt_face_poke(mesh, new_face, cx, cy, cz);
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.d.ts

@@ -10,6 +10,9 @@
  * Throws if any boundary vertex has more than two boundary edges (figure-8 /
  * pinched boundaries). Mutates the mesh in place.
  *
+ * The per-hole fill is {@link bt_boundary_loop_fan_fill}, which {@link bt_mesh_fill_small_holes} also
+ * runs — the two used to carry a copy of it each, and the winding argument with it.
+ *
  * @param {BinaryTopology} mesh
  * @returns {number} number of boundary holes that were closed
  */

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_close_boundary_holes.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,oEAFa,MAAM,CA8DlB"}
+{"version":3,"file":"bt_mesh_close_boundary_holes.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,oEAFa,MAAM,CAWlB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.js

@@ -1,9 +1,5 @@
-import { bt_boundary_loop_order_from } from "./bt_boundary_loop.js";
+import { bt_boundary_loop_fan_fill } from "./bt_boundary_loop.js";
 import { bt_mesh_walk_boundary_loops } from "../query/bt_mesh_walk_boundary_loops.js";
-import { bt_face_poke } from "./face/bt_face_poke.js";
-import { bt_radial_loop_add } from "./bt_radial_loop_add.js";
-
-const scratch_coord = [0, 0, 0];
 
 
 /**
@@ -18,66 +14,18 @@ const scratch_coord = [0, 0, 0];
  * Throws if any boundary vertex has more than two boundary edges (figure-8 /
  * pinched boundaries). Mutates the mesh in place.
  *
+ * The per-hole fill is {@link bt_boundary_loop_fan_fill}, which {@link bt_mesh_fill_small_holes} also
+ * runs — the two used to carry a copy of it each, and the winding argument with it.
+ *
  * @param {BinaryTopology} mesh
  * @returns {number} number of boundary holes that were closed
  */
 export function bt_mesh_close_boundary_holes(mesh) {
     const cycles = bt_mesh_walk_boundary_loops(mesh);
 
-    const ordered_vertices = [];
-    const ordered_edges = [];
 
     for (const cycle of cycles) {
-        const n = cycle.length;
-
-        // Each new loop on a boundary edge must wind opposite the existing
-        // loop, so the shared edge ends up with consistent radial orientation.
-        const seed_edge = cycle[0];
-        const seed_loop = mesh.edge_read_loop(seed_edge);
-        const existing_loop_vertex = mesh.loop_read_vertex(seed_loop);
-        const seed_v1 = mesh.edge_read_vertex1(seed_edge);
-        const seed_v2 = mesh.edge_read_vertex2(seed_edge);
-        const start_vertex = (existing_loop_vertex === seed_v1) ? seed_v2 : seed_v1;
-
-        ordered_vertices.length = n;
-        ordered_edges.length = n;
-        bt_boundary_loop_order_from(mesh, cycle, start_vertex, ordered_vertices, ordered_edges);
-
-        // Compute centroid of the hole's vertices.
-        let cx = 0, cy = 0, cz = 0;
-        for (let i = 0; i < n; i++) {
-            mesh.vertex_read_coordinate(scratch_coord, 0, ordered_vertices[i]);
-            cx += scratch_coord[0];
-            cy += scratch_coord[1];
-            cz += scratch_coord[2];
-        }
-        cx /= n;
-        cy /= n;
-        cz /= n;
-
-        // Allocate a new face plus n loops, wire them into the face cycle and
-        // each boundary edge's radial cycle. Face normal stays zero; downstream
-        // tetrahedralization is position-only.
-        const new_face = mesh.face_create();
-
-        const loops = new Array(n);
-        for (let i = 0; i < n; i++) {
-            loops[i] = mesh.loop_create();
-            mesh.loop_write_vertex(loops[i], ordered_vertices[i]);
-            mesh.loop_write_face(loops[i], new_face);
-            bt_radial_loop_add(mesh, loops[i], ordered_edges[i]);
-        }
-
-        for (let i = 0; i < n; i++) {
-            mesh.loop_write_next(loops[i], loops[(i + 1) % n]);
-            mesh.loop_write_prev(loops[i], loops[(i - 1 + n) % n]);
-        }
-
-        mesh.face_write_loop(new_face, loops[0]);
-
-        // Fan from centroid — adds the Steiner vertex and replaces the n-gon
-        // face with n triangles.
-        bt_face_poke(mesh, new_face, cx, cy, cz);
+        bt_boundary_loop_fan_fill(mesh, cycle);
     }
 
     return cycles.length;

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_compute_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAHa,QAAQ,EAAE,CAgHtB;yBA1KwB,iCAAiC"}
+{"version":3,"file":"bt_mesh_compute_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAHa,QAAQ,EAAE,CAgHtB;yBA1KwB,iCAAiC"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.js

@@ -1,3 +1,4 @@
+import { bt_edge_count_faces } from "../query/bt_edge_count_faces.js";
 import { quadric3_set_from_plane_through_point } from "../../../../quadric/quadric3_set_from_plane_through_point.js";
 import { assert } from "../../../../../../assert.js";
 import { v3_dot } from "../../../../../vec3/v3_dot.js";
@@ -174,39 +175,6 @@ export function bt_mesh_compute_vertex_quadrics(mesh) {
 
     return quadratics;
 }
-
-/**
- * How many live faces an edge carries.
- *
- * @param {BinaryTopology} mesh
- * @param {number} edge
- * @returns {number}
- */
-function count_edge_faces(mesh, edge) {
-    const first = mesh.edge_read_loop(edge);
-
-    if (first === NULL_POINTER) {
-        return 0;
-    }
-
-    const face_pool = mesh.faces;
-
-    let count = 0;
-    let loop = first;
-
-    do {
-        const face = mesh.loop_read_face(loop);
-
-        if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
-            count++;
-        }
-
-        loop = mesh.loop_read_radial_next(loop);
-    } while (loop !== first && loop !== NULL_POINTER);
-
-    return count;
-}
-
 /**
  * Constrain the face's open edges, so that the surface's border is not free to retreat for nothing.
  *
@@ -244,7 +212,7 @@ function add_boundary_constraints(mesh, quadratics, face, nx, ny, nz, area) {
     do {
         const edge = mesh.loop_read_edge(loop);
 
-        if (count_edge_faces(mesh, edge) === 2) {
+        if (bt_edge_count_faces(mesh, edge) === 2) {
             loop = mesh.loop_read_next(loop);
 
             continue;

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_fill_small_holes.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;;;GAYG;AACH,0EAHW,MAAM,GACJ,MAAM,CA2ClB"}
+{"version":3,"file":"bt_mesh_fill_small_holes.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;GAYG;AACH,0EAHW,MAAM,GACJ,MAAM,CA2ClB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js

@@ -1,9 +1,6 @@
-import { bt_boundary_loop_order_from } from "./bt_boundary_loop.js";
+import { bt_boundary_loop_fan_fill, bt_boundary_loop_order_from } from "./bt_boundary_loop.js";
 import { bt_mesh_walk_boundary_loops } from "../query/bt_mesh_walk_boundary_loops.js";
-import { bt_face_poke } from "./face/bt_face_poke.js";
-import { bt_radial_loop_add } from "./bt_radial_loop_add.js";
 
-const _c = [0, 0, 0];
 const _p = [0, 0, 0];
 const _q = [0, 0, 0];
 
@@ -25,44 +22,6 @@ function loop_perimeter_and_area(mesh, verts) {
     const area = 0.5 * Math.hypot(nx, ny, nz);
     return { perimeter, area };
 }
-
-/** Fan-fill a single boundary loop (n-gon face + centroid poke), as close_boundary_holes does. */
-function fill_loop(mesh, cycle) {
-    const n = cycle.length;
-    const seed_edge = cycle[0];
-    const seed_loop = mesh.edge_read_loop(seed_edge);
-    const existing_loop_vertex = mesh.loop_read_vertex(seed_loop);
-    const seed_v1 = mesh.edge_read_vertex1(seed_edge);
-    const seed_v2 = mesh.edge_read_vertex2(seed_edge);
-    const start_vertex = (existing_loop_vertex === seed_v1) ? seed_v2 : seed_v1;
-
-    const ordered_vertices = new Array(n);
-    const ordered_edges = new Array(n);
-    bt_boundary_loop_order_from(mesh, cycle, start_vertex, ordered_vertices, ordered_edges);
-
-    let cx = 0, cy = 0, cz = 0;
-    for (let i = 0; i < n; i++) {
-        mesh.vertex_read_coordinate(_c, 0, ordered_vertices[i]);
-        cx += _c[0]; cy += _c[1]; cz += _c[2];
-    }
-    cx /= n; cy /= n; cz /= n;
-
-    const new_face = mesh.face_create();
-    const loops = new Array(n);
-    for (let i = 0; i < n; i++) {
-        loops[i] = mesh.loop_create();
-        mesh.loop_write_vertex(loops[i], ordered_vertices[i]);
-        mesh.loop_write_face(loops[i], new_face);
-        bt_radial_loop_add(mesh, loops[i], ordered_edges[i]);
-    }
-    for (let i = 0; i < n; i++) {
-        mesh.loop_write_next(loops[i], loops[(i + 1) % n]);
-        mesh.loop_write_prev(loops[i], loops[(i - 1 + n) % n]);
-    }
-    mesh.face_write_loop(new_face, loops[0]);
-    bt_face_poke(mesh, new_face, cx, cy, cz);
-}
-
 /**
  * Fill inner boundary holes whose mean width falls below `min_width`.
  *
@@ -111,7 +70,7 @@ export function bt_mesh_fill_small_holes(mesh, min_width) {
         if (perimeter <= 0) continue;
         // mean width of the hole = 2*area/perimeter; fill when it is below the requested threshold
         if (2 * area / perimeter < min_width) {
-            fill_loop(mesh, cycles[i]);
+            bt_boundary_loop_fan_fill(mesh, cycles[i]);
             filled++;
         }
     }