@woosh/meep-engine 3.1.0 → 3.3.0

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

@@ -1,92 +1,92 @@
-import { assert } from "../../../../../../../assert.js";
-import { NULL_POINTER } from "../../BinaryTopology.js";
-import { bt_edge_kill } from "./bt_edge_kill.js";
-
-/**
- * Kill every edge that shares both endpoints with `keep_edge`, leaving `keep_edge`
- * itself alive.
- *
- * Useful as a pre-pass before {@link bt_edge_collapse}: without it, each direct
- * parallel survives {@link bt_vertex_replace} as a degenerate self-loop on the
- * survivor (the disk cycle stays valid -- see the convention in
- * BinaryTopology.js __edge_pool -- but the parallel's face is left allocated and
- * geometrically degenerate). Running this pre-pass kills both the parallel and
- * its face up front, keeping the post-collapse mesh clean and letting callers
- * that track face counts decrement accurately without a rescan.
- *
- * @param {BinaryTopology} mesh
- * @param {number} keep_edge Edge ID to preserve; its other-parallels are killed.
- * @returns {number} Number of faces killed as a side effect.
- */
-export function bt_edge_kill_parallels(mesh, keep_edge) {
-    assert.defined(mesh, 'mesh');
-    assert.notNull(mesh, 'mesh');
-    assert.isNonNegativeInteger(keep_edge, 'keep_edge');
-
-    const a = mesh.edge_read_vertex1(keep_edge);
-    const b = mesh.edge_read_vertex2(keep_edge);
-
-    const start_e = mesh.vertex_read_edge(b);
-
-    if (start_e === NULL_POINTER) {
-        return 0;
-    }
-
-    // Collect parallels while walking b's disk cycle. We snapshot into an array
-    // so that subsequent bt_edge_kill calls (which mutate the disk cycle) can't
-    // invalidate the traversal.
-    const victims = [];
-    let curr_e = start_e;
-
-    do {
-        let next_e;
-        if (mesh.edge_read_vertex1(curr_e) === b) {
-            next_e = mesh.edge_read_v1_disk_next(curr_e);
-        } else {
-            next_e = mesh.edge_read_v2_disk_next(curr_e);
-        }
-
-        if (curr_e !== keep_edge) {
-            const v1 = mesh.edge_read_vertex1(curr_e);
-            const v2 = mesh.edge_read_vertex2(curr_e);
-
-            if ((v1 === a && v2 === b) || (v1 === b && v2 === a)) {
-                victims.push(curr_e);
-            }
-        }
-
-        curr_e = next_e;
-    } while (curr_e !== start_e && curr_e !== NULL_POINTER);
-
-    const edge_pool = mesh.edges;
-    const face_pool = mesh.faces;
-
-    let faces_killed = 0;
-
-    for (let i = 0; i < victims.length; i++) {
-        const e = victims[i];
-
-        if (!edge_pool.is_allocated(e)) {
-            continue;
-        }
-
-        // Count still-allocated faces in this edge's radial loop cycle before
-        // bt_edge_kill drops them. Orphan loops (face already dead) are skipped.
-        const l0 = mesh.edge_read_loop(e);
-
-        if (l0 !== NULL_POINTER) {
-            let l = l0;
-            do {
-                const f = mesh.loop_read_face(l);
-                if (f !== NULL_POINTER && face_pool.is_allocated(f)) {
-                    faces_killed++;
-                }
-                l = mesh.loop_read_radial_next(l);
-            } while (l !== l0 && l !== NULL_POINTER);
-        }
-
-        bt_edge_kill(mesh, e);
-    }
-
-    return faces_killed;
-}
+import { assert } from "../../../../../../../assert.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_edge_kill } from "./bt_edge_kill.js";
+
+/**
+ * Kill every edge that shares both endpoints with `keep_edge`, leaving `keep_edge`
+ * itself alive.
+ *
+ * Useful as a pre-pass before {@link bt_edge_collapse}: without it, each direct
+ * parallel survives {@link bt_vertex_replace} as a degenerate self-loop on the
+ * survivor (the disk cycle stays valid -- see the convention in
+ * BinaryTopology.js __edge_pool -- but the parallel's face is left allocated and
+ * geometrically degenerate). Running this pre-pass kills both the parallel and
+ * its face up front, keeping the post-collapse mesh clean and letting callers
+ * that track face counts decrement accurately without a rescan.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} keep_edge Edge ID to preserve; its other-parallels are killed.
+ * @returns {number} Number of faces killed as a side effect.
+ */
+export function bt_edge_kill_parallels(mesh, keep_edge) {
+    assert.defined(mesh, 'mesh');
+    assert.notNull(mesh, 'mesh');
+    assert.isNonNegativeInteger(keep_edge, 'keep_edge');
+
+    const a = mesh.edge_read_vertex1(keep_edge);
+    const b = mesh.edge_read_vertex2(keep_edge);
+
+    const start_e = mesh.vertex_read_edge(b);
+
+    if (start_e === NULL_POINTER) {
+        return 0;
+    }
+
+    // Collect parallels while walking b's disk cycle. We snapshot into an array
+    // so that subsequent bt_edge_kill calls (which mutate the disk cycle) can't
+    // invalidate the traversal.
+    const victims = [];
+    let curr_e = start_e;
+
+    do {
+        let next_e;
+        if (mesh.edge_read_vertex1(curr_e) === b) {
+            next_e = mesh.edge_read_v1_disk_next(curr_e);
+        } else {
+            next_e = mesh.edge_read_v2_disk_next(curr_e);
+        }
+
+        if (curr_e !== keep_edge) {
+            const v1 = mesh.edge_read_vertex1(curr_e);
+            const v2 = mesh.edge_read_vertex2(curr_e);
+
+            if ((v1 === a && v2 === b) || (v1 === b && v2 === a)) {
+                victims.push(curr_e);
+            }
+        }
+
+        curr_e = next_e;
+    } while (curr_e !== start_e && curr_e !== NULL_POINTER);
+
+    const edge_pool = mesh.edges;
+    const face_pool = mesh.faces;
+
+    let faces_killed = 0;
+
+    for (let i = 0; i < victims.length; i++) {
+        const e = victims[i];
+
+        if (!edge_pool.is_allocated(e)) {
+            continue;
+        }
+
+        // Count still-allocated faces in this edge's radial loop cycle before
+        // bt_edge_kill drops them. Orphan loops (face already dead) are skipped.
+        const l0 = mesh.edge_read_loop(e);
+
+        if (l0 !== NULL_POINTER) {
+            let l = l0;
+            do {
+                const f = mesh.loop_read_face(l);
+                if (f !== NULL_POINTER && face_pool.is_allocated(f)) {
+                    faces_killed++;
+                }
+                l = mesh.loop_read_radial_next(l);
+            } while (l !== l0 && l !== NULL_POINTER);
+        }
+
+        bt_edge_kill(mesh, e);
+    }
+
+    return faces_killed;
+}

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

