@woosh/meep-engine 3.0.2 → 3.2.0

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

@@ -1,83 +1,83 @@
-import { NULL_POINTER } from "../../BinaryTopology.js";
-import { bt_disk_edge_remove } from "../bt_disk_edge_remove.js";
-import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
-import { bt_radial_loop_remove } from "../bt_radial_loop_remove.js";
-import { bt_kill_only_edge } from "./bt_kill_only_edge.js";
-
-/**
- * Walk the mesh and fuse any pair of edges that share the same endpoint pair into a single edge.
- *
- * When two edges connect the same vertices, all loops on the victim are moved into the master's
- * radial cycle, the victim is removed from both endpoint disk cycles, and the victim edge is
- * deallocated. This restores the topology invariant that a vertex pair is represented by at most
- * one edge — which is what loop/face neighbour queries rely on.
- *
- * Degenerate edges (v1 === v2) are left alone; callers that want those removed should run a
- * dedicated pass.
- *
- * Typically used after {@link bt_merge_verts_by_distance}, which re-points vertex references but
- * can leave behind multiple edges sharing the same endpoint pair.
- *
- * @param {BinaryTopology} mesh
- * @returns {number} number of edges fused away
- */
-export function bt_mesh_fuse_duplicate_edges(mesh) {
-    const edges = mesh.edges;
-    const edge_count = edges.size;
-
-    let removed_count = 0;
-
-    for (let master = 0; master < edge_count; master++) {
-        if (edges.is_allocated(master) === false) {
-            continue;
-        }
-
-        const master_v1 = mesh.edge_read_vertex1(master);
-        const master_v2 = mesh.edge_read_vertex2(master);
-
-        if (master_v1 === master_v2) {
-            // degenerate edge; skip
-            continue;
-        }
-
-        // walk master_v1's disk cycle, fusing any edge that also connects to master_v2
-        let curr = mesh.edge_read_v1_disk_next(master);
-
-        while (curr !== master) {
-
-            const curr_v1 = mesh.edge_read_vertex1(curr);
-            const curr_v2 = mesh.edge_read_vertex2(curr);
-
-            const curr_on_v1 = curr_v1 === master_v1;
-
-            // capture next before we potentially splice curr out of the disk cycle
-            const next = curr_on_v1
-                ? mesh.edge_read_v1_disk_next(curr)
-                : mesh.edge_read_v2_disk_next(curr);
-
-            const other_endpoint = curr_on_v1 ? curr_v2 : curr_v1;
-
-            if (other_endpoint === master_v2) {
-
-                // move every loop on curr into master's radial cycle
-                let l = mesh.edge_read_loop(curr);
-                while (l !== NULL_POINTER) {
-                    bt_radial_loop_remove(mesh, l, curr);
-                    bt_radial_loop_add(mesh, l, master);
-                    l = mesh.edge_read_loop(curr);
-                }
-
-                bt_disk_edge_remove(mesh, curr, master_v1);
-                bt_disk_edge_remove(mesh, curr, master_v2);
-
-                bt_kill_only_edge(mesh, curr);
-
-                removed_count++;
-            }
-
-            curr = next;
-        }
-    }
-
-    return removed_count;
-}
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_disk_edge_remove } from "../bt_disk_edge_remove.js";
+import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
+import { bt_radial_loop_remove } from "../bt_radial_loop_remove.js";
+import { bt_kill_only_edge } from "./bt_kill_only_edge.js";
+
+/**
+ * Walk the mesh and fuse any pair of edges that share the same endpoint pair into a single edge.
+ *
+ * When two edges connect the same vertices, all loops on the victim are moved into the master's
+ * radial cycle, the victim is removed from both endpoint disk cycles, and the victim edge is
+ * deallocated. This restores the topology invariant that a vertex pair is represented by at most
+ * one edge — which is what loop/face neighbour queries rely on.
+ *
+ * Degenerate edges (v1 === v2) are left alone; callers that want those removed should run a
+ * dedicated pass.
+ *
+ * Typically used after {@link bt_merge_verts_by_distance}, which re-points vertex references but
+ * can leave behind multiple edges sharing the same endpoint pair.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number} number of edges fused away
+ */
+export function bt_mesh_fuse_duplicate_edges(mesh) {
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+
+    let removed_count = 0;
+
+    for (let master = 0; master < edge_count; master++) {
+        if (edges.is_allocated(master) === false) {
+            continue;
+        }
+
+        const master_v1 = mesh.edge_read_vertex1(master);
+        const master_v2 = mesh.edge_read_vertex2(master);
+
+        if (master_v1 === master_v2) {
+            // degenerate edge; skip
+            continue;
+        }
+
+        // walk master_v1's disk cycle, fusing any edge that also connects to master_v2
+        let curr = mesh.edge_read_v1_disk_next(master);
+
+        while (curr !== master) {
+
+            const curr_v1 = mesh.edge_read_vertex1(curr);
+            const curr_v2 = mesh.edge_read_vertex2(curr);
+
+            const curr_on_v1 = curr_v1 === master_v1;
+
+            // capture next before we potentially splice curr out of the disk cycle
+            const next = curr_on_v1
+                ? mesh.edge_read_v1_disk_next(curr)
+                : mesh.edge_read_v2_disk_next(curr);
+
+            const other_endpoint = curr_on_v1 ? curr_v2 : curr_v1;
+
+            if (other_endpoint === master_v2) {
+
+                // move every loop on curr into master's radial cycle
+                let l = mesh.edge_read_loop(curr);
+                while (l !== NULL_POINTER) {
+                    bt_radial_loop_remove(mesh, l, curr);
+                    bt_radial_loop_add(mesh, l, master);
+                    l = mesh.edge_read_loop(curr);
+                }
+
+                bt_disk_edge_remove(mesh, curr, master_v1);
+                bt_disk_edge_remove(mesh, curr, master_v2);
+
+                bt_kill_only_edge(mesh, curr);
+
+                removed_count++;
+            }
+
+            curr = next;
+        }
+    }
+
+    return removed_count;
+}

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

