@woosh/meep-engine 2.131.48 → 2.132.1

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

@@ -0,0 +1,152 @@
+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_mesh_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.vertices.allocate();
+    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.faces.allocate();
+            // 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)
+        _link_loop_to_edge_local(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)
+        _link_loop_to_edge_local(mesh, l_center_spoke, spoke_edges[idx_curr]);
+    }
+
+    return v_center;
+}
+
+/**
+ * Local helper to link a loop to an edge's radial cycle.
+ * Replicates logic from 'link_loop_to_edge' since it is not exported.
+ * @param {BinaryTopology} mesh
+ * @param {number} loop_id
+ * @param {number} edge_id
+ */
+function _link_loop_to_edge_local(mesh, loop_id, edge_id) {
+    mesh.loop_write_edge(loop_id, edge_id);
+
+    const existing_loop = mesh.edge_read_loop(edge_id);
+
+    if (existing_loop === NULL_POINTER) {
+        // First loop on this edge
+        mesh.edge_write_loop(edge_id, loop_id);
+
+        // Link to self
+        mesh.loop_write_radial_next(loop_id, loop_id);
+        mesh.loop_write_radial_prev(loop_id, loop_id);
+    } else {
+        // Insert into doubly linked list
+        const next = mesh.loop_read_radial_next(existing_loop);
+
+        mesh.loop_write_radial_next(existing_loop, loop_id);
+        mesh.loop_write_radial_prev(next, loop_id);
+
+        mesh.loop_write_radial_next(loop_id, next);
+        mesh.loop_write_radial_prev(loop_id, existing_loop);
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Triangulate a face in a binary topology mesh.
+ *
+ * Assumes that each face is a convex polygon.
+ *
+ * If the face is already a triangle, no action is taken.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face Face ID
+ * @return {boolean} True if the face was triangulated, false if it was already a triangle.
+ */
+export function bt_face_triangulate(mesh: BinaryTopology, face: number): boolean;
+//# sourceMappingURL=bt_face_triangulate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_face_triangulate.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/face/bt_face_triangulate.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,gEAHW,MAAM,GACL,OAAO,CA8GlB"}

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

@@ -0,0 +1,124 @@
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
+import { bt_edge_create } from "../edge/bt_edge_create.js";
+
+/**
+ * Triangulate a face in a binary topology mesh.
+ *
+ * Assumes that each face is a convex polygon.
+ *
+ * If the face is already a triangle, no action is taken.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face Face ID
+ * @return {boolean} True if the face was triangulated, false if it was already a triangle.
+ */
+export function bt_face_triangulate(
+    mesh,
+    face
+) {
+    // 1. Validate Face and Count Loops
+    const first_loop = mesh.face_read_loop(face);
+    if (first_loop === NULL_POINTER){
+        // should never happen, but just in case
+        return false;
+    }
+
+    let count = 0;
+    let iter = first_loop;
+    do {
+        count++;
+        iter = mesh.loop_read_next(iter);
+    } while (iter !== first_loop);
+
+    if (count < 4) {
+        // looks like a triangle
+        return false;
+    }
+
+    // 2. Prepare for Triangulation (Fan method at first vertex)
+    let l_prev = first_loop;                  // Vertex 0 (Anchor)
+    let l_curr = mesh.loop_read_next(l_prev); // Vertex 1
+    let l_next = mesh.loop_read_next(l_curr); // Vertex 2
+
+    const cuts = count - 3;
+
+    // Cache normal to apply to new faces
+    const normal = new Float32Array(3);
+    mesh.face_read_normal(normal, 0, face);
+
+    for (let i = 0; i < cuts; i++) {
+        // We cut the triangle (l_prev, l_curr, l_next) out of 'face'.
+        // New Edge connects V(l_prev) <-> V(l_next).
+
+        const v_anchor = mesh.loop_read_vertex(l_prev);
+        const v_target = mesh.loop_read_vertex(l_next);
+
+        // --- A. Create Topology Elements ---
+        // Reuse: Handles allocation and Vertex Disk Cycle linking
+        const e_new = bt_edge_create(mesh, v_anchor, v_target);
+
+        const f_new = mesh.faces.allocate();
+        const l_tri = mesh.loop_create();  // Loop at v_target (for the Triangle)
+        const l_poly = mesh.loop_create(); // Loop at v_anchor (for the Polygon)
+
+        // --- B. Setup Loops & Radial Cycles ---
+
+        // 1. Setup l_tri properties
+        mesh.loop_write_vertex(l_tri, v_target);
+        mesh.loop_write_face(l_tri, f_new);
+
+        // 2. Setup l_poly properties
+        mesh.loop_write_vertex(l_poly, v_anchor);
+        mesh.loop_write_face(l_poly, face); // Stays part of the shrinking polygon
+
+        // 3. Reuse: Link loops to the edge's Radial Cycle
+        bt_radial_loop_add(mesh, l_tri, e_new);
+        bt_radial_loop_add(mesh, l_poly, e_new);
+
+        // --- C. Re-link Face Loop Topology (Next/Prev) ---
+
+        // 1. Get the loop entering the anchor from the polygon side
+        const l_prev_prev = mesh.loop_read_prev(l_prev);
+
+        // 2. Assign l_prev and l_curr to the new Triangle Face
+        mesh.loop_write_face(l_prev, f_new);
+        mesh.loop_write_face(l_curr, f_new);
+
+        // 3. Close the New Triangle (l_prev -> l_curr -> l_tri)
+        mesh.loop_write_next(l_prev, l_curr);
+        mesh.loop_write_prev(l_prev, l_tri);
+
+        mesh.loop_write_next(l_curr, l_tri);
+        mesh.loop_write_prev(l_curr, l_prev);
+
+        mesh.loop_write_next(l_tri, l_prev);
+        mesh.loop_write_prev(l_tri, l_curr);
+
+        // Set properties for the new face
+        mesh.face_write_loop(f_new, l_prev);
+        mesh.face_write_normal(f_new, normal, 0);
+
+        // 4. Close the Remaining Polygon (l_prev_prev -> l_poly -> l_next)
+        mesh.loop_write_next(l_prev_prev, l_poly);
+        // l_prev_prev's prev pointer remains unchanged
+
+        mesh.loop_write_prev(l_poly, l_prev_prev);
+        mesh.loop_write_next(l_poly, l_next);
+
+        mesh.loop_write_prev(l_next, l_poly);
+        // l_next's next pointer remains unchanged
+
+        // Update Polygon Face pointer (ensure it points to a valid loop in the poly)
+        mesh.face_write_loop(face, l_poly);
+
+        // --- D. Advance Fan ---
+        // The polygon now starts at l_poly (at v0).
+        // The next triangle will use l_poly as its "prev", l_next as "curr".
+        l_prev = l_poly;
+        l_curr = l_next;
+        l_next = mesh.loop_read_next(l_next);
+    }
+
+    return true;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_kill_only_face.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/face/bt_kill_only_face.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,2DAFW,MAAM,QAIhB"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_kill_only_vert.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_kill_only_vert.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,2DAFW,MAAM,QAIhB"}

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

@@ -0,0 +1,10 @@
+/**
+ * Only considers distance, no other attributes are accounted for.
+ * Performs operation in-place. Note that the duplicate vertices are not removed from the mesh itself, they are still present but are not linked to anything.
+ * You typically want to perform a cleanup phase afterward to remove such unliked vertices.
+ * @param {BinaryTopology} mesh
+ * @param {number} [max_distance] Inclusive distance between vertices within which we perform the merge.
+ * @returns {number} number of removed duplicate vertices
+ */
+export function bt_merge_verts_by_distance(mesh: BinaryTopology, max_distance?: number): number;
+//# sourceMappingURL=bt_merge_verts_by_distance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_merge_verts_by_distance.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_merge_verts_by_distance.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,gFAHW,MAAM,GACJ,MAAM,CAoJlB"}

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

@@ -0,0 +1,165 @@
+import { assert } from "../../../../../../../assert.js";
+import { ceilPowerOfTwo } from "../../../../../../../binary/operations/ceilPowerOfTwo.js";
+import {
+    generate_next_linear_congruential_index
+} from "../../../../../../../collection/map/generate_next_linear_congruential_index.js";
+import { lowbias32 } from "../../../../../../../math/hash/lowbias32.js";
+import { v3_distance_sqr } from "../../../../../../vec3/v3_distance_sqr.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_vertex_replace } from "./bt_vertex_replace.js";
+
+/**
+ * Only considers distance, no other attributes are accounted for.
+ * Performs operation in-place. Note that the duplicate vertices are not removed from the mesh itself, they are still present but are not linked to anything.
+ * You typically want to perform a cleanup phase afterward to remove such unliked vertices.
+ * @param {BinaryTopology} mesh
+ * @param {number} [max_distance] Inclusive distance between vertices within which we perform the merge.
+ * @returns {number} number of removed duplicate vertices
+ */
+export function bt_merge_verts_by_distance(
+    mesh,
+    max_distance = 0.0001
+) {
+
+    assert.defined(mesh, "mesh");
+    assert.greaterThan(max_distance, 0, "max_distance must be greater than 0");
+
+    assert.defined(mesh, "mesh");
+    assert.greaterThan(max_distance, 0, "max_distance must be greater than 0");
+
+    const max_distance2 = max_distance * max_distance;
+    const grid_cell_size = max_distance + 1e-10;
+
+    /**
+     * Hashes pre-quantized integer cell coordinates
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} cz
+     * @returns {number}
+     */
+    function hash_int3(cx, cy, cz) {
+        const hx = lowbias32(cx);
+        const hy = lowbias32(cy);
+        const hz = lowbias32(cz);
+
+        return lowbias32(
+            hx
+            ^ Math.imul(hy, 73856093)
+            ^ Math.imul(hz, 19349663)
+        );
+    }
+
+    const vertices = mesh.vertices;
+    const vertex_count = vertices.size;
+
+    const grid_bin_count = ceilPowerOfTwo(Math.max(32, Math.ceil(vertex_count * 1.2)));
+    const grid_bin_mask = grid_bin_count - 1;
+
+    const vertex_grid = new Uint32Array(grid_bin_count);
+    vertex_grid.fill(NULL_POINTER);
+
+    const scratch_vertex1 = new Float32Array(3);
+
+    /**
+     * @param {number} x Original float coordinate
+     * @param {number} y Original float coordinate
+     * @param {number} z Original float coordinate
+     * @param {number} initial_bin Start index for probing
+     * @returns {number}
+     */
+    function hash_grid_get(x, y, z, initial_bin) {
+        let bin_index = initial_bin;
+
+        for (;;) {
+            const entry = vertex_grid[bin_index];
+
+            if (entry === NULL_POINTER) {
+                return NULL_POINTER;
+            }
+
+            mesh.vertex_read_coordinate(scratch_vertex1, 0, entry);
+
+            const d2 = v3_distance_sqr(
+                x, y, z,
+                scratch_vertex1[0], scratch_vertex1[1], scratch_vertex1[2],
+            );
+
+            if (d2 <= max_distance2) {
+                return entry;
+            }
+
+            bin_index = generate_next_linear_congruential_index(bin_index, grid_bin_mask);
+        }
+    }
+
+    /**
+     * @param {number} vertex
+     * @param {number} initial_bin
+     */
+    function hash_grid_set(vertex, initial_bin) {
+        let bin_index = initial_bin;
+
+        for (;;) {
+            const entry = vertex_grid[bin_index];
+
+            if (entry === NULL_POINTER) {
+                vertex_grid[bin_index] = vertex;
+                return;
+            }
+
+            bin_index = generate_next_linear_congruential_index(bin_index, grid_bin_mask);
+        }
+    }
+
+    let removed_count = 0;
+    const scratch_vertex = new Float32Array(3);
+
+    for (let vertex = 0; vertex < vertex_count; vertex++) {
+        if (vertices.is_allocated(vertex) === false) {
+            continue;
+        }
+
+        mesh.vertex_read_coordinate(scratch_vertex, 0, vertex);
+
+        const _x = scratch_vertex[0];
+        const _y = scratch_vertex[1];
+        const _z = scratch_vertex[2];
+
+        // 1. Calculate the base integer cell coordinates
+        const cx = Math.floor(_x / grid_cell_size) | 0;
+        const cy = Math.floor(_y / grid_cell_size) | 0;
+        const cz = Math.floor(_z / grid_cell_size) | 0;
+
+        const initial_bin = hash_int3(cx, cy, cz) & grid_bin_mask;
+        let master_vertex = hash_grid_get(_x, _y, _z, initial_bin);
+
+        // 2. Check NULL_POINTER instead of undefined
+        if (master_vertex === NULL_POINTER) {
+
+            // 3. Search integer neighbors
+            search_loop: for (let iz = -1; iz <= 1; iz++) {
+                for (let iy = -1; iy <= 1; iy++) {
+                    for (let ix = -1; ix <= 1; ix++) {
+                        if (iz === 0 && iy === 0 && ix === 0) continue;
+
+                        const _bin = hash_int3(cx + ix, cy + iy, cz + iz) & grid_bin_mask;
+                        master_vertex = hash_grid_get(_x, _y, _z, _bin);
+
+                        if (master_vertex !== NULL_POINTER) {
+                            break search_loop;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (master_vertex === NULL_POINTER) {
+            hash_grid_set(vertex, initial_bin);
+        } else {
+            bt_vertex_replace(mesh, vertex, master_vertex);
+            removed_count++;
+        }
+    }
+
+    return removed_count;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_vert_kill.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vert_kill.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,sDAFW,MAAM,QAWhB"}

package/src/core/geom/3d/topology/struct/binary/io/{bt_vert_kill.js → vertex/bt_vert_kill.js}

@@ -1,5 +1,6 @@
-import { NULL_POINTER } from "../BinaryTopology.js";
-import { bt_edge_kill } from "./bt_edge_kill.js";
+import { assert } from "../../../../../../../assert.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_edge_kill } from "../edge/bt_edge_kill.js";
 import { bt_kill_only_vert } from "./bt_kill_only_vert.js";
 
 
@@ -9,6 +10,8 @@ import { bt_kill_only_vert } from "./bt_kill_only_vert.js";
  * @param {number} v
  */
 export function bt_vert_kill(mesh, v) {
+    assert.isNonNegativeInteger(v, 'v');
+
     let e = NULL_POINTER;
     while ((e = mesh.vertex_read_edge(v)) !== NULL_POINTER) {
         bt_edge_kill(mesh, e);

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

@@ -0,0 +1,13 @@
+/**
+ * Patch mesh structure to make all loops/edges/faces point to this new replacement vertex instead of the victim.
+ * This effectively removes any usage of the victim from the mesh enabling us to safely remove it.
+ *
+ * Note: both victim and replacement vertices must be part of the mesh.
+ * Note: does not actually remove the victim vertex from the mesh, only links that point to it that will now point to `replacement` instead.
+ * Note: may create degenerate edges if victim and replacement are a part of the same edge originally.
+ * @param {BinaryTopology} mesh
+ * @param {number} victim
+ * @param {number} replacement
+ */
+export function bt_vertex_replace(mesh: BinaryTopology, victim: number, replacement: number): void;
+//# sourceMappingURL=bt_vertex_replace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_vertex_replace.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_replace.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,gEAHW,MAAM,eACN,MAAM,QA8GhB"}

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

@@ -0,0 +1,125 @@
+import { assert } from "../../../../../../../assert.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+
+const scratch_edges = new Uint32Array(1024);
+
+/**
+ * Patch mesh structure to make all loops/edges/faces point to this new replacement vertex instead of the victim.
+ * This effectively removes any usage of the victim from the mesh enabling us to safely remove it.
+ *
+ * Note: both victim and replacement vertices must be part of the mesh.
+ * Note: does not actually remove the victim vertex from the mesh, only links that point to it that will now point to `replacement` instead.
+ * Note: may create degenerate edges if victim and replacement are a part of the same edge originally.
+ * @param {BinaryTopology} mesh
+ * @param {number} victim
+ * @param {number} replacement
+ */
+export function bt_vertex_replace(
+    mesh,
+    victim,
+    replacement
+) {
+
+    if (victim === replacement) {
+        // special case
+        return;
+    }
+
+    // 1. Traverse and collect all edges attached to the victim vertex.
+    // We collect them into an array first because we will be mutating their disk cycles
+    // during the loop, which would break an inline traversal.
+    let edges_to_move_count = 0;
+    let curr_e = mesh.vertex_read_edge(victim);
+
+    if (curr_e !== NULL_POINTER) {
+        let start_e = curr_e;
+        do {
+
+            assert.lessThan(edges_to_move_count, scratch_edges.length, "edges_to_move_count");
+
+            scratch_edges[edges_to_move_count++] = curr_e;
+
+            // Move to the next edge in the victim's disk cycle
+            if (mesh.edge_read_vertex1(curr_e) === victim) {
+                curr_e = mesh.edge_read_v1_disk_next(curr_e);
+            } else {
+                curr_e = mesh.edge_read_v2_disk_next(curr_e);
+            }
+        } while (curr_e !== start_e && curr_e !== NULL_POINTER);
+    }
+
+    // 2. Unlink the victim vertex by clearing its edge pointer.
+    mesh.vertex_write_edge(victim, NULL_POINTER);
+
+    // 3. Process each edge: update loops, update vertices, and insert into replacement's disk cycle.
+    for (let i = 0; i < edges_to_move_count; i++) {
+        const e = scratch_edges[i];
+
+        // --- Update Loops ---
+        // Loops are corner representations; we must check the radial cycle of loops around this edge
+        let curr_l = mesh.edge_read_loop(e);
+        if (curr_l !== NULL_POINTER) {
+            let start_l = curr_l;
+            do {
+                if (mesh.loop_read_vertex(curr_l) === victim) {
+                    mesh.loop_write_vertex(curr_l, replacement);
+                }
+                curr_l = mesh.loop_read_radial_next(curr_l);
+            } while (curr_l !== start_l && curr_l !== NULL_POINTER);
+        }
+
+        // --- Update Edge Vertices ---
+        const is_v1 = mesh.edge_read_vertex1(e) === victim;
+        if (is_v1) {
+            mesh.edge_write_vertex1(e, replacement);
+        } else {
+            mesh.edge_write_vertex2(e, replacement);
+        }
+
+        // --- Insert Edge into Replacement's Disk Cycle ---
+        const base_edge = mesh.vertex_read_edge(replacement);
+
+        if (base_edge === NULL_POINTER) {
+            // This is the first edge attached to the replacement vertex
+            mesh.vertex_write_edge(replacement, e);
+            if (is_v1) {
+                mesh.edge_write_v1_disk_next(e, e);
+                mesh.edge_write_v1_disk_prev(e, e);
+            } else {
+                mesh.edge_write_v2_disk_next(e, e);
+                mesh.edge_write_v2_disk_prev(e, e);
+            }
+        } else {
+            // Splice this edge into the existing disk cycle before base_edge
+            const base_is_v1 = mesh.edge_read_vertex1(base_edge) === replacement;
+            const base_prev = base_is_v1
+                ? mesh.edge_read_v1_disk_prev(base_edge)
+                : mesh.edge_read_v2_disk_prev(base_edge);
+
+            const prev_is_v1 = mesh.edge_read_vertex1(base_prev) === replacement;
+
+            // 1. Link base_prev -> e
+            if (prev_is_v1) {
+                mesh.edge_write_v1_disk_next(base_prev, e);
+            } else {
+                mesh.edge_write_v2_disk_next(base_prev, e);
+            }
+
+            // 2. Link e -> base_prev & e -> base_edge
+            if (is_v1) {
+                mesh.edge_write_v1_disk_prev(e, base_prev);
+                mesh.edge_write_v1_disk_next(e, base_edge);
+            } else {
+                mesh.edge_write_v2_disk_prev(e, base_prev);
+                mesh.edge_write_v2_disk_next(e, base_edge);
+            }
+
+            // 3. Link base_edge -> e
+            if (base_is_v1) {
+                mesh.edge_write_v1_disk_prev(base_edge, e);
+            } else {
+                mesh.edge_write_v2_disk_prev(base_edge, e);
+            }
+        }
+    }
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_has_vertex.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @param {number} vertex_id
+ * @returns {boolean}
+ */
+export function bt_edge_has_vertex(mesh: BinaryTopology, edge_id: number, vertex_id: number): boolean;
+//# sourceMappingURL=bt_edge_has_vertex.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_has_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_edge_has_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_has_vertex.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,kEAJW,MAAM,aACN,MAAM,GACJ,OAAO,CAUnB"}

package/src/core/geom/3d/topology/struct/binary/query/{bt_mesh_edge_has_vertex.js → bt_edge_has_vertex.js}

@@ -5,7 +5,7 @@
  * @param {number} vertex_id
  * @returns {boolean}
  */
-export function bt_mesh_edge_has_vertex(mesh, edge_id, vertex_id) {
+export function bt_edge_has_vertex(mesh, edge_id, vertex_id) {
     const v1 = mesh.edge_read_vertex1(edge_id);
 
     if (v1 === vertex_id) {