@@ -1,180 +1,180 @@
-import { assert } from "../../../../../../../assert.js";
-import { NULL_POINTER } from "../../BinaryTopology.js";
-import { bt_disk_edge_add } from "../bt_disk_edge_add.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_edge_create } from "./bt_edge_create.js";
-
-
-const f_normal = new Float32Array(3);
-
-const c1 = new Float32Array(3);
-const c2 = new Float32Array(3);
-
-const n1 = new Float32Array(3);
-const n2 = new Float32Array(3);
-
-const c_new = new Float32Array(3);
-const n_new = new Float32Array(3);
-
-/**
- * Splits an edge at parameter t and triangulates adjacent faces.
- *
- * NOTE: Assumes that the input mesh is triangulated.
- * NOTE: Does not check for created self-intersections or degenerate edges/faces. Make sure that if you pass t <= 0 or t >= 1 - you understand the implications.
- *
- * @param {BinaryTopology} mesh
- * @param {number} edge_id The edge to split
- * @param {number} t Interpolation parameter (0.0 to 1.0)
- * @returns {number} The newly created vertex ID
- */
-export function bt_edge_split(
-    mesh,
-    edge_id,
-    t
-) {
-    assert.isNonNegativeInteger(edge_id, 'edge_id');
-    assert.isNumber(t, 't');
-    assert.greaterThanOrEqual(t, 0, 't');
-    assert.lessThanOrEqual(t, 1, 't');
-
-    assert.defined(mesh, 'mesh');
-    assert.notNull(mesh, 'mesh');
-
-    const v1 = mesh.edge_read_vertex1(edge_id);
-    const v2 = mesh.edge_read_vertex2(edge_id);
-
-    // ----------------------------------------------------------------
-    // 1. Interpolate and Create New Vertex
-    // ----------------------------------------------------------------
-
-    mesh.vertex_read_coordinate(c1, 0, v1);
-    mesh.vertex_read_coordinate(c2, 0, v2);
-
-    c_new[0] = c1[0] + (c2[0] - c1[0]) * t;
-    c_new[1] = c1[1] + (c2[1] - c1[1]) * t;
-    c_new[2] = c1[2] + (c2[2] - c1[2]) * t;
-
-    mesh.vertex_read_normal(n1, 0, v1);
-    mesh.vertex_read_normal(n2, 0, v2);
-
-    n_new[0] = n1[0] + (n2[0] - n1[0]) * t;
-    n_new[1] = n1[1] + (n2[1] - n1[1]) * t;
-    n_new[2] = n1[2] + (n2[2] - n1[2]) * t;
-
-    const len = Math.sqrt(n_new[0] ** 2 + n_new[1] ** 2 + n_new[2] ** 2);
-    if (len > 0) {
-        n_new[0] /= len;
-        n_new[1] /= len;
-        n_new[2] /= len;
-    }
-
-    const v_new = mesh.vertex_create();
-    mesh.vertex_write_coordinate(v_new, c_new, 0);
-    mesh.vertex_write_normal(v_new, n_new, 0);
-    mesh.vertex_write_edge(v_new, NULL_POINTER); // Initialize disk cycle
-
-    // ----------------------------------------------------------------
-    // 2. Gather Connected Faces (Radial Cycle)
-    // ----------------------------------------------------------------
-    const loops_to_split = [];
-    let curr_loop = mesh.edge_read_loop(edge_id);
-    if (curr_loop !== NULL_POINTER) {
-        let start_loop = curr_loop;
-        do {
-            loops_to_split.push(curr_loop);
-            curr_loop = mesh.loop_read_radial_next(curr_loop);
-        } while (curr_loop !== start_loop && curr_loop !== NULL_POINTER);
-    }
-
-    // ----------------------------------------------------------------
-    // 3. Split the Edge Topologically
-    // ----------------------------------------------------------------
-    // Shrink original edge to (v1, v_new)
-    bt_disk_edge_remove(mesh, edge_id, v2);
-    mesh.edge_write_vertex2(edge_id, v_new);
-    bt_disk_edge_add(mesh, edge_id, v_new);
-
-    // Create new edge for (v_new, v2)
-    // Note: bt_edge_create handles the disk cycle attachments for us!
-    const e_new = bt_edge_create(mesh, v_new, v2);
-
-    // ----------------------------------------------------------------
-    // 4. Split Adjacent Faces
-    // ----------------------------------------------------------------
-
-
-    for (let i = 0; i < loops_to_split.length; i++) {
-        const l_start = loops_to_split[i];
-        const l_end = mesh.loop_read_next(l_start);
-        const l_opp = mesh.loop_read_next(l_end);
-
-        const v_start = mesh.loop_read_vertex(l_start);
-        const v_end = mesh.loop_read_vertex(l_end);
-        const v_opp = mesh.loop_read_vertex(l_opp);
-
-        const f = mesh.loop_read_face(l_start);
-        mesh.face_read_normal(f_normal, 0, f);
-
-        const e_end_opp = mesh.loop_read_edge(l_end);
-
-        // Determine which physical edge corresponds to this loop's direction
-        const is_start_v1 = (v_start === v1);
-        const edge_start_new = is_start_v1 ? edge_id : e_new;
-        const edge_new_end = is_start_v1 ? e_new : edge_id;
-
-        // Create the cross edge dividing the triangle
-        const e_cross = bt_edge_create(mesh, v_new, v_opp);
-
-        // --- FACE 1: Re-use existing face (v_start, v_new, v_opp) ---
-
-        // Update l_start (ensure it points to the correct half of the split edge)
-        if (mesh.loop_read_edge(l_start) !== edge_start_new) {
-            bt_radial_loop_remove(mesh, l_start, mesh.loop_read_edge(l_start));
-            bt_radial_loop_add(mesh, l_start, edge_start_new);
-        }
-
-        // Update l_end (now acts as the loop for v_new -> v_opp)
-        bt_radial_loop_remove(mesh, l_end, e_end_opp);
-        mesh.loop_write_vertex(l_end, v_new);
-        bt_radial_loop_add(mesh, l_end, e_cross);
-
-        // l_opp remains unchanged (v_opp -> v_start)
-
-        // --- FACE 2: Create new face (v_new, v_end, v_opp) ---
-        const f2 = mesh.face_create();
-        mesh.face_write_normal(f2, f_normal, 0);
-
-        const nl1 = mesh.loop_create();
-        const nl2 = mesh.loop_create();
-        const nl3 = mesh.loop_create();
-
-        // nl1: v_new -> v_end
-        mesh.loop_write_vertex(nl1, v_new);
-        mesh.loop_write_face(nl1, f2);
-        bt_radial_loop_add(mesh, nl1, edge_new_end);
-
-        // nl2: v_end -> v_opp
-        mesh.loop_write_vertex(nl2, v_end);
-        mesh.loop_write_face(nl2, f2);
-        bt_radial_loop_add(mesh, nl2, e_end_opp);
-
-        // nl3: v_opp -> v_new
-        mesh.loop_write_vertex(nl3, v_opp);
-        mesh.loop_write_face(nl3, f2);
-        bt_radial_loop_add(mesh, nl3, e_cross);
-
-        // Wire up loops for f2
-        mesh.loop_write_next(nl1, nl2);
-        mesh.loop_write_prev(nl1, nl3);
-        mesh.loop_write_next(nl2, nl3);
-        mesh.loop_write_prev(nl2, nl1);
-        mesh.loop_write_next(nl3, nl1);
-        mesh.loop_write_prev(nl3, nl2);
-
-        mesh.face_write_loop(f2, nl1);
-    }
-
-    return v_new;
+import { assert } from "../../../../../../../assert.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_disk_edge_add } from "../bt_disk_edge_add.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_edge_create } from "./bt_edge_create.js";
+
+
+const f_normal = new Float32Array(3);
+
+const c1 = new Float32Array(3);
+const c2 = new Float32Array(3);
+
+const n1 = new Float32Array(3);
+const n2 = new Float32Array(3);
+
+const c_new = new Float32Array(3);
+const n_new = new Float32Array(3);
+
+/**
+ * Splits an edge at parameter t and triangulates adjacent faces.
+ *
+ * NOTE: Assumes that the input mesh is triangulated.
+ * NOTE: Does not check for created self-intersections or degenerate edges/faces. Make sure that if you pass t <= 0 or t >= 1 - you understand the implications.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id The edge to split
+ * @param {number} t Interpolation parameter (0.0 to 1.0)
+ * @returns {number} The newly created vertex ID
+ */
+export function bt_edge_split(
+    mesh,
+    edge_id,
+    t
+) {
+    assert.isNonNegativeInteger(edge_id, 'edge_id');
+    assert.isNumber(t, 't');
+    assert.greaterThanOrEqual(t, 0, 't');
+    assert.lessThanOrEqual(t, 1, 't');
+
+    assert.defined(mesh, 'mesh');
+    assert.notNull(mesh, 'mesh');
+
+    const v1 = mesh.edge_read_vertex1(edge_id);
+    const v2 = mesh.edge_read_vertex2(edge_id);
+
+    // ----------------------------------------------------------------
+    // 1. Interpolate and Create New Vertex
+    // ----------------------------------------------------------------
+
+    mesh.vertex_read_coordinate(c1, 0, v1);
+    mesh.vertex_read_coordinate(c2, 0, v2);
+
+    c_new[0] = c1[0] + (c2[0] - c1[0]) * t;
+    c_new[1] = c1[1] + (c2[1] - c1[1]) * t;
+    c_new[2] = c1[2] + (c2[2] - c1[2]) * t;
+
+    mesh.vertex_read_normal(n1, 0, v1);
+    mesh.vertex_read_normal(n2, 0, v2);
+
+    n_new[0] = n1[0] + (n2[0] - n1[0]) * t;
+    n_new[1] = n1[1] + (n2[1] - n1[1]) * t;
+    n_new[2] = n1[2] + (n2[2] - n1[2]) * t;
+
+    const len = Math.sqrt(n_new[0] ** 2 + n_new[1] ** 2 + n_new[2] ** 2);
+    if (len > 0) {
+        n_new[0] /= len;
+        n_new[1] /= len;
+        n_new[2] /= len;
+    }
+
+    const v_new = mesh.vertex_create();
+    mesh.vertex_write_coordinate(v_new, c_new, 0);
+    mesh.vertex_write_normal(v_new, n_new, 0);
+    mesh.vertex_write_edge(v_new, NULL_POINTER); // Initialize disk cycle
+
+    // ----------------------------------------------------------------
+    // 2. Gather Connected Faces (Radial Cycle)
+    // ----------------------------------------------------------------
+    const loops_to_split = [];
+    let curr_loop = mesh.edge_read_loop(edge_id);
+    if (curr_loop !== NULL_POINTER) {
+        let start_loop = curr_loop;
+        do {
+            loops_to_split.push(curr_loop);
+            curr_loop = mesh.loop_read_radial_next(curr_loop);
+        } while (curr_loop !== start_loop && curr_loop !== NULL_POINTER);
+    }
+
+    // ----------------------------------------------------------------
+    // 3. Split the Edge Topologically
+    // ----------------------------------------------------------------
+    // Shrink original edge to (v1, v_new)
+    bt_disk_edge_remove(mesh, edge_id, v2);
+    mesh.edge_write_vertex2(edge_id, v_new);
+    bt_disk_edge_add(mesh, edge_id, v_new);
+
+    // Create new edge for (v_new, v2)
+    // Note: bt_edge_create handles the disk cycle attachments for us!
+    const e_new = bt_edge_create(mesh, v_new, v2);
+
+    // ----------------------------------------------------------------
+    // 4. Split Adjacent Faces
+    // ----------------------------------------------------------------
+
+
+    for (let i = 0; i < loops_to_split.length; i++) {
+        const l_start = loops_to_split[i];
+        const l_end = mesh.loop_read_next(l_start);
+        const l_opp = mesh.loop_read_next(l_end);
+
+        const v_start = mesh.loop_read_vertex(l_start);
+        const v_end = mesh.loop_read_vertex(l_end);
+        const v_opp = mesh.loop_read_vertex(l_opp);
+
+        const f = mesh.loop_read_face(l_start);
+        mesh.face_read_normal(f_normal, 0, f);
+
+        const e_end_opp = mesh.loop_read_edge(l_end);
+
+        // Determine which physical edge corresponds to this loop's direction
+        const is_start_v1 = (v_start === v1);
+        const edge_start_new = is_start_v1 ? edge_id : e_new;
+        const edge_new_end = is_start_v1 ? e_new : edge_id;
+
+        // Create the cross edge dividing the triangle
+        const e_cross = bt_edge_create(mesh, v_new, v_opp);
+
+        // --- FACE 1: Re-use existing face (v_start, v_new, v_opp) ---
+
+        // Update l_start (ensure it points to the correct half of the split edge)
+        if (mesh.loop_read_edge(l_start) !== edge_start_new) {
+            bt_radial_loop_remove(mesh, l_start, mesh.loop_read_edge(l_start));
+            bt_radial_loop_add(mesh, l_start, edge_start_new);
+        }
+
+        // Update l_end (now acts as the loop for v_new -> v_opp)
+        bt_radial_loop_remove(mesh, l_end, e_end_opp);
+        mesh.loop_write_vertex(l_end, v_new);
+        bt_radial_loop_add(mesh, l_end, e_cross);
+
+        // l_opp remains unchanged (v_opp -> v_start)
+
+        // --- FACE 2: Create new face (v_new, v_end, v_opp) ---
+        const f2 = mesh.face_create();
+        mesh.face_write_normal(f2, f_normal, 0);
+
+        const nl1 = mesh.loop_create();
+        const nl2 = mesh.loop_create();
+        const nl3 = mesh.loop_create();
+
+        // nl1: v_new -> v_end
+        mesh.loop_write_vertex(nl1, v_new);
+        mesh.loop_write_face(nl1, f2);
+        bt_radial_loop_add(mesh, nl1, edge_new_end);
+
+        // nl2: v_end -> v_opp
+        mesh.loop_write_vertex(nl2, v_end);
+        mesh.loop_write_face(nl2, f2);
+        bt_radial_loop_add(mesh, nl2, e_end_opp);
+
+        // nl3: v_opp -> v_new
+        mesh.loop_write_vertex(nl3, v_opp);
+        mesh.loop_write_face(nl3, f2);
+        bt_radial_loop_add(mesh, nl3, e_cross);
+
+        // Wire up loops for f2
+        mesh.loop_write_next(nl1, nl2);
+        mesh.loop_write_prev(nl1, nl3);
+        mesh.loop_write_next(nl2, nl3);
+        mesh.loop_write_prev(nl2, nl1);
+        mesh.loop_write_next(nl3, nl1);
+        mesh.loop_write_prev(nl3, nl2);
+
+        mesh.face_write_loop(f2, nl1);
+    }
+
+    return v_new;
 }

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