@@ -1,89 +1,89 @@
-import { assert } from "../../../../../../../assert.js";
-import { v3_distance_sqr } from "../../../../../../vec3/v3_distance_sqr.js";
-import {
-    bt_mesh_vertex_merge_distance
-} from "../vertex/bt_mesh_vertex_merge_distance.js";
-import { bt_edge_kill } from "./bt_edge_kill.js";
-
-const scratch_a = [0, 0, 0];
-const scratch_b = [0, 0, 0];
-
-/**
- * Kill every edge whose endpoints are within `max_distance` of each other —
- * including any pre-existing self-loops (v1 === v2). Adjacent faces are
- * cascaded through {@link bt_edge_kill}, so a sliver triangle (one short
- * edge, two longer ones) loses the short edge and its face here, and the
- * other two edges are left orphan for the standard cleanup pass to remove.
- *
- * The intended pre-pass before {@link bt_merge_verts_by_distance}. The merge
- * uses `bt_vertex_replace` internally, which produces a self-loop edge if
- * the two vertices it's collapsing are directly edge-connected — and
- * self-loops corrupt the disk cycle in ways that hang the downstream
- * `bt_mesh_fuse_duplicate_edges` walker. Killing the short edges up front
- * means the merge never sees a direct-edge pair, so it never produces a
- * self-loop, so the fuse pass terminates cleanly.
- *
- * It also means the merge never collapses two vertices of a surviving face:
- * that would leave the face's loop cycle visiting one vertex twice, stacking
- * two of its loops onto a single edge — a non-manifold edge no boundary walk
- * can get through, from a face that had already shrunk below the resolution
- * the mesh can store it at.
- *
- * `max_distance` is therefore read through
- * {@link bt_mesh_vertex_merge_distance}, so this pass and the merge agree
- * exactly on which endpoints are one point. Asking the nominal question when
- * the merge asks the floored one leaves precisely the pairs between the two
- * thresholds — which are the ones the merge then collapses.
- *
- * @param {BinaryTopology} mesh
- * @param {number} [max_distance] inclusive endpoint distance; defaults match
- *                                {@link bt_merge_verts_by_distance}
- * @returns {number} number of edges killed
- */
-export function bt_mesh_kill_short_edges(mesh, max_distance = 0.0001) {
-    assert.defined(mesh, "mesh");
-    assert.greaterThan(max_distance, 0, "max_distance must be greater than 0");
-
-    const kill_distance = bt_mesh_vertex_merge_distance(mesh, max_distance);
-    const max_distance_sqr = kill_distance * kill_distance;
-
-    const edge_pool = mesh.edges;
-    const edge_count = edge_pool.size;
-
-    // Collect victims first, kill after — bt_edge_kill mutates disk cycles and
-    // face pools, so iterating the pool while mutating it is fragile.
-    const victims = [];
-
-    for (let e = 0; e < edge_count; e++) {
-        if (!edge_pool.is_allocated(e)) continue;
-
-        const v1 = mesh.edge_read_vertex1(e);
-        const v2 = mesh.edge_read_vertex2(e);
-
-        if (v1 === v2) {
-            victims.push(e);
-            continue;
-        }
-
-        mesh.vertex_read_coordinate(scratch_a, 0, v1);
-        mesh.vertex_read_coordinate(scratch_b, 0, v2);
-
-        const d2 = v3_distance_sqr(
-            scratch_a[0], scratch_a[1], scratch_a[2],
-            scratch_b[0], scratch_b[1], scratch_b[2],
-        );
-
-        if (d2 <= max_distance_sqr) {
-            victims.push(e);
-        }
-    }
-
-    for (let i = 0; i < victims.length; i++) {
-        const e = victims[i];
-        if (edge_pool.is_allocated(e)) {
-            bt_edge_kill(mesh, e);
-        }
-    }
-
-    return victims.length;
-}
+import { assert } from "../../../../../../../assert.js";
+import { v3_distance_sqr } from "../../../../../../vec3/v3_distance_sqr.js";
+import {
+    bt_mesh_vertex_merge_distance
+} from "../vertex/bt_mesh_vertex_merge_distance.js";
+import { bt_edge_kill } from "./bt_edge_kill.js";
+
+const scratch_a = [0, 0, 0];
+const scratch_b = [0, 0, 0];
+
+/**
+ * Kill every edge whose endpoints are within `max_distance` of each other —
+ * including any pre-existing self-loops (v1 === v2). Adjacent faces are
+ * cascaded through {@link bt_edge_kill}, so a sliver triangle (one short
+ * edge, two longer ones) loses the short edge and its face here, and the
+ * other two edges are left orphan for the standard cleanup pass to remove.
+ *
+ * The intended pre-pass before {@link bt_merge_verts_by_distance}. The merge
+ * uses `bt_vertex_replace` internally, which produces a self-loop edge if
+ * the two vertices it's collapsing are directly edge-connected — and
+ * self-loops corrupt the disk cycle in ways that hang the downstream
+ * `bt_mesh_fuse_duplicate_edges` walker. Killing the short edges up front
+ * means the merge never sees a direct-edge pair, so it never produces a
+ * self-loop, so the fuse pass terminates cleanly.
+ *
+ * It also means the merge never collapses two vertices of a surviving face:
+ * that would leave the face's loop cycle visiting one vertex twice, stacking
+ * two of its loops onto a single edge — a non-manifold edge no boundary walk
+ * can get through, from a face that had already shrunk below the resolution
+ * the mesh can store it at.
+ *
+ * `max_distance` is therefore read through
+ * {@link bt_mesh_vertex_merge_distance}, so this pass and the merge agree
+ * exactly on which endpoints are one point. Asking the nominal question when
+ * the merge asks the floored one leaves precisely the pairs between the two
+ * thresholds — which are the ones the merge then collapses.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} [max_distance] inclusive endpoint distance; defaults match
+ *                                {@link bt_merge_verts_by_distance}
+ * @returns {number} number of edges killed
+ */
+export function bt_mesh_kill_short_edges(mesh, max_distance = 0.0001) {
+    assert.defined(mesh, "mesh");
+    assert.greaterThan(max_distance, 0, "max_distance must be greater than 0");
+
+    const kill_distance = bt_mesh_vertex_merge_distance(mesh, max_distance);
+    const max_distance_sqr = kill_distance * kill_distance;
+
+    const edge_pool = mesh.edges;
+    const edge_count = edge_pool.size;
+
+    // Collect victims first, kill after — bt_edge_kill mutates disk cycles and
+    // face pools, so iterating the pool while mutating it is fragile.
+    const victims = [];
+
+    for (let e = 0; e < edge_count; e++) {
+        if (!edge_pool.is_allocated(e)) continue;
+
+        const v1 = mesh.edge_read_vertex1(e);
+        const v2 = mesh.edge_read_vertex2(e);
+
+        if (v1 === v2) {
+            victims.push(e);
+            continue;
+        }
+
+        mesh.vertex_read_coordinate(scratch_a, 0, v1);
+        mesh.vertex_read_coordinate(scratch_b, 0, v2);
+
+        const d2 = v3_distance_sqr(
+            scratch_a[0], scratch_a[1], scratch_a[2],
+            scratch_b[0], scratch_b[1], scratch_b[2],
+        );
+
+        if (d2 <= max_distance_sqr) {
+            victims.push(e);
+        }
+    }
+
+    for (let i = 0; i < victims.length; i++) {
+        const e = victims[i];
+        if (edge_pool.is_allocated(e)) {
+            bt_edge_kill(mesh, e);
+        }
+    }
+
+    return victims.length;
+}

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