@@ -1,28 +1,28 @@
-/**
- * Swap the v1/v2 slots of an edge. Disk cycle pointers for the two slots are swapped
- * alongside so that the disk cycles on both attached vertices remain valid.
- *
- * Useful before a half-edge collapse (e.g. {@link bt_edge_collapse}, which keeps v1 as
- * the survivor) when the caller needs a specific endpoint to survive: swap first so the
- * desired survivor sits in the v1 slot.
- *
- * @param {BinaryTopology} mesh
- * @param {number} edge_id
- */
-export function bt_edge_swap_vertex_slots(mesh, edge_id) {
-    const v1 = mesh.edge_read_vertex1(edge_id);
-    const v2 = mesh.edge_read_vertex2(edge_id);
-
-    const v1_next = mesh.edge_read_v1_disk_next(edge_id);
-    const v1_prev = mesh.edge_read_v1_disk_prev(edge_id);
-    const v2_next = mesh.edge_read_v2_disk_next(edge_id);
-    const v2_prev = mesh.edge_read_v2_disk_prev(edge_id);
-
-    mesh.edge_write_vertex1(edge_id, v2);
-    mesh.edge_write_vertex2(edge_id, v1);
-
-    mesh.edge_write_v1_disk_next(edge_id, v2_next);
-    mesh.edge_write_v1_disk_prev(edge_id, v2_prev);
-    mesh.edge_write_v2_disk_next(edge_id, v1_next);
-    mesh.edge_write_v2_disk_prev(edge_id, v1_prev);
-}
+/**
+ * Swap the v1/v2 slots of an edge. Disk cycle pointers for the two slots are swapped
+ * alongside so that the disk cycles on both attached vertices remain valid.
+ *
+ * Useful before a half-edge collapse (e.g. {@link bt_edge_collapse}, which keeps v1 as
+ * the survivor) when the caller needs a specific endpoint to survive: swap first so the
+ * desired survivor sits in the v1 slot.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ */
+export function bt_edge_swap_vertex_slots(mesh, edge_id) {
+    const v1 = mesh.edge_read_vertex1(edge_id);
+    const v2 = mesh.edge_read_vertex2(edge_id);
+
+    const v1_next = mesh.edge_read_v1_disk_next(edge_id);
+    const v1_prev = mesh.edge_read_v1_disk_prev(edge_id);
+    const v2_next = mesh.edge_read_v2_disk_next(edge_id);
+    const v2_prev = mesh.edge_read_v2_disk_prev(edge_id);
+
+    mesh.edge_write_vertex1(edge_id, v2);
+    mesh.edge_write_vertex2(edge_id, v1);
+
+    mesh.edge_write_v1_disk_next(edge_id, v2_next);
+    mesh.edge_write_v1_disk_prev(edge_id, v2_prev);
+    mesh.edge_write_v2_disk_next(edge_id, v1_next);
+    mesh.edge_write_v2_disk_prev(edge_id, v1_prev);
+}

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

@@ -1,9 +1,9 @@
-/**
- * low level function, only frees the edge,
- * doesn't change or adjust surrounding geometry
- * @param {BinaryTopology} mesh
- * @param {number} e
- */
-export function bt_kill_only_edge(mesh, e) {
-    mesh.edge_destroy(e);
+/**
+ * low level function, only frees the edge,
+ * doesn't change or adjust surrounding geometry
+ * @param {BinaryTopology} mesh
+ * @param {number} e
+ */
+export function bt_kill_only_edge(mesh, e) {
+    mesh.edge_destroy(e);
 }