@@ -1,26 +1,26 @@
-import { assert } from "../../../../../../../assert.js";
-import { NULL_POINTER } from "../../BinaryTopology.js";
-import { bt_loop_kill } from "../bt_loop_kill.js";
-
-/**
- * Safely removes a face from the topology.
- * Iteratively untangles and frees all its loops, then releases the face memory.
- * @param {BinaryTopology} mesh
- * @param {number} f Face ID
- */
-export function bt_face_kill(mesh, f) {
-    assert.isNonNegativeInteger(f, 'f');
-
-    let l = NULL_POINTER;
-
-    // TODO add a cycle limit to avoid infinite loops on bad topologies
-
-    // bt_loop_kill automatically updates the face's base loop pointer to the
-    // next loop, or to NULL_POINTER if it's the last loop in the cycle.
-    while ((l = mesh.face_read_loop(f)) !== NULL_POINTER) {
-        bt_loop_kill(mesh, l);
-    }
-
-    // With all loops removed, the face is completely isolated and can be freed
-    mesh.face_destroy(f);
+import { assert } from "../../../../../../../assert.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_loop_kill } from "../bt_loop_kill.js";
+
+/**
+ * Safely removes a face from the topology.
+ * Iteratively untangles and frees all its loops, then releases the face memory.
+ * @param {BinaryTopology} mesh
+ * @param {number} f Face ID
+ */
+export function bt_face_kill(mesh, f) {
+    assert.isNonNegativeInteger(f, 'f');
+
+    let l = NULL_POINTER;
+
+    // TODO add a cycle limit to avoid infinite loops on bad topologies
+
+    // bt_loop_kill automatically updates the face's base loop pointer to the
+    // next loop, or to NULL_POINTER if it's the last loop in the cycle.
+    while ((l = mesh.face_read_loop(f)) !== NULL_POINTER) {
+        bt_loop_kill(mesh, l);
+    }
+
+    // With all loops removed, the face is completely isolated and can be freed
+    mesh.face_destroy(f);
 }

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

@@ -1,127 +1,127 @@
-import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
-import { assert } from "../../../../../../../assert.js";
-import { NULL_POINTER } from "../../BinaryTopology.js";
-import { bt_edge_create } from "../edge/bt_edge_create.js";
-
-const normal = new Float32Array(3);
-
-/**
- * Pokes a face by adding a vertex at the specified coordinates and fan-tessellating the face.
- * Reuses bt_edge_create to handle the complex vertex-disk linking automatically.
- *
- * Coordinates of the new vertex must be co-planar with the face.
- *
- * @param {BinaryTopology} mesh
- * @param {number} face_id
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @returns {number} vertex ID of the new center vertex, NULL_POINTER if face is degenerate or does not exist.
- */
-export function bt_face_poke(
-    mesh,
-    face_id,
-    x, y, z
-) {
-
-    assert.isNumber(x, 'x');
-    assert.isNumber(y, 'y');
-    assert.isNumber(z, 'z');
-
-    // 1. Validate and Gather Initial State
-    // We must collect the original loops/vertices first because we will be modifying the topology.
-    const loop_ids = [];
-    const first_loop_id = mesh.face_read_loop(face_id);
-
-    if (first_loop_id === NULL_POINTER) {
-        return NULL_POINTER;
-    }
-
-    let iter_loop = first_loop_id;
-    do {
-        loop_ids.push(iter_loop);
-        iter_loop = mesh.loop_read_next(iter_loop);
-    } while (iter_loop !== first_loop_id);
-
-    const count = loop_ids.length;
-
-    if (count < 3) {
-        // Degenerate face
-        return NULL_POINTER;
-    }
-
-    // 2. Create the Central Vertex
-    const v_center = mesh.vertex_create();
-    mesh.vertex_write_coordinate(v_center, [x, y, z], 0);
-    mesh.vertex_write_edge(v_center, NULL_POINTER); // Initialize with no edges
-
-    // 3. Create Spoke Edges using bt_edge_create
-    // This handles all the complexity of linking edges into the vertices' disk cycles.
-    const spoke_edges = new Uint32Array(count);
-
-    for (let i = 0; i < count; i++) {
-        const v_curr = mesh.loop_read_vertex(loop_ids[i]);
-
-        // REUSE: bt_edge_create handles the allocation and the disk-cycle linking
-        // for both v_curr and the new v_center.
-        spoke_edges[i] = bt_edge_create(mesh, v_curr, v_center);
-    }
-
-    // 4. Tessellate (Create Faces and Loops)
-    for (let i = 0; i < count; i++) {
-        const idx_curr = i;
-        const idx_next = (i + 1) % count;
-
-        const l_old = loop_ids[idx_curr];
-        const v_next = mesh.loop_read_vertex(loop_ids[idx_next]);
-
-        // Determine which face ID to use (reuse original for the first triangle)
-        let f_active;
-        if (i === 0) {
-            f_active = face_id;
-            mesh.face_write_loop(f_active, l_old);
-        } else {
-            f_active = mesh.face_create();
-            // Copy normal from original face
-            mesh.face_read_normal(normal, 0, face_id);
-            mesh.face_write_normal(f_active, normal, 0);
-            mesh.face_write_loop(f_active, l_old);
-        }
-
-        // Create the two new loops required for the triangle fan
-        const l_next_spoke = mesh.loop_create();
-        const l_center_spoke = mesh.loop_create();
-
-        // --- Configure Loop 1 (The Original Loop) ---
-        // Reuse l_old. It keeps its Vertex and Edge (outer edge).
-        // Just update Face and Links.
-        mesh.loop_write_face(l_old, f_active);
-        mesh.loop_write_next(l_old, l_next_spoke);
-        mesh.loop_write_prev(l_old, l_center_spoke);
-
-        // --- Configure Loop 2 (At V_next, pointing to V_center) ---
-        mesh.loop_write_vertex(l_next_spoke, v_next);
-        mesh.loop_write_face(l_next_spoke, f_active);
-        mesh.loop_write_next(l_next_spoke, l_center_spoke);
-        mesh.loop_write_prev(l_next_spoke, l_old);
-
-        // Link to the spoke edge (Radial Cycle)
-        bt_radial_loop_add(mesh, l_next_spoke, spoke_edges[idx_next]);
-
-        // --- Configure Loop 3 (At V_center, pointing to V_curr) ---
-        mesh.loop_write_vertex(l_center_spoke, v_center);
-        mesh.loop_write_face(l_center_spoke, f_active);
-        mesh.loop_write_next(l_center_spoke, l_old);
-        mesh.loop_write_prev(l_center_spoke, l_next_spoke);
-
-        // Link to the spoke edge (Radial Cycle)
-        bt_radial_loop_add(mesh, l_center_spoke, spoke_edges[idx_curr]);
-    }
-
-    return v_center;
-}
-
-/**
- * @deprecated Renamed to {@link bt_face_poke} (operates on a single face, not the whole mesh).
- */
-export const bt_mesh_face_poke = bt_face_poke;
+import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
+import { assert } from "../../../../../../../assert.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_edge_create } from "../edge/bt_edge_create.js";
+
+const normal = new Float32Array(3);
+
+/**
+ * Pokes a face by adding a vertex at the specified coordinates and fan-tessellating the face.
+ * Reuses bt_edge_create to handle the complex vertex-disk linking automatically.
+ *
+ * Coordinates of the new vertex must be co-planar with the face.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number} vertex ID of the new center vertex, NULL_POINTER if face is degenerate or does not exist.
+ */
+export function bt_face_poke(
+    mesh,
+    face_id,
+    x, y, z
+) {
+
+    assert.isNumber(x, 'x');
+    assert.isNumber(y, 'y');
+    assert.isNumber(z, 'z');
+
+    // 1. Validate and Gather Initial State
+    // We must collect the original loops/vertices first because we will be modifying the topology.
+    const loop_ids = [];
+    const first_loop_id = mesh.face_read_loop(face_id);
+
+    if (first_loop_id === NULL_POINTER) {
+        return NULL_POINTER;
+    }
+
+    let iter_loop = first_loop_id;
+    do {
+        loop_ids.push(iter_loop);
+        iter_loop = mesh.loop_read_next(iter_loop);
+    } while (iter_loop !== first_loop_id);
+
+    const count = loop_ids.length;
+
+    if (count < 3) {
+        // Degenerate face
+        return NULL_POINTER;
+    }
+
+    // 2. Create the Central Vertex
+    const v_center = mesh.vertex_create();
+    mesh.vertex_write_coordinate(v_center, [x, y, z], 0);
+    mesh.vertex_write_edge(v_center, NULL_POINTER); // Initialize with no edges
+
+    // 3. Create Spoke Edges using bt_edge_create
+    // This handles all the complexity of linking edges into the vertices' disk cycles.
+    const spoke_edges = new Uint32Array(count);
+
+    for (let i = 0; i < count; i++) {
+        const v_curr = mesh.loop_read_vertex(loop_ids[i]);
+
+        // REUSE: bt_edge_create handles the allocation and the disk-cycle linking
+        // for both v_curr and the new v_center.
+        spoke_edges[i] = bt_edge_create(mesh, v_curr, v_center);
+    }
+
+    // 4. Tessellate (Create Faces and Loops)
+    for (let i = 0; i < count; i++) {
+        const idx_curr = i;
+        const idx_next = (i + 1) % count;
+
+        const l_old = loop_ids[idx_curr];
+        const v_next = mesh.loop_read_vertex(loop_ids[idx_next]);
+
+        // Determine which face ID to use (reuse original for the first triangle)
+        let f_active;
+        if (i === 0) {
+            f_active = face_id;
+            mesh.face_write_loop(f_active, l_old);
+        } else {
+            f_active = mesh.face_create();
+            // Copy normal from original face
+            mesh.face_read_normal(normal, 0, face_id);
+            mesh.face_write_normal(f_active, normal, 0);
+            mesh.face_write_loop(f_active, l_old);
+        }
+
+        // Create the two new loops required for the triangle fan
+        const l_next_spoke = mesh.loop_create();
+        const l_center_spoke = mesh.loop_create();
+
+        // --- Configure Loop 1 (The Original Loop) ---
+        // Reuse l_old. It keeps its Vertex and Edge (outer edge).
+        // Just update Face and Links.
+        mesh.loop_write_face(l_old, f_active);
+        mesh.loop_write_next(l_old, l_next_spoke);
+        mesh.loop_write_prev(l_old, l_center_spoke);
+
+        // --- Configure Loop 2 (At V_next, pointing to V_center) ---
+        mesh.loop_write_vertex(l_next_spoke, v_next);
+        mesh.loop_write_face(l_next_spoke, f_active);
+        mesh.loop_write_next(l_next_spoke, l_center_spoke);
+        mesh.loop_write_prev(l_next_spoke, l_old);
+
+        // Link to the spoke edge (Radial Cycle)
+        bt_radial_loop_add(mesh, l_next_spoke, spoke_edges[idx_next]);
+
+        // --- Configure Loop 3 (At V_center, pointing to V_curr) ---
+        mesh.loop_write_vertex(l_center_spoke, v_center);
+        mesh.loop_write_face(l_center_spoke, f_active);
+        mesh.loop_write_next(l_center_spoke, l_old);
+        mesh.loop_write_prev(l_center_spoke, l_next_spoke);
+
+        // Link to the spoke edge (Radial Cycle)
+        bt_radial_loop_add(mesh, l_center_spoke, spoke_edges[idx_curr]);
+    }
+
+    return v_center;
+}
+
+/**
+ * @deprecated Renamed to {@link bt_face_poke} (operates on a single face, not the whole mesh).
+ */
+export const bt_mesh_face_poke = bt_face_poke;